use crate::assets::{Handle, Texture};
use crate::canvas::camera::WorldUnits;
use sgl_core::math::Vec2;
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Rect {
pub min: Vec2,
pub max: Vec2,
}
impl Rect {
pub fn new(x: f32, y: f32, w: f32, h: f32) -> Self {
Self {
min: Vec2::new(x, y),
max: Vec2::new(x + w, y + h),
}
}
pub fn sheet_frame(index: usize, frame_w: u32, frame_h: u32, columns: usize) -> Self {
let columns = columns.max(1);
let col = index % columns;
let row = index / columns;
Self::new(
(col as u32 * frame_w) as f32,
(row as u32 * frame_h) as f32,
frame_w as f32,
frame_h as f32,
)
}
pub fn size(&self) -> Vec2 {
self.max - self.min
}
pub fn intersection(&self, other: &Rect) -> Option<Rect> {
let min = self.min.max(other.min);
let max = self.max.min(other.max);
if min.x < max.x && min.y < max.y {
Some(Rect { min, max })
} else {
None
}
}
}
#[derive(Debug, Clone, Copy)]
pub struct SpriteInstance {
pub texture: Handle<Texture>,
pub src: Option<Rect>,
pub pos: Vec2,
pub rot: f32,
pub scale: Vec2,
pub color: [f32; 4],
pub z: f32,
pub flip_x: bool,
pub flip_y: bool,
pub normal: Option<Handle<Texture>>,
pub light_mask: u32,
pub clip: Option<Rect>,
}
impl SpriteInstance {
pub fn new(texture: Handle<Texture>, pos: Vec2) -> Self {
Self {
texture,
src: None,
pos,
rot: 0.0,
scale: Vec2::ONE,
color: [1.0, 1.0, 1.0, 1.0],
z: 0.0,
flip_x: false,
flip_y: false,
normal: None,
light_mask: 1,
clip: None,
}
}
}
pub const MAX_TILED_QUADS: usize = 1 << 16;
fn quad(
template: &SpriteInstance,
offset: Vec2,
src: Rect,
scale: Vec2,
units: WorldUnits,
) -> SpriteInstance {
let offset = Vec2::new(offset.x, offset.y * units.screen_y_sign()) / units.pixels_per_unit;
let offset = if template.rot == 0.0 {
offset
} else {
Vec2::from_angle(template.rot).rotate(offset)
};
SpriteInstance {
src: Some(src),
pos: template.pos + offset,
scale,
..*template
}
}
pub fn expand_tiled(
out: &mut Vec<SpriteInstance>,
template: &SpriteInstance,
src: Rect,
size: Vec2,
tile: Vec2,
units: WorldUnits,
) {
let size = size * units.pixels_per_unit;
let tile = tile * units.pixels_per_unit;
let src_size = src.size();
if !(size.x > 0.0
&& size.y > 0.0
&& tile.x > 0.0
&& tile.y > 0.0
&& src_size.x > 0.0
&& src_size.y > 0.0)
{
return;
}
let cols = (size.x / tile.x).ceil();
let rows = (size.y / tile.y).ceil();
if cols * rows > MAX_TILED_QUADS as f32 {
return;
}
let scale = tile / src_size;
let half = size * 0.5;
for row in 0..rows as usize {
let y = row as f32 * tile.y;
let h = (y + tile.y).min(size.y) - y;
if h <= 0.0 {
continue;
}
for col in 0..cols as usize {
let x = col as f32 * tile.x;
let w = (x + tile.x).min(size.x) - x;
if w <= 0.0 {
continue;
}
let frac = Vec2::new(w / tile.x, h / tile.y);
out.push(quad(
template,
Vec2::new(x + w * 0.5, y + h * 0.5) - half,
Rect {
min: src.min,
max: src.min + src_size * frac,
},
scale,
units,
));
}
}
}
pub fn expand_nine_slice(
out: &mut Vec<SpriteInstance>,
template: &SpriteInstance,
src: Rect,
size: Vec2,
border_px: f32,
units: WorldUnits,
) {
let size = size * units.pixels_per_unit;
let src_size = src.size();
if !(size.x > 0.0 && size.y > 0.0 && border_px >= 0.0 && src_size.x > 0.0 && src_size.y > 0.0) {
return;
}
let bx = border_px.min(src_size.x * 0.5).min(size.x * 0.5);
let by = border_px.min(src_size.y * 0.5).min(size.y * 0.5);
let col_w = [bx, size.x - 2.0 * bx, bx];
let row_h = [by, size.y - 2.0 * by, by];
let src_w = [bx, src_size.x - 2.0 * bx, bx];
let src_h = [by, src_size.y - 2.0 * by, by];
let half = size * 0.5;
let mut y = 0.0;
let mut src_y = src.min.y;
for (&h, &sh) in row_h.iter().zip(&src_h) {
let mut x = 0.0;
let mut src_x = src.min.x;
for (&w, &sw) in col_w.iter().zip(&src_w) {
if w > 0.0 && h > 0.0 && sw > 0.0 && sh > 0.0 {
out.push(quad(
template,
Vec2::new(x + w * 0.5, y + h * 0.5) - half,
Rect {
min: Vec2::new(src_x, src_y),
max: Vec2::new(src_x + sw, src_y + sh),
},
Vec2::new(w / sw, h / sh),
units,
));
}
x += w;
src_x += sw;
}
y += h;
src_y += sh;
}
}
#[derive(Debug, Default)]
pub struct DrawList {
pub world: Vec<SpriteInstance>,
pub screen: Vec<SpriteInstance>,
}
impl DrawList {
pub fn new() -> Self {
Self::default()
}
pub fn clear(&mut self) {
self.world.clear();
self.screen.clear();
}
pub fn push(&mut self, instance: SpriteInstance) {
self.world.push(instance);
}
pub fn push_screen(&mut self, instance: SpriteInstance) {
self.screen.push(instance);
}
pub fn push_tiled(
&mut self,
template: &SpriteInstance,
src: Rect,
size: Vec2,
tile: Vec2,
units: WorldUnits,
) {
expand_tiled(&mut self.world, template, src, size, tile, units);
}
pub fn push_screen_tiled(
&mut self,
template: &SpriteInstance,
src: Rect,
size: Vec2,
tile: Vec2,
) {
expand_tiled(
&mut self.screen,
template,
src,
size,
tile,
WorldUnits::default(),
);
}
pub fn push_nine_slice(
&mut self,
template: &SpriteInstance,
src: Rect,
size: Vec2,
border_px: f32,
units: WorldUnits,
) {
expand_nine_slice(&mut self.world, template, src, size, border_px, units);
}
pub fn push_screen_nine_slice(
&mut self,
template: &SpriteInstance,
src: Rect,
size: Vec2,
border_px: f32,
) {
expand_nine_slice(
&mut self.screen,
template,
src,
size,
border_px,
WorldUnits::default(),
);
}
pub fn sort(&mut self) {
let by_z = |a: &SpriteInstance, b: &SpriteInstance| {
a.z.partial_cmp(&b.z).unwrap_or(std::cmp::Ordering::Equal)
};
self.world.sort_by(by_z);
self.screen.sort_by(by_z);
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::path::PathBuf;
use wasm_bindgen_test::wasm_bindgen_test;
#[wasm_bindgen_test(unsupported = test)]
fn expansion_guards_are_strict_at_zero() {
let template = template();
let unit = Rect::new(0.0, 0.0, 1.0, 1.0);
let cases = [
(Vec2::new(0.0, 4.0), Vec2::ONE, unit, true),
(Vec2::new(4.0, 0.0), Vec2::ONE, unit, true),
(Vec2::splat(4.0), Vec2::new(0.0, 1.0), unit, false),
(Vec2::splat(4.0), Vec2::new(1.0, 0.0), unit, false),
(
Vec2::splat(4.0),
Vec2::ONE,
Rect::new(0.0, 0.0, 0.0, 1.0),
true,
),
(
Vec2::splat(4.0),
Vec2::ONE,
Rect::new(0.0, 0.0, 1.0, 0.0),
true,
),
];
for (size, tile, src, nine_slice_too) in cases {
let mut out = Vec::new();
expand_tiled(&mut out, &template, src, size, tile, WorldUnits::default());
assert!(out.is_empty(), "tiled {size} {tile} {src:?}");
if nine_slice_too {
let mut out = Vec::new();
expand_nine_slice(&mut out, &template, src, size, 1.0, WorldUnits::default());
assert!(out.is_empty(), "nine-slice {size} {src:?}");
}
}
let mut out = Vec::new();
expand_tiled(
&mut out,
&template,
unit,
Vec2::splat(f32::MIN_POSITIVE),
Vec2::ONE,
WorldUnits::default(),
);
assert_eq!(out.len(), 1);
let mut out = Vec::new();
expand_nine_slice(
&mut out,
&template,
unit,
Vec2::splat(f32::MIN_POSITIVE),
0.0,
WorldUnits::default(),
);
assert_eq!(out.len(), 1);
}
#[wasm_bindgen_test(unsupported = test)]
fn intersection_is_strict_and_never_empty() {
let a = Rect::new(0.0, 0.0, 4.0, 4.0);
assert_eq!(
a.intersection(&Rect::new(4.0, 0.0, 4.0, 4.0)),
None,
"touching right"
);
assert_eq!(
a.intersection(&Rect::new(0.0, 4.0, 4.0, 4.0)),
None,
"touching below"
);
assert_eq!(
a.intersection(&Rect::new(-4.0, 0.0, 4.0, 4.0)),
None,
"touching left"
);
assert_eq!(
a.intersection(&Rect::new(2.0, 2.0, 0.0, 3.0)),
None,
"zero width"
);
assert_eq!(
a.intersection(&Rect::new(3.0, 3.0, 4.0, 4.0)),
Some(Rect::new(3.0, 3.0, 1.0, 1.0))
);
assert_eq!(
Rect::new(5.0, 5.0, 1.0, 1.0).intersection(&a),
None,
"disjoint"
);
}
use crate::assets::Assets;
fn handle(n: u32) -> Handle<Texture> {
let mut assets: Assets<Texture> = Assets::new();
let mut h = None;
for i in 0..=n {
h = Some(assets.insert(
PathBuf::from(format!("{i}.png")),
Texture {
width: 1,
height: 1,
rgba: vec![0; 4],
},
));
}
h.unwrap()
}
fn sprite(z: f32, tag: f32) -> SpriteInstance {
SpriteInstance {
z,
rot: tag,
..SpriteInstance::new(handle(0), Vec2::ZERO)
}
}
#[wasm_bindgen_test(unsupported = test)]
fn sort_is_by_z_then_push_order() {
let mut list = DrawList::new();
list.push(sprite(2.0, 0.0));
list.push(sprite(0.0, 1.0));
list.push(sprite(1.0, 2.0));
list.push(sprite(0.0, 3.0)); list.sort();
let order: Vec<f32> = list.world.iter().map(|s| s.rot).collect();
assert_eq!(order, vec![1.0, 3.0, 2.0, 0.0]);
}
#[wasm_bindgen_test(unsupported = test)]
fn screen_channel_sorts_independently() {
let mut list = DrawList::new();
list.push(sprite(5.0, 0.0));
list.push_screen(sprite(9.0, 1.0));
list.push_screen(sprite(-1.0, 2.0));
list.sort();
assert_eq!(list.world.len(), 1);
let screen: Vec<f32> = list.screen.iter().map(|s| s.rot).collect();
assert_eq!(screen, vec![2.0, 1.0]);
}
#[wasm_bindgen_test(unsupported = test)]
fn sheet_frame_cuts_single_row_sheets() {
let f0 = Rect::sheet_frame(0, 32, 32, 3);
let f2 = Rect::sheet_frame(2, 32, 32, 3);
assert_eq!(f0, Rect::new(0.0, 0.0, 32.0, 32.0));
assert_eq!(f2, Rect::new(64.0, 0.0, 32.0, 32.0));
assert_eq!(f2.size(), Vec2::new(32.0, 32.0));
}
#[wasm_bindgen_test(unsupported = test)]
fn sheet_frame_wraps_rows() {
let f5 = Rect::sheet_frame(5, 16, 16, 4);
assert_eq!(f5, Rect::new(16.0, 16.0, 16.0, 16.0));
}
#[wasm_bindgen_test(unsupported = test)]
fn new_sprite_has_light_defaults() {
let s = SpriteInstance::new(handle(0), Vec2::ZERO);
assert_eq!(s.light_mask, 1);
assert!(s.normal.is_none());
}
fn extent_in(s: &SpriteInstance, ppu: f32) -> (Vec2, Vec2) {
let size = s.src.expect("an expanded quad always carries a src").size() * s.scale / ppu;
(s.pos - size * 0.5, s.pos + size * 0.5)
}
fn coverage(quads: &[SpriteInstance]) -> (Vec2, Vec2, f32) {
coverage_in(quads, 1.0)
}
fn coverage_in(quads: &[SpriteInstance], ppu: f32) -> (Vec2, Vec2, f32) {
let mut min = Vec2::splat(f32::INFINITY);
let mut max = Vec2::splat(f32::NEG_INFINITY);
let mut area = 0.0;
for q in quads {
let (lo, hi) = extent_in(q, ppu);
min = min.min(lo);
max = max.max(hi);
area += (hi.x - lo.x) * (hi.y - lo.y);
}
(min, max, area)
}
fn template() -> SpriteInstance {
SpriteInstance::new(handle(0), Vec2::ZERO)
}
fn units32() -> WorldUnits {
WorldUnits {
pixels_per_unit: 32.0,
y_up: true,
}
}
#[wasm_bindgen_test(unsupported = test)]
fn tiled_grid_lays_out_in_world_units_with_y_up() {
let t = SpriteInstance {
pos: Vec2::new(10.0, 5.0),
..template()
};
let mut out = Vec::new();
expand_tiled(
&mut out,
&t,
Rect::new(0.0, 0.0, 16.0, 16.0),
Vec2::new(2.0, 1.5),
Vec2::ONE,
units32(),
);
assert_eq!(out.len(), 4);
assert_eq!(out[0].pos, Vec2::new(9.5, 5.25));
assert_eq!(out[0].src, Some(Rect::new(0.0, 0.0, 16.0, 16.0)));
assert_eq!(out[0].scale, Vec2::splat(2.0));
assert_eq!(out[1].pos, Vec2::new(10.5, 5.25));
assert_eq!(out[2].pos, Vec2::new(9.5, 4.5));
assert_eq!(out[2].src, Some(Rect::new(0.0, 0.0, 16.0, 8.0)));
assert_eq!(out[2].scale, Vec2::splat(2.0));
let (min, max, area) = coverage_in(&out, 32.0);
assert_eq!(min, Vec2::new(9.0, 4.25));
assert_eq!(max, Vec2::new(11.0, 5.75));
assert_eq!(area, 2.0 * 1.5);
}
#[wasm_bindgen_test(unsupported = test)]
fn nine_slice_lays_out_in_world_units_with_y_up() {
let mut out = Vec::new();
expand_nine_slice(
&mut out,
&template(),
Rect::new(0.0, 0.0, 16.0, 16.0),
Vec2::new(2.0, 1.0),
4.0,
units32(),
);
assert_eq!(out.len(), 9);
let (min, max, area) = coverage_in(&out, 32.0);
assert_eq!(min, Vec2::new(-1.0, -0.5));
assert_eq!(max, Vec2::new(1.0, 0.5));
assert_eq!(area, 2.0 * 1.0, "the nine quads tile the target once");
assert_eq!(out[0].pos, Vec2::new(-0.9375, 0.4375));
assert_eq!(out[0].src, Some(Rect::new(0.0, 0.0, 4.0, 4.0)));
assert_eq!(out[0].scale, Vec2::ONE);
assert_eq!(out[1].pos, Vec2::new(0.0, 0.4375));
assert_eq!(out[1].src, Some(Rect::new(4.0, 0.0, 8.0, 4.0)));
assert_eq!(out[1].scale, Vec2::new(7.0, 1.0));
assert_eq!(out[4].pos, Vec2::ZERO);
assert_eq!(out[4].src, Some(Rect::new(4.0, 4.0, 8.0, 8.0)));
assert_eq!(out[4].scale, Vec2::new(7.0, 3.0));
assert_eq!(out[8].pos, Vec2::new(0.9375, -0.4375));
assert_eq!(out[8].src, Some(Rect::new(12.0, 12.0, 4.0, 4.0)));
assert_eq!(out[8].scale, Vec2::ONE);
}
#[wasm_bindgen_test(unsupported = test)]
fn tiled_rotation_turns_a_y_up_grid_in_world_axes() {
let t = SpriteInstance {
rot: std::f32::consts::FRAC_PI_2,
..template()
};
let mut out = Vec::new();
expand_tiled(
&mut out,
&t,
Rect::new(0.0, 0.0, 8.0, 8.0),
Vec2::new(1.0, 2.0),
Vec2::ONE,
WorldUnits {
pixels_per_unit: 16.0,
y_up: true,
},
);
assert_eq!(out.len(), 2);
assert!(
(out[0].pos - Vec2::new(-0.5, 0.0)).length() < 1e-4,
"{:?}",
out[0].pos
);
assert!(
(out[1].pos - Vec2::new(0.5, 0.0)).length() < 1e-4,
"{:?}",
out[1].pos
);
}
#[wasm_bindgen_test(unsupported = test)]
fn tiled_grid_clips_the_last_column_to_a_partial_src() {
let src = Rect::new(0.0, 0.0, 8.0, 8.0);
let t = SpriteInstance {
pos: Vec2::new(100.0, 50.0),
..template()
};
let mut out = Vec::new();
expand_tiled(
&mut out,
&t,
src,
Vec2::new(40.0, 16.0),
Vec2::new(16.0, 8.0),
WorldUnits::default(),
);
assert_eq!(out.len(), 6);
let (min, max, area) = coverage(&out);
assert_eq!(min, Vec2::new(80.0, 42.0));
assert_eq!(max, Vec2::new(120.0, 58.0));
assert_eq!(area, 40.0 * 16.0, "tiles cover the target exactly, once");
assert_eq!(out[0].pos, Vec2::new(88.0, 46.0));
assert_eq!(out[0].src, Some(Rect::new(0.0, 0.0, 8.0, 8.0)));
assert_eq!(out[0].scale, Vec2::new(2.0, 1.0));
assert_eq!(out[2].pos, Vec2::new(116.0, 46.0));
assert_eq!(out[2].src, Some(Rect::new(0.0, 0.0, 4.0, 8.0)));
assert_eq!(out[2].scale, Vec2::new(2.0, 1.0));
assert_eq!(out[4].pos, Vec2::new(104.0, 54.0));
assert_eq!(out[4].src, Some(Rect::new(0.0, 0.0, 8.0, 8.0)));
}
#[wasm_bindgen_test(unsupported = test)]
fn tiled_rejects_degenerate_and_unbounded_grids() {
let src = Rect::new(0.0, 0.0, 8.0, 8.0);
let t = template();
let tile = Vec2::new(8.0, 8.0);
let size = Vec2::new(16.0, 16.0);
for (src, size, tile) in [
(src, Vec2::new(0.0, 16.0), tile),
(src, Vec2::new(16.0, -1.0), tile),
(src, size, Vec2::new(0.0, 8.0)),
(src, size, Vec2::new(8.0, -8.0)),
(Rect::new(0.0, 0.0, 0.0, 8.0), size, tile),
] {
let mut out = Vec::new();
expand_tiled(&mut out, &t, src, size, tile, WorldUnits::default());
assert!(out.is_empty(), "size {size:?} tile {tile:?} src {src:?}");
}
let mut out = Vec::new();
expand_tiled(
&mut out,
&t,
src,
Vec2::splat(300.0),
Vec2::ONE,
WorldUnits::default(),
);
assert!(out.is_empty(), "an over-large grid emits nothing");
expand_tiled(
&mut out,
&t,
src,
Vec2::splat(200.0),
Vec2::ONE,
WorldUnits::default(),
);
assert_eq!(out.len(), 40_000);
}
#[wasm_bindgen_test(unsupported = test)]
fn tiled_rotation_turns_the_grid_about_the_center() {
let quarter = std::f32::consts::FRAC_PI_2;
let t = SpriteInstance {
rot: quarter,
..template()
};
let mut out = Vec::new();
expand_tiled(
&mut out,
&t,
Rect::new(0.0, 0.0, 8.0, 8.0),
Vec2::new(16.0, 8.0),
Vec2::new(8.0, 8.0),
WorldUnits::default(),
);
assert_eq!(out.len(), 2);
assert!(
(out[0].pos - Vec2::new(0.0, -4.0)).length() < 1e-4,
"{:?}",
out[0].pos
);
assert!(
(out[1].pos - Vec2::new(0.0, 4.0)).length() < 1e-4,
"{:?}",
out[1].pos
);
assert_eq!(out[0].rot, quarter);
assert_eq!(out[1].rot, quarter);
}
#[wasm_bindgen_test(unsupported = test)]
fn tiled_flips_ride_each_quad_over_the_leading_src_edge() {
let t = SpriteInstance {
flip_x: true,
flip_y: true,
color: [0.25, 0.5, 0.75, 0.5],
z: 7.0,
light_mask: 4,
..template()
};
let mut out = Vec::new();
expand_tiled(
&mut out,
&t,
Rect::new(2.0, 3.0, 8.0, 8.0),
Vec2::new(12.0, 8.0),
Vec2::new(8.0, 8.0),
WorldUnits::default(),
);
assert_eq!(out.len(), 2);
assert!(out.iter().all(|q| q.flip_x && q.flip_y));
assert!(out.iter().all(|q| q.z == 7.0 && q.light_mask == 4));
assert!(out.iter().all(|q| q.color == [0.25, 0.5, 0.75, 0.5]));
assert_eq!(out[0].src, Some(Rect::new(2.0, 3.0, 8.0, 8.0)));
assert_eq!(out[1].src, Some(Rect::new(2.0, 3.0, 4.0, 8.0)));
assert_eq!(out[0].pos, Vec2::new(-2.0, 0.0));
assert_eq!(out[1].pos, Vec2::new(4.0, 0.0));
}
#[wasm_bindgen_test(unsupported = test)]
fn nine_slice_tiles_the_target_with_native_corners() {
let mut out = Vec::new();
expand_nine_slice(
&mut out,
&template(),
Rect::new(0.0, 0.0, 16.0, 16.0),
Vec2::new(40.0, 24.0),
4.0,
WorldUnits::default(),
);
assert_eq!(out.len(), 9);
let (min, max, area) = coverage(&out);
assert_eq!(min, Vec2::new(-20.0, -12.0));
assert_eq!(max, Vec2::new(20.0, 12.0));
assert_eq!(area, 40.0 * 24.0, "the nine quads tile the target once");
assert_eq!(out[0].pos, Vec2::new(-18.0, -10.0));
assert_eq!(out[0].src, Some(Rect::new(0.0, 0.0, 4.0, 4.0)));
assert_eq!(out[0].scale, Vec2::ONE);
assert_eq!(out[1].pos, Vec2::new(0.0, -10.0));
assert_eq!(out[1].src, Some(Rect::new(4.0, 0.0, 8.0, 4.0)));
assert_eq!(out[1].scale, Vec2::new(4.0, 1.0));
assert_eq!(out[4].pos, Vec2::ZERO);
assert_eq!(out[4].src, Some(Rect::new(4.0, 4.0, 8.0, 8.0)));
assert_eq!(out[4].scale, Vec2::new(4.0, 2.0));
assert_eq!(out[8].pos, Vec2::new(18.0, 10.0));
assert_eq!(out[8].src, Some(Rect::new(12.0, 12.0, 4.0, 4.0)));
assert_eq!(out[8].scale, Vec2::ONE);
}
#[wasm_bindgen_test(unsupported = test)]
fn nine_slice_drops_the_zero_width_center_column() {
let mut out = Vec::new();
expand_nine_slice(
&mut out,
&template(),
Rect::new(0.0, 0.0, 16.0, 16.0),
Vec2::new(8.0, 24.0),
4.0,
WorldUnits::default(),
);
assert_eq!(out.len(), 6, "three rows × two surviving columns");
let (min, max, area) = coverage(&out);
assert_eq!(min, Vec2::new(-4.0, -12.0));
assert_eq!(max, Vec2::new(4.0, 12.0));
assert_eq!(area, 8.0 * 24.0);
assert_eq!(out[0].pos, Vec2::new(-2.0, -10.0));
assert_eq!(out[0].scale, Vec2::ONE);
assert_eq!(out[1].pos, Vec2::new(2.0, -10.0));
assert_eq!(out[1].src, Some(Rect::new(12.0, 0.0, 4.0, 4.0)));
assert_eq!(out[2].pos, Vec2::new(-2.0, 0.0));
assert_eq!(out[2].src, Some(Rect::new(0.0, 4.0, 4.0, 8.0)));
assert_eq!(out[2].scale, Vec2::new(1.0, 2.0));
}
#[wasm_bindgen_test(unsupported = test)]
fn nine_slice_corners_stay_native_on_a_tiny_target() {
let mut out = Vec::new();
expand_nine_slice(
&mut out,
&template(),
Rect::new(0.0, 0.0, 16.0, 16.0),
Vec2::splat(6.0),
4.0,
WorldUnits::default(),
);
assert_eq!(out.len(), 4, "only the corners survive");
for q in &out {
assert_eq!(q.scale, Vec2::ONE);
assert_eq!(q.src.unwrap().size(), Vec2::splat(3.0));
}
let (min, max, area) = coverage(&out);
assert_eq!((min, max), (Vec2::splat(-3.0), Vec2::splat(3.0)));
assert_eq!(area, 36.0);
assert_eq!(out[0].src, Some(Rect::new(0.0, 0.0, 3.0, 3.0)));
assert_eq!(out[1].src, Some(Rect::new(13.0, 0.0, 3.0, 3.0)));
assert_eq!(out[3].src, Some(Rect::new(13.0, 13.0, 3.0, 3.0)));
}
#[wasm_bindgen_test(unsupported = test)]
fn nine_slice_border_clamps_to_half_the_source() {
let mut out = Vec::new();
expand_nine_slice(
&mut out,
&template(),
Rect::new(0.0, 0.0, 4.0, 4.0),
Vec2::splat(20.0),
10.0,
WorldUnits::default(),
);
assert_eq!(out.len(), 4);
assert_eq!(out[0].pos, Vec2::splat(-9.0));
assert_eq!(out[0].src, Some(Rect::new(0.0, 0.0, 2.0, 2.0)));
assert_eq!(out[3].pos, Vec2::splat(9.0));
assert_eq!(out[3].src, Some(Rect::new(2.0, 2.0, 2.0, 2.0)));
for q in &out {
assert_eq!(q.scale, Vec2::ONE);
}
}
#[wasm_bindgen_test(unsupported = test)]
fn nine_slice_rejects_degenerate_inputs() {
let src = Rect::new(0.0, 0.0, 16.0, 16.0);
let t = template();
for (src, size, border) in [
(src, Vec2::new(0.0, 24.0), 4.0),
(src, Vec2::new(40.0, -2.0), 4.0),
(src, Vec2::new(40.0, 24.0), -1.0),
(Rect::new(0.0, 0.0, 16.0, 0.0), Vec2::new(40.0, 24.0), 4.0),
] {
let mut out = Vec::new();
expand_nine_slice(&mut out, &t, src, size, border, WorldUnits::default());
assert!(out.is_empty(), "size {size:?} border {border} src {src:?}");
}
let mut out = Vec::new();
expand_nine_slice(
&mut out,
&t,
src,
Vec2::new(40.0, 24.0),
0.0,
WorldUnits::default(),
);
assert_eq!(out.len(), 1);
assert_eq!(out[0].scale, Vec2::new(2.5, 1.5));
}
#[wasm_bindgen_test(unsupported = test)]
fn push_helpers_target_one_channel_each() {
let src = Rect::new(0.0, 0.0, 8.0, 8.0);
let t = template();
let mut list = DrawList::new();
list.push_tiled(
&t,
src,
Vec2::new(16.0, 8.0),
Vec2::new(8.0, 8.0),
WorldUnits::default(),
);
list.push_screen_nine_slice(&t, src, Vec2::new(24.0, 24.0), 2.0);
assert_eq!(list.world.len(), 2);
assert_eq!(list.screen.len(), 9);
list.clear();
list.push_screen_tiled(&t, src, Vec2::new(16.0, 8.0), Vec2::new(8.0, 8.0));
list.push_nine_slice(&t, src, Vec2::new(24.0, 24.0), 2.0, WorldUnits::default());
assert_eq!(list.screen.len(), 2);
assert_eq!(list.world.len(), 9);
}
}