use super::RayTracingStats;
use crate::asset::{Asset, CpuMesh, Vertex};
use crate::shading::{RayQueryForm, SCENE_RAYS_QUERY_OPAQUE, bind, compose};
use crate::test_support;
use crate::{InstanceState, Mobility, Scene};
use glam::{Mat4, Vec3};
fn triangles(centre: Vec3, triangles: u32) -> CpuMesh {
let vertices = (0..triangles * 3)
.map(|vertex| {
let corner = [[-0.5, -0.5], [0.5, -0.5], [0., 0.5]][vertex as usize % 3];
let layer = (vertex / 3) as f32 * 0.01;
Vertex {
tangent: [0.; 4],
lightmap_bounds: [0., 0., 1., 1.],
lightmap_uv: [0.; 2],
position: (centre + Vec3::new(corner[0], corner[1], layer)).to_array(),
normal: [0., 0., 1.],
uv: [0.; 2],
color: [1.; 4],
}
})
.collect();
CpuMesh {
vertices,
indices: (0..triangles * 3).collect(),
material: 0,
deformation: Default::default(),
}
}
fn asset(meshes: Vec<CpuMesh>) -> Asset {
let mut asset = test_support::cube();
asset.meshes = meshes;
asset
}
fn place(
gpu: (&wgpu::Device, &wgpu::Queue),
scene: &mut Scene,
model: crate::ModelId,
pose: Mat4,
mobility: Mobility,
) -> crate::InstanceId {
scene
.add_instance(
gpu.0,
gpu.1,
InstanceState {
pose,
..InstanceState::new(model)
},
mobility,
)
.unwrap()
}
fn build(gpu: (&wgpu::Device, &wgpu::Queue), scene: &mut Scene, eye: Vec3) -> RayTracingStats {
build_in(gpu, scene, eye, RayQueryForm::Baseline)
}
fn build_in(
(device, queue): (&wgpu::Device, &wgpu::Queue),
scene: &mut Scene,
eye: Vec3,
form: RayQueryForm,
) -> RayTracingStats {
let stats = scene
.prepare_acceleration_structures(device, queue, eye, form)
.expect("the device holds a TLAS");
let mut encoder = device.create_command_encoder(&Default::default());
scene.encode_acceleration_structures(&mut encoder);
queue.submit([encoder.finish()]);
scene.finish_frame();
stats
}
fn bind_tlas((device, queue): (&wgpu::Device, &wgpu::Queue), scene: &Scene) {
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("TLAS test"),
entries: &[bind::tlas_entry()],
});
let source =
compose(&[&SCENE_RAYS_QUERY_OPAQUE]) + "@compute @workgroup_size(1) fn bind_tlas() {}\n";
let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("TLAS test"),
source: wgpu::ShaderSource::Wgsl(source.into()),
});
let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some("TLAS test"),
layout: Some(
&device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: None,
bind_group_layouts: &[None, None, None, Some(&layout)],
immediate_size: 0,
}),
),
module: &module,
entry_point: Some("bind_tlas"),
compilation_options: Default::default(),
cache: None,
});
let tlas = scene
.acceleration_structures()
.expect("structures were built")
.tlas()
.0;
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("TLAS test"),
layout: &layout,
entries: &[wgpu::BindGroupEntry {
binding: bind::hardware::SCENE_TLAS,
resource: tlas.as_binding(),
}],
});
let mut encoder = device.create_command_encoder(&Default::default());
{
let mut pass = encoder.begin_compute_pass(&Default::default());
pass.set_pipeline(&pipeline);
pass.set_bind_group(3, &group, &[]);
pass.dispatch_workgroups(1, 1, 1);
}
queue.submit([encoder.finish()]);
}
#[test]
fn one_triangle_builds_and_binds() {
let Some((device, queue)) = test_support::ray_tracing_device(|limits| limits) else {
return;
};
let gpu = (&device, &queue);
let mut scene = Scene::new(&device, &queue);
let model = scene
.add_asset(&device, &queue, asset(vec![triangles(Vec3::ZERO, 1)]))
.unwrap()
.model;
place(gpu, &mut scene, model, Mat4::IDENTITY, Mobility::Static);
let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
let stats = build(gpu, &mut scene, Vec3::Z * 5.);
bind_tlas(gpu, &scene);
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
let error = pollster::block_on(validation.pop());
assert!(error.is_none(), "{error:?}");
assert_eq!(
stats,
RayTracingStats {
hardware: 1,
portable: 0,
left_out: 0,
}
);
let resources = scene.diagnostic_resources();
assert_eq!((resources.blases, resources.blas_triangles), (1, 1));
}
fn with_alpha(mut asset: Asset, alpha: crate::AlphaMode) -> Asset {
asset.materials[0].alpha = alpha;
asset
}
fn held(scene: &Scene) -> Vec<(u32, u8)> {
scene
.acceleration_structures()
.expect("structures were built")
.tlas()
.0
.get()
.iter()
.map_while(|instance| instance.as_ref())
.map(|instance| (instance.custom_data, instance.mask))
.collect()
}
#[test]
fn what_the_device_cannot_hold_is_left_out_and_counted() {
let Some((device, queue)) = test_support::ray_tracing_device(|limits| wgpu::Limits {
max_blas_primitive_count: 4,
max_tlas_instance_count: 2,
..limits
}) else {
return;
};
let gpu = (&device, &queue);
let mut scene = Scene::new(&device, &queue);
let mut dangling = triangles(Vec3::ZERO, 1);
dangling.indices.push(0);
let mut empty = triangles(Vec3::X, 1);
empty.indices.truncate(2);
let small = scene
.add_asset(&device, &queue, asset(vec![dangling, empty]))
.unwrap();
let large = scene
.add_asset(&device, &queue, asset(vec![triangles(Vec3::ZERO, 5)]))
.unwrap()
.model;
let masked = scene
.add_asset(
&device,
&queue,
test_support::masked(test_support::cube(), 0.5),
)
.unwrap()
.model;
let blended = scene
.add_asset(
&device,
&queue,
with_alpha(
test_support::cube(),
crate::AlphaMode::Blend {
receives_screen_space_reflections: false,
},
),
)
.unwrap()
.model;
let at = |z: f32| Mat4::from_translation(Vec3::Z * z);
let near = place(gpu, &mut scene, small.model, at(0.), Mobility::Static);
let middle = place(gpu, &mut scene, small.model, at(-10.), Mobility::Moving);
place(gpu, &mut scene, small.model, at(-20.), Mobility::Static);
place(gpu, &mut scene, large, at(0.), Mobility::Static);
place(gpu, &mut scene, masked, at(0.), Mobility::Static);
place(gpu, &mut scene, blended, at(0.), Mobility::Static);
let hidden = place(gpu, &mut scene, small.model, at(1.), Mobility::Static);
scene
.set_instance(
&queue,
hidden,
InstanceState {
capture_visible: false,
..*scene.instance(hidden).unwrap()
},
)
.unwrap();
let eye = Vec3::Z * 5.;
let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
let stats = build(gpu, &mut scene, eye);
assert_eq!(
stats,
RayTracingStats {
hardware: 2,
portable: 3,
left_out: 2,
}
);
let index = |id: crate::InstanceId| crate::content::identity::Identity::index(id) as u32;
let mut kept = held(&scene);
kept.sort_unstable();
assert_eq!(
kept,
[
(index(near), super::MASK_STATIC),
(index(middle), super::MASK_MOVING)
]
);
bind_tlas(gpu, &scene);
let opaque = scene.material(small.materials[0]).unwrap();
let mask = crate::SurfaceMaterial {
alpha: crate::AlphaMode::Mask { cutoff: 0.5 },
..opaque
};
scene
.set_material(&queue, small.materials[0], mask)
.unwrap();
assert_eq!(
build(gpu, &mut scene, eye),
RayTracingStats {
hardware: 0,
portable: 5,
left_out: 1,
}
);
assert_eq!(scene.diagnostic_resources().blases, 0);
scene
.set_material(&queue, small.materials[0], opaque)
.unwrap();
assert_eq!(build(gpu, &mut scene, eye), stats);
bind_tlas(gpu, &scene);
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
let error = pollster::block_on(validation.pop());
assert!(error.is_none(), "{error:?}");
}
fn realpha(
queue: &wgpu::Queue,
scene: &mut Scene,
material: crate::MaterialId,
alpha: crate::AlphaMode,
) {
let values = scene.material(material).unwrap();
scene
.set_material(queue, material, crate::SurfaceMaterial { alpha, ..values })
.unwrap();
}
#[test]
fn the_candidate_form_holds_masked_models_and_rebuilds_them_when_edited() {
let Some((device, queue)) = test_support::ray_tracing_device(|limits| limits) else {
return;
};
let gpu = (&device, &queue);
let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
let mut scene = Scene::new(&device, &queue);
let edited = scene
.add_asset(&device, &queue, asset(vec![triangles(Vec3::ZERO, 1)]))
.unwrap();
let masked = scene
.add_asset(
&device,
&queue,
test_support::masked(test_support::cube(), 0.5),
)
.unwrap()
.model;
let mut skinned = triangles(Vec3::ZERO, 1);
skinned.deformation.influences = vec![
crate::deformation::Influence {
joints: [0; 4],
weights: [1., 0., 0., 0.],
};
3
];
let skinned = scene
.add_asset(&device, &queue, asset(vec![skinned]))
.unwrap();
let at = |x: f32, z: f32| Mat4::from_translation(Vec3::new(x, 0., z));
place(gpu, &mut scene, edited.model, at(0., -2.), Mobility::Static);
place(gpu, &mut scene, masked, at(3., 0.), Mobility::Static);
let deforming = place(
gpu,
&mut scene,
skinned.model,
at(-3., 0.),
Mobility::Moving,
);
scene
.set_instance_deformation(&queue, deforming, &[Mat4::IDENTITY], &[])
.unwrap();
let eye = Vec3::Z * 5.;
let build = |scene: &mut Scene, form| {
let before = crate::counters::snapshot();
let stats = build_in(gpu, scene, eye, form);
let counted = crate::counters::snapshot().since(&before);
(stats, [counted.blas_builds, counted.deformed_blas_builds])
};
let stats = |hardware, portable| RayTracingStats {
hardware,
portable,
left_out: 0,
};
assert_eq!(
build(&mut scene, RayQueryForm::Candidates),
(stats(3, 0), [2, 1])
);
assert_eq!(
build(&mut scene, RayQueryForm::Candidates),
(stats(3, 0), [0, 0])
);
let mut vertices = triangles(Vec3::ZERO, 1);
let corner = vertices.vertices[0];
vertices
.vertices
.resize(super::blas::MOST_VERTICES_PER_FRAME as usize, corner);
let large = scene
.add_asset(&device, &queue, asset(vec![vertices]))
.unwrap()
.model;
let small = scene
.add_asset(&device, &queue, asset(vec![triangles(Vec3::ZERO, 1)]))
.unwrap()
.model;
place(gpu, &mut scene, large, at(0., 1.), Mobility::Static);
place(gpu, &mut scene, small, at(0., -20.), Mobility::Static);
let mask = crate::AlphaMode::Mask { cutoff: 0.5 };
realpha(&queue, &mut scene, edited.materials[0], mask);
realpha(&queue, &mut scene, skinned.materials[0], mask);
assert_eq!(
build(&mut scene, RayQueryForm::Candidates),
(stats(4, 1), [2, 1])
);
assert_eq!(
build(&mut scene, RayQueryForm::Candidates),
(stats(5, 0), [1, 0])
);
realpha(
&queue,
&mut scene,
edited.materials[0],
crate::AlphaMode::Opaque,
);
assert_eq!(
build(&mut scene, RayQueryForm::Candidates),
(stats(5, 0), [1, 0])
);
realpha(&queue, &mut scene, edited.materials[0], mask);
assert_eq!(
build(&mut scene, RayQueryForm::Candidates),
(stats(5, 0), [1, 0])
);
assert_eq!(
build(&mut scene, RayQueryForm::Baseline),
(stats(3, 2), [0, 1])
);
assert_eq!(scene.diagnostic_resources().blases, 3);
bind_tlas(gpu, &scene);
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
let error = pollster::block_on(validation.pop());
assert!(error.is_none(), "{error:?}");
}
#[test]
fn a_re_pended_model_is_compacted_once() {
let Some((device, queue)) = test_support::ray_tracing_device(|limits| limits) else {
return;
};
let gpu = (&device, &queue);
let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
let mut scene = Scene::new(&device, &queue);
let mut vertices = triangles(Vec3::ZERO, 1);
let corner = vertices.vertices[0];
vertices
.vertices
.resize(super::blas::MOST_VERTICES_PER_FRAME as usize, corner);
let large = scene
.add_asset(&device, &queue, asset(vec![vertices]))
.unwrap()
.model;
place(gpu, &mut scene, large, Mat4::IDENTITY, Mobility::Static);
let eye = Vec3::Z * 5.;
let frame = |scene: &mut Scene| {
let before = crate::counters::snapshot();
build_in(gpu, scene, eye, RayQueryForm::Candidates);
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
let counted = crate::counters::snapshot().since(&before);
[counted.blas_builds, counted.blas_compactions]
};
assert_eq!(frame(&mut scene), [1, 0]);
let edited = scene
.add_asset(&device, &queue, asset(vec![triangles(Vec3::ZERO, 1)]))
.unwrap();
let behind = Mat4::from_translation(Vec3::Z * -2.);
place(gpu, &mut scene, edited.model, behind, Mobility::Static);
assert_eq!(frame(&mut scene), [1, 0]);
let mask = crate::AlphaMode::Mask { cutoff: 0.5 };
realpha(&queue, &mut scene, edited.materials[0], mask);
assert_eq!(frame(&mut scene), [1, 1]);
let mut compactions = 0;
for _ in 0..4 {
let [builds, compacted] = frame(&mut scene);
assert_eq!(builds, 0);
compactions += compacted;
}
assert_eq!(compactions, 1);
bind_tlas(gpu, &scene);
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
let error = pollster::block_on(validation.pop());
assert!(error.is_none(), "{error:?}");
}
fn frame(
(device, queue): (&wgpu::Device, &wgpu::Queue),
(renderer, scene): (&mut crate::Renderer, &mut Scene),
settings: &crate::settings::Settings,
output: &wgpu::TextureView,
abandoned: bool,
) -> RayTracingStats {
let eye = Vec3::new(0., 1., 6.);
let input = crate::FrameInput::new(crate::Camera {
view: glam::camera::rh::view::look_at_mat4(eye, Vec3::ZERO, Vec3::Y),
projection: crate::perspective(1., 1., 0.1),
eye,
});
let mut encoder = device.create_command_encoder(&Default::default());
renderer.render(
device,
queue,
&mut encoder,
scene,
&input,
settings,
output,
None,
);
if !abandoned {
queue.submit([encoder.finish()]);
renderer.finish_frame(scene);
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
}
renderer.ray_tracing_stats()
}
#[test]
fn frames_build_the_structures_after_their_deformations() {
let Some((device, queue)) = test_support::ray_tracing_device(|limits| limits) else {
return;
};
let gpu = (&device, &queue);
let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
let mut scene = Scene::new(&device, &queue);
let opaque = scene
.add_asset(&device, &queue, asset(vec![triangles(Vec3::ZERO, 2)]))
.unwrap()
.model;
place(gpu, &mut scene, opaque, Mat4::IDENTITY, Mobility::Static);
let masked = scene
.add_asset(
&device,
&queue,
test_support::masked(test_support::cube(), 0.5),
)
.unwrap()
.model;
place(
gpu,
&mut scene,
masked,
Mat4::from_translation(Vec3::X * 3.),
Mobility::Static,
);
let mut skinned = triangles(Vec3::ZERO, 1);
skinned.deformation.influences = vec![
crate::deformation::Influence {
joints: [0; 4],
weights: [1., 0., 0., 0.],
};
3
];
let skinned = scene
.add_asset(&device, &queue, asset(vec![skinned]))
.unwrap()
.model;
let deforming = place(
gpu,
&mut scene,
skinned,
Mat4::from_translation(Vec3::X * -3.),
Mobility::Moving,
);
let pose = |scene: &mut Scene, lift: f32| {
scene
.set_instance_deformation(
&queue,
deforming,
&[Mat4::from_translation(Vec3::Y * lift)],
&[],
)
.unwrap();
};
let mut settings = crate::settings::Settings {
screen_space_reflections: crate::settings::ScreenSpaceReflections::Half,
world_space_reflections: crate::settings::WorldSpaceReflections::Moving,
hardware_ray_tracing: true,
..Default::default()
};
let size = [64, 64];
let mut renderer = crate::Renderer::for_test(&device, &queue, size, &settings);
let output = crate::view::targets::target(
&device,
"acceleration structure frames",
size,
crate::shading::gbuffer::COLOR,
);
let frame = |renderer: &mut crate::Renderer,
scene: &mut Scene,
settings: &crate::settings::Settings,
abandoned: bool| {
let before = crate::counters::snapshot();
let stats = frame(gpu, (renderer, scene), settings, &output, abandoned);
(stats, crate::counters::snapshot().since(&before))
};
let counts = |counted: &crate::counters::Counters| {
[
counted.blas_builds,
counted.deformed_blas_builds,
counted.tlas_builds,
]
};
let (models, held) = match RayQueryForm::of_backend(device.adapter_info().backend) {
RayQueryForm::Baseline => (
1,
RayTracingStats {
hardware: 2,
portable: 1,
left_out: 0,
},
),
RayQueryForm::Candidates => (
2,
RayTracingStats {
hardware: 3,
portable: 0,
left_out: 0,
},
),
};
pose(&mut scene, 0.5);
let (stats, counted) = frame(&mut renderer, &mut scene, &settings, false);
assert_eq!(stats, held);
assert_eq!(counts(&counted), [models, 1, 1]);
let mut compactions = 0;
pose(&mut scene, 0.25);
let (_, abandoned) = frame(&mut renderer, &mut scene, &settings, true);
assert_eq!(counts(&abandoned), [0, 1, 1]);
compactions += abandoned.blas_compactions;
let untraced = crate::settings::Settings {
world_space_reflections: crate::settings::WorldSpaceReflections::Off,
..settings
};
let (stats, counted) = frame(&mut renderer, &mut scene, &untraced, false);
assert_eq!(stats, RayTracingStats::default());
assert_eq!(counts(&counted), [0, 0, 0]);
compactions += counted.blas_compactions;
let (stats, counted) = frame(&mut renderer, &mut scene, &settings, false);
assert_eq!(stats, held);
assert_eq!(counts(&counted), [0, 1, 1]);
compactions += counted.blas_compactions;
for _ in 0..6 {
let (stats, counted) = frame(&mut renderer, &mut scene, &settings, false);
assert_eq!(stats, held);
assert_eq!(counts(&counted), [0, 0, 1]);
compactions += counted.blas_compactions;
}
assert_eq!(compactions, models);
settings.hardware_ray_tracing = false;
let (stats, counted) = frame(&mut renderer, &mut scene, &settings, false);
assert_eq!(stats, RayTracingStats::default());
assert_eq!(counts(&counted), [0, 0, 0]);
assert!(scene.acceleration_structures().is_none());
assert_eq!(scene.diagnostic_resources().blases, 0);
settings.hardware_ray_tracing = true;
let (stats, counted) = frame(&mut renderer, &mut scene, &settings, false);
assert_eq!(stats, held);
assert_eq!(counts(&counted), [models, 1, 1]);
bind_tlas(gpu, &scene);
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
let error = pollster::block_on(validation.pop());
assert!(error.is_none(), "{error:?}");
}
#[test]
fn the_renderer_reports_whether_the_hardware_path_traces() {
let settings = crate::settings::Settings {
screen_space_reflections: crate::settings::ScreenSpaceReflections::Half,
world_space_reflections: crate::settings::WorldSpaceReflections::Moving,
hardware_ray_tracing: true,
..Default::default()
};
let devices = [
test_support::device(),
test_support::ray_tracing_device(|limits| limits),
];
for (ray_queries, device) in [false, true].into_iter().zip(devices) {
let Some((device, queue)) = device else {
return;
};
let gpu = (&device, &queue);
let mut scene = Scene::new(&device, &queue);
let model = scene
.add_asset(&device, &queue, asset(vec![triangles(Vec3::ZERO, 1)]))
.unwrap()
.model;
place(gpu, &mut scene, model, Mat4::IDENTITY, Mobility::Static);
let size = [16, 16];
let mut renderer = crate::Renderer::for_test(&device, &queue, size, &settings);
let output = crate::view::targets::target(
&device,
"ray tracing reports",
size,
crate::shading::gbuffer::COLOR,
);
let stats = frame(gpu, (&mut renderer, &mut scene), &settings, &output, false);
assert_eq!(renderer.ray_tracing_in_effect(&settings), ray_queries);
assert_eq!(renderer.ray_tracing_error().is_none(), ray_queries);
assert_eq!(stats.hardware, u32::from(ray_queries));
let off = crate::settings::Settings {
hardware_ray_tracing: false,
..settings
};
frame(gpu, (&mut renderer, &mut scene), &off, &output, false);
assert!(!renderer.ray_tracing_in_effect(&off));
assert!(
renderer.ray_tracing_error().is_none(),
"nothing asked for it"
);
}
}