hyzboy/ULRE
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

created ULRE.Work contains WorkObject/WorkManager

Browse Source
This commit is contained in:
hyzboy
2025-01-28 20:48:43 +08:00
parent dd0cf9bf51
commit 93e38fc14f
10 changed files with 69 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
example/common/WorkManager.cpp
View File

@@ -1,70 +0,0 @@
#pragma once
#include"WorkManager.h"
#include<hgl/graph/VKRenderTarget.h>
namespace hgl
{
void WorkManager::Tick(WorkObject *wo)
{
double delta_time=cur_time-last_update_time;
if(delta_time>=frame_time)
{
last_update_time=cur_time;
wo->Tick(delta_time);
}
}
void WorkManager::Render(WorkObject *wo)
{
double delta_time=cur_time-last_render_time;
if(delta_time>=frame_time||wo->IsRenderDirty())
{
last_render_time=cur_time;
wo->Render(delta_time);
}
}
void SwapchainWorkManager::Render(WorkObject *wo)
{
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();
while(!cur_work_object->IsDestroy())
{
cur_time=GetDoubleTime();
if(cur_work_object->IsTickable())
Tick(cur_work_object);
if(win->IsVisible()&&cur_work_object->IsRenderable())
{
Render(cur_work_object);
dev->WaitIdle();
}
if(!win->Update())
break;
}
}
}//namespcae hgl

61
example/common/WorkManager.h
View File

@@ -1,61 +0,0 @@
#pragma once
#include"WorkObject.h"
namespace hgl
{
/**
* 工作管理器，管理一个序列的WorkObject<br>
*/
class WorkManager
{
graph::RenderFramework *render_framework;
uint fps=60;
double frame_time=1.0f/double(fps);
double last_update_time=0;
double last_render_time=0;
double cur_time=0;
WorkObject *cur_work_object=nullptr;
public:
WorkManager(graph::RenderFramework *rf)
{
render_framework=rf;
}
virtual ~WorkManager()
{
SAFE_CLEAR(cur_work_object);
}
void SetFPS(uint f)
{
fps=f;
frame_time=1.0f/double(fps);
}
void Tick(WorkObject *wo);
virtual void Render(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

93
example/common/WorkObject.h
View File

@@ -1,93 +0,0 @@
#pragma once
#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:
graph::RenderResource *db=nullptr; //暂时的，未来会被更好的机制替代
public:
graph::RenderFramework * GetRenderFramework (){return render_framework;}
graph::GPUDevice * GetDevice (){return render_framework->GetDevice();}
graph::GPUDeviceAttribute * GetDeviceAttribute (){return render_framework->GetDeviceAttribute();}
public:
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()=default;
virtual ~WorkObject()=default;
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,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