MeshNode.h

#pragma once
 
// Standard.
#include <atomic>
 
// Custom.
#include "game/nodes/SpatialNode.h"
#include "math/GLMath.hpp"
#include "render/general/resources/GpuResource.h"
#include "shader/general/resources/ShaderResource.h"
#include "shader/general/resources/cpuwrite/ShaderCpuWriteResourceUniquePtr.h"
#include "shader/general/resources/texture/ShaderTextureResourceUniquePtr.h"
#include "shader/VulkanAlignmentConstants.hpp"
#include "misc/shapes/AABB.h"
#include "material/Material.h"
 
#include "MeshNode.generated.h"
 
namespace ne RNAMESPACE() {
    class UploadBuffer;
 
    struct MeshVertex { // not using inheritance to avoid extra fields that are not related to vertex
        MeshVertex() = default;
        ~MeshVertex() = default;
 
        MeshVertex(const MeshVertex&) = default;
 
        MeshVertex& operator=(const MeshVertex&) = default;
 
        MeshVertex(MeshVertex&&) noexcept = default;
 
        MeshVertex& operator=(MeshVertex&&) noexcept = default;
 
        bool operator==(const MeshVertex& other) const;
 
        // --------------------------------------------------------------------------------------
 
        glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f);
 
        glm::vec3 normal = glm::vec3(0.0f, 0.0f, 0.0f);
 
        glm::vec2 uv = glm::vec2(0.0f, 0.0f);
 
        // --------------------------------------------------------------------------------------
 
        // ! only vertex related fields (same as in shader) can be added here !
        // (not deriving from `Serializable` to avoid extra fields that are not related to vertex)
 
        // --------------------------------------------------------------------------------------
    };
 
    class RCLASS(Guid("b60e4b47-b1e6-4001-87a8-b7885b4e8383")) MeshData : public Serializable {
    public:
        using meshindex_t = unsigned int; // if making this dynamic (changes depending on the number of
                                          // indices) change hardcoded FORMAT in the renderer
 
        MeshData();
        virtual ~MeshData() override = default;
 
        MeshData(const MeshData&) = default;
 
        MeshData& operator=(const MeshData&) = default;
 
        MeshData(MeshData&&) noexcept = default;
 
        MeshData& operator=(MeshData&&) noexcept = default;
 
        std::vector<MeshVertex>* getVertices();
 
        std::vector<std::vector<meshindex_t>>* getIndices();
 
    private:
        RPROPERTY(Serialize)
        std::vector<MeshVertex> vVertices;
 
        RPROPERTY(Serialize)
        std::vector<std::vector<meshindex_t>> vIndices;
 
        ne_MeshData_GENERATED
    };
 
    class RCLASS(Guid("d5407ca4-3c2e-4a5a-9ff3-1262b6a4d264")) MeshNode : public SpatialNode {
        // Material notifies us when it changes its pipeline.
        friend class Material;
 
    public:
        struct MeshShaderConstants {
            MeshShaderConstants() = default;
 
            alignas(iVkMat4Alignment) glm::mat4x4 worldMatrix = glm::identity<glm::mat4x4>();
 
            alignas(iVkMat4Alignment) glm::mat4x4 normalMatrix = glm::identity<glm::mat4x4>();
        };
 
        struct GpuResources {
            GpuResources() = default;
 
            struct Mesh {
                Mesh() = default;
 
                std::unique_ptr<GpuResource> pVertexBuffer;
 
                std::vector<std::unique_ptr<GpuResource>> vIndexBuffers;
            };
 
            struct ShaderResources {
                ShaderResources() = default;
 
                std::unordered_map<std::string, ShaderCpuWriteResourceUniquePtr> shaderCpuWriteResources;
 
                std::unordered_map<std::string, ShaderTextureResourceUniquePtr> shaderTextureResources;
            };
 
            Mesh mesh;
 
            ShaderResources shaderResources;
        };
 
        static inline const char* getMeshShaderConstantBufferName() { return sMeshShaderConstantBufferName; }
 
        MeshNode();
 
        MeshNode(const std::string& sNodeName);
 
        virtual ~MeshNode() override = default;
 
        void setMaterial(std::unique_ptr<Material> pMaterial, size_t iMaterialSlot = 0);
 
        void setMeshData(const MeshData& meshData);
 
        void setMeshData(MeshData&& meshData);
 
        void onMeshDataChanged();
 
        void setIsVisible(bool bVisible);
 
        Material* getMaterial(size_t iMaterialSlot = 0);
 
        size_t getAvailableMaterialSlotCount();
 
        inline std::pair<std::recursive_mutex*, MeshData*> getMeshData() {
            return std::make_pair(&mtxMeshData, &meshData);
        }
 
        inline std::pair<std::recursive_mutex, GpuResources>* getMeshGpuResources() {
            return &mtxGpuResources;
        }
 
        inline std::pair<std::recursive_mutex, MeshShaderConstants>* getMeshShaderConstants() {
            return &mtxShaderMeshDataConstants;
        }
 
        inline AABB* getAABB() { return &aabb; }
 
        bool isVisible() const;
 
    protected:
        virtual void onAfterDeserialized() override;
 
        virtual void onSpawning() override;
 
        virtual void onDespawning() override;
 
        virtual void onWorldLocationRotationScaleChanged() override;
 
        void setShaderCpuWriteResourceBindingData(
            const std::string& sShaderResourceName,
            size_t iResourceSizeInBytes,
            const std::function<void*()>& onStartedUpdatingResource,
            const std::function<void()>& onFinishedUpdatingResource);
 
        void setShaderTextureResourceBindingData(
            const std::string& sShaderResourceName, const std::string& sPathToTextureResourceRelativeRes);
 
        void markShaderCpuWriteResourceToBeCopiedToGpu(const std::string& sShaderResourceName);
 
    private:
        static std::unique_ptr<Material> getDefaultMaterial();
 
        void allocateShaderResources();
 
        void allocateGeometryBuffers();
 
        void deallocateShaderResources();
 
        void deallocateGeometryBuffers();
 
        void* onStartedUpdatingShaderMeshConstants();
 
        void onFinishedUpdatingShaderMeshConstants();
 
        void updateShaderResourcesToUseChangedMaterialPipelines();
 
        std::pair<GpuResource*, unsigned int> getIndexBufferInfoForMaterialSlot(size_t iMaterialSlot);
 
        RPROPERTY(Serialize)
        std::vector<std::unique_ptr<Material>> vMaterials;
 
        RPROPERTY(Serialize(FST_AS_EXTERNAL_BINARY_FILE)) // allow VCSs to treat this file in a special way
        MeshData meshData;
 
        AABB aabb;
 
        std::recursive_mutex mtxMeshData;
 
        std::pair<std::recursive_mutex, GpuResources> mtxGpuResources;
 
        std::pair<std::recursive_mutex, MeshShaderConstants> mtxShaderMeshDataConstants;
 
        bool bIsVisible = true;
 
        static inline const auto sMeshShaderConstantBufferName = "meshData";
 
        ne_MeshNode_GENERATED
    };
} // namespace ne RNAMESPACE()
 
File_MeshNode_GENERATED