use std::collections::HashMap;
use std::ops::Range;
use glam::{Affine2, Mat4, Vec2};
use wgpu::util::DeviceExt;
use crate::assets::{Handle, Texture};
use crate::canvas::LightingSpace;
use crate::canvas::atlas::ShelfPacker;
use crate::canvas::camera::WorldUnits;
use crate::canvas::draw::{DrawList, Rect, SpriteInstance};
use crate::canvas::light::mask_bits;
pub const MAX_ATLAS_DIM: u32 = 384;
pub const ATLAS_PAGE_SIZE: u32 = 1024;
pub const NORMAL_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
pub const MASK_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
struct InstanceRaw {
model_x: [f32; 2],
model_y: [f32; 2],
translation: [f32; 2],
uv_min: [f32; 2],
uv_max: [f32; 2],
color: [f32; 4],
misc: [f32; 4],
_pad: [f32; 2],
}
struct Page {
texture: wgpu::Texture,
view: wgpu::TextureView,
normal: Option<wgpu::Texture>,
bind_group: wgpu::BindGroup,
size: Vec2,
}
struct AtlasPage {
page: usize,
packer: ShelfPacker,
}
struct Entry {
page: usize,
offset: Vec2,
size: Vec2,
normal: Option<Handle<Texture>>,
}
struct Batch {
camera: usize,
page: usize,
first: u32,
count: u32,
scissor: Option<[u32; 4]>,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct SpriteDrawStats {
pub world: ChannelDrawStats,
pub screen: ChannelDrawStats,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct ChannelDrawStats {
pub draws: u32,
pub instances: u32,
}
pub fn scissor_px(clip: &Rect, target: (u32, u32)) -> Option<[u32; 4]> {
let x0 = clip.min.x.floor().max(0.0) as u32;
let y0 = clip.min.y.floor().max(0.0) as u32;
let x1 = (clip.max.x.ceil().max(0.0) as u32).min(target.0);
let y1 = (clip.max.y.ceil().max(0.0) as u32).min(target.1);
if x0 >= x1 || y0 >= y1 {
None
} else {
Some([x0, y0, x1 - x0, y1 - y0])
}
}
struct CameraSlot {
buffer: wgpu::Buffer,
bind_group: wgpu::BindGroup,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TextureError {
Empty { width: u32, height: u32 },
DataLength { expected: u64, actual: usize },
TooLarge { width: u32, height: u32, max: u32 },
SizeMismatch {
expected: (u32, u32),
actual: (u32, u32),
},
DiffuseNotUploaded,
}
impl std::fmt::Display for TextureError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Empty { width, height } => write!(f, "empty {width}x{height} texture"),
Self::DataLength { expected, actual } => {
write!(f, "texture has {actual} RGBA bytes, expected {expected}")
}
Self::TooLarge { width, height, max } => {
write!(
f,
"{width}x{height} texture exceeds the device's {max} px limit"
)
}
Self::SizeMismatch { expected, actual } => write!(
f,
"normal map is {}x{}, its diffuse {}x{}",
actual.0, actual.1, expected.0, expected.1
),
Self::DiffuseNotUploaded => {
write!(f, "normal map's diffuse texture is not uploaded")
}
}
}
}
impl std::error::Error for TextureError {}
impl TextureError {
pub(crate) fn check(device: &wgpu::Device, tex: &Texture) -> Result<(), Self> {
let (width, height) = (tex.width, tex.height);
if width == 0 || height == 0 {
return Err(Self::Empty { width, height });
}
let max = device.limits().max_texture_dimension_2d;
if width > max || height > max {
return Err(Self::TooLarge { width, height, max });
}
let expected = u64::from(width) * u64::from(height) * 4;
if tex.rgba.len() as u64 != expected {
return Err(Self::DataLength {
expected,
actual: tex.rgba.len(),
});
}
Ok(())
}
}
pub struct SpritePass {
scene_pipeline: wgpu::RenderPipeline,
screen_pipeline: wgpu::RenderPipeline,
quad_vb: wgpu::Buffer,
instance_buffer: wgpu::Buffer,
instance_capacity: u64,
cameras: [CameraSlot; 2],
texture_bgl: wgpu::BindGroupLayout,
sampler: wgpu::Sampler,
default_normal_view: wgpu::TextureView,
pages: Vec<Page>,
atlases: Vec<AtlasPage>,
free_pages: Vec<usize>,
entries: HashMap<Handle<Texture>, Entry>,
raw: Vec<InstanceRaw>,
batches: Vec<Batch>,
target_size: (u32, u32),
}
const QUAD_VERTS: &[[f32; 2]] = &[
[0.0, 0.0],
[1.0, 0.0],
[1.0, 1.0],
[0.0, 0.0],
[1.0, 1.0],
[0.0, 1.0],
];
const INITIAL_INSTANCE_CAP: u64 = 256;
impl SpritePass {
pub fn new(
device: &wgpu::Device,
queue: &wgpu::Queue,
albedo_format: wgpu::TextureFormat,
screen_format: wgpu::TextureFormat,
space: LightingSpace,
) -> Self {
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("sprite shader"),
source: wgpu::ShaderSource::Wgsl(include_str!("sprite.wgsl").into()),
});
let camera_bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("sprite camera bgl"),
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
}],
});
let camera_slot = |label: &str| {
let buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some(label),
size: size_of::<[[f32; 4]; 4]>() as u64,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some(label),
layout: &camera_bgl,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: buffer.as_entire_binding(),
}],
});
CameraSlot { buffer, bind_group }
};
let cameras = [camera_slot("world camera"), camera_slot("screen camera")];
let texture_bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("sprite page 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,
},
wgpu::BindGroupLayoutEntry {
binding: 2,
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 sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("sprite sampler (nearest)"),
mag_filter: wgpu::FilterMode::Nearest,
min_filter: wgpu::FilterMode::Nearest,
mipmap_filter: wgpu::MipmapFilterMode::Nearest,
..Default::default()
});
let default_normal = device.create_texture_with_data(
queue,
&wgpu::TextureDescriptor {
label: Some("default normal (1x1 flat)"),
size: wgpu::Extent3d {
width: 1,
height: 1,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: NORMAL_FORMAT,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
},
wgpu::util::TextureDataOrder::LayerMajor,
&[128, 128, 255, 255],
);
let default_normal_view =
default_normal.create_view(&wgpu::TextureViewDescriptor::default());
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("sprite pipeline layout"),
bind_group_layouts: &[Some(&camera_bgl), Some(&texture_bgl)],
immediate_size: 0,
});
let quad_vb_layout = wgpu::VertexBufferLayout {
array_stride: size_of::<[f32; 2]>() as u64,
step_mode: wgpu::VertexStepMode::Vertex,
attributes: &wgpu::vertex_attr_array![0 => Float32x2],
};
let instance_vb_layout = wgpu::VertexBufferLayout {
array_stride: size_of::<InstanceRaw>() as u64,
step_mode: wgpu::VertexStepMode::Instance,
attributes: &wgpu::vertex_attr_array![
1 => Float32x2, 2 => Float32x2, 3 => Float32x2, 4 => Float32x2, 5 => Float32x2, 6 => Float32x4, 7 => Float32x4, ],
};
let premul = wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
};
let target = |format: wgpu::TextureFormat| {
Some(wgpu::ColorTargetState {
format,
blend: Some(premul),
write_mask: wgpu::ColorWrites::ALL,
})
};
let make_pipeline =
|label: &str, entry: &str, targets: &[Option<wgpu::ColorTargetState>]| {
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some(label),
layout: Some(&layout),
vertex: wgpu::VertexState {
module: &shader,
entry_point: Some("vs_main"),
buffers: &[
Some(quad_vb_layout.clone()),
Some(instance_vb_layout.clone()),
],
compilation_options: Default::default(),
},
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: Some(entry),
targets,
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 scene_pipeline = make_pipeline(
"sprite scene pipeline (MRT)",
match space {
LightingSpace::Gamma => "fs_scene",
LightingSpace::Linear => "fs_scene_linear",
},
&[
target(albedo_format),
target(NORMAL_FORMAT),
target(MASK_FORMAT),
],
);
let screen_pipeline = make_pipeline(
"sprite screen pipeline",
"fs_main",
&[target(screen_format)],
);
let quad_vb = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("unit quad VB"),
contents: bytemuck::cast_slice(QUAD_VERTS),
usage: wgpu::BufferUsages::VERTEX,
});
let instance_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sprite instance buffer"),
size: INITIAL_INSTANCE_CAP * size_of::<InstanceRaw>() as u64,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
Self {
scene_pipeline,
screen_pipeline,
quad_vb,
instance_buffer,
instance_capacity: INITIAL_INSTANCE_CAP,
cameras,
texture_bgl,
sampler,
default_normal_view,
pages: Vec::new(),
atlases: Vec::new(),
free_pages: Vec::new(),
entries: HashMap::new(),
raw: Vec::new(),
batches: Vec::new(),
target_size: (0, 0),
}
}
pub fn has_texture(&self, handle: Handle<Texture>) -> bool {
self.entries.contains_key(&handle)
}
pub fn upload(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
handle: Handle<Texture>,
tex: &Texture,
) -> Result<(), TextureError> {
if self.entries.contains_key(&handle) {
return self.replace(device, queue, handle, tex).map(drop);
}
TextureError::check(device, tex)?;
let entry = self.place(device, queue, tex);
self.entries.insert(handle, entry);
Ok(())
}
pub fn replace(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
handle: Handle<Texture>,
tex: &Texture,
) -> Result<bool, TextureError> {
TextureError::check(device, tex)?;
let size = Vec2::new(tex.width as f32, tex.height as f32);
let mut found = false;
if let Some(entry) = self.entries.get(&handle) {
found = true;
if entry.size == size {
let (x, y) = (entry.offset.x as u32, entry.offset.y as u32);
write_pixels(queue, &self.pages[entry.page].texture, x, y, tex);
} else {
let old = entry.page;
self.release_if_exclusive(device, handle, old, tex);
let entry = self.place(device, queue, tex);
self.entries.insert(handle, entry);
}
}
let owners: Vec<_> = self
.entries
.iter()
.filter_map(|(diffuse, entry)| {
(entry.normal == Some(handle)).then_some((
*diffuse,
entry.page,
entry.offset,
entry.size,
))
})
.collect();
found |= !owners.is_empty();
for (diffuse, page, offset, diffuse_size) in owners {
if diffuse_size != size {
self.entries
.get_mut(&diffuse)
.expect("normal owner came from entries")
.normal = None;
continue;
}
self.ensure_page_normal(device, page);
let normal = self.pages[page]
.normal
.as_ref()
.expect("ensure_page_normal just created it");
write_pixels(queue, normal, offset.x as u32, offset.y as u32, tex);
}
Ok(found)
}
fn release_if_exclusive(
&mut self,
device: &wgpu::Device,
handle: Handle<Texture>,
page: usize,
tex: &Texture,
) {
let shared = self.atlases.iter().any(|atlas| atlas.page == page)
|| self
.entries
.iter()
.any(|(other, entry)| *other != handle && entry.page == page);
if shared {
return;
}
if tex.width <= MAX_ATLAS_DIM && tex.height <= MAX_ATLAS_DIM {
self.pages[page] = self.new_page(device, 1, 1, "released sprite page");
}
self.free_pages.push(page);
}
fn place(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, tex: &Texture) -> Entry {
let (w, h) = (tex.width, tex.height);
if w <= MAX_ATLAS_DIM && h <= MAX_ATLAS_DIM {
let (page, x, y) = self.atlas_spot(device, w, h);
write_pixels(queue, &self.pages[page].texture, x, y, tex);
Entry {
page,
offset: Vec2::new(x as f32, y as f32),
size: Vec2::new(w as f32, h as f32),
normal: None,
}
} else {
let label = "standalone sprite page";
let page = if let Some(page) = self.free_pages.pop() {
self.pages[page] = self.new_page(device, w, h, label);
page
} else {
self.create_page(device, w, h, label)
};
write_pixels(queue, &self.pages[page].texture, 0, 0, tex);
Entry {
page,
offset: Vec2::ZERO,
size: Vec2::new(w as f32, h as f32),
normal: None,
}
}
}
pub fn upload_normal(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
diffuse: Handle<Texture>,
normal_handle: Handle<Texture>,
tex: &Texture,
) -> Result<(), TextureError> {
TextureError::check(device, tex)?;
let Some(entry) = self.entries.get(&diffuse) else {
return Err(TextureError::DiffuseNotUploaded);
};
if entry.normal == Some(normal_handle) {
return Ok(());
}
if entry.size != Vec2::new(tex.width as f32, tex.height as f32) {
return Err(TextureError::SizeMismatch {
expected: (entry.size.x as u32, entry.size.y as u32),
actual: (tex.width, tex.height),
});
}
let page = entry.page;
let (x, y) = (entry.offset.x as u32, entry.offset.y as u32);
self.ensure_page_normal(device, page);
let normal_tex = self.pages[page]
.normal
.as_ref()
.expect("ensure_page_normal just created it");
write_pixels(queue, normal_tex, x, y, tex);
self.entries
.get_mut(&diffuse)
.expect("entry checked above")
.normal = Some(normal_handle);
Ok(())
}
fn ensure_page_normal(&mut self, device: &wgpu::Device, page: usize) {
if self.pages[page].normal.is_some() {
return;
}
let size = self.pages[page].size;
let normal = device.create_texture(&wgpu::TextureDescriptor {
label: Some("sprite page normal companion"),
size: wgpu::Extent3d {
width: size.x as u32,
height: size.y as u32,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: NORMAL_FORMAT,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
});
let normal_view = normal.create_view(&wgpu::TextureViewDescriptor::default());
let bind_group = self.page_bind_group(
device,
&self.pages[page].view,
&normal_view,
"sprite page (with normals)",
);
self.pages[page].bind_group = bind_group;
self.pages[page].normal = Some(normal);
}
fn page_bind_group(
&self,
device: &wgpu::Device,
view: &wgpu::TextureView,
normal_view: &wgpu::TextureView,
label: &str,
) -> wgpu::BindGroup {
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some(label),
layout: &self.texture_bgl,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(view),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Sampler(&self.sampler),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::TextureView(normal_view),
},
],
})
}
fn atlas_spot(&mut self, device: &wgpu::Device, w: u32, h: u32) -> (usize, u32, u32) {
for atlas in &mut self.atlases {
if let Some((x, y)) = atlas.packer.insert(w, h) {
return (atlas.page, x, y);
}
}
let page = self.create_page(
device,
ATLAS_PAGE_SIZE,
ATLAS_PAGE_SIZE,
"sprite atlas page",
);
let mut packer = ShelfPacker::new(ATLAS_PAGE_SIZE, ATLAS_PAGE_SIZE);
let (x, y) = packer
.insert(w, h)
.expect("fresh atlas page must fit a <=MAX_ATLAS_DIM sprite");
self.atlases.push(AtlasPage { page, packer });
(page, x, y)
}
fn create_page(&mut self, device: &wgpu::Device, w: u32, h: u32, label: &str) -> usize {
let page = self.new_page(device, w, h, label);
self.pages.push(page);
self.pages.len() - 1
}
fn new_page(&self, device: &wgpu::Device, w: u32, h: u32, label: &str) -> Page {
let texture = device.create_texture(&wgpu::TextureDescriptor {
label: Some(label),
size: wgpu::Extent3d {
width: w,
height: h,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8Unorm,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
});
let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
let bind_group = self.page_bind_group(device, &view, &self.default_normal_view, label);
Page {
texture,
view,
normal: None,
bind_group,
size: Vec2::new(w as f32, h as f32),
}
}
#[allow(clippy::too_many_arguments)]
pub fn prepare(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
list: &DrawList,
world_vp: Mat4,
world_units: WorldUnits,
screen_vp: Mat4,
target_size: (u32, u32),
clip_scale: f32,
) {
self.raw.clear();
self.batches.clear();
self.target_size = target_size;
let max_instances = device.limits().max_buffer_size / size_of::<InstanceRaw>() as u64;
let channels = [
(0usize, &list.world, world_units),
(1usize, &list.screen, WorldUnits::default()),
];
'convert: for (camera, channel, units) in channels {
for inst in channel {
if self.raw.len() as u64 >= max_instances {
break 'convert; }
let Some(entry) = self.entries.get(&inst.texture) else {
continue; };
let scissor = match &inst.clip {
Some(clip) => match scissor_px(
&Rect {
min: clip.min * clip_scale,
max: clip.max * clip_scale,
},
target_size,
) {
Some(s) => Some(s),
None => continue, },
None => None,
};
let page = entry.page;
let raw = to_raw(inst, entry, self.pages[page].size, units);
let index = self.raw.len() as u32;
self.raw.push(raw);
match self.batches.last_mut() {
Some(b) if b.camera == camera && b.page == page && b.scissor == scissor => {
b.count += 1;
}
_ => self.batches.push(Batch {
camera,
page,
first: index,
count: 1,
scissor,
}),
}
}
}
if self.raw.is_empty() {
return;
}
queue.write_buffer(
&self.cameras[0].buffer,
0,
bytemuck::cast_slice(&world_vp.to_cols_array()),
);
queue.write_buffer(
&self.cameras[1].buffer,
0,
bytemuck::cast_slice(&screen_vp.to_cols_array()),
);
let needed = self.raw.len() as u64;
if needed > self.instance_capacity {
let new_cap = needed.next_power_of_two().min(max_instances);
self.instance_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sprite instance buffer"),
size: new_cap * size_of::<InstanceRaw>() as u64,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
self.instance_capacity = new_cap;
}
queue.write_buffer(&self.instance_buffer, 0, bytemuck::cast_slice(&self.raw));
}
pub fn draw_stats(&self) -> SpriteDrawStats {
let mut stats = SpriteDrawStats::default();
for batch in &self.batches {
let channel = if batch.camera == 0 {
&mut stats.world
} else {
&mut stats.screen
};
channel.draws += 1;
channel.instances += batch.count;
}
stats
}
#[cfg(all(test, not(target_arch = "wasm32")))]
pub(crate) fn instance_capacity(&self) -> u64 {
self.instance_capacity
}
#[cfg(all(test, not(target_arch = "wasm32")))]
pub(crate) fn page_count(&self) -> usize {
self.pages.len()
}
pub fn draw_world(&self, pass: &mut wgpu::RenderPass<'_>) {
self.draw_channel(pass, &self.scene_pipeline, 0);
}
pub fn draw_screen(&self, pass: &mut wgpu::RenderPass<'_>) {
self.draw_channel(pass, &self.screen_pipeline, 1);
}
fn draw_channel(
&self,
pass: &mut impl PassEncoder,
pipeline: &wgpu::RenderPipeline,
camera: usize,
) {
if !self.batches.iter().any(|b| b.camera == camera) {
return;
}
pass.set_pipeline(pipeline);
pass.set_vertex_buffer(0, self.quad_vb.slice(..));
pass.set_vertex_buffer(1, self.instance_buffer.slice(..));
pass.set_bind_group(0, &self.cameras[camera].bind_group);
let (tw, th) = self.target_size;
let mut scissor_active = false;
for batch in self.batches.iter().filter(|b| b.camera == camera) {
match batch.scissor {
Some([x, y, w, h]) => {
pass.set_scissor_rect(x, y, w, h);
scissor_active = true;
}
None if scissor_active => {
pass.set_scissor_rect(0, 0, tw, th);
scissor_active = false;
}
None => {}
}
pass.set_bind_group(1, &self.pages[batch.page].bind_group);
pass.draw(
0..QUAD_VERTS.len() as u32,
batch.first..batch.first + batch.count,
);
}
if scissor_active {
pass.set_scissor_rect(0, 0, tw, th);
}
}
}
trait PassEncoder {
fn set_pipeline(&mut self, pipeline: &wgpu::RenderPipeline);
fn set_vertex_buffer(&mut self, slot: u32, slice: wgpu::BufferSlice<'_>);
fn set_bind_group(&mut self, index: u32, group: &wgpu::BindGroup);
fn set_scissor_rect(&mut self, x: u32, y: u32, width: u32, height: u32);
fn draw(&mut self, vertices: Range<u32>, instances: Range<u32>);
}
impl PassEncoder for wgpu::RenderPass<'_> {
fn set_pipeline(&mut self, pipeline: &wgpu::RenderPipeline) {
wgpu::RenderPass::set_pipeline(self, pipeline);
}
fn set_vertex_buffer(&mut self, slot: u32, slice: wgpu::BufferSlice<'_>) {
wgpu::RenderPass::set_vertex_buffer(self, slot, slice);
}
fn set_bind_group(&mut self, index: u32, group: &wgpu::BindGroup) {
wgpu::RenderPass::set_bind_group(self, index, group, &[]);
}
fn set_scissor_rect(&mut self, x: u32, y: u32, width: u32, height: u32) {
wgpu::RenderPass::set_scissor_rect(self, x, y, width, height);
}
fn draw(&mut self, vertices: Range<u32>, instances: Range<u32>) {
wgpu::RenderPass::draw(self, vertices, instances);
}
}
fn write_pixels(queue: &wgpu::Queue, texture: &wgpu::Texture, x: u32, y: u32, tex: &Texture) {
queue.write_texture(
wgpu::TexelCopyTextureInfo {
texture,
mip_level: 0,
origin: wgpu::Origin3d { x, y, z: 0 },
aspect: wgpu::TextureAspect::All,
},
&tex.rgba,
wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(4 * tex.width),
rows_per_image: Some(tex.height),
},
wgpu::Extent3d {
width: tex.width,
height: tex.height,
depth_or_array_layers: 1,
},
);
}
pub fn sprite_affine(pos: Vec2, rot: f32, size_px: Vec2, units: WorldUnits) -> Affine2 {
let quad = size_px / units.pixels_per_unit;
let (sin, cos) = rot.sin_cos();
let col_x = Vec2::new(cos, sin) * quad.x;
let col_y = Vec2::new(-sin, cos) * quad.y * units.screen_y_sign();
let translation = pos - (col_x + col_y) * 0.5;
Affine2::from_cols(col_x, col_y, translation)
}
fn to_raw(inst: &SpriteInstance, entry: &Entry, page_size: Vec2, units: WorldUnits) -> InstanceRaw {
let src = inst
.src
.unwrap_or(Rect::new(0.0, 0.0, entry.size.x, entry.size.y));
let affine = sprite_affine(inst.pos, inst.rot, src.size() * inst.scale, units);
let mut uv_min = (entry.offset + src.min) / page_size;
let mut uv_max = (entry.offset + src.max) / page_size;
if inst.flip_x {
std::mem::swap(&mut uv_min.x, &mut uv_max.x);
}
if inst.flip_y {
std::mem::swap(&mut uv_min.y, &mut uv_max.y);
}
let has_normal = inst.normal.is_some() && inst.normal == entry.normal;
let bits = mask_bits(inst.light_mask);
InstanceRaw {
model_x: affine.matrix2.x_axis.to_array(),
model_y: affine.matrix2.y_axis.to_array(),
translation: affine.translation.to_array(),
uv_min: uv_min.to_array(),
uv_max: uv_max.to_array(),
color: inst.color,
misc: [
bits[0],
bits[1],
bits[2],
if has_normal { 1.0 } else { 0.0 },
],
_pad: [0.0; 2],
}
}
#[cfg(test)]
mod tests {
use super::*;
use wasm_bindgen_test::wasm_bindgen_test;
#[wasm_bindgen_test(unsupported = test)]
fn scissor_px_clamps_and_culls() {
let target = (960, 540);
assert_eq!(
scissor_px(&Rect::new(10.5, 20.5, 100.0, 50.0), target),
Some([10, 20, 101, 51])
);
assert_eq!(
scissor_px(&Rect::new(-50.0, -50.0, 2000.0, 2000.0), target),
Some([0, 0, 960, 540])
);
assert_eq!(
scissor_px(&Rect::new(1000.0, 0.0, 50.0, 50.0), target),
None
);
assert_eq!(
scissor_px(&Rect::new(-100.0, 0.0, 50.0, 50.0), target),
None
);
assert_eq!(scissor_px(&Rect::new(10.0, 10.0, 0.0, 0.0), target), None);
}
fn assert_close(a: Vec2, b: Vec2) {
assert!((a - b).length() < 1e-4, "expected {b:?}, got {a:?}");
}
#[wasm_bindgen_test(unsupported = test)]
fn sprite_affine_pixels_are_y_down_clockwise() {
let units = WorldUnits::default();
let a = sprite_affine(Vec2::new(100.0, 50.0), 0.0, Vec2::new(32.0, 16.0), units);
assert_eq!(a.matrix2.x_axis, Vec2::new(32.0, 0.0));
assert_eq!(a.matrix2.y_axis, Vec2::new(0.0, 16.0));
assert_eq!(a.translation, Vec2::new(84.0, 42.0));
assert_eq!(a.transform_point2(Vec2::ONE), Vec2::new(116.0, 58.0));
let turned = sprite_affine(
Vec2::ZERO,
std::f32::consts::FRAC_PI_2,
Vec2::new(32.0, 16.0),
units,
);
assert_close(turned.matrix2.x_axis, Vec2::new(0.0, 32.0));
assert_close(turned.matrix2.y_axis, Vec2::new(-16.0, 0.0));
}
#[wasm_bindgen_test(unsupported = test)]
fn sprite_affine_units_y_up_spans_one_unit_top_up() {
let units = WorldUnits {
pixels_per_unit: 32.0,
y_up: true,
};
let pos = Vec2::new(3.0, -2.0);
let a = sprite_affine(pos, 0.0, Vec2::new(32.0, 32.0), units);
assert_eq!(a.matrix2.x_axis, Vec2::new(1.0, 0.0));
assert_eq!(a.matrix2.y_axis, Vec2::new(0.0, -1.0));
assert_eq!(a.transform_point2(Vec2::ZERO), Vec2::new(2.5, -1.5));
assert_eq!(a.transform_point2(Vec2::ONE), Vec2::new(3.5, -2.5));
let turned = sprite_affine(pos, std::f32::consts::FRAC_PI_2, Vec2::splat(32.0), units);
assert_close(turned.matrix2.x_axis, Vec2::new(0.0, 1.0));
assert_close(turned.matrix2.y_axis, Vec2::new(1.0, 0.0));
}
#[wasm_bindgen_test(unsupported = test)]
fn sprite_affine_units_y_down_scales_only() {
let units = WorldUnits {
pixels_per_unit: 32.0,
y_up: false,
};
let a = sprite_affine(
Vec2::new(10.0, 20.0),
0.0,
Vec2::new(64.0, 32.0) * Vec2::new(1.0, 2.0),
units,
);
assert_eq!(a.matrix2.x_axis, Vec2::new(2.0, 0.0));
assert_eq!(a.matrix2.y_axis, Vec2::new(0.0, 2.0));
assert_eq!(a.translation, Vec2::new(9.0, 19.0));
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod gpu_tests {
use super::*;
use crate::assets::Assets;
use crate::canvas::camera::Camera;
use crate::canvas::test_gpu::{device, read_texture, rgba16f_to_f32};
use crate::canvas::text::GLYPH_PAGE_SIZE;
const SIZE: u32 = 4;
fn flat(width: u32, height: u32, rgba: [u8; 4]) -> Texture {
Texture {
width,
height,
rgba: rgba.repeat((width * height) as usize),
}
}
fn draw_targets(
device: &wgpu::Device,
queue: &wgpu::Queue,
pass: &mut SpritePass,
list: &DrawList,
albedo_format: wgpu::TextureFormat,
bytes_per_pixel: u32,
) -> (Vec<u8>, Vec<u8>) {
let vp = Camera::new(SIZE, SIZE).view_proj();
pass.prepare(
device,
queue,
list,
vp,
WorldUnits::default(),
vp,
(SIZE, SIZE),
1.0,
);
let target = |format: wgpu::TextureFormat, extra: wgpu::TextureUsages| {
device.create_texture(&wgpu::TextureDescriptor {
label: Some("scene test target"),
size: wgpu::Extent3d {
width: SIZE,
height: SIZE,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | extra,
view_formats: &[],
})
};
let albedo = target(albedo_format, wgpu::TextureUsages::COPY_SRC);
let normal = target(NORMAL_FORMAT, wgpu::TextureUsages::COPY_SRC);
let mask = target(MASK_FORMAT, wgpu::TextureUsages::empty());
let views: Vec<_> = [&albedo, &normal, &mask]
.into_iter()
.map(|t| t.create_view(&wgpu::TextureViewDescriptor::default()))
.collect();
let attachments: Vec<_> = views
.iter()
.map(|view| {
Some(wgpu::RenderPassColorAttachment {
view,
resolve_target: None,
depth_slice: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
store: wgpu::StoreOp::Store,
},
})
})
.collect();
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
{
let mut rp = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("scene test pass"),
color_attachments: &attachments,
depth_stencil_attachment: None,
timestamp_writes: None,
occlusion_query_set: None,
multiview_mask: None,
});
pass.draw_world(&mut rp);
}
queue.submit(Some(encoder.finish()));
(
read_texture(device, queue, &albedo, SIZE, SIZE, bytes_per_pixel),
read_texture(device, queue, &normal, SIZE, SIZE, 4),
)
}
fn draw_albedo(
device: &wgpu::Device,
queue: &wgpu::Queue,
pass: &mut SpritePass,
list: &DrawList,
albedo_format: wgpu::TextureFormat,
bytes_per_pixel: u32,
) -> Vec<u8> {
draw_targets(device, queue, pass, list, albedo_format, bytes_per_pixel).0
}
fn scene_albedo(space: LightingSpace, texel: [u8; 4]) -> Option<Vec<u8>> {
let (device, queue) = device()?;
let (albedo_format, bytes_per_pixel) = match space {
LightingSpace::Gamma => (wgpu::TextureFormat::Rgba8Unorm, 4),
LightingSpace::Linear => (wgpu::TextureFormat::Rgba16Float, 8),
};
let mut pass = SpritePass::new(
&device,
&queue,
albedo_format,
wgpu::TextureFormat::Rgba8Unorm,
space,
);
let mut assets = Assets::<Texture>::new();
let handle = assets.insert(
"texel.png".into(),
Texture {
width: 1,
height: 1,
rgba: texel.to_vec(),
},
);
pass.upload(
&device,
&queue,
handle,
assets.get(handle).expect("inserted"),
)
.unwrap();
let mut list = DrawList::new();
list.push(SpriteInstance {
scale: Vec2::splat(SIZE as f32),
..SpriteInstance::new(handle, Vec2::splat(SIZE as f32 / 2.0))
});
Some(draw_albedo(
&device,
&queue,
&mut pass,
&list,
albedo_format,
bytes_per_pixel,
))
}
#[test]
fn replacement_updates_pixels_and_detaches_incompatible_normal() {
let Some((device, queue)) = device() else {
return;
};
let mut pass = SpritePass::new(
&device,
&queue,
wgpu::TextureFormat::Rgba8Unorm,
wgpu::TextureFormat::Rgba8Unorm,
LightingSpace::Gamma,
);
let mut assets = Assets::<Texture>::new();
let diffuse = assets.insert("diffuse.png".into(), flat(1, 1, [220, 30, 20, 255]));
let normal = assets.insert("normal.png".into(), flat(1, 1, [128, 128, 255, 255]));
pass.upload(&device, &queue, diffuse, assets.get(diffuse).unwrap())
.unwrap();
pass.upload_normal(
&device,
&queue,
diffuse,
normal,
assets.get(normal).unwrap(),
)
.unwrap();
let mut list = DrawList::new();
list.push(SpriteInstance {
scale: Vec2::splat(SIZE as f32),
normal: Some(normal),
..SpriteInstance::new(diffuse, Vec2::splat(SIZE as f32 / 2.0))
});
assert!(
pass.replace(&device, &queue, diffuse, &flat(1, 1, [20, 210, 40, 255]),)
.unwrap()
);
let pixels = draw_albedo(
&device,
&queue,
&mut pass,
&list,
wgpu::TextureFormat::Rgba8Unorm,
4,
);
assert!(
pixels
.chunks_exact(4)
.all(|pixel| pixel == [20, 210, 40, 255]),
"same-size replacement did not reach the GPU: {:?}",
&pixels[..4]
);
assert_eq!(pass.raw[0].misc[3], 1.0, "compatible normal was detached");
let resized = Texture {
width: 2,
height: 1,
rgba: [30, 50, 230, 255, 230, 180, 20, 255].to_vec(),
};
assert!(pass.replace(&device, &queue, diffuse, &resized).unwrap());
let mut resized_list = DrawList::new();
resized_list.push(SpriteInstance {
scale: Vec2::new(2.0, SIZE as f32),
normal: Some(normal),
..SpriteInstance::new(diffuse, Vec2::splat(SIZE as f32 / 2.0))
});
let pixels = draw_albedo(
&device,
&queue,
&mut pass,
&resized_list,
wgpu::TextureFormat::Rgba8Unorm,
4,
);
for row in pixels.chunks_exact((SIZE * 4) as usize) {
assert_eq!(&row[..8], [30, 50, 230, 255, 30, 50, 230, 255]);
assert_eq!(&row[8..], [230, 180, 20, 255, 230, 180, 20, 255]);
}
assert_eq!(
pass.raw[0].misc[3], 0.0,
"resized diffuse kept an incompatible normal association"
);
let never_uploaded = assets.insert("unused.png".into(), flat(1, 1, [0, 0, 0, 255]));
assert!(
!pass
.replace(
&device,
&queue,
never_uploaded,
assets.get(never_uploaded).unwrap(),
)
.unwrap()
);
}
#[test]
fn normal_replacement_updates_every_owner_and_an_optional_diffuse_role() {
let Some((device, queue)) = device() else {
return;
};
let mut pass = SpritePass::new(
&device,
&queue,
wgpu::TextureFormat::Rgba8Unorm,
wgpu::TextureFormat::Rgba8Unorm,
LightingSpace::Gamma,
);
let mut assets = Assets::<Texture>::new();
let left = assets.insert("left.png".into(), flat(1, 1, [255; 4]));
let right = assets.insert("right.png".into(), flat(1, 1, [255; 4]));
let normal = assets.insert("shared-normal.png".into(), flat(1, 1, [255, 128, 128, 255]));
for diffuse in [left, right] {
pass.upload(&device, &queue, diffuse, assets.get(diffuse).unwrap())
.unwrap();
pass.upload_normal(
&device,
&queue,
diffuse,
normal,
assets.get(normal).unwrap(),
)
.unwrap();
}
assert!(
!pass.has_texture(normal),
"normal unexpectedly had a diffuse role"
);
let mut owners = DrawList::new();
for (diffuse, x) in [(left, 1.0), (right, 3.0)] {
owners.push(SpriteInstance {
scale: Vec2::new(2.0, SIZE as f32),
normal: Some(normal),
..SpriteInstance::new(diffuse, Vec2::new(x, 2.0))
});
}
let new_normal = flat(1, 1, [128, 255, 128, 255]);
assert!(pass.replace(&device, &queue, normal, &new_normal).unwrap());
let (_, normal_pixels) = draw_targets(
&device,
&queue,
&mut pass,
&owners,
wgpu::TextureFormat::Rgba8Unorm,
4,
);
assert!(
normal_pixels
.chunks_exact(4)
.all(|pixel| pixel == [128, 0, 128, 255]),
"shared companion pixels were not replaced for both owners"
);
pass.upload(&device, &queue, normal, &flat(1, 1, [10, 20, 30, 255]))
.unwrap();
let both_roles = flat(1, 1, [240, 30, 60, 255]);
assert!(pass.replace(&device, &queue, normal, &both_roles).unwrap());
let mut diffuse_draw = DrawList::new();
diffuse_draw.push(SpriteInstance {
scale: Vec2::splat(SIZE as f32),
..SpriteInstance::new(normal, Vec2::splat(2.0))
});
let diffuse_pixels = draw_albedo(
&device,
&queue,
&mut pass,
&diffuse_draw,
wgpu::TextureFormat::Rgba8Unorm,
4,
);
assert!(
diffuse_pixels
.chunks_exact(4)
.all(|pixel| pixel == [240, 30, 60, 255]),
"the handle's diffuse role was not replaced"
);
let (_, normal_pixels) = draw_targets(
&device,
&queue,
&mut pass,
&owners,
wgpu::TextureFormat::Rgba8Unorm,
4,
);
assert!(
normal_pixels
.chunks_exact(4)
.all(|pixel| pixel == [240, 225, 60, 255]),
"the handle's companion roles were not replaced"
);
assert!(
pass.replace(&device, &queue, normal, &flat(2, 1, [70, 80, 90, 255]),)
.unwrap()
);
let (_, normal_pixels) = draw_targets(
&device,
&queue,
&mut pass,
&owners,
wgpu::TextureFormat::Rgba8Unorm,
4,
);
assert!(
normal_pixels
.chunks_exact(4)
.all(|pixel| pixel == [128, 128, 255, 255]),
"mismatched shared normal remained associated"
);
}
#[test]
fn a_second_normal_map_replaces_the_first() {
let Some((device, queue)) = device() else {
return;
};
let mut pass = SpritePass::new(
&device,
&queue,
wgpu::TextureFormat::Rgba8Unorm,
wgpu::TextureFormat::Rgba8Unorm,
LightingSpace::Gamma,
);
let mut assets = Assets::<Texture>::new();
let diffuse = assets.insert("diffuse.png".into(), flat(1, 1, [255; 4]));
let first = assets.insert("first.png".into(), flat(1, 1, [128, 255, 128, 255]));
let second = assets.insert("second.png".into(), flat(1, 1, [240, 30, 60, 255]));
let wide = assets.insert("wide.png".into(), flat(2, 1, [70, 80, 90, 255]));
assert_eq!(
pass.upload_normal(&device, &queue, diffuse, first, assets.get(first).unwrap()),
Err(TextureError::DiffuseNotUploaded)
);
pass.upload(&device, &queue, diffuse, assets.get(diffuse).unwrap())
.unwrap();
for normal in [first, second] {
pass.upload_normal(
&device,
&queue,
diffuse,
normal,
assets.get(normal).unwrap(),
)
.unwrap();
}
assert_eq!(
pass.upload_normal(&device, &queue, diffuse, wide, assets.get(wide).unwrap()),
Err(TextureError::SizeMismatch {
expected: (1, 1),
actual: (2, 1)
})
);
let drawn_with = |normal| {
let mut list = DrawList::new();
list.push(SpriteInstance {
scale: Vec2::splat(SIZE as f32),
normal: Some(normal),
..SpriteInstance::new(diffuse, Vec2::splat(2.0))
});
list
};
let (_, normal_pixels) = draw_targets(
&device,
&queue,
&mut pass,
&drawn_with(second),
wgpu::TextureFormat::Rgba8Unorm,
4,
);
assert!(
normal_pixels
.chunks_exact(4)
.all(|pixel| pixel == [240, 225, 60, 255]),
"the second normal map did not replace the first: {:?}",
&normal_pixels[..4]
);
let (_, normal_pixels) = draw_targets(
&device,
&queue,
&mut pass,
&drawn_with(first),
wgpu::TextureFormat::Rgba8Unorm,
4,
);
assert!(
normal_pixels
.chunks_exact(4)
.all(|pixel| pixel == [128, 128, 255, 255]),
"the replaced handle still lights the diffuse"
);
}
#[test]
fn invalid_textures_are_refused_without_changes() {
let Some((device, queue)) = device() else {
return;
};
let mut pass = SpritePass::new(
&device,
&queue,
wgpu::TextureFormat::Rgba8Unorm,
wgpu::TextureFormat::Rgba8Unorm,
LightingSpace::Gamma,
);
let mut assets = Assets::<Texture>::new();
let empty = assets.insert("empty.png".into(), flat(0, 4, [0; 4]));
assert_eq!(
pass.upload(&device, &queue, empty, assets.get(empty).unwrap()),
Err(TextureError::Empty {
width: 0,
height: 4
})
);
assert!(!pass.has_texture(empty));
let handle = assets.insert("kept.png".into(), flat(1, 1, [10, 20, 30, 255]));
pass.upload(&device, &queue, handle, assets.get(handle).unwrap())
.unwrap();
assert_eq!(
pass.replace(&device, &queue, handle, &flat(4, 0, [0; 4])),
Err(TextureError::Empty {
width: 4,
height: 0
})
);
assert_eq!(
pass.upload(&device, &queue, handle, &flat(0, 0, [0; 4])),
Err(TextureError::Empty {
width: 0,
height: 0
})
);
let short = Texture {
width: 2,
height: 2,
rgba: vec![255; 4],
};
assert_eq!(
pass.replace(&device, &queue, handle, &short),
Err(TextureError::DataLength {
expected: 16,
actual: 4
})
);
let max = device.limits().max_texture_dimension_2d;
let wide = Texture {
width: max + 1,
height: 1,
rgba: Vec::new(),
};
assert_eq!(
pass.replace(&device, &queue, handle, &wide),
Err(TextureError::TooLarge {
width: max + 1,
height: 1,
max
})
);
let normal = assets.insert("normal.png".into(), flat(2, 2, [128, 128, 255, 255]));
assert_eq!(
pass.upload_normal(&device, &queue, handle, normal, assets.get(normal).unwrap()),
Err(TextureError::SizeMismatch {
expected: (1, 1),
actual: (2, 2)
})
);
let mut list = DrawList::new();
list.push(SpriteInstance {
scale: Vec2::splat(SIZE as f32),
..SpriteInstance::new(handle, Vec2::splat(2.0))
});
let pixels = draw_albedo(
&device,
&queue,
&mut pass,
&list,
wgpu::TextureFormat::Rgba8Unorm,
4,
);
assert!(pixels.chunks_exact(4).all(|p| p == [10, 20, 30, 255]));
}
#[test]
fn replacement_crosses_between_atlas_and_standalone() {
let Some((device, queue)) = device() else {
return;
};
let mut pass = SpritePass::new(
&device,
&queue,
wgpu::TextureFormat::Rgba8Unorm,
wgpu::TextureFormat::Rgba8Unorm,
LightingSpace::Gamma,
);
let mut assets = Assets::<Texture>::new();
let handle = assets.insert("threshold.png".into(), flat(1, 1, [10, 20, 30, 255]));
pass.upload(&device, &queue, handle, assets.get(handle).unwrap())
.unwrap();
assert_eq!(pass.page_count(), 1);
let standalone = flat(MAX_ATLAS_DIM + 1, 1, [25, 75, 225, 255]);
assert!(pass.replace(&device, &queue, handle, &standalone).unwrap());
assert_eq!(pass.page_count(), 2, "standalone page was not allocated");
let mut list = DrawList::new();
list.push(SpriteInstance {
src: Some(Rect::new(0.0, 0.0, 1.0, 1.0)),
scale: Vec2::splat(SIZE as f32),
..SpriteInstance::new(handle, Vec2::splat(2.0))
});
let pixels = draw_albedo(
&device,
&queue,
&mut pass,
&list,
wgpu::TextureFormat::Rgba8Unorm,
4,
);
assert!(pixels.chunks_exact(4).all(|p| p == [25, 75, 225, 255]));
assert!(
pass.replace(&device, &queue, handle, &flat(1, 1, [210, 45, 15, 255]),)
.unwrap()
);
assert_eq!(
pass.page_count(),
2,
"returning to the atlas unnecessarily opened another page"
);
let pixels = draw_albedo(
&device,
&queue,
&mut pass,
&list,
wgpu::TextureFormat::Rgba8Unorm,
4,
);
assert!(pixels.chunks_exact(4).all(|p| p == [210, 45, 15, 255]));
}
fn draw_screen_target(
device: &wgpu::Device,
queue: &wgpu::Queue,
pass: &mut SpritePass,
list: &DrawList,
(width, height): (u32, u32),
) -> Vec<u8> {
pass.prepare(
device,
queue,
list,
Mat4::IDENTITY,
WorldUnits::default(),
Camera::screen_view_proj(width, height),
(width, height),
1.0,
);
let target = device.create_texture(&wgpu::TextureDescriptor {
label: Some("screen test target"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8Unorm,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
view_formats: &[],
});
let view = target.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
{
let mut rp = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("screen test pass"),
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: &view,
resolve_target: None,
depth_slice: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
store: wgpu::StoreOp::Store,
},
})],
depth_stencil_attachment: None,
timestamp_writes: None,
occlusion_query_set: None,
multiview_mask: None,
});
pass.draw_screen(&mut rp);
}
queue.submit(Some(encoder.finish()));
read_texture(device, queue, &target, width, height, 4)
}
fn quad_texels(texels: [[u8; 3]; 4]) -> Texture {
Texture {
width: 2,
height: 2,
rgba: texels
.iter()
.flat_map(|t| [t[0], t[1], t[2], 255])
.collect(),
}
}
fn at_x(handle: Handle<Texture>, x: f32) -> SpriteInstance {
SpriteInstance::new(handle, Vec2::new(x + 1.0, 1.0))
}
fn side_by_side(left: &Texture, right: &Texture) -> Vec<u8> {
let row = |tex: &Texture, y: usize| tex.rgba[y * 8..y * 8 + 8].to_vec();
(0..2)
.flat_map(|y| [row(left, y), row(right, y)].concat())
.collect()
}
#[test]
fn public_updates_reach_a_drawn_handle_and_spare_its_neighbour() {
let Some((device, queue)) = device() else {
return;
};
let mut pass = SpritePass::new(
&device,
&queue,
wgpu::TextureFormat::Rgba8Unorm,
wgpu::TextureFormat::Rgba8Unorm,
LightingSpace::Gamma,
);
let mut assets = Assets::<Texture>::new();
let left = assets.insert(
"neighbour.png".into(),
quad_texels([[200, 10, 10], [10, 200, 10], [10, 10, 200], [90, 90, 90]]),
);
let right = assets.insert(
"updated.png".into(),
quad_texels([[1, 2, 3], [40, 50, 60], [70, 80, 90], [250, 240, 230]]),
);
let (neighbour, first) = (assets.get(left).unwrap(), assets.get(right).unwrap());
pass.upload(&device, &queue, left, neighbour).unwrap();
pass.upload(&device, &queue, right, first).unwrap();
let mut list = DrawList::new();
list.push_screen(at_x(left, 0.0));
list.push_screen(at_x(right, 2.0));
assert_eq!(
draw_screen_target(&device, &queue, &mut pass, &list, (4, 2)),
side_by_side(neighbour, first)
);
let replaced = quad_texels([[33, 66, 99], [120, 0, 7], [5, 180, 5], [0, 0, 0]]);
let pages = pass.page_count();
assert!(pass.replace(&device, &queue, right, &replaced).unwrap());
assert_eq!(
draw_screen_target(&device, &queue, &mut pass, &list, (4, 2)),
side_by_side(neighbour, &replaced),
"replace did not reach the drawn handle, or touched its neighbour"
);
let uploaded = quad_texels([[9, 8, 7], [6, 5, 4], [3, 2, 1], [222, 111, 0]]);
pass.upload(&device, &queue, right, &uploaded).unwrap();
assert_eq!(pass.page_count(), pages, "a same-size update opened a page");
assert_eq!(
draw_screen_target(&device, &queue, &mut pass, &list, (4, 2)),
side_by_side(neighbour, &uploaded),
"uploading a known handle did not replace its pixels"
);
}
#[test]
fn a_republished_glyph_page_reaches_the_existing_pass() {
use crate::canvas::text::{TextChannel, TextRenderer, TextStyle};
let Some((device, queue)) = device() else {
return;
};
let mut pass = SpritePass::new(
&device,
&queue,
wgpu::TextureFormat::Rgba8Unorm,
wgpu::TextureFormat::Rgba8Unorm,
LightingSpace::Gamma,
);
let mut assets = Assets::<Texture>::new();
let icon = assets.insert(
"icon.png".into(),
quad_texels([[10, 20, 30], [40, 50, 60], [70, 80, 90], [100, 110, 120]]),
);
pass.upload(&device, &queue, icon, assets.get(icon).unwrap())
.unwrap();
let icon_texels = assets.get(icon).unwrap().rgba.clone();
let mut text = TextRenderer::new(include_bytes!(
"../../tests/fixtures/IBMPlexSans-Regular.ttf"
))
.expect("test font should parse");
let style = TextStyle::new(24.0, [1.0; 4]);
let mut list = DrawList::new();
text.draw("A", Vec2::new(4.0, 4.0), &style, 0.0, TextChannel::Screen);
let changed = text.end_frame(&mut assets, &mut list);
let [page] = changed[..] else {
panic!("expected one new page, got {changed:?}")
};
pass.upload(&device, &queue, page, assets.get(page).unwrap())
.unwrap();
draw_screen_target(&device, &queue, &mut pass, &list, (64, 64));
let before = assets.get(page).unwrap().rgba.clone();
list.clear();
text.draw("Wq", Vec2::new(4.0, 4.0), &style, 0.0, TextChannel::Screen);
let changed = text.end_frame(&mut assets, &mut list);
assert_eq!(changed, [page], "the page kept its handle");
let republished = assets.get(page).unwrap();
let pages = pass.page_count();
pass.upload(&device, &queue, page, republished).unwrap();
assert_eq!(pass.page_count(), pages, "the page update opened a page");
let (w, h) = list.screen.iter().fold((0, 0), |(w, h), quad| {
let src = quad.src.expect("glyph quads carry a src rect");
(w.max(src.max.x as u32), h.max(src.max.y as u32))
});
let mut probe = DrawList::new();
probe.push_screen(SpriteInstance {
src: Some(Rect::new(0.0, 0.0, w as f32, h as f32)),
..SpriteInstance::new(page, Vec2::new(w as f32, h as f32) * 0.5)
});
probe.push_screen(SpriteInstance::new(icon, Vec2::new(1.0, h as f32 + 1.0)));
let pixels = draw_screen_target(&device, &queue, &mut pass, &probe, (w, h + 2));
let page_row = |rgba: &[u8], y: u32| -> Vec<u8> {
let start = (y * GLYPH_PAGE_SIZE * 4) as usize;
rgba[start..start + (w * 4) as usize]
.chunks_exact(4)
.flat_map(|t| {
let a = u32::from(t[3]);
let pm = |c: u8| ((u32::from(c) * a + 127) / 255) as u8;
[pm(t[0]), pm(t[1]), pm(t[2]), t[3]]
})
.collect()
};
let stride = (w * 4) as usize;
let mut changed_rows = 0;
for y in 0..h {
let got = &pixels[y as usize * stride..(y as usize + 1) * stride];
assert_eq!(got, page_row(&republished.rgba, y), "page row {y}");
changed_rows += usize::from(got != page_row(&before, y));
}
assert!(
changed_rows > 0,
"frame 2 added no ink to the probed region"
);
for y in 0..2 {
let row = &pixels[(h + y) as usize * stride..][..8];
assert_eq!(row, &icon_texels[y as usize * 8..][..8], "icon row {y}");
}
}
#[test]
fn standalone_resizes_reuse_their_page() {
let Some((device, queue)) = device() else {
return;
};
let mut pass = SpritePass::new(
&device,
&queue,
wgpu::TextureFormat::Rgba8Unorm,
wgpu::TextureFormat::Rgba8Unorm,
LightingSpace::Gamma,
);
let mut assets = Assets::<Texture>::new();
let other = assets.insert(
"other.png".into(),
flat(MAX_ATLAS_DIM + 1, 1, [9, 9, 9, 255]),
);
let resized = assets.insert("resized.png".into(), flat(MAX_ATLAS_DIM + 1, 1, [1; 4]));
for handle in [other, resized] {
pass.upload(&device, &queue, handle, assets.get(handle).unwrap())
.unwrap();
}
let pages = pass.page_count();
let pattern = |w: u32, h: u32| Texture {
width: w,
height: h,
rgba: (0..h)
.flat_map(|y| (0..w).flat_map(move |x| [x as u8, y as u8, (x + y) as u8, 255]))
.collect(),
};
for step in 0..8 {
let tex = flat(MAX_ATLAS_DIM + 2 + step, 1 + step % 3, [step as u8; 4]);
pass.upload(&device, &queue, resized, &tex).unwrap();
}
pass.upload(&device, &queue, resized, &flat(2, 2, [7; 4]))
.unwrap();
let with_atlas = pass.page_count();
assert_eq!(with_atlas, pages + 1, "the atlas page");
pass.upload(&device, &queue, resized, &pattern(MAX_ATLAS_DIM + 5, 3))
.unwrap();
assert_eq!(
pass.page_count(),
with_atlas,
"standalone resizes opened pages"
);
let mut list = DrawList::new();
list.push_screen(SpriteInstance {
src: Some(Rect::new(0.0, 0.0, 4.0, 3.0)),
..SpriteInstance::new(resized, Vec2::new(2.0, 1.5))
});
let pixels = draw_screen_target(&device, &queue, &mut pass, &list, (4, 3));
assert_eq!(pixels, pattern(4, 3).rgba);
let mut list = DrawList::new();
list.push_screen(SpriteInstance {
src: Some(Rect::new(0.0, 0.0, 1.0, 1.0)),
scale: Vec2::splat(2.0),
..SpriteInstance::new(other, Vec2::splat(1.0))
});
let pixels = draw_screen_target(&device, &queue, &mut pass, &list, (2, 2));
assert!(pixels.chunks_exact(4).all(|p| p == [9, 9, 9, 255]));
}
#[derive(Default)]
struct Recorder {
page: Option<wgpu::BindGroup>,
scissor: Option<[u32; 4]>,
draws: Vec<(Range<u32>, wgpu::BindGroup, Option<[u32; 4]>)>,
}
impl PassEncoder for Recorder {
fn set_pipeline(&mut self, _: &wgpu::RenderPipeline) {}
fn set_vertex_buffer(&mut self, _: u32, _: wgpu::BufferSlice<'_>) {}
fn set_bind_group(&mut self, index: u32, group: &wgpu::BindGroup) {
if index == 1 {
self.page = Some(group.clone());
}
}
fn set_scissor_rect(&mut self, x: u32, y: u32, width: u32, height: u32) {
self.scissor = Some([x, y, width, height]);
}
fn draw(&mut self, _: Range<u32>, instances: Range<u32>) {
let page = self.page.clone().expect("draw without a page bound");
self.draws.push((instances, page, self.scissor));
}
}
impl Recorder {
fn observed(&self) -> ChannelDrawStats {
ChannelDrawStats {
draws: self.draws.len() as u32,
instances: self.draws.iter().map(|(r, ..)| r.len() as u32).sum(),
}
}
fn pages(&self) -> usize {
let mut pages: Vec<&wgpu::BindGroup> = Vec::new();
for (_, page, _) in &self.draws {
if !pages.contains(&page) {
pages.push(page);
}
}
pages.len()
}
}
#[test]
fn draw_stats_match_the_encoded_draws() {
let Some((device, queue)) = device() else {
return;
};
let mut pass = SpritePass::new(
&device,
&queue,
wgpu::TextureFormat::Rgba8Unorm,
wgpu::TextureFormat::Rgba8Unorm,
LightingSpace::Gamma,
);
let mut assets = Assets::<Texture>::new();
let a = assets.insert("a.png".into(), flat(1, 1, [255; 4]));
let b = assets.insert("b.png".into(), flat(1, 1, [255; 4]));
let big = assets.insert("big.png".into(), flat(MAX_ATLAS_DIM + 1, 1, [255; 4]));
let missing = assets.insert("missing.png".into(), flat(1, 1, [255; 4]));
for handle in [a, b, big] {
pass.upload(&device, &queue, handle, assets.get(handle).unwrap())
.unwrap();
}
let target = (64, 32);
let clip_one = Rect::new(2.0, 3.0, 10.0, 5.0); let clip_two = Rect::new(20.5, 0.0, 4.0, 4.0); let off_target = Rect::new(100.0, 0.0, 8.0, 8.0);
let sprite = |texture, clip: Option<Rect>| SpriteInstance {
clip,
..SpriteInstance::new(texture, Vec2::splat(4.0))
};
let mut list = DrawList::new();
for instance in [
sprite(a, None), sprite(b, None),
sprite(a, None),
sprite(big, None), sprite(a, None), sprite(missing, None), sprite(a, Some(clip_one)), sprite(b, Some(clip_one)),
sprite(a, Some(clip_two)), sprite(a, Some(off_target)), sprite(a, None), sprite(missing, None), sprite(a, None),
] {
list.push_screen(instance);
}
list.push(sprite(a, None)); list.push(sprite(b, None));
list.push(sprite(big, None)); pass.prepare(
&device,
&queue,
&list,
Mat4::IDENTITY,
WorldUnits::default(),
Mat4::IDENTITY,
target,
1.0,
);
let mut screen = Recorder::default();
pass.draw_channel(&mut screen, &pass.screen_pipeline, 1);
let mut world = Recorder::default();
pass.draw_channel(&mut world, &pass.scene_pipeline, 0);
let stats = pass.draw_stats();
assert_eq!(
stats.screen,
screen.observed(),
"screen: reported vs encoded"
);
assert_eq!(stats.world, world.observed(), "world: reported vs encoded");
assert_eq!(
stats.screen,
ChannelDrawStats {
draws: 6,
instances: 10
}
);
assert_eq!(
stats.world,
ChannelDrawStats {
draws: 2,
instances: 3
}
);
assert_eq!((screen.pages(), world.pages()), (2, 2));
let scissors: Vec<_> = screen.draws.iter().map(|d| d.2).collect();
assert_eq!(scissors[3], Some([2, 3, 10, 5]), "clip one");
assert_eq!(scissors[4], Some([20, 0, 5, 4]), "clip two");
assert_eq!(scissors[5], Some([0, 0, 64, 32]), "unclipped after a clip");
pass.prepare(
&device,
&queue,
&DrawList::new(),
Mat4::IDENTITY,
WorldUnits::default(),
Mat4::IDENTITY,
target,
1.0,
);
let mut empty = Recorder::default();
pass.draw_channel(&mut empty, &pass.screen_pipeline, 1);
assert_eq!(pass.draw_stats(), SpriteDrawStats::default());
assert!(empty.draws.is_empty());
}
#[test]
fn linear_scene_pass_decodes_srgb_texels() {
let Some(bytes) = scene_albedo(LightingSpace::Linear, [128, 128, 128, 255]) else {
return;
};
let px = rgba16f_to_f32(&bytes);
for p in px.chunks_exact(4) {
for c in &p[..3] {
assert!((c - 0.2159).abs() < 2e-3, "{p:?}");
}
assert!((p[3] - 1.0).abs() < 1e-3, "{p:?}");
}
}
#[test]
fn gamma_scene_pass_stores_texels_raw() {
let Some(bytes) = scene_albedo(LightingSpace::Gamma, [128, 128, 128, 255]) else {
return;
};
for p in bytes.chunks_exact(4) {
assert_eq!(p, [128, 128, 128, 255], "{p:?}");
}
}
#[test]
fn instances_past_the_device_buffer_limit_are_dropped() {
if device().is_none() {
return;
}
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
let adapter =
pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions::default()))
.expect("an adapter, as device() found one");
let max_instances = 300u64;
let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
required_limits: wgpu::Limits {
max_buffer_size: max_instances * size_of::<InstanceRaw>() as u64,
..wgpu::Limits::default()
},
..Default::default()
}))
.unwrap();
let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
let mut pass = SpritePass::new(
&device,
&queue,
wgpu::TextureFormat::Rgba8Unorm,
wgpu::TextureFormat::Rgba8Unorm,
LightingSpace::Gamma,
);
let mut assets = Assets::<Texture>::new();
let white = assets.insert("white.png".into(), flat(1, 1, [255; 4]));
pass.upload(&device, &queue, white, assets.get(white).unwrap())
.unwrap();
let side = 20u32;
let mut list = DrawList::new();
for i in 0..side * side {
let (x, y) = ((i % side) as f32, (i / side) as f32);
list.push_screen(SpriteInstance::new(white, Vec2::new(x + 0.5, y + 0.5)));
}
let pixels = draw_screen_target(&device, &queue, &mut pass, &list, (side, side));
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
if let Some(error) = pollster::block_on(validation.pop()) {
panic!("{error}");
}
assert_eq!(pass.draw_stats().screen.instances, max_instances as u32);
for (i, p) in pixels.chunks_exact(4).enumerate() {
let expected = if (i as u64) < max_instances {
[255; 4]
} else {
[0; 4]
};
assert_eq!(p, expected, "pixel {i}");
}
}
}