如何创建并使用结构体缓冲区？Vulkan中DirectX Structured Buffer等效项及用法

Hey there! Let's tackle your questions one by one—they're super common when working with structured data on the GPU or switching between graphics APIs.

Structured buffers are just contiguous blocks of memory holding instances of a custom struct, accessible by both CPU and GPU. I'll walk through the process using Vulkan (since your second question ties into it):

• First: Match CPU and GPU struct layouts exactly
  This is a make-or-break step—if your CPU-side struct doesn't align with what the shader expects, you'll get garbage data. GPUs have strict alignment rules; for example, a GLSL vec3 is often padded to 16 bytes. Here's how to set it up:

  // CPU-side struct (use compiler attributes if needed to enforce alignment)
  struct MyStruct {
      glm::vec3 position;
      glm::vec4 color;
      float scale;
  };
  
  // GLSL shader struct (must mirror the CPU version)
  struct MyStruct {
      vec3 position;
      vec4 color;
      float scale;
  };
  

  If your compiler's default alignment isn't cutting it, use directives like #pragma pack(push, 16) or platform-specific attributes to match GPU requirements.

• Second: Create the buffer and allocate memory
  In Vulkan, you'll create a VkBuffer with the right usage flags, then bind it to compatible memory. For a CPU-write, GPU-read structured buffer, use VK_BUFFER_USAGE_STORAGE_BUFFER_BIT and memory that's host-visible and coherent:

  // Buffer creation info
  VkBufferCreateInfo bufferInfo{};
  bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
  bufferInfo.size = sizeof(MyStruct) * 100; // Let's say we need 100 struct instances
  bufferInfo.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
  bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
  
  VkBuffer structuredBuffer;
  vkCreateBuffer(device, &bufferInfo, nullptr, &structuredBuffer);
  
  // Allocate and bind memory
  VkMemoryRequirements memRequirements;
  vkGetBufferMemoryRequirements(device, structuredBuffer, &memRequirements);
  
  VkMemoryAllocateInfo allocInfo{};
  allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
  allocInfo.allocationSize = memRequirements.size;
  // findMemoryType is a helper function you'll write to pick the right memory type
  allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, 
      VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
  
  VkDeviceMemory bufferMemory;
  vkAllocateMemory(device, &allocInfo, nullptr, &bufferMemory);
  vkBindBufferMemory(device, structuredBuffer, bufferMemory, 0);
  

• Third: Populate the buffer with data
  Since we used host-visible memory, we can map it directly to write our struct array:

  void* mappedData;
  vkMapMemory(device, bufferMemory, 0, bufferInfo.size, 0, &mappedData);
  // myStructArray is your CPU-side array of MyStruct instances
  memcpy(mappedData, myStructArray, bufferInfo.size);
  vkUnmapMemory(device, bufferMemory);
  

  No need to flush if you used VK_MEMORY_PROPERTY_HOST_COHERENT_BIT—the driver handles syncing CPU and GPU views automatically.

• Fourth: Access it in shaders
  We'll cover this in detail with the second question, but the gist is binding the buffer to a descriptor set and using a GLSL buffer block to read the data.

DirectX's Structured Buffer maps directly to Vulkan Storage Buffers—these are buffers created with VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, designed to hold structured data like struct arrays, and support GPU read/write (or CPU-write/GPU-read workflows).

Creating a Vulkan Storage Buffer (equivalent to Structured Buffer) #

Most of this overlaps with the first question, but here are the key specifics:

• Mandatory usage flag: Include VK_BUFFER_USAGE_STORAGE_BUFFER_BIT in your VkBufferCreateInfo—this marks it as a storage buffer, matching Structured Buffer functionality.
• Descriptor setup: You need to bind the buffer to a descriptor of type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, so the shader can access it. Here's how to set up the descriptor set layout:

  VkDescriptorSetLayoutBinding storageBinding{};
  storageBinding.binding = 0;
  storageBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
  storageBinding.descriptorCount = 1;
  // Allow vertex and fragment shaders to access it (adjust based on your needs)
  storageBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
  storageBinding.pImmutableSamplers = nullptr;
  
  VkDescriptorSetLayoutCreateInfo layoutInfo{};
  layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
  layoutInfo.bindingCount = 1;
  layoutInfo.pBindings = &storageBinding;
  
  VkDescriptorSetLayout descriptorSetLayout;
  vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &descriptorSetLayout);
  

  Then update the descriptor set to link it to your buffer:

  VkDescriptorBufferInfo bufferInfo{};
  bufferInfo.buffer = structuredBuffer;
  bufferInfo.offset = 0;
  bufferInfo.range = sizeof(MyStruct) * 100;
  
  VkWriteDescriptorSet descriptorWrite{};
  descriptorWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
  descriptorWrite.dstSet = yourDescriptorSet;
  descriptorWrite.dstBinding = 0;
  descriptorWrite.dstArrayElement = 0;
  descriptorWrite.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
  descriptorWrite.descriptorCount = 1;
  descriptorWrite.pBufferInfo = &bufferInfo;
  
  vkUpdateDescriptorSets(device, 1, &descriptorWrite, 0, nullptr);
  

Using the Storage Buffer in GLSL #

In your shader, define a buffer block (matching your struct) and link it to the descriptor binding number:

#version 450

// Mirror the CPU-side struct exactly
struct MyStruct {
    vec3 position;
    vec4 color;
    float scale;
};

// Define the storage buffer—binding must match your descriptor set's binding number
buffer MyStructBuffer {
    MyStruct data[]; // Array of struct instances
} myBuffer;

void main() {
    // Access the 5th struct instance's color
    vec4 objectColor = myBuffer.data[4].color;
    // Or use vertex index to fetch per-vertex struct data
    vec3 vertexPos = myBuffer.data[gl_VertexIndex].position;
    // ... rest of your shader logic
}

If you only need read access (like a read-only Structured Buffer in DirectX), add the readonly modifier: readonly buffer MyStructBuffer { ... }—this helps the shader compiler optimize performance.

内容的提问来源于stack exchange，提问作者nikitablack