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

refactored RenderTarget

Browse Source
This commit is contained in:
hyzboy
2025-01-26 23:21:53 +08:00
parent 02ac76e5bd
commit 11ca8e7fdf
8 changed files with 290 additions and 176 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
inc/hgl/graph/VK.h
View File

@@ -37,7 +37,7 @@ class ImageView;
class Framebuffer;
struct Swapchain;
class RenderTarget;
class RTSwapchain;
class SwapchainRenderTarget;
class Texture;
class Texture1D;

6
inc/hgl/graph/VKDevice.h
View File

@@ -39,9 +39,9 @@ private:
DeviceRenderPassManage *render_pass_manage;
RTSwapchain *sc_rt;
SwapchainRenderTarget *sc_rt;
RTSwapchain *CreateSwapchainRenderTarget();
SwapchainRenderTarget *CreateSwapchainRenderTarget();
void InitRenderPassManage();
void ClearRenderPassManage();
@@ -80,7 +80,7 @@ public:
RenderPass * GetRenderPass () {return sc_rt->GetRenderPass();}
RTSwapchain * GetSwapchainRT () {return sc_rt;}
SwapchainRenderTarget * GetSwapchainRT () {return sc_rt;}
const VkExtent2D & GetSwapchainSize ()const {return sc_rt->GetExtent();}

264
inc/hgl/graph/VKRenderTarget.h
View File

@@ -1,5 +1,4 @@
#ifndef HGL_GRAPH_VULKAN_RENDER_TARGET_INCLUDE
#define HGL_GRAPH_VULKAN_RENDER_TARGET_INCLUDE
#pragma once
#include<hgl/graph/VK.h>
#include<hgl/graph/VKRenderPass.h>
@@ -7,61 +6,216 @@
#include<hgl/graph/VKSwapchain.h>
#include<hgl/graph/VKQueue.h>
#include<hgl/graph/VKPipeline.h>
VK_NAMESPACE_BEGIN
/**
* 渲染目标
*/
class RenderTarget
* RenderTarget 存在几种情况：
*
* 1.正常单帧渲染目标，即只有一帧的数据，每次渲染都是当前帧
*
* 2.多帧渲染目标，即有多帧数据，每次渲染都是指定帧，典型的是Swapchain
*
* 所以RenderTarget的其实是一个多态类，根据不同的情况，有不同的实现
*/
class IRenderTarget
{
protected:
DeviceQueue *queue;
Framebuffer *fbo;
VkExtent2D extent;
Semaphore *render_complete_semaphore =nullptr;
public:
protected:
const VkExtent2D &GetExtent ()const{return extent;}
uint32_t color_count; ///<颜色成分数量
Texture2D **color_textures; ///<颜色成分纹理列表
Texture2D *depth_texture; ///<深度成分纹理
virtual uint32_t GetColorCount ()=0;
virtual bool hasDepth ()=0;
public:
IRenderTarget(const VkExtent2D &ext){extent=ext;}
virtual ~IRenderTarget()=default;
virtual Framebuffer * GetFramebuffer ()=0;
virtual RenderPass * GetRenderPass ()=0;
virtual Texture2D * GetColorTexture (const int index=0)=0;
virtual Texture2D * GetDepthTexture ()=0;
public: // Command Buffer
virtual DeviceQueue * GetQueue ()=0;
virtual Semaphore * GetRenderCompleteSemaphore()=0;
virtual RenderCmdBuffer * GetRenderCmdBuffer ()=0;
virtual bool Submit (Semaphore *wait_sem)=0;
virtual bool Submit (){return Submit(nullptr);}
virtual bool WaitQueue ()=0;
virtual bool WaitFence ()=0;
};//class IRenderTarget
struct RenderTargetData
{
Framebuffer * fbo;
DeviceQueue * queue;
Semaphore * render_complete_semaphore;
RenderCmdBuffer * cmd_buf;
uint32_t color_count; ///<颜色成分数量
Texture2D ** color_textures; ///<颜色成分纹理列表
Texture2D * depth_texture; ///<深度成分纹理
public:
Texture2D *GetColorTexture(const uint32_t index)
{
if(index>=color_count)
return(nullptr);
return color_textures[index];
}
virtual void Clear();
};//struct RenderTargetData
/**
* 单帧渲染目标
*/
class RenderTarget:public IRenderTarget
{
RenderTargetData *data;
protected:
friend class GPUDevice;
RenderTarget(DeviceQueue *,Semaphore *);
RenderTarget(DeviceQueue *,Semaphore *,Framebuffer *_fb,Texture2D **color_texture_list,const uint32_t color_count,Texture2D *depth_texture);
RenderTarget(RenderTargetData *rtd):IRenderTarget(rtd->fbo->GetExtent())
{
data=rtd;
}
public:
virtual ~RenderTarget();
virtual ~RenderTarget()
{
if(data)
{
data->Clear();
delete data;
}
}
Framebuffer * GetFramebuffer ()override{return data->fbo;}
RenderPass * GetRenderPass ()override{return data->fbo->GetRenderPass();}
uint32_t GetColorCount ()override{return data->color_count;}
DeviceQueue * GetQueue () {return queue;}
const VkExtent2D & GetExtent ()const {return extent;}
virtual RenderPass * GetRenderPass () {return GetFramebuffer()->GetRenderPass();}
virtual uint32_t GetColorCount () {return GetFramebuffer()->GetColorCount();}
bool hasDepth ()override{return data->depth_texture;}
virtual Framebuffer * GetFramebuffer () {return fbo;}
virtual Texture2D * GetColorTexture (const int index=0){return color_textures[index];}
virtual Texture2D * GetDepthTexture () {return depth_texture;}
Texture2D * GetColorTexture (const int index=0) override{return data->GetColorTexture(index);}
Texture2D * GetDepthTexture () override{return data->depth_texture;}
public: // command buffer
public: // Command Buffer
Semaphore * GetRenderCompleteSemaphore (){return render_complete_semaphore;}
virtual bool Submit (RenderCmdBuffer *,Semaphore *present_complete_semaphore=nullptr);
DeviceQueue * GetQueue ()override{return data->queue;}
Semaphore * GetRenderCompleteSemaphore()override{return data->render_complete_semaphore;}
bool WaitQueue(){return queue->WaitQueue();}
bool WaitFence(){return queue->WaitFence();}
RenderCmdBuffer * GetRenderCmdBuffer ()override{return data->cmd_buf;}
virtual bool Submit (Semaphore *wait_sem)override
{
if(!data)
return(false);
return data->queue->Submit(*data->cmd_buf,wait_sem,data->render_complete_semaphore);
}
bool WaitQueue ()override{return data->queue->WaitQueue();}
bool WaitFence ()override{return data->queue->WaitFence();}
};//class RenderTarget
/**
* 多帧渲染目标
*/
class MFRenderTarget:public IRenderTarget
{
protected:
uint32_t frame_number;
uint32_t current_frame;
RenderTarget **rt_list;
protected:
friend class GPUDevice;
MFRenderTarget(const uint32_t fn,RenderTarget **rtl):IRenderTarget(rtl[0]->GetFramebuffer()->GetExtent())
{
frame_number=fn;
current_frame=0;
rt_list=rtl;
}
public:
virtual ~MFRenderTarget()
{
SAFE_CLEAR_OBJECT_ARRAY_OBJECT(rt_list,frame_number);
}
virtual void NextFrame()
{
++current_frame;
if(current_frame>=frame_number)
current_frame=0;
}
uint32_t GetCurrentFrameIndices ()const{return current_frame;}
uint32_t GetFrameCount ()const{return frame_number;}
RenderTarget * GetCurrentFrameRenderTarget (){return rt_list[current_frame];}
public:
Framebuffer * GetFramebuffer ()override{return rt_list[current_frame]->GetFramebuffer();}
RenderPass * GetRenderPass ()override{return rt_list[current_frame]->GetRenderPass();}
uint32_t GetColorCount ()override{return rt_list[current_frame]->GetColorCount();}
Texture2D * GetColorTexture (const int index=0) override{return rt_list[current_frame]->GetColorTexture(index);}
Texture2D * GetDepthTexture () override{return rt_list[current_frame]->GetDepthTexture();}
bool hasDepth ()override{return rt_list[current_frame]->hasDepth();}
public: // Command Buffer
DeviceQueue * GetQueue ()override{return rt_list[current_frame]->GetQueue();}
Semaphore * GetRenderCompleteSemaphore()override{return rt_list[current_frame]->GetRenderCompleteSemaphore();}
RenderCmdBuffer * GetRenderCmdBuffer ()override{return rt_list[current_frame]->GetRenderCmdBuffer();}
Framebuffer * GetFramebuffer (const uint32_t index){return rt_list[index]->GetFramebuffer();}
RenderCmdBuffer * GetRenderCmdBuffer (const uint32_t index){return rt_list[index]->GetRenderCmdBuffer();}
virtual bool Submit ()override{return rt_list[current_frame]->Submit(nullptr);}
virtual bool Submit (Semaphore *wait_sem) override
{
return rt_list[current_frame]->Submit(wait_sem);
}
bool WaitQueue ()override{return rt_list[current_frame]->WaitQueue();}
bool WaitFence ()override{return rt_list[current_frame]->WaitFence();}
};//class MFRenderTarget
/**
* 交换链专用渲染目标
*/
class RTSwapchain:public RenderTarget
class SwapchainRenderTarget:public MFRenderTarget
{
VkDevice device;
Swapchain *swapchain;
@@ -69,47 +223,25 @@ class RTSwapchain:public RenderTarget
Semaphore *present_complete_semaphore=nullptr;
uint32_t current_frame;
private:
SwapchainRenderTarget(VkDevice dev,Swapchain *sc,Semaphore *pcs,RenderTarget **rtl);
friend class GPUDevice;
public:
RTSwapchain(VkDevice dev,Swapchain *sc,DeviceQueue *q,Semaphore *rcs,Semaphore *pcs);
~RTSwapchain();
uint32_t GetColorCount () override {return 1;}
uint32_t GetImageCount ()const {return swapchain->image_count;}
uint32_t GetCurrentFrameIndices ()const {return current_frame;}
Framebuffer * GetFramebuffer ()override {return swapchain->sc_image[current_frame].fbo;}
Framebuffer * GetFramebuffer (int index) {return swapchain->sc_image[index].fbo;}
virtual Texture2D * GetColorTexture (const int index=0) override{return swapchain->sc_image[current_frame].color;}
virtual Texture2D * GetDepthTexture () override{return swapchain->sc_image[current_frame].depth;}
RenderCmdBuffer * GetRenderCmdBuffer (int index) {return swapchain->sc_image[index].cmd_buf;}
~SwapchainRenderTarget();
public:
Semaphore * GetPresentSemaphore () {return present_complete_semaphore;}
int AcquireNextImage(); ///<获取下一帧的索引
public:
bool PresentBackbuffer(); ///<推送后台画面到前台
/**
* 请求下一帧画面的索引
* @param present_complete_semaphore 推送完成信号
*/
int AcquireNextImage();
/**
* 推送后台画面到前台
* @param render_complete_semaphore 渲染完成信号
*/
bool PresentBackbuffer(VkSemaphore *wait_semaphores,const uint32_t wait_semaphore_count);
bool PresentBackbuffer();
bool Submit(VkCommandBuffer);
bool Submit(VkCommandBuffer,Semaphore *);
bool Submit()override
{
return rt_list[current_frame]->Submit(present_complete_semaphore);
}
};//class RTSwapchain:public RenderTarget
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_RENDER_TARGET_INCLUDE