Gaussian Splats Rendering in Vulkan: A Comprehensive Guide

{
  "extensionsUsed": ["KHR_gaussian_splatting"],
  "meshes": [{
    "name": "GaussianSplats",
    "primitives": [{
      "attributes": {
        "POSITION": 0,
        "KHR_gaussian_splatting:ROTATION": 1,
        "KHR_gaussian_splatting:SCALE": 2,
        "KHR_gaussian_splatting:OPACITY": 3,
        "KHR_gaussian_splatting:SH_DEGREE_0_COEF_0": 4
      },
      "extensions": {
        "KHR_gaussian_splatting": {
          "kernel": "ellipse",
          "colorSpace": "sRGB",
          "antialiased": false,
          "shDegree": 0
        }
      },
      "mode": 0
    }]
  }]
}

{
  "extensionsUsed": [
    "KHR_gaussian_splatting",
    "KHR_gaussian_splatting_compression_spz"
  ],
  "meshes": [{
    "name": "GaussianSplats",
    "primitives": [{
      "mode": 0,  // POINTS
      "attributes": {
        "POSITION": 0,
        "KHR_gaussian_splatting:ROTATION": 1,
        "KHR_gaussian_splatting:SCALE": 2,
        "KHR_gaussian_splatting:OPACITY": 3,
        "KHR_gaussian_splatting:SH_DEGREE_0_COEF_0": 4
      },
      "extensions": {
        "KHR_gaussian_splatting": {
          "kernel": "ellipse",
          "colorSpace": "sRGB",
          "antialiased": false,
          "shDegree": 0
        },
        "KHR_gaussian_splatting_compression_spz": {
          "buffer": 5,  // Points to SPZ blob
          "byteOffset": 0,
          "byteLength": 25000000
        }
      }
    }]
  }],
  "buffers": [{
    "uri": "splats.spz",
    "byteLength": 25000000
  }]
}

// From render_octomap.h
struct SplatInstance
{
    float pos[3];
    float rot[4];
    float scale[3];
    float opacity;
    float color[3];
    float _pad;  // padding to 16-byte alignment
};

std::vector<SplatInstance>          splat_instances_cpu;
std::unique_ptr<vkb::core::BufferC> splat_instance_buffer;
uint32_t                            splat_count{0};

struct
{
    glm::mat4 projection;
    glm::mat4 view;
    glm::vec2 viewport;
    float     focalX;
    float     focalY;
} splat_ubo;

// In gltf_loader.h
#define KHR_GAUSSIAN_SPLATTING_EXTENSION "KHR_gaussian_splatting"

// In gltf_loader.cpp
std::unordered_map<std::string, bool> GLTFLoader::supported_extensions = {
    {KHR_LIGHTS_PUNCTUAL_EXTENSION, false},
    {KHR_GAUSSIAN_SPLATTING_EXTENSION, false}
};

bool has_gaussian_splats(const tinygltf::Model& model)
{
    // Check if the extension is used
    auto it = std::find(model.extensionsUsed.begin(),
                        model.extensionsUsed.end(),
                        "KHR_gaussian_splatting");
    if (it == model.extensionsUsed.end())
        return false;

    // Check if any mesh primitive uses the extension
    for (const auto& mesh : model.meshes)
    {
        for (const auto& primitive : mesh.primitives)
        {
            if (primitive.extensions.find("KHR_gaussian_splatting") !=
                primitive.extensions.end())
            {
                return true;
            }
        }
    }
    return false;
}

struct GaussianSplatExtension
{
    int position_accessor = -1;
    int rotation_accessor = -1;
    int scale_accessor = -1;
    int opacity_accessor = -1;
    int color_accessor = -1;
    std::vector<int> sh_accessors;

    int sh_degree = 0;
    bool antialiased = false;
    std::string color_space = "BT.709-sRGB";
    std::string kernel = "ellipse";
};

GaussianSplatExtension parse_extension(const tinygltf::Model& model, const tinygltf::Primitive& primitive)
{
    GaussianSplatExtension ext;

    // Helper to get attribute accessor index
    auto get_attrib = [&](const std::string& name) {
        auto it = primitive.attributes.find(name);
        return (it != primitive.attributes.end()) ? it->second : -1;
    };

    // Get accessor indices from attributes (KHR spec)
    ext.position_accessor = get_attrib("POSITION");
    ext.rotation_accessor = get_attrib("KHR_gaussian_splatting:ROTATION");
    ext.scale_accessor    = get_attrib("KHR_gaussian_splatting:SCALE");
    ext.opacity_accessor  = get_attrib("KHR_gaussian_splatting:OPACITY");
    ext.color_accessor    = get_attrib("KHR_gaussian_splatting:SH_DEGREE_0_COEF_0");

    // Fallback to old draft names or COLOR_0 if needed
    if (ext.color_accessor < 0) ext.color_accessor = get_attrib("COLOR_0");

    // Get properties from the extension object
    auto it = primitive.extensions.find("KHR_gaussian_splatting");
    if (it != primitive.extensions.end() && it->second.IsObject())
    {
        const auto& ext_value = it->second;
        if (ext_value.Has("kernel"))
            ext.kernel = ext_value.Get("kernel").Get<std::string>();
        if (ext_value.Has("colorSpace"))
            ext.color_space = ext_value.Get("colorSpace").Get<std::string>();
        if (ext_value.Has("shDegree"))
            ext.sh_degree = ext_value.Get("shDegree").Get<int>();
        if (ext_value.Has("antialiased"))
            ext.antialiased = ext_value.Get("antialiased").Get<bool>();
    }

    return ext;
}

// Number of float components per accessor.type ("SCALAR", "VEC3", ...).
size_t componentCount(const std::string& type)
{
    if (type == "SCALAR") return 1;
    if (type == "VEC2")   return 2;
    if (type == "VEC3")   return 3;
    if (type == "VEC4")   return 4;
    if (type == "MAT3")   return 9;
    if (type == "MAT4")   return 16;
    return 0;
}

// Returns accessor.count * componentCount(accessor.type) floats.
// Assumes a float component type; integer or normalized integer
// accessors require their own dequantization path.
std::vector<float> read_accessor_data(const tinygltf::Model& model, int accessor_idx)
{
    if (accessor_idx < 0 || accessor_idx >= model.accessors.size())
        return {};

    const auto& accessor = model.accessors[accessor_idx];
    const auto& buffer_view = model.bufferViews[accessor.bufferView];
    const auto& buffer = model.buffers[buffer_view.buffer];

    size_t num_components = componentCount(accessor.type);
    std::vector<float> data(accessor.count * num_components);

    // Calculate byte stride
    size_t byte_stride = buffer_view.byteStride;
    if (byte_stride == 0)
        byte_stride = accessor.ByteStride(buffer_view);

    // Read data
    const unsigned char* src = buffer.data.data() +
                               buffer_view.byteOffset +
                               accessor.byteOffset;

    for (size_t i = 0; i < accessor.count; i++)
    {
        float* dst = &data[i * num_components];

        // Handle different component types and normalization
        if (accessor.componentType == TINYGLTF_COMPONENT_TYPE_FLOAT)
        {
            memcpy(dst, src + i * byte_stride, num_components * sizeof(float));
        }
        else if (accessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT)
        {
            // Dequantize if normalized
            const uint16_t* quantized = reinterpret_cast<const uint16_t*>(src + i * byte_stride);
            if (accessor.normalized)
            {
                // Convert [0, 65535] to [0.0, 1.0]
                for (size_t j = 0; j < num_components; j++)
                    dst[j] = quantized[j] / 65535.0f;
            }
        }
        // Handle other component types...
    }

    return data;
}

std::unique_ptr<GaussianSplat> create_gaussian_splat_from_gltf(
    const tinygltf::Model& model,
    const tinygltf::Primitive& primitive,
    vkb::Device& device)
{
    auto splat = std::make_unique<GaussianSplat>();

    // Get extension data
    auto ext_it = primitive.extensions.find("KHR_gaussian_splatting");
    if (ext_it == primitive.extensions.end())
        return nullptr;

    GaussianSplatExtension ext = parse_extension(ext_it->second);

    // Read positions (from standard POSITION attribute)
    auto positions = read_accessor_data<glm::vec3>(
        model, primitive.attributes.at("POSITION"));
    splat->splat_count = positions.size();

    // Read rotations
    auto rotations = read_accessor_data<glm::vec4>(
        model, ext.rotation_accessor);

    // Read scales
    auto scales = read_accessor_data<glm::vec3>(
        model, ext.scale_accessor);

    // Read opacities
    auto opacities = read_accessor_data<float>(
        model, ext.opacity_accessor);

    // Read colors
    auto colors = read_accessor_data<glm::vec3>(
        model, primitive.attributes.at("COLOR_0"));

    // Create GPU buffers
    splat->position_buffer = create_device_buffer(
        device, positions.data(),
        positions.size() * sizeof(glm::vec3),
        VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);

    splat->rotation_buffer = create_device_buffer(
        device, rotations.data(),
        rotations.size() * sizeof(glm::vec4),
        VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);

    splat->scale_buffer = create_device_buffer(
        device, scales.data(),
        scales.size() * sizeof(glm::vec3),
        VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);

    splat->opacity_buffer = create_device_buffer(
        device, opacities.data(),
        opacities.size() * sizeof(float),
        VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);

    splat->color_buffer = create_device_buffer(
        device, colors.data(),
        colors.size() * sizeof(glm::vec3),
        VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);

    // Store extension properties
    splat->sh_degree = ext.sh_degree;
    splat->antialiased = ext.antialiased;
    splat->kernel = (ext.kernel == "sphere") ?
        GaussianSplat::KernelType::Sphere :
        GaussianSplat::KernelType::Ellipse;
    splat->color_space = (ext.color_space == "linear") ?
        GaussianSplat::ColorSpace::Linear :
        GaussianSplat::ColorSpace::SRGB;

    return splat;
}

// In vertex shader, dequantize positions
layout(location = 0) in vec3 inPositionQuantized;  // uint16 normalized

uniform vec3 quantization_min;
uniform vec3 quantization_range;

void main()
{
    // Dequantize: [0, 1] → [min, min + range]
    vec3 position = quantization_min + inPositionQuantized * quantization_range;

    // Continue with normal processing...
}

glm::vec3 dequantize_position(uint16_t x, uint16_t y, uint16_t z,
                               const glm::vec3& min, const glm::vec3& range)
{
    return min + glm::vec3(
        (float)x / 65535.0f * range.x,
        (float)y / 65535.0f * range.y,
        (float)z / 65535.0f * range.z
    );
}

void render_octomap::load_gaussian_splats_scene(const std::string &scene_dir)
{
    splat_instances_cpu.clear();
    splat_instance_buffer.reset();

    // Collect all *_cell_*.gltf files in the directory, then sort for
    // deterministic order (the scene is stored as tiled grid cells).
    std::vector<std::string> cell_files;
    for (auto &entry : std::filesystem::directory_iterator(full_dir))
    {
        std::string name = entry.path().filename().string();
        if (name.find("_cell_") != std::string::npos && name.ends_with(".gltf"))
            cell_files.push_back(scene_dir + "/" + name);
    }
    std::sort(cell_files.begin(), cell_files.end());

    for (auto &f : cell_files)
        load_gaussian_splats_data(f);        // appends into splat_instances_cpu

    splat_count           = static_cast<uint32_t>(splat_instances_cpu.size());
    splat_instance_buffer = std::make_unique<vkb::core::BufferC>(get_device(),
                                                                 splat_instances_cpu.size() * sizeof(SplatInstance),
                                                                 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
                                                                 VMA_MEMORY_USAGE_CPU_TO_GPU);
    auto *buf = splat_instance_buffer->map();
    memcpy(buf, splat_instances_cpu.data(), splat_instances_cpu.size() * sizeof(SplatInstance));
    splat_instance_buffer->flush();
    splat_instance_buffer->unmap();

    create_splat_pipeline(render_pass);
}

if (model.meshes.empty() || model.meshes[0].primitives.empty())
{
    LOGE("Splats gltf has no meshes/primitives: {}", filename);
    return;
}

// ... resolve POSITION / ROTATION / SCALE / OPACITY / COLOR_0 accessors ...

if (rot_accessor < 0 || scale_accessor < 0 || opacity_accessor < 0 || col_accessor < 0)
{
    LOGE("Splats gltf missing required KHR_gaussian_splatting accessors (ROTATION/SCALE/OPACITY/COLOR_0): {}", filename);
    return;
}

const size_t count = model.accessors[pos_accessor].count;
if (count == 0)
{
    LOGE("Splats gltf has 0 splats: {}", filename);
    return;
}

if (splat_instances_cpu.empty())
{
    LOGE("No splat data loaded from {}", scene_dir);
    return;
}

#version 450

// Per-splat attributes
layout(location = 0) in vec3 inPosition;    // Splat center
layout(location = 1) in vec4 inRotation;    // Quaternion
layout(location = 2) in vec3 inScale;       // Scale factors
layout(location = 3) in float inOpacity;    // Opacity [0, 1]
layout(location = 4) in vec3 inColor;       // RGB color

// Uniform buffer
layout(binding = 0) uniform UBO {
    mat4 view;
    mat4 proj;
    vec2 viewport;  // Width, height
    vec2 focal;     // fx, fy
} ubo;

// Output to fragment shader
layout(location = 0) out vec3 outColor;
layout(location = 1) out float outOpacity;
layout(location = 2) out vec2 outCoord;  // Gaussian coordinates

// Convert quaternion to rotation matrix
mat3 quaternionToMatrix(vec4 q)
{
    float x = q.x, y = q.y, z = q.z, w = q.w;

    return mat3(
        1.0 - 2.0*(y*y + z*z),  2.0*(x*y - w*z),        2.0*(x*z + w*y),
        2.0*(x*y + w*z),        1.0 - 2.0*(x*x + z*z),  2.0*(y*z - w*x),
        2.0*(x*z - w*y),        2.0*(y*z + w*x),        1.0 - 2.0*(x*x + y*y)
    );
}

// Compute Jacobian of perspective projection
mat3 computeJacobian(vec3 viewPos, vec2 focal)
{
    float x = viewPos.x;
    float y = viewPos.y;
    float z = viewPos.z;
    float z2 = z * z;

    // Jacobian maps 3D displacements to 2D screen displacements
    return mat3(
        focal.x / z,  0.0,           -focal.x * x / z2,
        0.0,          focal.y / z,   -focal.y * y / z2,
        0.0,          0.0,            0.0  // We only need 2x3, pad with zeros
    );
}

// Compute eigenvalues of 2x2 symmetric matrix (for radius calculation)
vec2 eigenvalues2x2(mat2 m)
{
    float a = m[0][0];
    float b = m[0][1];  // = m[1][0] since symmetric
    float c = m[1][1];

    float trace = a + c;
    float det = a * c - b * b;
    float discriminant = sqrt(max(0.0, trace * trace - 4.0 * det));

    float lambda1 = 0.5 * (trace + discriminant);
    float lambda2 = 0.5 * (trace - discriminant);

    return vec2(lambda1, lambda2);
}

void main()
{
    // 1. Transform splat center to view space
    vec4 viewPos = ubo.view * vec4(inPosition, 1.0);

    // Cull splats behind camera
    if (viewPos.z > 0.0) {
        gl_Position = vec4(0.0, 0.0, -1.0, 1.0);
        return;
    }

    // 2. Build 3D covariance matrix from rotation and scale
    mat3 R = quaternionToMatrix(inRotation);
    mat3 S = mat3(
        inScale.x, 0.0,       0.0,
        0.0,       inScale.y, 0.0,
        0.0,       0.0,       inScale.z
    );

    // Covariance: Σ = R S S^T R^T
    mat3 M = R * S;
    mat3 cov3D = M * transpose(M);

    // 3. Project 3D covariance to 2D
    mat3 J = computeJacobian(viewPos.xyz, ubo.focal);
    mat3 W = mat3(ubo.view);  // Extract rotation part only
    mat3 T = J * W;

    // Σ₂D = T Σ₃D T^T (only need upper 2x2 block)
    mat3 cov2Dfull = T * cov3D * transpose(T);
    mat2 cov2D = mat2(
        cov2Dfull[0][0], cov2Dfull[0][1],
        cov2Dfull[1][0], cov2Dfull[1][1]
    );

    // Add small value to diagonal for numerical stability
    cov2D[0][0] += 0.3;
    cov2D[1][1] += 0.3;

    // 4. Compute splat radius from eigenvalues
    vec2 eigenvals = eigenvalues2x2(cov2D);
    float maxEigenval = max(eigenvals.x, eigenvals.y);
    float radius = ceil(3.0 * sqrt(maxEigenval));  // 3 sigma = 99.7% coverage

    // 5. Generate billboard quad
    // gl_VertexIndex tells us which corner of the quad we're generating
    // Use instanced rendering with 4 vertices per splat
    vec2 quadOffsets[4] = vec2[](
        vec2(-1.0, -1.0),
        vec2( 1.0, -1.0),
        vec2(-1.0,  1.0),
        vec2( 1.0,  1.0)
    );

    int cornerIndex = gl_VertexIndex % 4;
    vec2 quadOffset = quadOffsets[cornerIndex];

    // Compute inverse of 2D covariance for Gaussian evaluation
    float det = cov2D[0][0] * cov2D[1][1] - cov2D[0][1] * cov2D[1][0];
    mat2 cov2DInv = mat2(
         cov2D[1][1] / det, -cov2D[0][1] / det,
        -cov2D[1][0] / det,  cov2D[0][0] / det
    );

    // Transform quad corner by covariance for proper ellipse shape
    // This makes the quad align with the Gaussian's principal axes
    vec2 offsetPixels = radius * quadOffset;

    // Convert to NDC offset
    vec2 offsetNDC = offsetPixels / (0.5 * ubo.viewport);

    // Project center to clip space
    vec4 clipPos = ubo.proj * viewPos;
    clipPos /= clipPos.w;

    // Add offset in NDC space
    clipPos.xy += offsetNDC * clipPos.w;

    gl_Position = clipPos;

    // 6. Output to fragment shader
    outColor = inColor;
    outOpacity = inOpacity;

    // Pass Gaussian coordinates for fragment evaluation
    // Transform to Gaussian space using inverse covariance
    outCoord = cov2DInv * (offsetPixels);
}

#version 450

layout(location = 0) in vec3 inColor;
layout(location = 1) in float inOpacity;
layout(location = 2) in vec2 inCoord;  // Gaussian coordinates

layout(location = 0) out vec4 outColor;

void main()
{
    // Evaluate 2D Gaussian function: exp(-0.5 * x^T Σ^(-1) x)
    // inCoord already has Σ^(-1) applied, so just compute dot product
    float power = -0.5 * dot(inCoord, inCoord);

    // Clamp for numerical stability
    power = max(power, -100.0);

    // Evaluate Gaussian
    float gaussian = exp(power);

    // Apply opacity
    float alpha = gaussian * inOpacity;

    // Early discard for performance (skip nearly transparent fragments)
    if (alpha < 0.004)  // ~1/255
        discard;

    // Output with premultiplied alpha
    // This is important for correct blending
    outColor = vec4(inColor * alpha, alpha);
}

result = source.rgb + destination.rgb * (1 - source.alpha)

result = source.rgb * source.alpha + destination.rgb * (1 - source.alpha)

void create_splat_pipeline()
{
    // 1. Vertex input state - one binding per attribute buffer
    std::vector<VkVertexInputBindingDescription> bindings = {
        {0, sizeof(glm::vec3), VK_VERTEX_INPUT_RATE_INSTANCE},  // Position
        {1, sizeof(glm::vec4), VK_VERTEX_INPUT_RATE_INSTANCE},  // Rotation
        {2, sizeof(glm::vec3), VK_VERTEX_INPUT_RATE_INSTANCE},  // Scale
        {3, sizeof(float),     VK_VERTEX_INPUT_RATE_INSTANCE},  // Opacity
        {4, sizeof(glm::vec3), VK_VERTEX_INPUT_RATE_INSTANCE},  // Color
    };

    std::vector<VkVertexInputAttributeDescription> attributes = {
        {0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0},     // Position
        {1, 1, VK_FORMAT_R32G32B32A32_SFLOAT, 0},  // Rotation
        {2, 2, VK_FORMAT_R32G32B32_SFLOAT, 0},     // Scale
        {3, 3, VK_FORMAT_R32_SFLOAT, 0},           // Opacity
        {4, 4, VK_FORMAT_R32G32B32_SFLOAT, 0},     // Color
    };

    VkPipelineVertexInputStateCreateInfo vertexInputState = {};
    vertexInputState.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
    vertexInputState.vertexBindingDescriptionCount = bindings.size();
    vertexInputState.pVertexBindingDescriptions = bindings.data();
    vertexInputState.vertexAttributeDescriptionCount = attributes.size();
    vertexInputState.pVertexAttributeDescriptions = attributes.data();

    // 2. Input assembly - triangle strip for quad generation
    VkPipelineInputAssemblyStateCreateInfo inputAssemblyState = {};
    inputAssemblyState.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
    inputAssemblyState.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
    inputAssemblyState.primitiveRestartEnable = VK_FALSE;

    // 3. Rasterization state
    VkPipelineRasterizationStateCreateInfo rasterizationState = {};
    rasterizationState.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
    rasterizationState.polygonMode = VK_POLYGON_MODE_FILL;
    rasterizationState.cullMode = VK_CULL_MODE_NONE;  // Don't cull, quads face camera
    rasterizationState.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
    rasterizationState.lineWidth = 1.0f;

    // 4. Depth/stencil state - READ depth but DON'T WRITE (transparency!)
    VkPipelineDepthStencilStateCreateInfo depthStencilState = {};
    depthStencilState.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
    depthStencilState.depthTestEnable = VK_TRUE;
    depthStencilState.depthWriteEnable = VK_FALSE;  // Critical for transparency
    depthStencilState.depthCompareOp = VK_COMPARE_OP_LESS;

    // 5. Blend state - Premultiplied alpha blending
    VkPipelineColorBlendAttachmentState blendAttachment = {};
    blendAttachment.blendEnable = VK_TRUE;
    blendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_ONE;
    blendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
    blendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
    blendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
    blendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
    blendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
    blendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT |
                                     VK_COLOR_COMPONENT_G_BIT |
                                     VK_COLOR_COMPONENT_B_BIT |
                                     VK_COLOR_COMPONENT_A_BIT;

    VkPipelineColorBlendStateCreateInfo colorBlendState = {};
    colorBlendState.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
    colorBlendState.attachmentCount = 1;
    colorBlendState.pAttachments = &blendAttachment;

    // Create pipeline...
}

void draw_gaussian_splats(VkCommandBuffer cmd, const GaussianSplat& splat)
{
    // Bind pipeline
    vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, splat_pipeline);

    // Bind uniform buffer (view, proj matrices, etc.)
    vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
                            pipeline_layout, 0, 1, &descriptor_set, 0, nullptr);

    // Bind vertex buffers (one per attribute)
    VkBuffer buffers[] = {
        splat.position_buffer->get_handle(),
        splat.rotation_buffer->get_handle(),
        splat.scale_buffer->get_handle(),
        splat.opacity_buffer->get_handle(),
        splat.color_buffer->get_handle(),
    };
    VkDeviceSize offsets[] = {0, 0, 0, 0, 0};
    vkCmdBindVertexBuffers(cmd, 0, 5, buffers, offsets);

    // Draw: 4 vertices per splat, instanced
    vkCmdDraw(cmd, 4, splat.splat_count, 0, 0);
}

std::sort(splats.begin(), splats.end(), [&](const Splat& a, const Splat& b) {
    float depthA = glm::dot(viewDir, a.position - cameraPos);
    float depthB = glm::dot(viewDir, b.position - cameraPos);
    return depthA > depthB;  // Back to front
});

struct SplatBuffers {
    std::vector<glm::vec3> positions;
    std::vector<glm::vec4> rotations;
    std::vector<glm::vec3> scales;
    std::vector<float> opacities;
    std::vector<glm::vec3> colors;
};

vec3 evaluateSH(vec3 dir, mat3 sh_coeffs) {
    // Evaluate spherical harmonics basis functions
    // and combine with coefficients
    return vec3(x,y,z);
}