[Milestone] new RenderWorkObject, rf_test run OK!

example/common/WorkManager.cpp

@@ -1,5 +1,6 @@
 #pragma once
 #include"WorkManager.h"
+#include<hgl/graph/VKRenderTarget.h>
 
 namespace hgl
 {
@@ -18,17 +19,33 @@ namespace hgl
     {
         double delta_time=cur_time-last_render_time;
 
-        if(delta_time>=frame_time)
+        if(delta_time>=frame_time||wo->IsRenderDirty())
         {
             last_render_time=cur_time;
             wo->Render(delta_time);
         }
     }
 
-    void WorkManager::Run()
+    void SwapchainWorkManager::Render(WorkObject *wo)
     {
-        if(!cur_work_object)
-            return;
+        graph::IRenderTarget *rt=swpachain_module->AcquireNextImage();
+
+        wo->MarkRenderDirty();      //临时的，未来会被更好的机制替代
+        WorkManager::Render(wo);
+
+        rt->WaitQueue();
+        rt->WaitFence();
+    }
+
+    void WorkManager::Run(WorkObject *wo)
+    {
+        if(!wo)return;
+
+        last_update_time=last_render_time=0;
+
+        cur_work_object=wo;
+
+        wo->Join(render_framework,render_framework->GetSwapchainRenderTarget());
 
         Window *win=render_framework->GetWindow();
         graph::GPUDevice *dev=render_framework->GetDevice();
@@ -50,17 +67,4 @@ namespace hgl
                 break;
         }
     }
-
-    void WorkManager::Start(WorkObject *wo)
-    {
-        if(!wo)return;
-
-        last_update_time=last_render_time=0;
-
-        cur_work_object=wo;
-
-        wo->Join(render_framework);
-
-        Run();
-    }
 }//namespcae hgl

example/common/WorkManager.h

@@ -3,6 +3,9 @@
 
 namespace hgl
 {
+    /**
+    * 工作管理器，管理一个序列的WorkObject<br>
+    */
     class WorkManager
     {
         graph::RenderFramework *render_framework;
@@ -35,10 +38,24 @@ namespace hgl
         }
 
         void Tick(WorkObject *wo);
-        void Render(WorkObject *wo);
 
-        void Run();
+        virtual void Render(WorkObject *wo);
 
-        void Start(WorkObject *wo);
+        void Run(WorkObject *wo);
     };//class WorkManager
+
+    class SwapchainWorkManager:public WorkManager
+    {
+        graph::SwapchainModule *swpachain_module;
+
+    public:
+
+        SwapchainWorkManager(graph::RenderFramework *rf):WorkManager(rf)
+        {
+            swpachain_module=rf->GetSwapchainModule();
+        }
+        ~SwapchainWorkManager()=default;
+
+        void Render(WorkObject *wo) override;
+    };
 }//namespcae hgl

example/common/WorkObject.h

@@ -2,18 +2,25 @@
 #include<hgl/graph/RenderFramework.h>
 #include<hgl/graph/module/SwapchainModule.h>
 #include<hgl/graph/VKRenderResource.h>
+#include<hgl/graph/VKRenderTarget.h>
 #include<hgl/type/object/TickObject.h>
 #include<hgl/Time.h>
+//#include<iostream>
 
 namespace hgl
 {
+    /**
+    * 工作对象</p>
+    */
     class WorkObject:public TickObject
     {
         graph::RenderFramework *render_framework=nullptr;
+        graph::IRenderTarget *cur_render_target=nullptr;
 
         bool destroy_flag=false;
 
         bool renderable=true;
+        bool render_dirty=true;
 
     protected:
 
@@ -29,27 +36,58 @@ namespace hgl
 
         const bool IsDestroy()const{return destroy_flag;}
         const bool IsRenderable()const{return renderable;}
+        const bool IsRenderDirty()const{return render_dirty;}
 
         void MarkDestory(){destroy_flag=true;}
         void SetRenderable(bool r){renderable=r;}
+        void MarkRenderDirty(){render_dirty=true;}
 
     public:
 
-        WorkObject(graph::RenderFramework *rf)
-        {
-            Join(rf);
-        }
+        WorkObject()=default;
         virtual ~WorkObject()=default;
 
-        virtual void Join(graph::RenderFramework *rf)
+        virtual void Join(graph::RenderFramework *rf,graph::IRenderTarget *rt)
         {
             if(!rf)return;
             if(render_framework==rf)return;
 
             render_framework=rf;
+            cur_render_target=rt;
             db=rf->GetRenderResource();
         }
 
-        virtual void Render(double delta_time)=0;
+        virtual void Render(double delta_time,graph::RenderCmdBuffer *cmd)=0;
+
+        virtual void Render(double delta_time)
+        {
+            if(!cur_render_target)
+            {
+                //std::cerr<<"WorkObject::Render,cur_render_target=nullptr"<<std::endl;
+                return;
+            }
+
+            //std::cout<<"WorkObject::Render begin, render_dirty="<<(render_dirty?"true":"false")<<std::endl;
+
+            if(render_dirty)
+            {
+                graph::RenderCmdBuffer *cmd=cur_render_target->BeginRender();
+
+                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;
+            }
+
+            //std::cout<<"WorkObject::Render End"<<std::endl;
+        }
     };//class WorkObject
 }//namespcae hgl