use wgpu::util::DeviceExt;
use crate::config::RasterConfig;
use crate::gaussian::GaussianModel;
#[repr(C)]
#[derive(Debug, Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
pub struct Uniforms {
pub view: [f32; 16],
pub proj: [f32; 16],
pub cam_pos: [f32; 3],
pub _pad0: f32,
pub focal: [f32; 2],
pub viewport: [f32; 2],
pub tile_grid: [u32; 2],
pub num_gaussians: u32,
pub sh_degree: u32,
pub near_plane: f32,
pub far_plane: f32,
pub _pad_bg: [f32; 2],
pub background: [f32; 3],
pub output_flags: u32,
pub transmittance_threshold: f32,
pub tile_size: u32,
pub _pad1: [u32; 2],
}
pub struct GaussianBuffers {
pub positions: wgpu::Buffer,
pub rotations: wgpu::Buffer,
pub scales: wgpu::Buffer,
pub opacities: wgpu::Buffer,
pub sh_coeffs: wgpu::Buffer,
pub count: u32,
}
pub struct IntermediateBuffers {
pub cov2d: wgpu::Buffer,
pub means2d: wgpu::Buffer,
pub depths: wgpu::Buffer,
pub radii: wgpu::Buffer,
pub tile_counts: wgpu::Buffer,
pub tile_offsets: wgpu::Buffer,
pub sort_keys: wgpu::Buffer,
pub sort_values: wgpu::Buffer,
pub tile_ranges: wgpu::Buffer,
pub colors: wgpu::Buffer,
pub conics: wgpu::Buffer,
pub max_pairs: u32,
pub block_sums: wgpu::Buffer,
pub block_sums_scanned: wgpu::Buffer,
pub normals: wgpu::Buffer,
}
pub struct OutputBuffers {
pub color: wgpu::Buffer,
pub depth: wgpu::Buffer,
pub transmittance: wgpu::Buffer,
pub n_contrib: wgpu::Buffer,
pub normals: Option<wgpu::Buffer>,
}
pub struct GradientBuffers {
pub grad_positions: wgpu::Buffer,
pub grad_rotations: wgpu::Buffer,
pub grad_scales: wgpu::Buffer,
pub grad_opacities: wgpu::Buffer,
pub grad_sh_coeffs: wgpu::Buffer,
pub grad_means2d_atomic: wgpu::Buffer,
pub grad_conics_atomic: wgpu::Buffer,
pub grad_colors_atomic: wgpu::Buffer,
pub grad_means2d: wgpu::Buffer,
pub grad_conics: wgpu::Buffer,
pub grad_colors: wgpu::Buffer,
}
pub struct UniformBuffer {
pub buffer: wgpu::Buffer,
}
impl UniformBuffer {
pub fn new(device: &wgpu::Device) -> Self {
let buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("uniforms"),
size: std::mem::size_of::<Uniforms>() as u64,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
Self { buffer }
}
pub fn update(&self, queue: &wgpu::Queue, uniforms: &Uniforms) {
queue.write_buffer(&self.buffer, 0, bytemuck::bytes_of(uniforms));
}
}
impl GaussianBuffers {
pub fn from_model(device: &wgpu::Device, model: &GaussianModel) -> Self {
let n = model.len();
let positions_data: Vec<[f32; 4]> = model
.gaussians
.iter()
.map(|g| [g.position[0], g.position[1], g.position[2], 0.0])
.collect();
let rotations_data: Vec<[f32; 4]> = model.gaussians.iter().map(|g| g.rotation).collect();
let scales_data: Vec<[f32; 4]> = model
.gaussians
.iter()
.map(|g| [g.scale[0], g.scale[1], g.scale[2], 0.0])
.collect();
let opacities_data: Vec<f32> = model.gaussians.iter().map(|g| g.opacity).collect();
let positions = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("gaussian_positions"),
contents: bytemuck::cast_slice(&positions_data),
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
});
let rotations = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("gaussian_rotations"),
contents: bytemuck::cast_slice(&rotations_data),
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
});
let scales = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("gaussian_scales"),
contents: bytemuck::cast_slice(&scales_data),
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
});
let opacities = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("gaussian_opacities"),
contents: bytemuck::cast_slice(&opacities_data),
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
});
let sh_data = if model.sh_coeffs.is_empty() {
vec![0.0f32; n.max(1) * 3]
} else {
model.sh_coeffs.clone()
};
let sh_coeffs = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("gaussian_sh"),
contents: bytemuck::cast_slice(&sh_data),
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
});
Self {
positions,
rotations,
scales,
opacities,
sh_coeffs,
count: n as u32,
}
}
}
impl IntermediateBuffers {
pub fn allocate(device: &wgpu::Device, n: u32, config: &RasterConfig) -> Self {
let avg_tiles_per_gaussian = 4u32; let max_pairs = n.saturating_mul(avg_tiles_per_gaussian).max(1024);
let num_tiles = config.num_tiles();
let storage = wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST;
let n_safe = n.max(1) as u64;
let cov2d = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("cov2d"),
size: n_safe * 4 * 4, usage: storage,
mapped_at_creation: false,
});
let means2d = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("means2d"),
size: n_safe * 2 * 4, usage: storage,
mapped_at_creation: false,
});
let depths = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("depths"),
size: n_safe * 4, usage: storage,
mapped_at_creation: false,
});
let radii = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("radii"),
size: n_safe * 4, usage: storage,
mapped_at_creation: false,
});
let tile_counts = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("tile_counts"),
size: n_safe * 4, usage: storage,
mapped_at_creation: false,
});
let tile_offsets = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("tile_offsets"),
size: n_safe * 4, usage: storage,
mapped_at_creation: false,
});
let sort_keys = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sort_keys"),
size: (max_pairs as u64) * 8, usage: storage,
mapped_at_creation: false,
});
let sort_values = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sort_values"),
size: (max_pairs as u64) * 4, usage: storage,
mapped_at_creation: false,
});
let tile_ranges = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("tile_ranges"),
size: (num_tiles.max(1) as u64) * 2 * 4, usage: storage,
mapped_at_creation: false,
});
let colors = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("colors"),
size: n_safe * 4 * 4, usage: storage,
mapped_at_creation: false,
});
let conics = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("conics"),
size: n_safe * 4 * 4, usage: storage,
mapped_at_creation: false,
});
let num_wg = n.div_ceil(512).max(1);
let block_sums = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("block_sums"),
size: (num_wg as u64) * 4,
usage: storage,
mapped_at_creation: false,
});
let block_sums_scanned = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("block_sums_scanned"),
size: (num_wg as u64) * 4,
usage: storage,
mapped_at_creation: false,
});
let normals = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("gaussian_normals"),
size: n_safe * 4 * 4, usage: storage,
mapped_at_creation: false,
});
Self {
cov2d,
means2d,
depths,
radii,
tile_counts,
tile_offsets,
sort_keys,
sort_values,
tile_ranges,
colors,
conics,
max_pairs,
block_sums,
block_sums_scanned,
normals,
}
}
}
impl OutputBuffers {
pub fn allocate(device: &wgpu::Device, config: &RasterConfig) -> Self {
let npx = config.num_pixels().max(1) as u64;
let storage = wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST;
let color = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("output_color"),
size: npx * 4 * 4, usage: storage,
mapped_at_creation: false,
});
let depth = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("output_depth"),
size: npx * 4, usage: storage,
mapped_at_creation: false,
});
let transmittance = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("output_transmittance"),
size: npx * 4, usage: storage,
mapped_at_creation: false,
});
let n_contrib = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("output_n_contrib"),
size: npx * 4, usage: storage,
mapped_at_creation: false,
});
let normals = if config.output_normals {
Some(device.create_buffer(&wgpu::BufferDescriptor {
label: Some("output_normals"),
size: npx * 4 * 4, usage: storage,
mapped_at_creation: false,
}))
} else {
None
};
Self {
color,
depth,
transmittance,
n_contrib,
normals,
}
}
#[inline]
pub fn has_normals(&self) -> bool {
self.normals.is_some()
}
}
impl GradientBuffers {
pub fn allocate(device: &wgpu::Device, n: u32, sh_coeffs_total: u32) -> Self {
let storage = wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST;
let n_safe = n.max(1) as u64;
let grad_positions = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("grad_positions"),
size: n_safe * 4 * 4, usage: storage,
mapped_at_creation: false,
});
let grad_rotations = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("grad_rotations"),
size: n_safe * 4 * 4,
usage: storage,
mapped_at_creation: false,
});
let grad_scales = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("grad_scales"),
size: n_safe * 4 * 4,
usage: storage,
mapped_at_creation: false,
});
let grad_opacities = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("grad_opacities"),
size: n_safe * 4,
usage: storage,
mapped_at_creation: false,
});
let grad_sh_coeffs = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("grad_sh_coeffs"),
size: (sh_coeffs_total.max(1) as u64) * 4,
usage: storage,
mapped_at_creation: false,
});
let grad_means2d_atomic = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("grad_means2d_atomic"),
size: n_safe * 2 * 4, usage: storage,
mapped_at_creation: false,
});
let grad_conics_atomic = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("grad_conics_atomic"),
size: n_safe * 3 * 4, usage: storage,
mapped_at_creation: false,
});
let grad_colors_atomic = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("grad_colors_atomic"),
size: n_safe * 3 * 4, usage: storage,
mapped_at_creation: false,
});
let grad_means2d = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("grad_means2d"),
size: n_safe * 2 * 4, usage: storage,
mapped_at_creation: false,
});
let grad_conics = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("grad_conics"),
size: n_safe * 3 * 4, usage: storage,
mapped_at_creation: false,
});
let grad_colors = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("grad_colors"),
size: n_safe * 3 * 4, usage: storage,
mapped_at_creation: false,
});
Self {
grad_positions,
grad_rotations,
grad_scales,
grad_opacities,
grad_sh_coeffs,
grad_means2d_atomic,
grad_conics_atomic,
grad_colors_atomic,
grad_means2d,
grad_conics,
grad_colors,
}
}
}