SPIR-V shader加载创建module完成并测试通过

example/Vulkan/VKShader.cpp

@@ -2,8 +2,23 @@
 
 VK_NAMESPACE_BEGIN
 
-VkShaderModule CreateShaderModule(VkDevice device,const uint32_t *spv_data,const uint32_t spv_size,const VkShaderStageFlagBits shader_stage_bit)
+ShaderCreater::~ShaderCreater()
 {
+    const int count=shader_stage_list.GetCount();
+
+    if(count>0)
+    {
+        VkPipelineShaderStageCreateInfo *ss=shader_stage_list.GetData();
+        for(int i=0;i<count;i++)
+        {
+            vkDestroyShaderModule(device,ss->module,nullptr);
+            ++ss;
+        }
+    }
+}
+
+bool ShaderCreater::Add(const VkShaderStageFlagBits shader_stage_bit,const void *spv_data,const uint32_t spv_size)
+{   
     VkPipelineShaderStageCreateInfo shader_stage;
     shader_stage.sType=VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
     shader_stage.pNext=nullptr;
@@ -17,14 +32,13 @@ VkShaderModule CreateShaderModule(VkDevice device,const uint32_t *spv_data,const
     moduleCreateInfo.pNext=nullptr;
     moduleCreateInfo.flags=0;
     moduleCreateInfo.codeSize=spv_size;
-    moduleCreateInfo.pCode=spv_data;
+    moduleCreateInfo.pCode=(const uint32_t *)spv_data;
 
-    VkShaderModule shader_module;
+    if(vkCreateShaderModule(device,&moduleCreateInfo,nullptr,&shader_stage.module)!=VK_SUCCESS)
+        return(false);
 
-    if(vkCreateShaderModule(device,&moduleCreateInfo,nullptr,&shader_module)==VK_SUCCESS)
-        return shader_module;
+    shader_stage_list.Add(shader_stage);
 
-    return nullptr;
+    return(true);
 }
-
 VK_NAMESPACE_END

example/Vulkan/VKShader.h

@@ -2,20 +2,52 @@
 #include"VK.h"
 
 VK_NAMESPACE_BEGIN
-class Shader
+/**
+ * Shader ´´½¨Æ÷
+ */
+class ShaderCreater
 {
-    
+    VkDevice device;
+
+    List<VkPipelineShaderStageCreateInfo> shader_stage_list;
+
 public:
 
+    ShaderCreater(VkDevice dev):device(dev){}
+    ~ShaderCreater();
 
-};//class Shader
+    bool Add(const VkShaderStageFlagBits shader_stage_bit,const void *spv_data,const uint32_t spv_size);
 
-VkShaderModule CreateShaderModule(VkDevice device,const uint32_t *spv_data,const uint32_t spv_size,const VkShaderStageFlagBits shader_stage_bit);
+#define ADD_SHADER_FUNC(sn,vk_name)   bool Add##sn##Shader(const void *spv_data,const uint32_t spv_size){return Add(VK_SHADER_STAGE_##vk_name##_BIT,spv_data,spv_size);}
+    ADD_SHADER_FUNC(Vertex,     VERTEX)
+    ADD_SHADER_FUNC(Fragment,   FRAGMENT)
+    ADD_SHADER_FUNC(Geometry,   GEOMETRY)
+    ADD_SHADER_FUNC(TessCtrl,   TESSELLATION_CONTROL)
+    ADD_SHADER_FUNC(TessEval,   TESSELLATION_EVALUATION)
+    ADD_SHADER_FUNC(Compute,    COMPUTE)
+#undef ADD_SHADER_FUNC
 
-inline VkShaderModule CreateVertexShader    (VkDevice device,const uint32_t *spv_data,const uint32_t spv_size) { return CreateShaderModule(device,spv_data,spv_size,VK_SHADER_STAGE_VERTEX_BIT); }
-inline VkShaderModule CreateFragmentShader  (VkDevice device,const uint32_t *spv_data,const uint32_t spv_size) { return CreateShaderModule(device,spv_data,spv_size,VK_SHADER_STAGE_FRAGMENT_BIT); }
-inline VkShaderModule CreateGeometryShader  (VkDevice device,const uint32_t *spv_data,const uint32_t spv_size) { return CreateShaderModule(device,spv_data,spv_size,VK_SHADER_STAGE_GEOMETRY_BIT); }
-inline VkShaderModule CreateTessCtrlShader  (VkDevice device,const uint32_t *spv_data,const uint32_t spv_size) { return CreateShaderModule(device,spv_data,spv_size,VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT); }
-inline VkShaderModule CreateTessEvalShader  (VkDevice device,const uint32_t *spv_data,const uint32_t spv_size) { return CreateShaderModule(device,spv_data,spv_size,VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT); }
-inline VkShaderModule CreateComputeShader   (VkDevice device,const uint32_t *spv_data,const uint32_t spv_size) { return CreateShaderModule(device,spv_data,spv_size,VK_SHADER_STAGE_COMPUTE_BIT); }
+#define ADD_NV_SHADER_FUNC(sn,vk_name)   bool Add##sn##Shader(const void *spv_data,const uint32_t spv_size) { return Add(VK_SHADER_STAGE_##vk_name##_BIT_NV,spv_data,spv_size); }
+    ADD_NV_SHADER_FUNC(Raygen,      RAYGEN);
+    ADD_NV_SHADER_FUNC(AnyHit,      ANY_HIT);
+    ADD_NV_SHADER_FUNC(ClosestHit,  CLOSEST_HIT);
+    ADD_NV_SHADER_FUNC(MissBit,     MISS);
+    ADD_NV_SHADER_FUNC(Intersection,INTERSECTION);
+    ADD_NV_SHADER_FUNC(Callable,    CALLABLE);
+    ADD_NV_SHADER_FUNC(Task,        TASK);
+    ADD_NV_SHADER_FUNC(Mesh,        MESH);
+#undef ADD_NV_SHADER_FUNC
+
+    void Clear()
+    {
+        shader_stage_list.Clear();
+    }
+
+    bool Finish(List<VkPipelineShaderStageCreateInfo> &pss_list)
+    {
+        pss_list=shader_stage_list;
+
+        Clear();
+    }
+};//class ShaderCreater
 VK_NAMESPACE_END

example/Vulkan/main.cpp

@@ -15,14 +15,16 @@ VkShaderModule fs=nullptr;
 
 char *LoadFile(const char *filename,uint32_t &file_length)
 {
-    int fp=_open(filename,O_RDONLY);
+    int fp=_open(filename,O_RDONLY|O_BINARY);
 
     if(fp==-1)return(nullptr);
 
     file_length=_filelength(fp);
     char *data=new char[file_length];
 
-    if(_read(fp,data,file_length)!=file_length)
+    const int result=_read(fp,data,file_length);
+    
+    if(result!=file_length)
     {
         delete[] data;
         return(nullptr);
@@ -32,8 +34,32 @@ char *LoadFile(const char *filename,uint32_t &file_length)
     return data;
 }
 
+bool LoadShader(vulkan::ShaderCreater *sc,const char *filename,VkShaderStageFlagBits shader_flag)
+{
+    uint32_t size;
+    char *data=LoadFile(filename,size);
+
+    if(!data)
+        return(false);
+
+    if(!sc->Add(shader_flag,data,size))
+        return(false);
+
+    delete[] data;
+    return(true);
+}
+
 bool LoadShader(VkDevice device)
 {
+    vulkan::ShaderCreater sc(device);
+
+    if(!LoadShader(&sc,"FlatColor.vert.spv",VK_SHADER_STAGE_VERTEX_BIT))
+        return(false);
+
+    if(!LoadShader(&sc,"FlatColor.frag.spv",VK_SHADER_STAGE_FRAGMENT_BIT))
+        return(false);
+
+    return(true);
 }
 
 int main(int,char **)