[OK] AutoInstance 范例完成迁移并测试成功。新结构下不再需要自己管理RenderList/SceneRoot。接下来请迁移其它范例。

example/Basic/auto_instance.cpp

@@ -29,14 +29,8 @@ constexpr uint8 color_data[VERTEX_COUNT][4]=
 
 class TestApp:public WorkObject
 {
-    Color4f             clear_color         =Color4f(0.2f,0.2f,0.2f,1.0f);
-
 private:
 
-    AutoDelete<RenderList>  render_list     =nullptr;
-
-    SceneNode           render_root;
-
     MaterialInstance *  material_instance   =nullptr;
     Mesh *              render_obj          =nullptr;
 
@@ -81,18 +75,16 @@ private:
         double rad;
         Matrix4f mat;
 
+        SceneNode *scene_root=GetSceneRoot();       ///<取得场景根节点
+        
         for(uint i=0;i<TRIANGLE_NUMBER;i++)
         {
             rad=deg2rad<double>((360.0f/double(TRIANGLE_NUMBER))*i);       //这里一定要加<float>或<float>，否则结果用int保存会出现问题
             mat=rotate(rad,Vector3f(0,0,1));
 
-            render_root.Add(new SceneNode(mat,render_obj));
+            scene_root->Add(new SceneNode(mat,render_obj));
         }
 
-        render_root.RefreshMatrix();
-
-        render_list->Expend(&render_root);
-
         return(true);
     }
 
@@ -102,10 +94,7 @@ public:
 
     bool Init() override
     {
-        render_list=GetRenderFramework()->CreateRenderList();
+        GetRenderer()->SetClearColor(Color4f(0.2f,0.2f,0.2f,1.0f));
-
-        if(!render_list)
-            return(false);
 
         if(!InitMaterial())
             return(false);
@@ -115,15 +104,6 @@ public:
 
         return(true);
     }
-
-    void Render(double delta_time,graph::RenderCmdBuffer *cmd)override
-    {
-        cmd->SetClearColor(0,clear_color);
-
-        cmd->BeginRenderPass();
-            render_list->Render(cmd);
-        cmd->EndRenderPass();
-    }
 };//class TestApp:public WorkObject
 
 int os_main(int,os_char **)

inc/hgl/WorkObject.h

@@ -4,6 +4,7 @@
 #include<hgl/graph/VKRenderResource.h>
 #include<hgl/graph/mtl/MaterialLibrary.h>
 #include<hgl/graph/Renderer.h>
+#include<hgl/graph/Scene.h>
 #include<hgl/Time.h>
 //#include<iostream>
 
@@ -22,8 +23,6 @@ namespace hgl
     class WorkObject:public TickObject
     {
         graph::RenderFramework *render_framework=nullptr;
-        graph::IRenderTarget *cur_render_target=nullptr;
-        graph::RenderPass *render_pass=nullptr;
 
         bool destroy_flag=false;
         bool render_dirty=true;
@@ -44,7 +43,12 @@ namespace hgl
         graph::VulkanDevAttr *      GetDevAttr          (){return render_framework->GetDevAttr();}
         graph::TextureManager *     GetTextureManager   (){return render_framework->GetTextureManager();}
 
-        const VkExtent2D &          GetExtent2D         (){return cur_render_target->GetExtent();}
+        const VkExtent2D &          GetExtent           (){return renderer->GetExtent();}
+
+        graph::Scene *              GetScene            (){return scene;}
+        graph::SceneNode *          GetSceneRoot        (){return scene->GetRootNode();}
+
+        graph::Renderer *           GetRenderer         (){return renderer;}
 
     public:
 
@@ -56,19 +60,17 @@ namespace hgl
 
     public:
 
-        WorkObject(graph::RenderFramework *,graph::IRenderTarget *rt=nullptr);
+        WorkObject(graph::RenderFramework *,graph::Renderer *r=nullptr);
         virtual ~WorkObject()=default;
 
         virtual bool Init()=0;
 
-        virtual void OnRenderTargetSwitch(graph::RenderFramework *rf,graph::IRenderTarget *rt);
+        virtual void OnRendererChange(graph::RenderFramework *rf,graph::Renderer *r);
         
         virtual void OnResize(const VkExtent2D &){}
 
         virtual void Tick(double){}
 
-        virtual void Render(double delta_time,graph::RenderCmdBuffer *cmd)=0;
-
         virtual void Render(double delta_time);
 
     public:
@@ -76,7 +78,7 @@ namespace hgl
         template<typename ...ARGS>
         graph::Pipeline *CreatePipeline(ARGS...args)
         {
-            return render_pass->CreatePipeline(args...);
+            return renderer->GetRenderPass()->CreatePipeline(args...);
         }
 
         graph::MaterialInstance *CreateMaterialInstance(const AnsiString &mi_name,const graph::mtl::MaterialCreateInfo *mci,const graph::VILConfig *vil_cfg=nullptr)

inc/hgl/graph/RenderFramework.h

@@ -55,6 +55,8 @@ protected:
     Scene *                 default_scene   =nullptr;
     Renderer *              default_renderer=nullptr;
 
+    void CreateDefaultRenderer();
+
 public:
 
             Window *            GetWindow           ()const{return win;}

inc/hgl/graph/Renderer.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include<hgl/graph/RenderTask.h>
+#include<hgl/graph/VKRenderTarget.h>
 #include<hgl/type/Map.h>
 
 namespace hgl::graph
@@ -15,7 +16,7 @@ namespace hgl::graph
     class Renderer
     {
         IRenderTarget *render_target;
-        Scene *world;
+        Scene *scene;
 
         Camera *camera;
 
@@ -24,23 +25,31 @@ namespace hgl::graph
 
         RenderTask *render_task;                                                ///<当前渲染任务
 
-    protected:
+        Color4f clear_color;                                                    ///<清屏颜色
-
 
+        bool build_frame=false;
 
     public:
 
-        Scene *GetScene   () const { return world; }                  ///<获取场景世界
+                RenderPass *GetRenderPass   (){return render_target->GetRenderPass();}      ///<取得当前渲染器RenderPass
-        Camera *    GetCurCamera    () const { return camera; }                 ///<获取当前相机
+
+        const   VkExtent2D &GetExtent       ()const{return render_target->GetExtent();}     ///<取得当前渲染器画面尺寸
+
+                Scene *     GetScene        ()const{return scene;}                          ///<获取场景世界
+                Camera *    GetCurCamera    ()const{return camera;}                         ///<获取当前相机
 
     public:
 
         Renderer(IRenderTarget *);
         virtual ~Renderer();
 
-        void SetCurWorld(Scene *);
+        void SetRenderTarget(IRenderTarget *);
+        void SetCurScene(Scene *);
         void SetCurCamera(Camera *);
 
-        bool RenderFrame(RenderCmdBuffer *);
+        void SetClearColor(const Color4f &c){clear_color=c;}
+
+        bool RenderFrame();                                                                ///<重新重成这一帧的CommandList
+        bool Submit();                                                                      ///<提交CommandList到GPU
     };//class Renderer
 }//namespace hgl::graph

src/SceneGraph/RenderFramework.cpp

@@ -5,9 +5,12 @@
 #include<hgl/graph/module/TextureManager.h>
 #include<hgl/graph/module/RenderTargetManager.h>
 #include<hgl/graph/module/SwapchainModule.h>
+#include<hgl/graph/VKRenderTargetSwapchain.h>
 #include<hgl/graph/module/RenderModule.h>
 #include<hgl/graph/VKRenderResource.h>
 #include<hgl/graph/VKCommandBuffer.h>
+#include<hgl/graph/Scene.h>
+#include<hgl/graph/Renderer.h>
 #include<hgl/log/Logger.h>
 #include<hgl/Time.h>
 
@@ -47,6 +50,8 @@ RenderFramework::RenderFramework(const OSString &an)
 
 RenderFramework::~RenderFramework()
 {
+    SAFE_CLEAR(default_renderer)
+    SAFE_CLEAR(default_scene)
     SAFE_CLEAR(render_resource)
     SAFE_CLEAR(module_manager)
 
@@ -117,14 +122,28 @@ bool RenderFramework::Init(uint w,uint h)
 
     render_resource=new RenderResource(device);
 
+    default_scene=new Scene;
+
+    CreateDefaultRenderer();
+
     return(true);
 }
 
+void RenderFramework::CreateDefaultRenderer()
+{
+    SAFE_CLEAR(default_renderer)
+
+    default_renderer=new Renderer(GetSwapchainRenderTarget());
+    default_renderer->SetCurScene(default_scene);
+}
+
 void RenderFramework::OnResize(uint w,uint h)
 {
     VkExtent2D ext(w,h);
 
     sc_module->OnResize(ext);        //其实swapchain_module并不需要传递尺寸数据过去
+
+    CreateDefaultRenderer();
 }
 
 void RenderFramework::OnActive(bool)

src/SceneGraph/render/Renderer.cpp

@@ -7,43 +7,55 @@ namespace hgl::graph
     Renderer::Renderer(IRenderTarget *rt)
     {
         render_target=rt;
-        world=nullptr;
+        scene=nullptr;
-        render_task=new RenderTask("TempRenderTask");
+        camera=nullptr;
+        render_task=new RenderTask("DefaultRenderTask",rt);
+
+        clear_color.Set(0,0,0,1);
     }
 
     Renderer::~Renderer()
     {
         delete render_task;
-        delete world;
     }
 
-    void Renderer::SetCurWorld(Scene *sw)
+    void Renderer::SetRenderTarget(IRenderTarget *rt)
     {
-        if(world==sw)
+        if(render_target==rt)
             return;
 
-        //if(world)
+        render_target=rt;
+
+        render_task->Set(rt);
+    }
+
+    void Renderer::SetCurScene(Scene *sw)
+    {
+        if(scene==sw)
+            return;
+
+        //if(scene)
         //{
-        //    world->Unjoin(this);
+        //    scene->Unjoin(this);
         //}
 
-        world=sw;
+        scene=sw;
 
-        //if(world)
+        //if(scene)
         //{
-        //    world->Join(this);
+        //    scene->Join(this);
         //}
     }
 
     void Renderer::SetCurCamera(Camera *c)
     {
-        if(!world||!c)
+        if(!scene||!c)
             return;
 
         //if(camera)
         //{
-        //    if(world)
+        //    if(scene)
-        //        camera->Unjoin(world);
+        //        camera->Unjoin(scene);
 
         //    camera->Unjoin(this);
         //}
@@ -52,19 +64,19 @@ namespace hgl::graph
 
         //if(camera)
         //{
-        //    if(world)
+        //    if(scene)
-        //        camera->Unjoin(world);
+        //        camera->Unjoin(scene);
 
         //    camera->Join(this);
         //}
     }
 
-    bool Renderer::RenderFrame(RenderCmdBuffer *cmd)
+    bool Renderer::RenderFrame()
     {
-        if(!world)
+        if(!scene)
             return(false);
 
-        SceneNode *root=world->GetRootNode();
+        SceneNode *root=scene->GetRootNode();
 
         if(!root)
             return(false);
@@ -75,10 +87,29 @@ namespace hgl::graph
 
         bool result=false;
 
+        graph::RenderCmdBuffer *cmd=render_target->BeginRender();
+
+        cmd->SetClearColor(0,clear_color);
+
         cmd->BeginRenderPass();
             result=render_task->Render(cmd);
         cmd->EndRenderPass();
 
+        render_target->EndRender();
+
+        build_frame=result;
+
         return(result);
     }
+
+    bool Renderer::Submit()
+    {
+        if(!render_target)
+            return(false);
+
+        if(!build_frame)
+            return(false);
+
+        return render_target->Submit();
+    }
 }//namespace hgl::graph

src/Work/WorkManager.cpp

@@ -32,9 +32,7 @@ namespace hgl
 
         VkExtent2D ext={w,h};
 
-        graph::IRenderTarget *rt=render_framework->GetSwapchainRenderTarget();
+        cur_work_object->OnRendererChange(render_framework,render_framework->GetDefaultRenderer());
-
-        cur_work_object->OnRenderTargetSwitch(render_framework,rt);
         cur_work_object->OnResize(ext);
     }
 
@@ -63,7 +61,7 @@ namespace hgl
 
         cur_work_object=wo;
 
-        wo->OnRenderTargetSwitch(render_framework,render_framework->GetSwapchainRenderTarget());
+        wo->OnRendererChange(render_framework,render_framework->GetDefaultRenderer());
 
         Window *win=render_framework->GetWindow();
         graph::VulkanDevice *dev=render_framework->GetDevice();

src/Work/WorkObject.cpp

@@ -11,15 +11,15 @@
 
 namespace hgl
 {
-    WorkObject::WorkObject(graph::RenderFramework *rf,graph::IRenderTarget *rt)
+    WorkObject::WorkObject(graph::RenderFramework *rf,graph::Renderer *r)
     {
-        if(!rt)
+        if(!r)
-            rt=rf->GetSwapchainRenderTarget();
+            renderer=rf->GetDefaultRenderer();
 
-        OnRenderTargetSwitch(rf,rt);
+        OnRendererChange(rf,renderer);
     }
 
-    void WorkObject::OnRenderTargetSwitch(graph::RenderFramework *rf,graph::IRenderTarget *rt)
+    void WorkObject::OnRendererChange(graph::RenderFramework *rf,graph::Renderer *r)
     {
         if(!rf)
         {
@@ -27,20 +27,12 @@ namespace hgl
             db=nullptr;
         }
 
-        if(!rt)
+        if(!rf||!r)
-        {
-            cur_render_target=nullptr;
-            render_pass=nullptr;
-        }
-
-        if(!rf||!rt)
         {
             return;
         }
 
         render_framework=rf;
-        cur_render_target=rt;
-        render_pass=rt->GetRenderPass();
 
         db=rf->GetRenderResource();
         scene=rf->GetDefaultScene();
@@ -49,9 +41,9 @@ namespace hgl
 
     void WorkObject::Render(double delta_time)
     {
-        if(!cur_render_target)
+        if(!renderer)
         {
-            //std::cerr<<"WorkObject::Render,cur_render_target=nullptr"<<std::endl;
+            //std::cerr<<"WorkObject::Render,renderer=nullptr"<<std::endl;
             return;
         }
 
@@ -59,22 +51,13 @@ namespace hgl
 
         if(render_dirty)
         {
-            graph::RenderCmdBuffer *cmd=cur_render_target->BeginRender();
+            renderer->RenderFrame();
-
-            if(!cmd)
-            {
-                //std::cerr<<"WorkObject::Render,cur_render_target->BeginRender()=nullptr"<<std::endl;
-                return;
-            }
-
-            Render(delta_time,cmd);
-
-            cur_render_target->EndRender();
-            cur_render_target->Submit();
 
             render_dirty=false;
         }
 
+        renderer->Submit();
+
         //std::cout<<"WorkObject::Render End"<<std::endl;
     }