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

new MaterialDescriptorSets

Browse Source
This commit is contained in:
hyzboy 2021-09-13 20:39:25 +08:00
parent ba6367556b
commit e259b76653
19 changed files with 394 additions and 396 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -14,6 +14,18 @@
VK_NAMESPACE_BEGIN
#ifndef VK_DESCRIPTOR_TYPE_BEGIN_RANGE
constexpr size_t VK_DESCRIPTOR_TYPE_BEGIN_RANGE=VK_DESCRIPTOR_TYPE_SAMPLER;
#endif//VK_DESCRIPTOR_TYPE_BEGIN_RANGE
#ifndef VK_DESCRIPTOR_TYPE_END_RANGE
constexpr size_t VK_DESCRIPTOR_TYPE_END_RANGE=VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
#endif//VK_DESCRIPTOR_TYPE_END_RANGE
#ifndef VK_DESCRIPTOR_TYPE_RANGE_SIZE
constexpr size_t VK_DESCRIPTOR_TYPE_RANGE_SIZE=VK_DESCRIPTOR_TYPE_END_RANGE-VK_DESCRIPTOR_TYPE_BEGIN_RANGE+1;
#endif//VK_DESCRIPTOR_TYPE_RANGE_SIZE
using CharPointerList=hgl::List<const char *>;
using BindingMapping=Map<uint32_t,int>;
@ -78,6 +90,7 @@ class ShaderResource;
class ShaderModule;
class VertexShaderModule;
class ShaderModuleMap;
class MaterialDescriptorSets;
class Material;
class MaterialParameters;

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

@ -191,7 +191,7 @@ public: //
public: //shader & material
DescriptorSetLayoutCreater *CreateDescriptorSetLayoutCreater();
DescriptorSetLayoutCreater *CreateDescriptorSetLayoutCreater(const MaterialDescriptorSets *);
ShaderModule *CreateShaderModule(ShaderResource *);

10
inc/hgl/graph/VKMaterial.h
View File

@ -18,8 +18,10 @@ class Material
UTF8String mtl_name;
ShaderModuleMap *shader_maps;
MaterialDescriptorSets *mds;
VertexShaderModule *vertex_sm;
List<VkPipelineShaderStageCreateInfo> *shader_stage_list;
List<VkPipelineShaderStageCreateInfo> shader_stage_list;
DescriptorSetLayoutCreater *dsl_creater;
@ -29,15 +31,15 @@ class Material
public:
Material(const UTF8String &name,ShaderModuleMap *smm,List<VkPipelineShaderStageCreateInfo> *,DescriptorSetLayoutCreater *dslc);
Material(const UTF8String &name,ShaderModuleMap *smm,MaterialDescriptorSets *_mds,DescriptorSetLayoutCreater *);
~Material();
const UTF8String & GetName ()const{return mtl_name;}
const VertexShaderModule * GetVertexShaderModule ()const{return vertex_sm;}
const uint32_t GetStageCount ()const{return shader_stage_list->GetCount();}
const VkPipelineShaderStageCreateInfo * GetStages ()const{return shader_stage_list->GetData();}
const uint32_t GetStageCount ()const{return shader_stage_list.GetCount();}
const VkPipelineShaderStageCreateInfo * GetStages ()const{return shader_stage_list.GetData();}
const VkPipelineLayout GetPipelineLayout ()const;

82
inc/hgl/graph/VKMaterialDescriptorSets.h Normal file
View File

@ -0,0 +1,82 @@
#ifndef HGL_GRAPH_VULKAN_MATERIAL_DESCRIPTOR_SETS_INCLUDE
#define HGL_GRAPH_VULKAN_MATERIAL_DESCRIPTOR_SETS_INCLUDE
#include<hgl/graph/VK.h>
VK_NAMESPACE_BEGIN
struct ShaderDescriptor
{
char name[128];
VkDescriptorType desc_type;
DescriptorSetType set_type;
uint32_t set;
uint32_t binding;
uint32_t stage_flag;
};
using ShaderDescriptorList=List<ShaderDescriptor *>;
class MaterialDescriptorSets
{
ShaderDescriptor *sd_list;
uint sd_count;
ShaderDescriptorList descriptor_list[VK_DESCRIPTOR_TYPE_RANGE_SIZE];
Map<AnsiString,ShaderDescriptor *> sd_by_name;
Map<AnsiString,int> binding_map[VK_DESCRIPTOR_TYPE_RANGE_SIZE];
int *binding_list[VK_DESCRIPTOR_TYPE_RANGE_SIZE];
private:
struct ShaderDescriptorSet
{
uint32_t count;
VkDescriptorSetLayoutBinding *binding_list;
};
ShaderDescriptorSet sds[size_t(DescriptorSetType::RANGE_SIZE)];
public:
MaterialDescriptorSets(ShaderDescriptor *,const uint);
~MaterialDescriptorSets();
const ShaderDescriptorList * GetDescriptorList ()const {return descriptor_list;}
ShaderDescriptorList * GetDescriptorList (VkDescriptorType desc_type)
{
if(desc_type<VK_DESCRIPTOR_TYPE_BEGIN_RANGE
||desc_type>VK_DESCRIPTOR_TYPE_END_RANGE)return nullptr;
return descriptor_list+desc_type;
}
//ShaderDescriptorList &GetUBO (){return descriptor_list[VK_DESCRIPTOR_TYPE_UNIFORM_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];}
const int GetBinding(const VkDescriptorType &desc_type,const AnsiString &name)const;
const int GetUBO(const AnsiString &name)const{return GetBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,name);}
const int GetSSBO(const AnsiString &name)const{return GetBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,name);}
const int GetSampler(const AnsiString &name)const{return GetBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,name);}
const int *GetBindingList(const VkDescriptorType &desc_type)const
{
if(desc_type<VK_DESCRIPTOR_TYPE_BEGIN_RANGE
||desc_type>VK_DESCRIPTOR_TYPE_END_RANGE)return nullptr;
return binding_list[(size_t)desc_type];
}
const int GetSetBindingCount(const DescriptorSetType &type)const{return sds[(size_t)type].count;}
const VkDescriptorSetLayoutBinding *GetSetBindingList(const DescriptorSetType &type)const{return sds[(size_t)type].binding_list;}
};//class MaterialDescriptorSets
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_MATERIAL_DESCRIPTOR_SETS_INCLUDE

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

@ -7,7 +7,7 @@
VK_NAMESPACE_BEGIN
class MaterialParameters
{
const ShaderModuleMap *shader_map;
const MaterialDescriptorSets *mds;
DescriptorSetType ds_type;
@ -17,7 +17,7 @@ private:
friend class Material;
MaterialParameters(const ShaderModuleMap *,const DescriptorSetType &type,DescriptorSets *);
MaterialParameters(const MaterialDescriptorSets *,const DescriptorSetType &type,DescriptorSets *);
public:

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

@ -1,7 +1,7 @@
#ifndef HGL_GRAPH_VULKAN_SHADER_MODULE_INCLUDE
#define HGL_GRAPH_VULKAN_SHADER_MODULE_INCLUDE
#include<hgl/graph/shader/ShaderResource.h>
#include<hgl/graph/VKShaderResource.h>
#include<hgl/type/Sets.h>
VK_NAMESPACE_BEGIN
@ -45,13 +45,6 @@ public:
const bool IsMesh ()const{return stage_create_info->stage==VK_SHADER_STAGE_MESH_BIT_NV;}
const VkPipelineShaderStageCreateInfo * GetCreateInfo ()const{return stage_create_info;}
const int GetBinding (VkDescriptorType desc_type,const AnsiString &name)const
{
return shader_resource->GetBinding(desc_type,name);
}
const ShaderDescriptorList * GetDescriptorList()const{return shader_resource->GetDescriptorList();}
};//class ShaderModule
class VertexAttributeBinding;

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

@ -17,30 +17,6 @@ public:
~ShaderModuleMap()=default;
bool Add(const ShaderModule *sm);
public:
const int GetBinding(VkDescriptorType,const AnsiString &)const;
#define GET_BO_BINDING(name,vk_name) const int Get##name(const AnsiString &obj_name)const{return GetBinding(VK_DESCRIPTOR_TYPE_##vk_name,obj_name);}
// GET_BO_BINDING(Sampler, SAMPLER)
GET_BO_BINDING(Sampler, COMBINED_IMAGE_SAMPLER)
// GET_BO_BINDING(SampledImage, SAMPLED_IMAGE)
GET_BO_BINDING(StorageImage, STORAGE_IMAGE)
GET_BO_BINDING(UTBO, UNIFORM_TEXEL_BUFFER)
GET_BO_BINDING(SSTBO, STORAGE_TEXEL_BUFFER)
GET_BO_BINDING(UBO, UNIFORM_BUFFER)
GET_BO_BINDING(SSBO, STORAGE_BUFFER)
//shader中并不区分普通UBO和动态UBO，所以Material/ShaderResource中的数据，只有UBO
// GET_BO_BINDING(UBODynamic, UNIFORM_BUFFER_DYNAMIC)
// GET_BO_BINDING(SSBODynamic, STORAGE_BUFFER_DYNAMIC)
GET_BO_BINDING(InputAttachment, INPUT_ATTACHMENT)
#undef GET_BO_BINDING
};//class ShaderModuleMap:public Map<VkShaderStageFlagBits,const ShaderModule *>
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_SHADER_MODULE_MAP_INCLUDE

71
inc/hgl/graph/VKShaderResource.h Normal file
View File

@ -0,0 +1,71 @@
#ifndef HGL_GRAPH_VULKAN_SHADER_RESOURCE_INCLUDE
#define HGL_GRAPH_VULKAN_SHADER_RESOURCE_INCLUDE
#include<hgl/type/String.h>
#include<hgl/type/List.h>
#include<hgl/type/StringList.h>
#include<hgl/graph/VK.h>
VK_NAMESPACE_BEGIN
struct ShaderStage
{
AnsiString name;
uint location;
VertexAttribType type; ///<成份数量(如vec4中的4)
VkFormat format; ///<对应的Vulkan格式(如vec4对应的FMT_RGBA32F)
uint binding;
bool global; ///<是否全局数据
bool dynamic; ///<是否动态数量
};//struct ShaderStage
using ShaderStageList =ObjectList<ShaderStage>;
class ShaderResource
{
VkShaderStageFlagBits stage_flag;
const void *spv_data;
uint32 spv_size;
ShaderStageList stage_inputs;
ShaderStageList stage_outputs;
public:
ShaderResource(const VkShaderStageFlagBits &,const void *,const uint32);
virtual ~ShaderResource()=default;
const VkShaderStageFlagBits GetStage ()const {return stage_flag;}
const os_char * GetStageName ()const;
const uint32_t * GetCode ()const {return (uint32_t *)spv_data;}
const uint32_t GetCodeSize ()const {return spv_size;}
ShaderStageList & GetStageInputs () {return stage_inputs;}
ShaderStageList & GetStageOutputs () {return stage_outputs;}
const uint GetStageInputCount ()const {return stage_inputs.GetCount();}
const uint GetStageOutputCount ()const {return stage_outputs.GetCount();}
const ShaderStage * GetStageInput (const AnsiString &)const;
const int GetStageInputBinding(const AnsiString &)const;
};//class ShaderResource
ShaderResource *LoadShaderResource(const uint8 *origin_filedata,const int64 filesize);
struct ShaderModuleCreateInfo:public vkstruct_flag<VkShaderModuleCreateInfo,VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO>
{
public:
ShaderModuleCreateInfo(ShaderResource *sr)
{
codeSize=sr->GetCodeSize();
pCode =sr->GetCode();
}
};//struct ShaderModuleCreateInfo
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_SHADER_RESOURCE_INCLUDE

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

@ -1,124 +0,0 @@
#pragma once
#include<hgl/type/String.h>
#include<hgl/type/List.h>
#include<hgl/type/StringList.h>
#include<hgl/graph/VK.h>
VK_NAMESPACE_BEGIN
struct ShaderStage
{
AnsiString name;
uint location;
VertexAttribType type; ///<成份数量(如vec4中的4)
VkFormat format; ///<对应的Vulkan格式(如vec4对应的FMT_RGBA32F)
uint binding;
bool global; ///<是否全局数据
bool dynamic; ///<是否动态数量
};//struct ShaderStage
using ShaderStageList =ObjectList<ShaderStage>;
struct ShaderDescriptor
{
char name[128];
VkDescriptorType desc_type;
DescriptorSetType set_type;
uint32_t set;
uint32_t binding;
uint32_t stage_flag;
};
using ShaderDescriptorList=List<ShaderDescriptor>;
#ifndef VK_DESCRIPTOR_TYPE_BEGIN_RANGE
constexpr size_t VK_DESCRIPTOR_TYPE_BEGIN_RANGE=VK_DESCRIPTOR_TYPE_SAMPLER;
#endif//VK_DESCRIPTOR_TYPE_BEGIN_RANGE
#ifndef VK_DESCRIPTOR_TYPE_END_RANGE
constexpr size_t VK_DESCRIPTOR_TYPE_END_RANGE=VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
#endif//VK_DESCRIPTOR_TYPE_END_RANGE
#ifndef VK_DESCRIPTOR_TYPE_RANGE_SIZE
constexpr size_t VK_DESCRIPTOR_TYPE_RANGE_SIZE=VK_DESCRIPTOR_TYPE_END_RANGE-VK_DESCRIPTOR_TYPE_BEGIN_RANGE+1;
#endif//VK_DESCRIPTOR_TYPE_RANGE_SIZE
class MaterialDescriptorSets
{
ShaderDescriptorList descriptor_list[VK_DESCRIPTOR_TYPE_RANGE_SIZE];
public:
const ShaderDescriptorList * GetDescriptorList ()const {return descriptor_list;}
ShaderDescriptorList * GetDescriptorList (VkDescriptorType desc_type)
{
if(desc_type<VK_DESCRIPTOR_TYPE_BEGIN_RANGE
||desc_type>VK_DESCRIPTOR_TYPE_END_RANGE)return nullptr;
return descriptor_list+desc_type;
}
ShaderDescriptorList &GetUBO (){return descriptor_list[VK_DESCRIPTOR_TYPE_UNIFORM_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];}
const int GetBinding (VkDescriptorType desc_type,const AnsiString &name)const;
//const DescriptorBindingList * GetBindingList (VkDescriptorType desc_type)const
//{
// if(desc_type<VK_DESCRIPTOR_TYPE_BEGIN_RANGE
// ||desc_type>VK_DESCRIPTOR_TYPE_END_RANGE)return nullptr;
// return &(descriptor_list[desc_type].binding_list);
//}
};//
class ShaderResource
{
VkShaderStageFlagBits stage_flag;
const void *spv_data;
uint32 spv_size;
ShaderStageList stage_inputs;
ShaderStageList stage_outputs;
public:
ShaderResource(const VkShaderStageFlagBits &,const void *,const uint32);
virtual ~ShaderResource()=default;
const VkShaderStageFlagBits GetStage ()const {return stage_flag;}
const os_char * GetStageName ()const;
const uint32_t * GetCode ()const {return (uint32_t *)spv_data;}
const uint32_t GetCodeSize ()const {return spv_size;}
ShaderStageList & GetStageInputs () {return stage_inputs;}
ShaderStageList & GetStageOutputs () {return stage_outputs;}
const uint GetStageInputCount ()const {return stage_inputs.GetCount();}
const uint GetStageOutputCount ()const {return stage_outputs.GetCount();}
const ShaderStage * GetStageInput (const AnsiString &)const;
const int GetStageInputBinding(const AnsiString &)const;
};//class ShaderResource
ShaderResource *LoadShaderResource(const uint8 *origin_filedata,const int64 filesize);
struct ShaderModuleCreateInfo:public vkstruct_flag<VkShaderModuleCreateInfo,VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO>
{
public:
ShaderModuleCreateInfo(ShaderResource *sr)
{
codeSize=sr->GetCodeSize();
pCode =sr->GetCode();
}
};
VK_NAMESPACE_END

30
src/SceneGraph/CMakeLists.txt
View File

@ -1,21 +1,9 @@
set(SG_INCLUDE_PATH ${ROOT_INCLUDE_PATH}/hgl/graph)
SET(SHADER_RESOURCE_FILES ${SG_INCLUDE_PATH}/shader/ShaderResource.h
shader/ShaderResource.cpp)
file(GLOB SG_MATERIAL_HEADER ${SG_INCLUDE_PATH}/material/*.*)
file(GLOB SG_MATERIAL_SOURCE material/*.*)
SOURCE_GROUP("Material" FILES ${SG_MATERIAL_HEADER}
${SG_MATERIAL_SOURCE})
SOURCE_GROUP("Material\\Shader" FILES ${SHADER_RESOURCE_FILES})
SET(SG_TEXTURE_SOURCE ${SG_INCLUDE_PATH}/TextureLoader.h
Texture2DLoader.cpp)
SOURCE_GROUP("Material\\Texture" FILES ${SG_TEXTURE_SOURCE})
SOURCE_GROUP("Texture" FILES ${SG_TEXTURE_SOURCE})
SET(SG_VAD_SOURCE ${SG_INCLUDE_PATH}/VertexAttribData.h
${SG_INCLUDE_PATH}/VertexAttribDataAccess.h
@ -95,6 +83,16 @@ SET(VK_RR_SOURCE ${SG_INCLUDE_PATH}/VKRenderResource.h
SOURCE_GROUP("Vulkan\\RenderResource" FILES ${VK_RR_SOURCE})
SET(VK_RR_SHADER_FILES ${SG_INCLUDE_PATH}/VKShaderResource.h
Vulkan/VKShaderResource.cpp)
SOURCE_GROUP("Vulkan\\RenderResource\\Shader" FILES ${VK_RR_SHADER_FILES})
SET(VK_RR_MATERIAL_FILES ${SG_INCLUDE_PATH}/VKMaterialDescriptorSets.h
Vulkan/VKMaterialDescriptorSets.cpp)
SOURCE_GROUP("Vulkan\\RenderResource\\Material" FILES ${VK_RR_MATERIAL_FILES})
SET(VK_INST_SOURCE ${SG_INCLUDE_PATH}/VKInstance.h
Vulkan/VKInstance.cpp)
@ -216,6 +214,8 @@ IF(WIN32)
ENDIF(WIN32)
SET(VULKAN_RENDER_SOURCE ${VK_RR_SOURCE}
${VK_RR_SHADER_FILES}
${VK_RR_MATERIAL_FILES}
${VK_INST_SOURCE}
${VK_DEBUG_SOURCE}
${VK_MEMORY_SOURCE}
@ -233,11 +233,7 @@ SET(VULKAN_RENDER_SOURCE ${VK_RR_SOURCE}
add_cm_library(ULRE.SceneGraph "ULRE" ${SCENE_GRAPH_HEADER}
${SCENE_GRAPH_SOURCE}
${SHADER_RESOURCE_FILES}
${SG_TEXTURE_SOURCE}
${SG_MATERIAL_HEADER}
${SG_MATERIAL_SOURCE}
${TILE_SOURCE}
${SG_VAD_SOURCE}

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

@ -1,11 +1,24 @@
#include"VKDescriptorSetLayoutCreater.h"
#include<hgl/graph/VKDescriptorSets.h>
#include<hgl/graph/VKDevice.h>
#include<hgl/graph/VKMaterialDescriptorSets.h>
VK_NAMESPACE_BEGIN
DescriptorSetLayoutCreater *GPUDevice::CreateDescriptorSetLayoutCreater()
DescriptorSetLayoutCreater *GPUDevice::CreateDescriptorSetLayoutCreater(const MaterialDescriptorSets *mds)
{
return(new DescriptorSetLayoutCreater(attr->device,attr->desc_pool));
return(new DescriptorSetLayoutCreater(attr->device,attr->desc_pool,mds));
}
DescriptorSetLayoutCreater::DescriptorSetLayoutCreater(VkDevice dev,VkDescriptorPool dp,const MaterialDescriptorSets *_mds)
{
hgl_zero(fin_dsl);
fin_dsl_count=0;
device=dev;
pool=dp;
mds=_mds;
ENUM_CLASS_FOR(DescriptorSetType,int,i)
layouts[i]=nullptr;
}
DescriptorSetLayoutCreater::~DescriptorSetLayoutCreater()
@ -13,63 +26,9 @@ DescriptorSetLayoutCreater::~DescriptorSetLayoutCreater()
if(pipeline_layout)
vkDestroyPipelineLayout(device,pipeline_layout,nullptr);
for(ShaderDescriptorSet s:sds)
if(s.layout)
vkDestroyDescriptorSetLayout(device,s.layout,nullptr);
}
void DescriptorSetLayoutCreater::Bind(const ShaderDescriptorList *sd_list,VkDescriptorType desc_type,VkShaderStageFlagBits stageFlags)
{
if(!sd_list||sd_list->GetCount()<=0)return;
uint32_t binding_count[size_t(DescriptorSetType::RANGE_SIZE)],
old_count[size_t(DescriptorSetType::RANGE_SIZE)],
fin_count[size_t(DescriptorSetType::RANGE_SIZE)];
VkDescriptorSetLayoutBinding *p[size_t(DescriptorSetType::RANGE_SIZE)];
hgl_zero(binding_count);
hgl_zero(old_count);
hgl_zero(fin_count);
hgl_zero(p);
for(const ShaderDescriptor &sd:*sd_list)
{
all_set.Add(sd.set_type);
++binding_count[(size_t)sd.set_type];
}
ENUM_CLASS_FOR(DescriptorSetType,int,i)
if(binding_count[i]>0)
{
old_count[i]=sds[i].binding_list.GetCount();
sds[i].binding_list.PreMalloc(old_count[i]+binding_count[i]);
p[i]=sds[i].binding_list.GetData()+old_count[i];
}
for(const ShaderDescriptor &sd:*sd_list)
{
//重复的绑定点是有可能存在的，比如CameraInfo在vs/fs中同时存在
if(!all_binding.IsMember(sd.binding))
{
p[(size_t)sd.set_type]->binding = sd.binding;
p[(size_t)sd.set_type]->descriptorType = sd.desc_type;
p[(size_t)sd.set_type]->descriptorCount = 1;
p[(size_t)sd.set_type]->stageFlags = stageFlags;
p[(size_t)sd.set_type]->pImmutableSamplers = nullptr;
all_binding.Add(sd.binding);
++p[(size_t)sd.set_type];
++fin_count[(size_t)sd.set_type];
}
}
ENUM_CLASS_FOR(DescriptorSetType,int,i)
if(binding_count[i]>0)
sds[i].binding_list.SetCount(old_count[i]+fin_count[i]);
if(layouts[i])
vkDestroyDescriptorSetLayout(device,layouts[i],nullptr);
}
bool DescriptorSetLayoutCreater::CreatePipelineLayout()
@ -78,7 +37,7 @@ bool DescriptorSetLayoutCreater::CreatePipelineLayout()
ENUM_CLASS_FOR(DescriptorSetType,int,i)
{
const int count=sds[i].binding_list.GetCount();
const int count=mds->GetSetBindingCount((DescriptorSetType)i);
if(count<=0)
continue;
@ -86,15 +45,15 @@ bool DescriptorSetLayoutCreater::CreatePipelineLayout()
DescriptorSetLayoutCreateInfo descriptor_layout;
descriptor_layout.bindingCount = count;
descriptor_layout.pBindings = sds[i].binding_list.GetData();
descriptor_layout.pBindings = mds->GetSetBindingList((DescriptorSetType)i);
if(sds[i].layout)
vkDestroyDescriptorSetLayout(device,sds[i].layout,nullptr);
if(layouts[i])
vkDestroyDescriptorSetLayout(device,layouts[i],nullptr);
if(vkCreateDescriptorSetLayout(device,&descriptor_layout,nullptr,&(sds[i].layout))!=VK_SUCCESS)
if(vkCreateDescriptorSetLayout(device,&descriptor_layout,nullptr,layouts+i)!=VK_SUCCESS)
return(false);
fin_dsl[fin_dsl_count]=sds[i].layout;
fin_dsl[fin_dsl_count]=layouts[i];
++fin_dsl_count;
}
@ -127,7 +86,7 @@ DescriptorSets *DescriptorSetLayoutCreater::Create(const DescriptorSetType &type
ENUM_CLASS_RANGE_ERROR_RETURN_NULLPTR(DescriptorSetType,type);
const uint32_t count=sds[(size_t)type].binding_list.GetCount();
const uint32_t count=mds->GetSetBindingCount(type);
if(!count)
return(nullptr);
@ -136,7 +95,7 @@ DescriptorSets *DescriptorSetLayoutCreater::Create(const DescriptorSetType &type
alloc_info.descriptorPool = pool;
alloc_info.descriptorSetCount = 1;
alloc_info.pSetLayouts = &(sds[(size_t)type].layout);
alloc_info.pSetLayouts = layouts+size_t(type);
VkDescriptorSet desc_set;

37
src/SceneGraph/Vulkan/VKDescriptorSetLayoutCreater.h
View File

@ -1,7 +1,7 @@
#pragma once
#include<hgl/graph/VK.h>
#include<hgl/graph/shader/ShaderResource.h>
#include<hgl/graph/VKShaderResource.h>
#include<hgl/type/Map.h>
#include<hgl/type/Sets.h>
VK_NAMESPACE_BEGIN
@ -15,17 +15,9 @@ class DescriptorSetLayoutCreater
VkDevice device;
VkDescriptorPool pool;
Sets<DescriptorSetType> all_set;
Sets<uint32_t> all_binding;
struct ShaderDescriptorSet
{
List<VkDescriptorSetLayoutBinding> binding_list;
VkDescriptorSetLayout layout;
};
ShaderDescriptorSet sds[size_t(DescriptorSetType::RANGE_SIZE)];
const MaterialDescriptorSets *mds;
VkDescriptorSetLayout layouts[size_t(DescriptorSetType::RANGE_SIZE)];
VkDescriptorSetLayout fin_dsl[size_t(DescriptorSetType::RANGE_SIZE)];
uint32_t fin_dsl_count;
@ -33,30 +25,9 @@ class DescriptorSetLayoutCreater
public:
DescriptorSetLayoutCreater(VkDevice dev,VkDescriptorPool dp)
{
ENUM_CLASS_FOR(DescriptorSetType,int,i)
sds[i].layout=nullptr;
hgl_zero(fin_dsl);
fin_dsl_count=0;
device=dev;pool=dp;
}
DescriptorSetLayoutCreater(VkDevice,VkDescriptorPool,const MaterialDescriptorSets *);
~DescriptorSetLayoutCreater();
void Bind(const ShaderDescriptorList *sd_list,VkDescriptorType type,VkShaderStageFlagBits stage);
void Bind(const ShaderDescriptorList *sdl,VkShaderStageFlagBits stage)
{
for(uint32_t i=VK_DESCRIPTOR_TYPE_BEGIN_RANGE;i<=VK_DESCRIPTOR_TYPE_END_RANGE;i++)
{
if(sdl->GetCount()>0)
Bind(sdl,(VkDescriptorType)i,stage);
++sdl;
}
}
//以下代码不再需要，使用一个void Bind(const ShaderResource &sr,VkShaderStageFlagBits stage)即可全部替代，而且更方便，但以此为提示
//
//#define DESC_SET_BIND_FUNC(name,vkname) void Bind##name(const uint32_t binding,VkShaderStageFlagBits stage_flag){Bind(binding,VK_DESCRIPTOR_TYPE_##vkname,stage_flag);} \

25
src/SceneGraph/Vulkan/VKDeviceMaterial.cpp
View File

@ -1,5 +1,6 @@
#include<hgl/graph/VKDevice.h>
#include<hgl/graph/VKMaterial.h>
#include<hgl/graph/VKMaterialDescriptorSets.h>
#include"VKDescriptorSetLayoutCreater.h"
VK_NAMESPACE_BEGIN
@ -15,34 +16,16 @@ Material *GPUDevice::CreateMaterial(const UTF8String &mtl_name,ShaderModuleMap *
if(!shader_maps->Get(VK_SHADER_STAGE_VERTEX_BIT,sm))
return(nullptr);
DescriptorSetLayoutCreater *dsl_creater=CreateDescriptorSetLayoutCreater();
List<VkPipelineShaderStageCreateInfo> *shader_stage_list=new List<VkPipelineShaderStageCreateInfo>;
shader_stage_list->SetCount(shader_count);
VkPipelineShaderStageCreateInfo *p=shader_stage_list->GetData();
auto **itp=shader_maps->GetDataList();
for(int i=0;i<shader_count;i++)
{
sm=(*itp)->right;
hgl_cpy(p,sm->GetCreateInfo());
dsl_creater->Bind(sm->GetDescriptorList(),sm->GetStage());
++p;
++itp;
}
DescriptorSetLayoutCreater *dsl_creater=CreateDescriptorSetLayoutCreater(mds);
if(!dsl_creater->CreatePipelineLayout())
{
delete shader_stage_list;
delete dsl_creater;
delete shader_maps;
SAFE_CLEAR(mds);
return(nullptr);
}
return(new Material(mtl_name,shader_maps,shader_stage_list,dsl_creater));
return(new Material(mtl_name,shader_maps,mds,dsl_creater));
}
Material *GPUDevice::CreateMaterial(const UTF8String &mtl_name,const VertexShaderModule *vertex_shader_module,const ShaderModule *fragment_shader_module,MaterialDescriptorSets *mds)

27
src/SceneGraph/Vulkan/VKMaterial.cpp
View File

@ -1,15 +1,34 @@
#include<hgl/graph/VKMaterial.h>
#include<hgl/graph/VKMaterialParameters.h>
#include<hgl/graph/VKMaterialDescriptorSets.h>
#include"VKDescriptorSetLayoutCreater.h"
VK_NAMESPACE_BEGIN
Material::Material(const UTF8String &name,ShaderModuleMap *smm,List<VkPipelineShaderStageCreateInfo> *psci_list,DescriptorSetLayoutCreater *dslc)
Material::Material(const UTF8String &name,ShaderModuleMap *smm,MaterialDescriptorSets *_mds,DescriptorSetLayoutCreater *dslc)
{
mtl_name=name;
shader_maps=smm;
shader_stage_list=psci_list;
mds=_mds;
dsl_creater=dslc;
const ShaderModule *sm;
{
const int shader_count=shader_maps->GetCount();
shader_stage_list.SetCount(shader_count);
VkPipelineShaderStageCreateInfo *p=shader_stage_list.GetData();
auto **itp=shader_maps->GetDataList();
for(int i=0;i<shader_count;i++)
{
sm=(*itp)->right;
hgl_cpy(p,sm->GetCreateInfo());
++p;
++itp;
}
}
if(smm->Get(VK_SHADER_STAGE_VERTEX_BIT,sm))
{
vertex_sm=(VertexShaderModule *)sm;
@ -41,8 +60,8 @@ Material::~Material()
delete vab;
}
delete shader_stage_list;
delete shader_maps;
SAFE_CLEAR(mds);
}
const VkPipelineLayout Material::GetPipelineLayout()const
@ -56,6 +75,6 @@ MaterialParameters *Material::CreateMP(const DescriptorSetType &type)const
if(!ds)return(nullptr);
return(new MaterialParameters(shader_maps,type,ds));
return(new MaterialParameters(mds,type,ds));
}
VK_NAMESPACE_END

107
src/SceneGraph/Vulkan/VKMaterialDescriptorSets.cpp Normal file
View File

@ -0,0 +1,107 @@
#include<hgl/graph/VKMaterialDescriptorSets.h>
#include<hgl/TypeFunc.h>
VK_NAMESPACE_BEGIN
void WriteDescriptorSetLayoutBinding(VkDescriptorSetLayoutBinding *dslb,ShaderDescriptor *sd)
{
dslb->binding =sd->binding;
dslb->descriptorType =sd->desc_type;
dslb->descriptorCount =1;
dslb->stageFlags =sd->stage_flag;
dslb->pImmutableSamplers=nullptr;
}
MaterialDescriptorSets::MaterialDescriptorSets(ShaderDescriptor *sd,const uint count)
{
sd_list=sd;
sd_count=count;
if(sd_count<=0)return;
{
hgl_zero(sds);
{
ShaderDescriptor *sp=sd_list;
for(uint i=0;i<sd_count;i++)
{
if(sp->desc_type>=VK_DESCRIPTOR_TYPE_BEGIN_RANGE
&&sp->desc_type<=VK_DESCRIPTOR_TYPE_END_RANGE)
descriptor_list[(size_t)sp->desc_type].Add(sp);
sd_by_name.Add(sp->name,sp);
binding_map[size_t(sp->desc_type)].Add(sp->name,sp->binding);
++sds[sp->set].count;
++sp;
}
}
VkDescriptorSetLayoutBinding *sds_ptr[size_t(DescriptorSetType::RANGE_SIZE)];
{
ENUM_CLASS_FOR(DescriptorSetType,int,i)
if(sds[i].count>0)
{
sds[i].binding_list=new VkDescriptorSetLayoutBinding[sds[i].count];
sds_ptr[i]=sds[i].binding_list;
}
}
{
ShaderDescriptorList *sdl=descriptor_list;
ShaderDescriptor **sdp;
for(uint i=VK_DESCRIPTOR_TYPE_BEGIN_RANGE;
i<=VK_DESCRIPTOR_TYPE_END_RANGE;i++)
{
if(sdl->GetCount()>0)
{
binding_list[i]=new int[sdl->GetCount()];
sdp=sdl->GetData();
for(int j=0;j<sdl->GetCount();j++)
{
binding_list[i][j]=(*sdp)->binding;
WriteDescriptorSetLayoutBinding(sds_ptr[(*sdp)->set],
*sdp);
++sds_ptr[(*sdp)->set];
++sdp;
}
}
else
{
binding_list[i]=nullptr;
}
}
}
}
}
MaterialDescriptorSets::~MaterialDescriptorSets()
{
ENUM_CLASS_FOR(DescriptorSetType,int,i)
if(sds[i].count)
delete[] sds[i].binding_list;
delete[] sd_list; //"delete[] nullptr" isn't bug.
}
const int MaterialDescriptorSets::GetBinding(const VkDescriptorType &desc_type,const AnsiString &name)const
{
if(desc_type<VK_DESCRIPTOR_TYPE_BEGIN_RANGE
||desc_type>VK_DESCRIPTOR_TYPE_END_RANGE)
return -1;
if(name.IsEmpty())return -1;
int result;
return(binding_map[size_t(desc_type)].Get(name,result)?result:-1);
}
VK_NAMESPACE_END

12
src/SceneGraph/Vulkan/VKMaterialParameters.cpp
View File

@ -1,12 +1,12 @@
#include<hgl/graph/VKMaterialParameters.h>
#include<hgl/graph/VKMaterialDescriptorSets.h>
#include<hgl/graph/VKMaterial.h>
#include<hgl/graph/VKDescriptorSets.h>
VK_NAMESPACE_BEGIN
MaterialParameters::MaterialParameters(const ShaderModuleMap *smm,const DescriptorSetType &type,DescriptorSets *ds)
MaterialParameters::MaterialParameters(const MaterialDescriptorSets *_mds,const DescriptorSetType &type,DescriptorSets *ds)
{
shader_map=smm;
mds=_mds;
ds_type=type;
descriptor_sets=ds;
}
@ -21,7 +21,7 @@ bool MaterialParameters::BindUBO(const AnsiString &name,GPUBuffer *ubo,bool dyna
if(name.IsEmpty()||!ubo)
return(false);
const int index=shader_map->GetUBO(name);
const int index=mds->GetUBO(name);
if(index<0)
return(false);
@ -37,7 +37,7 @@ bool MaterialParameters::BindSSBO(const AnsiString &name,GPUBuffer *ssbo,bool dy
if(name.IsEmpty()||!ssbo)
return(false);
const int index=shader_map->GetSSBO(name);
const int index=mds->GetSSBO(name);
if(index<0)
return(false);
@ -53,7 +53,7 @@ bool MaterialParameters::BindSampler(const AnsiString &name,Texture *tex,Sampler
if(name.IsEmpty()||!tex||!sampler)
return(false);
const int index=shader_map->GetSampler(name);
const int index=mds->GetSampler(name);
if(index<0)
return(false);

65
src/SceneGraph/Vulkan/VKRenderResourceMaterial.cpp
View File

@ -2,7 +2,8 @@
#include<hgl/graph/VKMaterial.h>
#include<hgl/graph/VKDevice.h>
#include<hgl/graph/VKShaderModuleMap.h>
#include<hgl/graph/shader/ShaderResource.h>
#include<hgl/graph/VKShaderResource.h>
#include<hgl/graph/VKMaterialDescriptorSets.h>
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/VKRenderResource.h>
@ -26,50 +27,36 @@ const ShaderModule *RenderResource::CreateShaderModule(const OSString &filename,
return sm;
}
const bool LoadShaderDescriptor(ShaderResource *sr,const uint8 *data)
void LoadShaderDescriptor(const uint8 *data,ShaderDescriptor *sd_list,const uint count)
{
const uint8 count=*data++;
if(count<=0)return(true);
ShaderDescriptorList *sd_list;
const VkDescriptorType desc_type;
ShaderDescriptor *sd=sd_list;
uint str_len;
sd_list->SetCount(count);
ShaderDescriptor *sd=sd_list->GetData();
for(uint i=0;i<count;i++)
{
sd->set=*data++;
sd->binding=*data++;
str_len=*data++;
sd->desc_type=VkDescriptorType(*data++);
memcpy(sd->name,(char *)data,str_len);
sd->name[str_len]=0;
data+=str_len;
{
str_len=*data++;
memcpy(sd->name,(char *)data,str_len);
data+=str_len;
}
sd->set =*data++;
sd->binding =*data++;
sd->stage_flag =*(uint32 *)data;
data+=sizeof(uint32);
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;
if(sd->desc_type==VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER)sd->desc_type=VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;else
if(sd->desc_type==VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)sd->desc_type=VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;
}
++sd;
}
return data;
}
Material *RenderResource::CreateMaterial(const OSString &filename)
@ -149,12 +136,24 @@ Material *RenderResource::CreateMaterial(const OSString &filename)
break;
}
if(!LoadShaderDescriptor(sr,filedata))
result=false;
MaterialDescriptorSets *mds=nullptr;
{
const uint8 count=*sp;
++sp;
if(count>0)
{
ShaderDescriptor *sd_list=hgl_zero_new<ShaderDescriptor>(count);
LoadShaderDescriptor(filedata,sd_list,count);
mds=new MaterialDescriptorSets(sd_list,count);
}
}
if(result)
{
mtl=device->CreateMaterial(ToUTF8String(filename),smm);
mtl=device->CreateMaterial(ToUTF8String(filename),smm,mds);
Add(mtl);
}
else

25
src/SceneGraph/Vulkan/VKShaderModuleMap.cpp
View File

@ -12,29 +12,4 @@ bool ShaderModuleMap::Add(const ShaderModule *sm)
return this->Map::Add(stage,sm);
}
const int ShaderModuleMap::GetBinding(VkDescriptorType desc_type,const AnsiString &name)const
{
if(desc_type<VK_DESCRIPTOR_TYPE_BEGIN_RANGE
||desc_type>VK_DESCRIPTOR_TYPE_END_RANGE
||name.IsEmpty())
return(-1);
int binding;
const int shader_count=GetCount();
const ShaderModule *sm;
auto **itp=GetDataList();
for(int i=0;i<shader_count;i++)
{
sm=(*itp)->right;
binding=sm->GetBinding(desc_type,name);
if(binding!=-1)
return binding;
++itp;
}
return(-1);
}
VK_NAMESPACE_END

28
src/SceneGraph/shader/ShaderResource.cpp → src/SceneGraph/Vulkan/VKShaderResource.cpp
View File

@ -1,6 +1,6 @@
#include<hgl/graph/shader/ShaderResource.h>
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/VKShaderResource.h>
#include<hgl/graph/VKFormat.h>
#include<hgl/filesystem/FileSystem.h>
#include<hgl/type/Map.h>
VK_NAMESPACE_BEGIN
@ -23,16 +23,6 @@ VK_NAMESPACE_BEGIN
{
MapObject<OSString,ShaderResource> shader_resource_by_filename;
constexpr char SHADER_FILE_HEADER[] ="Shader\x1A";
constexpr uint SHADER_FILE_HEADER_BYTES=sizeof(SHADER_FILE_HEADER)-1;
constexpr uint32 SHADER_FILE_MIN_SIZE =SHADER_FILE_HEADER_BYTES
+1 //version
+sizeof(uint32) //shader flag
+sizeof(uint32) //spv_size
+1 //input states count
+1; //output states count
const uint8 *LoadShaderStages(ShaderStageList &ss_list,const uint8 *data)
{
const uint count=*data++;
@ -134,20 +124,6 @@ VK_NAMESPACE_BEGIN
return -1;
}
const int ShaderResource::GetBinding(VkDescriptorType desc_type,const AnsiString &name)const
{
if(desc_type>=VK_DESCRIPTOR_TYPE_RANGE_SIZE)return -1;
if(name.IsEmpty())return -1;
const ShaderDescriptorList *sdl=descriptor_list+(size_t)desc_type;
for(const ShaderDescriptor &sd:*sdl)
if(name==sd.name)
return sd.binding;
return -1;
}
ShaderResource *LoadShaderResource(const uint8 *origin_filedata,const int64 filesize)
{
if(!origin_filedata)return(nullptr);