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

1.removed command_buffer from RenderTarget

Browse Source 
2.created and used RenderbufferInfo
This commit is contained in:
hyzboy 2020-10-27 22:43:24 +08:00
parent d0fd9af309
commit 672a14e656
17 changed files with 167 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMSceneGraph

@ -1 +1 @@
Subproject commit 2a750452cb0e0fef7e4c7a5c55d02e2cbb45d94e Subproject commit c4642ea87cb4abf4b68e94a63d868bdd66666dbe

65
example/Vulkan/DeferredModel.cpp
View File

@ -50,7 +50,18 @@ private:
SceneNode render_root; SceneNode render_root;
RenderList render_list; RenderList render_list;
RenderTarget *gbuffer_rt; struct
{
RenderTarget *rt;
GPUCmdBuffer *cmd;
public:
bool Submit(GPUSemaphore *sem)
{
return rt->Submit(cmd,sem);
}
}gbuffer;
PhongPointLight lights; PhongPointLight lights;
@ -89,23 +100,25 @@ public:
~TestApp() ~TestApp()
{ {
delete gbuffer_rt; delete gbuffer.cmd;
delete gbuffer.rt;
} }
private: private:
bool InitGBuffer() bool InitGBuffer()
{ {
List<VkFormat> gbuffer_color_format_list(gbuffer_color_format,size_t(GBufferAttachment::RANGE_SIZE)); FramebufferInfo fbi(gbuffer_color_format,size_t(GBufferAttachment::RANGE_SIZE),gbuffer_depth_format);
gbuffer_rt=device->CreateRenderTarget( SCREEN_WIDTH, fbi.SetExtent(SCREEN_WIDTH,SCREEN_HEIGHT);
SCREEN_HEIGHT,
gbuffer_color_format_list,
gbuffer_depth_format,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
return(gbuffer_rt); gbuffer.rt=device->CreateRenderTarget(&fbi);
if(!gbuffer.rt)return(false);
gbuffer.cmd=device->CreateCommandBuffer(size_t(GBufferAttachment::RANGE_SIZE)+1);
return(gbuffer.rt);
} }
bool InitSubpass(SubpassParam *sp,const OSString &material_filename) bool InitSubpass(SubpassParam *sp,const OSString &material_filename)
@ -121,11 +134,11 @@ private:
bool InitGBufferPipeline(SubpassParam *sp) bool InitGBufferPipeline(SubpassParam *sp)
{ {
sp->pipeline_triangles =gbuffer_rt->CreatePipeline(sp->material,InlinePipeline::Solid3D,Prim::Triangles); sp->pipeline_triangles =gbuffer.rt->CreatePipeline(sp->material,InlinePipeline::Solid3D,Prim::Triangles);
if(!sp->pipeline_triangles) if(!sp->pipeline_triangles)
return(false); return(false);
sp->pipeline_fan =gbuffer_rt->CreatePipeline(sp->material,InlinePipeline::Solid3D,Prim::Fan); sp->pipeline_fan =gbuffer.rt->CreatePipeline(sp->material,InlinePipeline::Solid3D,Prim::Fan);
return sp->pipeline_fan; return sp->pipeline_fan;
} }
@ -187,9 +200,9 @@ private:
sp_composition.material_instance->BindUBO("world",GetCameraMatrixBuffer()); sp_composition.material_instance->BindUBO("world",GetCameraMatrixBuffer());
sp_composition.material_instance->BindUBO("lights",ubo_lights); sp_composition.material_instance->BindUBO("lights",ubo_lights);
sp_composition.material_instance->BindSampler("GB_Color" ,gbuffer_rt->GetColorTexture((uint)GBufferAttachment::Color),sampler); sp_composition.material_instance->BindSampler("GB_Color" ,gbuffer.rt->GetColorTexture((uint)GBufferAttachment::Color),sampler);
sp_composition.material_instance->BindSampler("GB_Normal" ,gbuffer_rt->GetColorTexture((uint)GBufferAttachment::Normal),sampler); sp_composition.material_instance->BindSampler("GB_Normal" ,gbuffer.rt->GetColorTexture((uint)GBufferAttachment::Normal),sampler);
sp_composition.material_instance->BindSampler("GB_Depth" ,gbuffer_rt->GetDepthTexture(),sampler); sp_composition.material_instance->BindSampler("GB_Depth" ,gbuffer.rt->GetDepthTexture(),sampler);
sp_composition.material_instance->Update(); sp_composition.material_instance->Update();
return(true); return(true);
@ -278,19 +291,17 @@ private:
bool InitGBufferCommandBuffer() bool InitGBufferCommandBuffer()
{ {
GPUCmdBuffer *gbuffer_cmd=gbuffer_rt->GetCommandBuffer(); if(!gbuffer.cmd)
if(!gbuffer_cmd)
return(false); return(false);
gbuffer_cmd->Begin(); gbuffer.cmd->Begin();
if(!gbuffer_cmd->BindFramebuffer(gbuffer_rt)) if(!gbuffer.cmd->BindFramebuffer(gbuffer.rt->GetRenderPass(),gbuffer.rt->GetFramebuffer()))
return(false); return(false);
render_list.Render(gbuffer_cmd); render_list.Render(gbuffer.cmd);
gbuffer_cmd->EndRenderPass(); gbuffer.cmd->EndRenderPass();
gbuffer_cmd->End(); gbuffer.cmd->End();
return(true); return(true);
} }
@ -337,17 +348,17 @@ public:
virtual void SubmitDraw(int index) override virtual void SubmitDraw(int index) override
{ {
gbuffer_rt->Submit(sc_render_target->GetPresentCompleteSemaphore()); gbuffer.Submit(sc_render_target->GetPresentCompleteSemaphore());
VkCommandBuffer cb=*cmd_buf[index]; VkCommandBuffer cb=*cmd_buf[index];
sc_render_target->Submit(cb,gbuffer_rt->GetRenderCompleteSemaphore()); sc_render_target->Submit(cb,gbuffer.rt->GetRenderCompleteSemaphore());
sc_render_target->PresentBackbuffer(); sc_render_target->PresentBackbuffer();
sc_render_target->WaitQueue(); sc_render_target->WaitQueue();
sc_render_target->WaitFence(); sc_render_target->WaitFence();
gbuffer_rt->WaitQueue(); gbuffer.rt->WaitQueue();
gbuffer_rt->WaitFence(); gbuffer.rt->WaitFence();
} }
void BuildCommandBuffer(uint32_t index) override void BuildCommandBuffer(uint32_t index) override

25
example/Vulkan/OffscreenRender.cpp
View File

@ -22,9 +22,22 @@ class TestApp:public CameraAppFramework
struct:public RenderObject struct:public RenderObject
{ {
RenderTarget * render_taget =nullptr; RenderTarget * render_taget =nullptr;
GPUCmdBuffer * command_buffer =nullptr;
Pipeline * pipeline =nullptr; Pipeline * pipeline =nullptr;
RenderableInstance *renderable_instance =nullptr; RenderableInstance *renderable_instance =nullptr;
public:
bool Submit()
{
if(!render_taget->Submit(command_buffer))
return(false);
if(!render_taget->WaitQueue())
return(false);
return(true);
}
}os; }os;
struct:public RenderObject struct:public RenderObject
@ -64,9 +77,14 @@ public:
bool InitOffscreen() bool InitOffscreen()
{ {
os.render_taget=device->CreateColorRenderTarget(OFFSCREEN_SIZE,OFFSCREEN_SIZE,UFMT_RGBA8); FramebufferInfo fbi(UFMT_RGBA8,OFFSCREEN_SIZE,OFFSCREEN_SIZE);
os.render_taget=device->CreateRenderTarget(&fbi);
if(!os.render_taget)return(false); if(!os.render_taget)return(false);
os.command_buffer=device->CreateCommandBuffer(fbi.GetAttachmentCount());
if(!os.command_buffer)return(false);
os.material_instance=db->CreateMaterialInstance(OS_TEXT("res/material/VertexColor2D")); os.material_instance=db->CreateMaterialInstance(OS_TEXT("res/material/VertexColor2D"));
if(!os.material_instance)return(false); if(!os.material_instance)return(false);
@ -94,10 +112,9 @@ public:
if(!os.renderable_instance)return(false); if(!os.renderable_instance)return(false);
} }
VulkanApplicationFramework::BuildCommandBuffer(os.render_taget,os.renderable_instance); VulkanApplicationFramework::BuildCommandBuffer(os.command_buffer,os.render_taget,os.renderable_instance);
os.render_taget->Submit(nullptr); os.Submit();
os.render_taget->WaitQueue();
return(true); return(true);
} }

10
example/common/VulkanAppFramework.h
View File

@ -169,11 +169,11 @@ public:
cmd_buf=hgl_zero_new<GPUCmdBuffer *>(swap_chain_count); cmd_buf=hgl_zero_new<GPUCmdBuffer *>(swap_chain_count);
for(int32_t i=0;i<swap_chain_count;i++) for(int32_t i=0;i<swap_chain_count;i++)
cmd_buf[i]=device->CreateCommandBuffer(extent,2); cmd_buf[i]=device->CreateCommandBuffer(2);
} }
} }
bool BuildCommandBuffer(GPUCmdBuffer *cb,VkRenderPass rp,VkFramebuffer fb,RenderableInstance *ri) bool BuildCommandBuffer(GPUCmdBuffer *cb,RenderPass *rp,Framebuffer *fb,RenderableInstance *ri)
{ {
if(!ri)return(false); if(!ri)return(false);
@ -198,12 +198,12 @@ public:
return(true); return(true);
} }
void BuildCommandBuffer(RenderTarget *rt,RenderableInstance *ri) void BuildCommandBuffer(GPUCmdBuffer *cb,RenderTarget *rt,RenderableInstance *ri)
{ {
if(!rt||!ri) if(!cb||!rt||!ri)
return; return;
BuildCommandBuffer(rt->GetCommandBuffer(),rt->GetRenderPass(),rt->GetFramebuffer(),ri); BuildCommandBuffer(cb,rt->GetRenderPass(),rt->GetFramebuffer(),ri);
} }
bool BuildCommandBuffer(uint32_t index,RenderableInstance *ri) bool BuildCommandBuffer(uint32_t index,RenderableInstance *ri)

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

@ -8,6 +8,7 @@
#include<hgl/graph/VKFormat.h> #include<hgl/graph/VKFormat.h>
#include<hgl/graph/VKPrimivate.h> #include<hgl/graph/VKPrimivate.h>
#include<hgl/graph/VKStruct.h> #include<hgl/graph/VKStruct.h>
#include<hgl/graph/VKRenderbufferInfo.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN

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

@ -24,7 +24,7 @@ class GPUCmdBuffer
public: public:
GPUCmdBuffer(VkDevice dev,const VkExtent2D &extent,const uint32_t att_count,VkCommandPool cp,VkCommandBuffer cb); GPUCmdBuffer(VkDevice dev,const uint32_t att_count,VkCommandPool cp,VkCommandBuffer cb);
~GPUCmdBuffer(); ~GPUCmdBuffer();
operator VkCommandBuffer(){return cmd_buf;} operator VkCommandBuffer(){return cmd_buf;}
@ -66,9 +66,7 @@ public:
template<typename ...ARGS> void CopyImageToBuffer (ARGS...args){vkCmdCopyImageToBuffer(cmd_buf,args...);} template<typename ...ARGS> void CopyImageToBuffer (ARGS...args){vkCmdCopyImageToBuffer(cmd_buf,args...);}
template<typename ...ARGS> void BlitImage (ARGS...args){vkCmdBlitImage (cmd_buf,args...);} template<typename ...ARGS> void BlitImage (ARGS...args){vkCmdBlitImage (cmd_buf,args...);}
bool BindFramebuffer(VkRenderPass rp,VkFramebuffer fb); bool BindFramebuffer(RenderPass *rp,Framebuffer *fb);
// bool BindFramebuffer(Framebuffer *);
bool BindFramebuffer(RenderTarget *);
bool BindPipeline(Pipeline *p) bool BindPipeline(Pipeline *p)
{ {

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

@ -180,25 +180,14 @@ public: //shader & material
public: //Command GPUBuffer 相关 public: //Command GPUBuffer 相关
GPUCmdBuffer * CreateCommandBuffer(const VkExtent2D &extent,const uint32_t atta_count); GPUCmdBuffer * CreateCommandBuffer(const uint32_t attachment_count);
RenderPass * CreateRenderPass( const List<VkAttachmentDescription> &desc_list, RenderPass * CreateRenderPass( const List<VkAttachmentDescription> &desc_list,
const List<VkSubpassDescription> &subpass, const List<VkSubpassDescription> &subpass,
const List<VkSubpassDependency> &dependency, const List<VkSubpassDependency> &dependency,
const List<VkFormat> &color_format, const RenderbufferInfo *);
const VkFormat depth_format,
const VkImageLayout color_final_layout=VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
const VkImageLayout depth_final_layout=VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
RenderPass * CreateRenderPass( const List<VkFormat> &color_format, RenderPass * CreateRenderPass( const RenderbufferInfo *);
const VkFormat depth_format,
const VkImageLayout color_final_layout=VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
const VkImageLayout depth_final_layout=VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
RenderPass * CreateRenderPass( const VkFormat color_format,
const VkFormat depth_format,
const VkImageLayout color_final_layout=VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
const VkImageLayout depth_final_layout=VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
GPUFence * CreateFence(bool); GPUFence * CreateFence(bool);
GPUSemaphore * CreateSemaphore(); GPUSemaphore * CreateSemaphore();
@ -216,31 +205,7 @@ public:
RenderTarget *CreateRenderTarget( Framebuffer *,const uint32_t fence_count=1); RenderTarget *CreateRenderTarget( Framebuffer *,const uint32_t fence_count=1);
RenderTarget *CreateRenderTarget( const uint,const uint, RenderTarget *CreateRenderTarget( const FramebufferInfo *fbi,const uint32_t fence_count=1);
const List<VkFormat> &color_format_list,
const VkFormat depth_format,
const VkImageLayout color_final_layout=VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
const VkImageLayout depth_final_layout=VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
const uint32_t fence_count=1);
RenderTarget *CreateRenderTarget( const uint,const uint,
const VkFormat color_format,
const VkFormat depth_format,
const VkImageLayout color_final_layout=VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
const VkImageLayout depth_final_layout=VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
const uint32_t fence_count=1);
RenderTarget *CreateRenderTarget( const uint,const uint,const VkFormat,const VkImageLayout final_layout,const uint32_t fence_count=1);
RenderTarget *CreateColorRenderTarget( const uint w,const uint h,const VkFormat format,const uint32_t fence_count=1)
{
return CreateRenderTarget(w,h,format,VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,fence_count);
}
RenderTarget *CreateDepthRenderTarget( const uint w,const uint h,const VkFormat format,const uint32_t fence_count=1)
{
return CreateRenderTarget(w,h,format,VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,fence_count);
}
public: public:

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

@ -24,6 +24,8 @@ public:
~Framebuffer(); ~Framebuffer();
operator VkFramebuffer(){return frame_buffer;}
const VkFramebuffer GetFramebuffer ()const{return frame_buffer;} const VkFramebuffer GetFramebuffer ()const{return frame_buffer;}
const VkRenderPass GetRenderPass ()const{return render_pass;} const VkRenderPass GetRenderPass ()const{return render_pass;}

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

@ -21,7 +21,6 @@ protected:
VkExtent2D extent; VkExtent2D extent;
GPUSemaphore *render_complete_semaphore =nullptr; GPUSemaphore *render_complete_semaphore =nullptr;
GPUCmdBuffer *command_buffer =nullptr;
protected: protected:
@ -37,22 +36,23 @@ protected:
friend class GPUDevice; friend class GPUDevice;
RenderTarget(GPUDevice *dev,Framebuffer *_fb,GPUCmdBuffer *_cb,const uint32_t fence_count=1); RenderTarget(GPUDevice *dev,Framebuffer *_fb,const uint32_t fence_count=1);
RenderTarget(GPUDevice *dev,RenderPass *_rp,Framebuffer *_fb,GPUCmdBuffer *_cb,Texture2D **color_texture_list,const uint32_t color_count,Texture2D *depth_texture,const uint32_t fence_count=1); RenderTarget(GPUDevice *dev,RenderPass *_rp,Framebuffer *_fb,Texture2D **color_texture_list,const uint32_t color_count,Texture2D *depth_texture,const uint32_t fence_count=1);
public: public:
virtual ~RenderTarget(); virtual ~RenderTarget();
const VkExtent2D & GetExtent ()const {return extent;} const VkExtent2D & GetExtent ()const {return extent;}
virtual const VkRenderPass GetRenderPass ()const {return *render_pass;} virtual RenderPass * GetRenderPass () {return render_pass;}
virtual const VkRenderPass GetVkRenderPass ()const {return *render_pass;}
virtual const uint32_t GetColorCount ()const {return fbo->GetColorCount();} virtual const uint32_t GetColorCount ()const {return fbo->GetColorCount();}
virtual const VkFramebuffer GetFramebuffer ()const {return fbo->GetFramebuffer();} virtual Framebuffer * GetFramebuffer () {return fbo;}
virtual Texture2D * GetColorTexture (const int index=0){return color_textures[index];} virtual Texture2D * GetColorTexture (const int index=0){return color_textures[index];}
virtual Texture2D * GetDepthTexture (){return depth_texture;} virtual Texture2D * GetDepthTexture (){return depth_texture;}
public: public: //pipeline
Pipeline *CreatePipeline(Material *, const InlinePipeline &, const Prim &prim=Prim::Triangles,const bool prim_restart=false); Pipeline *CreatePipeline(Material *, const InlinePipeline &, const Prim &prim=Prim::Triangles,const bool prim_restart=false);
Pipeline *CreatePipeline(MaterialInstance *, const InlinePipeline &, const Prim &prim=Prim::Triangles,const bool prim_restart=false); Pipeline *CreatePipeline(MaterialInstance *, const InlinePipeline &, const Prim &prim=Prim::Triangles,const bool prim_restart=false);
@ -61,11 +61,10 @@ public:
Pipeline *CreatePipeline(Material *, const OSString &, const Prim &prim=Prim::Triangles,const bool prim_restart=false); Pipeline *CreatePipeline(Material *, const OSString &, const Prim &prim=Prim::Triangles,const bool prim_restart=false);
Pipeline *CreatePipeline(MaterialInstance *, const OSString &, const Prim &prim=Prim::Triangles,const bool prim_restart=false); Pipeline *CreatePipeline(MaterialInstance *, const OSString &, const Prim &prim=Prim::Triangles,const bool prim_restart=false);
public: public: // command buffer
GPUSemaphore * GetRenderCompleteSemaphore (){return render_complete_semaphore;} GPUSemaphore * GetRenderCompleteSemaphore (){return render_complete_semaphore;}
GPUCmdBuffer * GetCommandBuffer (){return command_buffer;} virtual bool Submit (GPUCmdBuffer *,GPUSemaphore *present_complete_semaphore=nullptr);
virtual bool Submit (GPUSemaphore *present_complete_semaphore=nullptr);
};//class RenderTarget };//class RenderTarget
/** /**
@ -89,8 +88,8 @@ public:
SwapchainRenderTarget(GPUDevice *dev,Swapchain *sc); SwapchainRenderTarget(GPUDevice *dev,Swapchain *sc);
~SwapchainRenderTarget(); ~SwapchainRenderTarget();
const VkFramebuffer GetFramebuffer ()const override {return render_frame[current_frame]->GetFramebuffer();} Framebuffer * GetFramebuffer ()override {return render_frame[current_frame];}
VkFramebuffer GetFramebuffer (const uint32_t index) {return render_frame[index]->GetFramebuffer();} Framebuffer * GetFramebuffer (const uint32_t index) {return render_frame[index];}
const uint32_t GetColorCount ()const override {return 1;} const uint32_t GetColorCount ()const override {return 1;}
const uint32_t GetImageCount ()const {return swap_chain_count;} const uint32_t GetImageCount ()const {return swap_chain_count;}

24
inc/hgl/graph/VKTextureCreateInfo.h
View File

@ -217,6 +217,14 @@ struct ColorAttachmentTextureCreateInfo:public AttachmentTextureCreateInfo
format=fmt; format=fmt;
extent=ext; extent=ext;
} }
ColorAttachmentTextureCreateInfo(const VkFormat fmt,const VkExtent2D &ext):ColorAttachmentTextureCreateInfo()
{
format=fmt;
extent.width=ext.width;
extent.height=ext.height;
extent.depth=1;
}
}; };
struct DepthAttachmentTextureCreateInfo:public AttachmentTextureCreateInfo struct DepthAttachmentTextureCreateInfo:public AttachmentTextureCreateInfo
@ -236,6 +244,14 @@ struct DepthAttachmentTextureCreateInfo:public AttachmentTextureCreateInfo
format=fmt; format=fmt;
extent=ext; extent=ext;
} }
DepthAttachmentTextureCreateInfo(const VkFormat fmt,const VkExtent2D &ext):DepthAttachmentTextureCreateInfo()
{
format=fmt;
extent.width=ext.width;
extent.height=ext.height;
extent.depth=1;
}
}; };
struct DepthStencilAttachmentTextureCreateInfo:public AttachmentTextureCreateInfo struct DepthStencilAttachmentTextureCreateInfo:public AttachmentTextureCreateInfo
@ -255,6 +271,14 @@ struct DepthStencilAttachmentTextureCreateInfo:public AttachmentTextureCreateInf
format=fmt; format=fmt;
extent=ext; extent=ext;
} }
DepthStencilAttachmentTextureCreateInfo(const VkFormat fmt,const VkExtent2D &ext):DepthStencilAttachmentTextureCreateInfo()
{
format=fmt;
extent.width=ext.width;
extent.height=ext.height;
extent.depth=1;
}
}; };
struct SwapchainColorTextureCreateInfo:public TextureCreateInfo struct SwapchainColorTextureCreateInfo:public TextureCreateInfo

27
src/RenderDevice/VKCommandBuffer.cpp
View File

@ -10,7 +10,7 @@
#include<hgl/graph/VKDescriptorSets.h> #include<hgl/graph/VKDescriptorSets.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
GPUCmdBuffer::GPUCmdBuffer(VkDevice dev,const VkExtent2D &extent,const uint32_t atta_count,VkCommandPool cp,VkCommandBuffer cb) GPUCmdBuffer::GPUCmdBuffer(VkDevice dev,const uint32_t atta_count,VkCommandPool cp,VkCommandBuffer cb)
{ {
device=dev; device=dev;
pool=cp; pool=cp;
@ -32,7 +32,8 @@ GPUCmdBuffer::GPUCmdBuffer(VkDevice dev,const VkExtent2D &extent,const uint32_t
render_area.offset.x=0; render_area.offset.x=0;
render_area.offset.y=0; render_area.offset.y=0;
render_area.extent=extent; render_area.extent.width=0;
render_area.extent.height=0;
default_line_width=1.0; default_line_width=1.0;
@ -65,12 +66,16 @@ bool GPUCmdBuffer::Begin()
return(true); return(true);
} }
bool GPUCmdBuffer::BindFramebuffer(VkRenderPass rp,VkFramebuffer fb) bool GPUCmdBuffer::BindFramebuffer(RenderPass *rp,Framebuffer *fb)
{ {
RenderPassBeginInfo rp_begin; RenderPassBeginInfo rp_begin;
rp_begin.renderPass = rp; render_area.offset.x=0;
rp_begin.framebuffer = fb; render_area.offset.y=0;
render_area.extent=fb->GetExtent();
rp_begin.renderPass = *rp;
rp_begin.framebuffer = *fb;
rp_begin.renderArea = render_area; rp_begin.renderArea = render_area;
rp_begin.clearValueCount = cv_count; rp_begin.clearValueCount = cv_count;
rp_begin.pClearValues = clear_values; rp_begin.pClearValues = clear_values;
@ -93,18 +98,6 @@ bool GPUCmdBuffer::BindFramebuffer(VkRenderPass rp,VkFramebuffer fb)
return(true); return(true);
} }
//bool GPUCmdBuffer::BindFramebuffer(Framebuffer *fbo)
//{
// return BindFramebuffer(fbo->GetRenderPass(),fbo->GetFramebuffer());
//}
bool GPUCmdBuffer::BindFramebuffer(RenderTarget *rt)
{
if(!rt)return(false);
return BindFramebuffer(rt->GetRenderPass(),rt->GetFramebuffer());
}
bool GPUCmdBuffer::BindVAB(RenderableInstance *ri) bool GPUCmdBuffer::BindVAB(RenderableInstance *ri)
{ {
if(!ri) if(!ri)

6
src/RenderDevice/VKDevice.cpp
View File

@ -47,7 +47,7 @@ bool GPUDevice::Resize(const VkExtent2D &extent)
if(!CreateSwapchain(extent)) if(!CreateSwapchain(extent))
return(false); return(false);
texture_cmd_buf=CreateCommandBuffer(extent,0); texture_cmd_buf=CreateCommandBuffer(0);
textureSQ=new GPUQueue(this,attr->graphics_queue,1); textureSQ=new GPUQueue(this,attr->graphics_queue,1);
swapchainRT=new SwapchainRenderTarget(this,swapchain); swapchainRT=new SwapchainRenderTarget(this,swapchain);
@ -55,7 +55,7 @@ bool GPUDevice::Resize(const VkExtent2D &extent)
return(true); return(true);
} }
GPUCmdBuffer *GPUDevice::CreateCommandBuffer(const VkExtent2D &extent,const uint32_t atta_count) GPUCmdBuffer *GPUDevice::CreateCommandBuffer(const uint32_t attachment_count)
{ {
if(!attr->cmd_pool) if(!attr->cmd_pool)
return(nullptr); return(nullptr);
@ -73,7 +73,7 @@ GPUCmdBuffer *GPUDevice::CreateCommandBuffer(const VkExtent2D &extent,const uint
if(res!=VK_SUCCESS) if(res!=VK_SUCCESS)
return(nullptr); return(nullptr);
return(new GPUCmdBuffer(attr->device,extent,atta_count,attr->cmd_pool,cmd_buf)); return(new GPUCmdBuffer(attr->device,attachment_count,attr->cmd_pool,cmd_buf));
} }
/** /**

60
src/RenderDevice/VKDeviceRenderPass.cpp
View File

@ -80,11 +80,11 @@ void CreateAttachmentReference(VkAttachmentReference *ref_list,uint start,uint c
} }
} }
bool CreateAttachmentDescription(List<VkAttachmentDescription> &desc_list,const List<VkFormat> &color_format,const VkFormat depth_format,VkImageLayout color_final_layout,VkImageLayout depth_final_layout) bool CreateAttachmentDescription(List<VkAttachmentDescription> &desc_list,const RenderbufferInfo *rbi)
{ {
const uint color_count=color_format.GetCount(); const uint color_count=rbi->GetColorCount();
const uint count=(depth_format!=FMT_UNDEFINED)?color_count+1:color_count; const uint count=(rbi->HasDepthOrStencil())?color_count+1:color_count;
desc_list.SetCount(count); desc_list.SetCount(count);
@ -104,21 +104,21 @@ bool CreateAttachmentDescription(List<VkAttachmentDescription> &desc_list,const
} }
desc=desc_list.GetData(); desc=desc_list.GetData();
const VkFormat *cf=color_format.GetData(); const VkFormat *cf=rbi->GetColorFormat();
for(uint i=0;i<color_count;i++) for(uint i=0;i<color_count;i++)
{ {
desc->finalLayout = color_final_layout; desc->finalLayout = rbi->GetColorLayout();
desc->format = *cf; desc->format = *cf;
++desc; ++desc;
++cf; ++cf;
} }
if(depth_format!=FMT_UNDEFINED) if(rbi->GetDepthFormat()!=FMT_UNDEFINED)
{ {
desc->finalLayout = depth_final_layout; desc->finalLayout = rbi->GetDepthLayout();
desc->format = depth_format; desc->format = rbi->GetDepthFormat();
desc->storeOp = VK_ATTACHMENT_STORE_OP_STORE; //swapchainRT最后"可能"是不需要保存深度的，，，，想想怎么最后弄成"DONT CARE" desc->storeOp = rbi->IsSwapchain()?VK_ATTACHMENT_STORE_OP_DONT_CARE:VK_ATTACHMENT_STORE_OP_STORE;
} }
return(true); return(true);
@ -192,22 +192,21 @@ bool CreateDepthAttachment( List<VkAttachmentReference> &ref_list,List<VkAttachm
return(true); return(true);
} }
RenderPass *GPUDevice::CreateRenderPass( const List<VkAttachmentDescription> &desc_list, RenderPass *GPUDevice::CreateRenderPass(const List<VkAttachmentDescription> &desc_list,
const List<VkSubpassDescription> &subpass, const List<VkSubpassDescription> &subpass,
const List<VkSubpassDependency> &dependency, const List<VkSubpassDependency> &dependency,
const List<VkFormat> &color_format_list, const RenderbufferInfo *rbi)
const VkFormat depth_format,
const VkImageLayout color_final_layout,
const VkImageLayout depth_final_layout)
{ {
for(const VkFormat cf:color_format_list) for(const VkFormat cf:rbi->GetColorFormatList())
{ {
if(!attr->physical_device->IsColorAttachmentOptimal(cf) if(!attr->physical_device->IsColorAttachmentOptimal(cf)
&&!attr->physical_device->IsColorAttachmentLinear(cf)) &&!attr->physical_device->IsColorAttachmentLinear(cf))
return(nullptr); return(nullptr);
} }
if(depth_format!=FMT_UNDEFINED) const VkFormat depth_format=rbi->GetDepthFormat();
if(rbi->HasDepthOrStencil())
{ {
if(!attr->physical_device->IsDepthAttachmentOptimal(depth_format) if(!attr->physical_device->IsDepthAttachmentOptimal(depth_format)
&&!attr->physical_device->IsDepthAttachmentLinear(depth_format)) &&!attr->physical_device->IsDepthAttachmentLinear(depth_format))
@ -230,12 +229,12 @@ RenderPass *GPUDevice::CreateRenderPass( const List<VkAttachmentDescription> &
if(vkCreateRenderPass(attr->device,&rp_info,nullptr,&render_pass)!=VK_SUCCESS) if(vkCreateRenderPass(attr->device,&rp_info,nullptr,&render_pass)!=VK_SUCCESS)
return(nullptr); return(nullptr);
return(new RenderPass(attr->device,render_pass,color_format_list,depth_format)); return(new RenderPass(attr->device,render_pass,rbi->GetColorFormatList(),depth_format));
} }
RenderPass *GPUDevice::CreateRenderPass(const List<VkFormat> &color_format_list,VkFormat depth_format,VkImageLayout color_final_layout,VkImageLayout depth_final_layout) RenderPass *GPUDevice::CreateRenderPass(const RenderbufferInfo *rbi)
{ {
for(const VkFormat &fmt:color_format_list) for(const VkFormat &fmt:rbi->GetColorFormatList())
if(!attr->physical_device->IsColorAttachmentOptimal(fmt)) if(!attr->physical_device->IsColorAttachmentOptimal(fmt))
return(nullptr); return(nullptr);
@ -245,17 +244,17 @@ RenderPass *GPUDevice::CreateRenderPass(const List<VkFormat> &color_format_list,
List<VkSubpassDescription> subpass_desc_list; List<VkSubpassDescription> subpass_desc_list;
List<VkSubpassDependency> subpass_dependency_list; List<VkSubpassDependency> subpass_dependency_list;
color_ref_list.SetCount(color_format_list.GetCount()); color_ref_list.SetCount(rbi->GetColorCount());
CreateColorAttachmentReference(color_ref_list.GetData(),0,color_format_list.GetCount()); CreateColorAttachmentReference(color_ref_list.GetData(),0,rbi->GetColorCount());
CreateAttachmentDescription(atta_desc_list,color_format_list,depth_format,color_final_layout,depth_final_layout); CreateAttachmentDescription(atta_desc_list,rbi);
if(depth_format!=FMT_UNDEFINED) if(rbi->HasDepthOrStencil())
{ {
if(!attr->physical_device->IsDepthAttachmentOptimal(depth_format)) if(!attr->physical_device->IsDepthAttachmentOptimal(rbi->GetDepthFormat()))
return(nullptr); return(nullptr);
CreateDepthAttachmentReference(&depth_ref,color_format_list.GetCount()); CreateDepthAttachmentReference(&depth_ref,rbi->GetColorCount());
subpass_desc_list.Add(SubpassDescription(color_ref_list.GetData(),color_ref_list.GetCount(),&depth_ref)); subpass_desc_list.Add(SubpassDescription(color_ref_list.GetData(),color_ref_list.GetCount(),&depth_ref));
} }
else else
@ -265,15 +264,6 @@ RenderPass *GPUDevice::CreateRenderPass(const List<VkFormat> &color_format_list,
CreateSubpassDependency(subpass_dependency_list,2); CreateSubpassDependency(subpass_dependency_list,2);
return CreateRenderPass(atta_desc_list,subpass_desc_list,subpass_dependency_list,color_format_list,depth_format,color_final_layout,depth_final_layout); return CreateRenderPass(atta_desc_list,subpass_desc_list,subpass_dependency_list,rbi);
}
RenderPass *GPUDevice::CreateRenderPass(VkFormat color_format,VkFormat depth_format,VkImageLayout color_final_layout,VkImageLayout depth_final_layout)
{
List<VkFormat> color_format_list;
color_format_list.Add(color_format);
return CreateRenderPass(color_format_list,depth_format,color_final_layout,depth_final_layout);
} }
VK_NAMESPACE_END VK_NAMESPACE_END

63
src/RenderDevice/VKDeviceRenderTarget.cpp
View File

@ -3,27 +3,20 @@
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
RenderTarget *GPUDevice::CreateRenderTarget(Framebuffer *fb,const uint32_t fence_count) RenderTarget *GPUDevice::CreateRenderTarget(Framebuffer *fb,const uint32_t fence_count)
{ {
GPUCmdBuffer *cb=CreateCommandBuffer(fb->GetExtent(),fb->GetAttachmentCount()); return(new RenderTarget(this,fb,fence_count));
return(new RenderTarget(this,fb,cb,fence_count));
} }
RenderTarget *GPUDevice::CreateRenderTarget(const uint w,const uint h, RenderTarget *GPUDevice::CreateRenderTarget(const FramebufferInfo *fbi,const uint32_t fence_count)
const List<VkFormat> &color_format_list,
const VkFormat depth_format,
const VkImageLayout color_layout,
const VkImageLayout depth_layout,
const uint32_t fence_count)
{ {
if(w<=0||h<=0)return(nullptr); if(!fbi)return(nullptr);
RenderPass *rp=CreateRenderPass(color_format_list,depth_format,color_layout,depth_layout); //Renderpass内部会验证格式，所以不需要自己处理 RenderPass *rp=CreateRenderPass(fbi); //Renderpass内部会验证格式，所以不需要自己处理
if(!rp)return(nullptr); if(!rp)return(nullptr);
const uint32_t color_count=color_format_list.GetCount(); const uint32_t color_count=fbi->GetColorCount();
const VkExtent2D extent=fbi->GetExtent();
const VkExtent3D extent={w,h,1}; const VkFormat depth_format=fbi->GetDepthFormat();
AutoDeleteObjectArray<Texture2D> color_texture_list(color_count); AutoDeleteObjectArray<Texture2D> color_texture_list(color_count);
AutoDeleteArray<ImageView *> color_iv_list(color_count); //iv只是从Texture2D中取出来的，无需一个个delete AutoDeleteArray<ImageView *> color_iv_list(color_count); //iv只是从Texture2D中取出来的，无需一个个delete
@ -31,7 +24,7 @@ RenderTarget *GPUDevice::CreateRenderTarget(const uint w,const uint h,
Texture2D **tp=color_texture_list; Texture2D **tp=color_texture_list;
ImageView **iv=color_iv_list; ImageView **iv=color_iv_list;
for(const VkFormat &fmt:color_format_list) for(const VkFormat &fmt:fbi->GetColorFormatList())
{ {
Texture2D *color_texture=CreateTexture2D(new ColorAttachmentTextureCreateInfo(fmt,extent)); Texture2D *color_texture=CreateTexture2D(new ColorAttachmentTextureCreateInfo(fmt,extent));
@ -51,11 +44,11 @@ RenderTarget *GPUDevice::CreateRenderTarget(const uint w,const uint h,
if(fb) if(fb)
{ {
GPUCmdBuffer *cb=CreateCommandBuffer(fb->GetExtent(),fb->GetAttachmentCount()); GPUCmdBuffer *cb=CreateCommandBuffer(fb->GetAttachmentCount());
if(cb) if(cb)
{ {
RenderTarget *rt=new RenderTarget(this,rp,fb,cb,color_texture_list,color_count,depth_texture,fence_count); RenderTarget *rt=new RenderTarget(this,rp,fb,color_texture_list,color_count,depth_texture,fence_count);
color_texture_list.DiscardObject(); color_texture_list.DiscardObject();
return rt; return rt;
@ -66,40 +59,4 @@ RenderTarget *GPUDevice::CreateRenderTarget(const uint w,const uint h,
delete rp; delete rp;
return nullptr; return nullptr;
} }
RenderTarget *GPUDevice::CreateRenderTarget(const uint w,const uint h,
const VkFormat color_format,
const VkFormat depth_format,
const VkImageLayout color_layout,
const VkImageLayout depth_layout,
const uint32_t fence_count)
{
if(w<=0||h<=0)return(nullptr);
List<VkFormat> color_format_list;
color_format_list.Add(color_format);
return CreateRenderTarget(w,h,color_format_list,depth_format,color_layout,depth_layout,fence_count);
}
RenderTarget *GPUDevice::CreateRenderTarget(const uint w,const uint h,const VkFormat format,const VkImageLayout final_layout,const uint32_t fence_count)
{
if(w<=0||h<=0)return(nullptr);
if(format==FMT_UNDEFINED)return(nullptr);
List<VkFormat> color_format_list;
if(IsDepthFormat(format))
{
return CreateRenderTarget(w,h,color_format_list,format,VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,final_layout,fence_count);
}
else
{
color_format_list.Add(format);
return CreateRenderTarget(w,h,color_format_list,FMT_UNDEFINED,final_layout,VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,fence_count);
}
}
VK_NAMESPACE_END VK_NAMESPACE_END

2
src/RenderDevice/VKPipeline.cpp
View File

@ -28,7 +28,7 @@ Pipeline *CreatePipeline(VkDevice device,VkPipelineCache pipeline_cache,Pipeline
data->pipeline_info.layout = material->GetPipelineLayout(); data->pipeline_info.layout = material->GetPipelineLayout();
{ {
data->pipeline_info.renderPass = rt->GetRenderPass(); data->pipeline_info.renderPass = rt->GetVkRenderPass();
data->pipeline_info.subpass = 0; //subpass由于还不知道有什么用，所以暂时写0，待知道功用后，需改进 data->pipeline_info.subpass = 0; //subpass由于还不知道有什么用，所以暂时写0，待知道功用后，需改进
} }

10
src/RenderDevice/VKRenderTarget.cpp
View File

@ -3,13 +3,13 @@
#include<hgl/graph/VKSwapchain.h> #include<hgl/graph/VKSwapchain.h>
#include<hgl/graph/VKCommandBuffer.h> #include<hgl/graph/VKCommandBuffer.h>
#include<hgl/graph/VKSemaphore.h> #include<hgl/graph/VKSemaphore.h>
#include<hgl/graph/VKFramebuffer.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
RenderTarget::RenderTarget(GPUDevice *dev,Framebuffer *_fb,GPUCmdBuffer *_cb,const uint32_t fence_count):GPUQueue(dev,dev->GetGraphicsQueue(),fence_count) RenderTarget::RenderTarget(GPUDevice *dev,Framebuffer *_fb,const uint32_t fence_count):GPUQueue(dev,dev->GetGraphicsQueue(),fence_count)
{ {
render_pass=nullptr; render_pass=nullptr;
fbo=_fb; fbo=_fb;
command_buffer=_cb;
if(fbo) if(fbo)
color_count=fbo->GetColorCount(); color_count=fbo->GetColorCount();
@ -21,11 +21,10 @@ RenderTarget::RenderTarget(GPUDevice *dev,Framebuffer *_fb,GPUCmdBuffer *_cb,con
render_complete_semaphore=dev->CreateSemaphore(); render_complete_semaphore=dev->CreateSemaphore();
} }
RenderTarget::RenderTarget(GPUDevice *dev,RenderPass *_rp,Framebuffer *_fb,GPUCmdBuffer *_cb,Texture2D **ctl,const uint32_t cc,Texture2D *dt,const uint32_t fence_count):GPUQueue(dev,dev->GetGraphicsQueue(),fence_count) RenderTarget::RenderTarget(GPUDevice *dev,RenderPass *_rp,Framebuffer *_fb,Texture2D **ctl,const uint32_t cc,Texture2D *dt,const uint32_t fence_count):GPUQueue(dev,dev->GetGraphicsQueue(),fence_count)
{ {
render_pass=_rp; render_pass=_rp;
fbo=_fb; fbo=_fb;
command_buffer=_cb;
depth_texture=dt; depth_texture=dt;
@ -59,12 +58,11 @@ RenderTarget::~RenderTarget()
SAFE_CLEAR_OBJECT_ARRAY(color_textures,color_count); SAFE_CLEAR_OBJECT_ARRAY(color_textures,color_count);
SAFE_CLEAR(render_complete_semaphore); SAFE_CLEAR(render_complete_semaphore);
SAFE_CLEAR(command_buffer);
SAFE_CLEAR(fbo); SAFE_CLEAR(fbo);
SAFE_CLEAR(render_pass); SAFE_CLEAR(render_pass);
} }
bool RenderTarget::Submit(GPUSemaphore *present_complete_semaphore) bool RenderTarget::Submit(GPUCmdBuffer *command_buffer,GPUSemaphore *present_complete_semaphore)
{ {
return this->GPUQueue::Submit(*command_buffer,present_complete_semaphore,render_complete_semaphore); return this->GPUQueue::Submit(*command_buffer,present_complete_semaphore,render_complete_semaphore);
} }

6
src/RenderDevice/VKSwapchainRenderTarget.cpp
View File

@ -3,7 +3,7 @@
#include<hgl/graph/VKSemaphore.h> #include<hgl/graph/VKSemaphore.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
SwapchainRenderTarget::SwapchainRenderTarget(GPUDevice *dev,Swapchain *sc):RenderTarget(dev,nullptr,nullptr,sc->GetImageCount()) SwapchainRenderTarget::SwapchainRenderTarget(GPUDevice *dev,Swapchain *sc):RenderTarget(dev,nullptr,sc->GetImageCount())
{ {
swapchain=sc; swapchain=sc;
vk_swapchain=swapchain->GetSwapchain(); vk_swapchain=swapchain->GetSwapchain();
@ -17,7 +17,9 @@ SwapchainRenderTarget::SwapchainRenderTarget(GPUDevice *dev,Swapchain *sc):Rende
Texture2D **sc_color=swapchain->GetColorTextures(); Texture2D **sc_color=swapchain->GetColorTextures();
Texture2D *sc_depth=swapchain->GetDepthTexture(); Texture2D *sc_depth=swapchain->GetDepthTexture();
this->render_pass=device->CreateRenderPass((*sc_color)->GetFormat(),sc_depth->GetFormat(),VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); SwapchainRenderbufferInfo rbi((*sc_color)->GetFormat(),sc_depth->GetFormat());
this->render_pass=device->CreateRenderPass(&rbi);
swap_chain_count=swapchain->GetImageCount(); swap_chain_count=swapchain->GetImageCount();