added VKDeviceCreater.h

inc/hgl/graph/VKDevice.h

@@ -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

inc/hgl/graph/VKDeviceCreater.h

@@ -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

src/SceneGraph/CMakeLists.txt

@@ -130,13 +130,15 @@ SET(VK_TEXTURE_LOADER_SOURCE    ${SG_INCLUDE_PATH}/VKTextureCreateInfo.h
                                 Vulkan/Texture/VKTextureLoader.h
                                 Vulkan/Texture/VKTexture2DLoader.cpp
                                 Vulkan/Texture/VKTextureCubeLoader.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    ${SG_INCLUDE_PATH}/VKDevice.h
+SET(VK_DEVICE_SOURCE    Vulkan/VKDeviceMemory.cpp
-                        ${SG_INCLUDE_PATH}/VKDeviceAttribute.h
-                        Vulkan/VKDeviceAttribute.cpp
-                        Vulkan/VKDeviceCreater.cpp
-                        Vulkan/VKDevice.cpp
-                        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}

src/SceneGraph/Vulkan/Debug/VKPhysicalDeviceCapsOutput.cpp

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

src/SceneGraph/Vulkan/VKDeviceCreater.cpp

@@ -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
+    float queue_priorities[1]={0.0};
-        OutputPhysicalDeviceCaps(physical_device);
-    #endif//_DEBUG
 
-    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);
+    physical_device=nullptr;
-    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);
+    perfer_color_formats=spf_color;
-    if(require.min_cube_image_size      >0&&require.min_cube_image_size     >limits.maxImageDimensionCube   )return(false);
+    perfer_depth_formats=spf_depth;
-    if(require.min_array_image_layers   >0&&require.min_array_image_layers  >limits.maxImageArrayLayers     )return(false);
+
+    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);
-
+    if(require.texture_compression.astc_hdr &&(!features13.textureCompressionASTC_HDR))return(false);
-    const VkPhysicalDeviceVulkan13Features &features13=pd->GetFeatures13();
+    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.line_rasterization&&(!physical_device->CheckExtensionSupport(VK_EXT_LINE_RASTERIZATION_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);
 
     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);      //先找独显
+    #ifdef _DEBUG
-    if(!pd)pd=vdci->instance->GetDevice(VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU);    //再找集显
+        OutputPhysicalDeviceCaps(physical_device);
-    if(!pd)pd=vdci->instance->GetDevice(VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU);       //最后找虚拟显卡
+    #endif//_DEBUG
 
-    if(!pd)
-        return(nullptr);
 
-    vdci->physical_device=pd;
+    if(!RequirementCheck())
+        return(false);
 
-    if(!RequirementCheck(vdci->require,pd))
+    surface=CreateVulkanSurface(*instance,window);
-        return(nullptr);
-
-    VkSurfaceKHR surface=CreateVulkanSurface(*(vdci->instance),vdci->window);
 
     if(!surface)
         return(nullptr);
-        
-    VkExtent2D extent;
-    
-    extent.width    =vdci->window->GetWidth();
-    extent.height   =vdci->window->GetHeight();
 
-    GPUDevice *device=CreateRenderDevice(vdci,surface,extent);
+    extent.width    =window->GetWidth();
+    extent.height   =window->GetHeight();
+
+    GPUDevice *device=CreateRenderDevice();
 
     if(!device)
     {
-        vkDestroySurfaceKHR(*(vdci->instance), surface, nullptr);
+        vkDestroySurfaceKHR(*instance,surface,nullptr);
         return(nullptr);
     }
 

src/SceneGraph/Vulkan/VKDeviceMaterial.cpp

@@ -119,9 +119,13 @@ Material *GPUDevice::CreateMaterial(const UTF8String &mtl_name,ShaderModuleMap *
 
     const VkDeviceSize ubo_range=this->GetUBORange();
 
-    // ubo_range大致分为三档，16k,64k,>64k
+    // ubo_range大致分为三档:
-    // 只有手机平台少量老旧GPU为16k，大部分手机与PC均为64k
+    //
-    // Intel 核显与 PowerVR 为128MB或更高，可视为无上限。
+    //  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字节