EcsData.h

Go to the documentation of this file.

#pragma once
#include "Engine/Entity/Entity.h"
#include "Engine/Files/AssetPath.h"
#include "Engine/Mesh/Vertex.h"
#include "Engine/Renderer/RenderData.h"
#include "Engine/Texture/ExrLoader.h"
#include "entt/entt.hpp"
#include "meshoptimizer.h"
#include "tiny_gltf.h"
 
#include <filesystem>
#include <future>
#include <glm/glm.hpp>
#include <optional>
#include <string>
#include <vector>
 
class btCollisionShape;
class btRigidBody;
 
namespace EngineCore {
    class MeshAsset;
    class MeshComponent;
    enum PipelineNames : int;
    class MaterialData;
    class SceneNode;
}  // namespace EngineCore

namespace Ecs {
 
    struct AssetLoadingImage {
        std::filesystem::path path;
        std::future<tinygltf::Image> future;
    };

    struct Parent
    {
        entt::entity parent;
    };

    struct AssetRequested
    {
    };
 
    struct StaticMeshData
    {
        Asset::Path asset;
        EngineCore::MeshAsset * assetData;
 
    };
 
    struct StaticMeshes
    {
        std::vector<StaticMeshData> meshData;
    };
 
    struct ExrHeaderData
    {
        EngineCore::ExrHeader header;
    };
 
    struct ExrHeaderFuture {
        std::filesystem::path path;
        std::future<EngineCore::ExrHeader> future;
    };
 
    struct GltfModelFuture {
        std::filesystem::path path;
        std::future<tinygltf::Model> future;
    };
 
    struct MaterialLoadingData {
        Asset::Path path;
        EngineCore::PipelineNames type;
        EngineCore::MaterialData* data;
    };
 
    struct ImageData {
        tinygltf::Image image;
    };
 
    struct Model {
        tinygltf::Model model;
    };

    struct SimulatesPhysics
    {
        btRigidBody* rigidBody;
        btCollisionShape* collisionShape;
 
        bool isKinematic = false;
        bool isStatic = false;
    };

    struct TransformDirty
    {
    };

    struct TransformDirtyRenderer
    {
    };

    struct SceneNodeRef {
        std::weak_ptr<EngineCore::SceneNode> node;
    };

    struct MeshComponentRef {
        EngineCore::MeshComponent* component = nullptr;
    };

    struct Tick
    {
        EngineCore::ITickable* tickable;
    };

    struct MeshIndex
    {
        uint32_t index;
    };
    struct Mesh
    {
        tinygltf::Mesh mesh;
    };
 
    struct ModelNode
    {
        tinygltf::Node node;
    };
 
    struct PrimitiveData
    {
        std::vector<Vertex> vertices;
        std::vector<uint32_t> indices;
    };

    using Meshlet = meshopt_Meshlet;
 
    struct MeshletData {
        std::vector<meshopt_Meshlet> meshlets;
        std::vector<uint32_t> meshletVertices;
        std::vector<uint8_t> meshletTriangles;
    };
 
    struct PrimitiveDataLoading {
        Asset::Path path;
        std::vector<PrimitiveData> data;
        std::vector<Asset::Path> materialPaths;  
    };

    struct BoundingSphere {
        glm::vec3 center = { 0.0f, 0.0f, 0.0f };
        float radius = 0.0f;
    };

    struct PackedTriangle {
        uint32_t packed;  

        static PackedTriangle pack(uint8_t i0, uint8_t i1, uint8_t i2) {
            return { static_cast<uint32_t>(i0) |
                    (static_cast<uint32_t>(i1) << 8) |
                    (static_cast<uint32_t>(i2) << 16) };
        }
    };
 
    // Backwards compatibility alias
    using UnpackedTriangle = PackedTriangle;

    struct UnpackedMeshletData {
        std::vector<Vertex> vertices;           
        std::vector<PackedTriangle> triangles;  
    };

    struct LodHierarchyResult {
        std::vector<EngineCore::ClusterLodData> clusters;
        std::vector<EngineCore::ClusterGroupData> groups;

        MeshletData meshletData;

        UnpackedMeshletData unpackedData;
 
        size_t baseLevelClusterCount = 0;  
        size_t lodLevelCount = 0;          
    };

    struct PrimitiveMeshletResult {
        MeshletData meshletData;
        PrimitiveData optimizedData;  
        BoundingSphere boundingSphere;
        UnpackedMeshletData unpackedData; 
        std::optional<LodHierarchyResult> lodHierarchy; 
    };

    struct CompletedMeshletGeneration {
        Asset::Path meshPath;
        entt::entity meshEntity;
        std::vector<PrimitiveMeshletResult> primitiveResults;
        BoundingSphere meshBoundingSphere;
    };
 
    struct MeshPrimitive {
        std::optional<PrimitiveData> data = std::nullopt;
        std::optional<MeshletData> meshletData = std::nullopt;
        std::optional<UnpackedMeshletData> unpackedData = std::nullopt; 
        std::optional<LodHierarchyResult> lodHierarchy = std::nullopt; 
        Ecs::BoundingSphere boundingSphere;
        Asset::Path materialPath;  
    };
 
    struct MeshPrimitiveData
    {
        std::vector<Ecs::MeshPrimitive> primitives;
        Ecs::BoundingSphere boundingSphere;
    };
 
    struct MaterialDiffuseFlatColor
    {
        glm::vec4 color;
    };
 
    struct MaterialNormals
    {
        bool debugMode;
    };
 
    struct ModelFuture {
        std::future<tinygltf::Model> future;
    };
 
    struct LocalTransform {
        glm::mat4 matrix;
    };
 
    struct WorldTransform {
        glm::mat4 matrix;
    };
 
    struct TransformDepth {
        uint32_t depth;
    };

    struct ActiveCamera { };

    struct CameraProperties {
        float fov = 60.0f;          
        float nearPlane = 0.01f;
        float farPlane = 1000.0f;
        float aspectRatio = 16.0f / 9.0f;
    };
 
 
    // ============================================================================
    // Asset Loading Pipeline Components
    // ============================================================================

    struct PrimitiveMetaData {
        uint32_t uvCount = 0;
        int materialIndex = -1;
    };

    struct RawMeshData {
        std::vector<Vertex> vertices;
        std::vector<uint32_t> indices;
    };

    enum class AssetLoadingStage : uint8_t {
        Pending = 0,
        MetadataExtracted = 1,
        MaterialLoaded = 2,
        GeometryValidated = 3,
        GeometryExtracted = 4,
        VerticesAssembled = 5,
        Complete = 6,
        Failed = 7
    };

    struct AssetLoadingStatus {
        AssetLoadingStage stage = AssetLoadingStage::Pending;
        std::string lastError;
    };
 
    // Forward declaration for pipeline
    namespace AssetPipeline {
        struct RawGeometryData;
    }

    struct PipelineGeometryData {
        // Store as void* to avoid forward declaration issues
        // Will be cast to AssetPipeline::RawGeometryData* when used
        void* rawGeometryData = nullptr;
    };
}