use std::path::Path;
use crate::assets::{Assets, Handle, Texture};
use crate::canvas::camera::Camera;
use crate::canvas::draw::DrawList;
use crate::canvas::gpu::{Context, Frame, Gpu};
use crate::canvas::letterbox::fit_fractional;
use crate::canvas::light::{LightFrame, LightPass};
use crate::canvas::sprite::{MASK_FORMAT, NORMAL_FORMAT, SpritePass};
use crate::canvas::{LightingSpace, linear_to_srgb, srgb_to_linear};
pub const SCENE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
pub const LINEAR_ALBEDO_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
fn albedo_format(space: LightingSpace) -> wgpu::TextureFormat {
match space {
LightingSpace::Gamma => SCENE_FORMAT,
LightingSpace::Linear => LINEAR_ALBEDO_FORMAT,
}
}
#[must_use]
pub fn composite_linear(albedo: [f32; 3], modulate: [f32; 3], accum: [f32; 3]) -> [f32; 3] {
let mut out = [0.0; 3];
for i in 0..3 {
let combined = (albedo[i] * (modulate[i] + accum[i])).clamp(0.0, 1.0);
out[i] = linear_to_srgb(combined);
}
out
}
pub struct Renderer {
logical_width: u32,
logical_height: u32,
max_texture_dim: u32,
ui_scale: f32,
lighting_space: LightingSpace,
clear_color: wgpu::Color,
albedo_view: wgpu::TextureView,
normal_view: wgpu::TextureView,
mask_view: wgpu::TextureView,
composited_texture: wgpu::Texture,
composited_view: wgpu::TextureView,
sprites: SpritePass,
lights: LightPass,
composite: CompositePass,
blit_pipeline: wgpu::RenderPipeline,
blit_bgl: wgpu::BindGroupLayout,
blit_sampler: wgpu::Sampler,
blit_bind_group: wgpu::BindGroup,
}
struct SceneTargets {
albedo_view: wgpu::TextureView,
normal_view: wgpu::TextureView,
mask_view: wgpu::TextureView,
composited_texture: wgpu::Texture,
composited_view: wgpu::TextureView,
}
fn scene_targets(
device: &wgpu::Device,
width: u32,
height: u32,
space: LightingSpace,
) -> SceneTargets {
let target = |label: &str, format: wgpu::TextureFormat, extra: wgpu::TextureUsages| {
device.create_texture(&wgpu::TextureDescriptor {
label: Some(label),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT
| wgpu::TextureUsages::TEXTURE_BINDING
| extra,
view_formats: &[],
})
};
let none = wgpu::TextureUsages::empty();
let albedo_view = target("scene albedo target", albedo_format(space), none)
.create_view(&wgpu::TextureViewDescriptor::default());
let normal_view = target("scene normal target", NORMAL_FORMAT, none)
.create_view(&wgpu::TextureViewDescriptor::default());
let mask_view = target("scene light-mask target", MASK_FORMAT, none)
.create_view(&wgpu::TextureViewDescriptor::default());
let composited_texture = target(
"composited target (sRGB-encoded)",
SCENE_FORMAT,
wgpu::TextureUsages::COPY_SRC,
);
let composited_view = composited_texture.create_view(&wgpu::TextureViewDescriptor::default());
SceneTargets {
albedo_view,
normal_view,
mask_view,
composited_texture,
composited_view,
}
}
#[derive(Debug)]
pub enum CaptureError {
Readback(String),
Encode(image::ImageError),
}
impl std::fmt::Display for CaptureError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Readback(msg) => write!(f, "scene readback: {msg}"),
Self::Encode(e) => write!(f, "png encode: {e}"),
}
}
}
impl std::error::Error for CaptureError {}
struct CompositePass {
pipeline: wgpu::RenderPipeline,
uniform: wgpu::Buffer,
bgl: wgpu::BindGroupLayout,
bind_group: wgpu::BindGroup,
}
fn composite_bind_group(
device: &wgpu::Device,
layout: &wgpu::BindGroupLayout,
uniform: &wgpu::Buffer,
albedo_view: &wgpu::TextureView,
accum_view: &wgpu::TextureView,
) -> wgpu::BindGroup {
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("composite bind group"),
layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: uniform.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(albedo_view),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::TextureView(accum_view),
},
],
})
}
impl CompositePass {
fn new(
device: &wgpu::Device,
space: LightingSpace,
albedo_view: &wgpu::TextureView,
accum_view: &wgpu::TextureView,
) -> Self {
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("composite shader"),
source: wgpu::ShaderSource::Wgsl(include_str!("composite.wgsl").into()),
});
let uniform = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("composite uniform"),
size: size_of::<[f32; 4]>() as u64,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let tex_entry = |binding: u32| wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
};
let bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("composite bgl"),
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
},
tex_entry(1),
tex_entry(2),
],
});
let bind_group = composite_bind_group(device, &bgl, &uniform, albedo_view, accum_view);
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("composite pipeline layout"),
bind_group_layouts: &[Some(&bgl)],
immediate_size: 0,
});
let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("composite pipeline"),
layout: Some(&layout),
vertex: wgpu::VertexState {
module: &shader,
entry_point: Some("vs_main"),
buffers: &[],
compilation_options: Default::default(),
},
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: Some(match space {
LightingSpace::Gamma => "fs_main",
LightingSpace::Linear => "fs_main_linear",
}),
targets: &[Some(wgpu::ColorTargetState {
format: SCENE_FORMAT,
blend: None,
write_mask: wgpu::ColorWrites::ALL,
})],
compilation_options: Default::default(),
}),
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
..Default::default()
},
depth_stencil: None,
multisample: wgpu::MultisampleState::default(),
multiview_mask: None,
cache: None,
});
Self {
pipeline,
uniform,
bgl,
bind_group,
}
}
fn rebind(
&mut self,
device: &wgpu::Device,
albedo_view: &wgpu::TextureView,
accum_view: &wgpu::TextureView,
) {
self.bind_group =
composite_bind_group(device, &self.bgl, &self.uniform, albedo_view, accum_view);
}
fn set_modulate(&self, queue: &wgpu::Queue, modulate: [f32; 4]) {
queue.write_buffer(&self.uniform, 0, bytemuck::cast_slice(&modulate));
}
fn run(&self, encoder: &mut wgpu::CommandEncoder, target: &wgpu::TextureView) {
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("composite pass"),
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: target,
resolve_target: None,
depth_slice: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
store: wgpu::StoreOp::Store,
},
})],
depth_stencil_attachment: None,
timestamp_writes: None,
occlusion_query_set: None,
multiview_mask: None,
});
pass.set_pipeline(&self.pipeline);
pass.set_bind_group(0, &self.bind_group, &[]);
pass.draw(0..3, 0..1);
}
}
const MAX_TARGET_AREA: u64 = 4096 * 4096;
fn clamp_target_size(width: u32, height: u32, max_dim: u32) -> (u32, u32) {
let (mut width, mut height) = (width.max(1), height.max(1));
let area = u64::from(width) * u64::from(height);
if area > MAX_TARGET_AREA {
let scale = ((MAX_TARGET_AREA as f64) / (area as f64)).sqrt();
width = ((f64::from(width) * scale) as u32).max(1);
height = ((f64::from(height) * scale) as u32).max(1);
}
let max_dim = max_dim.max(1);
(width.min(max_dim), height.min(max_dim))
}
impl Renderer {
pub fn new(
ctx: &Context,
logical_width: u32,
logical_height: u32,
clear_color_srgb: [f32; 3],
) -> Self {
Self::with_lighting(
ctx,
logical_width,
logical_height,
clear_color_srgb,
LightingSpace::Gamma,
)
}
pub fn with_lighting(
ctx: &Context,
logical_width: u32,
logical_height: u32,
clear_color_srgb: [f32; 3],
lighting_space: LightingSpace,
) -> Self {
Self::build(
ctx,
ctx.surface_format,
logical_width,
logical_height,
clear_color_srgb,
lighting_space,
)
}
pub fn headless(
gpu: &Gpu,
logical_width: u32,
logical_height: u32,
clear_color_srgb: [f32; 3],
lighting_space: LightingSpace,
) -> Self {
Self::build(
gpu,
wgpu::TextureFormat::Bgra8UnormSrgb,
logical_width,
logical_height,
clear_color_srgb,
lighting_space,
)
}
fn build(
gpu: &Gpu,
surface_format: wgpu::TextureFormat,
logical_width: u32,
logical_height: u32,
clear_color_srgb: [f32; 3],
lighting_space: LightingSpace,
) -> Self {
let device = &gpu.device;
let targets = scene_targets(device, logical_width, logical_height, lighting_space);
let SceneTargets {
albedo_view,
normal_view,
mask_view,
composited_texture,
composited_view,
} = targets;
let sprites = SpritePass::new(
device,
&gpu.queue,
albedo_format(lighting_space),
SCENE_FORMAT,
lighting_space,
);
let lights = LightPass::new(
device,
&gpu.queue,
&normal_view,
&mask_view,
logical_width,
logical_height,
);
let composite =
CompositePass::new(device, lighting_space, &albedo_view, lights.accum_view());
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("blit shader"),
source: wgpu::ShaderSource::Wgsl(include_str!("blit.wgsl").into()),
});
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("blit sampler (nearest)"),
mag_filter: wgpu::FilterMode::Nearest,
min_filter: wgpu::FilterMode::Nearest,
mipmap_filter: wgpu::MipmapFilterMode::Nearest,
..Default::default()
});
let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("blit bgl"),
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
count: None,
},
],
});
let blit_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("blit bind group"),
layout: &bind_group_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(&composited_view),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Sampler(&sampler),
},
],
});
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("blit pipeline layout"),
bind_group_layouts: &[Some(&bind_group_layout)],
immediate_size: 0,
});
let blit_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("blit pipeline"),
layout: Some(&layout),
vertex: wgpu::VertexState {
module: &shader,
entry_point: Some("vs_main"),
buffers: &[],
compilation_options: Default::default(),
},
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: Some(if surface_format.is_srgb() {
"fs_main"
} else {
"fs_main_unorm"
}),
targets: &[Some(wgpu::ColorTargetState {
format: surface_format,
blend: None,
write_mask: wgpu::ColorWrites::ALL,
})],
compilation_options: Default::default(),
}),
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
..Default::default()
},
depth_stencil: None,
multisample: wgpu::MultisampleState::default(),
multiview_mask: None,
cache: None,
});
let channel = |c: f32| match lighting_space {
LightingSpace::Gamma => f64::from(c),
LightingSpace::Linear => f64::from(srgb_to_linear(c)),
};
Self {
logical_width,
logical_height,
max_texture_dim: device.limits().max_texture_dimension_2d,
ui_scale: 1.0,
lighting_space,
clear_color: wgpu::Color {
r: channel(clear_color_srgb[0]),
g: channel(clear_color_srgb[1]),
b: channel(clear_color_srgb[2]),
a: 1.0,
},
albedo_view,
normal_view,
mask_view,
composited_texture,
composited_view,
sprites,
lights,
composite,
blit_pipeline,
blit_bgl: bind_group_layout,
blit_sampler: sampler,
blit_bind_group,
}
}
pub fn lighting_space(&self) -> LightingSpace {
self.lighting_space
}
pub fn scene_view(&self) -> &wgpu::TextureView {
&self.composited_view
}
pub fn target_size(&self) -> (u32, u32) {
(self.logical_width, self.logical_height)
}
pub fn set_target_size(&mut self, gpu: &Gpu, width: u32, height: u32) {
let (width, height) = clamp_target_size(width, height, self.max_texture_dim);
if (width, height) == (self.logical_width, self.logical_height) {
return;
}
let device = &gpu.device;
let targets = scene_targets(device, width, height, self.lighting_space);
self.lights.resize(
device,
&targets.normal_view,
&targets.mask_view,
width,
height,
);
self.composite
.rebind(device, &targets.albedo_view, self.lights.accum_view());
self.blit_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("blit bind group"),
layout: &self.blit_bgl,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(&targets.composited_view),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Sampler(&self.blit_sampler),
},
],
});
self.albedo_view = targets.albedo_view;
self.normal_view = targets.normal_view;
self.mask_view = targets.mask_view;
self.composited_texture = targets.composited_texture;
self.composited_view = targets.composited_view;
self.logical_width = width;
self.logical_height = height;
}
pub fn set_ui_scale(&mut self, scale: f32) {
self.ui_scale = scale.max(0.25);
}
pub fn upload_texture(&mut self, gpu: &Gpu, handle: Handle<Texture>, tex: &Texture) {
if self.sprites.has_texture(handle) {
self.sprites.replace(&gpu.device, &gpu.queue, handle, tex);
} else {
self.sprites.upload(&gpu.device, &gpu.queue, handle, tex);
}
}
pub fn replace_texture(&mut self, gpu: &Gpu, handle: Handle<Texture>, tex: &Texture) -> bool {
self.sprites.replace(&gpu.device, &gpu.queue, handle, tex)
}
pub fn white_texture(&mut self, gpu: &Gpu, assets: &mut Assets<Texture>) -> Handle<Texture> {
let handle = crate::assets::white_texture(assets);
if let Some(tex) = assets.get(handle) {
self.sprites.upload(&gpu.device, &gpu.queue, handle, tex);
}
handle
}
pub fn upload_normal_map(
&mut self,
gpu: &Gpu,
diffuse: Handle<Texture>,
normal: Handle<Texture>,
tex: &Texture,
) {
self.sprites
.upload_normal(&gpu.device, &gpu.queue, diffuse, normal, tex);
}
pub fn upload_light_cookie(&mut self, gpu: &Gpu, handle: Handle<Texture>, tex: &Texture) {
self.lights
.upload_cookie(&gpu.device, &gpu.queue, handle, tex);
}
pub fn render(&mut self, ctx: &Context, frame: &Frame, list: &mut DrawList, camera: &Camera) {
self.render_lit(ctx, Some(frame), list, camera, &LightFrame::default());
}
pub fn render_lit(
&mut self,
ctx: &Context,
frame: Option<&Frame>,
list: &mut DrawList,
camera: &Camera,
lighting: &LightFrame,
) {
let mut encoder = ctx
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("frame encoder"),
});
self.encode_scene(ctx, &mut encoder, list, camera, lighting);
let (win_w, win_h) = ctx.size();
let letterbox = fit_fractional(win_w, win_h, self.logical_width, self.logical_height);
if let Some(frame) = frame {
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("letterbox blit pass"),
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
depth_slice: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
store: wgpu::StoreOp::Store,
},
})],
depth_stencil_attachment: None,
timestamp_writes: None,
occlusion_query_set: None,
multiview_mask: None,
});
pass.set_viewport(
letterbox.x,
letterbox.y,
letterbox.width,
letterbox.height,
0.0,
1.0,
);
pass.set_pipeline(&self.blit_pipeline);
pass.set_bind_group(0, &self.blit_bind_group, &[]);
pass.draw(0..3, 0..1);
}
ctx.queue.submit(Some(encoder.finish()));
}
pub fn render_scene(
&mut self,
gpu: &Gpu,
list: &mut DrawList,
camera: &Camera,
lighting: &LightFrame,
) {
let mut encoder = gpu
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("scene encoder"),
});
self.encode_scene(gpu, &mut encoder, list, camera, lighting);
gpu.queue.submit(Some(encoder.finish()));
}
fn encode_scene(
&mut self,
gpu: &Gpu,
encoder: &mut wgpu::CommandEncoder,
list: &mut DrawList,
camera: &Camera,
lighting: &LightFrame,
) {
list.sort();
let world_vp = camera.view_proj();
let screen_vp = Camera::screen_view_proj_size(glam::Vec2::new(
self.logical_width as f32 / self.ui_scale,
self.logical_height as f32 / self.ui_scale,
));
let world_units = camera.units();
self.sprites.prepare(
&gpu.device,
&gpu.queue,
list,
world_vp,
world_units,
screen_vp,
(self.logical_width, self.logical_height),
self.ui_scale,
);
self.lights.prepare(
&gpu.device,
&gpu.queue,
world_vp,
world_units,
lighting,
(self.logical_width, self.logical_height),
);
self.composite
.set_modulate(&gpu.queue, lighting.canvas_modulate);
{
fn attachment(
view: &wgpu::TextureView,
clear: wgpu::Color,
) -> wgpu::RenderPassColorAttachment<'_> {
wgpu::RenderPassColorAttachment {
view,
resolve_target: None,
depth_slice: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(clear),
store: wgpu::StoreOp::Store,
},
}
}
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("scene pass (MRT)"),
color_attachments: &[
Some(attachment(&self.albedo_view, self.clear_color)),
Some(attachment(
&self.normal_view,
wgpu::Color {
r: 0.5,
g: 0.5,
b: 1.0,
a: 0.0,
},
)),
Some(attachment(&self.mask_view, wgpu::Color::TRANSPARENT)),
],
depth_stencil_attachment: None,
timestamp_writes: None,
occlusion_query_set: None,
multiview_mask: None,
});
self.sprites.draw_world(&mut pass);
}
self.lights.run(encoder);
self.composite.run(encoder, &self.composited_view);
{
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("screen sprite pass"),
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: &self.composited_view,
resolve_target: None,
depth_slice: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Load,
store: wgpu::StoreOp::Store,
},
})],
depth_stencil_attachment: None,
timestamp_writes: None,
occlusion_query_set: None,
multiview_mask: None,
});
self.sprites.draw_screen(&mut pass);
}
}
pub fn read_scene(&self, gpu: &Gpu) -> Result<Vec<u8>, CaptureError> {
let (w, h) = (self.logical_width, self.logical_height);
let unpadded = 4 * w;
let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT; let padded = unpadded.div_ceil(align) * align;
let buffer = gpu.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("scene capture buffer"),
size: u64::from(padded) * u64::from(h),
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
});
let mut encoder = gpu
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("scene capture encoder"),
});
encoder.copy_texture_to_buffer(
wgpu::TexelCopyTextureInfo {
texture: &self.composited_texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
aspect: wgpu::TextureAspect::All,
},
wgpu::TexelCopyBufferInfo {
buffer: &buffer,
layout: wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(padded),
rows_per_image: Some(h),
},
},
wgpu::Extent3d {
width: w,
height: h,
depth_or_array_layers: 1,
},
);
gpu.queue.submit(Some(encoder.finish()));
let (tx, rx) = std::sync::mpsc::channel();
buffer.slice(..).map_async(wgpu::MapMode::Read, move |r| {
let _ = tx.send(r);
});
gpu.device
.poll(wgpu::PollType::wait_indefinitely())
.map_err(|e| CaptureError::Readback(format!("poll: {e}")))?;
rx.recv()
.map_err(|_| CaptureError::Readback("map callback dropped".into()))?
.map_err(|e| CaptureError::Readback(format!("map: {e}")))?;
let data = buffer
.slice(..)
.get_mapped_range()
.expect("mapped readback buffer");
let mut pixels = Vec::with_capacity((unpadded * h) as usize);
for row in 0..h {
let start = (row * padded) as usize;
for px in data[start..start + unpadded as usize].chunks_exact(4) {
pixels.extend_from_slice(&[px[0], px[1], px[2], 255]);
}
}
drop(data);
buffer.unmap();
Ok(pixels)
}
pub fn capture_scene(&self, gpu: &Gpu, path: &Path) -> Result<(), CaptureError> {
let (w, h) = (self.logical_width, self.logical_height);
let pixels = self.read_scene(gpu)?;
image::save_buffer(path, &pixels, w, h, image::ExtendedColorType::Rgba8)
.map_err(CaptureError::Encode)
}
#[cfg(all(test, not(target_arch = "wasm32")))]
pub(crate) fn resource_stats(&self) -> ResourceStats {
ResourceStats {
instance_capacity: self.sprites.instance_capacity(),
sprite_pages: self.sprites.page_count(),
shadow_capacity: self.lights.shadow_capacity(),
}
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct ResourceStats {
pub instance_capacity: u64,
pub sprite_pages: usize,
pub shadow_capacity: u64,
}
#[cfg(test)]
mod tests {
use super::*;
use wasm_bindgen_test::wasm_bindgen_test;
#[wasm_bindgen_test(unsupported = test)]
fn clamp_target_size_passes_real_surfaces_through() {
for (w, h) in [
(960, 540),
(1920, 1080),
(2560, 1440),
(3840, 2160),
(5120, 2880), ] {
assert_eq!(clamp_target_size(w, h, 8192), (w, h), "{w}x{h}");
}
}
#[wasm_bindgen_test(unsupported = test)]
fn clamp_target_size_scales_down_above_the_area_budget() {
let (w, h) = clamp_target_size(7680, 4320, 16_384);
let area = u64::from(w) * u64::from(h);
assert!(area <= MAX_TARGET_AREA, "area over budget: {area}");
assert!(
area > MAX_TARGET_AREA * 95 / 100,
"scaled far below the budget: {area}"
);
let aspect = f64::from(w) / f64::from(h);
assert!(
(aspect - 16.0 / 9.0).abs() < 0.01,
"aspect not preserved: {aspect}"
);
}
#[wasm_bindgen_test(unsupported = test)]
fn clamp_target_size_respects_the_device_dimension_limit() {
assert_eq!(clamp_target_size(20_000, 100, 8192), (8192, 100));
assert_eq!(clamp_target_size(100, 20_000, 8192), (100, 8192));
}
#[wasm_bindgen_test(unsupported = test)]
fn clamp_target_size_never_returns_zero() {
assert_eq!(clamp_target_size(0, 0, 8192), (1, 1));
assert_eq!(clamp_target_size(0, 540, 8192), (1, 540));
let (w, h) = clamp_target_size(960, 540, 0);
assert!(w >= 1 && h >= 1);
}
#[wasm_bindgen_test(unsupported = test)]
fn composite_linear_matches_hand_values() {
let [r, _, _] = composite_linear([0.5; 3], [1.0; 3], [0.0; 3]);
assert!((r - 0.735_357).abs() < 1e-4, "{r}");
let [r, _, _] = composite_linear([0.5; 3], [0.2; 3], [0.3; 3]);
assert!((r - 0.537_099).abs() < 1e-4, "{r}");
let [r, _, _] = composite_linear([1.0; 3], [0.254_131 * 0.003; 3], [0.0; 3]);
assert!((r - 0.009_850).abs() < 1e-5, "{r}");
let white = composite_linear([1.0; 3], [1.0; 3], [5.0; 3]);
assert!(
white.iter().all(|c| (c - 1.0).abs() < 1e-6),
"clamps to white: {white:?}"
);
assert_eq!(
composite_linear([0.5; 3], [-1.0; 3], [0.0; 3]),
[0.0; 3],
"clamps to black"
);
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod gpu_tests {
use super::*;
use crate::assets::Assets;
use crate::canvas::draw::SpriteInstance;
use crate::canvas::light::ACCUM_FORMAT;
use crate::canvas::light::PointLight;
use crate::canvas::sprite::MAX_ATLAS_DIM;
use crate::canvas::test_gpu::{device, gpu, read_texture};
use glam::Vec2;
use std::path::PathBuf;
use wgpu::util::DeviceExt;
fn flat(size: u32, rgba: [u8; 4]) -> Texture {
Texture {
width: size,
height: size,
rgba: rgba.repeat((size * size) as usize),
}
}
#[test]
fn allocations_persist_across_frames_and_grow_only_when_exceeded() {
let Some(gpu) = gpu() else { return };
let mut renderer = Renderer::headless(&gpu, 32, 32, [0.0; 3], LightingSpace::Gamma);
let mut assets: Assets<Texture> = Assets::new();
let white = renderer.white_texture(&gpu, &mut assets);
let camera = Camera::new(32, 32);
let frame = |sprites: usize| {
let mut list = DrawList::new();
for i in 0..sprites {
list.push(SpriteInstance::new(white, Vec2::new((i % 32) as f32, 8.0)));
}
list
};
let lighting = LightFrame {
lights: vec![PointLight {
shadows: true,
..PointLight::analytic(Vec2::new(16.0, 16.0), 20.0, 1.0)
}],
occluders: vec![vec![
Vec2::new(10.0, 20.0),
Vec2::new(14.0, 20.0),
Vec2::new(14.0, 24.0),
Vec2::new(10.0, 24.0),
]],
..LightFrame::default()
};
renderer.render_scene(&gpu, &mut frame(10), &camera, &lighting);
let baseline = renderer.resource_stats();
assert_eq!(
baseline.sprite_pages, 1,
"the white pixel opens one atlas page"
);
for _ in 0..100 {
renderer.render_scene(&gpu, &mut frame(10), &camera, &lighting);
}
assert_eq!(
renderer.resource_stats(),
baseline,
"identical frames reallocated"
);
let over = usize::try_from(baseline.instance_capacity).unwrap() + 1;
renderer.render_scene(&gpu, &mut frame(over), &camera, &lighting);
let grown = renderer.resource_stats();
assert!(
grown.instance_capacity >= over as u64,
"buffer too small for the frame"
);
assert!(grown.instance_capacity > baseline.instance_capacity);
for sprites in [over, over, 3, 0, over] {
renderer.render_scene(&gpu, &mut frame(sprites), &camera, &lighting);
}
assert_eq!(
renderer.resource_stats(),
grown,
"buffer churned after growing"
);
let small = assets.insert(PathBuf::from("small.png"), flat(8, [255, 0, 0, 255]));
renderer.upload_texture(&gpu, small, assets.get(small).unwrap());
assert_eq!(renderer.resource_stats().sprite_pages, grown.sprite_pages);
let big = assets.insert(
PathBuf::from("big.png"),
flat(MAX_ATLAS_DIM + 1, [0, 255, 0, 255]),
);
renderer.upload_texture(&gpu, big, assets.get(big).unwrap());
assert_eq!(
renderer.resource_stats().sprite_pages,
grown.sprite_pages + 1
);
}
#[test]
fn glyph_pages_update_in_place_across_frames() {
use crate::canvas::text::{TextChannel, TextRenderer, TextStyle};
let Some(gpu) = gpu() else { return };
let mut renderer = Renderer::headless(&gpu, 64, 64, [0.0; 3], LightingSpace::Gamma);
let mut assets: Assets<Texture> = Assets::new();
let mut text = TextRenderer::new(include_bytes!(
"../../tests/fixtures/IBMPlexSans-Regular.ttf"
))
.expect("test font should parse");
let camera = Camera::new(64, 64);
let style = TextStyle::new(32.0, [1.0; 4]);
let mut handles = std::collections::HashSet::new();
let mut pages = None;
for c in 'A'..='Z' {
let mut list = DrawList::new();
let glyph = c.to_string();
text.draw(
&glyph,
Vec2::new(16.0, 8.0),
&style,
0.0,
TextChannel::Screen,
);
let changed = text.end_frame(&mut assets, &mut list);
assert_eq!(changed.len(), 1, "{c} is a new glyph");
for page in changed {
handles.insert(page);
renderer.upload_texture(&gpu, page, assets.get(page).unwrap());
}
renderer.render_scene(&gpu, &mut list, &camera, &LightFrame::default());
let sprite_pages = renderer.resource_stats().sprite_pages;
assert_eq!(
*pages.get_or_insert(sprite_pages),
sprite_pages,
"{c} opened another GPU texture"
);
let pixels = renderer.read_scene(&gpu).unwrap();
assert!(
pixels.chunks(4).any(|p| p[..3].iter().all(|&v| v > 200)),
"{c} did not reach the GPU"
);
}
assert_eq!(text.page_count(), 1);
assert_eq!(handles.len(), 1, "the glyph page took more than one asset");
}
fn texture_1x1(
device: &wgpu::Device,
queue: &wgpu::Queue,
format: wgpu::TextureFormat,
data: &[u8],
) -> wgpu::Texture {
device.create_texture_with_data(
queue,
&wgpu::TextureDescriptor {
label: Some("composite test input"),
size: wgpu::Extent3d {
width: 1,
height: 1,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
},
wgpu::util::TextureDataOrder::LayerMajor,
data,
)
}
fn composite_1x1(
space: LightingSpace,
albedo: &[u8],
accum: &[u8],
modulate: [f32; 4],
) -> Option<[u8; 4]> {
let (device, queue) = device()?;
let albedo = texture_1x1(&device, &queue, albedo_format(space), albedo)
.create_view(&wgpu::TextureViewDescriptor::default());
let accum = texture_1x1(&device, &queue, ACCUM_FORMAT, accum)
.create_view(&wgpu::TextureViewDescriptor::default());
let target = device.create_texture(&wgpu::TextureDescriptor {
label: Some("composite test target"),
size: wgpu::Extent3d {
width: 1,
height: 1,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: SCENE_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
view_formats: &[],
});
let composite = CompositePass::new(&device, space, &albedo, &accum);
composite.set_modulate(&queue, modulate);
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
composite.run(
&mut encoder,
&target.create_view(&wgpu::TextureViewDescriptor::default()),
);
queue.submit(Some(encoder.finish()));
let bytes = read_texture(&device, &queue, &target, 1, 1, 4);
Some([bytes[0], bytes[1], bytes[2], bytes[3]])
}
const F16_ONE: [u8; 2] = 0x3C00u16.to_le_bytes();
const F16_HALF: [u8; 2] = 0x3800u16.to_le_bytes();
const F16_0_3: [u8; 2] = 0x34CDu16.to_le_bytes();
const F16_ZERO: [u8; 2] = [0, 0];
fn rgba16f(r: [u8; 2], g: [u8; 2], b: [u8; 2], a: [u8; 2]) -> Vec<u8> {
[r, g, b, a].concat()
}
#[test]
fn linear_composite_encodes_to_srgb_once() {
let Some(px) = composite_1x1(
LightingSpace::Linear,
&rgba16f(F16_HALF, F16_HALF, F16_HALF, F16_ONE),
&rgba16f(F16_ZERO, F16_ZERO, F16_ZERO, F16_ZERO),
[1.0, 1.0, 1.0, 1.0],
) else {
return;
};
for c in &px[..3] {
assert!((f32::from(*c) - 187.5).abs() <= 1.0, "{px:?}");
}
assert_eq!(px[3], 255);
let Some(px) = composite_1x1(
LightingSpace::Linear,
&rgba16f(F16_HALF, F16_HALF, F16_HALF, F16_ONE),
&rgba16f(F16_0_3, F16_0_3, F16_0_3, F16_ZERO),
[0.2, 0.2, 0.2, 1.0],
) else {
return;
};
for c in &px[..3] {
assert!((f32::from(*c) - 137.0).abs() <= 1.0, "{px:?}");
}
}
#[test]
fn gamma_composite_stores_the_product_unencoded() {
let Some(px) = composite_1x1(
LightingSpace::Gamma,
&[128, 128, 128, 255],
&rgba16f(F16_ZERO, F16_ZERO, F16_ZERO, F16_ZERO),
[1.0, 1.0, 1.0, 1.0],
) else {
return;
};
for c in &px[..3] {
assert!((f32::from(*c) - 128.0).abs() <= 1.0, "{px:?}");
}
assert_eq!(px[3], 255);
let Some(px) = composite_1x1(
LightingSpace::Gamma,
&[128, 128, 128, 255],
&rgba16f(F16_0_3, F16_0_3, F16_0_3, F16_ZERO),
[0.2, 0.2, 0.2, 1.0],
) else {
return;
};
for c in &px[..3] {
assert!((f32::from(*c) - 64.0).abs() <= 1.0, "{px:?}");
}
}
}