MeshComponent.h

#pragma once
 
#include "Engine/Component/LogicComponent.h"
#include "Engine/Asset/AssetRegistry.h"
#include "Engine/Asset/AssetHandles.h"
#include "Engine/Core/Asset.h"
#include "Engine/Ecs/EcsData.h"
#include "Engine/Material/MaterialTypes.h"
#include "Engine/Mesh/MeshAssetRef.h"
 
#include <string>
#include <string_view>
#include <vector>
 
#ifdef ENABLE_TRACY
#include <tracy/Tracy.hpp>
#endif
 
namespace Engine::Assets
{
    class Mesh;
}  // namespace Engine::Assets
 
namespace Engine::Entities
{
    class SceneNode;
}  // namespace Engine::Entities
 
namespace Engine::Core
{
    class Engine;
    class SceneNode;
    class Mesh;
    class RenderingDataManager;
}  // namespace EngineCore
 
namespace Engine::Components
{
    class Collision;
    class MaterialShader;

    class Mesh : public Logic
    {
    public:
        static constexpr const char* ComponentName = "Mesh";  
 
    private:
        std::string name    = "game object";
        bool        visible = true;
 
    public:
        Mesh(
            Entities::Scene *                    owningScene,
            entt::entity &                       actor,
            Asset::MeshPath                      asset,
            std::shared_ptr<Entities::SceneNode> sceneNode,
            bool                                 isVisible_ = true,
            const std::string &                  name_      = "game object"
        );

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

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

        Mesh(
            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"
        );

        Mesh(
            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"
        );

        Mesh(
            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"
        );

        ~Mesh() override = default;
 
        void beginPlay() override;
        void endPlay() override;

        bool drawImGui() override;

        [[nodiscard]] bool isVisible() const;

        void setVisible( bool isVisible );

        [[nodiscard]] Assets::MeshAssetRef getMeshAsset() const;

        [[nodiscard]] glm::mat4 getWorldTransform() const;
        [[nodiscard]] glm::mat4 getLocalTransform() const;

        [[nodiscard]] std::optional<Core::AnchorPoint> anchorPoint( std::string_view name ) const;

        [[nodiscard]] std::vector<std::string> anchorPointNames() const;

        [[nodiscard]] Rendering::PipelineNames getMaterialNames() const;

        void setMaterialOverride(Assets::MaterialHandle material);

        void clearMaterialOverride();

        [[nodiscard]] std::optional<Assets::MaterialHandle> getMaterialOverride() const;

        [[nodiscard]] std::string getAssetName() const;

        void attachCollisionChild(Collision * collision);

        void attachCollisionChildren(const std::vector<Collision *> & collisions);

        void detachCollisionChild(const Collision * collision);

        [[nodiscard]] const std::vector<Collision *> & getCollisionChildren() const;

        [[nodiscard]] bool ownsCollisionChild(const Logic * component) const;

        virtual void onMeshAssetResolved(Assets::MeshAssetRef meshAsset);
 
    protected:
        [[nodiscard]] std::shared_ptr<Entities::SceneNode> getSceneNode() const;

        [[nodiscard]] Ecs::StaticMeshData * getStaticMeshData() const;
 
        entt::entity componentEntity = entt::null;  
        std::optional<std::shared_ptr<Entities::SceneNode>> sceneNode;  
 
    private:
        void initializeMeshData(
            Entities::Scene * owningScene,
            entt::entity & actor,
            Asset::MeshPath asset,
            std::optional<Assets::GltfRenderableHandle> renderable,
            Assets::GeometryMeshHandle mesh
        );
 
        Core::RenderingDataManager * renderingDataManager_ = nullptr;
        std::vector<Collision *> collisionChildren_;
        std::optional<Assets::MaterialHandle> materialOverride_;
    };
}  // namespace EngineCore