MeshNode.h

#pragma once
 
// Standard.
#include <atomic>
 
// Custom.
#include "game/node/SpatialNode.h"
#include "math/GLMath.hpp"
#include "render/general/resource/GpuResource.h"
#include "shader/general/resource/binding/ShaderResourceBinding.h"
#include "shader/general/resource/binding/cpuwrite/ShaderCpuWriteResourceBindingUniquePtr.h"
#include "shader/general/resource/binding/texture/ShaderTextureResourceBindingUniquePtr.h"
#include "shader/VulkanAlignmentConstants.hpp"
#include "misc/shapes/AABB.h"
#include "material/Material.h"
#include "render/general/resource/MeshData.h"
 
#include "MeshNode.generated.h"
 
namespace ne RNAMESPACE() {
    class UploadBuffer;
 
    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, ShaderCpuWriteResourceBindingUniquePtr>
                    shaderCpuWriteResourceBindings;
 
                std::unordered_map<std::string, ShaderTextureResourceBindingUniquePtr> 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 setShaderCpuWriteResourceBinding(
            const std::string& sShaderResourceName,
            size_t iResourceSizeInBytes,
            const std::function<void*()>& onStartedUpdatingResource,
            const std::function<void()>& onFinishedUpdatingResource);
 
        void setShaderTextureResourceBinding(
            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
    };
}
 
File_MeshNode_GENERATED