在GPU端（WGSL）读取Buffer时出现异常行为

我用Bevy实现了一个八叉树，通过bincode序列化后写入WGPU Storage Buffer，但GPU端读取数据时出现异常：最终节点的voxel id是u32::MAX（预期为3），颜色是255,0,0（预期为0,255,0），怀疑是数据偏移导致，但不知道原因和解决办法。

Rust端相关代码 #

八叉树结构体定义 #

#[derive(Serialize)]
pub struct Octree {
    pub root: [u32; 3],
    pub width: u32,
    pub leaves: Vec<Leaf>,
}

#[derive(Serialize)]
pub struct Leaf {
    voxel: OctreeVoxel,
    children: [u32; 8],
}

#[derive(Serialize)]
pub struct OctreeVoxel {
    pub id: u32,
    pub color: [u32; 3],
}

Buffer创建与数据写入 #

// 创建Buffer
render_device.create_buffer(&wgpu::BufferDescriptor {
    label: None,
    size: 9000000,
    usage: wgpu::BufferUsages::STORAGE
        | wgpu::BufferUsages::COPY_SRC
        | wgpu::BufferUsages::COPY_DST,
    mapped_at_creation: false,
})

// 序列化并写入数据
let data = bincode::serialize(&octree).unwrap();
render_queue.write_buffer(&buffer, 0, data);

WGPU端WGSL读取代码 #

let vox_photon = vec3<u32>(128 + 5, 128 + 5, 128 + 5);

var root = octree.root;
var width = octree.width;
var node = octree.leaves[0];
var next_index = 0u;
var exit = 0u;
while next_index != U32MAX && exit < 100 {
    let i = get_leaf(root, vox_photon);

    node = octree.leaves[next_index];
    next_index = node.children[i];

    root = get_new_root(i, root, width);
    width = width / 2u;
    exit += 1u;
}
if node.voxel.id != 0u {
    let color = node.voxel.color;
    return vec4<f32>(f32(color[0]), f32(color[1]), f32(color[2]), 255.0);
}

• 内存对齐与布局不匹配
  WGPU的Storage Buffer遵循SPIR-V的内存布局规则，而bincode默认序列化的Rust结构体布局可能和WGSL中的定义不一致。

  • 解决：给Rust结构体添加#[repr(C)]属性，强制使用C风格内存布局，确保和WGSL结构体对齐一致：

    #[derive(Serialize)]
    #[repr(C)]
    pub struct Octree {
        pub root: [u32; 3],
        pub width: u32,
        pub leaves: Vec<Leaf>,
    }
    
    #[derive(Serialize)]
    #[repr(C)]
    pub struct Leaf {
        voxel: OctreeVoxel,
        children: [u32; 8],
    }
    
    #[derive(Serialize)]
    #[repr(C)]
    pub struct OctreeVoxel {
        pub id: u32,
        pub color: [u32; 3],
    }
    

  • 额外注意：Rust中Vec<Leaf>序列化时，bincode会先写入数组长度（usize类型），再写入元素。WGSL中的Octree结构体必须匹配这个结构，比如添加长度字段：

    struct OctreeVoxel {
        id: u32,
        color: vec3<u32>,
    };
    
    struct Leaf {
        voxel: OctreeVoxel,
        children: array<u32, 8>,
    };
    
    struct Octree {
        root: vec3<u32>,
        width: u32,
        leaves_length: u32, // 对应Rust Vec的长度（64位系统需注意usize转u32的范围）
        leaves: array<Leaf, 100000>, // 按实际需求调整数组大小
    };
    

    若WGSL中缺少leaves_length字段，读取leaves时会直接跳过长度数据，导致整体读取偏移，出现错误数据。

• bincode序列化配置问题
  显式指定bincode的编码配置，避免字节序或编码方式不匹配：

  let config = bincode::config::standard()
      .with_endian(bincode::Endian::Little)
      .with_fixint_encoding();
  let data = bincode::serialize_with(&octree, config).unwrap();
  

• Buffer大小与数据长度不匹配
  创建Buffer时不要硬编码大小，先计算序列化后的数据长度，确保Buffer能容纳完整数据：

  let data = bincode::serialize(&octree).unwrap();
  let buffer = render_device.create_buffer(&wgpu::BufferDescriptor {
      label: None,
      size: data.len() as u64,
      usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC | wgpu::BufferUsages::COPY_DST,
      mapped_at_creation: false,
  });
  render_queue.write_buffer(&buffer, 0, data);
  

• WGSL数组越界问题
  循环中需先判断next_index是否小于leaves_length，再访问octree.leaves[next_index]，避免越界读取脏数据：

  while next_index != U32MAX && exit < 100 && next_index < octree.leaves_length {
      // 原有逻辑
  }
  

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