EcsData.h

Go to the documentation of this file.

#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::Skin* skin = nullptr;          
    };

    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::Skin* skin = nullptr;  
    };
 
    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::Mesh* assetData = nullptr;
        Engine::Assets::Skin* skin = nullptr;
    };

    struct AnimationState {
        Engine::Assets::Animation * currentAnimation = nullptr;
        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;
    };
}