support MI_MAX_COUNT in ShaderGen

example/Vulkan/first_triangle.cpp

@@ -8,7 +8,7 @@
 #include<hgl/graph/SceneInfo.h>
 #include<hgl/graph/VKVertexInputConfig.h>
 #include<hgl/graph/VKRenderablePrimitiveCreater.h>
-#include<hgl/graph/mtl/2d/Material2DConfig.h>
+#include<hgl/graph/mtl/2d/Material2DCreateConfig.h>
 
 using namespace hgl;
 using namespace hgl::graph;
@@ -87,7 +87,7 @@ private:
 
     bool InitAutoMaterial()
     {
-        mtl::Material2DConfig cfg("VertexColor2d");
+        mtl::Material2DCreateConfig cfg(device->GetDeviceAttribute(),"VertexColor2d");
 
         cfg.coordinate_system=CoordinateSystem2D::NDC;
         cfg.local_to_world=false;

example/Vulkan/fourth_triangle.cpp

@@ -5,7 +5,7 @@
 #include<hgl/math/Math.h>
 #include<hgl/filesystem/FileSystem.h>
 #include<hgl/graph/VKRenderablePrimitiveCreater.h>
-#include<hgl/graph/mtl/2d/Material2DConfig.h>
+#include<hgl/graph/mtl/2d/Material2DCreateConfig.h>
 #include<hgl/graph/RenderList.h>
 
 using namespace hgl;
@@ -47,7 +47,7 @@ private:
     bool InitMaterial()
     {
         {
-            mtl::Material2DConfig cfg("PureColor2D");
+            mtl::Material2DCreateConfig cfg(device->GetDeviceAttribute(),"PureColor2D");
 
             cfg.coordinate_system=CoordinateSystem2D::NDC;
             cfg.local_to_world=true;

example/Vulkan/second_triangle.cpp

@@ -6,7 +6,7 @@
 #include<hgl/filesystem/FileSystem.h>
 #include<hgl/graph/SceneInfo.h>
 #include<hgl/graph/VKRenderablePrimitiveCreater.h>
-#include<hgl/graph/mtl/2d/Material2DConfig.h>
+#include<hgl/graph/mtl/2d/Material2DCreateConfig.h>
 
 using namespace hgl;
 using namespace hgl::graph;
@@ -45,7 +45,7 @@ private:
 
     bool InitMaterial()
     {
-        mtl::Material2DConfig cfg("VertexColor2D");
+        mtl::Material2DCreateConfig cfg("VertexColor2D");
 
 #ifdef USE_ZERO2ONE_COORD
         cfg.coordinate_system=CoordinateSystem2D::ZeroToOne;

example/Vulkan/third_triangle.cpp

@@ -5,7 +5,7 @@
 #include<hgl/math/Math.h>
 #include<hgl/filesystem/FileSystem.h>
 #include<hgl/graph/VKRenderablePrimitiveCreater.h>
-#include<hgl/graph/mtl/2d/Material2DConfig.h>
+#include<hgl/graph/mtl/2d/Material2DCreateConfig.h>
 #include<hgl/graph/RenderList.h>
 
 using namespace hgl;
@@ -46,7 +46,7 @@ private:
     bool InitMaterial()
     {
         {
-            mtl::Material2DConfig cfg("VertexColor2D");
+            mtl::Material2DCreateConfig cfg("VertexColor2D");
 
             cfg.coordinate_system=CoordinateSystem2D::NDC;
             cfg.local_to_world=true;

inc/hgl/graph/VKDescriptorSet.h

@@ -23,9 +23,7 @@ class DescriptorSet
 
     bool is_dirty;
 
-private:
+public:
-
-    friend class GPUDevice;
 
     DescriptorSet(VkDevice dev,const int bc,VkPipelineLayout pl,VkDescriptorSet ds)
     {
@@ -37,8 +35,6 @@ private:
         is_dirty=true;
     }
 
-public:
-
     ~DescriptorSet()=default;
 
     const uint32_t          GetCount            ()const{return binding_count;}

inc/hgl/graph/VKDevice.h

@@ -209,10 +209,6 @@ public: //
 
 public: //shader & material
 
-    PipelineLayoutData *CreatePipelineLayoutData(const MaterialDescriptorManager *);
-    void Destroy(PipelineLayoutData *);
-
-    DescriptorSet *     CreateDS(const PipelineLayoutData *,const DescriptorSetType &type)const;
     MaterialParameters *CreateMP(const MaterialDescriptorManager *,const PipelineLayoutData *,const DescriptorSetType &);
     MaterialParameters *CreateMP(Material *,const DescriptorSetType &);
     

inc/hgl/graph/mtl/2d/Material2DCreateConfig.h

@@ -1,11 +1,11 @@
-#ifndef HGL_GRAPH_MTL_2D_CONFIG_INCLUDE
+#ifndef HGL_GRAPH_MTL_2D_CREATE_CONFIG_INCLUDE
-#define HGL_GRAPH_MTL_2D_CONFIG_INCLUDE
+#define HGL_GRAPH_MTL_2D_CREATE_CONFIG_INCLUDE
 
 #include<hgl/graph/mtl/MaterialConfig.h>
 #include<hgl/graph/CoordinateSystem.h>
 
 STD_MTL_NAMESPACE_BEGIN
-struct Material2DConfig:public MaterialConfig
+struct Material2DCreateConfig:public MaterialCreateConfig
 {
     CoordinateSystem2D  coordinate_system;      ///<使用的坐标系
 
@@ -13,7 +13,7 @@ struct Material2DConfig:public MaterialConfig
 
 public:
 
-    Material2DConfig(const AnsiString &name):MaterialConfig(name)
+    Material2DCreateConfig(const GPUDeviceAttribute *da,const AnsiString &name):MaterialCreateConfig(da,name)
     {
         rt_output.color=1;          //输出一个颜色
         rt_output.depth=false;      //不输出深度
@@ -22,9 +22,9 @@ public:
         coordinate_system=CoordinateSystem2D::NDC;
         local_to_world=false;
     }
-};//struct Material2DConfig:public MaterialConfig
+};//struct Material2DCreateConfig:public MaterialCreateConfig
 
-MaterialCreateInfo *CreateVertexColor2D(const Material2DConfig *);
+MaterialCreateInfo *CreateVertexColor2D(const Material2DCreateConfig *);
-MaterialCreateInfo *CreatePureColor2D(const Material2DConfig *);
+MaterialCreateInfo *CreatePureColor2D(const Material2DCreateConfig *);
 STD_MTL_NAMESPACE_END
-#endif//HGL_GRAPH_MTL_2D_CONFIG_INCLUDE
+#endif//HGL_GRAPH_MTL_2D_CREATE_CONFIG_INCLUDE

inc/hgl/graph/mtl/MaterialConfig.h

@@ -12,8 +12,10 @@ class MaterialCreateInfo;
 /**
  * 材质配置结构
  */
-struct MaterialConfig
+struct MaterialCreateConfig
 {
+    const GPUDeviceAttribute *dev_attr;
+
     AnsiString mtl_name;                                    ///<材质名称
 
     RenderTargetOutputConfig rt_output;                     ///<渲染目标输出配置
@@ -22,12 +24,14 @@ struct MaterialConfig
 
 public:
 
-    MaterialConfig(const AnsiString &name)
+    MaterialCreateConfig(const GPUDeviceAttribute *da,const AnsiString &name)
     {
+        dev_attr=da;
+
         mtl_name=name;
 
         shader_stage=VK_SHADER_STAGE_VERTEX_BIT|VK_SHADER_STAGE_FRAGMENT_BIT;
     }
-};//struct MaterialConfig
+};//struct MaterialCreateConfig
 STD_MTL_NAMESPACE_END
 #endif//HGL_GRAPH_MTL_CONFIG_INCLUDE

inc/hgl/graph/mtl/StdMaterial.h

@@ -4,3 +4,13 @@
 #define STD_MTL_NAMESPACE_END   }}}
 
 #define STD_MTL_NAMESPACE_USING using namespace hgl::graph::mtl;
+
+namespace hgl
+{
+    namespace graph
+    {
+        namespace mtl
+        {
+        }//namespace mtl
+    }//namespace graph
+}//namespace hgl

inc/hgl/graph/mtl/UBOCommon.h

@@ -50,7 +50,7 @@ constexpr const ShaderBufferSource SBS_MaterialInstanceData=
     "mtl",
 
     R"(
-    MaterialInstance mi[256];)"
+    MaterialInstance mi[MI_MAX_COUNT];)"
 };
 
 constexpr const ShaderBufferSource SBS_JointInfo=

inc/hgl/shadergen/MaterialCreateInfo.h

@@ -10,12 +10,17 @@
 #include<hgl/graph/mtl/ShaderBuffer.h>
 #include<hgl/graph/VKSamplerType.h>
 
-STD_MTL_NAMESPACE_BEGIN
+namespace hgl{namespace graph
+{
+    struct GPUDeviceAttribute;
+
+    namespace mtl
+    {
         class MaterialCreateInfo
         {
         protected:
 
-    const MaterialConfig *config;
+            const MaterialCreateConfig *config;
 
             MaterialDescriptorInfo mdi;                             ///<材质描述符管理器
 
@@ -55,7 +60,7 @@ public:
 
         public:
 
-    MaterialCreateInfo(const MaterialConfig *);
+            MaterialCreateInfo(const MaterialCreateConfig *);
             ~MaterialCreateInfo()=default;
 
             bool SetMaterialInstance(const AnsiString &mi_glsl_codes,const uint32_t mi_struct_bytes,const uint32_t shader_stage);
@@ -68,6 +73,9 @@ public:
 
             bool AddUBO(const uint32_t flag_bits,const DescriptorSetType &set_type,const ShaderBufferSource &ss);
 
-    bool CreateShader();
+            bool CreateShader(const GPUDeviceAttribute *);
         };//class MaterialCreateInfo
-STD_MTL_NAMESPACE_END
+    }//namespace mtl
+}//namespace graph
+}//namespace hgl
+

inc/hgl/shadergen/MaterialDescriptorInfo.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include<hgl/graph/VKShaderDescriptorSet.h>
+#include<hgl/graph/mtl/ShaderBuffer.h>
 #include<hgl/type/Map.h>
 
 namespace hgl{namespace graph{
@@ -28,6 +29,11 @@ public:
         return(true);
     }
 
+    bool AddStruct(const ShaderBufferSource &ss)
+    {
+        return(AddStruct(ss.struct_name,ss.codes));
+    }
+
     bool GetStruct(const AnsiString &name,AnsiString &code)
     {
         return(struct_map.Get(name,code));

inc/hgl/shadergen/ShaderCreateInfo.h

@@ -25,6 +25,11 @@ protected:
 
 protected:
 
+    AnsiStringList define_macro_list;
+    AnsiStringList define_value_list;
+    uint32_t define_macro_max_length;
+    uint32_t define_value_max_length;
+
     AnsiString output_struct;
 
     AnsiString mi_codes;
@@ -39,6 +44,9 @@ protected:
 protected:
 
     virtual bool ProcHeader(){return(true);}
+
+    virtual bool ProcDefine();
+
     virtual bool ProcSubpassInput();
     virtual bool ProcInput(ShaderCreateInfo *);
     virtual bool ProcOutput();
@@ -65,6 +73,8 @@ public:
     ShaderCreateInfo(VkShaderStageFlagBits ss,MaterialDescriptorInfo *m);
     virtual ~ShaderCreateInfo();
 
+    bool AddDefine(const AnsiString &m,const AnsiString &v);
+
     int AddOutput(const graph::VAT &type,const AnsiString &name,Interpolation inter=Interpolation::Smooth);
     int AddOutput(const AnsiString &type,const AnsiString &name,Interpolation inter=Interpolation::Smooth);
 

src/SceneGraph/MaterialRenderList.cpp

@@ -115,9 +115,9 @@ void MaterialRenderList::End()
 
     if(mi_count<=0)return;
 
-    if(extra_buffer->mi_count<mi_count)
+    //if(extra_buffer->mi_count<mi_count)
-        extra_buffer->MIAlloc(device,mi_count,);
+    //    extra_buffer->MIAlloc(device,mi_count,);
-    extra_buffer->WriteMaterialInstance(rn_list.GetData(),node_count,mi_set);
+    //extra_buffer->WriteMaterialInstance(rn_list.GetData(),node_count,mi_set);
 }
 
 void MaterialRenderList::RenderItem::Set(Renderable *ri)

src/SceneGraph/RenderExtraBuffer.h

@@ -144,20 +144,20 @@ public:
 
         //MaterialInstance Data
         {
-            const uint count=mi_set.GetCount();
+            //const uint count=mi_set.GetCount();
 
-            uint8 *tp=(uint8 *)(mi_data_buffer->Map());
+            //uint8 *tp=(uint8 *)(mi_data_buffer->Map());
-            const MaterialInstance **mi=mi_set.GetData();
+            //const MaterialInstance **mi=mi_set.GetData();
 
-            for(uint i=0;i<count;i++)
+            //for(uint i=0;i<count;i++)
-            {
+            //{
-                memcpy(tp,(*mi)->GetData(),mi_size);
+            //    memcpy(tp,(*mi)->GetData(),mi_size);
     
-                ++mi;
+            //    ++mi;
-                tp+=mi_size;
+            //    tp+=mi_size;
-            }
+            //}
 
-            mi_data_buffer->Unmap();
+            //mi_data_buffer->Unmap();
         }
     }
 };//struct RenderExtraBuffer

src/SceneGraph/Vulkan/VKDeviceMaterial.cpp

@@ -8,7 +8,12 @@
 #include"VKPipelineLayoutData.h"
 
 VK_NAMESPACE_BEGIN
-DescriptorSet *GPUDevice::CreateDS(const PipelineLayoutData *pld,const DescriptorSetType &type)const
+
+PipelineLayoutData *CreatePipelineLayoutData(VkDevice device,const MaterialDescriptorManager *desc_manager);
+
+namespace
+{
+    DescriptorSet *CreateDS(VkDevice device,VkDescriptorPool desc_pool,const PipelineLayoutData *pld,const DescriptorSetType &type)
     {
         RANGE_CHECK_RETURN_NULLPTR(type);
 
@@ -19,41 +24,16 @@ DescriptorSet *GPUDevice::CreateDS(const PipelineLayoutData *pld,const Descripto
 
         DescriptorSetAllocateInfo alloc_info;
 
-    alloc_info.descriptorPool       = attr->desc_pool;
+        alloc_info.descriptorPool       = desc_pool;
         alloc_info.descriptorSetCount   = 1;
         alloc_info.pSetLayouts          = pld->layouts+size_t(type);
 
         VkDescriptorSet desc_set;
 
-    if(vkAllocateDescriptorSets(attr->device,&alloc_info,&desc_set)!=VK_SUCCESS)
+        if(vkAllocateDescriptorSets(device,&alloc_info,&desc_set)!=VK_SUCCESS)
             return(nullptr);
 
-    return(new DescriptorSet(attr->device,binding_count,pld->pipeline_layout,desc_set));
+        return(new DescriptorSet(device,binding_count,pld->pipeline_layout,desc_set));
-}
-
-MaterialParameters *GPUDevice::CreateMP(const MaterialDescriptorManager *desc_manager,const PipelineLayoutData *pld,const DescriptorSetType &desc_set_type)
-{
-    if(!desc_manager||!pld)return(nullptr);
-    RANGE_CHECK_RETURN_NULLPTR(desc_set_type)
-
-    DescriptorSet *ds=CreateDS(pld,desc_set_type);
-
-    if(!ds)return(nullptr);
-
-#ifdef _DEBUG
-    const UTF8String addr_string=HexToString<char,uint64_t>((uint64_t)(ds->GetDescriptorSet()));
-
-    LOG_INFO(U8_TEXT("Create [DescriptSets:")+addr_string+("] OK! Material Name: \"")+desc_manager->GetMaterialName()+U8_TEXT("\" Type: ")+GetDescriptorSetTypeName(desc_set_type));
-#endif//_DEBUG
-
-    return(new MaterialParameters(desc_manager,desc_set_type,ds));
-}
-
-MaterialParameters *GPUDevice::CreateMP(Material *mtl,const DescriptorSetType &desc_set_type)
-{
-    if(!mtl)return(nullptr);
-
-    return CreateMP(mtl->GetDescriptorSets(),mtl->GetPipelineLayoutData(),desc_set_type);
     }
 
     void CreateShaderStageList(List<VkPipelineShaderStageCreateInfo> &shader_stage_list,ShaderModuleMap *shader_maps)
@@ -75,6 +55,32 @@ void CreateShaderStageList(List<VkPipelineShaderStageCreateInfo> &shader_stage_l
             ++itp;
         }
     }
+}//namespace
+
+MaterialParameters *GPUDevice::CreateMP(const MaterialDescriptorManager *desc_manager,const PipelineLayoutData *pld,const DescriptorSetType &desc_set_type)
+{
+    if(!desc_manager||!pld)return(nullptr);
+    RANGE_CHECK_RETURN_NULLPTR(desc_set_type)
+
+    DescriptorSet *ds=CreateDS(attr->device,attr->desc_pool,pld,desc_set_type);
+
+    if(!ds)return(nullptr);
+
+#ifdef _DEBUG
+    const UTF8String addr_string=HexToString<char,uint64_t>((uint64_t)(ds->GetDescriptorSet()));
+
+    LOG_INFO(U8_TEXT("Create [DescriptSets:")+addr_string+("] OK! Material Name: \"")+desc_manager->GetMaterialName()+U8_TEXT("\" Type: ")+GetDescriptorSetTypeName(desc_set_type));
+#endif//_DEBUG
+
+    return(new MaterialParameters(desc_manager,desc_set_type,ds));
+}
+
+MaterialParameters *GPUDevice::CreateMP(Material *mtl,const DescriptorSetType &desc_set_type)
+{
+    if(!mtl)return(nullptr);
+
+    return CreateMP(mtl->GetDescriptorSets(),mtl->GetPipelineLayoutData(),desc_set_type);
+}
 
 Material *GPUDevice::CreateMaterial(const UTF8String &mtl_name,ShaderModuleMap *shader_maps,MaterialDescriptorManager *desc_manager,VertexInput *vi)
 {
@@ -83,7 +89,7 @@ Material *GPUDevice::CreateMaterial(const UTF8String &mtl_name,ShaderModuleMap *
     if(shader_count<1)
         return(nullptr);
 
-    PipelineLayoutData *pld=CreatePipelineLayoutData(desc_manager);
+    PipelineLayoutData *pld=CreatePipelineLayoutData(attr->device,desc_manager);
     
     if(!pld)
     {

src/SceneGraph/Vulkan/VKPipelineLayoutData.cpp

@@ -4,7 +4,7 @@
 #include<hgl/graph/VKMaterialDescriptorManager.h>
 
 VK_NAMESPACE_BEGIN
-PipelineLayoutData *GPUDevice::CreatePipelineLayoutData(const MaterialDescriptorManager *desc_manager)
+PipelineLayoutData *CreatePipelineLayoutData(VkDevice device,const MaterialDescriptorManager *desc_manager)
 {
     PipelineLayoutData *pld=hgl_zero_new<PipelineLayoutData>();
 
@@ -18,9 +18,9 @@ PipelineLayoutData *GPUDevice::CreatePipelineLayoutData(const MaterialDescriptor
                 continue;
 
             if(pld->layouts[i])
-                vkDestroyDescriptorSetLayout(attr->device,pld->layouts[i],nullptr);
+                vkDestroyDescriptorSetLayout(device,pld->layouts[i],nullptr);
 
-            if(vkCreateDescriptorSetLayout(attr->device,dslci,nullptr,pld->layouts+i)!=VK_SUCCESS)
+            if(vkCreateDescriptorSetLayout(device,dslci,nullptr,pld->layouts+i)!=VK_SUCCESS)
             {
                 delete pld;
                 return(nullptr);
@@ -56,9 +56,9 @@ PipelineLayoutData *GPUDevice::CreatePipelineLayoutData(const MaterialDescriptor
     pPipelineLayoutCreateInfo.pushConstantRangeCount    = 0;//1;
     pPipelineLayoutCreateInfo.pPushConstantRanges       = nullptr;//&push_constant_range;
 
-    pld->device=attr->device;
+    pld->device=device;
 
-    if(vkCreatePipelineLayout(attr->device,&pPipelineLayoutCreateInfo,nullptr,&(pld->pipeline_layout))!=VK_SUCCESS)
+    if(vkCreatePipelineLayout(device,&pPipelineLayoutCreateInfo,nullptr,&(pld->pipeline_layout))!=VK_SUCCESS)
     {
         delete pld;
         return(nullptr);

src/ShaderGen/2d/PureColor2D.cpp

@@ -35,16 +35,16 @@ void main()
 
         ~MaterialPureColor2D()=default;
 
-        bool CreateVertexShader(ShaderCreateInfoVertex *vsc) override
+        bool CustomVertexShader(ShaderCreateInfoVertex *vsc) override
         {
-            if(!Std2DMaterial::CreateVertexShader(vsc))
+            if(!Std2DMaterial::CustomVertexShader(vsc))
                 return(false);
 
             vsc->SetMain(vs_main);
             return(true);
         }
 
-        bool CreateFragmentShader(ShaderCreateInfoFragment *fsc) override
+        bool CustomFragmentShader(ShaderCreateInfoFragment *fsc) override
         {
             fsc->AddOutput(VAT_VEC4,"Color");       //Fragment shader的输出等于最终的RT了，所以这个名称其实随便起。
 
@@ -52,7 +52,7 @@ void main()
             return(true);
         }
 
-        bool AfterCreateShader() override
+        bool EndCustomShader() override
         {
             mci->SetMaterialInstance(   mi_codes,                       //材质实例glsl代码
                                         mi_bytes,                       //材质实例数据大小
@@ -63,7 +63,7 @@ void main()
     };//class MaterialPureColor2D:public Std2DMaterial
 }//namespace
 
-MaterialCreateInfo *CreatePureColor2D(const Material2DConfig *cfg)
+MaterialCreateInfo *CreatePureColor2D(const Material2DCreateConfig *cfg)
 {
     MaterialPureColor2D mpc2d(cfg);
 

src/ShaderGen/2d/Std2DMaterial.cpp

@@ -1,18 +1,18 @@
 #include"Std2DMaterial.h"
 #include<hgl/shadergen/MaterialCreateInfo.h>
-#include<hgl/graph/mtl/2d/Material2DConfig.h>
+#include<hgl/graph/mtl/2d/Material2DCreateConfig.h>
 #include<hgl/graph/mtl/UBOCommon.h>
 #include"common/MFGetPosition.h"
 
 STD_MTL_NAMESPACE_BEGIN
-Std2DMaterial::Std2DMaterial(const Material2DConfig *c)
+Std2DMaterial::Std2DMaterial(const Material2DCreateConfig *c)
 {
     mci=new MaterialCreateInfo(c);
 
     cfg=c;
 }
 
-bool Std2DMaterial::CreateVertexShader(ShaderCreateInfoVertex *vsc)
+bool Std2DMaterial::CustomVertexShader(ShaderCreateInfoVertex *vsc)
 {
     RANGE_CHECK_RETURN_FALSE(cfg->coordinate_system)
 
@@ -39,25 +39,25 @@ bool Std2DMaterial::CreateVertexShader(ShaderCreateInfoVertex *vsc)
 
 MaterialCreateInfo *Std2DMaterial::Create()
 {
-    if(!BeforeCreateShader())
+    if(!BeginCustomShader())
         return(nullptr);
 
     if(mci->hasVertex())
-        if(!CreateVertexShader(mci->GetVS()))
+        if(!CustomVertexShader(mci->GetVS()))
             return(nullptr);
 
     if(mci->hasGeometry())
-        if(!CreateGeometryShader(mci->GetGS()))
+        if(!CustomGeometryShader(mci->GetGS()))
             return(nullptr);
 
     if(mci->hasFragment())
-        if(!CreateFragmentShader(mci->GetFS()))
+        if(!CustomFragmentShader(mci->GetFS()))
             return(nullptr);
 
-    if(!AfterCreateShader())
+    if(!EndCustomShader())
         return(false);
 
-    if(!mci->CreateShader())
+    if(!mci->CreateShader(cfg->dev_attr))
         return(nullptr);
 
     return(mci);

src/ShaderGen/2d/Std2DMaterial.h

@@ -6,6 +6,8 @@ namespace hgl
 {
     namespace graph
     {
+        struct GPUDeviceAttribute;
+
         class ShaderCreateInfoVertex;
         class ShaderCreateInfoGeometry;
         class ShaderCreateInfoFragment;
@@ -13,29 +15,29 @@ namespace hgl
         namespace mtl
         {
             class MaterialCreateInfo;
-            struct Material2DConfig;
+            struct Material2DCreateConfig;
 
             class Std2DMaterial
             {
             protected:
 
-                const Material2DConfig *cfg;
+                const Material2DCreateConfig *cfg;
 
                 MaterialCreateInfo *mci;
 
             protected:
 
-                virtual bool BeforeCreateShader(){return true;/*some work before creating shader*/};
+                virtual bool BeginCustomShader(){return true;/*some work before creating shader*/};
 
-                virtual bool CreateVertexShader(ShaderCreateInfoVertex *);
+                virtual bool CustomVertexShader(ShaderCreateInfoVertex *);
-                virtual bool CreateGeometryShader(ShaderCreateInfoGeometry *){return false;}
+                virtual bool CustomGeometryShader(ShaderCreateInfoGeometry *){return false;}
-                virtual bool CreateFragmentShader(ShaderCreateInfoFragment *)=0;
+                virtual bool CustomFragmentShader(ShaderCreateInfoFragment *)=0;
 
-                virtual bool AfterCreateShader(){return true;/*some work after creating shader*/};
+                virtual bool EndCustomShader(){return true;/*some work after creating shader*/};
 
             public:
 
-                Std2DMaterial(const Material2DConfig *);
+                Std2DMaterial(const Material2DCreateConfig *);
                 virtual ~Std2DMaterial()=default;
     
                 virtual MaterialCreateInfo *Create();

src/ShaderGen/2d/VertexColor2D.cpp

@@ -31,9 +31,9 @@ void main()
         using Std2DMaterial::Std2DMaterial;
         ~MaterialVertexColor2D()=default;
 
-        bool CreateVertexShader(ShaderCreateInfoVertex *vsc) override
+        bool CustomVertexShader(ShaderCreateInfoVertex *vsc) override
         {
-            if(!Std2DMaterial::CreateVertexShader(vsc))
+            if(!Std2DMaterial::CustomVertexShader(vsc))
                 return(false);
 
             vsc->AddInput(VAT_VEC4,VAN::Color);
@@ -44,7 +44,7 @@ void main()
             return(true);
         }
 
-        bool CreateFragmentShader(ShaderCreateInfoFragment *fsc) override
+        bool CustomFragmentShader(ShaderCreateInfoFragment *fsc) override
         {
             fsc->AddOutput(VAT_VEC4,"Color");       //Fragment shader的输出等于最终的RT了，所以这个名称其实随便起。
 
@@ -54,7 +54,7 @@ void main()
     };//class MaterialVertexColor2D:public Std2DMaterial
 }//namespace
 
-MaterialCreateInfo *CreateVertexColor2D(const Material2DConfig *cfg)
+MaterialCreateInfo *CreateVertexColor2D(const Material2DCreateConfig *cfg)
 {
     MaterialVertexColor2D mvc2d(cfg);
 

src/ShaderGen/CMakeLists.txt

@@ -46,7 +46,7 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
 SET(STD_MTL_2D_HEADER_PATH ${STD_MTL_HEADER_PATH}/2d)
 
-SET(STD_MTL_2D_SOURCE_FILES	${STD_MTL_2D_HEADER_PATH}/Material2DConfig.h
+SET(STD_MTL_2D_SOURCE_FILES	${STD_MTL_2D_HEADER_PATH}/Material2DCreateConfig.h
                             2d/Std2DMaterial.h
                             2d/Std2DMaterial.cpp
                             2d/VertexColor2D.cpp

src/ShaderGen/MaterialCreateInfo.cpp

@@ -1,13 +1,14 @@
 #include<hgl/shadergen/MaterialCreateInfo.h>
 #include<hgl/shadergen/ShaderDescriptorInfo.h>
 #include<hgl/graph/mtl/UBOCommon.h>
+#include<hgl/graph/VKDeviceAttribute.h>
 #include"common/MFCommon.h"
 
 using namespace hgl;
 using namespace hgl::graph;
 
 STD_MTL_NAMESPACE_BEGIN
-MaterialCreateInfo::MaterialCreateInfo(const MaterialConfig *mc)
+MaterialCreateInfo::MaterialCreateInfo(const MaterialCreateConfig *mc)
 {
     config=mc;
 
@@ -140,7 +141,11 @@ bool MaterialCreateInfo::SetMaterialInstance(const AnsiString &glsl_codes,const
     if(data_bytes>0)
         mi_codes=glsl_codes;
 
+    const uint32_t ubo_range=config->dev_attr->physical_device->GetUBORange();
+    AnsiString MI_MAX_COUNT=AnsiString::numberOf(ubo_range/data_bytes);
+
     mdi.AddStruct(MaterialInstanceStruct,mi_codes);
+    mdi.AddStruct(SBS_MaterialInstanceData);
 
     UBODescriptor *ubo=new UBODescriptor();
 
@@ -148,7 +153,6 @@ bool MaterialCreateInfo::SetMaterialInstance(const AnsiString &glsl_codes,const
     hgl::strcpy(ubo->name,DESCRIPTOR_NAME_MAX_LENGTH,SBS_MaterialInstanceData.name);
     ubo->stage_flag=shader_stage;
 
-    mdi.AddStruct(SBS_MaterialInstanceData.struct_name,SBS_MaterialInstanceData.codes);
     mdi.AddUBO(shader_stage,DescriptorSetType::PerMaterial,ubo);
 
     auto *it=shader_map.GetDataList();
@@ -156,7 +160,10 @@ bool MaterialCreateInfo::SetMaterialInstance(const AnsiString &glsl_codes,const
     for(int i=0;i<shader_map.GetCount();i++)
     {
         if((*it)->key&shader_stage)
+        {
+            (*it)->value->AddDefine("MI_MAX_COUNT",MI_MAX_COUNT);
             (*it)->value->SetMaterialInstance(ubo,mi_codes);
+        }
 
         ++it;
     }
@@ -168,7 +175,7 @@ bool MaterialCreateInfo::SetMaterialInstance(const AnsiString &glsl_codes,const
     return(true);
 }
 
-bool MaterialCreateInfo::CreateShader()
+bool MaterialCreateInfo::CreateShader(const GPUDeviceAttribute *dev_attr)
 {
     if(shader_map.IsEmpty())
         return(false);
@@ -182,7 +189,6 @@ bool MaterialCreateInfo::CreateShader()
         if(!shader_map.GetValue(i,sc))
             return(false);
 
-        if(mi_shader_stage)
         if(sc->GetShaderStage()<mi_shader_stage)
         {
             sc->AddOutput(VAT_UINT,VAN::MaterialInstanceID,Interpolation::Flat);

src/ShaderGen/ShaderCreateInfo.cpp

@@ -12,6 +12,9 @@ ShaderCreateInfo::ShaderCreateInfo(VkShaderStageFlagBits ss,MaterialDescriptorIn
     sdm=new ShaderDescriptorInfo(ss);
 
     spv_data=nullptr;
+
+    define_macro_max_length=0;
+    define_value_max_length=0;
 }
 
 ShaderCreateInfo::~ShaderCreateInfo()
@@ -22,6 +25,70 @@ ShaderCreateInfo::~ShaderCreateInfo()
     delete sdm;
 }
 
+bool ShaderCreateInfo::AddDefine(const AnsiString &m,const AnsiString &v)
+{
+    if(define_macro_list.Find(m)!=-1)
+        return(false);
+
+    define_macro_list.Add(m);
+    define_value_list.Add(v);
+
+    if(m.Length()>define_macro_max_length)
+        define_macro_max_length=m.Length();
+
+    if(v.Length()>define_value_max_length)
+        define_value_max_length=v.Length();
+
+    return(true);
+}
+
+bool ShaderCreateInfo::ProcDefine()
+{
+    const uint count=define_macro_list.GetCount();
+
+    if(count<=0)return(true);
+
+    final_shader+="\n";
+
+    constexpr const char GLSL_DEFINE_FRONT[]="#define ";
+    constexpr const uint GLSL_DEFINE_FRONT_LENGTH=sizeof(GLSL_DEFINE_FRONT)-1;
+
+    const uint32_t total_length=GLSL_DEFINE_FRONT_LENGTH+define_macro_max_length+define_value_max_length+3;
+
+    char *tmp=new char[total_length];
+
+    memcpy(tmp,GLSL_DEFINE_FRONT,GLSL_DEFINE_FRONT_LENGTH);
+
+    uint macro_length;
+    uint value_length;
+
+    AnsiString m;
+    AnsiString v;
+
+    for(uint i=0;i<count;i++)
+    {
+        m=define_macro_list.GetString(i);
+        v=define_value_list.GetString(i);
+
+        macro_length=m.Length();
+        value_length=v.Length();
+
+        memcpy(tmp+GLSL_DEFINE_FRONT_LENGTH,m.c_str(),macro_length);
+
+        tmp[GLSL_DEFINE_FRONT_LENGTH+macro_length]=' ';
+
+        memcpy(tmp+GLSL_DEFINE_FRONT_LENGTH+macro_length+1,v.c_str(),value_length);
+
+        tmp[GLSL_DEFINE_FRONT_LENGTH+macro_length+1+value_length]='\n';
+
+        final_shader.Strcat(tmp,GLSL_DEFINE_FRONT_LENGTH+macro_length+value_length+2);
+    }
+
+    delete[] tmp;
+
+    return(true);
+}
+
 int ShaderCreateInfo::AddOutput(const VAT &type,const AnsiString &name,Interpolation inter)
 {
     ShaderAttribute *ss=new ShaderAttribute;
@@ -55,6 +122,8 @@ bool ShaderCreateInfo::ProcSubpassInput()
     if(sil.IsEmpty())
         return(true);
 
+    final_shader+="\n";
+
     auto si=sil.GetData();
     int si_count=sil.GetCount();
 
@@ -71,8 +140,6 @@ bool ShaderCreateInfo::ProcSubpassInput()
         ++si;
     }
 
-    final_shader+="\n";
-
     return(true);
 }
 
@@ -98,7 +165,7 @@ bool ShaderCreateInfo::ProcInput(ShaderCreateInfo *last_sc)
         return(true);
     }
 
-    final_shader+="layout(location=0) in ";
+    final_shader+="\nlayout(location=0) in ";
     final_shader+=last_output;
     final_shader+="Input;\n";
 
@@ -113,8 +180,6 @@ bool ShaderCreateInfo::ProcOutput()
 
     if(ssd.count<=0)return(true);
 
-    output_struct="\n";
-
     output_struct=GetShaderStageName(shader_stage);
     output_struct+="_Output\n{\n";
 
@@ -141,9 +206,9 @@ bool ShaderCreateInfo::ProcOutput()
 
     output_struct+="}";
 
-    final_shader+="layout(location=0) out ";
+    final_shader+="\nlayout(location=0) out ";
     final_shader+=output_struct;
-    final_shader+="Output;";
+    final_shader+="Output;\n";
 
     return(true);
 }
@@ -159,11 +224,11 @@ bool ShaderCreateInfo::ProcStruct()
         if(!mdi->GetStruct(*str,codes))
             return(false);
 
-        final_shader+="struct ";
+        final_shader+="\nstruct ";
         final_shader+=*str;
         final_shader+="\n{";
         final_shader+=codes;
-        final_shader+="};\n\n";
+        final_shader+="};\n";
     }
 
     return(true);
@@ -174,7 +239,7 @@ bool ShaderCreateInfo::ProcMI()
     if(mi_codes.IsEmpty())
         return(true);
 
-    final_shader+="struct MaterialInstance\n{\n";
+    final_shader+="\nstruct MaterialInstance\n{\n";
     final_shader+=mi_codes;
     final_shader+="\n};\n";
     return(true);
@@ -188,6 +253,8 @@ bool ShaderCreateInfo::ProcUBO()
 
     if(count<=0)return(true);
 
+    final_shader+="\n";
+
     auto ubo=ubo_list.GetData();
 
     AnsiString struct_codes;
@@ -214,7 +281,6 @@ bool ShaderCreateInfo::ProcUBO()
         ++ubo;
     }
 
-    final_shader+="\n";
     return(true);
 }
 
@@ -231,6 +297,8 @@ bool ShaderCreateInfo::ProcConst()
 
     if(count<=0)return(true);
 
+    final_shader+="\n";
+
     auto const_data=const_list.GetData();
 
     for(int i=0;i<count;i++)
@@ -248,7 +316,6 @@ bool ShaderCreateInfo::ProcConst()
         ++const_data;
     }
 
-    final_shader+="\n";
     return(true);
 }
 
@@ -260,6 +327,8 @@ bool ShaderCreateInfo::ProcSampler()
 
     if(count<=0)return(true);
 
+    final_shader+="\n";
+
     auto sampler=sampler_list.GetData();
 
     for(int i=0;i<count;i++)
@@ -277,7 +346,6 @@ bool ShaderCreateInfo::ProcSampler()
         ++sampler;
     }
 
-    final_shader+="\n";
     return(true);
 }
 
@@ -288,6 +356,8 @@ bool ShaderCreateInfo::CreateShader(ShaderCreateInfo *last_sc)
 
     final_shader="#version 460 core\n";
 
+    ProcDefine();
+
     if(!ProcSubpassInput())
         return(false);
     if(!ProcInput(last_sc))
@@ -310,11 +380,9 @@ bool ShaderCreateInfo::CreateShader(ShaderCreateInfo *last_sc)
 
     for(int i=0;i<function_list.GetCount();i++)
     {
-        final_shader+="\n";
         final_shader+=function_list[i];
     }
 
-    final_shader+="\n";
     final_shader+=main_function;
 
 #ifdef _DEBUG

src/ShaderGen/ShaderCreateInfoFragment.cpp

@@ -35,6 +35,8 @@ bool ShaderCreateInfoFragment::ProcOutput()
 
     const ShaderAttribute *o=output_list.items;
 
+        final_shader+="\n";
+
     for(uint i=0;i<output_list.count;i++)
     {
         final_shader+="layout(location=";

src/ShaderGen/common/MFCommon.h

@@ -22,18 +22,21 @@ mat4 GetJointMatrix()
             joint.mats[JointID.y]*JointWeight.y+
             joint.mats[JointID.z]*JointWeight.z+
             joint.mats[JointID.w]*JointWeight.w;
-})";
+}
+)";
 
     constexpr const char HandoverMI[]=R"(
 void HandoverMI()
 {
     Output.MaterialInstanceID=MaterialInstanceID;
-})";
+}
+)";
 
     constexpr const char GetMI[]=R"(
 MaterialInstance GetMI()
 {
     return mtl.mi[Input.MaterialInstanceID];
-})";
+}
+)";
 }//namespace func
 STD_MTL_NAMESPACE_END

src/ShaderGen/common/MFGetPosition.h

@@ -7,38 +7,50 @@ namespace func
 {
     constexpr const char *GetPosition2D[size_t(CoordinateSystem2D::RANGE_SIZE)]=
     {
-        R"(vec4 GetPosition2D()
+        R"(
+vec4 GetPosition2D()
 {
     return vec4(Position,0,1);
-})",
+}
+)",
 
-R"(vec4 GetPosition2D()
+R"(
+vec4 GetPosition2D()
 {
     return vec4(Position.xy*2-1,0,1);
-})",
+}
+)",
 
-R"(vec4 GetPosition2D()
+R"(
+vec4 GetPosition2D()
 {
     return viewport.ortho_matrix*vec4(Position,0,1);
-})"
+}
+)"
     };
 
     constexpr const char *GetPosition2DL2W[size_t(CoordinateSystem2D::RANGE_SIZE)]=
     {
-        R"(vec4 GetPosition2D()
+        R"(
+vec4 GetPosition2D()
 {
     return GetLocalToWorld()*vec4(Position,0,1);
-})",
+}
+)",
 
-R"(vec4 GetPosition2D()
+R"(
+vec4 GetPosition2D()
 {
     return GetLocalToWorld()*vec4(Position.xy*2-1,0,1);
-})",
+}
+)",
 
-R"(vec4 GetPosition2D()
+R"(
+vec4 GetPosition2D()
 {
     return GetLocalToWorld()*viewport.ortho_matrix*vec4(Position,0,1);
-})"
+}
+)"
     };
 }//namespace func
 STD_MTL_NAMESPACE_END