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

added VKDeviceCreater.h

Browse Source
This commit is contained in:
HuYingzhuo(hugo/hyzboy) 2023-05-11 21:14:35 +08:00
parent 4ef1283fce
commit d6d2d337c9
6 changed files with 331 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -24,183 +24,6 @@ class TileFont;
class FontSource;
class GPUArrayBuffer;
struct VulkanHardwareRequirement
{
uint min_1d_image_size;
uint min_2d_image_size;
uint min_3d_image_size;
uint min_cube_image_size;
uint min_array_image_layers;
uint min_vertex_input_attribute; ///<最小顶点输入属性数量需求
uint min_color_attachments; ///<最小颜色输出成份数量需求
uint min_push_constant_size; ///<最小push constant大小
uint min_ubo_range; ///<最小ubo range需求
uint min_ssbo_range; ///<最小ssbo range需求
uint min_draw_indirect_count; ///<最小间接绘制次数需求
bool geometry_shader; ///<要求支持几何着色器
bool tessellation_shader; ///<要求支持细分着色器
// bool compute_shader; ///<要求支持计算着色器
bool multi_draw_indirect; ///<要求支持MultiDrawIndirect
bool wide_lines; ///<要求支持宽线条
bool line_rasterization; ///<要支持线条特性(这功能mac/ios平台不支持)
bool large_points; ///<要求支持绘制大点
bool texture_cube_array; ///<要求支持立方体数组纹理
bool uint32_draw_index; ///<要求支持32位索引(不建议使用)
struct
{
bool bc,etc2,astc_ldr,astc_hdr,pvrtc; ///<要求支持的压缩纹理格式
}texture_compression;
//dynamic_state VK_EXT_extended_dynamic_state
// cull mode
// front face
// primitive topology
// viewport
// scissor
// bind vbo
// depth test
// depth write
// depth compare op
// depth bounds test
// stencil test
// stencil op
//dynamic_state[1] VK_EXT_extended_dynamic_state2
// patch control points
// rasterizer discard
// depth bias
// logic op
// primitive restart
//dynamic_state[2] VK_EXT_extended_dynamic_state3
// tess domain origin
// depth clamp
// discard polygon mode
// rasterization samples
// sample mask
// alpha to coverage
// alpha to one
// logic op enable
// color blend
// color blend equation
// color write mask
// depth clamp
// Color blend advanced
// line rasterization mode
// line stipple
// depth clip -1 to 1
// shading rate image enable
bool dynamic_state[3]; ///<要求支持动态状态
// 1.3 特性
bool dynamic_rendering; ///<要求支持动态渲染
};
constexpr const VkFormat SwapchainPreferFormatsLDR[]=
{
PF_RGB5A1,
PF_BGR5A1,
PF_A1RGB5,
PF_RGB565,
PF_BGR565,
};
constexpr const VkFormat SwapchainPreferFormatsSDR[]=
{
PF_RGBA8UN,PF_RGBA8s,
PF_BGRA8UN,PF_BGRA8s,
PF_ABGR8UN,PF_ABGR8s,
PF_A2RGB10UN,
PF_A2BGR10UN,
PF_B10GR11UF
};
constexpr const VkFormat SwapchainPreferFormatsHDR16[]=
{
PF_RGBA16UN,PF_RGBA16SN,PF_RGBA16F
};
constexpr const VkFormat SwapchainPreferFormatsHDR32[]=
{
PF_RGB32F,
PF_RGBA32F
};
constexpr const VkFormat SwapchainPreferFormatsDepth[]=
{
PF_D16UN,
PF_X8_D24UN,
PF_D16UN_S8U,
PF_D24UN_S8U,
PF_D32F,
PF_D32F_S8U
};
struct PreferFormats
{
//偏好格式需从低质量到高质量排列
const VkFormat *formats;
uint count;
};
constexpr const PreferFormats PreferLDR {SwapchainPreferFormatsLDR, sizeof(SwapchainPreferFormatsLDR )/sizeof(VkFormat)};
constexpr const PreferFormats PreferSDR {SwapchainPreferFormatsSDR, sizeof(SwapchainPreferFormatsSDR )/sizeof(VkFormat)};
constexpr const PreferFormats PreferHDR16{SwapchainPreferFormatsHDR16, sizeof(SwapchainPreferFormatsHDR16 )/sizeof(VkFormat)};
constexpr const PreferFormats PreferHDR32{SwapchainPreferFormatsHDR32, sizeof(SwapchainPreferFormatsHDR32 )/sizeof(VkFormat)};
constexpr const PreferFormats PreferDepth{SwapchainPreferFormatsDepth, sizeof(SwapchainPreferFormatsDepth )/sizeof(VkFormat)};
class VulkanDeviceCreateInfo
{
protected:
VulkanInstance *instance;
Window *window;
const GPUPhysicalDevice *physical_device;
VulkanHardwareRequirement require;
const PreferFormats *perfer_color_formats;
const PreferFormats *perfer_depth_formats;
public:
VulkanDeviceCreateInfo( VulkanInstance *vi,
Window *win,
const PreferFormats *spf_color=&PreferSDR,
const PreferFormats *spf_depth=&PreferDepth)
{
instance=vi;
window=win;
physical_device=nullptr;
hgl_zero(require);
perfer_color_formats=spf_color;
perfer_depth_formats=spf_depth;
}
virtual bool ChoosePhysicalDevice()
{
physical_device=nullptr;
if(!physical_device)physical_device=instance->GetDevice(VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU); //先找独显
if(!physical_device)physical_device=instance->GetDevice(VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU); //再找集显
if(!physical_device)physical_device=instance->GetDevice(VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU); //最后找虚拟显卡
return physical_device;
}
virtual bool RequirementCheck();
};
class GPUDevice
{
GPUDeviceAttribute *attr;
@ -230,7 +53,7 @@ private:
private:
friend GPUDevice *CreateRenderDevice(VulkanDeviceCreateInfo *,VkSurfaceKHR surface,const VkExtent2D &extent);
friend class VulkanDeviceCreater;
GPUDevice(GPUDeviceAttribute *da);
@ -293,10 +116,12 @@ public: //Buffer相关
VBO * CreateVBO (const VAD *vad, SharingMode sm=SharingMode::Exclusive){return CreateVBO(vad->GetFormat(),vad->GetCount(),vad->GetData(),sm);}
IndexBuffer * CreateIBO (IndexType type, uint32_t count,const void * data, SharingMode sm=SharingMode::Exclusive);
IndexBuffer * CreateIBO8 ( uint32_t count,const void * data, SharingMode sm=SharingMode::Exclusive){return CreateIBO(IndexType::U8, count,(void *)data,sm);}
IndexBuffer * CreateIBO16 ( uint32_t count,const uint16 *data, SharingMode sm=SharingMode::Exclusive){return CreateIBO(IndexType::U16, count,(void *)data,sm);}
IndexBuffer * CreateIBO32 ( uint32_t count,const uint32 *data, SharingMode sm=SharingMode::Exclusive){return CreateIBO(IndexType::U32, count,(void *)data,sm);}
IndexBuffer * CreateIBO (IndexType type, uint32_t count, SharingMode sm=SharingMode::Exclusive){return CreateIBO(type, count,nullptr,sm);}
IndexBuffer * CreateIBO8 ( uint32_t count, SharingMode sm=SharingMode::Exclusive){return CreateIBO(IndexType::U8, 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);}
@ -429,7 +254,5 @@ public:
TileFont *CreateTileFont(FontSource *fs,int limit_count=-1); ///<创建一个Tile字体
};//class GPUDevice
GPUDevice *CreateRenderDevice(VulkanDeviceCreateInfo *);
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_DEVICE_INCLUDE

215
inc/hgl/graph/VKDeviceCreater.h Normal file
View File

@ -0,0 +1,215 @@
#pragma once
#include<hgl/graph/VK.h>
VK_NAMESPACE_BEGIN
struct VulkanHardwareRequirement
{
uint min_1d_image_size;
uint min_2d_image_size;
uint min_3d_image_size;
uint min_cube_image_size;
uint min_array_image_layers;
uint min_vertex_input_attribute; ///<最小顶点输入属性数量需求
uint min_color_attachments; ///<最小颜色输出成份数量需求
uint min_push_constant_size; ///<最小push constant大小
uint min_ubo_range; ///<最小ubo range需求
uint min_ssbo_range; ///<最小ssbo range需求
uint min_draw_indirect_count; ///<最小间接绘制次数需求
bool geometry_shader; ///<要求支持几何着色器
bool tessellation_shader; ///<要求支持细分着色器
// bool compute_shader; ///<要求支持计算着色器
bool multi_draw_indirect; ///<要求支持MultiDrawIndirect
bool wide_lines; ///<要求支持宽线条
bool line_rasterization; ///<要支持线条特性(这功能mac/ios平台不支持)
bool large_points; ///<要求支持绘制大点
bool texture_cube_array; ///<要求支持立方体数组纹理
bool uint8_draw_index; ///<要求支持8位索引
bool uint32_draw_index; ///<要求支持32位索引(不建议使用)
struct
{
bool bc,etc2,astc_ldr,astc_hdr,pvrtc; ///<要求支持的压缩纹理格式
}texture_compression;
//dynamic_state VK_EXT_extended_dynamic_state
// cull mode
// front face
// primitive topology
// viewport
// scissor
// bind vbo
// depth test
// depth write
// depth compare op
// depth bounds test
// stencil test
// stencil op
//dynamic_state[1] VK_EXT_extended_dynamic_state2
// patch control points
// rasterizer discard
// depth bias
// logic op
// primitive restart
//dynamic_state[2] VK_EXT_extended_dynamic_state3
// tess domain origin
// depth clamp
// discard polygon mode
// rasterization samples
// sample mask
// alpha to coverage
// alpha to one
// logic op enable
// color blend
// color blend equation
// color write mask
// depth clamp
// Color blend advanced
// line rasterization mode
// line stipple
// depth clip -1 to 1
// shading rate image enable
bool dynamic_state[3]; ///<要求支持动态状态
// 1.3 特性
bool dynamic_rendering; ///<要求支持动态渲染
uint32_t descriptor_pool; ///<描述符池大小(默认1024)
public:
VulkanHardwareRequirement()
{
hgl_zero(*this);
descriptor_pool=1024;
}
};
constexpr const VkFormat SwapchainPreferFormatsLDR[]=
{
PF_RGB5A1,
PF_BGR5A1,
PF_A1RGB5,
PF_RGB565,
PF_BGR565,
};
constexpr const VkFormat SwapchainPreferFormatsSDR[]=
{
PF_RGBA8UN,PF_RGBA8s,
PF_BGRA8UN,PF_BGRA8s,
PF_ABGR8UN,PF_ABGR8s,
PF_A2RGB10UN,
PF_A2BGR10UN,
PF_B10GR11UF
};
constexpr const VkFormat SwapchainPreferFormatsHDR16[]=
{
PF_RGBA16UN,PF_RGBA16SN,PF_RGBA16F
};
constexpr const VkFormat SwapchainPreferFormatsHDR32[]=
{
PF_RGB32F,
PF_RGBA32F
};
constexpr const VkFormat SwapchainPreferFormatsDepth[]=
{
PF_D16UN,
PF_X8_D24UN,
PF_D16UN_S8U,
PF_D24UN_S8U,
PF_D32F,
PF_D32F_S8U
};
struct PreferFormats
{
//偏好格式需从低质量到高质量排列
const VkFormat *formats;
uint count;
};
constexpr const PreferFormats PreferLDR {SwapchainPreferFormatsLDR, sizeof(SwapchainPreferFormatsLDR )/sizeof(VkFormat)};
constexpr const PreferFormats PreferSDR {SwapchainPreferFormatsSDR, sizeof(SwapchainPreferFormatsSDR )/sizeof(VkFormat)};
constexpr const PreferFormats PreferHDR16{SwapchainPreferFormatsHDR16, sizeof(SwapchainPreferFormatsHDR16 )/sizeof(VkFormat)};
constexpr const PreferFormats PreferHDR32{SwapchainPreferFormatsHDR32, sizeof(SwapchainPreferFormatsHDR32 )/sizeof(VkFormat)};
constexpr const PreferFormats PreferDepth{SwapchainPreferFormatsDepth, sizeof(SwapchainPreferFormatsDepth )/sizeof(VkFormat)};
/**
* Vulkan设备创建器
*/
class VulkanDeviceCreater
{
protected:
VulkanInstance *instance;
Window *window;
const GPUPhysicalDevice *physical_device;
VulkanHardwareRequirement require;
VkExtent2D extent;
const PreferFormats *perfer_color_formats;
const PreferFormats *perfer_depth_formats;
VkSurfaceKHR surface;
CharPointerList ext_list;
VkPhysicalDeviceFeatures features={};
protected:
VkDevice CreateDevice(const uint32_t);
public:
VulkanDeviceCreater(VulkanInstance *vi,
Window *win,
const PreferFormats *spf_color,
const PreferFormats *spf_depth,
const VulkanHardwareRequirement *req);
virtual bool ChoosePhysicalDevice()
{
physical_device=nullptr;
if(!physical_device)physical_device=instance->GetDevice(VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU); //先找独显
if(!physical_device)physical_device=instance->GetDevice(VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU); //再找集显
if(!physical_device)physical_device=instance->GetDevice(VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU); //最后找虚拟显卡
return physical_device;
}
virtual bool RequirementCheck();
virtual GPUDevice *CreateRenderDevice();
public:
virtual GPUDevice *Create();
};//class VulkanDeviceCreater
inline GPUDevice *CreateRenderDevice( VulkanInstance *vi,
Window *win,
const PreferFormats *spf_color=&PreferSDR,
const PreferFormats *spf_depth=&PreferDepth,
const VulkanHardwareRequirement *req=nullptr)
{
VulkanDeviceCreater vdc(vi,win,spf_color,spf_depth,req);
return vdc.Create();
}
VK_NAMESPACE_END

16
src/SceneGraph/CMakeLists.txt
View File

@ -131,12 +131,14 @@ SET(VK_TEXTURE_LOADER_SOURCE ${SG_INCLUDE_PATH}/VKTextureCreateInfo.h
Vulkan/Texture/VKTexture2DLoader.cpp
Vulkan/Texture/VKTextureCubeLoader.cpp)
SET(VK_DEVICE_SOURCE ${SG_INCLUDE_PATH}/VKDevice.h
${SG_INCLUDE_PATH}/VKDeviceAttribute.h
Vulkan/VKDeviceAttribute.cpp
Vulkan/VKDeviceCreater.cpp
Vulkan/VKDevice.cpp
Vulkan/VKDeviceMemory.cpp
SET(VK_DEVICE_MAIN_SOURCE ${SG_INCLUDE_PATH}/VKDevice.h
${SG_INCLUDE_PATH}/VKDeviceAttribute.h
${SG_INCLUDE_PATH}/VKDeviceCreater.h
Vulkan/VKDeviceAttribute.cpp
Vulkan/VKDeviceCreater.cpp
Vulkan/VKDevice.cpp)
SET(VK_DEVICE_SOURCE Vulkan/VKDeviceMemory.cpp
Vulkan/VKDeviceBuffer.cpp
Vulkan/VKDeviceImage.cpp
Vulkan/VKDeviceSampler.cpp
@ -154,6 +156,7 @@ SET(VK_PHYSICAL_DEVICE_SOURCE ${SG_INCLUDE_PATH}/VKPhysicalDevice.h
Vulkan/Debug/VKPhysicalDeviceCapsOutput.cpp)
SOURCE_GROUP("Vulkan\\Device" FILES ${VK_DEVICE_SOURCE})
SOURCE_GROUP("Vulkan\\Device\\Main" FILES ${VK_DEVICE_MAIN_SOURCE})
SOURCE_GROUP("Vulkan\\Device\\Debug" FILES ${VK_DEBUG_SOURCE})
SOURCE_GROUP("Vulkan\\Device\\Instance" FILES ${VK_INST_SOURCE})
SOURCE_GROUP("Vulkan\\Device\\Physical Device" FILES ${VK_PHYSICAL_DEVICE_SOURCE})
@ -253,6 +256,7 @@ SET(VULKAN_RENDER_SOURCE ${VK_RR_SOURCE}
${VK_DEBUG_SOURCE}
${VK_MEMORY_SOURCE}
${VK_DEVICE_SOURCE}
${VK_DEVICE_MAIN_SOURCE}
${VK_DEVICE_TEXTURE_SOURCE}
${VK_TEXTURE_LOADER_SOURCE}
${VK_PHYSICAL_DEVICE_SOURCE}

2
src/SceneGraph/Vulkan/Debug/VKPhysicalDeviceCapsOutput.cpp
View File

@ -339,7 +339,7 @@ namespace
}
}//namespace
void OutputPhysicalDeviceCaps(GPUPhysicalDevice *pd)
void OutputPhysicalDeviceCaps(const GPUPhysicalDevice *pd)
{
DebugOut(pd->GetProperties());
DebugOut(pd->GetFeatures10());

178
src/SceneGraph/Vulkan/VKDeviceCreater.cpp
View File

@ -5,6 +5,7 @@
#include<hgl/graph/VKPhysicalDevice.h>
#include<hgl/graph/VKFramebuffer.h>
#include<hgl/graph/VKTexture.h>
#include<hgl/graph/VKDeviceCreater.h>
#include<hgl/graph/VKDevice.h>
#include<hgl/graph/VKDebugMaker.h>
@ -52,6 +53,9 @@ namespace
if(require.texture_compression.pvrtc) //前面检测过了，所以这里不用再次检测是否支持
ext_list->Add(VK_IMG_FORMAT_PVRTC_EXTENSION_NAME);
if(require.uint8_draw_index)
ext_list->Add(VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME);
}
void SetDeviceFeatures(VkPhysicalDeviceFeatures *features,const VkPhysicalDeviceFeatures &pdf,const VulkanHardwareRequirement &require)
@ -73,44 +77,6 @@ namespace
#undef FEATURE_COPY
}
VkDevice CreateDevice(VulkanDeviceCreateInfo *vdci,uint32_t graphics_family)
{
float queue_priorities[1]={0.0};
VkDeviceQueueCreateInfo queue_info;
queue_info.sType =VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queue_info.pNext =nullptr;
queue_info.queueFamilyIndex =graphics_family;
queue_info.queueCount =1;
queue_info.pQueuePriorities =queue_priorities;
queue_info.flags =0; //如果这里写VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT，会导致vkGetDeviceQueue调用崩溃
VkDeviceCreateInfo create_info;
CharPointerList ext_list;
VkPhysicalDeviceFeatures features={};
SetDeviceExtension(&ext_list,vdci->physical_device,vdci->require);
SetDeviceFeatures(&features,vdci->physical_device->GetFeatures10(),vdci->require);
create_info.sType =VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
create_info.pNext =nullptr;
create_info.flags =0;
create_info.queueCreateInfoCount =1;
create_info.pQueueCreateInfos =&queue_info;
create_info.enabledExtensionCount =ext_list.GetCount();
create_info.ppEnabledExtensionNames =ext_list.GetData();
create_info.enabledLayerCount =0;
create_info.ppEnabledLayerNames =nullptr;
create_info.pEnabledFeatures =&features;
VkDevice device;
if(vkCreateDevice(*(vdci->physical_device),&create_info,nullptr,&device)==VK_SUCCESS)
return device;
return nullptr;
}
void GetDeviceQueue(GPUDeviceAttribute *attr)
{
vkGetDeviceQueue(attr->device,attr->graphics_family,0,&attr->graphics_queue);
@ -195,23 +161,55 @@ constexpr size_t VK_DRIVER_ID_RANGE_SIZE=VK_DRIVER_ID_END_RANGE-VK_DRIVER_ID_BEG
#endif//VK_DRIVER_ID_RANGE_SIZE
#ifdef _DEBUG
void OutputPhysicalDeviceCaps(GPUPhysicalDevice *);
void OutputPhysicalDeviceCaps(const GPUPhysicalDevice *);
#endif//_DEBUG
GPUDevice *CreateRenderDevice(VulkanDeviceCreateInfo *vdci,VkSurfaceKHR surface,const VkExtent2D &extent)
VkDevice VulkanDeviceCreater::CreateDevice(const uint32_t graphics_family)
{
#ifdef _DEBUG
OutputPhysicalDeviceCaps(physical_device);
#endif//_DEBUG
float queue_priorities[1]={0.0};
GPUDeviceAttribute *device_attr=new GPUDeviceAttribute(vdci->instance,vdci->physical_device,surface);
VkDeviceQueueCreateInfo queue_info;
queue_info.sType =VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queue_info.pNext =nullptr;
queue_info.queueFamilyIndex =graphics_family;
queue_info.queueCount =1;
queue_info.pQueuePriorities =queue_priorities;
queue_info.flags =0; //如果这里写VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT，会导致vkGetDeviceQueue调用崩溃
VkDeviceCreateInfo create_info;
create_info.sType =VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
create_info.pNext =nullptr;
create_info.flags =0;
create_info.queueCreateInfoCount =1;
create_info.pQueueCreateInfos =&queue_info;
create_info.enabledExtensionCount =ext_list.GetCount();
create_info.ppEnabledExtensionNames =ext_list.GetData();
create_info.enabledLayerCount =0;
create_info.ppEnabledLayerNames =nullptr;
create_info.pEnabledFeatures =&features;
VkDevice device;
if(vkCreateDevice(*physical_device,&create_info,nullptr,&device)==VK_SUCCESS)
return device;
return nullptr;
}
GPUDevice *VulkanDeviceCreater::CreateRenderDevice()
{
GPUDeviceAttribute *device_attr=new GPUDeviceAttribute(instance,physical_device,surface);
AutoDelete<GPUDeviceAttribute> auto_delete(device_attr);
if(device_attr->graphics_family==ERROR_FAMILY_INDEX)
return(nullptr);
device_attr->device=CreateDevice(vdci,device_attr->graphics_family);
SetDeviceExtension(&ext_list,physical_device,require);
SetDeviceFeatures(&features,physical_device->GetFeatures10(),require);
device_attr->device=CreateDevice(device_attr->graphics_family);
if(!device_attr->device)
return(nullptr);
@ -228,12 +226,12 @@ GPUDevice *CreateRenderDevice(VulkanDeviceCreateInfo *vdci,VkSurfaceKHR surface,
if(!device_attr->cmd_pool)
return(nullptr);
device_attr->desc_pool=CreateDescriptorPool(device_attr->device,1024);
device_attr->desc_pool=CreateDescriptorPool(device_attr->device,require.descriptor_pool);
if(!device_attr->desc_pool)
return(nullptr);
device_attr->pipeline_cache=CreatePipelineCache(device_attr->device,vdci->physical_device->GetProperties());
device_attr->pipeline_cache=CreatePipelineCache(device_attr->device,physical_device->GetProperties());
if(!device_attr->pipeline_cache)
return(nullptr);
@ -243,15 +241,33 @@ GPUDevice *CreateRenderDevice(VulkanDeviceCreateInfo *vdci,VkSurfaceKHR surface,
return(new GPUDevice(device_attr));
}
bool RequirementCheck(const VulkanHardwareRequirement &require,const GPUPhysicalDevice *pd)
VulkanDeviceCreater::VulkanDeviceCreater( VulkanInstance *vi,
Window *win,
const PreferFormats *spf_color,
const PreferFormats *spf_depth,
const VulkanHardwareRequirement *req)
{
const VkPhysicalDeviceLimits &limits=pd->GetLimits();
instance=vi;
window=win;
if(require.min_1d_image_size >0&&require.min_1d_image_size >limits.maxImageDimension1D )return(false);
if(require.min_2d_image_size >0&&require.min_2d_image_size >limits.maxImageDimension2D )return(false);
if(require.min_3d_image_size >0&&require.min_3d_image_size >limits.maxImageDimension3D )return(false);
if(require.min_cube_image_size >0&&require.min_cube_image_size >limits.maxImageDimensionCube )return(false);
if(require.min_array_image_layers >0&&require.min_array_image_layers >limits.maxImageArrayLayers )return(false);
physical_device=nullptr;
perfer_color_formats=spf_color;
perfer_depth_formats=spf_depth;
if(req)
hgl_cpy(require,*req);
}
bool VulkanDeviceCreater::RequirementCheck()
{
const VkPhysicalDeviceLimits &limits=physical_device->GetLimits();
if(require.min_1d_image_size >0&&require.min_1d_image_size >limits.maxImageDimension1D )return(false);
if(require.min_2d_image_size >0&&require.min_2d_image_size >limits.maxImageDimension2D )return(false);
if(require.min_3d_image_size >0&&require.min_3d_image_size >limits.maxImageDimension3D )return(false);
if(require.min_cube_image_size >0&&require.min_cube_image_size >limits.maxImageDimensionCube )return(false);
if(require.min_array_image_layers >0&&require.min_array_image_layers >limits.maxImageArrayLayers )return(false);
if(require.min_vertex_input_attribute >0&&require.min_vertex_input_attribute >limits.maxVertexInputAttributes)return(false);
if(require.min_color_attachments >0&&require.min_color_attachments >limits.maxColorAttachments )return(false);
@ -262,7 +278,8 @@ bool RequirementCheck(const VulkanHardwareRequirement &require,const GPUPhysical
if(require.min_draw_indirect_count >0&&require.min_draw_indirect_count >limits.maxDrawIndirectCount )return(false);
const VkPhysicalDeviceFeatures &features10=pd->GetFeatures10();
const VkPhysicalDeviceFeatures &features10=physical_device->GetFeatures10();
const VkPhysicalDeviceVulkan13Features &features13=physical_device->GetFeatures13();
if(require.geometry_shader &&(!features10.geometryShader ))return(false);
if(require.tessellation_shader &&(!features10.tessellationShader ))return(false);
@ -272,63 +289,56 @@ bool RequirementCheck(const VulkanHardwareRequirement &require,const GPUPhysical
if(require.wide_lines &&(!features10.wideLines ))return(false);
if(require.large_points &&(!features10.largePoints ))return(false);
if(require.texture_cube_array &&(!features10.imageCubeArray ))return(false);
if(require.uint8_draw_index &&(!physical_device->CheckExtensionSupport(VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME)))return(false);
if(require.uint32_draw_index &&(!features10.fullDrawIndexUint32 ))return(false);
if(require.texture_compression.bc &&(!features10.textureCompressionBC))return(false);
if(require.texture_compression.etc2 &&(!features10.textureCompressionETC2))return(false);
if(require.texture_compression.astc_ldr &&(!features10.textureCompressionASTC_LDR))return(false);
const VkPhysicalDeviceVulkan13Features &features13=pd->GetFeatures13();
if(require.texture_compression.astc_hdr &&(!features13.textureCompressionASTC_HDR))return(false);
if(require.texture_compression.pvrtc &&(!physical_device->CheckExtensionSupport(VK_IMG_FORMAT_PVRTC_EXTENSION_NAME)))return(false);
if(require.dynamic_rendering&&(!features13.dynamicRendering))return(false);
if(require.texture_compression.astc_hdr &&(!features13.textureCompressionASTC_HDR))return(false);
if(require.dynamic_state[0]&&(!physical_device->CheckExtensionSupport(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME )))return(false);
if(require.dynamic_state[1]&&(!physical_device->CheckExtensionSupport(VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME )))return(false);
if(require.dynamic_state[2]&&(!physical_device->CheckExtensionSupport(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME )))return(false);
if(require.texture_compression.pvrtc&&(!pd->CheckExtensionSupport(VK_IMG_FORMAT_PVRTC_EXTENSION_NAME)))return(false);
if(require.dynamic_state[0]&&(!pd->CheckExtensionSupport(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME )))return(false);
if(require.dynamic_state[1]&&(!pd->CheckExtensionSupport(VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME )))return(false);
if(require.dynamic_state[2]&&(!pd->CheckExtensionSupport(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME )))return(false);
if(require.line_rasterization&&(!pd->CheckExtensionSupport(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)))return(false);
if(require.line_rasterization&&(!physical_device->CheckExtensionSupport(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)))return(false);
return(true);
}
GPUDevice *CreateRenderDevice(VulkanDeviceCreateInfo *vdci)
GPUDevice *VulkanDeviceCreater::Create()
{
if(!vdci||!vdci->instance)
if(!instance||!window)
return(nullptr);
const GPUPhysicalDevice *pd=vdci->physical_device;
if(!ChoosePhysicalDevice())
return(false);
if(!pd)pd=vdci->instance->GetDevice(VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU); //先找独显
if(!pd)pd=vdci->instance->GetDevice(VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU); //再找集显
if(!pd)pd=vdci->instance->GetDevice(VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU); //最后找虚拟显卡
#ifdef _DEBUG
OutputPhysicalDeviceCaps(physical_device);
#endif//_DEBUG
if(!pd)
return(nullptr);
vdci->physical_device=pd;
if(!RequirementCheck())
return(false);
if(!RequirementCheck(vdci->require,pd))
return(nullptr);
VkSurfaceKHR surface=CreateVulkanSurface(*(vdci->instance),vdci->window);
surface=CreateVulkanSurface(*instance,window);
if(!surface)
return(nullptr);
VkExtent2D extent;
extent.width =window->GetWidth();
extent.height =window->GetHeight();
extent.width =vdci->window->GetWidth();
extent.height =vdci->window->GetHeight();
GPUDevice *device=CreateRenderDevice(vdci,surface,extent);
GPUDevice *device=CreateRenderDevice();
if(!device)
{
vkDestroySurfaceKHR(*(vdci->instance), surface, nullptr);
vkDestroySurfaceKHR(*instance,surface,nullptr);
return(nullptr);
}

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

@ -119,9 +119,13 @@ Material *GPUDevice::CreateMaterial(const UTF8String &mtl_name,ShaderModuleMap *
const VkDeviceSize ubo_range=this->GetUBORange();
// ubo_range大致分为三档，16k,64k,>64k
// 只有手机平台少量老旧GPU为16k，大部分手机与PC均为64k
// Intel 核显与 PowerVR 为128MB或更高，可视为无上限。
// ubo_range大致分为三档:
//
// 16k: Mali-T系列或更早、Mali-G71、nVidia GeForce RTX 3070 Laptop为16k
//
// 64k: 大部分手机与PC均为64k
//
// >64k: Intel 核显与 PowerVR 为128MB，AMD显卡为4GB，可视为随显存无上限。
//
// 我们使用uint8类型在vertex input中保存MaterialInstance ID，表示范围0-255。
// 所以MaterialInstance结构容量按16k/64k分为两个档次，64字节和256字节