如何在计算着色器中访问非对齐偏移的BGR存储缓冲区？

HLSL实现方案 #

HLSL的ByteAddressBuffer提供了支持单字节读取的重载函数Load(uint address, uint byteOffset)，可以直接读取4字节对齐地址中的指定偏移字节，完美解决非对齐问题。具体实现如下：

1. 计算当前像素在输入缓冲区中的起始字节偏移：每个像素占3字节，偏移量为texCoord.x * 3 + texCoord.y * 纹理宽度 * 3。
2. 分别读取B、G、R三个字节：对每个字节，计算其所在的4字节对齐基地址（字节偏移 & ~3），以及在该基地址内的字节偏移（字节偏移 % 4），通过Load的重载函数获取单字节值。
3. 将字节值转换为0-1范围的float，组装成RGBA格式（A通道设为1.0），写入输出纹理。

完整代码示例：

ByteAddressBuffer inputBuffer : register(t0); // BGR格式，每像素3字节
RWTexture2D<float4> outputTexture : register(u1); // RGBA非归一化纹理

static const uint TEXTURE_WIDTH = 1024; // 替换为实际纹理宽度

[numthreads(16, 16, 1)]
void main(uint3 dispatchThreadID : SV_DispatchThreadID)
{
    uint2 texCoord = dispatchThreadID.xy;
    // 跳过超出纹理范围的线程（如果调度线程数大于纹理尺寸）
    if (texCoord.x >= TEXTURE_WIDTH || texCoord.y >= outputTexture.GetDimensions().y)
        return;

    // 计算当前像素的起始字节偏移
    uint pixel_byte_offset = texCoord.x * 3 + texCoord.y * TEXTURE_WIDTH * 3;

    // 读取B字节
    uint b_base_addr = pixel_byte_offset & ~3; // 4字节对齐基地址
    uint b_offset = pixel_byte_offset % 4;
    byte b = inputBuffer.Load(b_base_addr, b_offset);

    // 读取G字节
    uint g_byte_offset = pixel_byte_offset + 1;
    uint g_base_addr = g_byte_offset & ~3;
    uint g_offset = g_byte_offset % 4;
    byte g = inputBuffer.Load(g_base_addr, g_offset);

    // 读取R字节
    uint r_byte_offset = pixel_byte_offset + 2;
    uint r_base_addr = r_byte_offset & ~3;
    uint r_offset = r_byte_offset % 4;
    byte r = inputBuffer.Load(r_base_addr, r_offset);

    // 转换为0-1的float，组装RGBA
    float4 rgba = float4(
        float(r) / 255.0f,
        float(g) / 255.0f,
        float(b) / 255.0f,
        1.0f
    );
    outputTexture[texCoord] = rgba;
}

GLSL实现方案 #

GLSL中可以通过Shader Storage Buffer Object（SSBO）处理非对齐访问，借助位操作从加载的4字节uint中提取目标字节：

1. 声明SSBO存储输入的BGR像素数据。
2. 计算当前像素的起始字节偏移，再转换为SSBO中uint数组的索引和字节偏移。
3. 通过位操作提取每个字节，转换为float后组装RGBA写入输出纹理。

完整代码示例：

#version 450 core

layout(local_size_x = 16, local_size_y = 16) in;

// 输入BGR像素缓冲区（std430布局确保内存对齐规则）
layout(std430, binding = 0) buffer InputBuffer {
    uint data[];
};

// 输出RGBA纹理
layout(rgba8, binding = 1) uniform image2D outputTexture;

const uint TEXTURE_WIDTH = 1024; // 替换为实际纹理宽度

void main() {
    ivec2 texCoord = ivec2(gl_GlobalInvocationID.xy);
    ivec2 textureSize = imageSize(outputTexture);
    // 跳过超出纹理范围的线程
    if (texCoord.x >= textureSize.x || texCoord.y >= textureSize.y)
        return;

    // 计算当前像素的起始字节偏移
    uint pixel_byte_offset = uint(texCoord.x) * 3 + uint(texCoord.y) * uint(TEXTURE_WIDTH) * 3;

    // 读取B字节
    uint b_uint_idx = pixel_byte_offset / 4;
    uint b_bit_shift = (pixel_byte_offset % 4) * 8;
    uint b_value = bitfieldExtract(data[b_uint_idx], int(b_bit_shift), 8);

    // 读取G字节
    uint g_byte_offset = pixel_byte_offset + 1;
    uint g_uint_idx = g_byte_offset / 4;
    uint g_bit_shift = (g_byte_offset % 4) * 8;
    uint g_value = bitfieldExtract(data[g_uint_idx], int(g_bit_shift), 8);

    // 读取R字节
    uint r_byte_offset = pixel_byte_offset + 2;
    uint r_uint_idx = r_byte_offset / 4;
    uint r_bit_shift = (r_byte_offset % 4) * 8;
    uint r_value = bitfieldExtract(data[r_uint_idx], int(r_bit_shift), 8);

    // 转换为0-1的float，组装RGBA
    vec4 rgba = vec4(
        float(r_value) / 255.0f,
        float(g_value) / 255.0f,
        float(b_value) / 255.0f,
        1.0f
    );
    imageStore(outputTexture, texCoord, rgba);
}

额外优化提示 #

• 如果纹理尺寸固定，可以提前计算每行的字节数（TEXTURE_WIDTH * 3），避免重复计算。
• 对于大规模纹理，可考虑按线程组批量读取数据，减少内存访问次数，提升性能。

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