改进PipelineCreateInfo存档，并增加部分读档操作

example/Vulkan/main.cpp

@@ -7,7 +7,8 @@
 using namespace hgl;
 using namespace hgl::graph;
 
-bool SaveToFile(const OSString &filename,const VkGraphicsPipelineCreateInfo *info);
+bool SaveToFile(const OSString &filename,VK_NAMESPACE::PipelineCreater *pc);
+bool LoadFromFile(const OSString &filename,VK_NAMESPACE::PipelineCreater *pc);
 
 constexpr uint32_t SCREEN_WIDTH=128;
 constexpr uint32_t SCREEN_HEIGHT=128;
@@ -104,22 +105,26 @@ private:
     {
         constexpr os_char PIPELINE_FILENAME[]=OS_TEXT("2DSolid.pipeline");
 
-        //vulkan::PipelineCreater *pipeline_creater=new vulkan::PipelineCreater(device,material,device->GetRenderPass());
+        {
-        //pipeline_creater->SetDepthTest(false);
-        //pipeline_creater->SetDepthWrite(false);
-        //pipeline_creater->CloseCullFace();
-        //pipeline_creater->Set(PRIM_TRIANGLES);
-
             vulkan::PipelineCreater *pipeline_creater=new vulkan::PipelineCreater(device,material,device->GetRenderPass());
+            pipeline_creater->SetDepthTest(false);
+            pipeline_creater->SetDepthWrite(false);
+            pipeline_creater->CloseCullFace();
+            pipeline_creater->Set(PRIM_TRIANGLES);
 
-        pipeline=pipeline_creater->Create();
+            SaveToFile(PIPELINE_FILENAME,pipeline_creater);
-
-        SaveToFile(PIPELINE_FILENAME,pipeline_creater->GetInfo());
 
             delete pipeline_creater;
-        delete pipeline;
+        }
 
+        {
+            vulkan::PipelineCreater *pipeline_creater=new vulkan::PipelineCreater(device,material,device->GetRenderPass());
 
+            LoadFromFile(PIPELINE_FILENAME,pipeline_creater);
+            pipeline=pipeline_creater->Create();
+
+            delete pipeline_creater;
+        }
 
         return pipeline;
     }

inc/hgl/graph/vulkan/VKPipeline.h

@@ -2,6 +2,7 @@
 #define HGL_GRAPH_VULKAN_PIPELINE_INCLUDE
 
 #include<hgl/graph/vulkan/VK.h>
+#include<hgl/io/DataOutputStream.h>
 VK_NAMESPACE_BEGIN
 class Pipeline
 {
@@ -103,7 +104,9 @@ public:
 
     void SetBlendConstans(float *blend_constans)        {hgl_typecpy(colorBlending.blendConstants,blend_constans,4);}
 
-    const VkGraphicsPipelineCreateInfo *GetInfo()const{return &pipelineInfo;}
+    bool SaveToStream(io::DataOutputStream *dos);
+    bool LoadFromMemory(uchar *,uint);
+    
     Pipeline *Create();
 };//class PipelineCreater
 VK_NAMESPACE_END

src/RenderDevice/Vulkan/POD/VKPipelineCreateInfo.POD.cpp

@@ -1,48 +1,114 @@
-#include<vulkan/vulkan.h>
+#include<hgl/graph/vulkan/VKPipeline.h>
 #include<hgl/type/BaseString.h>
 #include<hgl/io/MemoryOutputStream.h>
 #include<hgl/io/DataOutputStream.h>
+#include<hgl/io/MemoryInputStream.h>
+#include<hgl/io/DataInputStream.h>
 #include<hgl/filesystem/FileSystem.h>
 
 using namespace hgl;
 
-namespace
+VK_NAMESPACE_BEGIN
+bool PipelineCreater::SaveToStream(io::DataOutputStream *dos)
 {
-    void Write(io::DataOutputStream *dos,const VkPipelineMultisampleStateCreateInfo *info)
+    if(!dos)return(false);
-    {
-        dos->Write(info);
 
-        if(info->pSampleMask)
+    dos->WriteUint16(1);     //file ver
-            dos->WriteUint32(info->pSampleMask,(info->rasterizationSamples+31)/32);
+
+    dos->Write(&pipelineInfo,sizeof(VkGraphicsPipelineCreateInfo));
+
+    dos->Write(pipelineInfo.pInputAssemblyState,    sizeof(VkPipelineInputAssemblyStateCreateInfo));
+    dos->Write(pipelineInfo.pTessellationState,     sizeof(VkPipelineTessellationStateCreateInfo));
+    dos->Write(pipelineInfo.pRasterizationState,    sizeof(VkPipelineRasterizationStateCreateInfo));
+
+    dos->Write(pipelineInfo.pMultisampleState,      sizeof(VkPipelineMultisampleStateCreateInfo));
+    if(pipelineInfo.pMultisampleState->pSampleMask)
+    {
+        const uint count=(pipelineInfo.pMultisampleState->rasterizationSamples+31)/32;
+        dos->WriteUint8(count);
+        dos->WriteUint32(pipelineInfo.pMultisampleState->pSampleMask,count);
+    }
+    else
+    {
+        dos->WriteUint8(0);
     }
 
-    void Write(io::DataOutputStream *dos,const VkPipelineColorBlendStateCreateInfo *info)
+    dos->Write(pipelineInfo.pDepthStencilState,    sizeof(VkPipelineDepthStencilStateCreateInfo));
-    {
-        dos->Write(info,sizeof(VkPipelineColorBlendStateCreateInfo));
 
-        for(uint32_t i=0;i<info->attachmentCount;i++)
+    dos->Write(pipelineInfo.pColorBlendState,sizeof(VkPipelineColorBlendStateCreateInfo));
-            dos->Write(info->pAttachments+i,sizeof(VkPipelineColorBlendAttachmentState));
+    for(uint32_t i=0;i<pipelineInfo.pColorBlendState->attachmentCount;i++)
-    }
+        dos->Write(pipelineInfo.pColorBlendState->pAttachments+i,sizeof(VkPipelineColorBlendAttachmentState));
-}//namespace
 
-bool SaveToFile(const OSString &filename,const VkGraphicsPipelineCreateInfo *info)
+    return(true);
+}
+
+bool PipelineCreater::LoadFromMemory(uchar *data,uint size)
 {
-    if(filename.IsEmpty()||!info)
+    uint16 ver=*(uint16 *)data;
+
+    if(ver!=1)
+        return(false);
+
+    data+=sizeof(uint16);
+    size-=sizeof(uint16);
+
+    if(size<sizeof(VkGraphicsPipelineCreateInfo))
+        return(false);
+
+    memcpy(&pipelineInfo,data,sizeof(VkGraphicsPipelineCreateInfo));
+    data+=sizeof(VkGraphicsPipelineCreateInfo);
+    size-=sizeof(VkGraphicsPipelineCreateInfo);
+
+    if(size<sizeof(VkPipelineInputAssemblyStateCreateInfo))return(false);
+    pipelineInfo.pInputAssemblyState=(VkPipelineInputAssemblyStateCreateInfo *)data;
+    data+=sizeof(VkPipelineInputAssemblyStateCreateInfo);
+    size-=sizeof(VkPipelineInputAssemblyStateCreateInfo);
+
+    if(size<sizeof(VkPipelineTessellationStateCreateInfo))return(false);
+    pipelineInfo.pTessellationState=(VkPipelineTessellationStateCreateInfo *)data;
+    data+=sizeof(VkPipelineTessellationStateCreateInfo);
+    size-=sizeof(VkPipelineTessellationStateCreateInfo);
+
+    if(size<sizeof(VkPipelineRasterizationStateCreateInfo))return(false);
+    pipelineInfo.pRasterizationState=(VkPipelineRasterizationStateCreateInfo *)data;
+    data+=sizeof(VkPipelineRasterizationStateCreateInfo);
+    size-=sizeof(VkPipelineRasterizationStateCreateInfo);
+
+    
+    if(size<sizeof(VkPipelineMultisampleStateCreateInfo)+1)return(false);
+    pipelineInfo.pMultisampleState=(VkPipelineMultisampleStateCreateInfo *)data;
+    data+=sizeof(VkPipelineMultisampleStateCreateInfo);
+    size-=sizeof(VkPipelineMultisampleStateCreateInfo);
+
+    const uint8 count=*(uint8 *)data;
+
+    if(count>0)
+    {
+        pipelineInfo.pMultisampleState->pSampleMask=(const VkSampleMask *)data;
+        data+=count;
+        size=count;
+    }
+    else
+    {
+        pipelineInfo.pMultisampleState->pSampleMask=nullptr;
+    }
+
+    if(size<sizeof(VkPipelineDepthStencilStateCreateInfo))return(false);
+    pipelineInfo.pDepthStencilState=(VkPipelineDepthStencilStateCreateInfo *)data;
+    data+=sizeof(VkPipelineDepthStencilStateCreateInfo);
+    size-=sizeof(VkPipelineDepthStencilStateCreateInfo);
+}
+VK_NAMESPACE_END
+
+bool SaveToFile(const OSString &filename,VK_NAMESPACE::PipelineCreater *pc)
+{
+    if(filename.IsEmpty()||!pc)
         return(false);
 
     io::MemoryOutputStream mos;
     io::DataOutputStream *dos=new io::LEDataOutputStream(&mos);
 
-    dos->WriteUint16(1);     //file ver
+    pc->SaveToStream(dos);
-
-    dos->Write(info,sizeof(VkGraphicsPipelineCreateInfo));
-
-    dos->Write(info->pInputAssemblyState,   sizeof(VkPipelineInputAssemblyStateCreateInfo));
-    dos->Write(info->pTessellationState,    sizeof(VkPipelineTessellationStateCreateInfo));
-    dos->Write(info->pRasterizationState,   sizeof(VkPipelineRasterizationStateCreateInfo));
-    Write(dos,info->pMultisampleState);
-    dos->Write(info->pDepthStencilState,    sizeof(VkPipelineDepthStencilStateCreateInfo));
-    Write(dos,info->pColorBlendState);
 
     delete dos;
 
@@ -50,3 +116,17 @@ bool SaveToFile(const OSString &filename,const VkGraphicsPipelineCreateInfo *inf
 
     return(true);
 }
+
+bool LoadFromFile(const OSString &filename,VK_NAMESPACE::PipelineCreater *pc)
+{
+    if(filename.IsEmpty()||!pc)
+        return(false);
+
+    void *data;
+    uint size=filesystem::LoadFileToMemory(filename,(void **)&data);
+
+    bool result=pc->LoadFromMemory((uchar *)data,size);
+
+    delete[] data;
+    return result;
+}