CollidableMeshComponent.h

#pragma once
 
#include "Engine/Component/MeshComponent.h"
#include "Engine/Mesh/GltfLoader.h"
 
#include <optional>
 
namespace Engine::Components
{
    class CollidableMesh : public Mesh
    {
    public:
        static constexpr const char* ComponentName = "CollidableMesh"; 

        CollidableMesh(
            Entities::Scene * owningScene,
            entt::entity & actor,
            Asset::MeshPath asset,
            std::shared_ptr<Entities::SceneNode> sceneNode,
            bool isVisible_ = true,
            const std::string & name_ = "game object"
        );

        CollidableMesh(
            Entities::Scene * owningScene,
            entt::entity & actor,
            Assets::GltfRenderableHandle renderable,
            std::shared_ptr<Entities::SceneNode> sceneNode,
            bool isVisible_ = true,
            const std::string & name_ = "game object"
        );

        CollidableMesh(
            Entities::Scene * owningScene,
            entt::entity & actor,
            Assets::GeometryMeshHandle mesh,
            std::shared_ptr<Entities::SceneNode> sceneNode,
            bool isVisible_ = true,
            const std::string & name_ = "game object"
        );

        CollidableMesh(
            Entities::Scene * owningScene,
            entt::entity & actor,
            Asset::MeshPath asset,
            std::shared_ptr<Entities::SceneNode> sceneNode,
            Core::RenderingDataManager * renderingDataManager,
            bool isVisible_ = true,
            const std::string & name_ = "game object"
        );

        CollidableMesh(
            Entities::Scene * owningScene,
            entt::entity & actor,
            Assets::GltfRenderableHandle renderable,
            std::shared_ptr<Entities::SceneNode> sceneNode,
            Core::RenderingDataManager * renderingDataManager,
            bool isVisible_ = true,
            const std::string & name_ = "game object"
        );

        CollidableMesh(
            Entities::Scene * owningScene,
            entt::entity & actor,
            Assets::GeometryMeshHandle mesh,
            std::shared_ptr<Entities::SceneNode> sceneNode,
            Core::RenderingDataManager * renderingDataManager,
            bool isVisible_ = true,
            const std::string & name_ = "game object"
        );

        void endPlay() override;

        void enableCollision(bool enabled);

        [[nodiscard]] bool isCollisionEnabled() const;

        void setCollisionProperties(
            const Assets::Loaders::GltfLoader::VulkanSchneeExtension::CollisionProperties & properties
        );

        void markCollisionPropertiesResolved();

        void clearCollisionProperties();

        void setCollisionStatic(bool isStatic);

        void onMeshAssetResolved(Assets::MeshAssetRef meshAsset) override;
 
    private:
        using CollisionProperties = Assets::Loaders::GltfLoader::VulkanSchneeExtension::CollisionProperties;

        void rebuildOwnedCollision();

        void loadCollisionPropertiesFromAsset();

        bool createCollisionFromProperties();

        bool createFallbackBoxCollision();

        void ensurePhysicsBody();

        void removeOwnedCollision();
 
        std::optional<CollisionProperties> collisionProperties_;
        std::vector<Collision *> ownedCollisionChildren_;
        bool collisionRequested_ = false;
        bool collisionPropertiesResolved_ = false;
        bool collisionStatic_ = false;
    };
}  // namespace Engine::Components