use wgpu::util::DeviceExt;
use crate::config::RasterConfig;
use crate::gaussian::GaussianModel;
use crate::RenderError;
pub const PREFIX_SUM_BLOCK: u32 = 512;
pub const MAX_SCAN_GAUSSIANS: u32 = PREFIX_SUM_BLOCK * PREFIX_SUM_BLOCK * PREFIX_SUM_BLOCK;
pub const DEFAULT_PAIRS_PER_GAUSSIAN: u32 = 4;
const MIN_SORT_PAIRS: u32 = 1024;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ScanPlan {
pub num_elements: u32,
pub level0_workgroups: u32,
pub level1_workgroups: u32,
pub level2_workgroups: u32,
pub levels: u32,
}
impl ScanPlan {
#[must_use]
pub fn new(num_elements: u32) -> Self {
let level0_workgroups = num_elements.div_ceil(PREFIX_SUM_BLOCK).max(1);
let level1_workgroups = level0_workgroups.div_ceil(PREFIX_SUM_BLOCK).max(1);
let level2_workgroups = level1_workgroups.div_ceil(PREFIX_SUM_BLOCK).max(1);
let levels = if level0_workgroups <= 1 {
1
} else if level1_workgroups <= 1 {
2
} else {
3
};
Self {
num_elements,
level0_workgroups,
level1_workgroups,
level2_workgroups,
levels,
}
}
#[inline]
#[must_use]
pub fn is_supported(&self) -> bool {
self.level2_workgroups <= 1
}
}
#[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 block_sums_l2: wgpu::Buffer,
pub block_sums_l2_scanned: wgpu::Buffer,
pub scan_plan: ScanPlan,
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));
}
}
struct PackedAttributes {
positions: Vec<[f32; 4]>,
rotations: Vec<[f32; 4]>,
scales: Vec<[f32; 4]>,
opacities: Vec<f32>,
sh_coeffs: Vec<f32>,
}
impl PackedAttributes {
fn of(model: &GaussianModel) -> Self {
let n = model.len();
Self {
positions: model
.gaussians
.iter()
.map(|g| [g.position[0], g.position[1], g.position[2], 0.0])
.collect(),
rotations: model.gaussians.iter().map(|g| g.rotation).collect(),
scales: model
.gaussians
.iter()
.map(|g| [g.scale[0], g.scale[1], g.scale[2], 0.0])
.collect(),
opacities: model.gaussians.iter().map(|g| g.opacity).collect(),
sh_coeffs: if model.sh_coeffs.is_empty() {
vec![0.0f32; n.max(1) * 3]
} else {
model.sh_coeffs.clone()
},
}
}
}
impl GaussianBuffers {
pub fn from_model(device: &wgpu::Device, model: &GaussianModel) -> Self {
let n = model.len();
let PackedAttributes {
positions: positions_data,
rotations: rotations_data,
scales: scales_data,
opacities: opacities_data,
sh_coeffs: sh_data,
} = PackedAttributes::of(model);
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_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,
}
}
pub fn write_model(
&self,
queue: &wgpu::Queue,
model: &GaussianModel,
) -> Result<(), RenderError> {
if model.len() != self.count as usize {
return Err(RenderError::MismatchedBufferSizes {
expected: self.count as usize,
actual: model.len(),
});
}
let packed = PackedAttributes::of(model);
let sh_bytes = std::mem::size_of_val(packed.sh_coeffs.as_slice()) as u64;
if sh_bytes > self.sh_coeffs.size() {
return Err(RenderError::BufferOverflow {
buffer_name: "gaussian_sh".to_string(),
max_size: self.sh_coeffs.size(),
requested: sh_bytes,
});
}
if !packed.positions.is_empty() {
queue.write_buffer(&self.positions, 0, bytemuck::cast_slice(&packed.positions));
queue.write_buffer(&self.rotations, 0, bytemuck::cast_slice(&packed.rotations));
queue.write_buffer(&self.scales, 0, bytemuck::cast_slice(&packed.scales));
queue.write_buffer(&self.opacities, 0, bytemuck::cast_slice(&packed.opacities));
}
if !packed.sh_coeffs.is_empty() {
queue.write_buffer(&self.sh_coeffs, 0, bytemuck::cast_slice(&packed.sh_coeffs));
}
Ok(())
}
}
impl IntermediateBuffers {
#[must_use]
pub fn estimate_max_pairs(n: u32, pairs_per_gaussian: u32, num_tiles: u32) -> u32 {
let estimate = u64::from(n).saturating_mul(u64::from(pairs_per_gaussian.max(1)));
let upper_bound = u64::from(n).saturating_mul(u64::from(num_tiles.max(1)));
let clamped = estimate.min(upper_bound).min(u64::from(u32::MAX));
(clamped as u32).max(MIN_SORT_PAIRS)
}
pub fn validate_gaussian_count(n: u32) -> Result<(), RenderError> {
if !ScanPlan::new(n).is_supported() {
return Err(RenderError::TooManyGaussians {
count: n,
max: MAX_SCAN_GAUSSIANS,
});
}
Ok(())
}
pub fn try_allocate(
device: &wgpu::Device,
n: u32,
config: &RasterConfig,
) -> Result<Self, RenderError> {
Self::validate_gaussian_count(n)?;
Ok(Self::allocate_with_pairs_per_gaussian(
device,
n,
config,
DEFAULT_PAIRS_PER_GAUSSIAN,
))
}
pub fn allocate(device: &wgpu::Device, n: u32, config: &RasterConfig) -> Self {
if let Err(e) = Self::validate_gaussian_count(n) {
tracing::error!(
num_gaussians = n,
max = MAX_SCAN_GAUSSIANS,
"{e}; tile offsets will be incorrect — use IntermediateBuffers::try_allocate to reject this up front"
);
}
Self::allocate_with_pairs_per_gaussian(device, n, config, DEFAULT_PAIRS_PER_GAUSSIAN)
}
pub fn allocate_with_pairs_per_gaussian(
device: &wgpu::Device,
n: u32,
config: &RasterConfig,
pairs_per_gaussian: u32,
) -> Self {
let num_tiles = config.num_tiles();
let max_pairs = Self::estimate_max_pairs(n, pairs_per_gaussian, num_tiles);
let scan_plan = ScanPlan::new(n);
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_l1 = u64::from(scan_plan.level0_workgroups);
let num_wg_l2 = u64::from(scan_plan.level1_workgroups);
let block_sums = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("block_sums"),
size: num_wg_l1 * 4,
usage: storage,
mapped_at_creation: false,
});
let block_sums_scanned = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("block_sums_scanned"),
size: num_wg_l1 * 4,
usage: storage,
mapped_at_creation: false,
});
let block_sums_l2 = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("block_sums_l2"),
size: num_wg_l2 * 4,
usage: storage,
mapped_at_creation: false,
});
let block_sums_l2_scanned = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("block_sums_l2_scanned"),
size: num_wg_l2 * 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,
block_sums_l2,
block_sums_l2_scanned,
scan_plan,
normals,
}
}
pub fn check_pair_capacity(&self, count: u32) -> Result<(), RenderError> {
if count > self.max_pairs {
return Err(RenderError::TooManyTilePairs {
count,
allocated: self.max_pairs,
});
}
Ok(())
}
pub fn read_tile_offset(
&self,
device: &wgpu::Device,
queue: &wgpu::Queue,
index: u32,
) -> Result<u32, RenderError> {
let byte_offset = u64::from(index) * 4;
if byte_offset + 4 > self.tile_offsets.size() {
return Err(RenderError::BufferOverflow {
buffer_name: "tile_offsets".to_string(),
max_size: self.tile_offsets.size(),
requested: byte_offset + 4,
});
}
let staging_size = wgpu::COPY_BUFFER_ALIGNMENT.max(wgpu::MAP_ALIGNMENT);
let staging = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("tile_offset_readback"),
size: staging_size,
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("tile_offset_readback"),
});
encoder.copy_buffer_to_buffer(&self.tile_offsets, byte_offset, &staging, 0, 4u64);
queue.submit(std::iter::once(encoder.finish()));
let slice = staging.slice(..);
let (tx, rx) = std::sync::mpsc::channel();
slice.map_async(wgpu::MapMode::Read, move |result| {
tx.send(result).ok();
});
let _ = device.poll(wgpu::PollType::Wait {
submission_index: None,
timeout: None,
});
rx.recv()
.map_err(|e| RenderError::BufferMapFailed {
buffer_name: "tile_offsets".to_string(),
error: format!("Channel recv failed: {e}"),
})?
.map_err(|e| RenderError::BufferMapFailed {
buffer_name: "tile_offsets".to_string(),
error: e.to_string(),
})?;
let data = slice
.get_mapped_range()
.map_err(|e| RenderError::BufferMapFailed {
buffer_name: "tile_offsets".to_string(),
error: format!("Mapped range failed: {e}"),
})?;
let value = match data.get(..4) {
Some(chunk) => {
let mut raw = [0u8; 4];
raw.copy_from_slice(chunk);
u32::from_le_bytes(raw)
}
None => 0,
};
drop(data);
staging.unmap();
Ok(value)
}
pub fn read_pair_total(
&self,
device: &wgpu::Device,
queue: &wgpu::Queue,
n: u32,
) -> Result<u32, RenderError> {
if n == 0 {
return Ok(0);
}
self.read_tile_offset(device, queue, n - 1)
}
pub fn verify_pair_capacity(
&self,
device: &wgpu::Device,
queue: &wgpu::Queue,
n: u32,
) -> Result<u32, RenderError> {
let total = self.read_pair_total(device, queue, n)?;
self.check_pair_capacity(total)?;
Ok(total)
}
pub fn grow_sort_buffers(&mut self, device: &wgpu::Device, required: u32) -> bool {
if required <= self.max_pairs {
return false;
}
let new_max = required.max(self.max_pairs.saturating_mul(2));
let storage = wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST;
self.sort_keys = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sort_keys"),
size: u64::from(new_max) * 8, usage: storage,
mapped_at_creation: false,
});
self.sort_values = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sort_values"),
size: u64::from(new_max) * 4, usage: storage,
mapped_at_creation: false,
});
tracing::debug!(
old_max_pairs = self.max_pairs,
new_max_pairs = new_max,
"Grew sort buffers"
);
self.max_pairs = new_max;
true
}
}
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,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_scan_plan_single_level() {
let plan = ScanPlan::new(500);
assert_eq!(plan.level0_workgroups, 1);
assert_eq!(plan.levels, 1);
assert!(plan.is_supported());
}
#[test]
fn test_scan_plan_two_levels() {
let plan = ScanPlan::new(100_000);
assert_eq!(plan.level0_workgroups, 196);
assert_eq!(plan.level1_workgroups, 1);
assert_eq!(plan.levels, 2);
assert!(plan.is_supported());
}
#[test]
fn test_scan_plan_two_levels_at_exact_boundary() {
let plan = ScanPlan::new(PREFIX_SUM_BLOCK * PREFIX_SUM_BLOCK);
assert_eq!(plan.level0_workgroups, PREFIX_SUM_BLOCK);
assert_eq!(plan.level1_workgroups, 1);
assert_eq!(plan.levels, 2);
}
#[test]
fn test_scan_plan_requires_third_level_above_262144() {
let plan = ScanPlan::new(PREFIX_SUM_BLOCK * PREFIX_SUM_BLOCK + 1);
assert_eq!(plan.level0_workgroups, PREFIX_SUM_BLOCK + 1);
assert_eq!(plan.level1_workgroups, 2);
assert_eq!(plan.levels, 3);
assert!(plan.is_supported());
}
#[test]
fn test_scan_plan_three_levels_for_typical_scene() {
let plan = ScanPlan::new(1_000_000);
assert_eq!(plan.levels, 3);
assert!(plan.level1_workgroups > 1);
assert_eq!(plan.level2_workgroups, 1);
assert!(plan.is_supported());
}
#[test]
fn test_scan_plan_zero_elements() {
let plan = ScanPlan::new(0);
assert_eq!(plan.level0_workgroups, 1);
assert_eq!(plan.levels, 1);
assert!(plan.is_supported());
}
#[test]
fn test_validate_gaussian_count_accepts_supported_counts() {
assert!(IntermediateBuffers::validate_gaussian_count(0).is_ok());
assert!(IntermediateBuffers::validate_gaussian_count(1_000_000).is_ok());
assert!(IntermediateBuffers::validate_gaussian_count(MAX_SCAN_GAUSSIANS).is_ok());
}
#[test]
fn test_validate_gaussian_count_rejects_beyond_three_levels() {
let err = IntermediateBuffers::validate_gaussian_count(MAX_SCAN_GAUSSIANS + 1)
.expect_err("beyond the three-level scan must be rejected");
assert!(matches!(
err,
RenderError::TooManyGaussians {
max: MAX_SCAN_GAUSSIANS,
..
}
));
}
#[test]
fn test_estimate_max_pairs_uses_heuristic() {
assert_eq!(
IntermediateBuffers::estimate_max_pairs(10_000, DEFAULT_PAIRS_PER_GAUSSIAN, 4096),
40_000
);
}
#[test]
fn test_estimate_max_pairs_has_minimum() {
assert_eq!(
IntermediateBuffers::estimate_max_pairs(10, DEFAULT_PAIRS_PER_GAUSSIAN, 4096),
MIN_SORT_PAIRS
);
}
#[test]
fn test_estimate_max_pairs_clamped_by_tile_count() {
assert_eq!(
IntermediateBuffers::estimate_max_pairs(10_000, DEFAULT_PAIRS_PER_GAUSSIAN, 1),
10_000
);
}
#[test]
fn test_estimate_max_pairs_does_not_overflow() {
let pairs = IntermediateBuffers::estimate_max_pairs(2_000_000_000, 8, 100_000);
assert_eq!(pairs, u32::MAX);
}
fn packing_model(n: usize) -> GaussianModel {
use crate::gaussian::GaussianAttributes;
GaussianModel {
gaussians: (0..n)
.map(|i| GaussianAttributes {
position: [i as f32, i as f32 + 0.5, i as f32 + 0.25],
_pad0: 0.0,
rotation: [0.1, 0.2, 0.3, 0.4],
scale: [-1.0, -2.0, -3.0],
opacity: 0.75,
})
.collect(),
sh_coeffs: vec![1.0; n * 3],
sh_degree: 0,
face_indices: vec![0; n],
barycentric: vec![[1.0, 0.0, 0.0]; n],
local_offsets: vec![[0.0; 3]; n],
is_rigid: vec![false; n],
}
}
#[test]
fn test_packed_attributes_pads_to_vec4() {
let model = packing_model(2);
let packed = PackedAttributes::of(&model);
assert_eq!(packed.positions.len(), 2);
assert_eq!(packed.positions[1], [1.0, 1.5, 1.25, 0.0]);
assert_eq!(packed.scales[0], [-1.0, -2.0, -3.0, 0.0]);
assert_eq!(packed.rotations[0], [0.1, 0.2, 0.3, 0.4]);
assert_eq!(packed.opacities, vec![0.75, 0.75]);
assert_eq!(packed.sh_coeffs.len(), 6);
}
#[test]
fn test_packed_attributes_substitutes_missing_sh() {
let mut model = packing_model(4);
model.sh_coeffs.clear();
let packed = PackedAttributes::of(&model);
assert_eq!(packed.sh_coeffs.len(), 4 * 3);
assert!(packed.sh_coeffs.iter().all(|v| *v == 0.0));
let empty = packing_model(0);
assert_eq!(PackedAttributes::of(&empty).sh_coeffs.len(), 3);
}
}