[WIP] Renderer/RenderTask

inc/hgl/WorkObject.h

@@ -3,6 +3,7 @@
 #include<hgl/graph/RenderFramework.h>
 #include<hgl/graph/VKRenderResource.h>
 #include<hgl/graph/mtl/MaterialLibrary.h>
+#include<hgl/graph/Renderer.h>
 #include<hgl/Time.h>
 //#include<iostream>
 
@@ -26,12 +27,18 @@ namespace hgl
 
         bool destroy_flag=false;
 
-        bool renderable=true;
-        bool render_dirty=true;
-
     protected:
 
-        graph::RenderResource *db=nullptr;          //暂时的，未来会被更好的机制替代
+        graph::RenderResource *db=nullptr;                  //暂时的，未来会被更好的机制替代
+
+        /**
+        * 不管我们的游戏多么的复杂，一般在一个WorkObject中，都只需要一个SceneWorld以及一个Renderer即可。
+        * 如果我们整体切换World，那么建议直接切换到新的WorkObject上。
+        */
+
+        graph::SceneWorld * world   =nullptr;               //世界
+
+        graph::Renderer *   renderer=nullptr;               //渲染器
 
     public:
 
@@ -44,13 +51,8 @@ namespace hgl
 
     public:
 
-        const bool IsDestroy()const{return destroy_flag;}
+        const   bool IsDestroy  ()const{return destroy_flag;}
-        const bool IsRenderable()const{return renderable;}
+                void MarkDestory(){destroy_flag=true;}
-        const bool IsRenderDirty()const{return render_dirty;}
-
-        void MarkDestory(){destroy_flag=true;}
-        void SetRenderable(bool r){renderable=r;}
-        void MarkRenderDirty(){render_dirty=true;}
 
     public:
 

inc/hgl/graph/RenderFramework.h

@@ -27,7 +27,7 @@ class RenderFramework:public io::WindowEvent
     Window *                win                 =nullptr;
     VulkanInstance *        inst                =nullptr;
 
-    VulkanDevice *             device              =nullptr;
+    VulkanDevice *          device              =nullptr;
 
     RenderResource *        render_resource     =nullptr;
 
@@ -49,13 +49,13 @@ protected:
 
 public:
 
-            Window *                GetWindow           ()const{return win;}
+            Window *            GetWindow           ()const{return win;}
-            VulkanDevice *             GetDevice           ()const{return device;}
+            VulkanDevice *      GetDevice           ()const{return device;}
-            VkDevice                GetVkDevice         ()const{return device->GetDevice();}
+            VkDevice            GetVkDevice         ()const{return device->GetDevice();}
-    const   VulkanPhyDevice *     GetPhyDevice   ()const{return device->GetPhyDevice();}
+    const   VulkanPhyDevice *   GetPhyDevice        ()const{return device->GetPhyDevice();}
-            VulkanDevAttr *    GetDevAttr  ()const{return device->GetDevAttr();}
+            VulkanDevAttr *     GetDevAttr          ()const{return device->GetDevAttr();}
 
-            RenderResource *        GetRenderResource   ()const{return render_resource;}
+            RenderResource *    GetRenderResource   ()const{return render_resource;}
 
 public:
 

inc/hgl/graph/RenderTask.h

@@ -20,8 +20,8 @@ namespace hgl::graph
     {
         RenderTaskName  task_name;
 
-        RenderList *    render_list;
         IRenderTarget * render_target;
+        RenderList *    render_list;
         Camera *        camera;
 
     public:
@@ -34,32 +34,16 @@ namespace hgl::graph
 
     public:
 
-        RenderTask(const RenderTaskName &tn)
+        RenderTask(const RenderTaskName &tn,IRenderTarget *rt=nullptr,Camera *c=nullptr);
-        {
-            task_name=tn;
-
-            render_list=nullptr;
-            render_target=nullptr;
-            camera=nullptr;
-        }
-
-        RenderTask(const RenderTaskName &tn,RenderList *rl,IRenderTarget *rt=nullptr,Camera *c=nullptr)
-        {
-            task_name=tn;
-
-            render_list=rl;
-            render_target=rt;
-            camera=c;
-        }
 
         virtual ~RenderTask();
 
-        void Set(IRenderTarget *rt){render_target=rt;}
+        bool Set(IRenderTarget *rt);
         void Set(Camera *c){camera=c;}
 
         void Restart();                             ///<复位数据，清空渲染列表
 
-        void MakeRenderList(SceneNode *);
+        bool RebuildRenderList(SceneNode *);
 
         bool IsEmpty()const;                        ///<是否是空的，不可渲染或是没啥可渲染的
 

inc/hgl/graph/Renderer.h

@@ -11,17 +11,36 @@ namespace hgl::graph
 
     /**
     * 渲染器
-    * 管理相对的所有的渲染资源，包括场景、相机、渲染目标、渲染任务等
     */
     class Renderer
     {
+        IRenderTarget *render_target;
         SceneWorld *world;
 
-        RenderTaskNameMap static_render_task_list;                              ///<静态渲染任务列表
+        Camera *camera;
-        RenderTaskNameMap dynamic_render_task_list;                             ///<动态渲染任务列表
+
+        //RenderTaskNameMap static_render_task_list;                              ///<静态渲染任务列表
+        //RenderTaskNameMap dynamic_render_task_list;                             ///<动态渲染任务列表
+
+        RenderTask *render_task;                                                ///<当前渲染任务
+
+    protected:
+
+
 
     public:
 
+        SceneWorld *GetSceneWorld   () const { return world; }                  ///<获取场景世界
+        Camera *    GetCurCamera    () const { return camera; }                 ///<获取当前相机
 
+    public:
+
+        Renderer(IRenderTarget *);
+        virtual ~Renderer();
+
+        void SetCurWorld(SceneWorld *);
+        void SetCurCamera(Camera *);
+
+        bool RenderFrame(RenderCmdBuffer *);
     };//class Renderer
 }//namespace hgl::graph

src/SceneGraph/render/RenderTask.cpp

@@ -1,13 +1,47 @@
 #include<hgl/graph/RenderTask.h>
 #include<hgl/graph/RenderList.h>
+#include<hgl/graph/VKCommandBuffer.h>
+#include<hgl/graph/VKRenderTarget.h>
 
 namespace hgl::graph
 {
+    RenderTask::RenderTask(const RenderTaskName &tn,IRenderTarget *rt,Camera *c)
+    {
+        task_name=tn;
+
+        camera=c;
+        render_target=nullptr;
+        render_list=nullptr;
+
+        Set(rt);
+    }
+
     RenderTask::~RenderTask()
     {
         SAFE_CLEAR(render_list)
     }
 
+    bool RenderTask::Set(IRenderTarget *rt)
+    {
+        if(render_target)
+        {
+            if(render_target->GetDevice()!=rt->GetDevice())
+            {
+                //换Device是不允许的，当然这一般也不可能
+                return(false);
+            }
+        }
+
+        render_target=rt;
+
+        if(!render_list)
+        {
+            render_list=new RenderList(rt->GetDevice());
+        }
+
+        return(true);
+    }
+
     void RenderTask::Restart()
     {
         if(!render_list)
@@ -16,16 +50,18 @@ namespace hgl::graph
         render_list->Clear();
     }
 
-    void RenderTask::MakeRenderList(SceneNode *root)
+    bool RenderTask::RebuildRenderList(SceneNode *root)
     {
         if(!root)
-            return;
+            return(false);
 
         if(!render_list)
-            return;
+            return(false);
 
         render_list->Clear();
         render_list->Expend(root);
+
+        return(true);
     }
 
     bool RenderTask::IsEmpty()const
@@ -41,6 +77,9 @@ namespace hgl::graph
         if(!cmd)
             return(false);
 
+        if(!render_target)
+            return(false);
+
         if(!render_list)
             return(false);
 

src/SceneGraph/render/Renderer.cpp

@@ -0,0 +1,84 @@
+#include<hgl/graph/Renderer.h>
+#include<hgl/graph/SceneWorld.h>
+#include<hgl/graph/VKCommandBuffer.h>
+
+namespace hgl::graph
+{
+    Renderer::Renderer(IRenderTarget *rt)
+    {
+        render_target=rt;
+        world=nullptr;
+        render_task=new RenderTask("TempRenderTask");
+    }
+
+    Renderer::~Renderer()
+    {
+        delete render_task;
+        delete world;
+    }
+
+    void Renderer::SetCurWorld(SceneWorld *sw)
+    {
+        if(world==sw)
+            return;
+
+        //if(world)
+        //{
+        //    world->Unjoin(this);
+        //}
+
+        world=sw;
+
+        //if(world)
+        //{
+        //    world->Join(this);
+        //}
+    }
+
+    void Renderer::SetCurCamera(Camera *c)
+    {
+        if(!world||!c)
+            return;
+
+        //if(camera)
+        //{
+        //    if(world)
+        //        camera->Unjoin(world);
+
+        //    camera->Unjoin(this);
+        //}
+
+        camera=c;
+
+        //if(camera)
+        //{
+        //    if(world)
+        //        camera->Unjoin(world);
+
+        //    camera->Join(this);
+        //}
+    }
+
+    bool Renderer::RenderFrame(RenderCmdBuffer *cmd)
+    {
+        if(!world)
+            return(false);
+
+        SceneNode *root=world->GetRootNode();
+
+        if(!root)
+            return(false);
+
+        root->RefreshMatrix();
+
+        render_task->RebuildRenderList(root);
+
+        bool result=false;
+
+        cmd->BeginRenderPass();
+            result=render_task->Render(cmd);
+        cmd->EndRenderPass();
+
+        return(result);
+    }
+}//namespace hgl::graph