Vulkan与OpenGL渲染立方体：从OpenGL迁移到Vulkan遇问题求助

Hey there! Let's break down how to adapt your minimal OpenGL cube renderer to Vulkan step by step, since you mentioned hitting snags after following Intel's 2D texture tutorial.

1. Strip Out Unneeded 2D Texture Code #

Your original OpenGL app doesn't use textures, so you can toss out most texture-related logic from the Intel tutorial—things like image views, samplers, texture buffer allocations, and texture descriptor sets aren't required here. Keep only the core Vulkan boilerplate: instance, physical device, logical device, queue family selection, swapchain, render pass, framebuffers, command pools, and command buffers.

2. Set Up the Vertex Buffer (No Index Buffer Required) #

Just like in OpenGL, you can use a single vertex buffer holding all cube vertices (either 36 vertices for full triangles, or 24 for triangle strips—match your OpenGL setup). Here's the core workflow:

• Create a staging buffer to copy vertex data from host memory to device-local memory (Vulkan requires explicit memory management, unlike OpenGL's implicit handling).
• Use vkCmdCopyBuffer to transfer data from the staging buffer to your final vertex buffer.
• Bind the vertex buffer in your command buffer with vkCmdBindVertexBuffers, and make sure your vertex input state matches your data layout (e.g., a single VK_FORMAT_R32G32B32_SFLOAT attribute for position).

3. Configure the MVP Uniform Buffer #

Vulkan's uniform buffers have stricter requirements than OpenGL's uniform blocks—here's what you need to do:

• Create a uniform buffer (plus a staging buffer if you're updating data from the host) to hold your MVP matrix. Critical: Respect the device's alignment rules (check VkPhysicalDeviceProperties::limits.minUniformBufferOffsetAlignment to avoid crashes or garbage values).
• Set up a descriptor set layout with one uniform buffer binding, then create a descriptor pool and allocate a descriptor set for it.
• Update the descriptor set to point to your uniform buffer's memory range.
• Bind the descriptor set in your command buffer before drawing with vkCmdBindDescriptorSets.

4. Port Shaders to SPIR-V #

Rewrite your OpenGL shaders for Vulkan GLSL, then compile them to SPIR-V (use glslc or a similar tool):

• Vertex shader example (matches your OpenGL logic):

#version 450
layout(binding = 0) uniform MVP {
    mat4 mvp;
};
layout(location = 0) in vec3 aPos;
void main() {
    gl_Position = mvp * vec4(aPos, 1.0);
}

• Fragment shader (simple red output):

#version 450
layout(location = 0) out vec4 FragColor;
void main() {
    FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}

Compile with commands like glslc vertex.vert -o vert.spv and glslc fragment.frag -o frag.spv, then load the SPIR-V binaries into Vulkan shader modules.

5. Configure Render Pass & Graphics Pipeline #

Since you're rendering a solid red cube, keep this setup minimal:

• The render pass only needs a color attachment (skip depth/stencil if your OpenGL app didn't use it, to keep parity).
• Pipeline state details:
  • Vertex input state matching your position attribute layout.
  • Input assembly set to VK_PRIMITIVE_TOPOLOGY_TRIANGLES (for 36 vertices) or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP (for 24 vertices).
  • Viewport and scissor matching your swapchain image size.
  • No blending (you're overwriting the color buffer with red, so blending isn't needed).

6. Final Draw Call Setup #

In your command buffer, after binding the vertex buffer, descriptor set, and pipeline, issue the draw call:

• For 36 triangle vertices: vkCmdDraw(commandBuffer, 36, 1, 0, 0);
• For 24 triangle strip vertices: 6 separate draw calls (one per face) like vkCmdDraw(commandBuffer, 4, 1, faceStartIndex, 0);

Common Pitfalls to Avoid #

• Memory Alignment: Misaligned uniform buffers will cause incorrect MVP transformations or crashes.
• Swapchain Format Mismatch: Ensure your render pass color attachment format matches the swapchain's image format (pull this from VkSwapchainCreateInfoKHR::imageFormat).
• Queue Family Compatibility: Pick a queue family that supports both graphics and presentation (simpler for your minimal app than using separate queues).
• Shader Binding Consistency: The binding index in your GLSL shader must exactly match the one defined in your Vulkan descriptor set layout.

If you run into a specific issue—like a black screen, validation layer errors, or crashes—share relevant code snippets and validation logs, and we can dig deeper!

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