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

split RenderCommand/TextureCommand from GPUCmdBuffer

Browse Source
This commit is contained in:
hyzboy 2020-10-28 12:30:44 +08:00
parent 672a14e656
commit 2e05e06b3f
18 changed files with 127 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
example/CMakeLists.txt
View File

@ -1,5 +1,7 @@
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/common)
SET(VULKAN_APP_FRAMEWORK ${CMAKE_CURRENT_SOURCE_DIR}/common/VulkanAppFramework.h)
add_subdirectory(Vulkan)
add_subdirectory(2dVector)
add_subdirectory(GUI)

2
example/Vulkan/CMakeLists.txt
View File

@ -1,5 +1,5 @@
macro(CreateProject name)
add_executable(${name} ${ARGN})
add_executable(${name} ${ARGN} ${VULKAN_APP_FRAMEWORK})
target_link_libraries(${name} ${ULRE})
IF(WIN32)

9
example/Vulkan/DeferredModel.cpp
View File

@ -53,7 +53,7 @@ private:
struct
{
RenderTarget *rt;
GPUCmdBuffer *cmd;
RenderCommand *cmd;
public:
@ -116,7 +116,7 @@ private:
if(!gbuffer.rt)return(false);
gbuffer.cmd=device->CreateCommandBuffer(size_t(GBufferAttachment::RANGE_SIZE)+1);
gbuffer.cmd=device->CreateRenderCommandBuffer();
return(gbuffer.rt);
}
@ -298,7 +298,10 @@ private:
if(!gbuffer.cmd->BindFramebuffer(gbuffer.rt->GetRenderPass(),gbuffer.rt->GetFramebuffer()))
return(false);
render_list.Render(gbuffer.cmd);
if(!gbuffer.cmd->BeginRenderpass())
return(false);
render_list.Render(gbuffer.cmd);
gbuffer.cmd->EndRenderPass();
gbuffer.cmd->End();

26
example/Vulkan/Geometry3D.cpp
View File

@ -66,19 +66,6 @@ private:
render_root.Add(ri,mat);
}
bool InitScene()
{
Add(ro_round_rectangle,m2d);
Add(ro_plane_grid[0],m3d);
Add(ro_plane_grid[1],m3d,rotate(HGL_RAD_90,0,1,0));
Add(ro_plane_grid[2],m3d,rotate(HGL_RAD_90,1,0,0));
render_root.RefreshMatrix();
render_root.ExpendToList(&render_list);
return(true);
}
void CreateRenderObject()
{
struct PlaneGridCreateInfo pgci;
@ -121,6 +108,19 @@ private:
camera.eye.Set(200,200,200,1.0);
}
bool InitScene()
{
Add(ro_round_rectangle,m2d);
Add(ro_plane_grid[0],m3d);
Add(ro_plane_grid[1],m3d,rotate(HGL_RAD_90,0,1,0));
Add(ro_plane_grid[2],m3d,rotate(HGL_RAD_90,1,0,0));
render_root.RefreshMatrix();
render_root.ExpendToList(&render_list);
return(true);
}
public:
bool Init()

4
example/Vulkan/OffscreenRender.cpp
View File

@ -22,7 +22,7 @@ class TestApp:public CameraAppFramework
struct:public RenderObject
{
RenderTarget * render_taget =nullptr;
GPUCmdBuffer * command_buffer =nullptr;
RenderCommand * command_buffer =nullptr;
Pipeline * pipeline =nullptr;
RenderableInstance *renderable_instance =nullptr;
@ -82,7 +82,7 @@ public:
os.render_taget=device->CreateRenderTarget(&fbi);
if(!os.render_taget)return(false);
os.command_buffer=device->CreateCommandBuffer(fbi.GetAttachmentCount());
os.command_buffer=device->CreateRenderCommandBuffer();
if(!os.command_buffer)return(false);
os.material_instance=db->CreateMaterialInstance(OS_TEXT("res/material/VertexColor2D"));

24
example/common/VulkanAppFramework.h
View File

@ -53,7 +53,7 @@ protected:
int32_t swap_chain_count =0;
GPUCmdBuffer ** cmd_buf =nullptr;
RenderCommand ** cmd_buf =nullptr;
Color4f clear_color;
@ -166,23 +166,23 @@ public:
{
const VkExtent2D extent=sc_render_target->GetExtent();
cmd_buf=hgl_zero_new<GPUCmdBuffer *>(swap_chain_count);
cmd_buf=hgl_zero_new<RenderCommand *>(swap_chain_count);
for(int32_t i=0;i<swap_chain_count;i++)
cmd_buf[i]=device->CreateCommandBuffer(2);
cmd_buf[i]=device->CreateRenderCommandBuffer();
}
}
bool BuildCommandBuffer(GPUCmdBuffer *cb,RenderPass *rp,Framebuffer *fb,RenderableInstance *ri)
bool BuildCommandBuffer(RenderCommand *cb,RenderPass *rp,Framebuffer *fb,RenderableInstance *ri)
{
if(!ri)return(false);
const IndexBuffer *ib=ri->GetIndexBuffer();
cb->SetClearColor(0,clear_color.r,clear_color.g,clear_color.b);
cb->Begin();
cb->BindFramebuffer(rp,fb);
cb->SetClearColor(0,clear_color.r,clear_color.g,clear_color.b);
cb->BeginRenderpass();
cb->BindPipeline(ri->GetPipeline());
cb->BindDescriptorSets(ri->GetDescriptorSets());
cb->BindVAB(ri);
@ -198,7 +198,7 @@ public:
return(true);
}
void BuildCommandBuffer(GPUCmdBuffer *cb,RenderTarget *rt,RenderableInstance *ri)
void BuildCommandBuffer(RenderCommand *cb,RenderTarget *rt,RenderableInstance *ri)
{
if(!cb||!rt||!ri)
return;
@ -234,14 +234,14 @@ public:
{
if(!rl)return;
GPUCmdBuffer *cb=cmd_buf[index];
cb->SetClearColor(0,clear_color.r,clear_color.g,clear_color.b);
RenderCommand *cb=cmd_buf[index];
cb->Begin();
cb->BindFramebuffer(sc_render_target->GetRenderPass(),sc_render_target->GetFramebuffer(index));
rl->Render(cb);
cb->EndRenderPass();
cb->SetClearColor(0,clear_color.r,clear_color.g,clear_color.b);
cb->BeginRenderpass();
rl->Render(cb);
cb->EndRenderPass();
cb->End();
}

4
inc/hgl/graph/RenderList.h
View File

@ -11,7 +11,7 @@ namespace hgl
{
class RenderList
{
GPUCmdBuffer *cmd_buf;
RenderCommand *cmd_buf;
private:
@ -41,7 +41,7 @@ namespace hgl
void Add (SceneNode *node) {if(node)scene_node_list.Add(node);}
void Clear () {scene_node_list.ClearData();}
bool Render(GPUCmdBuffer *);
bool Render (RenderCommand *);
};//class RenderList
}//namespace graph
}//namespace hgl

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

@ -45,6 +45,8 @@ using VAB=VertexAttribBuffer;
class IndexBuffer;
class GPUCmdBuffer;
class RenderCommand;
class TextureCommand;
class RenderPass;
class GPUFence;
class GPUSemaphore;

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

@ -9,10 +9,27 @@ VK_NAMESPACE_BEGIN
//所以我们将每个对象的独立变换矩阵存在push constant中
class GPUCmdBuffer
{
protected:
VkDevice device;
VkCommandPool pool;
VkCommandBuffer cmd_buf;
public:
GPUCmdBuffer(VkDevice dev,VkCommandPool cp,VkCommandBuffer cb);
virtual ~GPUCmdBuffer();
operator VkCommandBuffer(){return cmd_buf;}
operator const VkCommandBuffer()const{return cmd_buf;}
operator const VkCommandBuffer *()const{return &cmd_buf;}
bool Begin();
bool End(){return(vkEndCommandBuffer(cmd_buf)==VK_SUCCESS);}
};//class GPUCmdBuffer
class RenderCommand:public GPUCmdBuffer
{
uint32_t cv_count;
VkClearValue *clear_values;
VkRect2D render_area;
@ -20,16 +37,16 @@ class GPUCmdBuffer
float default_line_width;
Framebuffer *fbo;
RenderPassBeginInfo rp_begin;
VkPipelineLayout pipeline_layout;
void SetFBO(Framebuffer *);
public:
GPUCmdBuffer(VkDevice dev,const uint32_t att_count,VkCommandPool cp,VkCommandBuffer cb);
~GPUCmdBuffer();
operator VkCommandBuffer(){return cmd_buf;}
operator const VkCommandBuffer()const{return cmd_buf;}
operator const VkCommandBuffer *()const{return &cmd_buf;}
RenderCommand(VkDevice dev,VkCommandPool cp,VkCommandBuffer cb);
~RenderCommand();
void SetRenderArea(const VkRect2D &ra){render_area=ra;}
void SetRenderArea(const VkExtent2D &);
@ -59,15 +76,10 @@ public:
//以上设定在Begin开始后即不可改变
bool Begin();
template<typename ...ARGS> void PipelineBarrier (ARGS...args){vkCmdPipelineBarrier (cmd_buf,args...);}
template<typename ...ARGS> void CopyBufferToImage (ARGS...args){vkCmdCopyBufferToImage(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...);}
bool BindFramebuffer(RenderPass *rp,Framebuffer *fb);
bool BeginRenderpass();
bool BindPipeline(Pipeline *p)
{
if(!p)return(false);
@ -120,7 +132,18 @@ public: //draw
void NextSubpass(){vkCmdNextSubpass(cmd_buf,VK_SUBPASS_CONTENTS_INLINE);}
void EndRenderPass(){vkCmdEndRenderPass(cmd_buf);}
bool End(){return(vkEndCommandBuffer(cmd_buf)==VK_SUCCESS);}
};//class GPUCmdBuffer
};//class RenderCommand:public GPUCmdBuffer
class TextureCommand:public GPUCmdBuffer
{
public:
using GPUCmdBuffer::GPUCmdBuffer;
template<typename ...ARGS> void PipelineBarrier (ARGS...args){vkCmdPipelineBarrier (cmd_buf,args...);}
template<typename ...ARGS> void CopyBufferToImage (ARGS...args){vkCmdCopyBufferToImage(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...);}
};//class TextureCommand:public GPUCmdBuffer
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_COMMAND_BUFFER_INCLUDE

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

@ -31,11 +31,15 @@ class GPUDevice
GPUDeviceAttribute *attr;
GPUQueue *textureSQ;
GPUCmdBuffer *texture_cmd_buf;
TextureCommand *texture_cmd_buf;
Swapchain *swapchain;
SwapchainRenderTarget *swapchainRT;
private:
VkCommandBuffer CreateCommandBuffer();
bool CreateSwapchainColorTexture();
bool CreateSwapchainDepthTexture();
@ -180,7 +184,8 @@ public: //shader & material
public: //Command GPUBuffer 相关
GPUCmdBuffer * CreateCommandBuffer(const uint32_t attachment_count);
RenderCommand * CreateRenderCommandBuffer();
TextureCommand *CreateTextureCommandBuffer();
RenderPass * CreateRenderPass( const List<VkAttachmentDescription> &desc_list,
const List<VkSubpassDescription> &subpass,

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

@ -64,7 +64,7 @@ public: //pipeline
public: // command buffer
GPUSemaphore * GetRenderCompleteSemaphore (){return render_complete_semaphore;}
virtual bool Submit (GPUCmdBuffer *,GPUSemaphore *present_complete_semaphore=nullptr);
virtual bool Submit (RenderCommand *,GPUSemaphore *present_complete_semaphore=nullptr);
};//class RenderTarget
/**

10
src/RenderDevice/CMakeLists.txt
View File

@ -75,7 +75,6 @@ SET(VK_RENDER_PASS_SOURCE ${VK_INCLUDE_PATH}/VKFramebuffer.h
${VK_INCLUDE_PATH}/VKRenderPass.h
${VK_INCLUDE_PATH}/VKRenderTarget.h
${VK_INCLUDE_PATH}/VKSwapchain.h
${VK_INCLUDE_PATH}/VKCommandBuffer.h
${VK_INCLUDE_PATH}/VKSemaphore.h
${VK_INCLUDE_PATH}/VKFence.h
VKQueue.cpp
@ -88,10 +87,16 @@ SET(VK_RENDER_PASS_SOURCE ${VK_INCLUDE_PATH}/VKFramebuffer.h
VKRenderTargetPipeline.cpp
VKSwapchainRenderTarget.cpp
VKSwapchain.cpp
VKCommandBuffer.cpp)
)
SOURCE_GROUP("Render Pass" FILES ${VK_RENDER_PASS_SOURCE})
SET(VK_CMD_BUFFER_SOURCE ${VK_INCLUDE_PATH}/VKCommandBuffer.h
VKCommandBuffer.cpp
VKCommandBufferRender.cpp)
SOURCE_GROUP("Command Buffer" FILES ${VK_CMD_BUFFER_SOURCE})
SET(VK_RENDERABLE_SOURCE ${VK_INCLUDE_PATH}/VKVertexAttributeBinding.h
${VK_INCLUDE_PATH}/VKRenderable.h
${VK_INCLUDE_PATH}/VKRenderableInstance.h
@ -122,5 +127,6 @@ add_cm_library(ULRE.VulkanRender "ULRE" ${VK_RR_SOURCE}
${VK_TEXTURE_SOURCE}
${VK_MATERIAL_SOURCE}
${VK_RENDER_PASS_SOURCE}
${VK_CMD_BUFFER_SOURCE}
${VK_RENDERABLE_SOURCE}
${VK_RENDER_DEVICE_SOURCE})

95
src/RenderDevice/VKCommandBuffer.cpp
View File

@ -1,59 +1,18 @@
#include<hgl/graph/VKCommandBuffer.h>
#include<hgl/graph/VKRenderPass.h>
#include<hgl/graph/VKFramebuffer.h>
#include<hgl/graph/VKRenderTarget.h>
#include<hgl/graph/VKPipeline.h>
#include<hgl/graph/VKBuffer.h>
#include<hgl/graph/VKMaterial.h>
#include<hgl/graph/VKRenderable.h>
#include<hgl/graph/VKRenderableInstance.h>
#include<hgl/graph/VKDescriptorSets.h>
VK_NAMESPACE_BEGIN
GPUCmdBuffer::GPUCmdBuffer(VkDevice dev,const uint32_t atta_count,VkCommandPool cp,VkCommandBuffer cb)
GPUCmdBuffer::GPUCmdBuffer(VkDevice dev,VkCommandPool cp,VkCommandBuffer cb)
{
device=dev;
pool=cp;
cmd_buf=cb;
cv_count=atta_count;
if(cv_count>0)
{
clear_values=hgl_zero_new<VkClearValue>(cv_count);
clear_values[cv_count-1].depthStencil.depth = 1.0f;
clear_values[cv_count-1].depthStencil.stencil = 0;
}
else
{
clear_values=nullptr;
}
render_area.offset.x=0;
render_area.offset.y=0;
render_area.extent.width=0;
render_area.extent.height=0;
default_line_width=1.0;
pipeline_layout=VK_NULL_HANDLE;
}
GPUCmdBuffer::~GPUCmdBuffer()
{
delete[] clear_values;
vkFreeCommandBuffers(device,pool,1,&cmd_buf);
}
void GPUCmdBuffer::SetRenderArea(const VkExtent2D &ext2d)
{
render_area.offset.x=0;
render_area.offset.y=0;
render_area.extent=ext2d;
}
bool GPUCmdBuffer::Begin()
{
CommandBufferBeginInfo cmd_buf_info;
@ -65,56 +24,4 @@ bool GPUCmdBuffer::Begin()
return(true);
}
bool GPUCmdBuffer::BindFramebuffer(RenderPass *rp,Framebuffer *fb)
{
RenderPassBeginInfo rp_begin;
render_area.offset.x=0;
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.clearValueCount = cv_count;
rp_begin.pClearValues = clear_values;
vkCmdBeginRenderPass(cmd_buf, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
viewport.x = 0;
viewport.y = 0;
viewport.minDepth = 0.0f;
viewport.maxDepth = 1.0f;
viewport.width = render_area.extent.width;
viewport.height = render_area.extent.height;
vkCmdSetViewport(cmd_buf,0,1,&viewport);
vkCmdSetScissor(cmd_buf,0,1,&render_area);
vkCmdSetLineWidth(cmd_buf,default_line_width);
pipeline_layout=VK_NULL_HANDLE;
return(true);
}
bool GPUCmdBuffer::BindVAB(RenderableInstance *ri)
{
if(!ri)
return(false);
const uint count=ri->GetBufferCount();
if(count<=0)
return(false);
vkCmdBindVertexBuffers(cmd_buf,0,count,ri->GetBuffer(),ri->GetBufferSize());
IndexBuffer *indices_buffer=ri->GetIndexBuffer();
if(indices_buffer)
vkCmdBindIndexBuffer(cmd_buf,indices_buffer->GetBuffer(),ri->GetIndexBufferOffset(),VkIndexType(indices_buffer->GetType()));
return(true);
}
VK_NAMESPACE_END

28
src/RenderDevice/VKDevice.cpp
View File

@ -47,7 +47,7 @@ bool GPUDevice::Resize(const VkExtent2D &extent)
if(!CreateSwapchain(extent))
return(false);
texture_cmd_buf=CreateCommandBuffer(0);
texture_cmd_buf=CreateTextureCommandBuffer();
textureSQ=new GPUQueue(this,attr->graphics_queue,1);
swapchainRT=new SwapchainRenderTarget(this,swapchain);
@ -55,10 +55,10 @@ bool GPUDevice::Resize(const VkExtent2D &extent)
return(true);
}
GPUCmdBuffer *GPUDevice::CreateCommandBuffer(const uint32_t attachment_count)
VkCommandBuffer GPUDevice::CreateCommandBuffer()
{
if(!attr->cmd_pool)
return(nullptr);
return(VK_NULL_HANDLE);
CommandBufferAllocateInfo cmd;
@ -71,9 +71,27 @@ GPUCmdBuffer *GPUDevice::CreateCommandBuffer(const uint32_t attachment_count)
VkResult res=vkAllocateCommandBuffers(attr->device,&cmd,&cmd_buf);
if(res!=VK_SUCCESS)
return(nullptr);
return(VK_NULL_HANDLE);
return(new GPUCmdBuffer(attr->device,attachment_count,attr->cmd_pool,cmd_buf));
return cmd_buf;
}
RenderCommand *GPUDevice::CreateRenderCommandBuffer()
{
VkCommandBuffer cb=CreateCommandBuffer();
if(cb==VK_NULL_HANDLE)return(nullptr);
return(new RenderCommand(attr->device,attr->cmd_pool,cb));
}
TextureCommand *GPUDevice::CreateTextureCommandBuffer()
{
VkCommandBuffer cb=CreateCommandBuffer();
if(cb==VK_NULL_HANDLE)return(nullptr);
return(new TextureCommand(attr->device,attr->cmd_pool,cb));
}
/**

11
src/RenderDevice/VKDeviceRenderTarget.cpp
View File

@ -44,15 +44,10 @@ RenderTarget *GPUDevice::CreateRenderTarget(const FramebufferInfo *fbi,const uin
if(fb)
{
GPUCmdBuffer *cb=CreateCommandBuffer(fb->GetAttachmentCount());
RenderTarget *rt=new RenderTarget(this,rp,fb,color_texture_list,color_count,depth_texture,fence_count);
if(cb)
{
RenderTarget *rt=new RenderTarget(this,rp,fb,color_texture_list,color_count,depth_texture,fence_count);
color_texture_list.DiscardObject();
return rt;
}
color_texture_list.DiscardObject();
return rt;
}
SAFE_CLEAR(depth_texture);

2
src/RenderDevice/VKDeviceTexture.cpp
View File

@ -50,7 +50,7 @@ namespace
}
};//
void GenerateMipmaps(GPUCmdBuffer *texture_cmd_buf,VkImage image,VkImageAspectFlags aspect_mask,const int32_t width,const int32_t height,const uint32_t mipLevels)
void GenerateMipmaps(TextureCommand *texture_cmd_buf,VkImage image,VkImageAspectFlags aspect_mask,const int32_t width,const int32_t height,const uint32_t mipLevels)
{
//VkImage image, VkFormat imageFormat, int32_t texWidth, int32_t texHeight, uint32_t mipLevels) {
// Check if image format supports linear blitting

2
src/RenderDevice/VKRenderTarget.cpp
View File

@ -62,7 +62,7 @@ RenderTarget::~RenderTarget()
SAFE_CLEAR(render_pass);
}
bool RenderTarget::Submit(GPUCmdBuffer *command_buffer,GPUSemaphore *present_complete_semaphore)
bool RenderTarget::Submit(RenderCommand *command_buffer,GPUSemaphore *present_complete_semaphore)
{
return this->GPUQueue::Submit(*command_buffer,present_complete_semaphore,render_complete_semaphore);
}

2
src/SceneGraph/RenderList.cpp
View File

@ -85,7 +85,7 @@ namespace hgl
}
}
bool RenderList::Render(GPUCmdBuffer *cb)
bool RenderList::Render(RenderCommand *cb)
{
if(!cb)
return(false);