EcsData.h

#pragma once
#include "Engine/Asset/AssetHandles.h"
#include "Engine/Files/AssetPath.h"
#include "Engine/Mesh/MeshAssetRef.h"
#include "Engine/Mesh/Vertex.h"
#include "Engine/Renderer/RenderData.h"
#include "Engine/Texture/ExrLoader.h"
#include "Engine/Texture/Ktx2Loader.h"
#include "Engine/Core/Tick.h"
#include "entt/entt.hpp"
#include "meshoptimizer.h"
#include "tiny_gltf.h"
 
#include <filesystem>
#include <future>
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
class btCollisionShape;
class btRigidBody;
 
namespace Engine::Components
{
    class Mesh;
}  // namespace Engine::Components
 
namespace Engine::Entities
{
    class SceneNode;
}  // namespace Engine::Entities
 
namespace Engine::Core
{
    struct MaterialData;
}  // namespace Engine::Core
 
namespace Engine::Rendering
{
    enum PipelineNames : int;
}  // namespace Engine::Rendering
 
namespace Engine::Assets
{
    class Animation;
    class Skin;
    class Mesh;
}  // namespace Engine::Assets
 
namespace glm
{
    typedef vec3 eulr;  
}

namespace Engine::Ecs {

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

    struct Parent
    {
        entt::entity parent;  
    };

    struct AssetRequested
    {
    };

    struct StaticMeshData
    {
        std::optional<Engine::Assets::GltfRenderableHandle> renderable;
 
        Engine::Assets::GeometryMeshHandle mesh;  
        Asset::MeshPath asset;  

        Engine::Assets::MeshAssetRef assetRef;
 
        Engine::Components::Mesh * owner = nullptr;  
 
    };

    struct StaticMeshes
    {
        std::vector<StaticMeshData> meshData;  
    };

    struct ExrHeaderData
    {
        Engine::Assets::Textures::ExrHeader header;  
    };

    struct ExrHeaderFuture {
        std::filesystem::path path;  

        std::future<Engine::Assets::Textures::ExrHeader> future;
    };

    struct Ktx2LoadFuture {
        std::filesystem::path path;  
        std::future<Engine::Assets::Textures::Ktx2TextureData> future;  
    };

    struct GltfModelFuture {
        std::filesystem::path path;  
        std::future<tinygltf::Model> future;  
    };

    struct MaterialLoadingData {
        Asset::MeshPath path;  
        Engine::Rendering::PipelineNames type;  
        Engine::Core::MaterialData * data;  
    };

    struct ImageData {
        tinygltf::Image image;  
    };

    struct Model {
        tinygltf::Model model;  
    };

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

    struct TransformDirty
    {
    };

    struct TransformDirtyRenderer
    {
    };

    struct RendererDirtyList
    {
        static void push(entt::entity entity)
        {
            entities.push_back(entity);
        }

        static std::vector<entt::entity>& get()
        {
            return entities;
        }

        static void clear()
        {
            entities.clear();
        }

        static void reserveAdditional(size_t additionalEntities)
        {
            entities.reserve(entities.size() + additionalEntities);
        }

        static bool empty()
        {
            return entities.empty();
        }
 
    private:
        inline static std::vector<entt::entity> entities;
    };

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

    struct MeshComponentRef {
        std::vector<Engine::Components::Mesh*> components;  
    };

    struct Tick
    {
        Engine::Core::ITickable* tickable = nullptr;  
        int32_t priority = 0;  
    };

    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;  
        std::vector<BoneVertexData> boneVertexData;  
    };

    using Meshlet = meshopt_Meshlet;

    struct MeshletData {
        std::vector<meshopt_Meshlet> meshlets;  
        std::vector<uint32_t> meshletVertices;  
        std::vector<uint8_t> meshletTriangles;  
    };

    struct PrimitiveDataLoading {
        Asset::MeshPath path;  
        std::vector<PrimitiveData> data;  
        std::vector<Asset::MeshPath> materialPaths;  
        Engine::Assets::SkinHandle skin = Engine::Assets::Null;  
    };

    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<Engine::Rendering::ClusterLodData> clusters;  
        std::vector<Engine::Rendering::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::MeshPath meshPath;  
        entt::entity meshEntity;  
        std::vector<PrimitiveMeshletResult> primitiveResults;  
        BoundingSphere meshBoundingSphere;  
        Engine::Assets::SkinHandle skin = Engine::Assets::Null;  
    };

    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;  
        Engine::Assets::MaterialHandle material;  
        Asset::MeshPath 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 Transform {
        Transform() = default;

        explicit Transform(glm::mat4 matrix);

        explicit Transform(glm::vec3 position);

        explicit Transform(glm::quat rotation);

        explicit Transform(glm::vec3 position, glm::quat rotation);

        explicit Transform(glm::vec3 position, glm::eulr rotation, glm::vec3 scale);
 
        glm::mat4 matrix = glm::mat4(1.0f);  

        [[nodiscard]] glm::vec3 getPosition() const;

        [[nodiscard]] glm::quat getRotation() const;

        [[nodiscard]] glm::vec3 getRotationEuler() const;

        [[nodiscard]] glm::vec3 getScale() const;

        void setPosition(const glm::vec3& newPosition);

        void setRotation(const glm::vec3& newRotation);

        void setRotation(const glm::quat& newQuaternion);

        void setScale(const glm::vec3& newScale);

        void setFacing(const glm::vec3& newFacing);
    };

    struct WorldTransform {
        glm::mat4 matrix = glm::mat4(1.0f);  
    };

    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;  
    };

    struct LightData {};

    struct DirectionalLightData
    {
        glm::vec3 color{1.0f};  
        float intensity = 1.0f;  
        float angularDiameterDegrees = 0.53f;  
        uint32_t enabled = 1u;  
        uint32_t castsShadows = 1u;  
        uint32_t hasDirectionOverride = 0u;  
        glm::vec3 direction{0.0f, -1.0f, 0.0f};  
        entt::entity sceneNodeEntity = entt::null;  
    };

    struct PointLightData
    {
        glm::vec3 color{1.0f};  
        float intensity = 1.0f;  
        float radius = 10.0f;  
        float cullDistance = 100.0f;  
        uint32_t enabled = 1u;  
        entt::entity sceneNodeEntity = entt::null;  
    };
 
 
    // ============================================================================
    // 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,  
        METADATA_EXTRACTED = 1,  
        MATERIAL_LOADED = 2,  
        GEOMETRY_VALIDATED = 3,  
        GEOMETRY_EXTRACTED = 4,  
        VERTICES_ASSEMBLED = 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;  
    };
 
    // ============================================================================
    // Skeletal Mesh Components
    // ============================================================================

    struct SkeletalMeshData {
        Asset::MeshPath asset;  
        Engine::Assets::SkinHandle skin = Engine::Assets::Null;  
    };

    struct AnimationState {
        Engine::Assets::AnimationClipHandle currentAnimation = Engine::Assets::Null;  
        float playbackTime = 0.0f;  
        float playbackSpeed = 1.0f;  
        bool isLooping = true;  
        bool isPlaying = false;  
    };

    struct BoneTransformsDirty {};

    struct ComputedBoneTransforms {
        std::vector<glm::mat4> boneMatrices;  
        uint32_t gpuBoneMatrixOffset = 0;  
    };

    struct VRTrackingInput {
        struct DevicePose {
            glm::vec3 position = glm::vec3(0.0f);  
            glm::quat orientation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f);  
        };
        DevicePose hmd;  
        DevicePose leftHand;  
        DevicePose rightHand;  
        double timestamp = 0.0;  
    };
}