use super::{
harness::{host, Host, Spec},
scene,
};
use wgpu::TextureFormat as F;
use zaxis::{EmbedViewport, EmbeddedRenderer, SharedResources};
const SIZE: [u32; 2] = [320, 224];
fn first(host: &Host, spec: &Spec) -> EmbeddedRenderer {
EmbeddedRenderer::new_with_adapter(
host.device.clone(),
host.queue.clone(),
&host.adapter,
spec.options(),
)
.unwrap()
}
#[test]
fn siblings_share_pipelines_and_the_atlas_but_not_buffers() {
let Some(host) = host("embedded siblings") else {
return;
};
let spec = Spec::new(F::Bgra8UnormSrgb, SIZE);
let resources = SharedResources::new();
let mut panels: Vec<_> = (0..3)
.map(|n| {
scene::controls_in(
&mut scene::sharing(&resources, SIZE, 1.0),
&format!("Panel {n}"),
)
})
.collect();
let mut renderers = vec![first(&host, &spec)];
for _ in 0..3 {
let sibling = renderers[0].create_sibling(spec.options()).unwrap();
renderers.push(sibling);
}
assert_eq!(renderers[0].shared_pipeline_targets(), 1);
renderers[0]
.prepare(&panels[0], EmbedViewport::whole(SIZE))
.unwrap();
let uploaded = renderers[0].stats();
assert!(uploaded.texture_uploads > 0 && uploaded.geometry_uploads == 1);
for (renderer, data) in renderers[1..].iter_mut().zip(&panels[1..]) {
renderer.prepare(data, EmbedViewport::whole(SIZE)).unwrap();
let stats = renderer.stats();
assert_eq!(stats.texture_creations, 0, "{stats:?}");
assert_eq!(stats.geometry_uploads, 1);
}
assert_eq!(renderers[0].shared_pipeline_targets(), 1);
let wide = Spec::new(F::Rgba16Float, SIZE);
let a = renderers[0].create_sibling(wide.options()).unwrap();
let b = renderers[0].create_sibling(wide.options()).unwrap();
assert_eq!(a.shared_pipeline_targets(), 2);
drop((a, b));
panels.swap(0, 1);
renderers[1]
.prepare(&panels[0], EmbedViewport::whole(SIZE))
.unwrap();
assert_eq!(renderers[0].stats().geometry_uploads, 1);
}
#[test]
fn preparing_an_unchanged_frame_uploads_nothing() {
let Some(host) = host("embedded revisions") else {
return;
};
let spec = Spec::new(F::Bgra8UnormSrgb, SIZE);
let data = scene::controls(SIZE, 1.0);
let mut embed = first(&host, &spec);
for _ in 0..4 {
embed.prepare(&data, EmbedViewport::whole(SIZE)).unwrap();
host.in_pass(&spec, true, |pass| {
embed.record(pass).unwrap();
});
}
let stats = embed.stats();
assert_eq!(stats.geometry_uploads, 1);
assert_eq!(stats.texture_creations, data.textures.len() as u64);
assert_eq!(stats.texture_reuploads, 0);
assert_eq!(stats.presented_frames, 4);
assert!(stats.draw_calls >= 4);
}
#[test]
fn backdrop_targets_are_released_on_request_and_on_drop() {
let Some(host) = host("embedded release") else {
return;
};
let Some(before) = host.device.generate_allocator_report() else {
eprintln!("SKIPPED release: the backend reports no allocations");
return;
};
let spec = Spec::new(F::Rgba8UnormSrgb, SIZE);
let data = scene::blur_panel(
SIZE,
1.0,
zaxis::Rect::from_min_size(zaxis::vec2(20.0, 20.0), zaxis::vec2(200.0, 150.0)),
12.0,
);
let mut embed = first(&host, &spec);
host.frame(
&spec,
true,
wgpu::TextureUsages::empty(),
|encoder, target| {
embed
.render_to(encoder, &target.view, None, zaxis::EmbedLoad::Keep, &data)
.unwrap();
},
);
assert!(embed.stats().blur_target_bytes > 0);
embed.release_targets();
assert_eq!(embed.stats().blur_target_bytes, 0);
drop(embed);
host.device
.poll(wgpu::PollType::wait_indefinitely())
.unwrap();
let after = host.device.generate_allocator_report().unwrap();
assert!(
after.total_allocated_bytes <= before.total_allocated_bytes + (4 << 20),
"{} bytes before, {} after",
before.total_allocated_bytes,
after.total_allocated_bytes
);
}