use super::atlas::{AtlasRect, SharedAtlas};
use super::{Column, ColumnFormat, KindUniforms, Mark, MarkCommon, MarkKind, PrepareContext};
type PlacedFor = ([f32; 16], (u32, u32), [f64; 3], u64, u64, [u32; 7]);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum SpriteMode {
#[default]
Color,
Mask,
DistanceField,
}
#[derive(Debug)]
pub struct SpriteMarks {
pub common: MarkCommon,
atlas: SharedAtlas,
positions: Column,
sizes: Column,
rects: Column,
angles: Column,
colors: Column,
pub mode: SpriteMode,
pub anchor: [f32; 2],
pub collision: bool,
pub collision_index: Option<super::SharedCollision>,
pub padding: f32,
shown: Column,
priorities: Vec<f32>,
placed: Option<PlacedFor>,
version: u64,
owner: u64,
gpu: Option<(u64, wgpu::BindGroup)>,
atlas_size: (u32, u32),
}
impl SpriteMarks {
pub fn new(atlas: SharedAtlas) -> Self {
let mut sizes = Column::float(1);
sizes.set_default_f32(&[1.0]);
let mut common = MarkCommon::default();
common.style.size_scale = 24.0;
Self {
common,
atlas,
positions: Column::new(ColumnFormat::PositionF64),
sizes,
rects: Column::float(4),
angles: Column::float(1),
colors: Column::new(ColumnFormat::Unorm8x4),
mode: SpriteMode::Color,
anchor: [0.0, 0.0],
collision: false,
collision_index: None,
padding: 1.0,
shown: {
let mut c = Column::float(1);
c.set_default_f32(&[1.0]);
c
},
priorities: Vec::new(),
placed: None,
version: 0,
owner: super::collision::next_owner(),
gpu: None,
atlas_size: (1, 1),
}
}
pub fn atlas(&self) -> &SharedAtlas {
&self.atlas
}
pub fn set_positions(&mut self, p: &[[f64; 3]]) {
self.version += 1;
self.common.local_origin = None;
self.positions.set_positions(p);
}
pub fn set_local_positions(&mut self, origin: [f64; 3], p: &[[f32; 3]]) {
self.version += 1;
self.common.local_origin = Some(origin);
self.positions.set_local_positions(p);
}
pub fn update_local_positions(&mut self, start: usize, p: &[[f32; 3]]) {
self.version += 1;
self.positions.update_local_positions(start, p);
}
pub fn update_positions(&mut self, start: usize, p: &[[f64; 3]]) {
self.version += 1;
self.positions.update_positions(start, p);
}
pub fn set_sizes(&mut self, s: &[f32]) {
self.version += 1;
self.sizes.set_f32(s);
}
pub fn update_sizes(&mut self, start: usize, s: &[f32]) {
self.version += 1;
self.sizes.update_f32(start, s);
}
pub fn set_rects(&mut self, r: &[AtlasRect]) {
self.version += 1;
let flat: Vec<f32> = r.iter().flat_map(|r| r.to_array()).collect();
self.rects.set_f32(&flat);
}
pub fn update_rects(&mut self, start: usize, r: &[AtlasRect]) {
self.version += 1;
let flat: Vec<f32> = r.iter().flat_map(|r| r.to_array()).collect();
self.rects.update_f32(start, &flat);
}
pub fn set_images(&mut self, names: &[&str]) {
let atlas = self.atlas.read().unwrap();
let r: Vec<AtlasRect> = names
.iter()
.map(|n| {
atlas.get(n).unwrap_or(AtlasRect {
x: 0,
y: 0,
width: 0,
height: 0,
})
})
.collect();
drop(atlas);
self.set_rects(&r);
}
pub fn set_default_rect(&mut self, r: AtlasRect) {
self.version += 1;
self.rects.set_default_f32(&r.to_array());
}
pub fn set_angles(&mut self, a: &[f32]) {
self.version += 1;
self.angles.set_f32(a);
}
pub fn update_angles(&mut self, start: usize, a: &[f32]) {
self.version += 1;
self.angles.update_f32(start, a);
}
pub fn set_colors(&mut self, c: &[[u8; 4]]) {
self.colors.set_rgba(c);
}
pub fn update_colors(&mut self, start: usize, c: &[[u8; 4]]) {
self.colors.update_rgba(start, c);
}
pub fn set_default_color(&mut self, c: [u8; 4]) {
self.colors.set_default_rgba(c);
}
pub fn set_priorities(&mut self, p: &[f32]) {
self.priorities = p.to_vec();
self.version += 1;
}
pub fn shown(&self) -> Vec<bool> {
(0..self.positions.len())
.map(|i| self.shown.row_f32(i)[0] > 0.5)
.collect()
}
fn place(&mut self, view: &super::MarkView) {
let shared = self.collision_index.clone();
let generation = shared
.as_ref()
.map_or(0, |s| s.lock().unwrap().generation());
let s = &self.common.style;
let settings = [
self.anchor[0].to_bits(),
self.anchor[1].to_bits(),
self.padding.to_bits(),
s.size_scale.to_bits(),
s.min_pixels.to_bits(),
s.max_pixels.to_bits(),
u32::from(s.units == super::SizeUnits::World),
];
let key = (
view.view_proj,
view.viewport,
view.origin.position,
generation,
self.version,
settings,
);
if self.placed == Some(key) {
return;
}
if let Some(sh) = &shared {
sh.lock()
.unwrap()
.reclaim(self.owner, self.placed.map(|p| p.3));
}
self.placed = Some(key);
let Some(pos) = self.positions.positions_f64(self.common.local_origin) else {
return;
};
let s = &self.common.style;
let (vw, vh) = (view.viewport.0 as f32, view.viewport.1 as f32);
let mut order: Vec<usize> = (0..pos.len()).collect();
let pr = |i: usize| self.priorities.get(i).copied().unwrap_or(0.0);
order.sort_by(|&a, &b| {
pr(b)
.partial_cmp(&pr(a))
.unwrap_or(std::cmp::Ordering::Equal)
});
let mut private = super::CollisionIndex::new();
let mut guard = shared.as_ref().map(|s| s.lock().unwrap());
let index: &mut super::CollisionIndex = match guard.as_deref_mut() {
Some(g) => g,
None => &mut private,
};
let mut shown = vec![0.0f32; pos.len()];
for i in order {
let Some(p) = view.project(pos[i]) else {
continue;
};
let rect = self.rects.row_f32(i);
if rect[3] <= 0.0 {
continue;
}
let mut h = self.sizes.row_f32(i)[0] * s.size_scale;
if s.units == super::SizeUnits::World {
h /= view.units_per_pixel(pos[i]).unwrap_or(1.0) as f32;
}
let h = h.clamp(s.min_pixels, s.max_pixels);
let half = [h * rect[2] / rect[3] * 0.5, h * 0.5];
let c = [
p[0] - self.anchor[0] * half[0],
p[1] + self.anchor[1] * half[1],
];
let a = self.angles.row_f32(i)[0];
let (sn, cs) = a.sin_cos();
let ex = (half[0] * cs).abs() + (half[1] * sn).abs() + self.padding;
let ey = (half[0] * sn).abs() + (half[1] * cs).abs() + self.padding;
let r = [c[0] - ex, c[1] - ey, c[0] + ex, c[1] + ey];
if r[2] < 0.0 || r[3] < 0.0 || r[0] > vw || r[1] > vh {
continue;
}
if index.try_insert_owned(self.owner, r) {
shown[i] = 1.0;
}
}
drop(guard);
self.shown.set_f32(&shown);
}
}
pub(crate) fn atlas_bind_group(
ctx: &PrepareContext,
atlas: &SharedAtlas,
gpu: &mut Option<(u64, wgpu::BindGroup)>,
) -> (u32, u32) {
let mut a = atlas.write().unwrap();
let (view, generation) = a.texture(ctx.device, ctx.queue);
let size = a.size();
drop(a);
if gpu.as_ref().is_none_or(|g| g.0 != generation) {
let bg = ctx.device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("threers atlas bind group"),
layout: &ctx.resources.texture_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(&view),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Sampler(&ctx.resources.mip_sampler),
},
],
});
*gpu = Some((generation, bg));
}
size
}
impl Mark for SpriteMarks {
fn kind(&self) -> MarkKind {
MarkKind::Sprite
}
fn common(&self) -> &MarkCommon {
&self.common
}
fn common_mut(&mut self) -> &mut MarkCommon {
&mut self.common
}
fn instance_count(&self) -> usize {
self.positions.len()
}
fn kind_uniforms(&self) -> KindUniforms {
let mode = match self.mode {
SpriteMode::Color => 0.0,
SpriteMode::Mask => 1.0,
SpriteMode::DistanceField => 2.0,
};
(
[mode, 0.0, 0.0, 0.0],
[
self.atlas_size.0 as f32,
self.atlas_size.1 as f32,
self.anchor[0],
self.anchor[1],
],
[0.0; 4],
)
}
fn prepare(&mut self, ctx: &PrepareContext) {
self.atlas_size = atlas_bind_group(ctx, &self.atlas, &mut self.gpu);
if self.collision {
self.place(ctx.view);
} else if !self.shown.is_empty() {
self.shown.set_f32(&[]);
if let (Some(sh), Some(_)) = (&self.collision_index, self.placed) {
let mut index = sh.lock().unwrap();
index.remove_owner(self.owner);
index.invalidate();
}
self.placed = None;
}
}
fn release_gpu(&mut self) {
self.gpu = None;
super::release_columns(self);
}
fn gpu_bytes(&mut self) -> u64 {
super::column_bytes(self)
}
fn columns(&mut self) -> Vec<&mut Column> {
vec![
&mut self.positions,
&mut self.sizes,
&mut self.rects,
&mut self.angles,
&mut self.colors,
&mut self.shown,
]
}
fn extra_bind_group(&self) -> Option<&wgpu::BindGroup> {
self.gpu.as_ref().map(|g| &g.1)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::marks::{MarkView, Origin, TextureAtlas};
fn view() -> MarkView {
let mut m = [0.0f32; 16];
m[0] = 1.0;
m[5] = 1.0;
m[10] = 1.0;
m[15] = 1.0;
MarkView {
view_proj: m,
projection_scale: 1.0,
viewport: (200, 100),
origin: Origin::ZERO,
light_direction: [0.0, 1.0, 0.0],
eye: [0.0, 0.0, 1.0, 0.0],
tone_mapping: (crate::ToneMapping::None, 1.0),
reversed_z: false,
}
}
#[test]
fn moving_icons_are_placed_again_under_a_still_view() {
let mut atlas = TextureAtlas::new(8);
let rect = atlas.insert("dot", 2, 2, &[255; 16]).unwrap();
let mut s = SpriteMarks::new(atlas.shared());
s.collision = true;
s.set_default_rect(rect);
s.set_positions(&[[0.0, 0.0, 0.0], [0.05, 0.0, 0.0]]);
s.place(&view());
assert_eq!(s.shown(), vec![true, false]);
s.set_positions(&[[-0.5, 0.0, 0.0], [0.5, 0.0, 0.0]]);
s.place(&view());
assert_eq!(s.shown(), vec![true, true]);
s.common.style.size_scale = 150.0;
s.common.style.max_pixels = 1000.0;
s.place(&view());
assert_eq!(s.shown(), vec![true, false]);
}
}