求Windows平台下Vulkan API实现平移旋转缩放变换的学习资源

Hey Kartheek, I totally get where you're coming from—Vulkan's low-level, explicit design means higher-level math like transformations isn't built into the API itself, so it's easy to feel stuck hunting for clear, targeted resources. Let's break this down step by step for your Windows Vulkan project:

First, a key point: Vulkan only handles sending data to the GPU and executing draw commands. All transformation logic (translation, rotation, scaling) happens either on the CPU (building matrices) or in your shader code (applying them to vertices). The good news is the math here is standard 3D graphics math—you just need to adapt it to Vulkan's requirements (like column-major matrix order).

Below are practical, Windows-friendly implementations using either the GLM math library (highly recommended to avoid reinventing the wheel) or manual matrix code if you prefer to understand every detail.

Translation Matrices #

Translation shifts an object along the X, Y, or Z axis. Here's how to build the matrix:

// Using GLM (easy, compatible with Windows Vulkan)
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>

glm::mat4 createTranslationMatrix(float x, float y, float z) {
    return glm::translate(glm::mat4(1.0f), glm::vec3(x, y, z));
}

// Manual implementation (if you want to avoid GLM)
glm::mat4 createTranslationMatrixManual(float x, float y, float z) {
    // Vulkan uses column-major matrices, so the translation values go in the 4th column
    return glm::mat4(
        1.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 1.0f, 0.0f,
        x,    y,    z,    1.0f
    );
}

On Windows, you'll pass this matrix to the GPU via a uniform buffer object (UBO)—make sure to follow Vulkan's memory alignment rules (GLM handles this automatically for you).

Rotation Matrices #

Rotation rotates an object around an axis. Vulkan uses radians, so convert degrees first if needed:

// GLM implementation (绕Y轴旋转示例)
float rotationAngleDeg = 45.0f;
float rotationAngleRad = glm::radians(rotationAngleDeg); // Convert to radians
glm::mat4 createRotationYMatrix(float angleRad) {
    return glm::rotate(glm::mat4(1.0f), angleRad, glm::vec3(0.0f, 1.0f, 0.0f));
}

// Manual绕Y轴旋转
glm::mat4 createRotationYMatrixManual(float angleRad) {
    float cosA = cos(angleRad);
    float sinA = sin(angleRad);
    return glm::mat4(
        cosA,  0.0f, sinA, 0.0f,
        0.0f, 1.0f, 0.0f, 0.0f,
        -sinA, 0.0f, cosA, 0.0f,
        0.0f, 0.0f, 0.0f, 1.0f
    );
}

For rotations around X or Z axes, just adjust the axis vector and the matrix values accordingly—GLM has glm::rotate for any axis, so that's the easiest route on Windows.

Scaling Matrices #

Scaling resizes an object along each axis:

// GLM implementation
glm::mat4 createScalingMatrix(float sx, float sy, float sz) {
    return glm::scale(glm::mat4(1.0f), glm::vec3(sx, sy, sz));
}

// Manual implementation
glm::mat4 createScalingMatrixManual(float sx, float sy, float sz) {
    return glm::mat4(
        sx,    0.0f,  0.0f,  0.0f,
        0.0f,  sy,    0.0f,  0.0f,
        0.0f,  0.0f,  sz,    0.0f,
        0.0f,  0.0f,  0.0f,  1.0f
    );
}

Order matters here! In Vulkan (since it uses column-major matrices), you multiply matrices in reverse order of the transformations you want to apply. For example, to scale → rotate → translate:

glm::mat4 modelMatrix = translateMatrix * rotateMatrix * scaleMatrix;
// The actual transformation flow is: scale first, then rotate, then translate

Once your matrix is in a UBO, use it in your vertex shader (compiled to SPIR-V for Windows Vulkan):

#version 450

// Bind the UBO to descriptor set 0, binding 0
layout(binding = 0) uniform ModelTransform {
    mat4 model;
} ubo;

// Input vertex position
layout(location = 0) in vec3 inPosition;

void main() {
    // Apply the transformation matrix to the vertex position
    gl_Position = ubo.model * vec4(inPosition, 1.0f);
}

On Windows, you can compile this shader to SPIR-V using the glslangValidator tool (included with the Vulkan SDK).

• GLM Integration: GLM is perfect for Windows Vulkan projects—it's header-only, no DLLs needed, and its matrix layout matches Vulkan's requirements. Just drop the headers into your project and include them.
• Memory Alignment: Windows Vulkan enforces strict UBO alignment rules. GLM types like glm::mat4 are already aligned to 16 bytes (required for vec4/mat4), so you won't hit alignment issues.
• Debugging: Use RenderDoc (a Windows-friendly tool) to inspect your UBO data and verify your transformation matrices are being passed correctly to the GPU.

内容的提问来源于stack exchange，提问作者Kartheek.D