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

finished dynamic UBO for RenderList,,,but rendering breakout error.

Browse Source
This commit is contained in:
hyzboy 2021-06-22 21:33:47 +08:00
parent bbab22304d
commit c3e9015d95
16 changed files with 152 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
example/Vulkan/DeferredModel.cpp
View File

@ -70,7 +70,7 @@ private:
struct SubpassParam struct SubpassParam
{ {
Material * material; Material * material;
MaterialParameters * material_instance; MaterialInstance * material_instance;
Pipeline * pipeline_fan; Pipeline * pipeline_fan;
Pipeline * pipeline_triangles; Pipeline * pipeline_triangles;
};// };//

4
example/Vulkan/Geometry2D.cpp
View File

@ -29,7 +29,7 @@ private:
RenderList render_list; RenderList render_list;
Material * material =nullptr; Material * material =nullptr;
MaterialParameters * material_instance =nullptr; MaterialInstance * material_instance =nullptr;
Renderable * ro_rectangle =nullptr; Renderable * ro_rectangle =nullptr;
Renderable * ro_circle =nullptr; Renderable * ro_circle =nullptr;
@ -119,7 +119,7 @@ private:
cam.Refresh(); cam.Refresh();
ubo_camera_info =CreateUBO("camera", sizeof(CameraInfo),&cam.info); ubo_camera_info =CreateUBO("camera", sizeof(CameraInfo),&cam.info);
ubo_color_material =CreateUBO("color_material",sizeof(Vector4f),&color); ubo_color_material =CreateUBO("color_material", sizeof(Vector4f),&color);
material_instance->Update(); material_instance->Update();
return(true); return(true);

68
example/Vulkan/Geometry3D.cpp
View File

@ -22,14 +22,14 @@ class TestApp:public CameraAppFramework
private: private:
SceneNode render_root; SceneNode render_root;
RenderList render_list; RenderList *render_list=nullptr;
struct MDP struct MDP
{ {
Material * material =nullptr; Material * material =nullptr;
MaterialParameters * material_instance =nullptr; MaterialInstance * material_instance =nullptr;
Pipeline * pipeline =nullptr; Pipeline * pipeline =nullptr;
}m3d,m2d; }m3d;//,m2d;
Renderable *ro_plane_grid[3], Renderable *ro_plane_grid[3],
*ro_round_rectangle =nullptr; *ro_round_rectangle =nullptr;
@ -46,10 +46,17 @@ private:
mdp->pipeline=CreatePipeline(mdp->material_instance,InlinePipeline::Solid3D,primitive); mdp->pipeline=CreatePipeline(mdp->material_instance,InlinePipeline::Solid3D,primitive);
if(!mdp->material_instance->BindUBO("camera",GetCameraInfoBuffer())) {
return(false); MaterialParameters *mp_global=mdp->material_instance->GetMP(DescriptorSetType::Global);
if(!mp_global)
return(false);
if(!mp_global->BindUBO("g_camera",GetCameraInfoBuffer()))return(false);
mp_global->Update();
}
mdp->material_instance->Update();
return(true); return(true);
} }
@ -57,14 +64,14 @@ private:
{ {
auto ri=db->CreateRenderableInstance(r,mdp.material_instance,mdp.pipeline); auto ri=db->CreateRenderableInstance(r,mdp.material_instance,mdp.pipeline);
render_root.Add(ri); render_root.CreateSubNode(ri);
} }
void Add(Renderable *r,MDP &mdp,const Matrix4f &mat) void Add(Renderable *r,MDP &mdp,const Matrix4f &mat)
{ {
auto ri=db->CreateRenderableInstance(r,mdp.material_instance,mdp.pipeline); auto ri=db->CreateRenderableInstance(r,mdp.material_instance,mdp.pipeline);
render_root.Add(ri,mat); render_root.CreateSubNode(mat,ri);
} }
void CreateRenderObject() void CreateRenderObject()
@ -96,54 +103,61 @@ private:
pgci.side_color.Set(0,0,1,1); pgci.side_color.Set(0,0,1,1);
ro_plane_grid[2]=CreateRenderablePlaneGrid(db,m3d.material,&pgci); ro_plane_grid[2]=CreateRenderablePlaneGrid(db,m3d.material,&pgci);
{ //{
struct RoundRectangleCreateInfo rrci; // struct RoundRectangleCreateInfo rrci;
rrci.scope.Set(SCREEN_WIDTH-30,10,20,20); // rrci.scope.Set(SCREEN_WIDTH-30,10,20,20);
rrci.radius=5; // rrci.radius=5;
rrci.round_per=5; // rrci.round_per=5;
ro_round_rectangle=CreateRenderableRoundRectangle(db,m2d.material,&rrci); // ro_round_rectangle=CreateRenderableRoundRectangle(db,m2d.material,&rrci);
} //}
camera->pos.Set(200,200,200,1.0); camera->pos.Set(200,200,200,1.0);
} }
bool InitScene() bool InitScene()
{ {
Add(ro_round_rectangle,m2d); // Add(ro_round_rectangle,m2d);
Add(ro_plane_grid[0],m3d); Add(ro_plane_grid[0],m3d);
Add(ro_plane_grid[1],m3d,rotate(HGL_RAD_90,0,1,0)); 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)); Add(ro_plane_grid[2],m3d,rotate(HGL_RAD_90,1,0,0));
render_root.RefreshMatrix(); render_root.RefreshMatrix();
render_root.ExpendToList(&render_list); render_list->Expend(camera->info,&render_root);
return(true); return(true);
} }
public: public:
~TestApp()
{
SAFE_CLEAR(render_list);
}
bool Init() bool Init()
{ {
if(!CameraAppFramework::Init(SCREEN_WIDTH,SCREEN_HEIGHT)) if(!CameraAppFramework::Init(SCREEN_WIDTH,SCREEN_HEIGHT))
return(false); return(false);
render_list=new RenderList(device);
if(!InitMDP(&m3d,Prim::Lines,OS_TEXT("res/material/VertexColor3D"))) if(!InitMDP(&m3d,Prim::Lines,OS_TEXT("res/material/VertexColor3D")))
return(false); return(false);
if(!InitMDP(&m2d,Prim::Fan, OS_TEXT("res/material/PureColor2D"))) //if(!InitMDP(&m2d,Prim::Fan, OS_TEXT("res/material/PureColor2D")))
return(false); // return(false);
{ //{
color.Set(1,1,0,1); // color.Set(1,1,0,1);
ubo_color=device->CreateUBO(sizeof(Vector4f),&color); // ubo_color=device->CreateUBO(sizeof(Vector4f),&color);
m2d.material_instance->BindUBO("color_material",ubo_color); // m2d.material_instance->BindUBO("color_material",ubo_color);
m2d.material_instance->Update(); // m2d.material_instance->Update();
db->Add(ubo_color); // db->Add(ubo_color);
} //}
CreateRenderObject(); CreateRenderObject();
@ -155,7 +169,7 @@ public:
void BuildCommandBuffer(uint32 index) void BuildCommandBuffer(uint32 index)
{ {
VulkanApplicationFramework::BuildCommandBuffer(index,&render_list); VulkanApplicationFramework::BuildCommandBuffer(index,render_list);
} }
};//class TestApp:public CameraAppFramework };//class TestApp:public CameraAppFramework

23
example/Vulkan/HQFilterTexture.cpp
View File

@ -54,7 +54,7 @@ private:
struct MIR struct MIR
{ {
MaterialParameters * material_instance =nullptr; MaterialInstance * material_instance =nullptr;
RenderableInstance *renderable_instance =nullptr; RenderableInstance *renderable_instance =nullptr;
}mir_nearest,mir_linear,mir_nearest_hq,mir_linear_hq; }mir_nearest,mir_linear,mir_nearest_hq,mir_linear_hq;
@ -64,8 +64,9 @@ private:
VAB * tex_coord_buffer =nullptr; VAB * tex_coord_buffer =nullptr;
IndexBuffer * index_buffer =nullptr; IndexBuffer * index_buffer =nullptr;
SceneNode render_root; SceneNode render_root;
RenderList render_list; RenderList render_list;
public: public:
~TestApp() ~TestApp()
@ -160,9 +161,17 @@ private:
{ {
mir->material_instance=db->CreateMaterialInstance(mp->material); mir->material_instance=db->CreateMaterialInstance(mp->material);
if(!mir->material_instance)return(false); if(!mir->material_instance)return(false);
{
MaterialParameters *mp_texture=mir->material_instance->GetMP(DescriptorSetType::Value);
if(!mp_texture)
return(false);
if(!mir->material_instance->BindSampler("tex",texture,sampler))return(false); if(!mp_texture->BindSampler("tex",texture,sampler))return(false);
mir->material_instance->Update();
mp_texture->Update();
}
mir->renderable_instance=db->CreateRenderableInstance(render_obj,mir->material_instance,mp->pipeline); mir->renderable_instance=db->CreateRenderableInstance(render_obj,mir->material_instance,mp->pipeline);
@ -174,7 +183,7 @@ private:
bool Add(struct MIR *mir,const Matrix4f &offset) bool Add(struct MIR *mir,const Matrix4f &offset)
{ {
render_root.Add(mir->renderable_instance,offset); render_root.CreateSubNode(offset,mir->renderable_instance);
return(true); return(true);
} }
@ -187,7 +196,7 @@ private:
Add(&mir_linear_hq, translate( 0, 0,0)); Add(&mir_linear_hq, translate( 0, 0,0));
render_root.RefreshMatrix(); render_root.RefreshMatrix();
render_root.ExpendToList(&render_list); render_list.Expend(&render_root);
BuildCommandBuffer(&render_list); BuildCommandBuffer(&render_list);
return(true); return(true);
} }

2
example/common/VulkanAppFramework.h
View File

@ -105,7 +105,7 @@ public:
cili.lunarg.standard_validation = true; cili.lunarg.standard_validation = true;
cili.khronos.validation = true; cili.khronos.validation = true;
// cili.RenderDoc.Capture = true; cili.RenderDoc.Capture = true;
inst=CreateInstance("VulkanTest",nullptr,&cili); inst=CreateInstance("VulkanTest",nullptr,&cili);

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

@ -31,6 +31,8 @@ namespace hgl
CompOperatorMemcmp(const MVPMatrix &); CompOperatorMemcmp(const MVPMatrix &);
};//struct MVPMatrix };//struct MVPMatrix
constexpr size_t MVPMatrixBytes=sizeof(MVPMatrix);
}//namespace graph }//namespace graph
}//namespace hgl }//namespace hgl
#endif//HGL_GRAPH_SCENE_INFO_INCLUDE #endif//HGL_GRAPH_SCENE_INFO_INCLUDE

14
inc/hgl/graph/VKArrayBuffer.h
View File

@ -33,16 +33,17 @@ namespace hgl
buffer_usage_flags=flags; buffer_usage_flags=flags;
{ {
uint32_t unit_size=sizeof(T); ubo_offset_alignment=device->GetUBOAlign();
vk_ma=new VKMemoryAllocator(device,buffer_usage_flags); // construct function is going to set AllocUnitSize by minUniformOffsetAlignment
MemoryBlock *mb=new MemoryBlock(vk_ma);
ubo_offset_alignment=vk_ma->GetAllocUnitSize(); uint32_t unit_size=sizeof(T);
const uint32_t align_size=ubo_offset_alignment-1; const uint32_t align_size=ubo_offset_alignment-1;
unit_size=(unit_size+align_size)&(~align_size); unit_size=(unit_size+align_size)&(~align_size);
vk_ma=new VKMemoryAllocator(device,buffer_usage_flags,unit_size); // construct function is going to set AllocUnitSize by minUniformOffsetAlignment
MemoryBlock *mb=new MemoryBlock(vk_ma);
coll=new Collection(unit_size,mb); coll=new Collection(unit_size,mb);
} }
} }
@ -84,6 +85,11 @@ namespace hgl
{ {
return (T *)(coll->Map(start,count)); return (T *)(coll->Map(start,count));
} }
void Flush(const uint32 count)
{
vk_ma->Flush(count*GetUnitSize());
}
};//class GPUArrayBuffer };//class GPUArrayBuffer
}//namespace graph }//namespace graph
}//namespace hgl }//namespace hgl

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

@ -100,12 +100,16 @@ public: //内存相关
private: //Buffer相关 private: //Buffer相关
bool CreateBuffer(GPUBufferData *buf,VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data,SharingMode sharing_mode); bool CreateBuffer(GPUBufferData *buf,VkBufferUsageFlags buf_usage,VkDeviceSize range,VkDeviceSize size,const void *data,SharingMode sharing_mode);
bool CreateBuffer(GPUBufferData *buf,VkBufferUsageFlags buf_usage, VkDeviceSize size,const void *data,SharingMode sharing_mode){return CreateBuffer(buf,buf_usage,size,size,data,sharing_mode);}
public: //Buffer相关 public: //Buffer相关
GPUBuffer * CreateBuffer(VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data, SharingMode sm=SharingMode::Exclusive); GPUBuffer * CreateBuffer(VkBufferUsageFlags buf_usage,VkDeviceSize range,VkDeviceSize size,const void *data, SharingMode sm=SharingMode::Exclusive);
GPUBuffer * CreateBuffer(VkBufferUsageFlags buf_usage,VkDeviceSize size, SharingMode sm=SharingMode::Exclusive){return CreateBuffer(buf_usage,size,nullptr,sm);} GPUBuffer * CreateBuffer(VkBufferUsageFlags buf_usage,VkDeviceSize range,VkDeviceSize size, SharingMode sm=SharingMode::Exclusive){return CreateBuffer(buf_usage,range,size,nullptr,sm);}
GPUBuffer * CreateBuffer(VkBufferUsageFlags buf_usage, VkDeviceSize size,const void *data, SharingMode sm=SharingMode::Exclusive){return CreateBuffer(buf_usage,size,size,data,sm);}
GPUBuffer * CreateBuffer(VkBufferUsageFlags buf_usage, VkDeviceSize size, SharingMode sm=SharingMode::Exclusive){return CreateBuffer(buf_usage,size,size,nullptr,sm);}
VAB * CreateVAB (VkFormat format, uint32_t count,const void *data, SharingMode sm=SharingMode::Exclusive); VAB * CreateVAB (VkFormat format, uint32_t count,const void *data, SharingMode sm=SharingMode::Exclusive);
VAB * CreateVAB (VkFormat format, uint32_t count, SharingMode sm=SharingMode::Exclusive){return CreateVAB(format,count,nullptr,sm);} VAB * CreateVAB (VkFormat format, uint32_t count, SharingMode sm=SharingMode::Exclusive){return CreateVAB(format,count,nullptr,sm);}
@ -119,8 +123,12 @@ public: //Buffer相关
IndexBuffer * CreateIBO16 ( uint32_t count, SharingMode sm=SharingMode::Exclusive){return CreateIBO(IndexType::U16, count,nullptr,sm);} IndexBuffer * CreateIBO16 ( uint32_t count, SharingMode sm=SharingMode::Exclusive){return CreateIBO(IndexType::U16, count,nullptr,sm);}
IndexBuffer * CreateIBO32 ( uint32_t count, SharingMode sm=SharingMode::Exclusive){return CreateIBO(IndexType::U32, count,nullptr,sm);} IndexBuffer * CreateIBO32 ( uint32_t count, SharingMode sm=SharingMode::Exclusive){return CreateIBO(IndexType::U32, count,nullptr,sm);}
#define CREATE_BUFFER_OBJECT(LargeName,type) GPUBuffer *Create##LargeName( VkDeviceSize size,void *data, SharingMode sm=SharingMode::Exclusive) {return CreateBuffer(VK_BUFFER_USAGE_##type##_BUFFER_BIT,size,data, sm);} \ const VkDeviceSize GetUBOAlign();
GPUBuffer *Create##LargeName( VkDeviceSize size, SharingMode sm=SharingMode::Exclusive) {return CreateBuffer(VK_BUFFER_USAGE_##type##_BUFFER_BIT,size,nullptr, sm);}
#define CREATE_BUFFER_OBJECT(LargeName,type) GPUBuffer *Create##LargeName( VkDeviceSize size,void *data, SharingMode sm=SharingMode::Exclusive) {return CreateBuffer(VK_BUFFER_USAGE_##type##_BUFFER_BIT,size ,size,data, sm);} \
GPUBuffer *Create##LargeName( VkDeviceSize size, SharingMode sm=SharingMode::Exclusive) {return CreateBuffer(VK_BUFFER_USAGE_##type##_BUFFER_BIT,size ,size,nullptr, sm);} \
GPUBuffer *Create##LargeName(VkDeviceSize range,VkDeviceSize size,void *data, SharingMode sm=SharingMode::Exclusive) {return CreateBuffer(VK_BUFFER_USAGE_##type##_BUFFER_BIT,range,size,data, sm);} \
GPUBuffer *Create##LargeName(VkDeviceSize range,VkDeviceSize size, SharingMode sm=SharingMode::Exclusive) {return CreateBuffer(VK_BUFFER_USAGE_##type##_BUFFER_BIT,range,size,nullptr, sm);}
CREATE_BUFFER_OBJECT(UBO,UNIFORM) CREATE_BUFFER_OBJECT(UBO,UNIFORM)
CREATE_BUFFER_OBJECT(SSBO,STORAGE) CREATE_BUFFER_OBJECT(SSBO,STORAGE)

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

@ -13,6 +13,8 @@ class VKMemoryAllocator:public AbstractMemoryAllocator
GPUBuffer *gpu_buffer; GPUBuffer *gpu_buffer;
VkDeviceSize range; //ubo之类需要一个一次访问范围
protected: protected:
bool AllocMemory() override; bool AllocMemory() override;
@ -27,10 +29,12 @@ public:
public: public:
VKMemoryAllocator(GPUDevice *,const uint32_t flags); VKMemoryAllocator(GPUDevice *,const uint32_t flags,const VkDeviceSize r);
~VKMemoryAllocator(); ~VKMemoryAllocator();
void Free() override {/* DON'T RUN ANY OPERATION.*/} void Free() override {/* DON'T RUN ANY OPERATION.*/}
void Flush(const VkDeviceSize);
};//class VKMemoryAllocator:public AbstractMemoryAllocator };//class VKMemoryAllocator:public AbstractMemoryAllocator
VK_NAMESPACE_END VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_MEMORY_ALLOCATOR_INCLUDE #endif//HGL_GRAPH_VULKAN_MEMORY_ALLOCATOR_INCLUDE

12
inc/hgl/graph/shader/ShaderResource.h
View File

@ -25,7 +25,9 @@ using ShaderStageList =ObjectList<ShaderStage>;
struct ShaderDescriptor struct ShaderDescriptor
{ {
char name[128]; char name[128];
DescriptorSetType type;
VkDescriptorType desc_type;
DescriptorSetType set_type;
uint32_t set; uint32_t set;
uint32_t binding; uint32_t binding;
}; };
@ -80,13 +82,15 @@ public:
ShaderDescriptorList * GetDescriptorList (VkDescriptorType desc_type) ShaderDescriptorList * GetDescriptorList (VkDescriptorType desc_type)
{ {
if(desc_type<VK_DESCRIPTOR_TYPE_BEGIN_RANGE if(desc_type<VK_DESCRIPTOR_TYPE_BEGIN_RANGE
||desc_type>VK_DESCRIPTOR_TYPE_END_RANGE)return nullptr; ||desc_type>VK_DESCRIPTOR_TYPE_END_RANGE)return nullptr;
return descriptor_list+desc_type; return descriptor_list+desc_type;
} }
ShaderDescriptorList &GetUBO (){return descriptor_list[VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER];} ShaderDescriptorList &GetUBO (){return descriptor_list[VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER];}
ShaderDescriptorList &GetSSBO (){return descriptor_list[VK_DESCRIPTOR_TYPE_STORAGE_BUFFER];} ShaderDescriptorList &GetSSBO (){return descriptor_list[VK_DESCRIPTOR_TYPE_STORAGE_BUFFER];}
ShaderDescriptorList &GetUBODynamic (){return descriptor_list[VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC];}
ShaderDescriptorList &GetSSBODynamic(){return descriptor_list[VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC];}
ShaderDescriptorList &GetSampler(){return descriptor_list[VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER];} ShaderDescriptorList &GetSampler(){return descriptor_list[VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER];}
const int GetBinding (VkDescriptorType desc_type,const AnsiString &name)const; const int GetBinding (VkDescriptorType desc_type,const AnsiString &name)const;

2
res

@ -1 +1 @@
Subproject commit 179d904193cfbd0a3292fd7e7d0ed034011ed15d Subproject commit 9f031f98a611172812ceb4094af0f032218c5e91

13
src/SceneGraph/RenderList.cpp
View File

@ -137,12 +137,14 @@ namespace hgl
for(RenderNode *node:render_node_list) //未来可能要在Expend处考虑做去重 for(RenderNode *node:render_node_list) //未来可能要在Expend处考虑做去重
{ {
memcpy(mp,&(node->matrix),sizeof(MVPMatrix)); memcpy(mp,&(node->matrix),MVPMatrixBytes);
mp+=ubo_align; mp+=ubo_align;
(*ri)=node->ri; (*ri)=node->ri;
++ri; ++ri;
} }
mvp_array->Flush(count);
} }
} }
@ -152,7 +154,10 @@ namespace hgl
MaterialParameters *mp=mtl->GetMP(DescriptorSetType::Renderable); MaterialParameters *mp=mtl->GetMP(DescriptorSetType::Renderable);
if(mp) if(mp)
mp->BindUBO("r_scene_info",mvp_array->GetBuffer(),false); {
mp->BindUBO("r_scene_info",mvp_array->GetBuffer(),true);
mp->Update();
}
} }
} }
@ -218,9 +223,9 @@ namespace hgl
{ {
mp=ri->GetMP((DescriptorSetType)i); mp=ri->GetMP((DescriptorSetType)i);
if(last_mp[i]!=mp) // if(last_mp[i]!=mp)
{ {
last_mp[i]=mp; //last_mp[i]=mp;
if(mp) if(mp)
{ {

18
src/SceneGraph/Vulkan/VKDescriptorSetLayoutCreater.cpp
View File

@ -34,9 +34,9 @@ void DescriptorSetLayoutCreater::Bind(const ShaderDescriptorList *sd_list,VkDesc
for(const ShaderDescriptor &sd:*sd_list) for(const ShaderDescriptor &sd:*sd_list)
{ {
all_set.Add(sd.type); all_set.Add(sd.set_type);
++binding_count[(size_t)sd.type]; ++binding_count[(size_t)sd.set_type];
} }
ENUM_CLASS_FOR(DescriptorSetType,int,i) ENUM_CLASS_FOR(DescriptorSetType,int,i)
@ -54,16 +54,16 @@ void DescriptorSetLayoutCreater::Bind(const ShaderDescriptorList *sd_list,VkDesc
if(!all_binding.IsMember(sd.binding)) if(!all_binding.IsMember(sd.binding))
{ {
p[(size_t)sd.type]->binding = sd.binding; p[(size_t)sd.set_type]->binding = sd.binding;
p[(size_t)sd.type]->descriptorType = desc_type; p[(size_t)sd.set_type]->descriptorType = sd.desc_type;
p[(size_t)sd.type]->descriptorCount = 1; p[(size_t)sd.set_type]->descriptorCount = 1;
p[(size_t)sd.type]->stageFlags = stageFlags; p[(size_t)sd.set_type]->stageFlags = stageFlags;
p[(size_t)sd.type]->pImmutableSamplers = nullptr; p[(size_t)sd.set_type]->pImmutableSamplers = nullptr;
all_binding.Add(sd.binding); all_binding.Add(sd.binding);
++p[(size_t)sd.type]; ++p[(size_t)sd.set_type];
++fin_count[(size_t)sd.type]; ++fin_count[(size_t)sd.set_type];
} }
} }

17
src/SceneGraph/Vulkan/VKDeviceBuffer.cpp
View File

@ -1,9 +1,15 @@
#include<hgl/graph/VKDevice.h> #include<hgl/graph/VKDevice.h>
#include<hgl/graph/VKIndexBuffer.h> #include<hgl/graph/VKIndexBuffer.h>
#include<hgl/graph/VKVertexAttribBuffer.h> #include<hgl/graph/VKVertexAttribBuffer.h>
#include<hgl/graph/VKPhysicalDevice.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
bool GPUDevice::CreateBuffer(GPUBufferData *buf,VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data,SharingMode sharing_mode) const VkDeviceSize GPUDevice::GetUBOAlign()
{
return attr->physical_device->GetUBOAlign();
}
bool GPUDevice::CreateBuffer(GPUBufferData *buf,VkBufferUsageFlags buf_usage,VkDeviceSize range,VkDeviceSize size,const void *data,SharingMode sharing_mode)
{ {
BufferCreateInfo buf_info; BufferCreateInfo buf_info;
@ -26,14 +32,13 @@ bool GPUDevice::CreateBuffer(GPUBufferData *buf,VkBufferUsageFlags buf_usage,VkD
{ {
buf->info.buffer =buf->buffer; buf->info.buffer =buf->buffer;
buf->info.offset =0; buf->info.offset =0;
buf->info.range =size; buf->info.range =range;
buf->memory =dm; buf->memory =dm;
if(!data) if(!data)
return(true); return(true);
dm->Write(data,0,size);
return(true); return(true);
} }
@ -57,7 +62,7 @@ VAB *GPUDevice::CreateVAB(VkFormat format,uint32_t count,const void *data,Sharin
GPUBufferData buf; GPUBufferData buf;
if(!CreateBuffer(&buf,VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,size,data,sharing_mode)) if(!CreateBuffer(&buf,VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,size,size,data,sharing_mode))
return(nullptr); return(nullptr);
return(new VertexAttribBuffer(attr->device,buf,format,stride,count)); return(new VertexAttribBuffer(attr->device,buf,format,stride,count));
@ -81,11 +86,11 @@ IndexBuffer *GPUDevice::CreateIBO(IndexType index_type,uint32_t count,const void
return(new IndexBuffer(attr->device,buf,index_type,count)); return(new IndexBuffer(attr->device,buf,index_type,count));
} }
GPUBuffer *GPUDevice::CreateBuffer(VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data,SharingMode sharing_mode) GPUBuffer *GPUDevice::CreateBuffer(VkBufferUsageFlags buf_usage,VkDeviceSize range,VkDeviceSize size,const void *data,SharingMode sharing_mode)
{ {
GPUBufferData buf; GPUBufferData buf;
if(!CreateBuffer(&buf,buf_usage,size,data,sharing_mode)) if(!CreateBuffer(&buf,buf_usage,range,size,data,sharing_mode))
return(nullptr); return(nullptr);
return(new GPUBuffer(attr->device,buf)); return(new GPUBuffer(attr->device,buf));

14
src/SceneGraph/Vulkan/VKMemoryAllocator.cpp
View File

@ -4,15 +4,14 @@
#include<hgl/graph/VKBuffer.h> #include<hgl/graph/VKBuffer.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
VKMemoryAllocator::VKMemoryAllocator(GPUDevice *d,const uint32_t flags) VKMemoryAllocator::VKMemoryAllocator(GPUDevice *d,const uint32_t flags,const VkDeviceSize r)
{ {
device=d; device=d;
buffer_usage_flag_bits=flags; buffer_usage_flag_bits=flags;
gpu_buffer=nullptr; gpu_buffer=nullptr;
range=r;
const GPUPhysicalDevice *pd=device->GetPhysicalDevice(); SetAllocUnitSize(range);
SetAllocUnitSize(pd->GetUBOAlign());
} }
VKMemoryAllocator::~VKMemoryAllocator() VKMemoryAllocator::~VKMemoryAllocator()
@ -29,7 +28,7 @@ bool VKMemoryAllocator::AllocMemory()
if(gpu_buffer) if(gpu_buffer)
delete gpu_buffer; delete gpu_buffer;
gpu_buffer=device->CreateBuffer(buffer_usage_flag_bits,alloc_size); gpu_buffer=device->CreateBuffer(buffer_usage_flag_bits,range,alloc_size);
if(!gpu_buffer) if(!gpu_buffer)
{ {
@ -41,4 +40,9 @@ bool VKMemoryAllocator::AllocMemory()
return(true); return(true);
} }
void VKMemoryAllocator::Flush(const VkDeviceSize size)
{
gpu_buffer->Flush(size);
}
VK_NAMESPACE_END VK_NAMESPACE_END

17
src/SceneGraph/shader/ShaderResource.cpp
View File

@ -68,7 +68,7 @@ VK_NAMESPACE_BEGIN
return data; return data;
} }
const uint8 *LoadShaderDescriptor(const uint8_t version,ShaderDescriptorList *sd_list,const uint8 *data) const uint8 *LoadShaderDescriptor(const uint8_t version,ShaderDescriptorList *sd_list,const VkDescriptorType desc_type,const uint8 *data)
{ {
const uint32 total_bytes=AccessByPointer(data,uint32); const uint32 total_bytes=AccessByPointer(data,uint32);
@ -94,7 +94,18 @@ VK_NAMESPACE_BEGIN
sd->name[str_len]=0; sd->name[str_len]=0;
data+=str_len; data+=str_len;
sd->type=CheckDescriptorSetType(sd->name); sd->set_type=CheckDescriptorSetType(sd->name);
if(sd->set_type==DescriptorSetType::Renderable)
{
if(desc_type==VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER)sd->desc_type=VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;else
if(desc_type==VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)sd->desc_type=VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;else
sd->desc_type=desc_type;
}
else
{
sd->desc_type=desc_type;
}
++sd; ++sd;
} }
@ -223,7 +234,7 @@ VK_NAMESPACE_BEGIN
{ {
desc_type=AccessByPointer(filedata,uint32); desc_type=AccessByPointer(filedata,uint32);
filedata=LoadShaderDescriptor(version,sr->GetDescriptorList((VkDescriptorType)desc_type),filedata); filedata=LoadShaderDescriptor(version,sr->GetDescriptorList((VkDescriptorType)desc_type),(VkDescriptorType)desc_type,filedata);
} }
return sr; return sr;