use std::sync::Arc;
use bytemuck::{Pod, Zeroable};
use wgpu::util::DeviceExt;
use crate::{gaussian::GaussianModel, RenderError};
const DEFORM_STORAGE_BINDINGS: u32 = 11;
static NEXT_MESH_ID: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
fn next_mesh_id() -> u64 {
NEXT_MESH_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
}
pub struct MeshBuffers {
pub id: u64,
pub vertices: wgpu::Buffer,
pub normals: wgpu::Buffer,
pub faces: wgpu::Buffer,
pub num_vertices: u32,
pub num_faces: u32,
}
#[repr(C)]
#[derive(Debug, Clone, Copy, Pod, Zeroable)]
struct Vec4f32 {
x: f32,
y: f32,
z: f32,
w: f32,
}
impl Vec4f32 {
fn from_xyz(xyz: [f32; 3]) -> Self {
Self {
x: xyz[0],
y: xyz[1],
z: xyz[2],
w: 0.0,
}
}
fn from_xyzw(xyzw: [f32; 4]) -> Self {
Self {
x: xyzw[0],
y: xyzw[1],
z: xyzw[2],
w: xyzw[3],
}
}
}
#[repr(C)]
#[derive(Debug, Clone, Copy, Pod, Zeroable)]
struct Vec4u32 {
x: u32,
y: u32,
z: u32,
w: u32,
}
#[repr(C)]
#[derive(Debug, Clone, Copy, Pod, Zeroable)]
struct DeformUniforms {
num_gaussians: u32,
num_faces: u32,
_pad0: u32,
_pad1: u32,
}
pub struct DeformPipeline {
device: Arc<wgpu::Device>,
queue: Arc<wgpu::Queue>,
pipeline: wgpu::ComputePipeline,
bgl_0: wgpu::BindGroupLayout,
bgl_1: wgpu::BindGroupLayout,
}
type DeformResult = (Vec<[f32; 4]>, Vec<[f32; 4]>);
fn validate_deform_model_lengths(model: &GaussianModel) -> Result<(), RenderError> {
let n = model.len();
for (field, len) in [
("face_indices", model.face_indices.len()),
("barycentric", model.barycentric.len()),
("local_offsets", model.local_offsets.len()),
("is_rigid", model.is_rigid.len()),
] {
if len != n {
return Err(RenderError::Rasterize(format!(
"deform: GaussianModel.{field} has {len} entries, expected {n} (== model.len())"
)));
}
}
Ok(())
}
impl DeformPipeline {
pub fn new(device: Arc<wgpu::Device>, queue: Arc<wgpu::Queue>) -> Result<Self, RenderError> {
let available = device.limits().max_storage_buffers_per_shader_stage;
if available < DEFORM_STORAGE_BINDINGS {
return Err(RenderError::GpuInit(format!(
"DeformPipeline needs max_storage_buffers_per_shader_stage >= \
{DEFORM_STORAGE_BINDINGS}, but this device was created with {available}. \
Request the device with `wgpu::Limits {{ \
max_storage_buffers_per_shader_stage: 16, ..Default::default() }}`."
)));
}
let shader_src = include_str!("../shaders/deform_gaussians.wgsl");
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("deform_gaussians"),
source: wgpu::ShaderSource::Wgsl(shader_src.into()),
});
let bgl_0 = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("deform_bgl_0"),
entries: &[
storage_ro_entry(0), storage_ro_entry(1), storage_ro_entry(2), storage_ro_entry(3), storage_ro_entry(4), storage_ro_entry(5), storage_ro_entry(6), storage_ro_entry(7), storage_ro_entry(8), storage_rw_entry(9), storage_rw_entry(10), ],
});
let bgl_1 = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("deform_bgl_1"),
entries: &[
uniform_entry(0), ],
});
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("deform_pipeline_layout"),
bind_group_layouts: &[Some(&bgl_0), Some(&bgl_1)],
immediate_size: 0,
});
let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some("deform_gaussians_pipeline"),
layout: Some(&layout),
module: &shader,
entry_point: Some("deform_gaussians"),
compilation_options: Default::default(),
cache: None,
});
Ok(Self {
device,
queue,
pipeline,
bgl_0,
bgl_1,
})
}
pub fn upload_mesh(
&self,
vertices: &[[f32; 3]],
normals: &[[f32; 3]],
faces: &[[u32; 3]],
) -> Result<MeshBuffers, RenderError> {
if vertices.is_empty() {
return Err(RenderError::Rasterize(
"upload_mesh: vertices must not be empty".to_string(),
));
}
if faces.is_empty() {
return Err(RenderError::Rasterize(
"upload_mesh: faces must not be empty".to_string(),
));
}
if normals.len() != vertices.len() {
return Err(RenderError::Rasterize(format!(
"upload_mesh: normals has {} entries, expected {} (== vertices.len())",
normals.len(),
vertices.len()
)));
}
let vert_data: Vec<Vec4f32> = vertices.iter().map(|v| Vec4f32::from_xyz(*v)).collect();
let norm_data: Vec<Vec4f32> = normals.iter().map(|n| Vec4f32::from_xyz(*n)).collect();
let face_data: Vec<Vec4u32> = faces
.iter()
.map(|f| Vec4u32 {
x: f[0],
y: f[1],
z: f[2],
w: 0,
})
.collect();
let vert_buf = self
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("mesh_vertices"),
contents: bytemuck::cast_slice(&vert_data),
usage: wgpu::BufferUsages::STORAGE,
});
let norm_buf = self
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("mesh_normals"),
contents: bytemuck::cast_slice(&norm_data),
usage: wgpu::BufferUsages::STORAGE,
});
let face_buf = self
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("mesh_faces"),
contents: bytemuck::cast_slice(&face_data),
usage: wgpu::BufferUsages::STORAGE,
});
Ok(MeshBuffers {
id: next_mesh_id(),
vertices: vert_buf,
normals: norm_buf,
faces: face_buf,
num_vertices: vertices.len() as u32,
num_faces: faces.len() as u32,
})
}
pub fn deform(
&self,
model: &GaussianModel,
mesh: &MeshBuffers,
) -> Result<DeformResult, RenderError> {
let n = model.len() as u32;
if n == 0 {
return Ok((Vec::new(), Vec::new()));
}
validate_deform_model_lengths(model)?;
let pos_data: Vec<Vec4f32> = model
.gaussians
.iter()
.map(|g| Vec4f32::from_xyz(g.position))
.collect();
let rot_data: Vec<Vec4f32> = model
.gaussians
.iter()
.map(|g| Vec4f32::from_xyzw(g.rotation))
.collect();
let fi_buf = self
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("gaussian_face_indices"),
contents: bytemuck::cast_slice(&model.face_indices),
usage: wgpu::BufferUsages::STORAGE,
});
let bary_data: Vec<Vec4f32> = model
.barycentric
.iter()
.map(|b| Vec4f32::from_xyz(*b))
.collect();
let offset_data: Vec<Vec4f32> = model
.local_offsets
.iter()
.map(|o| Vec4f32::from_xyz(*o))
.collect();
let rigid_data: Vec<u32> = model
.is_rigid
.iter()
.map(|&r| if r { 1u32 } else { 0u32 })
.collect();
let pos_buf = self
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("g_positions"),
contents: bytemuck::cast_slice(&pos_data),
usage: wgpu::BufferUsages::STORAGE,
});
let rot_buf = self
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("g_rotations"),
contents: bytemuck::cast_slice(&rot_data),
usage: wgpu::BufferUsages::STORAGE,
});
let bary_buf = self
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("g_barycentric"),
contents: bytemuck::cast_slice(&bary_data),
usage: wgpu::BufferUsages::STORAGE,
});
let offset_buf = self
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("g_local_offsets"),
contents: bytemuck::cast_slice(&offset_data),
usage: wgpu::BufferUsages::STORAGE,
});
let rigid_buf = self
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("g_is_rigid"),
contents: bytemuck::cast_slice(&rigid_data),
usage: wgpu::BufferUsages::STORAGE,
});
let out_stride = std::mem::size_of::<Vec4f32>() as u64;
let out_byte_size = n as u64 * out_stride;
let out_pos_buf = self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("out_positions"),
size: out_byte_size,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
let out_rot_buf = self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("out_rotations"),
size: out_byte_size,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
let uniforms_data = DeformUniforms {
num_gaussians: n,
num_faces: mesh.num_faces,
_pad0: 0,
_pad1: 0,
};
let uniform_buf = self
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("deform_uniforms"),
contents: bytemuck::bytes_of(&uniforms_data),
usage: wgpu::BufferUsages::UNIFORM,
});
let bg_0 = self.device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("deform_bg_0"),
layout: &self.bgl_0,
entries: &[
buf_entry(0, &pos_buf),
buf_entry(1, &rot_buf),
buf_entry(2, &fi_buf),
buf_entry(3, &bary_buf),
buf_entry(4, &offset_buf),
buf_entry(5, &rigid_buf),
buf_entry(6, &mesh.vertices),
buf_entry(7, &mesh.normals),
buf_entry(8, &mesh.faces),
buf_entry(9, &out_pos_buf),
buf_entry(10, &out_rot_buf),
],
});
let bg_1 = self.device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("deform_bg_1"),
layout: &self.bgl_1,
entries: &[buf_entry(0, &uniform_buf)],
});
let workgroup_size = 256u32;
let num_workgroups = n.div_ceil(workgroup_size);
let mut encoder = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("deform_encoder"),
});
{
let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("deform_pass"),
timestamp_writes: None,
});
pass.set_pipeline(&self.pipeline);
pass.set_bind_group(0, &bg_0, &[]);
pass.set_bind_group(1, &bg_1, &[]);
pass.dispatch_workgroups(num_workgroups, 1, 1);
}
self.queue.submit(std::iter::once(encoder.finish()));
self.readback_vec4_pair(&out_pos_buf, &out_rot_buf, n as usize)
}
fn readback_vec4_pair(
&self,
buffer_a: &wgpu::Buffer,
buffer_b: &wgpu::Buffer,
count: usize,
) -> Result<DeformResult, RenderError> {
let half_byte_size = (count * std::mem::size_of::<[f32; 4]>()) as u64;
let total_byte_size = half_byte_size * 2;
let staging = self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("deform_staging_pair"),
size: total_byte_size,
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let mut encoder = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("deform_readback_pair"),
});
encoder.copy_buffer_to_buffer(buffer_a, 0, &staging, 0, half_byte_size);
encoder.copy_buffer_to_buffer(buffer_b, 0, &staging, half_byte_size, half_byte_size);
self.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 _ = self.device.poll(wgpu::PollType::Wait {
submission_index: None,
timeout: None,
});
rx.recv()
.map_err(|e| RenderError::Rasterize(format!("Deform readback channel error: {e}")))?
.map_err(|e| RenderError::Rasterize(format!("Deform buffer map failed: {e}")))?;
let mapped = slice
.get_mapped_range()
.map_err(|e| RenderError::Rasterize(format!("Deform mapped range failed: {e}")))?;
let floats: &[f32] = bytemuck::cast_slice(&mapped);
let floats_per_half = count * 4;
let a: Vec<[f32; 4]> = floats[..floats_per_half]
.chunks_exact(4)
.map(|c| [c[0], c[1], c[2], c[3]])
.collect();
let b: Vec<[f32; 4]> = floats[floats_per_half..floats_per_half * 2]
.chunks_exact(4)
.map(|c| [c[0], c[1], c[2], c[3]])
.collect();
drop(mapped);
staging.unmap();
Ok((a, b))
}
}
fn uniform_entry(binding: u32) -> wgpu::BindGroupLayoutEntry {
wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
}
}
fn storage_ro_entry(binding: u32) -> wgpu::BindGroupLayoutEntry {
wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Storage { read_only: true },
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
}
}
fn storage_rw_entry(binding: u32) -> wgpu::BindGroupLayoutEntry {
wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Storage { read_only: false },
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
}
}
fn buf_entry(binding: u32, buffer: &wgpu::Buffer) -> wgpu::BindGroupEntry<'_> {
wgpu::BindGroupEntry {
binding,
resource: buffer.as_entire_binding(),
}
}
pub fn deform_cpu(
model: &GaussianModel,
vertices: &[[f32; 3]],
normals: &[[f32; 3]],
faces: &[[u32; 3]],
) -> Result<DeformResult, RenderError> {
let n = model.len();
if n == 0 {
return Ok((Vec::new(), Vec::new()));
}
validate_deform_model_lengths(model)?;
if normals.len() != vertices.len() {
return Err(RenderError::Rasterize(format!(
"deform_cpu: normals has {} entries, expected {} (== vertices.len())",
normals.len(),
vertices.len()
)));
}
let num_faces = faces.len() as u32;
let mut out_positions = Vec::with_capacity(n);
let mut out_rotations = Vec::with_capacity(n);
for i in 0..n {
let g = &model.gaussians[i];
if model.is_rigid[i] {
out_positions.push([g.position[0], g.position[1], g.position[2], 1.0]);
out_rotations.push(g.rotation);
continue;
}
let fi = model.face_indices[i];
if fi >= num_faces {
out_positions.push([g.position[0], g.position[1], g.position[2], 1.0]);
out_rotations.push(g.rotation);
continue;
}
let face = faces[fi as usize];
let (vi0, vi1, vi2) = (face[0] as usize, face[1] as usize, face[2] as usize);
if vi0 >= vertices.len() || vi1 >= vertices.len() || vi2 >= vertices.len() {
return Err(RenderError::Rasterize(format!(
"deform_cpu: face {fi} references an out-of-range vertex index (have {} vertices)",
vertices.len()
)));
}
let bary = model.barycentric[i];
let local = model.local_offsets[i];
let p0 = vertices[vi0];
let p1 = vertices[vi1];
let p2 = vertices[vi2];
let interp_pos = [
bary[0] * p0[0] + bary[1] * p1[0] + bary[2] * p2[0],
bary[0] * p0[1] + bary[1] * p1[1] + bary[2] * p2[1],
bary[0] * p0[2] + bary[1] * p1[2] + bary[2] * p2[2],
];
let n0 = normals[vi0];
let n1 = normals[vi1];
let n2 = normals[vi2];
let interp_normal = [
bary[0] * n0[0] + bary[1] * n1[0] + bary[2] * n2[0],
bary[0] * n0[1] + bary[1] * n1[1] + bary[2] * n2[1],
bary[0] * n0[2] + bary[1] * n1[2] + bary[2] * n2[2],
];
let (t, bt, tbn_n) = build_tbn(p0, p1, p2, interp_normal);
let world_pos = apply_local_offset(interp_pos, t, bt, tbn_n, local);
let q_tbn = mat3_cols_to_quat(t, bt, tbn_n);
let world_rot = quat_mul(q_tbn, g.rotation);
out_positions.push([world_pos[0], world_pos[1], world_pos[2], 1.0]);
out_rotations.push(world_rot);
}
Ok((out_positions, out_rotations))
}
pub fn quat_mul(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
let [ax, ay, az, aw] = a;
let [bx, by, bz, bw] = b;
[
aw * bx + ax * bw + ay * bz - az * by,
aw * by - ax * bz + ay * bw + az * bx,
aw * bz + ax * by - ay * bx + az * bw,
aw * bw - ax * bx - ay * by - az * bz,
]
}
pub fn mat3_cols_to_quat(t: [f32; 3], bt: [f32; 3], n: [f32; 3]) -> [f32; 4] {
let m00 = t[0];
let m01 = bt[0];
let m02 = n[0];
let m10 = t[1];
let m11 = bt[1];
let m12 = n[1];
let m20 = t[2];
let m21 = bt[2];
let m22 = n[2];
let trace = m00 + m11 + m22;
let (qx, qy, qz, qw);
if trace > 0.0 {
let s = (trace + 1.0_f32).sqrt() * 2.0; qw = 0.25 * s;
qx = (m21 - m12) / s;
qy = (m02 - m20) / s;
qz = (m10 - m01) / s;
} else if (m00 > m11) && (m00 > m22) {
let s = (1.0 + m00 - m11 - m22).sqrt() * 2.0; qw = (m21 - m12) / s;
qx = 0.25 * s;
qy = (m01 + m10) / s;
qz = (m02 + m20) / s;
} else if m11 > m22 {
let s = (1.0 + m11 - m00 - m22).sqrt() * 2.0; qw = (m02 - m20) / s;
qx = (m01 + m10) / s;
qy = 0.25 * s;
qz = (m12 + m21) / s;
} else {
let s = (1.0 + m22 - m00 - m11).sqrt() * 2.0; qw = (m10 - m01) / s;
qx = (m02 + m20) / s;
qy = (m12 + m21) / s;
qz = 0.25 * s;
}
let norm = (qx * qx + qy * qy + qz * qz + qw * qw).sqrt();
if norm < 1e-10 {
[0.0, 0.0, 0.0, 1.0]
} else {
[qx / norm, qy / norm, qz / norm, qw / norm]
}
}
pub fn build_tbn(
v0: [f32; 3],
v1: [f32; 3],
v2: [f32; 3],
interp_n: [f32; 3],
) -> ([f32; 3], [f32; 3], [f32; 3]) {
let e1 = vec3_sub(v1, v0);
let e2 = vec3_sub(v2, v0);
let geom_normal = vec3_cross(e1, e2);
let geom_len = vec3_len(geom_normal);
if geom_len < 1e-7 {
return ([1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]);
}
let interp_len = vec3_len(interp_n);
let n = if interp_len > 1e-7 {
vec3_scale(interp_n, 1.0 / interp_len)
} else {
vec3_scale(geom_normal, 1.0 / geom_len)
};
let e1_len = vec3_len(e1);
let raw_t = if e1_len > 1e-7 {
vec3_scale(e1, 1.0 / e1_len)
} else {
pick_perpendicular(n)
};
let t_proj = vec3_sub(raw_t, vec3_scale(n, vec3_dot(raw_t, n)));
let t_proj_len = vec3_len(t_proj);
let t = if t_proj_len > 1e-7 {
vec3_scale(t_proj, 1.0 / t_proj_len)
} else {
let fallback = pick_perpendicular(n);
let fp = vec3_sub(fallback, vec3_scale(n, vec3_dot(fallback, n)));
let fp_len = vec3_len(fp);
vec3_scale(fp, 1.0 / fp_len.max(1e-10))
};
let bt_raw = vec3_cross(n, t);
let bt = vec3_normalize(bt_raw);
let t_final = vec3_cross(bt, n);
(t_final, bt, n)
}
pub fn apply_local_offset(
bary_pos: [f32; 3],
t: [f32; 3],
bt: [f32; 3],
n: [f32; 3],
local: [f32; 3],
) -> [f32; 3] {
[
bary_pos[0] + t[0] * local[0] + bt[0] * local[1] + n[0] * local[2],
bary_pos[1] + t[1] * local[0] + bt[1] * local[1] + n[1] * local[2],
bary_pos[2] + t[2] * local[0] + bt[2] * local[1] + n[2] * local[2],
]
}
fn vec3_sub(a: [f32; 3], b: [f32; 3]) -> [f32; 3] {
[a[0] - b[0], a[1] - b[1], a[2] - b[2]]
}
fn vec3_scale(a: [f32; 3], s: f32) -> [f32; 3] {
[a[0] * s, a[1] * s, a[2] * s]
}
fn vec3_dot(a: [f32; 3], b: [f32; 3]) -> f32 {
a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
}
fn vec3_cross(a: [f32; 3], b: [f32; 3]) -> [f32; 3] {
[
a[1] * b[2] - a[2] * b[1],
a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0],
]
}
fn vec3_len(a: [f32; 3]) -> f32 {
(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]).sqrt()
}
fn vec3_normalize(a: [f32; 3]) -> [f32; 3] {
let len = vec3_len(a);
if len < 1e-10 {
a
} else {
vec3_scale(a, 1.0 / len)
}
}
fn pick_perpendicular(n: [f32; 3]) -> [f32; 3] {
let abs_n = [n[0].abs(), n[1].abs(), n[2].abs()];
if abs_n[0] <= abs_n[1] && abs_n[0] <= abs_n[2] {
[1.0, 0.0, 0.0]
} else if abs_n[1] <= abs_n[2] {
[0.0, 1.0, 0.0]
} else {
[0.0, 0.0, 1.0]
}
}
#[cfg(test)]
mod tests {
use super::*;
const EPS: f32 = 1e-5;
fn assert_approx_eq4(a: [f32; 4], b: [f32; 4], eps: f32, msg: &str) {
for i in 0..4 {
assert!(
(a[i] - b[i]).abs() < eps,
"{msg}: component {i}: {a:?} vs {b:?}"
);
}
}
fn assert_approx_eq3(a: [f32; 3], b: [f32; 3], eps: f32, msg: &str) {
for i in 0..3 {
assert!(
(a[i] - b[i]).abs() < eps,
"{msg}: component {i}: {a:?} vs {b:?}"
);
}
}
fn quat_canonical(q: [f32; 4]) -> [f32; 4] {
let [x, y, z, w] = q;
if w < 0.0 || (w == 0.0 && x < 0.0) || (w == 0.0 && x == 0.0 && y < 0.0) {
[-x, -y, -z, -w]
} else {
[x, y, z, w]
}
}
#[test]
fn test_mat3_to_quat_identity() {
let t = [1.0_f32, 0.0, 0.0];
let bt = [0.0_f32, 1.0, 0.0];
let n = [0.0_f32, 0.0, 1.0];
let q = quat_canonical(mat3_cols_to_quat(t, bt, n));
let expected = [0.0_f32, 0.0, 0.0, 1.0]; assert_approx_eq4(q, expected, EPS, "identity mat → quat");
}
#[test]
fn test_mat3_to_quat_rot90_z() {
let t = [0.0_f32, 1.0, 0.0];
let bt = [-1.0_f32, 0.0, 0.0];
let n = [0.0_f32, 0.0, 1.0];
let q = quat_canonical(mat3_cols_to_quat(t, bt, n));
let s = std::f32::consts::FRAC_1_SQRT_2;
let expected = quat_canonical([0.0, 0.0, s, s]);
assert_approx_eq4(q, expected, EPS, "90° Z rotation");
}
#[test]
fn test_mat3_to_quat_rot90_x() {
let t = [1.0_f32, 0.0, 0.0];
let bt = [0.0_f32, 0.0, 1.0];
let n = [0.0_f32, -1.0, 0.0];
let q = quat_canonical(mat3_cols_to_quat(t, bt, n));
let s = std::f32::consts::FRAC_1_SQRT_2;
let expected = quat_canonical([s, 0.0, 0.0, s]);
assert_approx_eq4(q, expected, EPS, "90° X rotation");
}
#[test]
fn test_quat_mul_identity() {
let id = [0.0_f32, 0.0, 0.0, 1.0];
let q = [0.1_f32, 0.2, 0.3, 0.9272727_f32]; let norm = (0.1f32 * 0.1 + 0.2 * 0.2 + 0.3 * 0.3 + 0.9272727 * 0.9272727).sqrt();
let q_unit = [q[0] / norm, q[1] / norm, q[2] / norm, q[3] / norm];
let result = quat_mul(q_unit, id);
assert_approx_eq4(result, q_unit, EPS, "q * id = q");
let result2 = quat_mul(id, q_unit);
assert_approx_eq4(result2, q_unit, EPS, "id * q = q");
}
#[test]
fn test_quat_mul_compose_z() {
let s = std::f32::consts::FRAC_1_SQRT_2;
let q90z = [0.0_f32, 0.0, s, s]; let q180z = quat_canonical(quat_mul(q90z, q90z));
let expected = quat_canonical([0.0, 0.0, 1.0, 0.0]);
assert_approx_eq4(q180z, expected, EPS, "90° + 90° Z = 180° Z");
}
#[test]
fn test_build_tbn_xy_plane() {
let v0 = [0.0_f32, 0.0, 0.0];
let v1 = [1.0_f32, 0.0, 0.0];
let v2 = [0.0_f32, 1.0, 0.0];
let interp_n = [0.0_f32, 0.0, 1.0];
let (t, bt, n) = build_tbn(v0, v1, v2, interp_n);
assert_approx_eq3(n, [0.0, 0.0, 1.0], EPS, "XY-plane normal");
let dot_t_n = vec3_dot(t, n);
let dot_bt_n = vec3_dot(bt, n);
let dot_t_bt = vec3_dot(t, bt);
assert!(dot_t_n.abs() < EPS, "t ⊥ n: {dot_t_n}");
assert!(dot_bt_n.abs() < EPS, "bt ⊥ n: {dot_bt_n}");
assert!(dot_t_bt.abs() < EPS, "t ⊥ bt: {dot_t_bt}");
assert!((vec3_len(t) - 1.0).abs() < EPS, "|t| = 1");
assert!((vec3_len(bt) - 1.0).abs() < EPS, "|bt| = 1");
assert!((vec3_len(n) - 1.0).abs() < EPS, "|n| = 1");
}
#[test]
fn test_apply_local_offset_zero() {
let base = [1.0_f32, 2.0, 3.0];
let t = [1.0_f32, 0.0, 0.0];
let bt = [0.0_f32, 1.0, 0.0];
let n = [0.0_f32, 0.0, 1.0];
let local = [0.0_f32, 0.0, 0.0];
let result = apply_local_offset(base, t, bt, n, local);
assert_approx_eq3(result, base, EPS, "zero offset = identity");
}
#[test]
fn test_apply_local_offset_normal_direction() {
let base = [0.0_f32, 0.0, 0.0];
let t = [1.0_f32, 0.0, 0.0];
let bt = [0.0_f32, 1.0, 0.0];
let n = [0.0_f32, 0.0, 1.0];
let local = [0.0_f32, 0.0, 0.5];
let result = apply_local_offset(base, t, bt, n, local);
assert_approx_eq3(result, [0.0, 0.0, 0.5], EPS, "normal offset → +Z");
}
#[test]
fn test_build_tbn_degenerate_triangle() {
let v = [1.0_f32, 2.0, 3.0];
let (t, bt, n) = build_tbn(v, v, v, [0.0, 0.0, 0.0]);
assert_approx_eq3(t, [1.0, 0.0, 0.0], EPS, "degenerate t");
assert_approx_eq3(bt, [0.0, 1.0, 0.0], EPS, "degenerate bt");
assert_approx_eq3(n, [0.0, 0.0, 1.0], EPS, "degenerate n");
}
#[test]
fn test_barycentric_interpolation_centroid() {
let v0 = [0.0_f32, 0.0, 0.0];
let v1 = [3.0_f32, 0.0, 0.0];
let v2 = [0.0_f32, 3.0, 0.0];
let bary = [1.0_f32 / 3.0, 1.0 / 3.0, 1.0 / 3.0];
let interp = [
bary[0] * v0[0] + bary[1] * v1[0] + bary[2] * v2[0],
bary[0] * v0[1] + bary[1] * v1[1] + bary[2] * v2[1],
bary[0] * v0[2] + bary[1] * v1[2] + bary[2] * v2[2],
];
assert_approx_eq3(interp, [1.0, 1.0, 0.0], EPS, "centroid interpolation");
let interp_n = [0.0_f32, 0.0, 1.0];
let (t, bt, n) = build_tbn(v0, v1, v2, interp_n);
let result = apply_local_offset(interp, t, bt, n, [0.5, 0.0, 0.0]);
let expected_x = interp[0] + 0.5 * t[0];
let expected_y = interp[1] + 0.5 * t[1];
let expected_z = interp[2] + 0.5 * t[2];
assert_approx_eq3(
result,
[expected_x, expected_y, expected_z],
EPS,
"offset round-trip",
);
}
#[test]
fn test_quat_mul_non_commutative() {
let s = std::f32::consts::FRAC_1_SQRT_2;
let qx = [s, 0.0, 0.0, s]; let qz = [0.0, 0.0, s, s];
let qxz = quat_mul(qx, qz);
let qzx = quat_mul(qz, qx);
let are_equal = qxz.iter().zip(qzx.iter()).all(|(a, b)| (a - b).abs() < EPS);
assert!(
!are_equal,
"quat_mul should be non-commutative for different axes"
);
}
#[test]
fn test_mat3_to_quat_rot90_y() {
let t = [0.0_f32, 0.0, -1.0];
let bt = [0.0_f32, 1.0, 0.0];
let n = [1.0_f32, 0.0, 0.0];
let q = quat_canonical(mat3_cols_to_quat(t, bt, n));
let s = std::f32::consts::FRAC_1_SQRT_2;
let expected = quat_canonical([0.0, s, 0.0, s]);
assert_approx_eq4(q, expected, EPS, "90° Y rotation");
}
fn make_test_model(n: usize) -> GaussianModel {
GaussianModel {
gaussians: vec![
crate::gaussian::GaussianAttributes {
position: [0.0, 0.0, 0.0],
_pad0: 0.0,
rotation: [0.0, 0.0, 0.0, 1.0],
scale: [0.0, 0.0, 0.0],
opacity: 0.0,
};
n
],
sh_coeffs: Vec::new(),
sh_degree: 0,
face_indices: vec![0u32; n],
barycentric: vec![[1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0]; n],
local_offsets: vec![[0.0, 0.0, 0.0]; n],
is_rigid: vec![false; n],
}
}
#[test]
fn test_validate_deform_model_lengths_ok() {
let model = make_test_model(5);
assert!(validate_deform_model_lengths(&model).is_ok());
}
#[test]
fn test_validate_deform_model_lengths_empty_model_ok() {
let model = make_test_model(0);
assert!(validate_deform_model_lengths(&model).is_ok());
}
#[test]
fn test_validate_deform_model_lengths_rejects_short_face_indices() {
let mut model = make_test_model(5);
model.face_indices.pop();
assert!(validate_deform_model_lengths(&model).is_err());
}
#[test]
fn test_validate_deform_model_lengths_rejects_short_barycentric() {
let mut model = make_test_model(5);
model.barycentric.pop();
assert!(validate_deform_model_lengths(&model).is_err());
}
#[test]
fn test_validate_deform_model_lengths_rejects_short_local_offsets() {
let mut model = make_test_model(5);
model.local_offsets.pop();
assert!(validate_deform_model_lengths(&model).is_err());
}
#[test]
fn test_validate_deform_model_lengths_rejects_short_is_rigid() {
let mut model = make_test_model(5);
model.is_rigid.pop();
assert!(validate_deform_model_lengths(&model).is_err());
}
#[test]
fn test_deform_cpu_empty_model() {
let model = make_test_model(0);
let vertices = vec![[0.0_f32, 0.0, 0.0]];
let normals = vec![[0.0_f32, 0.0, 1.0]];
let faces = vec![[0u32, 0, 0]];
let (positions, rotations) = deform_cpu(&model, &vertices, &normals, &faces).unwrap();
assert!(positions.is_empty());
assert!(rotations.is_empty());
}
#[test]
fn test_deform_cpu_rejects_mismatched_arrays() {
let mut model = make_test_model(3);
model.local_offsets.pop();
let vertices = vec![[0.0_f32, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]];
let normals = vec![[0.0_f32, 0.0, 1.0]; 3];
let faces = vec![[0u32, 1, 2]];
let result = deform_cpu(&model, &vertices, &normals, &faces);
assert!(result.is_err());
}
#[test]
fn test_deform_cpu_rejects_normals_length_mismatch() {
let model = make_test_model(1);
let vertices = vec![[0.0_f32, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]];
let normals = vec![[0.0_f32, 0.0, 1.0]; 2]; let faces = vec![[0u32, 1, 2]];
let result = deform_cpu(&model, &vertices, &normals, &faces);
assert!(result.is_err());
}
#[test]
fn test_deform_cpu_matches_barycentric_interpolation() {
let vertices = vec![[0.0_f32, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]];
let normals = vec![[0.0_f32, 0.0, 1.0]; 3];
let faces = vec![[0u32, 1, 2]];
let model = GaussianModel {
gaussians: vec![crate::gaussian::GaussianAttributes {
position: [1.0 / 3.0, 1.0 / 3.0, 0.0],
_pad0: 0.0,
rotation: [0.0, 0.0, 0.0, 1.0],
scale: [1.0, 1.0, 1.0],
opacity: 0.0,
}],
sh_coeffs: vec![0.0; 3],
sh_degree: 0,
face_indices: vec![0],
barycentric: vec![[1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0]],
local_offsets: vec![[0.0, 0.0, 0.0]],
is_rigid: vec![false],
};
let (positions, rotations) = deform_cpu(&model, &vertices, &normals, &faces).unwrap();
assert_eq!(positions.len(), 1);
assert_eq!(rotations.len(), 1);
assert_approx_eq4(
positions[0],
[1.0 / 3.0, 1.0 / 3.0, 0.0, 1.0],
EPS,
"barycentric-interpolated position",
);
assert_approx_eq4(
rotations[0],
[0.0, 0.0, 0.0, 1.0],
EPS,
"identity TBN frame leaves rotation unchanged",
);
}
#[test]
fn test_deform_cpu_invalid_face_index_passes_through() {
let vertices = vec![[0.0_f32, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]];
let normals = vec![[0.0_f32, 0.0, 1.0]; 3];
let faces = vec![[0u32, 1, 2]];
let orig_pos = [5.0_f32, 6.0, 7.0];
let orig_rot = [0.1_f32, 0.2, 0.3, 0.9];
let model = GaussianModel {
gaussians: vec![crate::gaussian::GaussianAttributes {
position: orig_pos,
_pad0: 0.0,
rotation: orig_rot,
scale: [1.0, 1.0, 1.0],
opacity: 0.0,
}],
sh_coeffs: vec![0.0; 3],
sh_degree: 0,
face_indices: vec![99], barycentric: vec![[1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0]],
local_offsets: vec![[0.0, 0.0, 0.0]],
is_rigid: vec![false],
};
let (positions, rotations) = deform_cpu(&model, &vertices, &normals, &faces).unwrap();
assert_approx_eq4(
positions[0],
[orig_pos[0], orig_pos[1], orig_pos[2], 1.0],
EPS,
"out-of-range face index should pass position through unchanged",
);
assert_approx_eq4(
rotations[0],
orig_rot,
EPS,
"out-of-range face index should pass rotation through unchanged",
);
}
#[test]
fn test_deform_cpu_rigid_gaussian_ignores_mesh_binding() {
let vertices = vec![[0.0_f32, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]];
let normals = vec![[0.0_f32, 0.0, 1.0]; 3];
let faces = vec![[0u32, 1, 2]];
let orig_pos = [10.0_f32, -3.0, 2.5];
let orig_rot = [0.0_f32, 0.0, 0.0, 1.0];
let model = GaussianModel {
gaussians: vec![crate::gaussian::GaussianAttributes {
position: orig_pos,
_pad0: 0.0,
rotation: orig_rot,
scale: [1.0, 1.0, 1.0],
opacity: 0.0,
}],
sh_coeffs: vec![0.0; 3],
sh_degree: 0,
face_indices: vec![0],
barycentric: vec![[1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0]],
local_offsets: vec![[100.0, 100.0, 100.0]],
is_rigid: vec![true],
};
let (positions, rotations) = deform_cpu(&model, &vertices, &normals, &faces).unwrap();
assert_approx_eq4(
positions[0],
[orig_pos[0], orig_pos[1], orig_pos[2], 1.0],
EPS,
"rigid Gaussian position must be unaffected by the mesh binding",
);
assert_approx_eq4(
rotations[0],
orig_rot,
EPS,
"rigid Gaussian rotation must be unaffected by the mesh binding",
);
}
#[test]
fn test_deform_cpu_rejects_out_of_range_face_vertex() {
let vertices = vec![[0.0_f32, 0.0, 0.0], [1.0, 0.0, 0.0]]; let normals = vec![[0.0_f32, 0.0, 1.0]; 2];
let faces = vec![[0u32, 1, 2]];
let model = make_test_model(1);
let result = deform_cpu(&model, &vertices, &normals, &faces);
assert!(result.is_err());
}
#[test]
fn test_shader_honours_is_rigid_binding() {
let shader_src = include_str!("../shaders/deform_gaussians.wgsl");
assert!(
shader_src.contains("if gaussian_is_rigid[gaussian_id] != 0u {"),
"deform_gaussians.wgsl must early-out on gaussian_is_rigid: \
DeformPipeline::deform no longer post-processes the readback"
);
let rigid_at = shader_src
.find("if gaussian_is_rigid[gaussian_id] != 0u {")
.expect("rigid branch present");
let face_at = shader_src
.find("if fi >= uniforms.num_faces {")
.expect("face-index branch present");
assert!(
rigid_at < face_at,
"the rigid early-out must be checked before the face-index bound"
);
}
#[test]
fn test_next_mesh_id_is_unique_and_monotonic() {
let a = next_mesh_id();
let b = next_mesh_id();
let c = next_mesh_id();
assert!(a < b && b < c, "mesh ids must be strictly increasing");
}
fn try_make_gpu_device() -> Option<(Arc<wgpu::Device>, Arc<wgpu::Queue>)> {
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
..wgpu::InstanceDescriptor::new_without_display_handle()
});
let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::HighPerformance,
compatible_surface: None,
force_fallback_adapter: false,
apply_limit_buckets: false,
}))
.ok()?;
let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
label: Some("test_device"),
required_features: wgpu::Features::empty(),
required_limits: wgpu::Limits {
max_storage_buffers_per_shader_stage: 16,
..wgpu::Limits::default()
},
memory_hints: wgpu::MemoryHints::Performance,
experimental_features: wgpu::ExperimentalFeatures::default(),
trace: wgpu::Trace::Off,
}))
.ok()?;
Some((Arc::new(device), Arc::new(queue)))
}
#[test]
#[ignore = "requires GPU adapter"]
fn test_deform_gpu_matches_deform_cpu_oracle() {
let vertices = vec![
[0.0_f32, 0.0, 0.0],
[1.0_f32, 0.0, 0.0],
[0.0_f32, 1.0, 0.0],
];
let normals = vec![[0.0_f32, 0.0, 1.0]; 3];
let faces = vec![[0u32, 1, 2]];
let attrs = |position: [f32; 3], rotation: [f32; 4]| crate::gaussian::GaussianAttributes {
position,
_pad0: 0.0,
rotation,
scale: [1.0, 1.0, 1.0],
opacity: 0.0,
};
let s = std::f32::consts::FRAC_1_SQRT_2;
let model = GaussianModel {
gaussians: vec![
attrs([0.0, 0.0, 0.0], [0.0, 0.0, s, s]),
attrs([10.0, -3.0, 2.5], [0.0, 0.0, 0.0, 1.0]),
attrs([-4.0, 8.0, 1.5], [s, 0.0, 0.0, s]),
attrs([5.0, 6.0, 7.0], [0.0, s, 0.0, s]),
],
sh_coeffs: vec![0.0; 4 * 3],
sh_degree: 0,
face_indices: vec![0, 0, 99, 99],
barycentric: vec![[1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0]; 4],
local_offsets: vec![
[0.25, -0.125, 0.5],
[100.0, 100.0, 100.0],
[100.0, 100.0, 100.0],
[1.0, 2.0, 3.0],
],
is_rigid: vec![false, true, true, false],
};
let Some((device, queue)) = try_make_gpu_device() else {
eprintln!("No GPU adapter available, skipping GPU test");
return;
};
let pipeline = DeformPipeline::new(Arc::clone(&device), Arc::clone(&queue))
.expect("Failed to create DeformPipeline");
let mesh = pipeline
.upload_mesh(&vertices, &normals, &faces)
.expect("upload_mesh failed");
let (gpu_pos, gpu_rot) = pipeline.deform(&model, &mesh).expect("Deform failed");
let (cpu_pos, cpu_rot) =
deform_cpu(&model, &vertices, &normals, &faces).expect("deform_cpu failed");
assert_eq!(gpu_pos.len(), model.len());
assert_eq!(cpu_pos.len(), model.len());
const GPU_EPS: f32 = 1e-4;
for i in 0..model.len() {
assert_approx_eq4(
gpu_pos[i],
cpu_pos[i],
GPU_EPS,
&format!("Gaussian {i}: GPU position must match the deform_cpu oracle"),
);
assert_approx_eq4(
quat_canonical(gpu_rot[i]),
quat_canonical(cpu_rot[i]),
GPU_EPS,
&format!("Gaussian {i}: GPU rotation must match the deform_cpu oracle"),
);
}
for i in [1_usize, 2] {
let g = &model.gaussians[i];
assert_approx_eq4(
gpu_pos[i],
[g.position[0], g.position[1], g.position[2], 1.0],
GPU_EPS,
&format!("rigid Gaussian {i} must keep its authored position"),
);
assert_approx_eq4(
gpu_rot[i],
g.rotation,
GPU_EPS,
&format!("rigid Gaussian {i} must keep its authored rotation"),
);
}
let g0 = &model.gaussians[0];
let moved = (gpu_pos[0][0] - g0.position[0]).abs()
+ (gpu_pos[0][1] - g0.position[1]).abs()
+ (gpu_pos[0][2] - g0.position[2]).abs();
assert!(
moved > 1e-3,
"flexible Gaussian 0 should be repositioned by the mesh binding, got {:?}",
gpu_pos[0]
);
for (i, p) in gpu_pos.iter().enumerate() {
assert!(
(p[3] - 1.0).abs() < GPU_EPS,
"Gaussian {i}: position w must be 1.0, got {}",
p[3]
);
}
}
#[test]
#[ignore = "requires GPU adapter"]
fn test_deform_pipeline_new_rejects_insufficient_storage_buffer_limit() {
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
..wgpu::InstanceDescriptor::new_without_display_handle()
});
let Ok(adapter) =
pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::HighPerformance,
compatible_surface: None,
force_fallback_adapter: false,
apply_limit_buckets: false,
}))
else {
eprintln!("No GPU adapter available, skipping GPU test");
return;
};
let Ok((device, queue)) =
pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
label: Some("test_device_default_limits"),
required_features: wgpu::Features::empty(),
required_limits: wgpu::Limits::default(),
memory_hints: wgpu::MemoryHints::Performance,
experimental_features: wgpu::ExperimentalFeatures::default(),
trace: wgpu::Trace::Off,
}))
else {
eprintln!("Could not create a default-limits device, skipping");
return;
};
assert!(
device.limits().max_storage_buffers_per_shader_stage < DEFORM_STORAGE_BINDINGS,
"precondition: the default-limits device must be under the requirement"
);
let result = DeformPipeline::new(Arc::new(device), Arc::new(queue));
match result {
Ok(_) => {
panic!("DeformPipeline::new must reject a device with too few storage buffers")
}
Err(e) => {
let msg = e.to_string();
assert!(
msg.contains("max_storage_buffers_per_shader_stage"),
"error should name the offending limit, got: {msg}"
);
}
}
}
#[test]
#[ignore = "requires GPU adapter"]
fn test_upload_mesh_assigns_unique_ids() {
let vertices = vec![
[0.0_f32, 0.0, 0.0],
[1.0_f32, 0.0, 0.0],
[0.0_f32, 1.0, 0.0],
];
let normals = vec![[0.0_f32, 0.0, 1.0]; 3];
let faces = vec![[0u32, 1, 2]];
let Some((device, queue)) = try_make_gpu_device() else {
eprintln!("No GPU adapter available, skipping GPU test");
return;
};
let pipeline = DeformPipeline::new(device, queue).expect("Failed to create DeformPipeline");
let mesh_a = pipeline
.upload_mesh(&vertices, &normals, &faces)
.expect("upload_mesh failed");
let mesh_b = pipeline
.upload_mesh(&vertices, &normals, &faces)
.expect("upload_mesh failed");
assert_ne!(
mesh_a.id, mesh_b.id,
"two uploads must never share a mesh id"
);
assert_eq!(mesh_a.num_vertices, mesh_b.num_vertices);
assert_eq!(mesh_a.num_faces, mesh_b.num_faces);
}
#[test]
#[ignore = "requires GPU adapter"]
fn test_deform_gpu_single_gaussian() {
let vertices = vec![
[0.0_f32, 0.0, 0.0],
[1.0_f32, 0.0, 0.0],
[0.0_f32, 1.0, 0.0],
];
let normals = vec![
[0.0_f32, 0.0, 1.0],
[0.0_f32, 0.0, 1.0],
[0.0_f32, 0.0, 1.0],
];
let faces = vec![[0u32, 1, 2]];
let model = GaussianModel {
gaussians: vec![crate::gaussian::GaussianAttributes {
position: [1.0 / 3.0, 1.0 / 3.0, 0.0],
_pad0: 0.0,
rotation: [0.0, 0.0, 0.0, 1.0],
scale: [1.0, 1.0, 1.0],
opacity: 0.0,
}],
sh_coeffs: vec![0.0; 3],
sh_degree: 0,
face_indices: vec![0],
barycentric: vec![[1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0]],
local_offsets: vec![[0.0, 0.0, 0.0]],
is_rigid: vec![false],
};
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
..wgpu::InstanceDescriptor::new_without_display_handle()
});
let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::HighPerformance,
compatible_surface: None,
force_fallback_adapter: false,
apply_limit_buckets: false,
}));
let adapter = match adapter {
Ok(a) => a,
Err(_) => {
eprintln!("No GPU adapter available, skipping GPU test");
return;
}
};
let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
label: Some("test_device"),
required_features: wgpu::Features::empty(),
required_limits: wgpu::Limits {
max_storage_buffers_per_shader_stage: 16,
..wgpu::Limits::default()
},
memory_hints: wgpu::MemoryHints::Performance,
experimental_features: wgpu::ExperimentalFeatures::default(),
trace: wgpu::Trace::Off,
}))
.expect("Failed to create device");
let device = Arc::new(device);
let queue = Arc::new(queue);
let pipeline = DeformPipeline::new(Arc::clone(&device), Arc::clone(&queue))
.expect("Failed to create DeformPipeline");
let mesh = pipeline
.upload_mesh(&vertices, &normals, &faces)
.expect("upload_mesh failed");
let (positions, rotations) = pipeline.deform(&model, &mesh).expect("Deform failed");
assert_eq!(positions.len(), 1, "Should have 1 output position");
assert_eq!(rotations.len(), 1, "Should have 1 output rotation");
let expected_pos = [1.0 / 3.0, 1.0 / 3.0, 0.0];
let [px, py, pz, _] = positions[0];
assert!((px - expected_pos[0]).abs() < 1e-4, "x: {px}");
assert!((py - expected_pos[1]).abs() < 1e-4, "y: {py}");
assert!((pz - expected_pos[2]).abs() < 1e-4, "z: {pz}");
}
}