added VKIndirectCommandBuffer.cpp and other codes.

inc/hgl/graph/VK.h

@@ -106,6 +106,10 @@ class Renderable;
 class VertexDataManager;
 using VDM=VertexDataManager;
 
+class IndirectDrawBuffer;
+class IndirectDrawIndexedBuffer;
+class IndirectDispatchBuffer;
+
 class RenderResource;
 
 enum class SharingMode

inc/hgl/graph/VKBuffer.h

@@ -23,6 +23,7 @@ private:
     friend class GPUDevice;
     friend class VertexAttribBuffer;
     friend class IndexBuffer;
+    template<typename T> friend class IndirectCommandBuffer;
 
     DeviceBuffer(VkDevice d,const DeviceBufferData &b)
     {

inc/hgl/graph/VKDevice.h

@@ -22,6 +22,9 @@ class TileData;
 class TileFont;
 class FontSource;
 class GPUArrayBuffer;
+class IndirectDrawBuffer;
+class IndirectDrawIndexedBuffer;
+class IndirectDispatchBuffer;
 
 struct CopyBufferToImageInfo;
 
@@ -149,6 +152,14 @@ public: //Buffer相关
     GPUArrayBuffer *CreateArrayInUBO(const VkDeviceSize &uint_size);
     GPUArrayBuffer *CreateArrayInSSBO(const VkDeviceSize &uint_size);
 
+public: //间接绘制
+
+    bool CreateIndirectCommandBuffer(DeviceBufferData *,const uint32_t cmd_count,const uint32_t cmd_size,SharingMode sm=SharingMode::Exclusive);
+
+    IndirectDrawBuffer *        CreateIndirectDrawBuffer(       const uint32_t cmd_count,SharingMode sm=SharingMode::Exclusive);
+    IndirectDrawIndexedBuffer * CreateIndirectDrawIndexedBuffer(const uint32_t cmd_count,SharingMode sm=SharingMode::Exclusive);
+    IndirectDispatchBuffer *    CreateIndirectDispatchBuffer(   const uint32_t cmd_count,SharingMode sm=SharingMode::Exclusive);
+
 public: //Image
 
     VkImage CreateImage         (VkImageCreateInfo *);

inc/hgl/graph/VKIndirectCommandBuffer.h

@@ -4,34 +4,85 @@
 
 VK_NAMESPACE_BEGIN
 
+template<typename T>
 class IndirectCommandBuffer:public DeviceBuffer
 {
 protected:
 
     uint32_t max_count;
-    uint32_t stride;
+
+public:
+
+    const uint32_t      GetMaxCount     ()const{ return max_count; }                ///<取得最大指令数
+    const uint32_t      GetCommandLength()const{ return sizeof(T); }                ///<取得单个指令的长度字节数
+    const VkDeviceSize  GetTotalBytes   ()const{ return sizeof(T)*max_count; }      ///<取得缓冲区总计字节数
 
 private:
 
     friend class GPUDevice;
 
-    IndirectCommandBuffer(VkDevice d,const DeviceBufferData &vb,const uint32_t mc,const uint32_t s):DeviceBuffer(d,vb)
+    IndirectCommandBuffer(VkDevice d,const DeviceBufferData &vb,const uint32_t mc):DeviceBuffer(d,vb)
     {
         max_count=mc;
-        stride=s;
     }
 
-    ~IndirectCommandBuffer()=default;
+public:
 
-    const uint32_t GetMaxCount ()const { return max_count; }
+    virtual ~IndirectCommandBuffer()=default;
+   
+    T *     MapCmd  ()                                                      {return (T *)Map();}
+    void *  Map     (VkDeviceSize start,VkDeviceSize size)          override{return DeviceBuffer::Map(start*sizeof(T),size*sizeof(T));}
+    T *     MapCmd  (VkDeviceSize start,VkDeviceSize size)                  {return (T *)Map(start,size);}
 
-    const VkDeviceSize GetTotalBytes()const { return stride*max_count; }
-    
-    void *  Map     (VkDeviceSize start,VkDeviceSize size)          override {return DeviceBuffer::Map(start*stride,size*stride);}
-    void    Flush   (VkDeviceSize start,VkDeviceSize size)          override {return DeviceBuffer::Flush(start*stride,size*stride);}
-    void    Flush   (VkDeviceSize size)                             override {return DeviceBuffer::Flush(size*stride);}
+    void    Flush   (VkDeviceSize start,VkDeviceSize size)          override{return DeviceBuffer::Flush(start*sizeof(T),size*sizeof(T));}
+    void    Flush   (VkDeviceSize size)                             override{return DeviceBuffer::Flush(size*sizeof(T));}
 
-    bool    Write   (const void *ptr,uint32_t start,uint32_t size)  override {return DeviceBuffer::Write(ptr,start*stride,size*stride);}
-    bool    Write   (const void *ptr,uint32_t size)                 override {return DeviceBuffer::Write(ptr,0,size*stride);}
+    bool    Write   (const void *ptr,uint32_t start,uint32_t size)  override{return DeviceBuffer::Write(ptr,start*sizeof(T),size*sizeof(T));}
+    bool    Write   (const void *ptr,uint32_t size)                 override{return DeviceBuffer::Write(ptr,0,size*sizeof(T));}
+
+    bool    WriteCmd(const T *ptr,uint32_t start,uint32_t size)             {return DeviceBuffer::Write(ptr,start*sizeof(T),size*sizeof(T));}
+    bool    WriteCmd(const T *ptr,uint32_t size)                            {return DeviceBuffer::Write(ptr,0,size*sizeof(T));}
 };//class IndirectCommandBuffer:public DeviceBuffer
+
+class IndirectDrawBuffer:public IndirectCommandBuffer<VkDrawIndirectCommand>
+{
+    friend class GPUDevice;
+
+public:
+    
+    using IndirectCommandBuffer<VkDrawIndirectCommand>::IndirectCommandBuffer;
+        
+    void Draw(VkCommandBuffer cmd_buf,uint32_t offset,uint32_t draw_count,uint32_t stride) const
+    {
+        vkCmdDrawIndirect(cmd_buf,buf.buffer,offset,draw_count,stride);
+    }
+};//class IndirectDrawBuffer:public IndirectCommandBuffer<VkDrawIndirectCommand>
+
+class IndirectDrawIndexedBuffer:public IndirectCommandBuffer<VkDrawIndexedIndirectCommand>
+{
+    friend class GPUDevice;
+
+public:
+
+    using IndirectCommandBuffer<VkDrawIndexedIndirectCommand>::IndirectCommandBuffer;
+    
+    void DrawIndexed(VkCommandBuffer cmd_buf,uint32_t offset,uint32_t draw_count,uint32_t stride) const
+    {
+        vkCmdDrawIndexedIndirect(cmd_buf,buf.buffer,offset,draw_count,stride);
+    }
+};//class IndirectDrawIndexedBuffer:public IndirectCommandBuffer<VkDrawIndexedIndirectCommand>
+
+class IndirectDispatchBuffer:public IndirectCommandBuffer<VkDispatchIndirectCommand>
+{
+    friend class GPUDevice;
+
+public:
+
+    using IndirectCommandBuffer<VkDispatchIndirectCommand>::IndirectCommandBuffer;
+            
+    void Dispatch(VkCommandBuffer cmd_buf,uint32_t offset) const
+    {
+        vkCmdDispatchIndirect(cmd_buf,buf.buffer,offset);
+    }
+};//class IndirectDispatchBuffer:public IndirectCommandBuffer<VkDispatchIndirectCommand>
 VK_NAMESPACE_END

src/SceneGraph/CMakeLists.txt

@@ -237,6 +237,7 @@ SOURCE_GROUP("Vulkan\\Render Context" FILES ${VK_RENDER_CONTEXT_SOURCE})
 
 SET(VK_CMD_BUFFER_SOURCE    ${SG_INCLUDE_PATH}/VKCommandBuffer.h
                             ${SG_INCLUDE_PATH}/VKIndirectCommandBuffer.h
+                            Vulkan/VKIndirectCommandBuffer.cpp
                             Vulkan/VKCommandBuffer.cpp
                             Vulkan/VKCommandBufferRender.cpp)
 

src/SceneGraph/Vulkan/VKIndirectCommandBuffer.cpp

@@ -0,0 +1,45 @@
+#include<hgl/graph/VKIndirectCommandBuffer.h>
+#include<hgl/graph/VKDevice.h>
+
+VK_NAMESPACE_BEGIN
+
+bool GPUDevice::CreateIndirectCommandBuffer(DeviceBufferData *buf,const uint32_t cmd_count,const uint32_t cmd_size,SharingMode sharing_mode)
+{
+    const uint32_t size=cmd_count*cmd_size;
+
+    if(size<=0)return(false);
+
+    return CreateBuffer(buf,VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,size,size,nullptr,sharing_mode);
+}
+
+IndirectDrawBuffer *GPUDevice::CreateIndirectDrawBuffer(const uint32_t cmd_count,SharingMode sm)
+{
+    DeviceBufferData buf;
+        
+    if(!CreateIndirectCommandBuffer(&buf,cmd_count,sizeof(VkDrawIndirectCommand),sm))
+        return(nullptr);
+
+    return(new IndirectDrawBuffer(attr->device,buf,cmd_count));
+}
+
+IndirectDrawIndexedBuffer *GPUDevice::CreateIndirectDrawIndexedBuffer(const uint32_t cmd_count,SharingMode sm)
+{
+    DeviceBufferData buf;
+        
+    if(!CreateIndirectCommandBuffer(&buf,cmd_count,sizeof(VkDrawIndexedIndirectCommand),sm))
+        return(nullptr);
+
+    return(new IndirectDrawIndexedBuffer(attr->device,buf,cmd_count));
+}
+
+IndirectDispatchBuffer *GPUDevice::CreateIndirectDispatchBuffer(const uint32_t cmd_count,SharingMode sm)
+{
+    DeviceBufferData buf;
+        
+    if(!CreateIndirectCommandBuffer(&buf,cmd_count,sizeof(VkDispatchIndirectCommand),sm))
+        return(nullptr);
+
+    return(new IndirectDispatchBuffer(attr->device,buf,cmd_count));
+}
+
+VK_NAMESPACE_END