Material.h

#pragma once
 
// Standard.
#include <string>
#include <unordered_map>
 
// Custom.
#include "render/general/pipeline/PipelineManager.h"
#include "io/Serializable.h"
#include "shader/general/ShaderMacro.h"
#include "math/GLMath.hpp"
#include "shader/general/resources/cpuwrite/ShaderCpuWriteResourceUniquePtr.h"
#include "shader/general/resources/texture/ShaderTextureResourceUniquePtr.h"
#include "shader/VulkanAlignmentConstants.hpp"
#include "material/TextureManager.h"
 
#include "Material.generated.h"
 
namespace ne RNAMESPACE() {
    class MeshNode;
    class GpuResource;
 
    struct MeshIndexBufferInfo {
        MeshIndexBufferInfo() = default;
 
        MeshIndexBufferInfo(GpuResource* pIndexBuffer, unsigned int iIndexCount) {
            this->pIndexBuffer = pIndexBuffer;
            this->iIndexCount = iIndexCount;
        }
 
        GpuResource* pIndexBuffer = nullptr;
 
        unsigned int iIndexCount = 0;
    };
 
    struct MeshNodesThatUseThisMaterial {
        size_t getTotalSize() const { return visibleMeshNodes.size() + invisibleMeshNodes.size(); }
 
        bool isMeshNodeAdded(MeshNode* pMeshNode) {
            auto it = visibleMeshNodes.find(pMeshNode);
            if (it != visibleMeshNodes.end()) {
                return true;
            }
 
            it = invisibleMeshNodes.find(pMeshNode);
            if (it != invisibleMeshNodes.end()) {
                return true;
            }
 
            return false;
        }
 
        std::unordered_map<MeshNode*, std::vector<MeshIndexBufferInfo>> visibleMeshNodes;
 
        std::unordered_map<MeshNode*, std::vector<MeshIndexBufferInfo>> invisibleMeshNodes;
    };
 
    class RCLASS(Guid("a603fa3a-e9c2-4c38-bb4c-76384ef001f4")) Material : public Serializable {
        // Mesh node will notify the material when it's spawned/despawned.
        friend class MeshNode;
 
    public:
        struct GpuResources {
            GpuResources() = default;
 
            struct ShaderResources {
                ShaderResources() = default;
 
                std::unordered_map<std::string, ShaderCpuWriteResourceUniquePtr> shaderCpuWriteResources;
 
                std::unordered_map<std::string, ShaderTextureResourceUniquePtr> shaderTextureResources;
            };
 
            ShaderResources shaderResources;
        };
 
        Material();
 
        Material(const Material&) = delete;
        Material& operator=(const Material&) = delete;
 
        virtual ~Material() override;
 
        static size_t getCurrentAliveMaterialCount();
 
        static std::variant<std::unique_ptr<Material>, Error> create(
            const std::string& sVertexShaderName,
            const std::string& sPixelShaderName,
            bool bUseTransparency,
            const std::string& sMaterialName = "Material");
 
        void setEnableTransparency(bool bEnable);
 
        void setDiffuseColor(const glm::vec3& diffuseColor);
 
        void setDiffuseTexture(const std::string& sTextureResourcePathRelativeRes);
 
        void setSpecularColor(const glm::vec3& specularColor);
 
        void setRoughness(float roughness);
 
        void setOpacity(float opacity = 1.0F);
 
        bool isTransparencyEnabled();
 
        glm::vec3 getDiffuseColor() const;
 
        glm::vec3 getSpecularColor() const;
 
        std::string getPathToDiffuseTextureResource();
 
        float getRoughness() const;
 
        float getOpacity() const;
 
        std::pair<std::mutex, MeshNodesThatUseThisMaterial>* getSpawnedMeshNodesThatUseThisMaterial();
 
        std::string getMaterialName() const;
 
        bool isUsingTransparency() const;
 
        Pipeline* getColorPipeline() const;
 
        Pipeline* getDepthOnlyPipeline() const;
 
        Pipeline* getShadowMappingDirectionalSpotPipeline() const;
 
        Pipeline* getShadowMappingPointPipeline() const;
 
        inline std::pair<std::recursive_mutex, GpuResources>* getMaterialGpuResources() {
            return &mtxGpuResources;
        }
 
        std::string getVertexShaderName() const;
 
        std::string getPixelShaderName() const;
 
    protected:
        virtual void onAfterDeserialized() override;
 
    private:
        struct InternalResources {
            InternalResources() = default;
 
            PipelineSharedPtr pColorPipeline;
 
            PipelineSharedPtr pDepthOnlyPipeline;
 
            PipelineSharedPtr pShadowMappingDirectionalSpotPipeline;
 
            PipelineSharedPtr pShadowMappingPointPipeline;
        };
 
        struct MaterialShaderConstants {
            MaterialShaderConstants() = default;
 
            alignas(iVkVec4Alignment) glm::vec4 diffuseColor = glm::vec4(1.0F, 1.0F, 1.0F, 1.0F);
 
            alignas(iVkVec4Alignment) glm::vec4 specularColor = glm::vec4(1.0F, 1.0F, 1.0F, 1.0F);
 
            alignas(iVkScalarAlignment) float roughness = 0.0F;
        };
 
        static std::variant<PipelineManager*, Error> getPipelineManagerForNewMaterial(
            const std::string& sVertexShaderName, const std::string& sPixelShaderName);
 
        Material(
            const std::string& sVertexShaderName,
            const std::string& sPixelShaderName,
            bool bUseTransparency,
            PipelineManager* pPipelineManager,
            const std::string& sMaterialName = "Material");
 
        void onMeshNodeSpawning(
            MeshNode* pMeshNode, const std::pair<GpuResource*, unsigned int>& indexBufferToDisplay);
 
        void onSpawnedMeshNodeStartedUsingMaterial(
            MeshNode* pMeshNode, const std::pair<GpuResource*, unsigned int>& indexBufferToDisplay);
 
        void onSpawnedMeshNodeRecreatedIndexBuffer(
            MeshNode* pMeshNode,
            const std::pair<GpuResource*, unsigned int>& deletedIndexBuffer,
            const std::pair<GpuResource*, unsigned int>& newIndexBuffer);
 
        void onSpawnedMeshNodeChangedVisibility(MeshNode* pMeshNode, bool bOldVisibility);
 
        void onSpawnedMeshNodeStoppedUsingMaterial(
            MeshNode* pMeshNode, const std::pair<GpuResource*, unsigned int>& indexBufferDisplayed);
 
        void onMeshNodeDespawning(
            MeshNode* pMeshNode, const std::pair<GpuResource*, unsigned int>& indexBufferDisplayed);
 
        [[nodiscard]] std::optional<Error> initializePipelines();
 
        void resetPipelines();
 
        void allocateShaderResources();
 
        void deallocateShaderResources();
 
        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 markShaderCpuWriteResourceAsNeedsUpdate(const std::string& sShaderResourceName);
 
        void updateToNewPipeline();
 
        void* onStartUpdatingShaderMeshConstants();
 
        void onFinishedUpdatingShaderMeshConstants();
 
        std::set<ShaderMacro> getVertexShaderMacrosForCurrentState();
 
        std::set<ShaderMacro> getPixelShaderMacrosForCurrentState();
 
        std::pair<std::mutex, MeshNodesThatUseThisMaterial> mtxSpawnedMeshNodesThatUseThisMaterial;
 
        std::pair<std::recursive_mutex, InternalResources> mtxInternalResources;
 
        std::pair<std::recursive_mutex, GpuResources> mtxGpuResources;
 
        std::pair<std::recursive_mutex, MaterialShaderConstants> mtxShaderMaterialDataConstants;
 
        PipelineManager* pPipelineManager = nullptr;
 
        RPROPERTY(Serialize)
        std::string sVertexShaderName;
 
        RPROPERTY(Serialize)
        std::string sPixelShaderName;
 
        RPROPERTY(Serialize)
        std::string sMaterialName;
 
        RPROPERTY(Serialize)
        std::string sDiffuseTexturePathRelativeRes;
 
        RPROPERTY(Serialize)
        glm::vec3 diffuseColor = glm::vec3(1.0F, 1.0F, 1.0F);
 
        RPROPERTY(Serialize)
        glm::vec3 specularColor = glm::vec3(1.0F, 1.0F, 1.0F);
 
        RPROPERTY(Serialize)
        float roughness = 0.7F;
 
        RPROPERTY(Serialize)
        float opacity = 0.6F;
 
        RPROPERTY(Serialize)
        bool bUseTransparency = false;
 
        bool bIsShaderResourcesAllocated = false;
 
        static inline const auto sMaterialShaderConstantBufferName = "materialData";
 
        static inline const auto sMaterialShaderDiffuseTextureName = "diffuseTexture";
 
        ne_Material_GENERATED
    };
} // namespace ne RNAMESPACE()
 
File_Material_GENERATED