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

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.5)
 
 PROJECT(ULRE)
 
@@ -26,7 +26,7 @@ SET(ULRE    CMCore
             ULRE.Util
             ULRE.ShaderGen
             ULRE.SceneGraph
-            ${HGL_GLM_LIB}
+            ${HGL_MATH_LIB}
             ${RENDER_LIBRARY}
             ${Vulkan_LIBRARIES})
 

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();

example/Gizmo/MetricCellsGrid.cpp

@@ -104,7 +104,7 @@ private:
     {
         Add(material_instance,scale(PLANE_SIZE,PLANE_SIZE,1));
 
-        camera->pos=Vector3f(PLANE_SIZE/2,PLANE_SIZE/2,PLANE_SIZE/4);
+        camera->pos=Vector3f(PLANE_SIZE/4,PLANE_SIZE/2,PLANE_SIZE/4);
         camera_control->SetTarget(Vector3f(0,0,0));
         camera_control->Refresh();
 

example/Gizmo/PlaneGrid3D.cpp

@@ -19,7 +19,7 @@ private:
     Material *          material            =nullptr;
     Pipeline *          pipeline            =nullptr;
 
-    Primitive *         prim_plane_grid       =nullptr;
+    Primitive *         prim_plane_grid     =nullptr;
     MaterialInstance *  material_instance[3]{};
 
 private:

example/LightBasic/BlinnPhongDirectionLight.cpp

@@ -10,6 +10,7 @@
 #include<hgl/graph/VKVertexAttribBuffer.h>
 #include<hgl/graph/mtl/Material3DCreateConfig.h>
 #include<hgl/graph/mtl/BlinnPhong.h>
+#include<hgl/color/Color.h>
 
 using namespace hgl;
 using namespace hgl::graph;
@@ -24,6 +25,58 @@ static mtl::blinnphong::SunLight sun_light=
     Vector4f(1,0.95,0.9,1)  //color
 };
 
+constexpr const COLOR AxisColor[4]=
+{
+    COLOR::Red,     //X轴颜色
+    COLOR::Green,   //Y轴颜色
+    COLOR::Blue,    //Z轴颜色
+    COLOR::White    //全局颜色
+};
+
+class VertexDataManager
+{
+    uint                        vi_count;       ///<顶点输入流数量
+    const VertexInputFormat *   vif_list;       ///<顶点输入格式列表
+    
+    VkDeviceSize        vbo_max_size;   ///<顶点缓冲区分配空间大小
+    VkDeviceSize        vbo_cur_size;   ///<顶点缓冲区当前使用大小
+    VBO **              vbo;            ///<顶点缓冲区列表
+    
+    VkDeviceSize        ibo_cur_size;   ///<索引缓冲区当前使用大小
+    IndexBuffer *       ibo;            ///<索引缓冲区
+
+    struct DataOffset
+    {
+        VkDeviceSize vbo_start;
+        VkDeviceSize vbo_size;
+
+        VkDeviceSize ibo_start;
+        VkDeviceSize ibo_size;
+    };
+
+public:
+
+    VertexDataManager(const VIL &_vil)
+    {
+        vi_count=_vil.GetCount();
+        vif_list=_vil.GetVIFList();
+
+        vbo_max_size=0;
+        vbo_cur_size=0;
+        vbo=hgl_zero_new<VBO *>(vi_count);
+
+        ibo_cur_size=0;
+        ibo=nullptr;
+    }
+
+    const VkDeviceSize  GetVBOMaxCount()const{return vbo_max_size;}                                  ///<取得顶点缓冲区分配的空间最大数量
+    const VkDeviceSize  GetVBOCurCount()const{return vbo_cur_size;}                                  ///<取得顶点缓冲区当前数量
+
+    const IndexType     GetIBOType      ()const{return ibo?ibo->GetType():IndexType::ERR;}           ///<取得索引缓冲区类型
+    const VkDeviceSize  GetIBOMaxCount  ()const{return ibo?ibo->GetCount():-1;}                      ///<取得索引缓冲区分配的空间最大数量
+    const VkDeviceSize  GetIBOCurCount  ()const{return ibo?ibo_cur_size:-1;}                         ///<取得索引缓冲区当前数量
+};//class VertexDataManager
+
 class TestApp:public SceneAppFramework
 {
 private:    //plane grid
@@ -40,7 +93,7 @@ private:
 private:    //sphere
 
     Material *          mtl_blinnphong      =nullptr;
-    MaterialInstance *  mi_blinnphong       =nullptr;
+    MaterialInstance *  mi_blinnphong[4]{};
     Pipeline *          p_blinnphong        =nullptr;
 
     Primitive *         prim_sphere         =nullptr;
@@ -89,14 +142,14 @@ private:
         mtl_blinnphong->BindUBO(DescriptorSetType::Global,"sun",ubo_sun);
         mtl_blinnphong->Update();
 
-        float mi_data[4]=
+        Color4f mi_data;
+        for(uint i=0;i<4;i++)
         {
-            1,0,0,      //color
-            4           //gloss
-        };
+            mi_data=GetColor4f(AxisColor[i],4);
 
-        mi_blinnphong=db->CreateMaterialInstance(mtl_blinnphong,nullptr,&mi_data);
-        if(!mi_blinnphong)return(false);
+            mi_blinnphong[i]=db->CreateMaterialInstance(mtl_blinnphong,nullptr,&mi_data);
+            if(!mi_blinnphong[i])return(false);
+        }
 
         p_blinnphong=CreatePipeline(mtl_blinnphong,InlinePipeline::Solid3D,Prim::Triangles);
 
@@ -124,7 +177,7 @@ private:
         }
 
         //Sphere
-        prim_sphere=CreateSphere(db,mi_blinnphong->GetVIL(),16);
+        prim_sphere=CreateSphere(db,mi_blinnphong[0]->GetVIL(),16);
 
         //Cone
         {
@@ -135,7 +188,7 @@ private:
             cci.numberSlices=16;        //圆锥底部分割数
             cci.numberStacks=8;         //圆锥高度分割数
 
-            prim_cone=CreateCone(db,mi_blinnphong->GetVIL(),&cci);
+            prim_cone=CreateCone(db,mi_blinnphong[1]->GetVIL(),&cci);
         }
 
         //Cyliner
@@ -146,13 +199,13 @@ private:
             cci.numberSlices=16;        //圆柱底部分割数
             cci.radius      =0.25f;     //圆柱半径
 
-            prim_cylinder=CreateCylinder(db,mi_blinnphong->GetVIL(),&cci);
+            prim_cylinder=CreateCylinder(db,mi_blinnphong[2]->GetVIL(),&cci);
         }
 
         return(true);
     }    
     
-    Renderable *Add(Primitive *r,MaterialInstance *mi,Pipeline *p,const Matrix4f &mat)
+    Renderable *Add(Primitive *r,MaterialInstance *mi,Pipeline *p,const Matrix4f &mat=Identity4f)
     {
         Renderable *ri=db->CreateRenderable(r,mi,p);
 
@@ -171,9 +224,10 @@ private:
     {
         Add(prim_plane_grid,mi_plane_grid,p_line,Identity4f);
 
-        Add(prim_sphere,    mi_blinnphong,p_blinnphong,translate(Vector3f(0,0,2)));
-        Add(prim_cone,      mi_blinnphong,p_blinnphong,Identity4f);
-        Add(prim_cylinder,  mi_blinnphong,p_blinnphong,translate(Vector3f(0,0,-5)));        
+        Add(prim_sphere,    mi_blinnphong[0],p_blinnphong,translate(Vector3f(0,0,2)));
+
+        Add(prim_cone,      mi_blinnphong[1],p_blinnphong);
+        Add(prim_cylinder,  mi_blinnphong[2],p_blinnphong,translate(Vector3f(0,0,-5)));
 
         camera->pos=Vector3f(32,32,32);
         camera_control->SetTarget(Vector3f(0,0,0));

example/common/VulkanAppFramework.h

@@ -460,6 +460,7 @@ public:
     {
         camera=wc;
         cur_time=0;
+        last_time=0;
     }
 
     const Vector2f &GetMouseCoord()const{return mouse_pos;}

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/VK.h

@@ -144,6 +144,8 @@ enum IndexType:uint
     U16=0,
     U32,
     U8=VK_INDEX_TYPE_UINT8_EXT,
+
+    ERR=VK_INDEX_TYPE_MAX_ENUM
 };
 
 //Push Constant max-lengths:

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/VKCommandBufferRender.cpp

@@ -38,13 +38,10 @@ void RenderCmdBuffer::SetFBO(Framebuffer *fb)
         clear_values[cv_count-1].depthStencil.depth = 1.0f;
         clear_values[cv_count-1].depthStencil.stencil = 0;
     }
-    else
+    else if(clear_values)
     {
-        if(clear_values)
-        {
-            hgl_free(clear_values);
-            clear_values=nullptr;
-        }
+        hgl_free(clear_values);
+        clear_values=nullptr;
     }
 
     render_area.offset.x=0;

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/SceneGraph/Vulkan/VKRenderResource.cpp

@@ -161,6 +161,8 @@ Texture2DArray *RenderResource::CreateTexture2DArray(const AnsiString &name,cons
 
     if(ta)
         Add(ta);
+    else
+        return nullptr;
 
     #ifdef _DEBUG
         DebugUtils *du=device->GetDebugUtils();

src/SceneGraph/font/FontSourceMulti.cpp

@@ -9,9 +9,13 @@ namespace hgl
             default_source=fs;
 
             if(fs)
+            {
                 fs->RefAcquire(this);
 
-            max_char_height=fs->GetCharHeight();
+                max_char_height=fs->GetCharHeight();
+            }
+            else
+                max_char_height=0;
         }
 
         FontSourceMulti::~FontSourceMulti()

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/MaterialFileLoader.cpp

@@ -120,6 +120,8 @@ namespace
 
     public:
 
+        UBOParse()=default;
+
         void Clear()
         {
             hgl_zero(ubo_data);

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