layout.h

浏览该文件的文档.

#ifndef LAYOUT_H
#define LAYOUT_H
#include "ShaderStage.h"
#include "Context.h"
#include "UniformWrapper.h"
#include "VertexShader.h"
 
namespace FCT {
    // --- 前向声明 ---
    class DepthStencilState;
    class Image;
    class Sampler;
    class PassResource;
    namespace RHI {
        class Pass;
        class CommandBuffer;
        class RasterizationPipeline;
    }
 
    // --- 用于构造 Layout 的参数结构体 ---
    struct TextureSlot
    {
        std::string name;
    };

    struct PassName
    {
        std::string name;
    };

    struct ShaderRef
    {
        std::string code;
        size_t hash;
        ShaderKind kind;
    };
 
    // --- 类型别名 ---
    using UniformSlot = FCT::ConstLayout;
    using UniformVar = FCT::ConstElement;
    using UniformType = FCT::ConstType;
    using SamplerSlot = FCT::SamplerElement;

    class Layout {
    public:
        template<typename... Args>
        Layout(FCT::Context* ctx,Args... args);
        void ctx(FCT::Context* ctx);


        void addVertexLayout(const FCT::VertexLayout& vertexLayout);

        void setPixelLayout(const FCT::PixelLayout& pixelLayout);

        void addUniformSlot(const UniformSlot& uniformSlot);
 
        void addTextureSlot(const FCT::TextureSlot& element);
        void addTextureSlot(FCT::TextureElement element);

        void addSamplerSlot(const SamplerSlot& samplerSlot);

        void removeTextureSlot(const char* name);

        void setFixedImage(std::string name, FCT::Image* image);

        void attachPass(std::string passName);



        Uniform allocateUniform(std::string name);

        void begin();

        void bindUniform(const Uniform& uniform);
        void bindUniform(Uniform* uniform);

        void bindTexture(std::string name, FCT::Image* image);

        void bindSampler(std::string name, FCT::Sampler* sampler);

        void bindVertexShader(std::string code);

        void bindPixelShader(std::string code);

        void bindVertexShader(const ShaderRef& ref);
        void bindPixelShader(const ShaderRef& ref);

        template<typename T>
        void drawMesh(RHI::CommandBuffer* cmdBuffer,T* mesh);

        template<typename T>
        void drawMesh(RHI::CommandBuffer* cmdBuffer,T& mesh);

        void end();



        ShaderRef cacheVertexShader(const std::string& code);

        ShaderRef cachePixelShader(const std::string& code);

        void clearPassResourceCache();
// ... existing code
        void clearPipelineCache();

        void clearShaderCache();

 
    private:
        // =================================================================================
        // 私有辅助结构体 (Private Helper Structs)
        // =================================================================================
 
        // 管线状态
        struct TraditionPipelineState
        {
            FCT::VertexShader* vertexShader = nullptr;
            FCT::PixelShader* pixelShader = nullptr;
            FCT::BlendState* blendState = nullptr;
            FCT::RasterizationState* rasterizationState = nullptr;
            FCT::DepthStencilState* depthStencilState = nullptr;
            size_t hash() const;
            bool operator==(const TraditionPipelineState& other) const;
        };
 
        // Pass 资源状态
        struct PassResourceState
        {
            std::unordered_map<std::string, FCT::Image*> boundTextures;
            std::unordered_map<std::string, FCT::Sampler*> boundSamplers;
            std::unordered_map<std::string, FCT::RHI::ConstBuffer*> boundUniforms;
            void clear();
            void bindTexture(const std::string& name, FCT::Image* image);
            void bindSampler(const std::string& name, FCT::Sampler* sampler);
            void bindUniform(const std::string& name, const Uniform& uniform);
            void bindUniform(const std::string& name, Uniform* uniform);
            size_t hash() const;
        };
 
        // Pass 资源缓存
        struct PassResourceCache
        {
            std::unordered_map<size_t,FCT::PassResource*> m_passResources;
            ~PassResourceCache();
            FCT::PassResource* get(const PassResourceState& state, const std::function<FCT::PassResource*(const PassResourceState& state)>& creator);
        };
 
        // 管线缓存
        struct PipelineCache
        {
            std::unordered_map<size_t, FCT::RHI::RasterizationPipeline*> m_pipelines;
            ~PipelineCache();
            FCT::RHI::RasterizationPipeline* get(const TraditionPipelineState& state, const std::function<FCT::RHI::RasterizationPipeline*(const TraditionPipelineState& state)>& creator);
        };
 
        // 着色器缓存
        struct ShaderCache
        {
            std::unordered_map<size_t, FCT::VertexShader*> m_vertexShaders;
            std::unordered_map<size_t, FCT::PixelShader*> m_pixelShaders;
            ~ShaderCache();
            FCT::VertexShader* getVertexShader(const std::string& code,const std::function<FCT::VertexShader*(const std::string& code)>& creator);
            FCT::PixelShader* getPixelShader(const std::string& code,const std::function<FCT::PixelShader*(const std::string& code)>& creator);
            FCT::VertexShader* getVertexShader(const ShaderRef& ref,const std::function<FCT::VertexShader*(const ShaderRef& ref)>& creator);
            FCT::PixelShader* getPixelShader(const ShaderRef& ref, const std::function<FCT::PixelShader*(const ShaderRef& ref)>& creator);
            void clear();
        };
 
        // =================================================================================
        // 私有成员变量 (Private Member Variables)
        // =================================================================================
 
        // --- 核心上下文与布局定义 ---
        FCT::Context* m_ctx;
        std::map<uint32_t, FCT::VertexLayout> m_vertexLayouts;
        std::map<std::string, FCT::ConstLayout> m_uniformLayouts;
        FCT::PixelLayout m_pixelLayout;
        FCT::ResourceLayout m_resourceLayout;
        FCT::ResourceLayout m_vertexResourceLayout;
        FCT::ResourceLayout m_pixelResourceLayout;
        std::unordered_map<std::string, FCT::Image*> m_fixedImages;
        std::map<std::string, Image*> m_textureFromPass;
        std::unordered_map<std::string,const char*> m_textureNames;
 
        // --- 状态与资源管理 ---
        uint32_t m_nextAvailableIndex = 0;
        std::vector<TextureSlot> m_unhandledTextureSlots;
        bool m_hasVertexLayout = false;
        bool m_hasPixelLayout = false;
 
        // --- 当前 Pass/Pipeline 状态 ---
        FCT::RHI::Pass* m_pass;
        PassResourceState m_passResourceState;
        TraditionPipelineState m_pipelineState;
 
        // --- 缓存对象 ---
        PassResourceCache m_passResourceCache;
        PipelineCache m_pipelineCache;
        ShaderCache m_shaderCache;
 
        // =================================================================================
        // 私有辅助函数 (Private Helper Functions)
        // =================================================================================
 
        // --- 构造函数参数处理 ---
        template<typename... Args>
        void proccessArgs(FCT::VertexLayout vertexLayout, Args... args);
        template <class ... Args>
        void proccessArgs(const std::vector<FCT::VertexLayout>& vertexLayouts, Args... args);
        template<typename... Args>
        void proccessArgs(SamplerSlot samplerSlot, Args... args);
        template<typename... Args>
        void proccessArgs(PassName passName, Args... args);
        template<typename... Args>
        void proccessArgs(uint32_t index, FCT::VertexLayout vertexLayout, Args... args);
        template<typename... Args>
        void proccessArgs(FCT::PixelLayout pixelLayout, Args... args);
        template<typename... Args>
        void proccessArgs(TextureSlot textureSlot, Args... args);
        template<typename... Args>
        void proccessArgs(UniformSlot uniformSlot, Args... args);
        void proccessArgs();
 
        // --- 内部资源获取 ---
        FCT::PassResource* getCurrentPassResource();
        FCT::RHI::RasterizationPipeline* getCurrentPipeline();
 
        // --- 内部绑定与分配 ---
        void bindVertexShader(FCT::VertexShader* shader);
        void bindPixelShader(FCT::PixelShader* shader);
        FCT::VertexShader* allocateVertexShader(std::string code);
        FCT::PixelShader* allocatePixelShader(std::string code);
 
        // --- 缓存访问 ---
        VertexShader* getCacheVertexShader(std::string code);
        PixelShader* getCachePixelShader(std::string code);
        VertexShader* getCacheVertexShader(const ShaderRef& ref);
        PixelShader* getCachePixelShader(const ShaderRef& ref);
 
        // --- 其他工具函数 ---
        void processUnhandledTextureSlots();
        uint32_t findNextAvailableIndex();
    };
 
}
#endif //LAYOUT_H