use super::gpu;
use super::{
Column, ColumnFormat, KindUniforms, Mark, MarkCommon, MarkKind, PolygonMesh, PrepareContext,
};
#[derive(Debug, Clone, Default, PartialEq)]
pub struct PolygonFeature {
pub outer: Vec<[f64; 2]>,
pub holes: Vec<Vec<[f64; 2]>>,
pub triangles: Option<Vec<[u32; 3]>>,
}
impl PolygonFeature {
pub fn new(outer: Vec<[f64; 2]>) -> Self {
Self {
outer,
holes: Vec::new(),
triangles: None,
}
}
}
#[derive(Debug)]
pub struct PolygonMarks {
pub common: MarkCommon,
positions: Column,
normal_top: Column,
feature: Column,
elevations: Column,
colors: Column,
backgrounds: Column,
index: Vec<u32>,
index_dirty: bool,
index_gpu: Option<(gpu::Buffer, u32)>,
ranges: Vec<(usize, usize)>,
source: Vec<u32>,
pub ambient: f32,
pub lighting: Option<super::Lighting>,
pub walls_first: bool,
uploaded_walls_first: bool,
radial: Option<[f64; 3]>,
radial_rel: [f32; 4],
pattern: Option<PolygonPattern>,
pub pattern_unit: f64,
pub pattern_origin: [f64; 2],
pattern_built: Option<(u64, [u64; 3], [u64; 2], u64)>,
pattern_gpu: Option<(u64, gpu::BindGroup)>,
procedural: Option<Vec<Option<ProceduralFrame>>>,
pub procedural_unit: f64,
pub procedural_y_down: bool,
pub procedural_offset: [f64; 2],
procedural_built: Option<(u64, u64)>,
}
#[derive(Debug, Clone)]
pub struct PolygonPattern {
pub atlas: super::SharedAtlas,
pub mask: bool,
pub frames: Vec<Option<PatternFrame>>,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum ProceduralShape {
Hatch {
angle: f32,
stroke_width: f32,
gaps: [f32; 2],
alternating: bool,
},
CrossHatch {
angles: [f32; 2],
stroke_width: f32,
gap: f32,
},
Dots {
radius: f32,
gap: f32,
angle: f32,
skew: f32,
},
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ProceduralFrame {
pub shape: ProceduralShape,
pub scale: f32,
}
impl ProceduralFrame {
pub(crate) fn params(&self, unit: f64, y_down: bool) -> ([f32; 4], [f32; 4]) {
let rad = |d: f32| d.to_radians();
let (shape, size, gaps, angles, count) = match self.shape {
ProceduralShape::Hatch {
angle,
stroke_width,
gaps,
alternating,
} => (
1.0,
stroke_width,
gaps,
[rad(angle), 0.0],
if alternating { 2.0 } else { 1.0 },
),
ProceduralShape::CrossHatch {
angles,
stroke_width,
gap,
} => (
2.0,
stroke_width,
[gap, gap],
[rad(angles[0]), rad(angles[1])],
2.0,
),
ProceduralShape::Dots {
radius,
gap,
angle,
skew,
} => (3.0, radius, [gap, gap], [rad(angle), rad(skew)], 2.0),
};
let unit = (unit * self.scale as f64) as f32 * if y_down { 1.0 } else { -1.0 };
(
[shape, size, gaps[0], gaps[1]],
[angles[0], angles[1], count, unit],
)
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct PatternFrame {
pub name: String,
pub scale: f32,
pub offset: [f32; 2],
}
impl Default for PolygonMarks {
fn default() -> Self {
Self::new()
}
}
impl PolygonMarks {
pub fn new() -> Self {
let mut common = MarkCommon::default();
common.style.depth_write = true;
Self {
common,
positions: Column::new(ColumnFormat::PositionF64),
normal_top: Column::float(4),
feature: Column::float(1),
elevations: Column::float(1),
colors: Column::new(ColumnFormat::Unorm8x4),
backgrounds: {
let mut c = Column::new(ColumnFormat::Unorm8x4);
c.set_default_rgba([0, 0, 0, 0]);
c
},
index: Vec::new(),
index_dirty: true,
index_gpu: None,
ranges: Vec::new(),
source: Vec::new(),
ambient: 0.45,
lighting: None,
walls_first: false,
uploaded_walls_first: false,
radial: None,
radial_rel: [0.0; 4],
pattern: None,
pattern_unit: 1.0,
pattern_origin: [0.0, 0.0],
pattern_built: None,
pattern_gpu: None,
procedural: None,
procedural_unit: 1.0,
procedural_y_down: true,
procedural_offset: [0.0, 0.0],
procedural_built: None,
}
}
pub fn set_pattern(&mut self, pattern: Option<PolygonPattern>) {
if pattern.is_none() && self.pattern.is_some() {
self.common.clear_custom(0);
self.common.clear_custom(1);
}
self.pattern = pattern;
self.pattern_built = None;
self.pattern_gpu = None;
}
pub fn pattern(&self) -> Option<&PolygonPattern> {
self.pattern.as_ref()
}
pub fn set_procedural(&mut self, frames: Option<Vec<Option<ProceduralFrame>>>) {
if frames.is_none() && self.procedural.is_some() {
for slot in 0..2 {
self.common.clear_custom(slot);
}
}
self.procedural = frames;
self.procedural_built = None;
}
fn build_procedural_columns(&mut self) {
let Some(frames) = &self.procedural else {
return;
};
let key = (
self.procedural_unit.to_bits(),
u64::from(self.procedural_y_down),
);
if self.procedural_built == Some(key)
&& self.common.has_custom(0)
&& self.common.has_custom(1)
{
return;
}
let n = self.ranges.len();
let mut a = vec![0.0f32; n * 4];
let mut b = vec![0.0f32; n * 4];
for (k, f) in frames.iter().enumerate().take(n) {
let Some(f) = f else { continue };
let (p0, p1) = f.params(self.procedural_unit, self.procedural_y_down);
a[k * 4..k * 4 + 4].copy_from_slice(&p0);
b[k * 4..k * 4 + 4].copy_from_slice(&p1);
}
self.set_feature_custom(0, 4, &a);
self.set_feature_custom(1, 4, &b);
self.procedural_built = Some(key);
}
fn build_pattern_columns(&mut self) {
let Some(p) = &self.pattern else { return };
let atlas = p.atlas.read().unwrap();
let (aw, ah) = atlas.size();
let version = atlas.version();
let origin = self.common.local_origin.unwrap_or([0.0; 3]);
let key = (
self.pattern_unit.to_bits(),
origin.map(f64::to_bits),
self.pattern_origin.map(f64::to_bits),
version ^ (u64::from(self.procedural_y_down) << 63),
);
if self.pattern_built == Some(key) {
return;
}
let n = self.ranges.len();
let mut frames = vec![0.0f32; n * 4];
let mut tiles = vec![0.0f32; n * 4];
for (k, f) in p.frames.iter().enumerate().take(n) {
let Some(f) = f else { continue };
let Some(r) = atlas.get(&f.name) else {
continue;
};
frames[k * 4..k * 4 + 4].copy_from_slice(&[
r.x as f32 / aw.max(1) as f32,
r.y as f32 / ah.max(1) as f32,
r.width as f32 / aw.max(1) as f32,
r.height as f32 / ah.max(1) as f32,
]);
let (px, pz) = (
r.width as f64 * f.scale as f64 * self.pattern_unit,
r.height as f64 * f.scale as f64 * self.pattern_unit,
);
if px <= 0.0 || pz <= 0.0 {
continue;
}
let reduce = |o: f64, period: f64, offset: f32| {
(o.rem_euclid(period) + offset as f64 * period) as f32
};
let (tx, tz) = (
origin[0] - self.pattern_origin[0],
origin[2] - self.pattern_origin[1],
);
let pz_signed = if self.procedural_y_down { pz } else { -pz };
tiles[k * 4..k * 4 + 4].copy_from_slice(&[
px as f32,
pz_signed as f32,
reduce(tx, px, f.offset[0]),
reduce(tz, pz, f.offset[1]),
]);
}
drop(atlas);
self.set_feature_custom(0, 4, &frames);
self.set_feature_custom(1, 4, &tiles);
self.pattern_built = Some(key);
}
pub fn set_polygons(&mut self, features: &[PolygonFeature], base: f64) {
self.set_mesh(PolygonMesh::build(features, base));
}
pub fn set_mesh(&mut self, mesh: PolygonMesh) {
self.common.local_origin = Some(mesh.origin);
self.positions.set_local_positions(&mesh.positions);
self.normal_top
.set_f32(bytemuck::cast_slice::<[f32; 4], f32>(&mesh.normal_top));
let fid: Vec<f32> = mesh.feature.iter().map(|&f| f as f32).collect();
self.feature.set_f32(&fid);
self.elevations.set_f32(&[]);
self.colors.set_rgba(&[]);
self.backgrounds.set_rgba(&[]);
for slot in 0..2 {
self.common.clear_custom(slot);
}
self.pattern_built = None;
self.procedural_built = None;
self.ranges = mesh
.ranges
.iter()
.map(|&(a, b)| (a as usize, b as usize))
.collect();
self.index = mesh.index;
self.source = mesh.source;
self.radial = mesh.radial;
self.index_dirty = true;
}
pub fn feature_count(&self) -> usize {
self.ranges.len()
}
fn expand<T: Copy>(&self, start: usize, values: &[T], components: usize) -> Vec<T> {
let mut out = Vec::new();
for (k, chunk) in values.chunks(components).enumerate() {
let Some(&(a, b)) = self.ranges.get(start + k) else {
break;
};
for _ in a..b {
out.extend_from_slice(chunk);
}
}
out
}
fn first_vertex(&self, k: usize) -> usize {
self.ranges.get(k).map_or(0, |r| r.0)
}
pub fn set_elevations(&mut self, e: &[f32]) {
let v = self.expand(0, e, 1);
self.elevations.set_f32(&v);
}
pub fn update_elevations(&mut self, start: usize, e: &[f32]) {
let v = self.expand(start, e, 1);
let first = self.first_vertex(start);
self.elevations.update_f32(first, &v);
}
pub fn set_colors(&mut self, c: &[[u8; 4]]) {
let v = self.expand(0, c, 1);
self.colors.set_rgba(&v);
}
pub fn set_point_colors(&mut self, colors: &[Vec<[u8; 4]>]) {
let mut v = Vec::with_capacity(self.source.len());
for (k, &(a, b)) in self.ranges.iter().enumerate() {
let c = colors.get(k).map_or(&[][..], |c| c.as_slice());
for i in a..b {
let s = self.source.get(i).copied().unwrap_or(u32::MAX) as usize;
v.push(c.get(s).or(c.first()).copied().unwrap_or([0, 0, 0, 255]));
}
}
self.colors.set_rgba(&v);
}
pub fn update_colors(&mut self, start: usize, c: &[[u8; 4]]) {
let v = self.expand(start, c, 1);
let first = self.first_vertex(start);
self.colors.update_rgba(first, &v);
}
pub fn set_default_color(&mut self, c: [u8; 4]) {
self.colors.set_default_rgba(c);
}
pub fn set_pattern_backgrounds(&mut self, c: &[[u8; 4]]) {
let v = self.expand(0, c, 1);
self.backgrounds.set_rgba(&v);
}
pub fn set_default_pattern_background(&mut self, c: [u8; 4]) {
self.backgrounds.set_default_rgba(c);
}
pub fn set_feature_custom(&mut self, slot: usize, components: u32, values: &[f32]) {
let v = self.expand(0, values, components as usize);
self.common.set_custom(slot, components, &v);
}
pub fn update_feature_custom(&mut self, slot: usize, start: usize, values: &[f32]) {
let components = self.common.custom(slot).map_or(1, |c| match c.format() {
ColumnFormat::Float(n) => n as usize,
_ => 1,
});
let v = self.expand(start, values, components);
let first = self.first_vertex(start);
self.common.update_custom(slot, first, &v);
}
pub fn vertex_count(&self) -> usize {
self.positions.len()
}
pub fn to_buffer_geometry(&self, origin: &super::Origin) -> crate::BufferGeometry {
use crate::core::BufferAttribute;
let n = self.positions.len();
let abs = self
.positions
.positions_f64(self.common.local_origin)
.unwrap_or_default();
let o = origin.position;
let scale = self.common.style.size_scale as f64;
let mut pos = Vec::with_capacity(n * 3);
let mut nor = Vec::with_capacity(n * 3);
let mut col = Vec::with_capacity(n * 4);
for (i, p) in abs.iter().enumerate() {
let nt = self.normal_top.row_f32(i);
let rise = self.elevations.row_f32(i)[0] as f64 * scale * nt[3] as f64;
let up = match self.radial {
Some(c) => {
let d = [p[0] - c[0], p[1] - c[1], p[2] - c[2]];
let l = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt().max(1e-12);
[d[0] / l, d[1] / l, d[2] / l]
}
None => [0.0, 1.0, 0.0],
};
for k in 0..3 {
pos.push((p[k] + up[k] * rise - o[k]) as f32);
}
nor.extend_from_slice(&nt[..3]);
let c = self.colors.row_f32(i);
let rgba: [u8; 4] = bytemuck::cast([c[0]]);
col.extend_from_slice(&super::points::srgb_u8_to_linear(rgba));
}
let mut g = crate::BufferGeometry::new();
g.set_attribute("position", BufferAttribute::new(pos, 3));
g.set_attribute("normal", BufferAttribute::new(nor, 3));
g.set_attribute("color", BufferAttribute::new(col, 4));
g.set_index(self.index.clone());
g
}
}
impl Mark for PolygonMarks {
fn kind(&self) -> MarkKind {
MarkKind::Polygon
}
fn common(&self) -> &MarkCommon {
&self.common
}
fn common_mut(&mut self) -> &mut MarkCommon {
&mut self.common
}
fn instance_count(&self) -> usize {
usize::from(!self.index.is_empty())
}
fn rows(&self) -> usize {
self.positions.len()
}
fn per_vertex(&self) -> bool {
true
}
fn kind_uniforms(&self) -> KindUniforms {
let (yz, l0, _) = super::Lighting::uniforms(self.lighting.as_ref());
let ambient = self
.lighting
.map_or(self.ambient.clamp(0.0, 1.0), |l| l.ambient);
(
[ambient, yz[0], yz[1], 0.0],
if self.radial.is_some() {
self.radial_rel
} else {
[
self.procedural_offset[0] as f32,
self.procedural_offset[1] as f32,
0.0,
0.0,
]
},
l0,
)
}
fn kind_extra(&self) -> [f32; 4] {
super::Lighting::uniforms(self.lighting.as_ref()).2
}
fn kind_material(&self) -> [f32; 4] {
let mut m = super::Lighting::material(self.lighting.as_ref());
m[2] = if self.pattern.as_ref().is_some_and(|p| p.mask) {
1.0
} else {
0.0
};
m
}
fn patterned(&self) -> bool {
self.pattern.is_some()
}
fn kind_flags(&self) -> u32 {
u32::from(self.procedural.is_some())
}
fn extra_bind_group(&self) -> Option<&gpu::BindGroup> {
self.pattern_gpu.as_ref().map(|g| &g.1)
}
fn prepare(&mut self, ctx: &PrepareContext) {
self.build_procedural_columns();
if let Some(atlas) = self.pattern.as_ref().map(|p| p.atlas.clone()) {
super::sprites::atlas_bind_group(ctx, &atlas, &mut self.pattern_gpu);
self.build_pattern_columns();
}
self.radial_rel = match self.radial {
Some(c) => {
let o = ctx.view.origin.position;
[
(c[0] - o[0]) as f32,
(c[1] - o[1]) as f32,
(c[2] - o[2]) as f32,
1.0,
]
}
None => [0.0; 4],
};
if self.walls_first != self.uploaded_walls_first {
self.index_dirty = true;
}
if !self.index_dirty || self.index.is_empty() {
return;
}
self.uploaded_walls_first = self.walls_first;
let ordered: std::borrow::Cow<[u32]> = if self.walls_first {
let nt: &[f32] = bytemuck::cast_slice(self.normal_top.bytes());
let roof = |t: &[u32; 3]| {
t.iter()
.all(|&v| nt.get(v as usize * 4 + 1).is_some_and(|y| y.abs() > 0.5))
};
let tris = || self.index.as_chunks::<3>().0.iter();
let walls = tris().filter(|t| !roof(t));
let roofs = tris().filter(|t| roof(t));
std::borrow::Cow::Owned(walls.chain(roofs).flatten().copied().collect())
} else {
std::borrow::Cow::Borrowed(&self.index)
};
let b = ctx.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("threers polygon marks indices"),
size: (ordered.len() * 4) as u64,
usage: wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
ctx.queue
.write_buffer(&b, 0, bytemuck::cast_slice(&ordered));
self.index_gpu = Some((b, self.index.len() as u32));
self.index_dirty = false;
}
fn release_gpu(&mut self) {
self.index_gpu = None;
self.pattern_gpu = None;
self.index_dirty = true;
super::release_columns(self);
}
fn gpu_bytes(&mut self) -> u64 {
super::column_bytes(self) + self.index_gpu.as_ref().map_or(0, |(b, _)| b.size())
}
fn columns(&mut self) -> Vec<&mut Column> {
vec![
&mut self.positions,
&mut self.normal_top,
&mut self.feature,
&mut self.elevations,
&mut self.colors,
&mut self.backgrounds,
]
}
fn index_buffer(&self) -> Option<(&gpu::Buffer, u32)> {
self.index_gpu.as_ref().map(|(b, n)| (b, *n))
}
}
#[cfg(test)]
mod tests {
use super::*;
fn square(x: f64, y: f64, s: f64) -> Vec<[f64; 2]> {
vec![[x, y], [x + s, y], [x + s, y + s], [x, y + s], [x, y]]
}
#[test]
fn features_get_contiguous_vertices_and_values() {
let mut p = PolygonMarks::new();
let mut holed = PolygonFeature::new(square(0.0, 0.0, 10.0));
holed.holes.push(square(4.0, 4.0, 2.0));
p.set_polygons(&[PolygonFeature::new(square(20.0, 0.0, 5.0)), holed], 0.0);
assert_eq!(p.feature_count(), 2);
assert_eq!(p.ranges, vec![(0, 4 + 16), (20, 20 + 8 + 32)]);
assert_eq!(p.index.len(), 3 * ((2 + 4 * 2) + (8 + 8 * 2)));
p.set_colors(&[[1, 0, 0, 255], [2, 0, 0, 255]]);
let c = p.colors.bytes();
assert_eq!(c.len(), 4 * 60);
assert_eq!(c[4 * 19], 1);
assert_eq!(c[4 * 20], 2);
p.colors.mark_uploaded();
p.update_colors(1, &[[3, 0, 0, 255]]);
assert_eq!(p.colors.pending_upload(), Some(4 * 20..4 * 60));
}
#[test]
fn walls_face_out_of_the_solid_whatever_the_winding() {
for ring in [square(0.0, 0.0, 1.0), {
let mut r = square(0.0, 0.0, 1.0);
r.reverse();
r
}] {
let mut p = PolygonMarks::new();
let mut f = PolygonFeature::new(ring);
f.holes.push(square(0.25, 0.25, 0.5));
p.set_polygons(&[f], 0.0);
let pos: Vec<f32> = bytemuck::pod_collect_to_vec(p.positions.bytes());
let o = p.common.local_origin.unwrap();
let nt: Vec<f32> = bytemuck::pod_collect_to_vec(p.normal_top.bytes());
for v in 8..p.vertex_count() {
let (x, z) = (pos[v * 3] + o[0] as f32, pos[v * 3 + 2] + o[2] as f32);
let n = [nt[v * 4], nt[v * 4 + 2]];
let (cx, cz) = (x - 0.5, z + 0.5);
let outward = n[0] * cx + n[1] * cz > 0.0;
let on_outer = cx.abs() > 0.4 || cz.abs() > 0.4;
assert_eq!(outward, on_outer, "vertex {v} at ({x}, {z}) normal {n:?}");
}
}
}
}