添加贴图种类的选择

添加法线贴图
修复layout的bug
passresource现在支持bind nullptr了（constlayout或者说uniform还不支持）

Author: MaaBlock

src/Context/Context.h

@@ -50,6 +50,7 @@ namespace FCT
 		class ConstBuffer;
 		class IndexBuffer;
 	}
+    class Sampler;
 
 	class VertexBuffer;
 	//class InputLayout;
@@ -126,6 +127,8 @@ namespace FCT
 		template <typename T>
 		T* createResource();
 		virtual RHI::RasterizationPipeline* createTraditionPipeline() = 0;
+		        virtual RHI::ConstBuffer* getEmptyConstBuffer(const ConstLayout& layout) = 0;
+        virtual Sampler* getEmptySampler() = 0;
 		StaticMesh<uint32_t>* createMesh(const ModelMesh* modelMesh, const VertexLayout& layout);
 		StaticMesh<uint32_t>* loadMesh(const std::string& filename,const std::string& meshName, const VertexLayout& layout);
 		Image* loadTexture(const std::string& filename);

src/Context/RenderGraph.cpp

@@ -919,6 +919,10 @@ void RenderGraph::removeDepthStencilEdge(DepthStencilEdge* edgeToRemove) {
             Image* image = imageNode->getImage();
             if (image) {
                 imageStates[image] = ImageState{};
+                if (dynamic_cast<RenderGraphWindowTargetNode*>(imageNode.get()) || dynamic_cast<RenderGraphWindowDepthStencilNode*>(imageNode.get()))
+                {
+                    imageStates[image].currentLayout = ImageLayout::undefined;
+                }
             }
         }
 
@@ -970,10 +974,9 @@ void RenderGraph::removeDepthStencilEdge(DepthStencilEdge* edgeToRemove) {
 
                 bool needsBarrier = false;
 
-                if (currentState.currentLayout != requiredLayout &&
-                    currentState.currentLayout != ImageLayout::undefined) {
+                if (currentState.currentLayout != requiredLayout) {
                     needsBarrier = true;
-                    }
+                }
 
                 if (!currentState.lastWriterGroup.empty() &&
                     currentState.lastWriterGroup != groupLeader &&

src/Context/Uniform.h

@@ -329,6 +329,15 @@ namespace FCT
             return true;
         }
 
+        size_t getHash() const noexcept {
+            size_t seed = 0;
+            boost::hash_combine(seed, std::string(m_name));
+            for (size_t i = 0; i < m_elementCount; ++i) {
+                boost::hash_combine(seed, m_elements[i].getType());
+            }
+            return seed;
+        }
+
         constexpr size_t getElementCount() const noexcept { return m_elementCount; }
 
         constexpr const ConstElement& getElement(size_t index) const noexcept {

src/Context/VK_Context.cpp

@@ -19,6 +19,40 @@ namespace FCT
         return new RHI::VK_TraditionalPipeline(this);
     }
 
+    RHI::ConstBuffer* VK_Context::getEmptyConstBuffer(const ConstLayout& layout)
+    {
+        size_t layoutHash = layout.getHash();
+        auto it = m_emptyConstBufferCache.find(layoutHash);
+        if (it != m_emptyConstBufferCache.end())
+        {
+            return it->second.get();
+        }
+
+        auto emptyBuffer = createResource<RHI::ConstBuffer>();
+        emptyBuffer->layout(layout);
+        emptyBuffer->create(); // This will allocate a buffer of the correct size
+
+        RHI::ConstBuffer* bufferPtr = emptyBuffer;
+        m_emptyConstBufferCache[layoutHash] = std::unique_ptr<RHI::ConstBuffer>(bufferPtr);
+        return bufferPtr;
+    }
+
+        Sampler* VK_Context::getEmptySampler()
+    {
+        if (m_emptySampler)
+        {
+            return m_emptySampler.get();
+        }
+
+        auto sampler = createResource<Sampler>();
+        sampler->setFilter(FCT::FilterMode::Linear, FCT::FilterMode::Linear, FCT::FilterMode::Linear);
+        sampler->setAddressMode(FCT::AddressMode::ClampToEdge, FCT::AddressMode::ClampToEdge, FCT::AddressMode::ClampToEdge);
+        sampler->create();
+
+        m_emptySampler = std::unique_ptr<Sampler>(sampler);
+        return m_emptySampler.get();
+    }
+
     VK_Context::~VK_Context()
     {
         if (m_device) {

src/Context/VK_Context.h

@@ -46,6 +46,9 @@ namespace FCT {
             return m_graphicsQueue;
         }
 
+        RHI::ConstBuffer* getEmptyConstBuffer(const ConstLayout& layout) override;
+        Sampler* getEmptySampler() override;
+
         vk::CommandBuffer beginSingleTimeCommands();
         void endSingleTimeCommands(vk::CommandBuffer commandBuffer);
         void transferDataToBuffer(vk::Buffer dstBuffer, size_t size, const void* data);
@@ -70,6 +73,8 @@ namespace FCT {
         uint32_t m_transferQueueFamilyIndex;
         vk::Queue m_transferQueue;
         vk::CommandPool m_transferCommandPool;
+        std::unordered_map<size_t, std::unique_ptr<RHI::ConstBuffer>> m_emptyConstBufferCache;
+        std::unique_ptr<Sampler> m_emptySampler;
     };
 }
 

src/Context/VK_PassResource.cpp

@@ -26,29 +26,23 @@ namespace FCT
 
     void VK_PassResource::addConstBuffer(RHI::ConstBuffer* buffer)
     {
-        if (buffer) {
-            m_constBuffers.push_back(buffer);
-            markAllDescriptorSetsDirty();
-            markAllDescriptorSetsNeedRecreate();
-        }
+        m_constBuffers.push_back(buffer);
+        markAllDescriptorSetsDirty();
+        markAllDescriptorSetsNeedRecreate();
     }
 
     void VK_PassResource::addSampler(Sampler* sampler, SamplerElement element)
     {
-        if (sampler) {
-            m_samplers.emplace_back(sampler, element);
-            markAllDescriptorSetsDirty();
-            markAllDescriptorSetsNeedRecreate();
-        }
+        m_samplers.emplace_back(sampler, element);
+        markAllDescriptorSetsDirty();
+        markAllDescriptorSetsNeedRecreate();
     }
 
     void VK_PassResource::addTexture(Image* texture, TextureElement element)
     {
-        if (texture) {
-            m_textures[element] = texture;
-            markAllDescriptorSetsDirty();
-            markAllDescriptorSetsNeedRecreate();
-        }
+        m_textures[element] = texture;
+        markAllDescriptorSetsDirty();
+        markAllDescriptorSetsNeedRecreate();
     }
 
     void VK_PassResource::setTexture(Image* texture, TextureElement element)
@@ -103,6 +97,7 @@ bool VK_PassResource::createDescriptorSetsAndLayouts(uint32_t frameIdx,
         std::map<uint32_t, std::vector<vk::DescriptorSetLayoutBinding>> setBindings;
 
         for (auto* constBuffer : m_constBuffers) {
+            if (!constBuffer) continue;
             auto* vkConstBuffer = static_cast<RHI::VK_ConstBuffer*>(constBuffer);
             auto uniformLayout = vkConstBuffer->layout();
             auto [setIndex, binding] = m_ctx->getGenerator()->getLayoutBinding(uniformLayout);
@@ -246,6 +241,9 @@ bool VK_PassResource::createDescriptorSetsAndLayouts(uint32_t frameIdx,
 
         for (size_t i = 0; i < m_constBuffers.size(); ++i) {
             auto* srcConstBuffer = m_constBuffers[i];
+            if (!srcConstBuffer) {
+                continue;
+            }
             auto* constBuffer = static_cast<RHI::VK_ConstBuffer*>(srcConstBuffer);
             auto uniformLayout = constBuffer->layout();
             auto [setIndex, binding] = m_ctx->getGenerator()->getLayoutBinding(uniformLayout);
@@ -268,17 +266,23 @@ bool VK_PassResource::createDescriptorSetsAndLayouts(uint32_t frameIdx,
         }
 
         for (auto& [element, texture ] : m_textures) {
-            auto* vkTexture = static_cast<RHI::VK_TextureView*>(texture->currentTextureView());
             auto [setIndex, binding] = m_ctx->getGenerator()->getTextureBinding(element);
 
-            if (setIndex >= m_descriptorSets[frameIdx].size() || !vkTexture) {
+            if (setIndex >= m_descriptorSets[frameIdx].size()) {
                 continue;
             }
 
             vk::DescriptorImageInfo imageInfo;
             imageInfo.setImageLayout(vk::ImageLayout::eShaderReadOnlyOptimal);
-            imageInfo.setImageView(vkTexture->view());
             imageInfo.setSampler(nullptr);
+
+            if (texture) {
+                auto* vkTexture = static_cast<RHI::VK_TextureView*>(texture->currentTextureView());
+                imageInfo.setImageView(vkTexture ? vkTexture->view() : VK_NULL_HANDLE);
+            } else {
+                imageInfo.setImageView(VK_NULL_HANDLE);
+            }
+            
             textureInfos.push_back(imageInfo);
 
             vk::WriteDescriptorSet descriptorWrite;
@@ -287,24 +291,30 @@ bool VK_PassResource::createDescriptorSetsAndLayouts(uint32_t frameIdx,
             descriptorWrite.setDstArrayElement(0);
             descriptorWrite.setDescriptorType(vk::DescriptorType::eSampledImage);
             descriptorWrite.setDescriptorCount(1);
-            descriptorWrite.setPImageInfo(&textureInfos[textureInfos.size() - 1]);
+            descriptorWrite.setPImageInfo(&textureInfos.back());
 
             descriptorWrites.push_back(descriptorWrite);
         }
 
         for (size_t i = 0; i < m_samplers.size(); ++i) {
             auto& [sampler, element] = m_samplers[i];
-            auto* vkSampler = static_cast<RHI::VK_Sampler*>(sampler);
             auto [setIndex, binding] = m_ctx->getGenerator()->getSamplerBinding(element);
 
-            if (setIndex >= m_descriptorSets[frameIdx].size() || !vkSampler) {
+            if (setIndex >= m_descriptorSets[frameIdx].size()) {
                 continue;
             }
 
             vk::DescriptorImageInfo samplerInfo;
-            samplerInfo.setSampler(vkSampler->getSampler());
             samplerInfo.setImageView(nullptr);
             samplerInfo.setImageLayout(vk::ImageLayout::eUndefined);
+
+            if (sampler) {
+                auto* vkSampler = static_cast<RHI::VK_Sampler*>(sampler);
+                samplerInfo.setSampler(vkSampler->getSampler());
+            } else {
+                samplerInfo.setSampler(VK_NULL_HANDLE);
+            }
+            
             samplerInfos.push_back(samplerInfo);
 
             vk::WriteDescriptorSet descriptorWrite;
@@ -313,7 +323,7 @@ bool VK_PassResource::createDescriptorSetsAndLayouts(uint32_t frameIdx,
             descriptorWrite.setDstArrayElement(0);
             descriptorWrite.setDescriptorType(vk::DescriptorType::eSampler);
             descriptorWrite.setDescriptorCount(1);
-            descriptorWrite.setPImageInfo(&samplerInfos[samplerInfos.size() - 1]);
+            descriptorWrite.setPImageInfo(&samplerInfos.back());
 
             descriptorWrites.push_back(descriptorWrite);
         }

src/Context/layout.cpp

@@ -31,6 +31,9 @@ namespace FCT
 
     void Layout::addTextureSlot(FCT::TextureElement element)
     {
+        if (m_resourceLayout.findTextureIndex(element.getName()) != -1) {
+            return;
+        }
         m_resourceLayout.addTexture(element);
         if (element.getShaderStages() & FCT::ShaderStage::Vertex)
         {
@@ -46,11 +49,13 @@ namespace FCT
     }
     void Layout::addUniformSlot(const UniformSlot& uniformSlot)
     {
+        if (m_uniformLayouts.count(uniformSlot.getName())) {
+            return;
+        }
         m_uniformLayouts[uniformSlot.getName()] = uniformSlot;
         clearShaderCache();
         clearPipelineCache();
         clearPassResourceCache();
-
     }
 
     void Layout::addTextureSlot(const FCT::TextureSlot& slot)
@@ -64,10 +69,9 @@ namespace FCT
 
     void Layout::addSamplerSlot(const SamplerSlot& samplerSlot)
     {
-        // 检查是否已存在相同名字的SamplerSlot，避免重复添加
         auto existingSampler = m_resourceLayout.findSampler(samplerSlot.getName());
         if (existingSampler.getName() != nullptr && existingSampler.getName()[0] != '\0') {
-            return; // 已存在，不重复添加
+            return;
         }
 
         m_resourceLayout.addSampler(samplerSlot);
@@ -411,15 +415,38 @@ namespace FCT
         return m_passResourceCache.get(m_passResourceState, [this](const PassResourceState& state)
         {
             auto ret = m_ctx->createResource<FCT::PassResource>();
-            for (const auto& tex : state.boundTextures) {
-                ret->addTexture( tex.second,m_resourceLayout.findTexture(tex.first.c_str()));
+
+            for (const auto& layoutPair : m_uniformLayouts) {
+                const std::string& name = layoutPair.first;
+                const UniformSlot& slot = layoutPair.second;
+                auto boundIt = state.boundUniforms.find(name);
+                if (boundIt != state.boundUniforms.end()) {
+                    ret->addConstBuffer(boundIt->second);
+                } else {
+                    ret->addConstBuffer(m_ctx->getEmptyConstBuffer(slot));
+                }
             }
-            for (const auto& samp : state.boundSamplers) {
-                ret->addSampler(samp.second,m_resourceLayout.findSampler(samp.first.c_str()));
+
+            for (size_t i = 0; i < m_resourceLayout.getTextureCount(); ++i) {
+                const TextureElement& element = m_resourceLayout.getTexture(i);
+                auto boundIt = state.boundTextures.find(element.getName());
+                if (boundIt != state.boundTextures.end()) {
+                    ret->addTexture(boundIt->second, element);
+                } else {
+                    ret->addTexture(nullptr, element);
+                }
             }
-            for (const auto& uni : state.boundUniforms) {
-                ret->addConstBuffer(uni.second);
+
+            for (size_t i = 0; i < m_resourceLayout.getSamplerCount(); ++i) {
+                const SamplerElement& element = m_resourceLayout.getSampler(i);
+                auto boundIt = state.boundSamplers.find(element.getName());
+                if (boundIt != state.boundSamplers.end()) {
+                    ret->addSampler(boundIt->second, element);
+                } else {
+                    ret->addSampler(m_ctx->getEmptySampler(), element);
+                }
             }
+
             ret->create();
             return ret;
         });

src/RHI/VK_RasterizationPipeline.cpp

@@ -19,6 +19,10 @@ namespace FCT::RHI
 
     VK_RasterizationPipeline::~VK_RasterizationPipeline()
     {
+        if (m_pipeline)
+        {
+            m_ctx->getDevice().destroyPipeline(m_pipeline);
+        }
         FCT_SAFE_RELEASE(m_blendState);
         FCT_SAFE_RELEASE(m_rasterizationState);
         FCT_SAFE_RELEASE(m_viewportState);