MeshPrimitive.h

Go to the documentation of this file.

#pragma once
#include "Engine/Entity/Actor.h"
#include "Engine/Renderer/RenderData.h"
#include "GltfLoader.h"
#include "Vertex.h"
 
#include <meshoptimizer.h>
 
namespace EngineCore
{
    struct MeshletBounds;
    class Texture;
class Mesh;
class Renderer;
class ApplicationContext;
class Material;
struct MaterialShader;
}
namespace EngineCore {
    class MeshPrimitive{
        friend Mesh;
    public:
        MeshPrimitive() = default;
        MeshPrimitive(GltfLoader::GltfMeshPrimitiveData meshPrimitiveData, ApplicationContext* context, Renderer* renderer);
        ~MeshPrimitive();
 
        [[nodiscard]] std::vector<Vertex> getVertices() const;
        [[nodiscard]] const std::vector<Vertex>& getVerticesByRef() const;
        [[nodiscard]] std::vector<uint32_t> getIndices() const;
        [[nodiscard]] const std::vector<uint32_t>& getIndicesByRef() const;
 
        [[nodiscard]] uint32_t getTextureIndex() const;
 
        [[nodiscard]] std::vector<meshopt_Meshlet> getMeshlets() const;
        [[nodiscard]] const std::vector<meshopt_Meshlet>& getMeshletByRef() const;
        [[nodiscard]] std::vector<uint8_t> getMeshletTriangles() const;
        [[nodiscard]] const std::vector<uint8_t>& getMeshletTrianglesByRef() const;
        [[nodiscard]] std::vector<uint32_t> getMeshletVertices() const;
        [[nodiscard]] const std::vector<uint32_t>& getMeshletVerticesByRef() const;
 
        [[nodiscard]] uint32_t getMeshletTriangleCount() const;
        [[nodiscard]] uint32_t getMeshletVertexCount() const;
        [[nodiscard]] uint32_t getMeshletsCount() const;
        [[nodiscard]] float getBoundingSphereRadius() const;
        [[nodiscard]] glm::vec3 getBoundingSphereCenter() const;
        [[nodiscard]] ObjectCullingData getCullingData() const;
        [[nodiscard]] bool hasCustomTexture() const;
 
        [[nodiscard]] PipelineNames getMaterialName() const;
        [[nodiscard]] MaterialShader* getMaterialShader() const;
        void setMaterialShader(MaterialShader* shader);
 
        void setMaterialId(uint32_t materialId);
 
        const ObjectCullingData& getPrimitiveBoundsByRef() const;
        const std::vector<MeshletBounds> &getMeshletBoundsByRef() const;
 
    private:
 
        void generateMeshlets();
        void generateBoundingSpheres();
 
        struct MeshletBoundsHelper {
            MeshletBoundsHelper(glm::vec3 init) : minX(init), maxX(init), minY(init), maxY(init), minZ(init), maxZ(init) {};
            void enlarge(glm::vec3 point);
            MeshletBounds getBounds(const std::vector<meshopt_Meshlet> &meshlets, const std::vector<Vertex> &vertices, const std::vector<uint32_t> &meshletVertices) const;
            glm::vec3 minX, maxX, minY, maxY, minZ, maxZ;
        };
 
    public:
        std::vector<meshopt_Meshlet> meshlets{};
        std::vector<MeshletBounds> meshletBounds{};
    private:
 
        PipelineNames materialName;
        MaterialShader* materialShader = nullptr;
        uint32_t materialId = 0;
        std::variant<
                NormalMaterialData,
                DiffuseFlatColorMaterialData,
                DiffuseShaderMaterialData,
                MovableDiffuseShaderMaterialData,
                L0ShaderMaterialData,
                L1ShaderMaterialData,
                L2ShaderMaterialData,
                DynamicTexturesMaterialData,
                StaticLightmapMaterialData
            > materialData;
 
    public:
        [[nodiscard]] const std::variant<NormalMaterialData, DiffuseFlatColorMaterialData, DiffuseShaderMaterialData,
        MovableDiffuseShaderMaterialData, L0ShaderMaterialData, L1ShaderMaterialData, L2ShaderMaterialData,
        DynamicTexturesMaterialData, StaticLightmapMaterialData>& getMaterialData() const {
            return materialData;
        }
 
    private:
        std::vector<uint32_t> meshletVertices{};
        std::vector<uint8_t> meshletTriangles{};
 
        ObjectCullingData objectCullingData{.worldPositionAndRadius = {0.0f, 0.0f, 0.0f, 0.0f}, .objectIndex = 0};
 
        ApplicationContext* context = nullptr;
        Renderer* renderer = nullptr;
 
        uint32_t textureIndex = 0;
        Texture* colorTexture = nullptr;
 
        std::vector<Vertex> vertices;
        std::vector<uint32_t> indices;
    };
}