RendererMaterial.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
#include "CeresEngine/RenderAPI/Forward.hpp"
#include "Resources/Forward.hpp"
 
#include "RendererMaterialSettings.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Container/Map.hpp"
 
#include "CeresEngine/Material/Material.hpp"
#include "CeresEngine/Material/MaterialModel.hpp"
#include "CeresEngine/RenderAPI/GPUBufferObject.hpp"
#include "CeresEngine/RenderAPI/GPUResourceSet.hpp"
#include "CeresEngine/RenderAPI/GPUSampler.hpp"
 
namespace CeresEngine {
 
    class RendererMaterialManager;
 
    class RendererMaterial {
    protected:
        RendererMaterialManager& mManager;
 
        Renderer& mRenderer;
 
        UInt32 mID = ~0u;
 
        bool mDirty = true;
 
    public:
        explicit RendererMaterial(RendererMaterialManager& manager);
 
        virtual ~RendererMaterial() = default;
 
    public:
        virtual void prepare(RendererContext& context) = 0;
 
        virtual void fillResourceSetDescriptor(GPUShaderResourceSetBindings& bindings) const = 0;
 
    public:
        [[nodiscard]] virtual const GPUShaderProgramPtr& getShaderProgram() const = 0;
 
        [[nodiscard]] virtual const GPUUniformBuffer& getUniformBuffer() const = 0;
 
        [[nodiscard]] virtual const GPUResourceSetPtr& getResourceSet() const = 0;
 
        [[nodiscard]] virtual GPUResourceSetDescriptor getResourceSetDescriptor() const = 0;
 
    public:
        [[nodiscard]] UInt32 getID() const noexcept { return mID; }
 
        [[nodiscard]] bool isDirty() const noexcept { return mDirty; }
 
        void markAsDirty() noexcept { mDirty = true; }
 
    public:
        virtual void bind(GPUCommandBuffer& commandBuffer) = 0;
 
    private:
        friend class RendererMaterialManager;
 
        void setID(const UInt32 id) noexcept { mID = id; }
    };
 
    struct alignas(16) PBRMaterialParams {
        alignas(16) Vector4f baseColor;
        alignas(4) UInt32 baseColorTextureID;
        //        alignas(4) UInt32 baseColorSamplerID;
        alignas(16) Matrix4f baseColorTextureMask;
 
        alignas(4) float roughness;
        alignas(4) UInt32 roughnessTextureID;
        //        alignas(4) UInt32 roughnessSamplerID;
        alignas(16) Vector4f roughnessTextureMask;
 
        alignas(4) float metallic;
        alignas(4) UInt32 metallicTextureID;
        //        alignas(4) UInt32 metallicSamplerID;
        alignas(16) Vector4f metallicTextureMask;
 
        alignas(16) Vector3f normal;
        alignas(4) UInt32 normalTextureID;
        //        alignas(4) UInt32 normalSamplerID;
        alignas(16) Matrix3x4f normalTextureMask;
 
        alignas(16) Vector4f emissive;
        alignas(4) UInt32 emissiveTextureID;
        //        alignas(4) UInt32 emissiveSamplerID;
        alignas(16) Matrix4f emissiveTextureMask;
 
        alignas(16) Vector3f displacement;
        alignas(4) UInt32 displacementTextureID;
        //        alignas(4) UInt32 displacementSamplerID;
        alignas(16) Matrix3x4f displacementTextureMask;
 
        alignas(4) float ambientOcclusion;
        alignas(4) UInt32 ambientOcclusionTextureID;
        //        alignas(4) UInt32 ambientOcclusionSamplerID;
        float pad2;
        float pad3;
        alignas(16) Vector4f ambientOcclusionTextureMask;
        
        alignas(4) UInt32 isNormalsInTangentSpace;
    };
 
    class RendererMaterialPBR final : public RendererMaterial {
        friend class RendererMaterialManager;
 
    private:
        SPtr<PBRMaterial> mMaterial;
 
        PBRMaterialModel mModel;
 
        GPUShaderProgramPtr mShaderProgram;
 
        GPUPipelineLayoutPtr mPipelineLayout;
 
        GPUDynamicUniformBuffer<PBRMaterialParams> mUniformBuffer;
 
        GPUResourceSetDescriptor mResourceSetDescriptor;
 
        GPUResourceSetPtr mResourceSet;
 
        UInt64 mHash = ~0u;
 
    public:
        template<typename ValueType> class Property : public MaterialProperty<ValueType, RendererTexturePtr> {
            using super = MaterialProperty<ValueType, RendererTexturePtr>;
 
        private:
            friend class RendererMaterialPBR;
            EventConnection mDidChangeImageConnection;
 
        public:
            GPUSamplerPtr sampler;
 
        public:
            using super::super;
 
            explicit Property(const MaterialProperty<ValueType>& other, const RendererTexturePtr& texture, const GPUSamplerPtr& sampler) : sampler(sampler) {
                super::value = other.value;
                super::texture = texture;
                super::sampler = other.sampler;
                super::swizzle = other.swizzle;
            }
        };
 
        const Property<Color> baseColor;
 
        const Property<double> roughness;
 
        const Property<double> metallic;
 
        const Property<Vector3> normal;
 
        const Property<Color> emission;
 
        const Property<Vector3> displacement;
 
        const Property<double> ambientOcclusion;
 
    public:
        explicit RendererMaterialPBR(RendererMaterialManager& manager, const SPtr<PBRMaterial>& material);
 
    public:
        void prepare(RendererContext& context) override;
 
        void fillResourceSetDescriptor(GPUShaderResourceSetBindings& bindings) const final;
 
    public:
        [[nodiscard]] const GPUShaderProgramPtr& getShaderProgram() const final { return mShaderProgram; }
 
        [[nodiscard]] const GPUUniformBuffer& getUniformBuffer() const final { return mUniformBuffer; }
 
        [[nodiscard]] const GPUResourceSetPtr& getResourceSet() const final { return mResourceSet; }
 
        [[nodiscard]] GPUResourceSetDescriptor getResourceSetDescriptor() const final { return mResourceSetDescriptor; }
 
        [[nodiscard]] const PBRMaterialModel& getModel() const noexcept { return mModel; }
 
    public:
        void bind(GPUCommandBuffer& commandBuffer) final;
 
    private:
        void onImageChanged();
 
        void didChangeMaterialModel(const PBRMaterialModel& newModel);
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class RendererMaterialManager {
    private:
        using UniformBufferType = GPUDynamicStridedBindlessBufferArray<PBRMaterialParams>;
 
        Renderer& mRenderer;
 
        GPUDevice& mDevice [[maybe_unused]];
 
        HashMap<HMaterial, WPtr<RendererMaterial>> mMaterials;
 
        SPtr<RendererMaterial> mDefaultMaterial;
 
        UniformBufferType mUniformBuffer;
 
    public:
        explicit RendererMaterialManager(Renderer& renderer, GPUDevice& device);
 
        ~RendererMaterialManager();
 
    public:
        [[nodiscard]] SPtr<RendererMaterial> get(const HMaterial& material);
 
    public:
        Async<> prepare(RendererContext& context);
 
    public:
        [[nodiscard]] Renderer& getRenderer() const { return mRenderer; }
 
        [[nodiscard]] RendererMaterial& getDefaultMaterial() const { return *mDefaultMaterial; }
 
    public:
        [[nodiscard]] const GPUBindlessBuffer& getUniformBuffer() const noexcept { return mUniformBuffer; }
    };
 
} // namespace CeresEngine