use super::gpu;
use super::{Column, ColumnFormat, KindUniforms, Mark, MarkCommon, MarkKind, PrepareContext};
use crate::math::ColorRamp;
pub(crate) const FIELD_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
#[derive(Debug)]
pub struct DensityMarks {
pub common: MarkCommon,
positions: Column,
weights: Column,
pub max_weight: f32,
pub auto_max: Option<f32>,
pub threshold: f32,
pub resolution: Option<f32>,
pub extent: [f32; 2],
pub ground: bool,
pub cover: Option<[f32; 4]>,
pub linear_fade: bool,
pub mean: bool,
ramp: Vec<[u8; 4]>,
ramp_dirty: bool,
gpu: Option<DensityGpu>,
}
#[derive(Debug)]
struct DensityGpu {
size: (u32, u32),
field: gpu::TextureView,
ramp: gpu::Texture,
bind_group: gpu::BindGroup,
levels: Vec<ReduceLevel>,
}
#[doc(hidden)]
#[derive(Debug)]
pub struct ReduceLevel {
pub(crate) target: gpu::TextureView,
pub(crate) bind_group: gpu::BindGroup,
}
fn reduce_sizes(mut size: (u32, u32)) -> Vec<(u32, u32)> {
let mut out = Vec::new();
loop {
size = (size.0.div_ceil(4).max(1), size.1.div_ceil(4).max(1));
out.push(size);
if size == (1, 1) {
return out;
}
}
}
impl Default for DensityMarks {
fn default() -> Self {
Self::new()
}
}
impl DensityMarks {
pub fn new() -> Self {
let mut weights = Column::float(1);
weights.set_default_f32(&[1.0]);
let mut common = MarkCommon::default();
common.style.size_scale = 30.0;
common.style.depth_test = false;
common.style.pickable = false;
let mut s = Self {
common,
positions: Column::new(ColumnFormat::PositionF64),
weights,
max_weight: 4.0,
auto_max: None,
threshold: 0.05,
resolution: None,
extent: [1.0; 2],
ground: false,
cover: None,
linear_fade: false,
mean: false,
ramp: Vec::new(),
ramp_dirty: true,
gpu: None,
};
s.set_ramp(&ColorRamp::inferno());
s
}
pub fn field_scale(&self) -> f32 {
if let Some(r) = self.resolution {
return r.clamp(0.05, 1.0);
}
let s = &self.common.style;
if s.units == super::SizeUnits::World {
return 0.5;
}
let radius = s.size_scale.clamp(s.min_pixels, s.max_pixels);
(12.0 / radius.max(1e-3)).clamp(0.25, 1.0)
}
pub fn set_positions(&mut self, p: &[[f64; 3]]) {
self.common.local_origin = None;
self.positions.set_positions(p);
}
pub fn set_local_positions(&mut self, origin: [f64; 3], p: &[[f32; 3]]) {
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.positions.update_local_positions(start, p);
}
pub fn update_positions(&mut self, start: usize, p: &[[f64; 3]]) {
self.positions.update_positions(start, p);
}
pub fn set_weights(&mut self, w: &[f32]) {
self.weights.set_f32(w);
}
pub fn update_weights(&mut self, start: usize, w: &[f32]) {
self.weights.update_f32(start, w);
}
pub fn set_ramp_srgb8(&mut self, ramp: &[[u8; 4]]) {
let n = ramp.len();
self.ramp = (0..256)
.map(|k| {
if n == 0 {
return [0, 0, 0, 255];
}
let x = ((k as f32 + 0.5) / 256.0 * n as f32 - 0.5).clamp(0.0, (n - 1) as f32);
let (i, f) = (x.floor() as usize, x.fract());
let (a, b) = (ramp[i], ramp[(i + 1).min(n - 1)]);
std::array::from_fn(|c| {
(a[c] as f32 + (b[c] as f32 - a[c] as f32) * f).round() as u8
})
})
.collect();
self.ramp_dirty = true;
}
pub fn set_ramp(&mut self, ramp: &ColorRamp) {
self.ramp = ramp
.sample(256)
.into_iter()
.map(|c| {
let e = |v: f32| {
let v = v.clamp(0.0, 1.0);
let s = if v <= 0.003_130_8 {
v * 12.92
} else {
1.055 * v.powf(1.0 / 2.4) - 0.055
};
(s * 255.0 + 0.5) as u8
};
[e(c.r), e(c.g), e(c.b), 255]
})
.collect();
self.ramp_dirty = true;
}
}
impl Mark for DensityMarks {
fn kind(&self) -> MarkKind {
MarkKind::Splat
}
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_extra(&self) -> [f32; 4] {
self.cover
.unwrap_or([f32::MIN, f32::MIN, f32::MAX, f32::MAX])
}
fn kind_uniforms(&self) -> KindUniforms {
let (auto, fraction) = match self.auto_max {
Some(k) => (1.0, k.max(1e-6)),
None => (0.0, 1.0),
};
(
[
if self.linear_fade { 1.0 } else { 0.0 },
if self.mean { 1.0 } else { 0.0 },
0.0,
0.0,
],
[self.max_weight, self.threshold, auto, fraction],
[
self.extent[0].max(1.0),
self.extent[1].max(1.0),
if self.ground { 1.0 } else { 0.0 },
0.0,
],
)
}
fn prepare(&mut self, ctx: &PrepareContext) {
let scale = self.field_scale();
let vp = ctx.view.viewport;
let [ex, ey] = self.extent.map(|e| e.max(1.0));
let size = (
((vp.0 as f32 * scale * ex).ceil() as u32)
.clamp(1, ctx.device.limits().max_texture_dimension_2d),
((vp.1 as f32 * scale * ey).ceil() as u32)
.clamp(1, ctx.device.limits().max_texture_dimension_2d),
);
let stale = self.gpu.as_ref().is_none_or(|g| g.size != size);
if stale {
let field = ctx.device.create_texture(&wgpu::TextureDescriptor {
label: Some("threers density field"),
size: wgpu::Extent3d {
width: size.0,
height: size.1,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: FIELD_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT
| wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
});
let ramp = match self.gpu.take() {
Some(g) => g.ramp,
None => ctx.device.create_texture(&wgpu::TextureDescriptor {
label: Some("threers density ramp"),
size: wgpu::Extent3d {
width: 256,
height: 1,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8UnormSrgb,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
}),
};
let field_view = field.create_view(&Default::default());
let ramp_view = ramp.create_view(&Default::default());
let mut levels = Vec::new();
let mut src = field_view.clone();
for (w, h) in reduce_sizes(size) {
let tex = ctx.device.create_texture(&wgpu::TextureDescriptor {
label: Some("threers density max"),
size: wgpu::Extent3d {
width: w,
height: h,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: FIELD_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT
| wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
});
let target = tex.create_view(&Default::default());
let bind_group = ctx.device.create_bind_group(&gpu::BindGroupDescriptor {
label: Some("threers density reduce bind group"),
layout: &ctx.resources.reduce_layout,
entries: &[
gpu::BindGroupEntry {
binding: 0,
resource: gpu::BindingResource::TextureView(&src),
},
gpu::BindGroupEntry {
binding: 1,
resource: gpu::BindingResource::Sampler(&ctx.resources.nearest_sampler),
},
],
});
src = target.clone();
levels.push(ReduceLevel { target, bind_group });
}
let bind_group = ctx.device.create_bind_group(&gpu::BindGroupDescriptor {
label: Some("threers density composite bind group"),
layout: &ctx.resources.density_layout,
entries: &[
gpu::BindGroupEntry {
binding: 0,
resource: gpu::BindingResource::TextureView(&field_view),
},
gpu::BindGroupEntry {
binding: 1,
resource: gpu::BindingResource::TextureView(&ramp_view),
},
gpu::BindGroupEntry {
binding: 2,
resource: gpu::BindingResource::Sampler(&ctx.resources.linear_sampler),
},
gpu::BindGroupEntry {
binding: 3,
resource: gpu::BindingResource::TextureView(&src),
},
],
});
self.gpu = Some(DensityGpu {
size,
field: field_view,
ramp,
bind_group,
levels,
});
}
if self.ramp_dirty || stale {
let g = self.gpu.as_ref().unwrap();
let bytes: Vec<u8> = self.ramp.iter().flatten().copied().collect();
ctx.queue.write_texture(
gpu::TexelCopyTextureInfo {
texture: &g.ramp,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
aspect: wgpu::TextureAspect::All,
},
&bytes,
wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(256 * 4),
rows_per_image: Some(1),
},
wgpu::Extent3d {
width: 256,
height: 1,
depth_or_array_layers: 1,
},
);
self.ramp_dirty = false;
}
}
fn release_gpu(&mut self) {
self.gpu = None;
self.ramp_dirty = true;
super::release_columns(self);
}
fn gpu_bytes(&mut self) -> u64 {
let field = self
.gpu
.as_ref()
.map_or(0, |g| g.size.0 as u64 * g.size.1 as u64 * 8);
super::column_bytes(self) + field
}
fn columns(&mut self) -> Vec<&mut Column> {
vec![&mut self.positions, &mut self.weights]
}
fn density(&self) -> Option<(&gpu::TextureView, &gpu::BindGroup)> {
self.gpu.as_ref().map(|g| (&g.field, &g.bind_group))
}
fn density_reduction(&self) -> Option<&[ReduceLevel]> {
self.auto_max?;
self.gpu.as_ref().map(|g| g.levels.as_slice())
}
}