first finished SceneTreeToRenderList.

inc/hgl/graph/SceneTreeToRenderList.h

@@ -5,10 +5,17 @@
 #include<hgl/graph/VKPipeline.h>
 #include<hgl/graph/VKMaterial.h>
 #include<hgl/graph/VKMaterialInstance.h>
+
+using RenderNodePointer=hgl::graph::RenderNode *;
+
+using RenderNodeComparator=Comparator<RenderNodePointer>;
+
 namespace hgl
 {
     namespace graph
     {
+        using MVPArrayBuffer=GPUArrayBuffer<MVPMatrix>;
+
         class SceneTreeToRenderList
         {
             using PipelineSets  =Sets<Pipeline *>;
@@ -26,23 +33,24 @@ namespace hgl
 
         protected:
         
-            RenderNodeList *render_node_list;       ///<场景节点列表
+            RenderNodeComparator render_node_comparator;
 
-            PipelineSets    pipeline_sets;          ///<管线合集
+            RenderNodeList  render_node_list;       ///<场景节点列表
-            MaterialSets    material_sets;          ///<材质合集
+
-            MatInstSets     mat_inst_sets;          ///<材质实例合集
+            //PipelineSets    pipeline_sets;          ///<管线合集
+            //MaterialSets    material_sets;          ///<材质合集
+            //MatInstSets     mat_inst_sets;          ///<材质实例合集
+
+            MVPArrayBuffer *mvp_array;
+            List<RenderableInstance *> ri_list;
 
             RenderList *    render_list;
 
         protected:
 
-            virtual int     Comp(RenderNode *,RenderNode *);                                  ///<摄像机距离比较函数
-
-//            virtual bool    InFrustum(const SceneNode *,void *);                                    ///<平截头截剪函数
-
             virtual bool    Begin();
             virtual bool    Expend(SceneNode *);
-            virtual bool    End();
+            virtual void    End();
 
         public:
 

src/SceneGraph/SceneTreeToRenderList.cpp

@@ -1,41 +1,25 @@
 #include<hgl/graph/SceneTreeToRenderList.h>
 #include<hgl/graph/VKRenderableInstance.h>
+#include<hgl/util/sort/Sort.h>
 
-namespace hgl
+/**
+* 理论上讲，我们需要按以下顺序排序
+*
+* for(material)
+*   for(pipeline)
+*       for(material_instance)
+*           for(vbo)
+*               for(distance)
+*/
+
+template<> 
+int Comparator<RenderNodePointer>::compare(const RenderNodePointer &obj_one,const RenderNodePointer &obj_two) const
 {
-    namespace graph
-    {    
-        SceneTreeToRenderList::SceneTreeToRenderList(GPUDevice *d)
-        {
-            device=d;
-            hgl_zero(camera_info);
-
-            render_node_list=nullptr;
-            render_list=nullptr;
-        }
-
-        SceneTreeToRenderList::~SceneTreeToRenderList()
-        {
-            SAFE_CLEAR(render_node_list);
-        }
-        
-        /**
-        * 理论上讲，我们需要按以下顺序排序
-        *
-        * for(material)
-        *   for(pipeline)
-        *       for(material_instance)
-        *           for(vbo)
-        *               for(distance)
-        */
-
-        int SceneTreeToRenderList::Comp(RenderNode *obj_one,RenderNode *obj_two)
-        {
     int off;
 
     //比较材质
-            MaterialInstance *mi1=obj_one->ri->GetMaterialInstance();
+    hgl::graph::MaterialInstance *mi1=obj_one->ri->GetMaterialInstance();
-            MaterialInstance *mi2=obj_two->ri->GetMaterialInstance();
+    hgl::graph::MaterialInstance *mi2=obj_two->ri->GetMaterialInstance();
                        
     off=mi1->GetMaterial()-mi2->GetMaterial();
 
@@ -43,8 +27,8 @@ namespace hgl
         return off;
             
     //比较管线
-            Pipeline *p1=obj_one->ri->GetPipeline();
+    hgl::graph::Pipeline *p1=obj_one->ri->GetPipeline();
-            Pipeline *p2=obj_two->ri->GetPipeline();
+    hgl::graph::Pipeline *p2=obj_two->ri->GetPipeline();
 
     off=p1-p2;
 
@@ -65,32 +49,88 @@ namespace hgl
         return off;
 
     //比较距离
-            return( obj_one->distance_to_camera_square-
+    {
-                    obj_two->distance_to_camera_square);
+        const double dist=obj_one->distance_to_camera_square-
+                          obj_two->distance_to_camera_square;
+
+        //由于距离差距可能会小于1，但又返回int，所以需要做如此处理
+
+        if(dist>0)return  1;else
+        if(dist<0)return -1;
     }
 
-        //bool SceneTreeToRenderList::InFrustum(const SceneNode *,void *)
+    return 0;
-        //{
+}
-        //    return(true);
+
-        //}
+namespace hgl
+{
+    namespace graph
+    {
+        SceneTreeToRenderList::SceneTreeToRenderList(GPUDevice *d)
+        {
+            device=d;
+            hgl_zero(camera_info);
+            
+            mvp_array   =new MVPArrayBuffer(device,VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
+            render_list =nullptr;
+        }
+
+        SceneTreeToRenderList::~SceneTreeToRenderList()
+        {
+            delete mvp_array;
+        }
 
         bool SceneTreeToRenderList::Begin()
         {
-            if(!render_node_list)
+            render_node_list.ClearData();
-                render_node_list=new RenderNodeList;
+            mvp_array->Clear();
+            ri_list.ClearData();
 
-            render_node_list->ClearData();
+            //pipeline_sets.ClearData();
-
+            //material_sets.ClearData();
-            pipeline_sets.ClearData();
+            //mat_inst_sets.ClearData();
-            material_sets.ClearData();
-            mat_inst_sets.ClearData();
 
             return(true);
         }
 
-        bool SceneTreeToRenderList::End()
+        void SceneTreeToRenderList::End()
         {
+            if(render_node_list.GetCount()<=0)return;
 
+            //排序
+            Sort(render_node_list,&render_node_comparator);
+
+            //产生MVP矩阵UBO数据
+            {
+                const uint32_t count=render_node_list.GetCount();
+
+                {
+                    //按当前总节点数量分配UBO
+                    mvp_array->Alloc(count);
+                    mvp_array->Clear();
+
+                    ri_list.SetCount(count);
+                }
+
+                {
+                    const uint32_t unit_offset=mvp_array->GetUnitSize();
+                    
+                    char *mp=(char *)(mvp_array->Map(0,count));
+                    RenderableInstance **ri=ri_list.GetData();
+
+                    for(RenderNode *node:render_node_list)                  //未来可能要在Expend处考虑做去重
+                    {
+                        memcpy(mp,&(node->matrix),sizeof(MVPMatrix));
+                        mp+=unit_offset;
+
+                        (*ri)=node->ri;
+                        ++ri;
+                    }
+                }
+            }
+
+            //写入RenderList
+            render_list->Set(mvp_array->GetBuffer(),&ri_list);
         }
 
         bool SceneTreeToRenderList::Expend(SceneNode *sn)
@@ -101,6 +141,8 @@ namespace hgl
             {
                 RenderNode *rn=new RenderNode;
 
+                rn->matrix.Set(sn->GetLocalToWorldMatrix(),camera_info.vp);
+
                 rn->WorldCenter=sn->GetWorldCenter();
 
                 rn->distance_to_camera_square=length_squared(rn->WorldCenter,camera_info.pos);
@@ -108,7 +150,7 @@ namespace hgl
 
                 rn->ri=sn->render_obj;
 
-                render_node_list->Add(rn);
+                render_node_list.Add(rn);
             }
 
             for(SceneNode *sub:sn->SubNode)