use std::rc::Rc;
use std::sync::Mutex;
use three_rs::nodes::tsl::{instanced_array, uint, vec3, StorageArray};
use three_rs::nodes::{ComputeFlow, NodeRef, Type};
use three_rs::{
plane_geometry, Mesh, MeshBasicNodeMaterial, ObjectRef, OrthographicCamera, Renderer,
RendererParameters, Scene,
};
const GRACE: usize = 4;
static GPU: Mutex<()> = Mutex::new(());
fn gpu() -> std::sync::MutexGuard<'static, ()> {
GPU.lock().unwrap_or_else(|poisoned| poisoned.into_inner())
}
fn renderer() -> Renderer {
let mut renderer =
Renderer::new(RendererParameters::default()).expect("a wgpu adapter and device");
renderer.set_pixel_ratio(1.0);
renderer.set_size(32.0, 32.0);
renderer
}
fn camera() -> OrthographicCamera {
let mut camera = OrthographicCamera::new(-1.0, 1.0, 1.0, -1.0, 0.1, 100.0);
camera.object.position.z = 10.0;
camera.update_matrix_world();
camera
}
fn plane(color: NodeRef) -> ObjectRef {
let mut material = MeshBasicNodeMaterial::new();
material.color_node = Some(color);
Mesh::new(Rc::new(plane_geometry(2.0, 2.0, 1, 1)), material)
}
fn set_color_node(mesh: &ObjectRef, node: NodeRef) {
let mut object = mesh.borrow_mut();
let material = object
.mesh_mut()
.and_then(|mesh| mesh.material.as_mut())
.expect("three-rs: the plane has a material");
material.color_node = Some(node);
material.set_needs_update();
}
fn centre(renderer: &mut Renderer) -> [u8; 3] {
let (w, h, pixels) = renderer.read_canvas_pixels().unwrap();
let at = ((h as usize / 2) * w as usize + w as usize / 2) * 4;
[pixels[at], pixels[at + 1], pixels[at + 2]]
}
#[track_caller]
fn assert_memory_counts(renderer: &Renderer) {
let (programs, _, _, compute_pipelines) = renderer.program_cache_lens();
assert_eq!(
renderer.info().memory.programs,
programs + compute_pipelines,
"info.memory.programs counts the render programs and compute pipelines"
);
}
fn increment(out: &StorageArray) -> ComputeFlow {
ComputeFlow::new(
vec![out
.element(uint(0))
.assign(out.element(uint(0)).add(uint(1)))],
1,
)
}
#[test]
fn editing_a_material_graph_does_not_grow_the_program_cache() {
const FRAMES: usize = 40;
let _gpu = gpu();
let mut renderer = renderer();
let mut camera = camera();
let mesh = plane(vec3(1.0, 0.0, 0.0));
let mut scene = Scene::new();
scene.add(&mesh);
renderer.render(&mut scene, &mut camera);
assert_eq!(centre(&mut renderer), [255, 0, 0]);
let first = renderer.program_cache_lens();
let mut lens = Vec::with_capacity(FRAMES);
for frame in 1..=FRAMES {
set_color_node(&mesh, vec3(0.0, frame as f64 / FRAMES as f64, 1.0));
renderer.render(&mut scene, &mut camera);
assert_eq!(
renderer.info().build.programs_compiled,
1,
"frame {frame}: an edited graph is one build"
);
assert_memory_counts(&renderer);
lens.push(renderer.program_cache_lens());
}
println!(
"edits: (programs, pipelines, compute programs, compute pipelines) frame 0 {first:?}, \
frame {} {:?}, frame {FRAMES} {:?}",
2 * GRACE,
lens[2 * GRACE - 1],
lens[FRAMES - 1]
);
let (programs, pipelines, _, _) = lens[FRAMES - 1];
assert_eq!(
lens[FRAMES - 1],
lens[2 * GRACE - 1],
"the program caches were still growing after {FRAMES} edits"
);
assert!(
programs <= first.0 + GRACE + 1 && pipelines <= first.1 + GRACE + 1,
"{FRAMES} edits left {programs} programs and {pipelines} pipelines, \
against {first:?} after one frame"
);
set_color_node(&mesh, vec3(1.0, 0.0, 0.0));
renderer.render(&mut scene, &mut camera);
assert_eq!(renderer.info().build.pipelines_built, 1);
assert_eq!(
centre(&mut renderer),
[255, 0, 0],
"the rebuilt first variant draws red"
);
}
#[test]
fn a_material_toggled_between_two_graphs_keeps_both_programs() {
let _gpu = gpu();
let mut renderer = renderer();
let mut camera = camera();
let red = vec3(1.0, 0.0, 0.0);
let blue = vec3(0.0, 0.0, 1.0);
let mesh = plane(red.clone());
let mut scene = Scene::new();
scene.add(&mesh);
renderer.render(&mut scene, &mut camera);
set_color_node(&mesh, blue.clone());
renderer.render(&mut scene, &mut camera);
let settled = renderer.program_cache_lens();
for frame in 0..4 * GRACE {
let (node, want) = if frame % 2 == 0 {
(red.clone(), [255, 0, 0])
} else {
(blue.clone(), [0, 0, 255])
};
set_color_node(&mesh, node);
renderer.render(&mut scene, &mut camera);
assert_eq!(
renderer.info().build.pipelines_built,
0,
"toggle {frame}: the program and pipeline were evicted and rebuilt"
);
assert_eq!(renderer.program_cache_lens(), settled, "toggle {frame}");
assert_eq!(centre(&mut renderer), want, "toggle {frame}");
}
}
#[test]
fn a_fresh_kernel_every_frame_does_not_grow_the_compute_cache() {
const FRAMES: usize = 30;
let _gpu = gpu();
let mut renderer = renderer();
renderer.info_mut().auto_reset = false;
let mut camera = camera();
let mut empty = Scene::new();
let out = instanced_array(1, Type::U32);
let mut built_after_first = 0;
for frame in 0..FRAMES {
renderer.compute(&increment(&out)).unwrap();
renderer.render(&mut empty, &mut camera);
let (_, _, compute_programs, compute_pipelines) = renderer.program_cache_lens();
assert_eq!(
(compute_programs, compute_pipelines),
(0, 1),
"frame {frame}: the dropped kernel's entry should be swept, its pipeline kept"
);
assert_memory_counts(&renderer);
if frame == 0 {
built_after_first = renderer.info().build.pipelines_built;
}
}
assert_eq!(
renderer.info().build.pipelines_built,
built_after_first,
"a kernel rebuilt with the same WGSL every frame recompiled its pipeline"
);
assert_eq!(
renderer.read_storage_buffer_u32(&out).unwrap(),
vec![FRAMES as u32],
"every frame's kernel ran"
);
}
#[test]
fn a_new_kernel_shape_every_frame_keeps_only_recent_pipelines() {
const FRAMES: usize = 30;
let _gpu = gpu();
let mut renderer = renderer();
let mut camera = camera();
let mut empty = Scene::new();
let out = instanced_array(1, Type::U32);
let mut lens = Vec::with_capacity(FRAMES);
for frame in 0..FRAMES {
let kernel = ComputeFlow::new(vec![out.element(uint(0)).assign(uint(frame as u32 + 1))], 1);
renderer.compute(&kernel).unwrap();
drop(kernel);
renderer.render(&mut empty, &mut camera);
assert_memory_counts(&renderer);
lens.push(renderer.program_cache_lens());
}
println!(
"kernel shapes: (programs, pipelines, compute programs, compute pipelines) \
frame {} {:?}, frame {FRAMES} {:?}",
2 * GRACE,
lens[2 * GRACE - 1],
lens[FRAMES - 1]
);
let (_, _, compute_programs, compute_pipelines) = lens[FRAMES - 1];
assert_eq!(compute_programs, 0);
assert!(
compute_pipelines <= GRACE + 1,
"{FRAMES} kernel shapes left {compute_pipelines} compute pipelines"
);
assert_eq!(lens[FRAMES - 1], lens[2 * GRACE - 1]);
assert_eq!(
renderer.read_storage_buffer_u32(&out).unwrap(),
vec![FRAMES as u32]
);
}
#[test]
fn an_idle_live_kernel_keeps_its_pipeline_and_does_not_reinit() {
let _gpu = gpu();
let mut renderer = renderer();
let mut camera = camera();
let mut empty = Scene::new();
let out = instanced_array(1, Type::U32);
let mut kernel = increment(&out);
kernel.on_init = Some(Box::new(ComputeFlow::new(
vec![out.element(uint(0)).assign(uint(100))],
1,
)));
renderer.compute(&kernel).unwrap();
assert_eq!(renderer.read_storage_buffer_u32(&out).unwrap(), vec![101]);
for _ in 0..3 * GRACE {
renderer.render(&mut empty, &mut camera);
}
let (_, _, compute_programs, compute_pipelines) = renderer.program_cache_lens();
assert_eq!(
(compute_programs, compute_pipelines),
(2, 2),
"the live kernel and its onInit keep their entries while idle"
);
renderer.compute(&kernel).unwrap();
assert_eq!(
renderer.read_storage_buffer_u32(&out).unwrap(),
vec![102],
"onInit ran again after the kernel sat idle"
);
drop(kernel);
for _ in 0..GRACE + 2 {
renderer.render(&mut empty, &mut camera);
}
let (_, _, compute_programs, compute_pipelines) = renderer.program_cache_lens();
assert_eq!((compute_programs, compute_pipelines), (0, 0));
assert_memory_counts(&renderer);
}
#[test]
fn compute_without_render_does_not_grow_the_compute_cache() {
const KERNELS: usize = 50;
let _gpu = gpu();
let mut renderer = renderer();
let out = instanced_array(1, Type::U32);
for _ in 0..KERNELS {
renderer.compute(&increment(&out)).unwrap();
let (_, _, compute_programs, compute_pipelines) = renderer.program_cache_lens();
assert_eq!((compute_programs, compute_pipelines), (1, 1));
}
assert_eq!(
renderer.read_storage_buffer_u32(&out).unwrap(),
vec![KERNELS as u32]
);
}