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

use standalone DescriptorSetType,ShaderDescriptor,ShaderStage

Browse Source
This commit is contained in:
HuYingzhuo(hugo/hyzboy) 2023-03-02 20:19:25 +08:00
parent f2d5209681
commit b4dccf7814
26 changed files with 139 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMSceneGraph

@ -1 +1 @@
Subproject commit 9c32616cbbc0b63a237ee1d120dffd0476e89de3 Subproject commit 4074a6f01ffff144ff77814a9dd0387b63419a03

1
CMakeLists.txt
View File

@ -24,6 +24,7 @@ SET(ULRE CMCore
CMSceneGraph CMSceneGraph
CMUtil CMUtil
ULRE.Util ULRE.Util
# ULRE.ShaderGen
ULRE.SceneGraph ULRE.SceneGraph
${HGL_GLM_LIB} ${HGL_GLM_LIB}
${RENDER_LIBRARY} ${RENDER_LIBRARY}

37
example/common/VulkanAppFramework.h
View File

@ -59,8 +59,11 @@ protected:
RenderResource * db =nullptr; RenderResource * db =nullptr;
protected: protected:
ViewportInfo vp_info;
Camera * camera =nullptr; Camera * camera =nullptr;
CameraInfo camera_info;
DeviceBuffer * ubo_camera_info =nullptr; DeviceBuffer * ubo_camera_info =nullptr;
public: public:
@ -129,16 +132,13 @@ public:
{ {
camera=new Camera; camera=new Camera;
camera->width=w;
camera->height=h;
camera->vp_width=w;
camera->vp_height=h;
camera->pos=Vector3f(10,10,10); camera->pos=Vector3f(10,10,10);
vp_info.Set(w,h);
camera->RefreshCameraInfo(); RefreshCameraInfo(&camera_info,&vp_info,camera);
ubo_camera_info=db->CreateUBO(sizeof(CameraInfo),&camera->info); ubo_camera_info=db->CreateUBO(sizeof(CameraInfo),&camera_info);
} }
return(true); return(true);
@ -146,7 +146,7 @@ public:
const CameraInfo &GetCameraInfo() const CameraInfo &GetCameraInfo()
{ {
return camera->info; return camera_info;
} }
DeviceBuffer *GetCameraInfoBuffer() DeviceBuffer *GetCameraInfoBuffer()
@ -161,14 +161,11 @@ public:
virtual void Resize(int w,int h) virtual void Resize(int w,int h)
{ {
camera->width=w; vp_info.Set(w,h);
camera->height=h;
camera->vp_width=w;
camera->vp_height=h;
camera->RefreshCameraInfo(); RefreshCameraInfo(&camera_info,&vp_info,camera);
ubo_camera_info->Write(&camera->info); ubo_camera_info->Write(&camera_info);
} }
void SetClearColor(const Color4f &cc) void SetClearColor(const Color4f &cc)
@ -482,7 +479,7 @@ public:
virtual void InitCamera(int w,int h) virtual void InitCamera(int w,int h)
{ {
camera_control=new FirstPersonCameraControl(camera); camera_control=new FirstPersonCameraControl(&vp_info,camera);
camera_control->Refresh(); //更新矩阵计算 camera_control->Refresh(); //更新矩阵计算
@ -495,14 +492,11 @@ public:
void Resize(int w,int h)override void Resize(int w,int h)override
{ {
camera->width=w; vp_info.Set(w,h);
camera->height=h;
camera->vp_width=w;
camera->vp_height=h;
camera_control->Refresh(); camera_control->Refresh();
ubo_camera_info->Write(&camera->info); ubo_camera_info->Write(&camera_info);
} }
virtual void BuildCommandBuffer(uint32_t index)=0; virtual void BuildCommandBuffer(uint32_t index)=0;
@ -510,6 +504,7 @@ public:
virtual void Draw()override virtual void Draw()override
{ {
camera_control->Refresh(); //更新相机矩阵 camera_control->Refresh(); //更新相机矩阵
ubo_camera_info->Write(&camera->info); //写入缓冲区 ubo_camera_info->Write(&camera->info); //写入缓冲区
const uint32_t index=AcquireNextImage(); const uint32_t index=AcquireNextImage();

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

@ -33,7 +33,7 @@ class VulkanInstance;
class GPUPhysicalDevice; class GPUPhysicalDevice;
class GPUDevice; class GPUDevice;
struct GPUDeviceAttribute; struct GPUDeviceAttribute;
class Queue; class DeviceQueue;
class ImageView; class ImageView;
class Framebuffer; class Framebuffer;
struct Swapchain; struct Swapchain;
@ -70,33 +70,6 @@ class DeviceRenderPassManage;
class Fence; class Fence;
class Semaphore; class Semaphore;
enum class DescriptorSetType
{
//设计使其对应shader中的set
Global=0, ///<全局参数(如太阳光等)
PerFrame, ///<帧参数(如摄像机等)
PerMaterialInstance,///<材质实例参数(如纹理等)
PerObject, ///<对象参数(如模型矩阵等)
Instance,
Skeleton,
ENUM_CLASS_RANGE(Global,Skeleton)
};//
constexpr char *DescriptSetsTypeName[]=
{
"Global","PerFrame","PerMaterialInstance","PerObject","Instance","Skeleton"
};
inline const char *GetDescriptorSetTypeName(const enum class DescriptorSetType &type)
{
RANGE_CHECK_RETURN_NULLPTR(type);
return DescriptSetsTypeName[(size_t)type];
}
struct PipelineLayoutData; struct PipelineLayoutData;
class DescriptorSet; class DescriptorSet;
@ -194,32 +167,6 @@ enum IndexType
U32 U32
}; };
enum class ShaderStageBit
{
Vertex =VK_SHADER_STAGE_VERTEX_BIT,
TessControl =VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
TessEval =VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
Geometry =VK_SHADER_STAGE_GEOMETRY_BIT,
Fragment =VK_SHADER_STAGE_FRAGMENT_BIT,
Compute =VK_SHADER_STAGE_COMPUTE_BIT
};//enum class ShaderStageBit
inline const uint GetShaderCountByBits(const uint32_t bits)
{
uint comp=(uint)VK_SHADER_STAGE_VERTEX_BIT;
uint result=0;
for(uint i=0;i<6;i++)
{
if(bits&comp)
++result;
comp<<=1;
}
return result;
}
/** /**
* max-lengths: * max-lengths:
* *

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

@ -147,7 +147,7 @@ public:
vkCmdPushDescriptorSetKHR(cmd_buf,VK_PIPELINE_BIND_POINT_GRAPHICS,pipeline_layout,set,count,write_desc_set); vkCmdPushDescriptorSetKHR(cmd_buf,VK_PIPELINE_BIND_POINT_GRAPHICS,pipeline_layout,set,count,write_desc_set);
} }
void PushConstants(ShaderStageBit shader_stage_bit,uint32_t offset,uint32_t size,const void *pValues) void PushConstants(VkShaderStageFlagBits shader_stage_bit,uint32_t offset,uint32_t size,const void *pValues)
{ {
vkCmdPushConstants(cmd_buf,pipeline_layout,(VkShaderStageFlagBits)shader_stage_bit,offset,size,pValues); vkCmdPushConstants(cmd_buf,pipeline_layout,(VkShaderStageFlagBits)shader_stage_bit,offset,size,pValues);
} }

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

@ -15,6 +15,7 @@
#include<hgl/graph/VertexAttribData.h> #include<hgl/graph/VertexAttribData.h>
#include<hgl/graph/VKShaderModuleMap.h> #include<hgl/graph/VKShaderModuleMap.h>
#include<hgl/graph/VKArrayBuffer.h> #include<hgl/graph/VKArrayBuffer.h>
#include<hgl/graph/VKDescriptorSetType.h>
namespace hgl namespace hgl
{ {
@ -43,7 +44,7 @@ class GPUDevice
{ {
GPUDeviceAttribute *attr; GPUDeviceAttribute *attr;
Queue *texture_queue; DeviceQueue *texture_queue;
TextureCmdBuffer *texture_cmd_buf; TextureCmdBuffer *texture_cmd_buf;
private: private:
@ -243,7 +244,7 @@ public:
Fence * CreateFence(bool); Fence * CreateFence(bool);
Semaphore * CreateGPUSemaphore(); Semaphore * CreateGPUSemaphore();
Queue * CreateQueue(const uint32_t fence_count=1,const bool create_signaled=false); DeviceQueue *CreateQueue(const uint32_t fence_count=1,const bool create_signaled=false);
public: //FrameBuffer相关 public: //FrameBuffer相关

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

@ -5,6 +5,7 @@
#include<hgl/type/Map.h> #include<hgl/type/Map.h>
#include<hgl/type/String.h> #include<hgl/type/String.h>
#include<hgl/graph/VKShaderModuleMap.h> #include<hgl/graph/VKShaderModuleMap.h>
#include<hgl/graph/VKDescriptorSetType.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
using ShaderStageCreateInfoList=List<VkPipelineShaderStageCreateInfo>; using ShaderStageCreateInfoList=List<VkPipelineShaderStageCreateInfo>;

15
inc/hgl/graph/VKMaterialDescriptorSets.h
View File

@ -2,22 +2,9 @@
#define HGL_GRAPH_VULKAN_MATERIAL_DESCRIPTOR_SETS_INCLUDE #define HGL_GRAPH_VULKAN_MATERIAL_DESCRIPTOR_SETS_INCLUDE
#include<hgl/graph/VK.h> #include<hgl/graph/VK.h>
#include<hgl/graph/VKShaderDescriptor.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
struct ShaderDescriptor
{
char name[128];
VkDescriptorType desc_type;
DescriptorSetType set_type;
uint8 set;
uint8 binding;
uint32 stage_flag;
};
using ShaderDescriptorList=List<ShaderDescriptor *>;
class MaterialDescriptorSets class MaterialDescriptorSets
{ {
UTF8String mtl_name; UTF8String mtl_name;

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

@ -4,6 +4,7 @@
#include<hgl/graph/VK.h> #include<hgl/graph/VK.h>
#include<hgl/type/String.h> #include<hgl/type/String.h>
#include<hgl/graph/VKDescriptorSet.h> #include<hgl/graph/VKDescriptorSet.h>
#include<hgl/graph/VKDescriptorSetType.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
class MaterialParameters class MaterialParameters
{ {

8
inc/hgl/graph/VKQueue.h
View File

@ -4,7 +4,7 @@
#include<hgl/graph/VK.h> #include<hgl/graph/VK.h>
#include<hgl/graph/VKFence.h> #include<hgl/graph/VKFence.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
class Queue class DeviceQueue
{ {
protected: protected:
@ -21,11 +21,11 @@ private:
friend class GPUDevice; friend class GPUDevice;
Queue(VkDevice dev,VkQueue q,Fence **,const uint32_t fc); DeviceQueue(VkDevice dev,VkQueue q,Fence **,const uint32_t fc);
public: public:
virtual ~Queue(); virtual ~DeviceQueue();
operator VkQueue(){return queue;} operator VkQueue(){return queue;}
@ -35,6 +35,6 @@ public:
bool WaitFence(const bool wait_all=true,const uint64_t time_out=HGL_NANO_SEC_PER_SEC); bool WaitFence(const bool wait_all=true,const uint64_t time_out=HGL_NANO_SEC_PER_SEC);
bool Submit(const VkCommandBuffer &cmd_buf,Semaphore *wait_sem,Semaphore *complete_sem); bool Submit(const VkCommandBuffer &cmd_buf,Semaphore *wait_sem,Semaphore *complete_sem);
bool Submit(const VkCommandBuffer *cmd_buf,const uint32_t count,Semaphore *wait_sem,Semaphore *complete_sem); bool Submit(const VkCommandBuffer *cmd_buf,const uint32_t count,Semaphore *wait_sem,Semaphore *complete_sem);
};//class SumbitQueue };//class DeviceQueue
VK_NAMESPACE_END VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_SUBMIT_QUEUE_INCLUDE #endif//HGL_GRAPH_VULKAN_SUBMIT_QUEUE_INCLUDE

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

@ -15,7 +15,7 @@ class RenderTarget
{ {
protected: protected:
Queue *queue; DeviceQueue *queue;
RenderPass *render_pass; RenderPass *render_pass;
Framebuffer *fbo; Framebuffer *fbo;
@ -34,14 +34,14 @@ protected:
friend class GPUDevice; friend class GPUDevice;
RenderTarget(Queue *,Semaphore *); RenderTarget(DeviceQueue *,Semaphore *);
RenderTarget(Queue *,Semaphore *,RenderPass *_rp,Framebuffer *_fb,Texture2D **color_texture_list,const uint32_t color_count,Texture2D *depth_texture); RenderTarget(DeviceQueue *,Semaphore *,RenderPass *_rp,Framebuffer *_fb,Texture2D **color_texture_list,const uint32_t color_count,Texture2D *depth_texture);
public: public:
virtual ~RenderTarget(); virtual ~RenderTarget();
Queue * GetQueue () {return queue;} DeviceQueue * GetQueue () {return queue;}
const VkExtent2D & GetExtent ()const {return extent;} const VkExtent2D & GetExtent ()const {return extent;}
virtual RenderPass * GetRenderPass () {return render_pass;} virtual RenderPass * GetRenderPass () {return render_pass;}
virtual const VkRenderPass GetVkRenderPass ()const {return render_pass->GetVkRenderPass();} virtual const VkRenderPass GetVkRenderPass ()const {return render_pass->GetVkRenderPass();}
@ -53,7 +53,7 @@ public:
public: // command buffer public: // command buffer
Semaphore * GetRenderCompleteSemaphore (){return render_complete_semaphore;} Semaphore * GetRenderCompleteSemaphore (){return render_complete_semaphore;}
virtual bool Submit (RenderCmdBuffer *,Semaphore *present_complete_semaphore=nullptr); virtual bool Submit (RenderCmdBuffer *,Semaphore *present_complete_semaphore=nullptr);
bool WaitQueue(){return queue->WaitQueue();} bool WaitQueue(){return queue->WaitQueue();}
@ -75,7 +75,7 @@ class SwapchainRenderTarget:public RenderTarget
public: public:
SwapchainRenderTarget(VkDevice dev,Swapchain *sc,Queue *q,Semaphore *rcs,Semaphore *pcs,RenderPass *rp); SwapchainRenderTarget(VkDevice dev,Swapchain *sc,DeviceQueue *q,Semaphore *rcs,Semaphore *pcs,RenderPass *rp);
~SwapchainRenderTarget(); ~SwapchainRenderTarget();
Framebuffer * GetFramebuffer ()override {return swapchain->render_frame[current_frame];} Framebuffer * GetFramebuffer ()override {return swapchain->render_frame[current_frame];}
@ -90,7 +90,7 @@ public:
public: public:
const uint32_t GetCurrentFrameIndices ()const {return current_frame;} const uint32_t GetCurrentFrameIndices ()const {return current_frame;}
Semaphore * GetPresentCompleteSemaphore () {return present_complete_semaphore;} Semaphore * GetPresentCompleteSemaphore () {return present_complete_semaphore;}
public: public:

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

@ -1,7 +1,9 @@
#ifndef HGL_GRAPH_VULKAN_SHADER_MODULE_INCLUDE #ifndef HGL_GRAPH_VULKAN_SHADER_MODULE_INCLUDE
#define HGL_GRAPH_VULKAN_SHADER_MODULE_INCLUDE #define HGL_GRAPH_VULKAN_SHADER_MODULE_INCLUDE
#include<hgl/graph/VK.h>
#include<hgl/graph/VKShaderResource.h> #include<hgl/graph/VKShaderResource.h>
#include<hgl/graph/VKVertexInputLayout.h>
#include<hgl/type/SortedSets.h> #include<hgl/type/SortedSets.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
@ -57,7 +59,7 @@ class VertexShaderModule:public ShaderModule
{ {
uint32_t attr_count; uint32_t attr_count;
VertexAttribType *type_list; VertexAttribType *type_list;
const AnsiString **name_list; const char **name_list;
ShaderStage **ssi_list; ShaderStage **ssi_list;
private: private:

20
inc/hgl/graph/VKShaderResource.h
View File

@ -4,23 +4,11 @@
#include<hgl/type/String.h> #include<hgl/type/String.h>
#include<hgl/type/List.h> #include<hgl/type/List.h>
#include<hgl/type/StringList.h> #include<hgl/type/StringList.h>
#include<hgl/graph/VK.h> #include<hgl/graph/VKShaderStage.h>
#include<hgl/io/ConstBufferReader.h> #include<hgl/graph/VKStruct.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
struct ShaderStage
{
AnsiString name;
uint8 location;
VertexAttribType type; ///<成份数量(如vec4中的4)
bool dynamic; ///<是否动态数据
};//struct ShaderStage
using ShaderStageList =ObjectList<ShaderStage>;
class ShaderResource class ShaderResource
{ {
VkShaderStageFlagBits stage_flag; VkShaderStageFlagBits stage_flag;
@ -37,7 +25,7 @@ public:
virtual ~ShaderResource()=default; virtual ~ShaderResource()=default;
const VkShaderStageFlagBits GetStage ()const {return stage_flag;} const VkShaderStageFlagBits GetStage ()const {return stage_flag;}
const os_char * GetStageName ()const; const char * GetStageName ()const {return GetShaderStageName(stage_flag);}
const uint32_t * GetCode ()const {return (uint32_t *)spv_data;} const uint32_t * GetCode ()const {return (uint32_t *)spv_data;}
const uint32_t GetCodeSize ()const {return spv_size;} const uint32_t GetCodeSize ()const {return spv_size;}
@ -52,8 +40,6 @@ public:
const int GetStageInputBinding(const AnsiString &)const; const int GetStageInputBinding(const AnsiString &)const;
};//class ShaderResource };//class ShaderResource
ShaderResource *LoadShaderResource(io::ConstBufferReader &);
struct ShaderModuleCreateInfo:public vkstruct_flag<VkShaderModuleCreateInfo,VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO> struct ShaderModuleCreateInfo:public vkstruct_flag<VkShaderModuleCreateInfo,VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO>
{ {
public: public:

78
src/SceneGraph/TextureLoader.cpp
View File

@ -99,49 +99,49 @@ namespace hgl
uint8 channels; //颜色通道数 uint8 channels; //颜色通道数
char colors[4]; char colors[4];
uint8 bits[4]; uint8 bits[4];
VulkanFormat::BaseType type; VulkanBaseType type;
};// };//
constexpr VulkanTexturePixelFormat pf_list[]= constexpr VulkanTexturePixelFormat pf_list[]=
{ {
{ PF_RGBA4, 4,{'R','G','B','A'},{ 4, 4, 4, 4},VulkanFormat::BaseType::UNORM}, //Android 部分不支持 { PF_RGBA4, 4,{'R','G','B','A'},{ 4, 4, 4, 4},VulkanBaseType::UNORM}, //Android 部分不支持
{ PF_BGRA4, 4,{'B','G','R','A'},{ 4, 4, 4, 4},VulkanFormat::BaseType::UNORM}, //ios不支持这个 { PF_BGRA4, 4,{'B','G','R','A'},{ 4, 4, 4, 4},VulkanBaseType::UNORM}, //ios不支持这个
{UPF_RGB565, 3,{'R','G','B', 0 },{ 5, 6, 5, 0},VulkanFormat::BaseType::UNORM}, {UPF_RGB565, 3,{'R','G','B', 0 },{ 5, 6, 5, 0},VulkanBaseType::UNORM},
{UPF_A1RGB5, 4,{'A','R','G','B'},{ 1, 5, 5, 5},VulkanFormat::BaseType::UNORM}, {UPF_A1RGB5, 4,{'A','R','G','B'},{ 1, 5, 5, 5},VulkanBaseType::UNORM},
{UPF_R8, 1,{'R', 0 , 0 , 0 },{ 8, 0, 0, 0},VulkanFormat::BaseType::UNORM}, {UPF_R8, 1,{'R', 0 , 0 , 0 },{ 8, 0, 0, 0},VulkanBaseType::UNORM},
{UPF_RG8, 2,{'R','G', 0 , 0 },{ 8, 8, 0, 0},VulkanFormat::BaseType::UNORM}, {UPF_RG8, 2,{'R','G', 0 , 0 },{ 8, 8, 0, 0},VulkanBaseType::UNORM},
{UPF_RGBA8, 4,{'R','G','B','A'},{ 8, 8, 8, 8},VulkanFormat::BaseType::UNORM}, {UPF_RGBA8, 4,{'R','G','B','A'},{ 8, 8, 8, 8},VulkanBaseType::UNORM},
{UPF_RGBA8S, 4,{'R','G','B','A'},{ 8, 8, 8, 8},VulkanFormat::BaseType::SNORM}, {UPF_RGBA8S, 4,{'R','G','B','A'},{ 8, 8, 8, 8},VulkanBaseType::SNORM},
{UPF_RGBA8U, 4,{'R','G','B','A'},{ 8, 8, 8, 8},VulkanFormat::BaseType::UINT}, {UPF_RGBA8U, 4,{'R','G','B','A'},{ 8, 8, 8, 8},VulkanBaseType::UINT},
{UPF_RGBA8I, 4,{'R','G','B','A'},{ 8, 8, 8, 8},VulkanFormat::BaseType::SINT}, {UPF_RGBA8I, 4,{'R','G','B','A'},{ 8, 8, 8, 8},VulkanBaseType::SINT},
{UPF_ABGR8, 4,{'A','B','G','R'},{ 8, 8, 8, 8},VulkanFormat::BaseType::UNORM}, {UPF_ABGR8, 4,{'A','B','G','R'},{ 8, 8, 8, 8},VulkanBaseType::UNORM},
{UPF_A2BGR10, 4,{'A','B','G','R'},{ 2,10,10,10},VulkanFormat::BaseType::UNORM}, {UPF_A2BGR10, 4,{'A','B','G','R'},{ 2,10,10,10},VulkanBaseType::UNORM},
{UPF_R16, 1,{'R', 0 , 0 , 0 },{16, 0, 0, 0},VulkanFormat::BaseType::UNORM}, {UPF_R16, 1,{'R', 0 , 0 , 0 },{16, 0, 0, 0},VulkanBaseType::UNORM},
{UPF_R16U, 1,{'R', 0 , 0 , 0 },{16, 0, 0, 0},VulkanFormat::BaseType::UINT}, {UPF_R16U, 1,{'R', 0 , 0 , 0 },{16, 0, 0, 0},VulkanBaseType::UINT},
{UPF_R16I, 1,{'R', 0 , 0 , 0 },{16, 0, 0, 0},VulkanFormat::BaseType::SINT}, {UPF_R16I, 1,{'R', 0 , 0 , 0 },{16, 0, 0, 0},VulkanBaseType::SINT},
{UPF_R16F, 1,{'R', 0 , 0 , 0 },{16, 0, 0, 0},VulkanFormat::BaseType::SFLOAT}, {UPF_R16F, 1,{'R', 0 , 0 , 0 },{16, 0, 0, 0},VulkanBaseType::SFLOAT},
{UPF_RG16, 2,{'R','G', 0 , 0 },{16,16, 0, 0},VulkanFormat::BaseType::UNORM}, {UPF_RG16, 2,{'R','G', 0 , 0 },{16,16, 0, 0},VulkanBaseType::UNORM},
{UPF_RG16U, 2,{'R','G', 0 , 0 },{16,16, 0, 0},VulkanFormat::BaseType::UINT}, {UPF_RG16U, 2,{'R','G', 0 , 0 },{16,16, 0, 0},VulkanBaseType::UINT},
{UPF_RG16I, 2,{'R','G', 0 , 0 },{16,16, 0, 0},VulkanFormat::BaseType::SINT}, {UPF_RG16I, 2,{'R','G', 0 , 0 },{16,16, 0, 0},VulkanBaseType::SINT},
{UPF_RG16F, 2,{'R','G', 0 , 0 },{16,16, 0, 0},VulkanFormat::BaseType::SFLOAT}, {UPF_RG16F, 2,{'R','G', 0 , 0 },{16,16, 0, 0},VulkanBaseType::SFLOAT},
{ PF_RGBA16UN, 4,{'R','G','B','A'},{16,16,16,16},VulkanFormat::BaseType::UNORM}, { PF_RGBA16UN, 4,{'R','G','B','A'},{16,16,16,16},VulkanBaseType::UNORM},
{ PF_RGBA16SN, 4,{'R','G','B','A'},{16,16,16,16},VulkanFormat::BaseType::SNORM}, { PF_RGBA16SN, 4,{'R','G','B','A'},{16,16,16,16},VulkanBaseType::SNORM},
{UPF_RGBA16U, 4,{'R','G','B','A'},{16,16,16,16},VulkanFormat::BaseType::UINT}, {UPF_RGBA16U, 4,{'R','G','B','A'},{16,16,16,16},VulkanBaseType::UINT},
{UPF_RGBA16I, 4,{'R','G','B','A'},{16,16,16,16},VulkanFormat::BaseType::SINT}, {UPF_RGBA16I, 4,{'R','G','B','A'},{16,16,16,16},VulkanBaseType::SINT},
{UPF_RGBA16F, 4,{'R','G','B','A'},{16,16,16,16},VulkanFormat::BaseType::SFLOAT}, {UPF_RGBA16F, 4,{'R','G','B','A'},{16,16,16,16},VulkanBaseType::SFLOAT},
{UPF_R32U, 1,{'R', 0 , 0 , 0 },{32, 0, 0, 0},VulkanFormat::BaseType::UINT}, {UPF_R32U, 1,{'R', 0 , 0 , 0 },{32, 0, 0, 0},VulkanBaseType::UINT},
{UPF_R32I, 1,{'R', 0 , 0 , 0 },{32, 0, 0, 0},VulkanFormat::BaseType::SINT}, {UPF_R32I, 1,{'R', 0 , 0 , 0 },{32, 0, 0, 0},VulkanBaseType::SINT},
{UPF_R32F, 1,{'R', 0 , 0 , 0 },{32, 0, 0, 0},VulkanFormat::BaseType::SFLOAT}, {UPF_R32F, 1,{'R', 0 , 0 , 0 },{32, 0, 0, 0},VulkanBaseType::SFLOAT},
{UPF_RG32U, 2,{'R','G', 0 , 0 },{32,32, 0, 0},VulkanFormat::BaseType::UINT}, {UPF_RG32U, 2,{'R','G', 0 , 0 },{32,32, 0, 0},VulkanBaseType::UINT},
{UPF_RG32I, 2,{'R','G', 0 , 0 },{32,32, 0, 0},VulkanFormat::BaseType::SINT}, {UPF_RG32I, 2,{'R','G', 0 , 0 },{32,32, 0, 0},VulkanBaseType::SINT},
{UPF_RG32F, 2,{'R','G', 0 , 0 },{32,32, 0, 0},VulkanFormat::BaseType::SFLOAT}, {UPF_RG32F, 2,{'R','G', 0 , 0 },{32,32, 0, 0},VulkanBaseType::SFLOAT},
{ PF_RGB32U, 3,{'R','G','B', 0 },{32,32,32, 0},VulkanFormat::BaseType::UINT}, { PF_RGB32U, 3,{'R','G','B', 0 },{32,32,32, 0},VulkanBaseType::UINT},
{ PF_RGB32I, 3,{'R','G','B', 0 },{32,32,32, 0},VulkanFormat::BaseType::SINT}, { PF_RGB32I, 3,{'R','G','B', 0 },{32,32,32, 0},VulkanBaseType::SINT},
{ PF_RGB32F, 3,{'R','G','B', 0 },{32,32,32, 0},VulkanFormat::BaseType::SFLOAT}, { PF_RGB32F, 3,{'R','G','B', 0 },{32,32,32, 0},VulkanBaseType::SFLOAT},
{UPF_RGBA32U, 4,{'R','G','B','A'},{32,32,32,32},VulkanFormat::BaseType::UINT}, {UPF_RGBA32U, 4,{'R','G','B','A'},{32,32,32,32},VulkanBaseType::UINT},
{UPF_RGBA32I, 4,{'R','G','B','A'},{32,32,32,32},VulkanFormat::BaseType::SINT}, {UPF_RGBA32I, 4,{'R','G','B','A'},{32,32,32,32},VulkanBaseType::SINT},
{UPF_RGBA32F, 4,{'R','G','B','A'},{32,32,32,32},VulkanFormat::BaseType::SFLOAT}, {UPF_RGBA32F, 4,{'R','G','B','A'},{32,32,32,32},VulkanBaseType::SFLOAT},
{UPF_B10GR11UF, 3,{'B','G','R', 0 },{10,11,11, 0},VulkanFormat::BaseType::UFLOAT} {UPF_B10GR11UF, 3,{'B','G','R', 0 },{10,11,11, 0},VulkanBaseType::UFLOAT}
}; };
constexpr uint VulkanTexturePixelFormatCount=sizeof(pf_list)/sizeof(VulkanTexturePixelFormat); constexpr uint VulkanTexturePixelFormatCount=sizeof(pf_list)/sizeof(VulkanTexturePixelFormat);

4
src/SceneGraph/Vulkan/VKDevice.cpp
View File

@ -140,7 +140,7 @@ Semaphore *GPUDevice::CreateGPUSemaphore()
return(new Semaphore(attr->device,sem)); return(new Semaphore(attr->device,sem));
} }
Queue *GPUDevice::CreateQueue(const uint32_t fence_count,const bool create_signaled) DeviceQueue *GPUDevice::CreateQueue(const uint32_t fence_count,const bool create_signaled)
{ {
if(fence_count<=0)return(nullptr); if(fence_count<=0)return(nullptr);
@ -149,6 +149,6 @@ Queue *GPUDevice::CreateQueue(const uint32_t fence_count,const bool create_signa
for(uint32_t i=0;i<fence_count;i++) for(uint32_t i=0;i<fence_count;i++)
fence_list[i]=CreateFence(create_signaled); fence_list[i]=CreateFence(create_signaled);
return(new Queue(attr->device,attr->graphics_queue,fence_list,fence_count)); return(new DeviceQueue(attr->device,attr->graphics_queue,fence_list,fence_count));
} }
VK_NAMESPACE_END VK_NAMESPACE_END

4
src/SceneGraph/Vulkan/VKDeviceRenderTarget.cpp
View File

@ -33,7 +33,7 @@ RenderTarget *GPUDevice::CreateRenderTarget(const FramebufferInfo *fbi,RenderPas
if(fb) if(fb)
{ {
Queue *q=CreateQueue(fence_count,false); DeviceQueue *q=CreateQueue(fence_count,false);
Semaphore *render_complete_semaphore=CreateGPUSemaphore(); Semaphore *render_complete_semaphore=CreateGPUSemaphore();
RenderTarget *rt=new RenderTarget(q,render_complete_semaphore,rp,fb,color_texture_list,color_count,depth_texture); RenderTarget *rt=new RenderTarget(q,render_complete_semaphore,rp,fb,color_texture_list,color_count,depth_texture);
@ -64,7 +64,7 @@ SwapchainRenderTarget *GPUDevice::CreateSwapchainRenderTarget()
if(!sc) if(!sc)
return(false); return(false);
Queue *q=CreateQueue(sc->color_count,false); DeviceQueue *q=CreateQueue(sc->color_count,false);
Semaphore *render_complete_semaphore=CreateGPUSemaphore(); Semaphore *render_complete_semaphore=CreateGPUSemaphore();
Semaphore *present_complete_semaphore=CreateGPUSemaphore(); Semaphore *present_complete_semaphore=CreateGPUSemaphore();

1
src/SceneGraph/Vulkan/VKMaterialDescriptorSets.cpp
View File

@ -1,4 +1,5 @@
#include<hgl/graph/VKMaterialDescriptorSets.h> #include<hgl/graph/VKMaterialDescriptorSets.h>
#include<hgl/graph/VKDescriptorSetType.h>
#include<hgl/TypeFunc.h> #include<hgl/TypeFunc.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN

2
src/SceneGraph/Vulkan/VKPipelineLayoutData.h
View File

@ -1,7 +1,7 @@
#pragma once #pragma once
#include<hgl/graph/VK.h> #include<hgl/graph/VK.h>
#include<hgl/graph/VKShaderResource.h> #include<hgl/graph/VKDescriptorSetType.h>
#include<hgl/type/Map.h> #include<hgl/type/Map.h>
#include<hgl/type/SortedSets.h> #include<hgl/type/SortedSets.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN

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

@ -7,7 +7,7 @@ namespace
const VkPipelineStageFlags pipe_stage_flags=VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; const VkPipelineStageFlags pipe_stage_flags=VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
}//namespace }//namespace
Queue::Queue(VkDevice dev,VkQueue q,Fence **fl,const uint32_t fc) DeviceQueue::DeviceQueue(VkDevice dev,VkQueue q,Fence **fl,const uint32_t fc)
{ {
device=dev; device=dev;
queue=q; queue=q;
@ -19,12 +19,12 @@ Queue::Queue(VkDevice dev,VkQueue q,Fence **fl,const uint32_t fc)
submit_info.pWaitDstStageMask = &pipe_stage_flags; submit_info.pWaitDstStageMask = &pipe_stage_flags;
} }
Queue::~Queue() DeviceQueue::~DeviceQueue()
{ {
SAFE_CLEAR_OBJECT_ARRAY(fence_list,fence_count) SAFE_CLEAR_OBJECT_ARRAY(fence_list,fence_count)
} }
bool Queue::WaitQueue() bool DeviceQueue::WaitQueue()
{ {
VkResult result=vkQueueWaitIdle(queue); VkResult result=vkQueueWaitIdle(queue);
@ -34,7 +34,7 @@ bool Queue::WaitQueue()
return(true); return(true);
} }
bool Queue::WaitFence(const bool wait_all,uint64_t time_out) bool DeviceQueue::WaitFence(const bool wait_all,uint64_t time_out)
{ {
VkResult result; VkResult result;
VkFence fence=*fence_list[current_fence]; VkFence fence=*fence_list[current_fence];
@ -48,7 +48,7 @@ bool Queue::WaitFence(const bool wait_all,uint64_t time_out)
return(true); return(true);
} }
bool Queue::Submit(const VkCommandBuffer *cmd_buf,const uint32_t cb_count,Semaphore *wait_sem,Semaphore *complete_sem) bool DeviceQueue::Submit(const VkCommandBuffer *cmd_buf,const uint32_t cb_count,Semaphore *wait_sem,Semaphore *complete_sem)
{ {
VkSemaphore ws; VkSemaphore ws;
VkSemaphore cs; VkSemaphore cs;
@ -91,7 +91,7 @@ bool Queue::Submit(const VkCommandBuffer *cmd_buf,const uint32_t cb_count,Semaph
return(result==VK_SUCCESS); return(result==VK_SUCCESS);
} }
bool Queue::Submit(const VkCommandBuffer &cmd_buf,Semaphore *wait_sem,Semaphore *complete_sem) bool DeviceQueue::Submit(const VkCommandBuffer &cmd_buf,Semaphore *wait_sem,Semaphore *complete_sem)
{ {
return Submit(&cmd_buf,1,wait_sem,complete_sem); return Submit(&cmd_buf,1,wait_sem,complete_sem);
} }

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

@ -75,6 +75,8 @@ void LoadShaderDescriptor(io::ConstBufferReader &cbr,ShaderDescriptor *sd_list,c
} }
} }
ShaderResource *LoadShaderResource(io::ConstBufferReader &cbr);
Material *RenderResource::CreateMaterial(const OSString &filename) Material *RenderResource::CreateMaterial(const OSString &filename)
{ {
Material *mtl; Material *mtl;
@ -137,7 +139,7 @@ Material *RenderResource::CreateMaterial(const OSString &filename)
if(sr) if(sr)
{ {
shader_name=filename+OS_TEXT("?")+OSString(sr->GetStageName()); shader_name=filename+OS_TEXT("?")+ToOSString(sr->GetStageName());
sm=CreateShaderModule(shader_name,sr); sm=CreateShaderModule(shader_name,sr);

4
src/SceneGraph/Vulkan/VKRenderTarget.cpp
View File

@ -6,7 +6,7 @@
#include<hgl/graph/VKFramebuffer.h> #include<hgl/graph/VKFramebuffer.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
RenderTarget::RenderTarget(Queue *q,Semaphore *s) RenderTarget::RenderTarget(DeviceQueue *q,Semaphore *s)
{ {
queue=q; queue=q;
render_pass=nullptr; render_pass=nullptr;
@ -18,7 +18,7 @@ RenderTarget::RenderTarget(Queue *q,Semaphore *s)
render_complete_semaphore=s; render_complete_semaphore=s;
} }
RenderTarget::RenderTarget(Queue *q,Semaphore *s,RenderPass *_rp,Framebuffer *_fb,Texture2D **ctl,const uint32_t cc,Texture2D *dt) RenderTarget::RenderTarget(DeviceQueue *q,Semaphore *s,RenderPass *_rp,Framebuffer *_fb,Texture2D **ctl,const uint32_t cc,Texture2D *dt)
{ {
queue=q; queue=q;
render_pass=_rp; render_pass=_rp;

6
src/SceneGraph/Vulkan/VKRenderable.cpp
View File

@ -51,17 +51,17 @@ Renderable *CreateRenderable(Primitive *r,MaterialInstance *mi,Pipeline *p)
AutoDeleteArray<VkDeviceSize> buffer_size(input_count); AutoDeleteArray<VkDeviceSize> buffer_size(input_count);
VBO *vbo; VBO *vbo;
const AnsiString ** name_list=vil->GetNameList(); const char ** name_list=vil->GetNameList();
const VkVertexInputBindingDescription * bind_list=vil->GetBindingList(); const VkVertexInputBindingDescription * bind_list=vil->GetBindingList();
const VkVertexInputAttributeDescription * attr_list=vil->GetAttributeList(); const VkVertexInputAttributeDescription * attr_list=vil->GetAttributeList();
for(int i=0;i<input_count;i++) for(int i=0;i<input_count;i++)
{ {
vbo=r->GetVBO(**name_list,buffer_size+i); vbo=r->GetVBO(*name_list,buffer_size+i);
if(!vbo) if(!vbo)
{ {
LOG_ERROR("[FATAL ERROR] not found VBO \""+**name_list+"\" in Material: "+mtl_name); LOG_ERROR("[FATAL ERROR] not found VBO \""+AnsiString(*name_list)+"\" in Material: "+mtl_name);
return(nullptr); return(nullptr);
} }

19
src/SceneGraph/Vulkan/VKShaderModule.cpp
View File

@ -48,13 +48,14 @@ VertexShaderModule::VertexShaderModule(VkDevice dev,VkPipelineShaderStageCreateI
attr_count=stage_input_list.GetCount(); attr_count=stage_input_list.GetCount();
ssi_list=stage_input_list.GetData(); ssi_list=stage_input_list.GetData();
name_list=new const AnsiString *[attr_count]; name_list=new const char *[attr_count];
type_list=new VertexAttribType[attr_count]; type_list=new VertexAttribType[attr_count];
for(uint i=0;i<attr_count;i++) for(uint i=0;i<attr_count;i++)
{ {
name_list[i]=&(ssi_list[i]->name); name_list[i] =ssi_list[i]->name;
type_list[i]= ssi_list[i]->type; type_list[i].basetype =VertexAttribType::BaseType(ssi_list[i]->basetype);
type_list[i].vec_size =ssi_list[i]->vec_size;
} }
} }
@ -69,6 +70,8 @@ VertexShaderModule::~VertexShaderModule()
delete[] name_list; delete[] name_list;
} }
const VkFormat GetVulkanFormat(const VertexAttribType::BaseType &base_type,const uint vec_size); //VertexAttrib.cpp
VIL *VertexShaderModule::CreateVIL(const VILConfig *cfg) VIL *VertexShaderModule::CreateVIL(const VILConfig *cfg)
{ {
VkVertexInputBindingDescription *binding_list=new VkVertexInputBindingDescription[attr_count]; VkVertexInputBindingDescription *binding_list=new VkVertexInputBindingDescription[attr_count];
@ -97,11 +100,11 @@ VIL *VertexShaderModule::CreateVIL(const VILConfig *cfg)
if(!cfg||!cfg->Get((*si)->name,vac)) if(!cfg||!cfg->Get((*si)->name,vac))
{ {
attr->format =VK_NAMESPACE::GetVulkanFormat(&((*si)->type)); attr->format =GetVulkanFormat(VertexAttribType::BaseType((*si)->basetype),(*si)->vec_size);
if(memcmp((*si)->name.c_str(),"Inst_",5)==0) //不可以使用CaseComp("Inst_",5)会被认为是比较一个5字长的字符串，而不是只比较5个字符 //if(memcmp((*si)->name.c_str(),"Inst_",5)==0) //不可以使用CaseComp("Inst_",5)会被认为是比较一个5字长的字符串，而不是只比较5个字符
bind->inputRate =VK_VERTEX_INPUT_RATE_INSTANCE; // bind->inputRate =VK_VERTEX_INPUT_RATE_INSTANCE;
else //else
bind->inputRate =VK_VERTEX_INPUT_RATE_VERTEX; bind->inputRate =VK_VERTEX_INPUT_RATE_VERTEX;
} }
else else
@ -109,7 +112,7 @@ VIL *VertexShaderModule::CreateVIL(const VILConfig *cfg)
if(vac.format!=PF_UNDEFINED) if(vac.format!=PF_UNDEFINED)
attr->format =vac.format; attr->format =vac.format;
else else
attr->format =VK_NAMESPACE::GetVulkanFormat(&((*si)->type)); attr->format =GetVulkanFormat(VertexAttribType::BaseType((*si)->basetype),(*si)->vec_size);
bind->inputRate =vac.instance?VK_VERTEX_INPUT_RATE_INSTANCE:VK_VERTEX_INPUT_RATE_VERTEX; bind->inputRate =vac.instance?VK_VERTEX_INPUT_RATE_INSTANCE:VK_VERTEX_INPUT_RATE_VERTEX;
} }

32
src/SceneGraph/Vulkan/VKShaderResource.cpp
View File

@ -26,8 +26,8 @@ VK_NAMESPACE_BEGIN
ss=new ShaderStage; ss=new ShaderStage;
cbr.Read(ss->location); cbr.Read(ss->location);
cbr.CastRead<uint8>(ss->type.basetype); cbr.CastRead<uint8>(ss->basetype);
cbr.CastRead<uint8>(ss->type.vec_size); cbr.CastRead<uint8>(ss->vec_size);
cbr.ReadTinyString(ss->name); cbr.ReadTinyString(ss->name);
@ -45,34 +45,6 @@ VK_NAMESPACE_BEGIN
spv_size=size; spv_size=size;
} }
const os_char *ShaderStageName[]=
{
OS_TEXT("vert"),
OS_TEXT("tesc"),
OS_TEXT("tese"),
OS_TEXT("geom"),
OS_TEXT("frag"),
OS_TEXT("comp"),
OS_TEXT("task"),
OS_TEXT("mesh")
};
const os_char *ShaderResource::GetStageName() const
{
switch(stage_flag)
{
case VK_SHADER_STAGE_VERTEX_BIT: return ShaderStageName[0];
case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT: return ShaderStageName[1];
case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT: return ShaderStageName[2];
case VK_SHADER_STAGE_GEOMETRY_BIT: return ShaderStageName[3];
case VK_SHADER_STAGE_FRAGMENT_BIT: return ShaderStageName[4];
case VK_SHADER_STAGE_COMPUTE_BIT: return ShaderStageName[5];
case VK_SHADER_STAGE_TASK_BIT_NV: return ShaderStageName[6];
case VK_SHADER_STAGE_MESH_BIT_NV: return ShaderStageName[7];
default: return nullptr;
}
}
const ShaderStage *ShaderResource::GetStageInput(const AnsiString &name) const const ShaderStage *ShaderResource::GetStageInput(const AnsiString &name) const
{ {
const int count=stage_inputs.GetCount(); const int count=stage_inputs.GetCount();

2
src/SceneGraph/Vulkan/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(VkDevice dev,Swapchain *sc,Queue *q,Semaphore *rcs,Semaphore *pcs,RenderPass *rp):RenderTarget(q,rcs) SwapchainRenderTarget::SwapchainRenderTarget(VkDevice dev,Swapchain *sc,DeviceQueue *q,Semaphore *rcs,Semaphore *pcs,RenderPass *rp):RenderTarget(q,rcs)
{ {
device=dev; device=dev;

23
src/ShaderGen/CMakeLists.txt Normal file
View File

@ -0,0 +1,23 @@
set(SHADERGEN_INCLUDE_PATH ${ROOT_INCLUDE_PATH}/hgl/shadergen)
SET(SHADERGEN_HEADER_FILES ${SHADERGEN_INCLUDE_PATH}/ShadingProgram.h
${SHADERGEN_INCLUDE_PATH}/PMC.h
${SHADERGEN_INCLUDE_PATH}/VertexInputStage.h
${SHADERGEN_INCLUDE_PATH}/ShaderModule.h
${SHADERGEN_INCLUDE_PATH}/VertexShaderModule.h
${SHADERGEN_INCLUDE_PATH}/ShaderCommon.h
${SHADERGEN_INCLUDE_PATH}/ShaderDescriptorManager.h
${SHADERGEN_INCLUDE_PATH}/MaterialDescriptorManager.h
)
SET(SHADERGEN_SOURCE_FILES PMC.cpp
ShaderDescriptorManager.cpp
MaterialDescriptorManager.cpp
)
#SOURCE_GROUP("Pixel Material Components" FILES ${SHADERGEN_HEADER_FILES}
# ${SHADERGEN_SOURCE_FILES})
add_cm_library(ULRE.ShaderGen "ULRE" ${SHADERGEN_HEADER_FILES}
${SHADERGEN_SOURCE_FILES}
ShaderGen.cpp)