codes layout

inc/hgl/graph/VKCommandBuffer.h

@@ -148,7 +148,7 @@ public:
     void PushConstants(const void *data,const uint32_t size)                        {vkCmdPushConstants(cmd_buf,pipeline_layout,VK_SHADER_STAGE_VERTEX_BIT,0,       size,data);}
     void PushConstants(const void *data,const uint32_t offset,const uint32_t size)  {vkCmdPushConstants(cmd_buf,pipeline_layout,VK_SHADER_STAGE_VERTEX_BIT,offset,  size,data);}
 
-    bool BindVAB(RenderableInstance *);
+    bool BindVBO(RenderableInstance *);
 
     void SetViewport        (uint32_t first,uint32_t count,const VkViewport *vp)    {vkCmdSetViewport(cmd_buf,first,count,vp);}
     void SetScissor         (uint32_t first,uint32_t count,const VkRect2D *sci)     {vkCmdSetScissor(cmd_buf,first,count,sci);}
@@ -183,14 +183,47 @@ public: //draw
 
 class TextureCmdBuffer:public GPUCmdBuffer
 {
+    VkImageMemoryBarrier imageMemoryBarrier;
+
 public:
 
-    using GPUCmdBuffer::GPUCmdBuffer;
+    TextureCmdBuffer(const GPUDeviceAttribute *attr,VkCommandBuffer cb):GPUCmdBuffer(attr,cb)
+    {
+        imageMemoryBarrier.sType=VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+        imageMemoryBarrier.pNext=nullptr;
+        imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+        imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    }
 
     template<typename ...ARGS> void PipelineBarrier     (ARGS...args){vkCmdPipelineBarrier  (cmd_buf,args...);}
     template<typename ...ARGS> void CopyBufferToImage   (ARGS...args){vkCmdCopyBufferToImage(cmd_buf,args...);}
     template<typename ...ARGS> void CopyImageToBuffer   (ARGS...args){vkCmdCopyImageToBuffer(cmd_buf,args...);}
     template<typename ...ARGS> void BlitImage           (ARGS...args){vkCmdBlitImage        (cmd_buf,args...);}
+
+    void ImageMemoryBarrier(VkImage image,
+                            VkPipelineStageFlags srcStageMask,
+                            VkPipelineStageFlags dstStageMask,
+                            VkAccessFlags srcAccessMask,
+                            VkAccessFlags dstAccessMask,
+                            VkImageLayout oldImageLayout,
+                            VkImageLayout newImageLayout,
+                            VkImageSubresourceRange subresourceRange)
+    {
+        imageMemoryBarrier.srcAccessMask = srcAccessMask;
+        imageMemoryBarrier.dstAccessMask = dstAccessMask;
+        imageMemoryBarrier.oldLayout = oldImageLayout;
+        imageMemoryBarrier.newLayout = newImageLayout;
+        imageMemoryBarrier.image = image;
+        imageMemoryBarrier.subresourceRange = subresourceRange;
+
+        vkCmdPipelineBarrier(   cmd_buf,
+                                srcStageMask,
+                                dstStageMask,
+                                0,
+                                0, nullptr,
+                                0, nullptr,
+                                1, &imageMemoryBarrier);
+    }
 };//class TextureCmdBuffer:public GPUCmdBuffer
 VK_NAMESPACE_END
 #endif//HGL_GRAPH_VULKAN_COMMAND_BUFFER_INCLUDE

inc/hgl/graph/VKTextureLoader.h

@@ -0,0 +1,97 @@
+#ifndef HGL_GRAPH_VULKAN_TEXTURE_LOADER_INCLUDE
+#define HGL_GRAPH_VULKAN_TEXTURE_LOADER_INCLUDE
+
+#include<hgl/graph/TextureLoader.h>
+
+VK_NAMESPACE_BEGIN
+template<typename T,typename L>
+class VkTextureLoader:public L
+{
+protected:
+
+    GPUDevice *device;
+    GPUBuffer *buf;
+
+    T *tex;
+
+    bool auto_mipmaps;
+
+public:
+
+    VkTextureLoader(GPUDevice *dev,const bool am)
+    {
+        device      =dev;
+        buf         =nullptr;
+        tex         =nullptr;
+        auto_mipmaps=am;
+    }
+
+    virtual ~VkTextureLoader()
+    {
+        SAFE_CLEAR(buf);
+        SAFE_CLEAR(tex);
+    }
+
+    T *GetTexture()
+    {
+        T *result=tex;
+        tex=nullptr;
+        return result;
+    }
+
+    void *OnBegin(uint32 total_bytes) override
+    {
+        SAFE_CLEAR(buf);
+        SAFE_CLEAR(tex);
+
+        if(!CheckVulkanFormat(format))
+            return(nullptr);
+
+        buf=device->CreateBuffer(VK_BUFFER_USAGE_TRANSFER_SRC_BIT,total_bytes);
+
+        if(!buf)
+            return(nullptr);
+
+        return buf->Map();
+    }
+
+    void OnEnd() override
+    {
+        buf->Unmap();
+
+        TextureCreateInfo *tci=new TextureCreateInfo(format);
+
+        tci->type=type;
+
+        VkExtent3D extent;
+        
+        extent.width    =file_header.width;
+        extent.height   =file_header.height;
+        extent.depth    =file_header.depth;
+
+        tci->SetData(buf,extent);
+
+        if(auto_mipmaps&&file_header.mipmaps<=1)
+        {
+            if(device->CheckFormatSupport(format,VK_FORMAT_FEATURE_BLIT_DST_BIT))
+            {
+                tci->usage|=VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+                tci->SetAutoMipmaps();
+            }
+        }
+        else
+        {
+            tci->origin_mipmaps=
+            tci->target_mipmaps=file_header.mipmaps;
+        }
+
+        tci->mipmap_zero_total_bytes=mipmap_zero_total_bytes;
+
+        tex=device->CreateTexture2D(tci);
+
+        if(tex)
+            buf=nullptr;
+    }
+};//class VkTextureLoader:public L
+VK_NAMESPACE_END
+#endif//HGL_GRAPH_VULKAN_TEXTURE_LOADER_INCLUDE