MeshComponent.h

Go to the documentation of this file.

#pragma once
 
#include "Engine/Component/LogicComponent.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 <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;

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

        [[nodiscard]] glm::mat4 getWorldTransform() const;
        [[nodiscard]] glm::mat4 getLocalTransform() 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;
 
        Ecs::StaticMeshData* staticMeshData = nullptr;
 
    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