split to two class they are RenderL2WBuffer and RenderMIBuffer from RenderAssignBuffer, two sample program RUN OK!

example/Basic/auto_merge_material_instance.cpp

@@ -95,7 +95,7 @@ private:
             if(!render_obj[i].r)
                 return(false);
 
-            render_root.CreateSubNode(rotate(deg2rad(360/DRAW_OBJECT_COUNT*i),Vector3f(0,0,1)),render_obj[i].r);
+            render_root.CreateSubNode(rotate(deg2rad(double(360/DRAW_OBJECT_COUNT*i)),Vector3f(0,0,1)),render_obj[i].r);
         }
 
         render_root.RefreshMatrix();

inc/hgl/graph/MaterialRenderList.h

@@ -3,7 +3,8 @@
 #include<hgl/graph/VKVBOList.h>
 
 VK_NAMESPACE_BEGIN
-class RenderAssignBuffer;
+class RenderL2WBuffer;
+class RenderMIBuffer;
 
 /**
 * 同一材质的对象渲染列表
@@ -19,7 +20,8 @@ class MaterialRenderList
 
 private:
 
-    RenderAssignBuffer *assign_buffer;
+    RenderL2WBuffer *l2w_buffer;
+    RenderMIBuffer *mi_buffer;
 
     struct RenderItem
     {
@@ -39,6 +41,8 @@ private:
     DataArray<RenderItem> ri_array;
     uint ri_count;
 
+    VkDeviceSize l2w_buffer_size[4];
+
     void StatMI();
     void Stat();
 
@@ -56,7 +60,7 @@ protected:
 
 public:
 
-    MaterialRenderList(GPUDevice *d,Material *m);
+    MaterialRenderList(GPUDevice *d,bool l2w,Material *m);
     ~MaterialRenderList();
 
     void Add(Renderable *ri,const Matrix4f &mat);

inc/hgl/graph/VKMaterial.h

@@ -69,7 +69,6 @@ public:
             }
 
     const   bool                                hasSet                  (const DescriptorSetType &type)const;
-    const   bool                                hasAssign               ()const;
 
     const   VIL *                               GetDefaultVIL()const;
             VIL *                               CreateVIL(const VILConfig *format_map=nullptr);

inc/hgl/graph/VKMemoryAllocator.h

@@ -35,6 +35,8 @@ public:
     void Free() override {/* DON'T RUN ANY OPERATION.*/}
 
     void Flush(const VkDeviceSize);
+
+    bool Write(const void *source,const uint64 offset,const uint64 size) override;
 };//class VKMemoryAllocator:public AbstractMemoryAllocator
 VK_NAMESPACE_END
 #endif//HGL_GRAPH_VULKAN_MEMORY_ALLOCATOR_INCLUDE

inc/hgl/graph/mtl/UBOCommon.h

@@ -45,15 +45,6 @@ constexpr const ShaderBufferSource SBS_CameraInfo=
 // UBO必须严格指定数组的大小
 // SSBO则不需要，使用[]方式指定为动态大小数组
 
-constexpr const ShaderBufferSource SBS_LocalToWorld=
-{
-    "LocalToWorldData",
-    "l2w",
-
-    R"(
-    mat4 mats[L2W_MAX_COUNT];)"
-};
-
 constexpr const char MaterialInstanceStruct[]="MaterialInstance";
 
 constexpr const ShaderBufferSource SBS_MaterialInstance=

inc/hgl/shadergen/MaterialCreateInfo.h

@@ -34,8 +34,6 @@ namespace hgl{namespace graph
             UBODescriptor *mi_ubo;
 
             uint32_t l2w_shader_stage;
-            uint32_t l2w_max_count;
-            UBODescriptor *l2w_ubo;
 
             ShaderCreateInfoMap shader_map;                         ///<着色器列表
 

inc/hgl/shadergen/ShaderCreateInfo.h

@@ -84,8 +84,6 @@ public:
     void SetMaterialInstance(UBODescriptor *,const AnsiString &);
     void AddMaterialInstanceOutput();
 
-    void SetLocalToWorld(UBODescriptor *);
-
     void SetMain(const AnsiString &str){main_function=str;}
     void SetMain(const char *str,const int len)
     {

inc/hgl/shadergen/ShaderCreateInfoVertex.h

@@ -21,8 +21,9 @@ namespace hgl
 
             int hasInput(const char *);
 
+            void AddLocalToWorld();
+            void AddMaterialInstanceID();
             void AddJoint();
-            void AddAssign();
         };//class ShaderCreateInfoVertex:public ShaderCreateInfo
     }//namespace graph
 }//namespace hgl::graph

src/SceneGraph/MaterialRenderList.cpp

@@ -47,16 +47,21 @@ int Comparator<hgl::graph::RenderNode>::compare(const hgl::graph::RenderNode &ob
 }
 
 VK_NAMESPACE_BEGIN
-MaterialRenderList::MaterialRenderList(GPUDevice *d,Material *m)
+MaterialRenderList::MaterialRenderList(GPUDevice *d,bool l2w,Material *m)
 {
     device=d;
     cmd_buf=nullptr;
     material=m;
 
-    if(material->hasAssign())
-        assign_buffer=new RenderAssignBuffer(d,material->GetMIDataBytes());
+    if(l2w)
+        l2w_buffer=new RenderL2WBuffer(device);
     else
-        assign_buffer=nullptr;
+        l2w_buffer=nullptr;
+
+    if(material->HasMI())
+        mi_buffer=new RenderMIBuffer(device,material->GetMIDataBytes());
+    else
+        mi_buffer=nullptr;
 
     vbo_list=new VBOList(material->GetVertexInput()->GetCount());
 }
@@ -64,7 +69,8 @@ MaterialRenderList::MaterialRenderList(GPUDevice *d,Material *m)
 MaterialRenderList::~MaterialRenderList()
 {
     SAFE_CLEAR(vbo_list);
-    SAFE_CLEAR(assign_buffer)
+    SAFE_CLEAR(mi_buffer);
+    SAFE_CLEAR(l2w_buffer);
 }
 
 void MaterialRenderList::Add(Renderable *ri,const Matrix4f &mat)
@@ -88,13 +94,15 @@ void MaterialRenderList::End()
 
     Stat();
 
-    if(assign_buffer)
+    if(l2w_buffer)
     {
-        if(material->HasMI())
-            StatMI();
+        l2w_buffer->WriteNode(rn_list.GetData(),node_count);
+    }
 
-        //写入LocalToWorld数据
-        assign_buffer->WriteNode(rn_list.GetData(),node_count,mi_set);
+    if(mi_buffer)
+    {
+        StatMI();
+        mi_buffer->WriteNode(rn_list.GetData(),node_count,mi_set);
     }
 }
 
@@ -179,6 +187,17 @@ bool MaterialRenderList::Bind(const VertexInputData *vid,const uint ri_index)
         vbo_list->Add(vid->buffer_list,vid->buffer_offset,vid->binding_count);
     }
 
+    if(l2w_buffer)//LocalToWorld组，由RenderList合成
+    {
+        for(uint i=0;i<4;i++)
+            l2w_buffer_size[i]=ri_index*16;                        //mat4每列都是rgba32f，自然是16字节
+
+        vbo_list->Add(l2w_buffer->GetVBO(),l2w_buffer_size,4);
+    }
+
+    if(mi_buffer) //材质实例组
+        vbo_list->Add(mi_buffer->GetVBO(),MI_VBO_STRIDE_BYTES*ri_index);
+
     //if(!vbo_list.IsFull()) //Joint组，暂未支持
     //{
     //    const uint joint_id_binding_count=vil->GetCount(VertexInputGroup::JointID);
@@ -207,12 +226,6 @@ bool MaterialRenderList::Bind(const VertexInputData *vid,const uint ri_index)
     //    }
     //}
 
-    //if(!vbo_list->IsFull()) //Assign组
-    {
-        if(assign_buffer)
-            vbo_list->Add(assign_buffer->GetAssignVBO(),ASSIGN_VBO_STRIDE_BYTES*ri_index);
-    }
-
     //if(count!=binding_count)
     //{
     //    //还有没支持的绑定组？？？？
@@ -273,8 +286,8 @@ void MaterialRenderList::Render(RenderCmdBuffer *rcb)
     last_pipeline   =nullptr;
     last_vid        =nullptr;
 
-    if(assign_buffer)
-        assign_buffer->Bind(material);
+    if(mi_buffer)
+        mi_buffer->Bind(material);
 
     cmd_buf->BindDescriptorSets(material);
 

src/SceneGraph/RenderAssignBuffer.cpp

@@ -8,54 +8,130 @@
 #include<hgl/graph/mtl/UBOCommon.h>
 
 VK_NAMESPACE_BEGIN
-RenderAssignBuffer::RenderAssignBuffer(GPUDevice *dev,const uint mi_bytes)
+RenderL2WBuffer::RenderL2WBuffer(GPUDevice *dev)
 {
     hgl_zero(*this);
 
     device=dev;
-
-    mi_data_bytes=mi_bytes;
-
-    ubo_mi=nullptr;
-    mi_count=0;
 }
 
-VkBuffer RenderAssignBuffer::GetAssignVBO()const
+void RenderL2WBuffer::Clear()
 {
-    return vbo_assigns->GetBuffer();
-}
-
-void RenderAssignBuffer::Bind(Material *mtl)const
-{
-    if(!mtl)return;
-
-    if(!mtl->hasAssign())
-        return;
-
-    mtl->BindUBO(DescriptorSetType::PerFrame,mtl::SBS_LocalToWorld.name,ubo_l2w);
-    mtl->BindUBO(DescriptorSetType::PerMaterial,mtl::SBS_MaterialInstance.name,ubo_mi);
-}
-
-void RenderAssignBuffer::Clear()
-{
-    SAFE_CLEAR(ubo_l2w);
-    SAFE_CLEAR(ubo_mi);
-    SAFE_CLEAR(vbo_assigns);
+    SAFE_CLEAR(l2w_vbo[0])
+    SAFE_CLEAR(l2w_vbo[1])
+    SAFE_CLEAR(l2w_vbo[2])
+    SAFE_CLEAR(l2w_vbo[3])
 
     node_count=0;
-    mi_count=0;
 }
 
-void RenderAssignBuffer::Alloc(const uint nc,const uint mc)
+#ifdef _DEBUG
+namespace
+{
+    constexpr const char *l2w_buffer_name[]=
+    {
+        "VBO:Buffer:LocalToWorld:0",
+        "VBO:Buffer:LocalToWorld:1",
+        "VBO:Buffer:LocalToWorld:2",
+        "VBO:Buffer:LocalToWorld:3"
+    };
+
+    constexpr const char *l2w_memory_name[]=
+    {
+        "VBO:Memory:LocalToWorld:0",
+        "VBO:Memory:LocalToWorld:1",
+        "VBO:Memory:LocalToWorld:2",
+        "VBO:Memory:LocalToWorld:3"
+    };
+}
+#endif//_DEBUG
+
+void RenderL2WBuffer::Alloc(const uint nc)
 {
     Clear();
 
     {
         node_count=nc;
 
-        ubo_l2w=device->CreateUBO(node_count*sizeof(Matrix4f));
+        for(uint i=0;i<4;i++)
+        {
+            l2w_vbo[i]=device->CreateVBO(VF_V4F,node_count);
+            l2w_buffer[i]=l2w_vbo[i]->GetBuffer();
+        }
     }
 
+#ifdef _DEBUG
+    DebugUtils *du=device->GetDebugUtils();
+
+    if(du)
+    {
+        for(int i=0;i<4;i++)
+        {
+            du->SetBuffer(l2w_buffer[i],l2w_buffer_name[i]);
+            du->SetDeviceMemory(l2w_vbo[i]->GetVkMemory(),l2w_memory_name[i]);
+        }
+    }
+#endif//_DEBUG
+}
+
+void RenderL2WBuffer::WriteNode(RenderNode *render_node,const uint count)
+{
+    RenderNode *rn;
+
+    Alloc(count);
+
+    glm::vec4 *tp;
+
+    for(uint col=0;col<4;col++)
+    {
+        tp=(glm::vec4 *)(l2w_vbo[col]->Map());
+
+        rn=render_node;
+
+        for(uint i=0;i<count;i++)
+        {
+            *tp=rn->local_to_world[col];
+            ++tp;
+            ++rn;
+        }
+
+        l2w_vbo[col]->Unmap();
+    }
+}
+VK_NAMESPACE_END
+
+VK_NAMESPACE_BEGIN
+RenderMIBuffer::RenderMIBuffer(GPUDevice *dev,const uint mi_bytes)
+{
+    hgl_zero(*this);
+
+    device=dev;
+
+    mi_data_bytes=mi_bytes;
+}
+
+void RenderMIBuffer::Bind(Material *mtl)const
+{
+    if(!mtl)return;
+
+    mtl->BindUBO(DescriptorSetType::PerMaterial,mtl::SBS_MaterialInstance.name,ubo_mi);
+}
+
+void RenderMIBuffer::Clear()
+{
+    SAFE_CLEAR(ubo_mi);
+    SAFE_CLEAR(vbo_mi);
+
+    mi_count=0;
+    node_count=0;
+}
+
+void RenderMIBuffer::Alloc(const uint nc,const uint mc)
+{
+    Clear();
+
+    node_count=nc;
+
     if(mi_data_bytes>0&&mc>0)
     {
         mi_count=mc;
@@ -63,72 +139,53 @@ void RenderAssignBuffer::Alloc(const uint nc,const uint mc)
         ubo_mi=device->CreateUBO(mi_data_bytes*mi_count);
     }
 
-    vbo_assigns=device->CreateVBO(ASSIGN_VBO_FMT,node_count);
+    vbo_mi=device->CreateVBO(MI_VBO_FMT,node_count);
+    mi_buffer=vbo_mi->GetBuffer();
 
     #ifdef _DEBUG
         DebugUtils *du=device->GetDebugUtils();
         
         if(du)
         {
-            du->SetBuffer(ubo_l2w->GetBuffer(),"UBO:Buffer:LocalToWorld");
-            du->SetDeviceMemory(ubo_l2w->GetVkMemory(),"UBO:Memory:LocalToWorld");
+            du->SetBuffer(ubo_mi->GetBuffer(),"UBO:Buffer:MaterialInstance");
+            du->SetDeviceMemory(ubo_mi->GetVkMemory(),"UBO:Memory:MaterialInstance");
 
-            if(ubo_mi)
-            {
-                du->SetBuffer(ubo_mi->GetBuffer(),"UBO:Buffer:MaterialInstance");
-                du->SetDeviceMemory(ubo_mi->GetVkMemory(),"UBO:Memory:MaterialInstance");
-            }
-
-            du->SetBuffer(vbo_assigns->GetBuffer(),"VBO:Buffer:Assign");
-            du->SetDeviceMemory(vbo_assigns->GetVkMemory(),"VBO:Memory:Assign");
+            du->SetBuffer(vbo_mi->GetBuffer(),"VBO:Buffer:MaterialInstanceID");
+            du->SetDeviceMemory(vbo_mi->GetVkMemory(),"VBO:Memory:MaterialInstanceID");
         }
     #endif//_DEBUG
 }
 
-void RenderAssignBuffer::WriteNode(RenderNode *render_node,const uint count,const MaterialInstanceSets &mi_set)
+void RenderMIBuffer::WriteNode(RenderNode *render_node,const uint count,const MaterialInstanceSets &mi_set)
 {
     RenderNode *rn;
 
     Alloc(count,mi_set.GetCount());
 
-    if(ubo_mi)
+    uint8 *mip=(uint8 *)(ubo_mi->Map());
+
+    for(MaterialInstance *mi:mi_set)
     {
-        uint8 *mip=(uint8 *)(ubo_mi->Map());
-
-        for(MaterialInstance *mi:mi_set)
-        {
-            memcpy(mip,mi->GetMIData(),mi_data_bytes);
-            mip+=mi_data_bytes;
-        }
-
-        ubo_mi->Unmap();
+        memcpy(mip,mi->GetMIData(),mi_data_bytes);
+        mip+=mi_data_bytes;
     }
 
-    uint16 *idp=(uint16 *)(vbo_assigns->Map());
+    ubo_mi->Unmap();
+
+    uint16 *idp=(uint16 *)(vbo_mi->Map());
 
     {
-        Matrix4f *tp=(hgl::Matrix4f *)(ubo_l2w->Map());
-        Matrix4f *l2w=tp;
-
         rn=render_node;
 
         for(uint i=0;i<count;i++)
         {
-            *l2w=rn->local_to_world;
-            ++l2w;
-
-            *idp=i;
-            ++idp;
-
             *idp=mi_set.Find(rn->ri->GetMaterialInstance());
             ++idp;
 
             ++rn;
         }
-
-        ubo_l2w->Unmap();
     }
 
-    vbo_assigns->Unmap();
+    vbo_mi->Unmap();
 }
 VK_NAMESPACE_END

src/SceneGraph/RenderAssignBuffer.h

@@ -25,24 +25,50 @@ VK_NAMESPACE_BEGIN
 struct RenderNode;
 class MaterialInstance;
 
+class RenderL2WBuffer
+{
+    GPUDevice *device;
+
+    uint node_count;                    ///<渲染节点数量
+
+    VBO *l2w_vbo[4];
+    VkBuffer l2w_buffer[4];
+
+private:
+
+    void Alloc(const uint nc);
+
+    void Clear();
+
+public:
+
+    const VkBuffer *GetVBO()const{return l2w_buffer;}
+
+public:
+
+    RenderL2WBuffer(GPUDevice *dev);
+    ~RenderL2WBuffer(){Clear();}
+
+    void WriteNode(RenderNode *render_node,const uint count);
+};//class RenderL2WBuffer
+
 /*
 * 渲染节点额外提供的数据
 */
-class RenderAssignBuffer
+class RenderMIBuffer
 {
 private:
 
     GPUDevice *device;
 
     uint node_count;                    ///<渲染节点数量
-    DeviceBuffer *ubo_l2w;              ///<Local2World数据
 
     uint32_t mi_data_bytes;             ///<材质实例数据字节数
     uint32_t mi_count;                  ///<材质实例数量
     DeviceBuffer *ubo_mi;               ///<材质实例数据
     
-    //Assign VBO
-    VBO *vbo_assigns;                   ///<RG16UI格式的VertexInputStream,,,,X:L2W ID,Y:MI ID
+    VBO *vbo_mi;                        ///<材质实例ID(R16UI格式)
+    VkBuffer mi_buffer;
 
 private:
 
@@ -52,16 +78,20 @@ private:
 
 public:
 
-    VkBuffer GetAssignVBO()const;
+    const VkBuffer GetVBO()const{return mi_buffer;}
 
     void Bind(Material *)const;
 
 public:
 
-    RenderAssignBuffer(GPUDevice *dev,const uint32_t mi_bytes);
-    ~RenderAssignBuffer(){Clear();}
+    RenderMIBuffer(GPUDevice *dev,const uint32_t mi_bytes);
+    ~RenderMIBuffer(){Clear();}
 
-    void WriteNode(RenderNode *render_node,const uint count,const MaterialInstanceSets &mi_set);
+    //下一代，将MaterialInstanceSets使用提前化，这样不用每一次绘制都重新写入MI DATA，可以提升效率。
+    //虽然这样就不自动化了，但我们要的就是不自动化。
+    //必须在外部全部准备好MaterialInstanceSets，然后一次性写入。
+    //渲染时找不到就直接用0号材质实例
 
-};//struct RenderAssignBuffer
+    void WriteNode(RenderNode *render_node,const uint nc,const MaterialInstanceSets &mi_set);
+};//struct RenderMIBuffer
 VK_NAMESPACE_END

src/SceneGraph/RenderList.cpp

@@ -35,7 +35,7 @@ namespace hgl
 
                 if(!mrl_map.Get(mtl,mrl))
                 {
-                    mrl=new MaterialRenderList(device,mtl);
+                    mrl=new MaterialRenderList(device,true,mtl);
 
                     mrl_map.Add(mtl,mrl);
                 }

src/SceneGraph/Vulkan/VKMaterial.cpp

@@ -47,11 +47,6 @@ const bool Material::hasSet(const DescriptorSetType &dst)const
     return desc_manager->hasSet(dst);
 }
 
-const bool Material::hasAssign()const
-{
-    return vertex_input->hasAssign();
-}
-
 const VIL *Material::GetDefaultVIL()const
 {
     return vertex_input->GetDefaultVIL();

src/SceneGraph/Vulkan/VKMemoryAllocator.cpp

@@ -45,4 +45,12 @@ void VKMemoryAllocator::Flush(const VkDeviceSize size)
 {
     gpu_buffer->Flush(size);
 }
+
+bool VKMemoryAllocator::Write(const void *source,const uint64 offset,const uint64 size)
+{
+    if(!source||size==0)
+        return(false);
+
+    return gpu_buffer->Write(source,offset,size);
+}
 VK_NAMESPACE_END

src/ShaderGen/2d/M_PureColor2D.cpp

@@ -39,6 +39,7 @@ void main()
             if(!Std2DMaterial::CustomVertexShader(vsc))
                 return(false);
 
+            vsc->AddMaterialInstanceID();
             vsc->SetMain(vs_main);
             return(true);
         }

src/ShaderGen/2d/Std2DMaterial.cpp

@@ -16,10 +16,9 @@ bool Std2DMaterial::CustomVertexShader(ShaderCreateInfoVertex *vsc)
 
     if(cfg->local_to_world)
     {
+        vsc->AddLocalToWorld();
         mci->SetLocalToWorld(VK_SHADER_STAGE_ALL_GRAPHICS);
 
-        vsc->AddAssign();
-
         if(is_rect)
             vsc->AddFunction(func::GetPosition2DRectL2W[size_t(cfg->coordinate_system)]);
         else

src/ShaderGen/2d/Std2DMaterialLoader.cpp

@@ -76,6 +76,9 @@ namespace
             for(auto &ua:mfd->vi)
                 vsc->AddInput(ua.vat,ua.name);
 
+            if(mfd->mi.mi_bytes>0)
+                vsc->AddMaterialInstanceID();
+
             if(!Std2DMaterial::CustomVertexShader(vsc))
                 return(false);
 

src/ShaderGen/3d/Std3DMaterial.cpp

@@ -24,7 +24,7 @@ bool Std3DMaterial::CustomVertexShader(ShaderCreateInfoVertex *vsc)
     {
         mci->SetLocalToWorld(VK_SHADER_STAGE_ALL_GRAPHICS);
 
-        vsc->AddAssign();
+        vsc->AddLocalToWorld();
         vsc->AddFunction(cfg->camera?func::GetPosition3DL2WCamera:func::GetPosition3DL2W);
     }
     else

src/ShaderGen/3d/Std3DMaterialLoader.cpp

@@ -1,121 +1,125 @@
-#include "MaterialFileData.h"
-#include "Std3DMaterial.h"
-#include <hgl/shadergen/MaterialCreateInfo.h>
+#include"MaterialFileData.h"
+#include"Std3DMaterial.h"
+#include<hgl/shadergen/MaterialCreateInfo.h>
 
 STD_MTL_NAMESPACE_BEGIN
 
 const char *GetUBOCodes(const AccumMemoryManager::Block *block);
 
-namespace {
-class Std3DMaterialLoader : public Std3DMaterial 
+namespace
 {
-protected:
-
-    material_file::MaterialFileData *mfd;
-
-public:
-
-    Std3DMaterialLoader(material_file::MaterialFileData* data, const Material3DCreateConfig* cfg)
-        : Std3DMaterial(cfg)
+    class Std3DMaterialLoader: public Std3DMaterial
     {
-        mfd = data;
-    }
+    protected:
 
-    ~Std3DMaterialLoader()
-    {
-        delete mfd;
-    }
+        material_file::MaterialFileData *mfd;
 
-    bool BeginCustomShader() override
-    {
-        if (!Std3DMaterial::BeginCustomShader())
-            return (false);
+    public:
 
-        for(const auto ubo:mfd->ubo_list)
+        Std3DMaterialLoader(material_file::MaterialFileData *data,const Material3DCreateConfig *cfg)
+            : Std3DMaterial(cfg)
         {
-            const char *ubo_codes=GetUBOCodes(ubo.block);
-
-            mci->AddStruct(ubo.struct_name,ubo_codes);
-
-            mci->AddUBO(ubo.shader_stage_flag_bits,
-                        ubo.set,
-                        ubo.struct_name,
-                        ubo.name);
+            mfd=data;
         }
 
-        if (mfd->mi.mi_bytes > 0)
+        ~Std3DMaterialLoader()
         {
-            mci->SetMaterialInstance(   mfd->mi.code,
-                                        mfd->mi.mi_bytes,
-                                        mfd->mi.shader_stage_flag_bits);
+            delete mfd;
         }
 
-        return true;
-    }
+        bool BeginCustomShader() override
+        {
+            if(!Std3DMaterial::BeginCustomShader())
+                return (false);
 
-    material_file::ShaderData* CommonProc(VkShaderStageFlagBits ss, ShaderCreateInfo* sc)
-    {
-        material_file::ShaderData* sd = mfd->shader[ss];
+            for(const auto ubo:mfd->ubo_list)
+            {
+                const char *ubo_codes=GetUBOCodes(ubo.block);
 
-        if (!sd)
-            return (nullptr);
+                mci->AddStruct(ubo.struct_name,ubo_codes);
 
-        for (auto& ua : sd->output)
-            sc->AddOutput(ua.vat, ua.name);
+                mci->AddUBO(ubo.shader_stage_flag_bits,
+                            ubo.set,
+                            ubo.struct_name,
+                            ubo.name);
+            }
 
-        for (auto& s : sd->sampler)
-            mci->AddSampler(ss, DescriptorSetType::PerMaterial, s.type, s.name);
+            if(mfd->mi.mi_bytes>0)
+            {
+                mci->SetMaterialInstance(mfd->mi.code,
+                                         mfd->mi.mi_bytes,
+                                         mfd->mi.shader_stage_flag_bits);
+            }
 
-        sc->SetMain(sd->code, sd->code_length); // 这里会产生复制这个string，但我不希望产生这个。未来想办法改进
+            return true;
+        }
 
-        return sd;
-    }
+        material_file::ShaderData *CommonProc(VkShaderStageFlagBits ss,ShaderCreateInfo *sc)
+        {
+            material_file::ShaderData *sd=mfd->shader[ss];
 
-    bool CustomVertexShader(ShaderCreateInfoVertex* vsc) override
-    {
-        for (auto& ua : mfd->vi)
-            vsc->AddInput(ua.vat, ua.name);
+            if(!sd)
+                return (nullptr);
 
-        if (!Std3DMaterial::CustomVertexShader(vsc))
-            return (false);
+            for(auto &ua:sd->output)
+                sc->AddOutput(ua.vat,ua.name);
 
-        return CommonProc(VK_SHADER_STAGE_VERTEX_BIT, vsc);
-    }
+            for(auto &s:sd->sampler)
+                mci->AddSampler(ss,DescriptorSetType::PerMaterial,s.type,s.name);
 
-    bool CustomGeometryShader(ShaderCreateInfoGeometry* gsc) override
-    {
-        material_file::GeometryShaderData* sd = (material_file::GeometryShaderData*)CommonProc(VK_SHADER_STAGE_GEOMETRY_BIT, gsc);
+            sc->SetMain(sd->code,sd->code_length); // 这里会产生复制这个string，但我不希望产生这个。未来想办法改进
 
-        if (!sd)
-            return (false);
+            return sd;
+        }
 
-        gsc->SetGeom(sd->input_prim, sd->output_prim, sd->max_vertices);
+        bool CustomVertexShader(ShaderCreateInfoVertex *vsc) override
+        {
+            for(auto &ua:mfd->vi)
+                vsc->AddInput(ua.vat,ua.name);
 
-        return true;
-    }
+            if(mfd->mi.mi_bytes>0)
+                vsc->AddMaterialInstanceID();
 
-    bool CustomFragmentShader(ShaderCreateInfoFragment* fsc) override
-    {
-        return CommonProc(VK_SHADER_STAGE_FRAGMENT_BIT, fsc);
-    }
-}; // class Std3DMaterialLoader:public Std3DMaterial
+            if(!Std3DMaterial::CustomVertexShader(vsc))
+                return (false);
+
+            return CommonProc(VK_SHADER_STAGE_VERTEX_BIT,vsc);
+        }
+
+        bool CustomGeometryShader(ShaderCreateInfoGeometry *gsc) override
+        {
+            material_file::GeometryShaderData *sd=(material_file::GeometryShaderData *)CommonProc(VK_SHADER_STAGE_GEOMETRY_BIT,gsc);
+
+            if(!sd)
+                return (false);
+
+            gsc->SetGeom(sd->input_prim,sd->output_prim,sd->max_vertices);
+
+            return true;
+        }
+
+        bool CustomFragmentShader(ShaderCreateInfoFragment *fsc) override
+        {
+            return CommonProc(VK_SHADER_STAGE_FRAGMENT_BIT,fsc);
+        }
+    }; // class Std3DMaterialLoader:public Std3DMaterial
 } // namespace
 
-material_file::MaterialFileData* LoadMaterialDataFromFile(const AnsiString& mtl_filename);
+material_file::MaterialFileData *LoadMaterialDataFromFile(const AnsiString &mtl_filename);
 
-MaterialCreateInfo* LoadMaterialFromFile(const AnsiString& name, Material3DCreateConfig* cfg)
+MaterialCreateInfo *LoadMaterialFromFile(const AnsiString &name,Material3DCreateConfig *cfg)
 {
-    if (name.IsEmpty() || !cfg)
+    if(name.IsEmpty()||!cfg)
         return (nullptr);
 
-    material_file::MaterialFileData* mfd = LoadMaterialDataFromFile(name);
+    material_file::MaterialFileData *mfd=LoadMaterialDataFromFile(name);
 
-    if (!mfd)
+    if(!mfd)
         return nullptr;
 
-    cfg->shader_stage_flag_bit = mfd->shader_stage_flag_bit;
+    cfg->shader_stage_flag_bit=mfd->shader_stage_flag_bit;
 
-    Std3DMaterialLoader mtl(mfd, cfg);
+    Std3DMaterialLoader mtl(mfd,cfg);
 
     return mtl.Create();
 }

src/ShaderGen/MaterialCreateInfo.cpp

@@ -26,13 +26,6 @@ MaterialCreateInfo::MaterialCreateInfo(const MaterialCreateConfig *mc)
         mi_max_count=0;
         mi_ubo=nullptr;
     }
-
-    {
-        l2w_max_count=hgl_min<uint32_t>(ubo_range/sizeof(Matrix4f),HGL_U16_MAX);
-
-        l2w_shader_stage=0;
-        l2w_ubo=nullptr;
-    }
 }
 
 bool MaterialCreateInfo::AddStruct(const AnsiString &struct_name,const AnsiString &codes)
@@ -205,27 +198,6 @@ bool MaterialCreateInfo::SetLocalToWorld(const uint32_t shader_stage_flag_bits)
 {
     if(shader_stage_flag_bits==0)return(false);
 
-    mdi.AddStruct(SBS_LocalToWorld);
-
-    l2w_ubo=CreateUBODescriptor(SBS_LocalToWorld,shader_stage_flag_bits);
-
-    mdi.AddUBO(shader_stage_flag_bits,DescriptorSetType::PerFrame,l2w_ubo);
-
-    const AnsiString L2W_MAX_COUNT=AnsiString::numberOf(l2w_max_count);
-
-    auto *it=shader_map.GetDataList();
-
-    for(int i=0;i<shader_map.GetCount();i++)
-    {
-        if((*it)->key&shader_stage_flag_bits)
-        {
-            (*it)->value->AddDefine("L2W_MAX_COUNT",L2W_MAX_COUNT);
-            (*it)->value->SetLocalToWorld(l2w_ubo);
-        }
-
-        ++it;
-    }
-
     l2w_shader_stage=shader_stage_flag_bits;
 
     return(true);

src/ShaderGen/ShaderCreateInfo.cpp

@@ -156,10 +156,10 @@ bool ShaderCreateInfo::ProcSubpassInput()
 
 namespace
 {
-    constexpr const char MF_GetMI_VS    []="\nMaterialInstance GetMI(){return mtl.mi[Assign.y];}\n";
+    constexpr const char MF_GetMI_VS    []="\nMaterialInstance GetMI(){return mtl.mi[MaterialInstanceID];}\n";
     constexpr const char MF_GetMI_Other []="\nMaterialInstance GetMI(){return mtl.mi[Input.MaterialInstanceID];}\n";
 
-    constexpr const char MF_HandoverMI_VS[]=    "\nvoid HandoverMI(){Output.MaterialInstanceID=Assign.y;}\n";
+    constexpr const char MF_HandoverMI_VS[]=    "\nvoid HandoverMI(){Output.MaterialInstanceID=MaterialInstanceID;}\n";
     constexpr const char MF_HandoverMI_GS[]=    "\nvoid HandoverMI(){Output.MaterialInstanceID=Input[0].MaterialInstanceID;}\n";
     constexpr const char MF_HandoverMI_OTHER[]= "\nvoid HandoverMI(){Output.MaterialInstanceID=Input.MaterialInstanceID;}\n";
 }//namespace
@@ -183,11 +183,6 @@ void ShaderCreateInfo::AddMaterialInstanceOutput()
                                                     AddFunction(MF_HandoverMI_OTHER);
 }
 
-void ShaderCreateInfo::SetLocalToWorld(UBODescriptor *ubo)
-{
-    sdm->AddUBO(DescriptorSetType::PerFrame,ubo);
-}
-
 bool ShaderCreateInfo::ProcInput(ShaderCreateInfo *last_sc)
 {
     if(!last_sc)

src/ShaderGen/ShaderCreateInfoVertex.cpp

@@ -50,19 +50,39 @@ void ShaderCreateInfoVertex::AddJoint()
 
 namespace
 {
-    constexpr const char MF_GetLocalToWorld[]="\nmat4 GetLocalToWorld(){return l2w.mats[Assign.x];}\n";
+    constexpr const char MF_GetLocalToWorld[]=R"(
+mat4 GetLocalToWorld()
+{
+    return mat4(LocalToWorld_0,
+                LocalToWorld_1,
+                LocalToWorld_2,
+                LocalToWorld_3);
+}
+)";
 }
 
-void ShaderCreateInfoVertex::AddAssign()
+void ShaderCreateInfoVertex::AddLocalToWorld()
 {
-    AddInput(   ASSIGN_VAT_FMT,
-                ASSIGN_VIS_NAME,
-                VK_VERTEX_INPUT_RATE_INSTANCE,
-                VertexInputGroup::Assign);
+    char name[]= "LocalToWorld_?";
+
+    for(uint i=0;i<4;i++)
+    {
+        name[sizeof(name)-2]='0'+i;
+
+        AddInput(VAT_VEC4,name,VK_VERTEX_INPUT_RATE_INSTANCE,VertexInputGroup::LocalToWorld);
+    }
 
     AddFunction(MF_GetLocalToWorld);
 }
 
+void ShaderCreateInfoVertex::AddMaterialInstanceID()
+{
+    AddInput(   MI_VAT_FMT,
+                MI_VIS_NAME,
+                VK_VERTEX_INPUT_RATE_INSTANCE,
+                VertexInputGroup::MaterialInstanceID);
+}
+
 bool ShaderCreateInfoVertex::ProcInput(ShaderCreateInfo *)
 {    
     const auto &input=sdm->GetShaderStageIO().input;

src/ShaderGen/common/MFCommon.h

@@ -9,5 +9,14 @@ namespace func
 
     constexpr const char MaterialInstanceID[]="MaterialInstanceID";
 
+    constexpr const char GetLocalToWorld[]=R"(
+mat4 GetLocalToWorld()
+{
+    return mat4(LocalToWorld_0,
+                LocalToWorld_1,
+                LocalToWorld_2,
+                LocalToWorld_3);
+}
+)";
 }//namespace func
 STD_MTL_NAMESPACE_END