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:22:25 +08:00
parent 2576675265
commit 74a5847bbc
9 changed files with 273 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files

257
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,8 +6,9 @@
#include<hgl/graph/VKSwapchain.h>
#include<hgl/graph/VKQueue.h>
#include<hgl/graph/VKPipeline.h>
VK_NAMESPACE_BEGIN
#include<hgl/graph/VKCommandBuffer.h>
VK_NAMESPACE_BEGIN
/**
* RenderTarget 存在几种情况：
*
@@ -21,67 +21,203 @@ VK_NAMESPACE_BEGIN
class IRenderTarget
{
VkExtent2D extent;
public:
IRenderTarget(DeviceQueue *,Semaphore *);
const VkExtent2D &GetExtent ()const{return extent;}
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
class RenderTarget:public IRenderTarget
{
RenderTargetData *data;
protected:
friend class SwapchainModule;
friend class RenderTargetManager;
RenderTarget(RenderTargetData *rtd):IRenderTarget(rtd->fbo->GetExtent())
{
data=rtd;
}
public:
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;}
bool hasDepth ()override{return data->depth_texture;}
Texture2D * GetColorTexture (const int index=0) override{return data->GetColorTexture(index);}
Texture2D * GetDepthTexture () override{return data->depth_texture;}
public: // Command Buffer
DeviceQueue * GetQueue ()override{return data->queue;}
Semaphore * GetRenderCompleteSemaphore()override{return data->render_complete_semaphore;}
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:
DeviceQueue *queue;
uint32_t frame_number;
uint32_t current_frame;
Framebuffer *fbo;
VkExtent2D extent;
Semaphore *render_complete_semaphore =nullptr;
protected:
uint32_t color_count;
Texture2D **color_textures;
Texture2D *depth_texture;
RenderTarget **rt_list;
protected:
friend class RenderTargetManager;
RenderTarget(DeviceQueue *,Semaphore *);
RenderTarget(DeviceQueue *,Semaphore *,Framebuffer *_fb,Texture2D **color_texture_list,const uint32_t color_count,Texture2D *depth_texture);
MFRenderTarget(const uint32_t fn,RenderTarget **rtl):IRenderTarget(rtl[0]->GetFramebuffer()->GetExtent())
{
frame_number=fn;
current_frame=0;
rt_list=rtl;
}
public:
virtual ~RenderTarget();
virtual ~MFRenderTarget()
{
SAFE_CLEAR_OBJECT_ARRAY_OBJECT(rt_list,frame_number);
}
virtual void NextFrame()
{
++current_frame;
if(current_frame>=frame_number)
current_frame=0;
}
DeviceQueue * GetQueue () {return queue;}
const VkExtent2D & GetExtent ()const {return extent;}
virtual RenderPass * GetRenderPass () {return GetFramebuffer()->GetRenderPass();}
virtual uint32_t GetColorCount () {return GetFramebuffer()->GetColorCount();}
uint32_t GetCurrentFrameIndices ()const{return current_frame;}
uint32_t GetFrameCount ()const{return frame_number;}
RenderTarget * GetCurrentFrameRenderTarget (){return rt_list[current_frame];}
virtual Framebuffer * GetFramebuffer () {return fbo;}
virtual Texture2D * GetColorTexture (const int index=0){return color_textures[index];}
virtual Texture2D * GetDepthTexture (){return depth_texture;}
public:
public: // command buffer
Framebuffer * GetFramebuffer ()override{return rt_list[current_frame]->GetFramebuffer();}
RenderPass * GetRenderPass ()override{return rt_list[current_frame]->GetRenderPass();}
Semaphore * GetRenderCompleteSemaphore (){return render_complete_semaphore;}
virtual bool Submit (RenderCmdBuffer *,Semaphore *present_complete_semaphore=nullptr);
uint32_t GetColorCount ()override{return rt_list[current_frame]->GetColorCount();}
bool WaitQueue(){return queue->WaitQueue();}
bool WaitFence(){return queue->WaitFence();}
};//class RenderTarget
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;
@@ -89,47 +225,26 @@ 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 SwapchainModule;
friend class RenderTargetManager;
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 *);
};//class RTSwapchain:public RenderTarget
bool Submit()override
{
return rt_list[current_frame]->Submit(present_complete_semaphore);
}
};//class SwapchainRenderTarget:public RenderTarget
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_RENDER_TARGET_INCLUDE