d84914ef1e5a
eval.rs
//! The layer-stack evaluator: composites a texture set's stack into one image per channel,
//! tile by tile in parallel. This is the reference implementation (the oracle) for the viewport
//! and for export.
pub(crate) mod thumbnail;
use std::borrow::Cow;
use std::collections::{BTreeMap, HashMap};
use std::sync::Arc;
use rayon::prelude::*;
use texturecraft_core::{
BakedMap, BlendMode, BlockScales, Channel, ChannelKind, CompareOp, CurvatureDetail, CurvatureMode, Effect, EffectKind, Fill, Filter, Generator,
GeneratorKind, HeightMask, Layer, LayerId, LayerKind, Mask, MaskBackground, MicroDetail, NormalFormat, Project, Projection, Source, TextureSet, TileGrid,
blend1, blend3, lum, mix3, per_unit,
};
use texturecraft_geom::glam::{Vec2, Vec3};
use texturecraft_geom::{Mesh, NO_TRI, UvGBuffer};
use texturecraft_texel::{DilationMap, TILE, TILE_AREA, TileImage, from_u16, noise, to_u16, to_u16_signed};
use crate::below::{Band, BelowCache, Level, StackKey};
use crate::curvature_sizes::CurvatureSizes;
use crate::held_fields::HeldFields;
use crate::pattern::{Coords, decal_uv_symmetric, image_samples, pattern_pixels, procedural_in, world_noise};
use crate::pattern_context::PatternContext;
use crate::store::{BakedMaps, ImageStore, PixelStore, decode};
const NCH: usize = Channel::ALL.len();
/// Stack values being composited, per channel.
type Acc = [[f32; 3]; NCH];
/// What a live stroke paints into.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PaintTarget {
/// A paint layer's channels.
Layer(LayerId),
/// A paint effect inside a mask.
Mask(LayerId),
}
/// A screen-pinned image painted through the camera (projection tool / stencil).
#[derive(Clone, Debug)]
pub struct Stencil {
pub image: std::sync::Arc<crate::store::ImageRes>,
/// Camera view-projection captured when the stroke started.
pub view_proj: texturecraft_geom::glam::Mat4,
/// Image placement in normalized device coordinates: center, half extents, rotation.
pub center: [f32; 2],
pub half: [f32; 2],
pub rotation: f32,
/// Repeat the image beyond its bounds (otherwise nothing is painted outside it).
pub tile: bool,
}
impl Stencil {
/// Linear color and alpha of the stencil at world point `p` (None outside the image).
pub fn sample_world(&self, p: Vec3) -> Option<([f32; 3], f32)> {
let c = self.view_proj * p.extend(1.0);
if c.w <= 1e-6 {
return None;
}
let (dx, dy) = (c.x / c.w - self.center[0], c.y / c.w - self.center[1]);
let (sn, cs) = (-self.rotation).sin_cos();
let lx = (dx * cs - dy * sn) / self.half[0].max(1e-6);
let ly = (dx * sn + dy * cs) / self.half[1].max(1e-6);
if !self.tile && (lx.abs() > 1.0 || ly.abs() > 1.0) {
return None;
}
let s = self.image.sample(lx * 0.5 + 0.5, 0.5 - ly * 0.5);
let rgb = if self.image.srgb { [s[0], s[1], s[2]].map(texturecraft_texel::srgb_to_linear) } else { [s[0], s[1], s[2]] };
Some((rgb, s[3].clamp(0.0, 1.0)))
}
}
/// The channel under which a clone or smudge stroke on a mask carries its mask values (the mask
/// has no channels of its own; any scalar channel works).
pub const MASK_CHANNEL: Channel = Channel::Roughness;
/// The stroke being drawn, shown before it is committed.
#[derive(Clone, Debug)]
pub struct StrokePreview {
pub target: PaintTarget,
/// Stroke alpha per texel (1 component, 0..1).
pub alpha: TileImage,
/// Stroke opacity cap.
pub opacity: f32,
pub erase: bool,
/// Values painted per channel (layer targets).
pub values: BTreeMap<Channel, [f32; 3]>,
/// Gray value painted into a mask.
pub mask_value: f32,
/// Projection tool: base color (and alpha) come from a screen-pinned image.
pub stencil: Option<Stencil>,
/// Clone and smudge: straight values per channel carried by the stroke (replace `values`).
pub carried: BTreeMap<Channel, TileImage>,
/// Mask coverage sampled by a mask pickup.
pub carried_mask: Option<TileImage>,
}
/// Everything the evaluator reads.
pub struct Inputs<'a> {
pub project: &'a Project,
pub ts: usize,
pub mesh: &'a Mesh,
pub gbuf: &'a UvGBuffer,
pub pixels: &'a PixelStore,
pub baked: &'a BakedMaps,
pub block_scales: BlockScales,
pub preview: Option<&'a StrokePreview>,
/// Imported image resources (fill sources).
pub images: &'a ImageStore,
/// Mesh bounds, for scale-independent procedural coordinates.
pub bounds: (Vec3, Vec3),
}
impl Inputs<'_> {
/// The UV tile grid of a UV-tiled set (the mesh's UVs for this set are in atlas space).
fn tile_grid(&self) -> Option<TileGrid> {
self.project.texture_set(self.ts).ok().and_then(TextureSet::tile_grid)
}
/// Texels per atlas block across (the whole width for a classic set): filter radii scale
/// with it, and with the tile's share of its block.
fn tile_res(&self) -> u32 {
self.gbuf.width / self.tile_grid().map_or(1, |g| g.cols.max(1))
}
/// The current UV tile can occupy only part of its atlas block
fn tile_res_at(&self, x: u32, y: u32) -> u32 {
((self.tile_res() as f32 * self.block_scales.at(x, y)).round() as u32).max(1)
}
}
/// The composited channels of one texture set.
#[derive(Clone, Debug, PartialEq)]
pub struct Composite {
/// Width in texels (the resolution of a classic, square set).
pub resolution: u32,
pub height: u32,
pub channels: BTreeMap<Channel, TileImage>,
/// The set's [`TextureSet::block_scales`]: height slopes on the display follow each tile.
pub block_scales: BlockScales,
}
impl Composite {
/// A square composite.
pub fn new(channels: &[Channel], resolution: u32) -> Composite {
Composite::with_size(channels, resolution, resolution)
}
pub fn with_size(channels: &[Channel], width: u32, height: u32) -> Composite {
Composite {
resolution: width,
height,
channels: channels.iter().map(|c| (*c, TileImage::new(width, height, c.components()))).collect(),
block_scales: BlockScales::default(),
}
}
/// Channel value at a texel (the channel default when absent).
pub fn value(&self, c: Channel, x: u32, y: u32) -> [f32; 3] {
let Some(img) = self.channels.get(&c) else { return c.default_value() };
let raw = img.get(x, y);
let k = c.kind();
if !img.is_allocated(x / TILE, y / TILE) {
return c.default_value();
}
if c.components() == 3 { [decode(k, raw[0]), decode(k, raw[1]), decode(k, raw[2])] } else { [decode(k, raw[0]); 3] }
}
}
/// Every tile of a `width × height` image.
pub fn all_tiles(width: u32, height: u32) -> Vec<(u32, u32)> {
let (nx, ny) = (width.div_ceil(TILE), height.div_ceil(TILE));
(0..ny).flat_map(|y| (0..nx).map(move |x| (x, y))).collect()
}
/// Tiles that hold at least one covered texel.
pub fn covered_tiles(gbuf: &UvGBuffer) -> Vec<(u32, u32)> {
let (tw, th) = (gbuf.width.div_ceil(TILE), gbuf.height.div_ceil(TILE));
let mut out = Vec::new();
for ty in 0..th {
for tx in 0..tw {
let any = (ty * TILE..((ty + 1) * TILE).min(gbuf.height))
.any(|y| (tx * TILE..((tx + 1) * TILE).min(gbuf.width)).any(|x| gbuf.tri.get((y * gbuf.width + x) as usize).is_some_and(|t| *t != NO_TRI)));
if any {
out.push((tx, ty));
}
}
}
out
}
// ---------------------------------------------------------------------------------------------
// Per-tile plan: the stack flattened with each layer's tile slices looked up once per tile.
struct ChanPlan<'a> {
ch: usize,
kind: ChannelKind,
comps: usize,
blend: BlendMode,
opacity: f32,
data: Option<Cow<'a, [u16]>>,
/// Visible content effects, holding this channel's tile for paint effects (empty, and
/// allocation free, for layers without content effects).
effects: Vec<EffectPlan<'a>>,
/// A content neighbourhood filter precomputed over the region: continue the effects after
/// effect `.0` starting from the field's value.
start: Option<(usize, &'a Field)>,
}
enum Content<'a> {
Paint { preview: bool },
Fill(&'a Fill),
Group(Vec<Node<'a>>),
}
struct EffectPlan<'a> {
/// The effect id (an anchor point records under it).
id: LayerId,
kind: &'a EffectKind,
blend: BlendMode,
opacity: f32,
data: Option<Cow<'a, [u16]>>,
preview: bool,
/// The curvature detail sizes a generator with detail reads.
curvature_sizes: Option<Arc<CurvatureSizes>>,
/// A filtered mask stage retained because an anchor above it records that stage.
filtered_mask: Option<&'a Field>,
}
struct MaskPlan<'a> {
background: f32,
effects: Vec<EffectPlan<'a>>,
/// A neighbourhood filter (blur, sharpen) precomputed over the region: continue the stack
/// after effect `.0` starting from the field's value.
start: Option<(usize, &'a Field)>,
}
/// A layer's mask (one value per texel) or one content channel (straight value and coverage)
/// after its last neighbourhood filter, over a texel region.
pub struct Field {
x0: u32,
y0: u32,
w: u32,
h: u32,
comps: usize,
data: Vec<f32>,
/// Intermediate mask stages needed by anchors, owned by this drawn layer's final field.
anchor_stages: Vec<(LayerId, Field)>,
}
impl Field {
fn get(&self, x: u32, y: u32) -> Option<&[f32]> {
if x < self.x0 || y < self.y0 || x >= self.x0 + self.w || y >= self.y0 + self.h {
return None;
}
let i = ((y - self.y0) * self.w + (x - self.x0)) as usize * self.comps;
self.data.get(i..i + self.comps)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum FieldKey {
Mask(LayerId),
Content(LayerId, Channel),
}
pub type Fields = HashMap<FieldKey, Field>;
/// How a neighbourhood filter reads around a texel.
#[derive(Clone, Copy)]
enum Op {
/// Box blurs (≈ Gaussian), sharpening by the amount when given.
Blur(Option<f32>),
/// The value minus its box blur, around the channel's mid value.
HighPass,
/// Values ramped down towards their shape's edge, from the box blur.
Bevel,
/// The value plus its box blur times the amount.
Glow(f32),
/// The value at the center of its cell (`r` texels across).
Mosaic,
/// Average along a direction (unit vector in texels).
Line([f32; 2]),
/// Read at an offset given by a noise vector field, or by noise along a direction.
Warp { scale: f32, seed: u32, dir: Option<[f32; 2]> },
/// Gradient magnitude from central differences.
Edge,
/// Average downhill along a noise height field.
Slope { scale: f32, seed: u32 },
}
/// The last neighbourhood filter of an effect stack (see [`neighbourhood_filters`]).
fn neighbourhood(effects: &[Effect], res: u32) -> Option<(usize, f32, Op)> {
neighbourhood_filters(effects, res).last()
}
/// Below this a coverage weight counts as no coverage at all.
const MIN_COVERAGE_WEIGHT: f32 = 1e-6;
/// Filter sizes are texels at this many texels per side (2K), scaled to the resolution they run at.
const FILTER_SIZE_RESOLUTION: f32 = 2048.0;
/// The smallest radius a filter runs at, in texels.
const MIN_FILTER_RADIUS: f32 = 0.5;
/// Sharpen's blur radius at [`FILTER_SIZE_RESOLUTION`], and the smallest it runs at, in texels.
const SHARPEN_RADIUS: f32 = 1.5;
const MIN_SHARPEN_RADIUS: f32 = 0.75;
/// The neighbourhood filters of an effect stack, bottom → top: index among the visible effects, radius in texels (`res` texels per UV tile across) and what it does.
fn neighbourhood_filters(effects: &[Effect], res: u32) -> impl Iterator<Item = (usize, f32, Op)> + '_ {
let texels = move |size: f32| (size * res as f32 / FILTER_SIZE_RESOLUTION).max(MIN_FILTER_RADIUS);
effects.iter().filter(|effect| effect.visible).enumerate().filter_map(move |(index, effect)| match &effect.kind {
EffectKind::Filter(Filter::Blur { radius }) if *radius > 0.0 => Some((index, texels(*radius), Op::Blur(None))),
EffectKind::Filter(Filter::Sharpen { amount }) => {
Some((index, (SHARPEN_RADIUS * res as f32 / FILTER_SIZE_RESOLUTION).max(MIN_SHARPEN_RADIUS), Op::Blur(Some(*amount))))
}
EffectKind::Filter(Filter::DirectionalBlur { radius, angle }) if *radius > 0.0 => Some((index, texels(*radius), Op::Line(direction(*angle)))),
EffectKind::Filter(Filter::Warp { intensity, scale, seed }) if *intensity > 0.0 => {
Some((index, texels(*intensity), Op::Warp { scale: *scale, seed: *seed, dir: None }))
}
EffectKind::Filter(Filter::DirectionalWarp { intensity, angle, scale, seed }) if *intensity > 0.0 => {
Some((index, texels(*intensity), Op::Warp { scale: *scale, seed: *seed, dir: Some(direction(*angle)) }))
}
EffectKind::Filter(Filter::HighPass { radius }) => Some((index, texels(*radius), Op::HighPass)),
EffectKind::Filter(Filter::EdgeDetect { width }) => Some((index, texels(*width), Op::Edge)),
// Three box passes ramp an edge over about twice their radius
EffectKind::Filter(Filter::Bevel { width }) => Some((index, texels(*width * 0.5), Op::Bevel)),
EffectKind::Filter(Filter::Glow { radius, amount }) => Some((index, texels(*radius), Op::Glow(*amount))),
EffectKind::Filter(Filter::Mosaic { size }) => Some((index, texels(*size), Op::Mosaic)),
// Independent of `res`, so every caller agrees on which effects are stages; the reach covers the cells, then the blur around them
EffectKind::Generator(generator) if generator.global.blur > 0.0 || generator.resolution.can_reduce() => {
Some((index, texels(generator.global.blur_radius()) + generator.resolution.largest_cell(res) as f32, Op::Blur(None)))
}
EffectKind::Filter(Filter::SlopeBlur { radius, scale, seed }) if *radius > 0.0 => {
Some((index, texels(*radius), Op::Slope { scale: *scale, seed: *seed }))
}
_ => None,
})
}
/// Whether any mask or content effect in a texture set reads neighbouring texels. Includes
/// filters, blurred generators and reduced-resolution generators. Hidden layers and disabled
/// masks count too, so partial invalidation remains conservative.
pub fn stack_reads_neighbours(project: &Project, texture_set_index: usize) -> bool {
const NEIGHBOUR_PROBE_RESOLUTION: u32 = 2048;
let Some(set) = project.texture_sets.get(texture_set_index) else {
return false;
};
project.render_tree(&set.stack).iter().filter_map(|id| project.layers.get(id)).any(|layer| {
neighbourhood(&layer.content_effects, NEIGHBOUR_PROBE_RESOLUTION).is_some()
|| layer.mask.as_ref().is_some_and(|mask| neighbourhood(&mask.effects, NEIGHBOUR_PROBE_RESOLUTION).is_some())
})
}
/// Unit texel-space vector of `angle` degrees. Texel rows run down: positive angles turn
/// counterclockwise on screen.
fn direction(angle: f32) -> [f32; 2] {
let (sn, cs) = angle.to_radians().sin_cos();
[cs, -sn]
}
/// Gain on the curvature map's own deviation from flat (±0.5 reaches black and white).
const MAP_GAIN: f32 = 2.0;
/// Gain per texel of a detail size: blurring spreads an edge over about twice its radius, so wider sizes need proportionally more to reach full strength.
const GAIN_PER_DETAIL_TEXEL: f32 = 2.0 * std::f32::consts::SQRT_2;
/// Samples along a directional or slope blur at most (beyond, samples spread out).
const LINE_SAMPLES: i32 = 24;
/// Fractal noise over texel position `(x, y)` (`res` texels per UV unit, `scale` features per
/// UV unit), shifted by `d` in noise space.
fn texel_noise(x: f32, y: f32, d: [f32; 2], res: u32, scale: f32, seed: u32) -> f32 {
let k = if scale.is_finite() { scale.clamp(0.01, 1000.0) } else { 1.0 } / res.max(1) as f32;
noise::fbm([x * k + d[0], y * k + d[1], 0.0], 3, seed, noise::perlin)
}
/// The neighbourhood filters that gather samples (directional and slope blur, warp) over a
/// field region `(x0, y0, w, h)` of premultiplied `orig` texels (`comps` each) and their
/// `cover`: bilinear samples weighted by coverage, so uncovered texels don't bleed in.
/// Positions are absolute texel coordinates, so a texel's result does not depend on the region.
#[allow(clippy::too_many_arguments)]
fn gather(op: Op, orig: &[f32], cover: &[f32], comps: usize, (x0, y0, w, h): (u32, u32, u32, u32), r: f32, res: u32, opacity: f32) -> Vec<f32> {
let mut data = orig.to_vec();
let (wu, hu) = (w as usize, h as usize);
// Bilinear sample at absolute texel position (fx, fy) into `acc` (components, then weight).
let sample = |fx: f32, fy: f32, acc: &mut [f32; 5]| {
if !(fx.is_finite() && fy.is_finite()) {
return;
}
let (bx, by) = (fx.floor(), fy.floor());
let (tx, ty) = (fx - bx, fy - by);
for (dx, dy, k) in [(0, 0, (1.0 - tx) * (1.0 - ty)), (1, 0, tx * (1.0 - ty)), (0, 1, (1.0 - tx) * ty), (1, 1, tx * ty)] {
let (cx, cy) = (bx as i64 + dx - i64::from(x0), by as i64 + dy - i64::from(y0));
if k <= 0.0 || cx < 0 || cy < 0 || cx >= wu as i64 || cy >= hu as i64 {
continue;
}
let i = cy as usize * wu + cx as usize;
let (Some(c), Some(px)) = (cover.get(i), orig.get(i * comps..(i + 1) * comps)) else { continue };
for (a, v) in acc.iter_mut().zip(px) {
*a += v * k;
}
acc[4] += c * k;
}
};
data.par_chunks_mut((comps * wu).max(1)).enumerate().for_each(|(row, line)| {
for col in 0..wu {
if cover.get(row * wu + col).is_none_or(|c| *c <= 0.0) {
continue;
}
let (x, y) = ((x0 as usize + col) as f32, (y0 as usize + row) as f32);
let mut acc = [0.0f32; 5];
let n = (r.ceil() as i32).clamp(1, LINE_SAMPLES);
let step = r / n as f32;
match op {
Op::Line(d) => {
for s in -n..=n {
let t = s as f32 * step;
sample(x + d[0] * t, y + d[1] * t, &mut acc);
}
}
Op::Warp { scale, seed, dir } => {
let off = |salt: u32| ((texel_noise(x, y, [0.0; 2], res, scale, seed ^ salt) - 0.5) * 3.0).clamp(-1.0, 1.0) * r;
match dir {
Some(d) => {
let t = off(0);
sample(x + d[0] * t, y + d[1] * t, &mut acc);
}
None => sample(x + off(0), y + off(0x5BD1_E995), &mut acc),
}
}
Op::Edge => {
let center = orig.get((row * wu + col) * comps..(row * wu + col + 1) * comps).unwrap_or(&[]);
let at = |dx: f32, dy: f32| {
let mut a = [0.0f32; 5];
sample(x + dx, y + dy, &mut a);
a
};
let (l, rt, u, d) = (at(-r, 0.0), at(r, 0.0), at(0.0, -r), at(0.0, r));
// A side outside the UV island reads the texel itself: seams are not edges.
let val = |a: &[f32; 5], k: usize| if a[4] > 1e-6 { a[k] / a[4] } else { center.get(k).copied().unwrap_or(0.0) };
let mag = |k: usize| (val(&rt, k) - val(&l, k)).hypot(val(&d, k) - val(&u, k)).min(1.0);
// Content stays premultiplied by its own coverage; masks are one value.
let cov = if comps == 4 { center.get(3).copied().unwrap_or(0.0) } else { 1.0 };
for (k, a) in acc.iter_mut().enumerate().take(comps.min(3)) {
*a = mag(k) * cov;
}
if comps == 4 {
acc[3] = cov;
}
acc[4] = 1.0;
}
Op::Slope { scale, seed } => {
let e = 0.01;
let hgt = |dx: f32, dy: f32| texel_noise(x, y, [dx, dy], res, scale, seed);
// Downhill; a flat spot keeps its value.
let d = Vec2::new(hgt(-e, 0.0) - hgt(e, 0.0), hgt(0.0, -e) - hgt(0.0, e)).try_normalize().unwrap_or(Vec2::ZERO);
for s in 0..=n {
let t = s as f32 * step;
sample(x + d.x * t, y + d.y * t, &mut acc);
}
}
Op::Mosaic => {
let center = |v: f32| ((v / r).floor() + 0.5) * r - 0.5;
sample(center(x), center(y), &mut acc);
}
Op::Blur(_) | Op::HighPass | Op::Bevel | Op::Glow(_) => {}
}
if acc[4] > 1e-6
&& let Some(px) = line.get_mut(col * comps..(col + 1) * comps)
{
for (slot, a) in px.iter_mut().zip(acc) {
*slot += (a / acc[4] - *slot) * opacity;
}
}
}
});
data
}
/// Fixed-point scale of the blur. Integer running sums make a texel's result independent of
/// the region it is computed in, so tiles composited in any grouping agree exactly.
const FIX: f64 = (1u64 << 24) as f64;
/// Texels one parallel task of a neighbourhood filter handles at least. Compositing in frame slices filters regions of a few tiles: split per texel,
/// handing that little work to every thread costs far more than the work itself. Each texel is computed on its own, so the split does not change results.
const MIN_PARALLEL_TEXELS: usize = 1 << 14;
/// How many lines of `length` texels make a parallel task of at least [`MIN_PARALLEL_TEXELS`].
fn lines_per_task(length: usize) -> usize {
(MIN_PARALLEL_TEXELS / length.max(1)).max(1)
}
/// Three running-sum box blurs (≈ Gaussian) of a `width × height` image along its rows, then its columns, each in parallel.
pub(crate) fn blur(data: &mut [f32], width: usize, height: usize, radius: usize) {
// Bound samples before fixed-point accumulation
const MAX_INPUT_MAGNITUDE: f32 = 1e6;
let to_fixed = |value: &f32| if value.is_finite() { (f64::from(value.clamp(-MAX_INPUT_MAGNITUDE, MAX_INPUT_MAGNITUDE)) * FIX).round() as i64 } else { 0 };
let mut fixed: Vec<i64> = data.par_iter().with_min_len(MIN_PARALLEL_TEXELS).map(to_fixed).collect();
blur_rows(&mut fixed, width, radius);
let mut columns = transpose(&fixed, width, height);
blur_rows(&mut columns, height, radius);
transpose_into(&columns, height, width, &mut fixed);
data.par_iter_mut().with_min_len(MIN_PARALLEL_TEXELS).zip(fixed).for_each(|(target, blurred)| *target = (blurred as f64 / FIX) as f32);
}
/// The box blurs `blur` runs along each axis
pub(crate) const BLUR_BOX_PASSES: usize = 3;
/// Three box blurs of radius `r` along every row (`w` long) of `data`.
fn blur_rows(data: &mut [i64], w: usize, r: usize) {
if w == 0 {
return;
}
data.par_chunks_mut(w).with_min_len(lines_per_task(w)).for_each(|row| {
let mut scratch = vec![0i64; row.len()];
for _ in 0..BLUR_BOX_PASSES {
box_line(row, &mut scratch, r);
row.copy_from_slice(&scratch);
}
});
}
/// One box blur of radius `r` of a line (texels past the ends count as 0).
fn box_line(src: &[i64], dst: &mut [i64], r: usize) {
let n = (2 * r + 1) as i64;
// Rounded division of a window sum.
let avg = |acc: i64| (2 * acc + n).div_euclid(2 * n);
let mut acc: i64 = src.iter().take(r + 1).sum();
for (i, d) in dst.iter_mut().enumerate() {
*d = avg(acc);
acc += src.get(i + r + 1).copied().unwrap_or(0);
if i >= r {
acc -= src.get(i - r).copied().unwrap_or(0);
}
}
}
/// `src` (`w × h`, row-major) transposed to `h × w`.
fn transpose(src: &[i64], w: usize, h: usize) -> Vec<i64> {
let mut out = vec![0i64; src.len()];
transpose_into(src, w, h, &mut out);
out
}
fn transpose_into(src: &[i64], w: usize, h: usize, out: &mut [i64]) {
if h > 0 {
out.par_chunks_mut(h).with_min_len(lines_per_task(h)).enumerate().for_each(|(x, col)| {
for (y, d) in col.iter_mut().enumerate() {
*d = src.get(y * w + x).copied().unwrap_or(0);
}
});
}
}
/// Covered texels of tile (tx, ty): (x, y, offset inside the tile).
fn tile_texels(gbuf: &UvGBuffer, tx: u32, ty: u32) -> impl Iterator<Item = (u32, u32, usize)> + '_ {
let (w, h) = (gbuf.width, gbuf.height);
(0..TILE).flat_map(|ly| (0..TILE).map(move |lx| (lx, ly))).filter_map(move |(lx, ly)| {
let (x, y) = (tx * TILE + lx, ty * TILE + ly);
(x < w && y < h && gbuf.tri.get((y * w + x) as usize).is_some_and(|t| *t != NO_TRI)).then_some((x, y, (ly * TILE + lx) as usize))
})
}
/// Live stroke alpha at offset `o` of a preview tile.
fn stroke_at(preview: Option<&[u16]>, o: usize) -> f32 {
preview.and_then(|t| t.get(o)).map(|v| from_u16(*v)).unwrap_or(0.0)
}
/// The full stack of tile (tx, ty) when `layer` reads anchor points (empty otherwise): evaluated
/// up to the layer, it records the anchors below it.
fn anchor_plan<'a>(inp: &Inputs<'a>, id: LayerId, channels: &[Channel], tx: u32, ty: u32, fields: Option<&'a Fields>) -> Vec<Node<'a>> {
match inp.project.texture_set(inp.ts) {
Ok(set) if reads_anchor(inp.project, id) => plan(inp, &set.stack, channels, tx, ty, 0, fields),
_ => Vec::new(),
}
}
/// Whether layer `id` (its own mask, or the content it draws) reads an anchor point.
pub(crate) fn reads_anchor(p: &Project, id: LayerId) -> bool {
p.layers.get(&id).is_some_and(Layer::reads_anchor) || p.content_layer(id).is_some_and(Layer::reads_anchor)
}
/// The mask layer `id` draws with: its own, or an instance source's.
fn layer_mask(p: &Project, id: LayerId) -> Option<&Mask> {
p.layers.get(&p.mask_owner(id))?.mask.as_ref()
}
/// Layers of `list` in drawing order (bottom → top, folder and instanced folder contents after
/// their folder).
fn draw_order(p: &Project, list: &[LayerId], depth: usize, out: &mut Vec<LayerId>) {
if depth > texturecraft_core::project::MAX_DEPTH {
return;
}
for id in list {
out.push(*id);
if let Some(l) = p.content_layer(*id) {
draw_order(p, l.children(), depth + 1, out);
}
}
}
/// What a field holds.
#[derive(Clone, Copy)]
enum Job<'a> {
Mask(&'a Mask),
Content(Channel),
}
/// A layer's mask or content channel after every neighbourhood filter of its stack, over `tiles`.
fn field(inp: &Inputs, channels: &[Channel], below: &Fields, id: LayerId, job: Job, tiles: &[(u32, u32)]) -> Option<Field> {
let effects = match job {
Job::Mask(mask) => &mask.effects,
Job::Content(_) => &inp.project.content_layer(id)?.content_effects,
};
let filters: Vec<(usize, f32, Op)> = neighbourhood_filters(effects, inp.tile_res()).collect();
let longest_side = inp.gbuf.width.max(inp.gbuf.height);
// Each filter's region also holds what every filter above it reads around the tiles
let mut margins: Vec<u32> = filters.iter().map(|&(_, radius, op)| filter_extent(radius, op, longest_side).1.div_ceil(TILE)).collect();
for index in (0..margins.len().saturating_sub(1)).rev() {
margins[index] += margins[index + 1];
}
let mut previous: Option<(usize, Field)> = None;
let mut anchor_stages = Vec::new();
for (&filter, &margin) in filters.iter().zip(&margins) {
let region = region_around(inp, tiles, margin)?;
let start = previous.as_ref().map(|(index, field)| (*index, field));
let filtered = filter_region(inp, channels, below, id, job, effects, filter, region, start)?;
// Preserve only stages with anchors before the next filter overwrites their value
if let Some((previous_index, previous_field)) = previous.take()
&& matches!(job, Job::Mask(_))
{
let mut visible = effects.iter().filter(|effect| effect.visible).skip(previous_index);
let previous_effect = visible.next();
let records_anchor = visible.take(filter.0 - previous_index - 1).any(|effect| matches!(effect.kind, EffectKind::Anchor));
if records_anchor && let Some(previous_effect) = previous_effect {
anchor_stages.push((previous_effect.id, previous_field));
}
}
previous = Some((filter.0, filtered));
}
previous.map(|(_, mut field)| {
field.anchor_stages = anchor_stages;
field
})
}
/// The tile-aligned texel region `(x0, y0, w, h)` around `tiles` plus `margin` tiles, clipped to the set.
fn region_around(inp: &Inputs, tiles: &[(u32, u32)], margin: u32) -> Option<(u32, u32, u32, u32)> {
let (first_x, first_y) = tiles.iter().fold((u32::MAX, u32::MAX), |(min_x, min_y), tile| (min_x.min(tile.0), min_y.min(tile.1)));
let (last_x, last_y) = tiles.iter().fold((0, 0), |(max_x, max_y), tile| (max_x.max(tile.0), max_y.max(tile.1)));
let (x0, y0) = (first_x.saturating_sub(margin) * TILE, first_y.saturating_sub(margin) * TILE);
let (x1, y1) = (((last_x + 1 + margin) * TILE).min(inp.gbuf.width), ((last_y + 1 + margin) * TILE).min(inp.gbuf.height));
let (w, h) = (x1.saturating_sub(x0), y1.saturating_sub(y0));
(w > 0 && h > 0).then_some((x0, y0, w, h))
}
/// A neighbourhood filter's radius in whole texels and how many texels around a texel it reads.
fn filter_extent(radius: f32, op: Op, longest_side: u32) -> (u32, u32) {
// Clamped so a hostile radius can't overflow the region arithmetic
let radius_texels = radius.round().clamp(1.0, longest_side as f32) as u32;
// Three box passes reach three radii; the gathering filters one radius plus a bilinear texel
let reach = if is_box_blur(op) { 3 * radius_texels } else { radius_texels + 1 };
(radius_texels, reach)
}
/// Whether neighbourhood filter `op` is computed from box blurs (the others gather samples).
fn is_box_blur(op: Op) -> bool {
matches!(op, Op::Blur(_) | Op::HighPass | Op::Bevel | Op::Glow(_))
}
/// The stack up to and including neighbourhood filter `filter` over texel `region`, continued from `start` (the filter below's field) when given.
#[allow(clippy::too_many_arguments)]
fn filter_region(
inputs: &Inputs,
channels: &[Channel],
below: &Fields,
id: LayerId,
job: Job,
effects: &[Effect],
(index, radius, op): (usize, f32, Op),
(region_x, region_y, width, height): (u32, u32, u32, u32),
start: Option<(usize, &Field)>,
) -> Option<Field> {
let filter_effect = effects.iter().filter(|effect| effect.visible).nth(index);
let opacity = filter_effect.map(|effect| effect.opacity.clamp(0.0, 1.0)).unwrap_or(1.0);
let (radius_texels, _) = filter_extent(radius, op, inputs.gbuf.width.max(inputs.gbuf.height));
// Generator stages keep their ramp beside the mask stack below
let generator = match (job, filter_effect.map(|effect| (&effect.kind, effect.blend))) {
(Job::Mask(_), Some((EffectKind::Generator(generator), blend))) => Some((generator, blend)),
_ => None,
};
let components = match job {
Job::Mask(_) if generator.is_some() => 2,
Job::Mask(_) => 1,
Job::Content(_) => 4,
};
// Evaluate the stack up to the filter, tile by tile (content premultiplied by coverage)
let (region_right, region_bottom) = (region_x + width, region_y + height);
let region_tiles: Vec<(u32, u32)> =
(region_y / TILE..region_bottom.div_ceil(TILE)).flat_map(|y| (region_x / TILE..region_right.div_ceil(TILE)).map(move |x| (x, y))).collect();
let parts: Vec<Vec<(u32, u32, [f32; 4])>> = region_tiles
.par_iter()
.map(|&(tile_x, tile_y)| {
let anchor_nodes = anchor_plan(inputs, id, channels, tile_x, tile_y, Some(below));
let preview_tile = inputs.preview.and_then(|preview| preview.alpha.tile(tile_x, tile_y));
let mut mask = None;
let mut nodes = Vec::new();
let mut generator_sizes = None;
match job {
Job::Mask(layer_mask) => {
let Some(mut mask_stack) = mask_plan(inputs, id, layer_mask, tile_x, tile_y, None) else { return Vec::new() };
generator_sizes = mask_stack.effects.get(index).and_then(|effect| effect.curvature_sizes.clone());
mask_stack.effects.truncate(index);
mask_stack.start = start;
mask = Some(mask_stack);
}
Job::Content(channel) => {
nodes = plan(inputs, &[id], &[channel], tile_x, tile_y, 0, Some(below));
if let Some(channel_plan) = nodes.first_mut().and_then(|node| node.chans.first_mut()) {
channel_plan.effects.truncate(index);
channel_plan.start = start;
}
}
}
tile_texels(inputs.gbuf, tile_x, tile_y)
.map(|(x, y, offset)| {
let mut texel = Texel::new(inputs, x, y, offset, stroke_at(preview_tile, offset));
if !anchor_nodes.is_empty() {
texel.anchors_below(&anchor_nodes, id);
}
let value = match (&mask, nodes.first()) {
(Some(mask_stack), _) => {
let ramp = generator.map_or(0.0, |(generator, _)| texel.generator_ramp(generator, generator_sizes.as_deref()));
[texel.mask(mask_stack), ramp, 0.0, 0.0]
}
(None, Some(node)) => match node.chans.first().and_then(|channel_plan| texel.content(&node.content, channel_plan)) {
Some((color, coverage)) => [color[0] * coverage, color[1] * coverage, color[2] * coverage, coverage],
None => [0.0; 4],
},
(None, None) => [0.0; 4],
};
(x, y, value)
})
.collect()
})
.collect();
// Scatter into the region, a row of tiles at a time (the region is tile aligned)
let texel_count = (width * height) as usize;
let mut stack_values = vec![0.0f32; texel_count * components];
let mut cover = vec![0.0f32; texel_count];
let row_tiles = (region_right.div_ceil(TILE) - region_x / TILE).max(1) as usize;
let band = (TILE * width) as usize;
stack_values.par_chunks_mut(band * components).zip(cover.par_chunks_mut(band)).zip(parts.par_chunks(row_tiles)).for_each(|((stack_values, cover), row)| {
for &(x, y, value) in row.iter().flatten() {
let texel = (((y - region_y) % TILE) * width + (x - region_x)) as usize;
if let (Some(covered), Some(pixel)) = (cover.get_mut(texel), stack_values.get_mut(texel * components..(texel + 1) * components)) {
*covered = 1.0;
pixel.copy_from_slice(&value[..components]);
}
}
});
// Release tile scatter data before allocating filter buffers
drop(parts);
// High pass centers on the channel's middle value (0 for signed channels like height)
let middle = match job {
Job::Content(channel) if channel.kind() == ChannelKind::Signed => 0.0,
_ => 0.5,
};
// A smaller UV tile has fewer texels per UV unit, so its filters reach fewer texels
let filtered = |scale: f32| -> Vec<f32> {
let tile_resolution = ((inputs.tile_res() as f32 * scale).round() as u32).max(1);
if let Some((generator, blend)) = generator {
let texture_set = inputs.project.texture_set(inputs.ts).map_or(inputs.tile_res(), |set| set.resolution);
return generator_region(generator, blend, opacity, &stack_values, &cover, (region_x, region_y, width, height), (tile_resolution, texture_set));
}
let scaled_radius = neighbourhood_filters(effects, tile_resolution)
.find(|filter| filter.0 == index)
.map_or(radius_texels, |filter| filter.1.round().clamp(1.0, radius_texels as f32) as u32);
if !is_box_blur(op) {
return gather(op, &stack_values, &cover, components, (region_x, region_y, width, height), scaled_radius as f32, tile_resolution, opacity);
}
// Weighted so uncovered texels don't bleed in
let (columns, rows, blur_radius) = (width as usize, height as usize, scaled_radius as usize);
let mut weights = cover.clone();
blur(&mut weights, columns, rows, blur_radius);
let mut filtered_values = stack_values.clone();
for component in 0..components {
let mut sums: Vec<f32> = stack_values.par_chunks(components).map(|pixel| pixel.get(component).copied().unwrap_or(0.0)).collect();
blur(&mut sums, columns, rows, blur_radius);
filtered_values.par_chunks_mut(components).zip(sums.par_iter()).zip(weights.par_iter()).for_each(|((pixel, sum), weight)| {
// Content is premultiplied, so the middle value is too (coverage itself is kept)
let coverage = if components == 4 { pixel.get(3).copied().unwrap_or(0.0) } else { 1.0 };
if *weight > MIN_COVERAGE_WEIGHT
&& let Some(slot) = pixel.get_mut(component)
{
let (original, blurred) = (*slot, sum / weight);
let result = match op {
Op::Blur(Some(amount)) => original + amount * (original - blurred),
Op::HighPass if component < 3 => original - blurred + middle * coverage,
// Away from 0 by at most the value itself: 0 at the edge, full inside
Op::Bevel if component < 3 => original.signum() * original.abs().min((2.0 * blurred * original.signum() - original.abs()).max(0.0)),
Op::Glow(amount) if component < 3 => original + amount * blurred,
Op::HighPass | Op::Bevel | Op::Glow(_) => original,
_ => blurred,
};
*slot = original + (result - original) * opacity;
}
});
}
filtered_values
};
// Each block keeps the result at its tile's scale (blocks are TILE aligned)
let scales = inputs.project.texture_set(inputs.ts).map(TextureSet::block_scales).unwrap_or_default();
let mut levels: Vec<f32> = (region_y..region_bottom)
.step_by(TILE as usize)
.flat_map(|y| (region_x..region_right).step_by(TILE as usize).map(move |x| (x, y)))
.map(|(x, y)| scales.at(x, y))
.collect();
levels.sort_by(f32::total_cmp);
levels.dedup();
let (first, rest) = levels.split_first().map_or((1.0, &[][..]), |(first, rest)| (*first, rest));
// A generator stage's field is the mask alone
let field_components = if generator.is_some() { 1 } else { components };
let mut result = filtered(first);
for &scale in rest {
let rescaled = filtered(scale);
let row = width as usize * field_components;
result.par_chunks_mut(row).zip(rescaled.par_chunks(row)).enumerate().for_each(|(y, (target_row, source_row))| {
for (x, (target, source)) in target_row.chunks_mut(field_components).zip(source_row.chunks(field_components)).enumerate() {
if scales.at(region_x + x as u32, region_y + y as u32) == scale {
target.copy_from_slice(source);
}
}
});
}
unpremultiply(&mut result, field_components);
Some(Field { x0: region_x, y0: region_y, w: width, h: height, comps: field_components, data: result, anchor_stages: Vec::new() })
}
/// The mask over a region after a generator at its own resolution and blur: `stack` is (stack below, generator ramp) per texel, sizes in texels per side.
fn generator_region(
generator: &Generator,
blend: BlendMode,
opacity: f32,
stack: &[f32],
cover: &[f32],
(region_x, region_y, width, height): (u32, u32, u32, u32),
(uv_tile, texture_set): (u32, u32),
) -> Vec<f32> {
let (columns, rows) = (width as usize, height as usize);
let mut ramps: Vec<f32> = stack.par_chunks(2).map(|texel| texel.get(1).copied().unwrap_or(0.0)).collect();
// Coarser than the UV tile: averaged over cells, then the blur around them
let cell = generator.resolution.cell(uv_tile, texture_set) as usize;
if cell > 1 {
ramps = resampled_by_cells(&ramps, cover, (region_x as usize, region_y as usize, columns, rows), cell);
}
let blur_radius = generator.global.blur_radius_at(uv_tile).round() as usize;
if blur_radius > 0 {
let mut weights = cover.to_vec();
blur(&mut weights, columns, rows, blur_radius);
let mut sums: Vec<f32> = ramps.iter().zip(cover).map(|(ramp, covered)| ramp * covered).collect();
blur(&mut sums, columns, rows, blur_radius);
ramps.par_iter_mut().zip(sums.par_iter().zip(weights.par_iter())).for_each(|(ramp, (sum, weight))| {
if *weight > MIN_COVERAGE_WEIGHT {
*ramp = sum / weight;
}
});
}
// Finished and blended over the stack below, like the generator effect itself
stack
.par_chunks(2)
.zip(ramps.par_iter())
.map(|(texel, ramp)| {
let below = texel.first().copied().unwrap_or(0.0);
let generated = finish_generator(generator, *ramp);
below + (blend1(blend, below, generated) - below) * opacity
})
.collect()
}
/// `values` averaged over `cell` × `cell` texel cells on the mesh (`cover`), read back bilinearly between cell centers.
fn resampled_by_cells(values: &[f32], cover: &[f32], (region_x, region_y, width, height): (usize, usize, usize, usize), cell: usize) -> Vec<f32> {
// Cells are aligned to absolute texel positions, so a texel's cell is the same in every region
let (first_column, first_row) = (region_x / cell, region_y / cell);
let columns = (region_x + width).div_ceil(cell) - first_column;
let rows = (region_y + height).div_ceil(cell) - first_row;
// Each cell's coverage-weighted average, a row of cells at a time
let averages: Vec<Option<f32>> = (0..rows)
.into_par_iter()
.flat_map_iter(|row| {
let mut sums = vec![(0.0f32, 0.0f32); columns];
let first_y = ((first_row + row) * cell).saturating_sub(region_y);
let last_y = ((first_row + row + 1) * cell).saturating_sub(region_y).min(height);
for y in first_y..last_y {
for x in 0..width {
let texel = y * width + x;
let covered = cover.get(texel).copied().unwrap_or(0.0);
if let Some((sum, weight)) = sums.get_mut((region_x + x) / cell - first_column) {
*sum += values.get(texel).copied().unwrap_or(0.0) * covered;
*weight += covered;
}
}
}
sums.into_iter().map(|(sum, weight)| (weight > MIN_COVERAGE_WEIGHT).then(|| sum / weight))
})
.collect();
let average = |column: isize, row: isize| -> Option<f32> {
let column = column.clamp(0, columns as isize - 1) as usize;
let row = row.clamp(0, rows as isize - 1) as usize;
averages.get(row * columns + column).copied().flatten()
};
let cell_size = cell as f32;
(0..height)
.into_par_iter()
.flat_map_iter(|y| (0..width).map(move |x| (x, y)))
.map(|(x, y)| {
// Position in cells, relative to the first cell's center
let cell_x = ((region_x + x) as f32 + 0.5) / cell_size - 0.5 - first_column as f32;
let cell_y = ((region_y + y) as f32 + 0.5) / cell_size - 0.5 - first_row as f32;
let (left, top) = (cell_x.floor(), cell_y.floor());
let (offset_x, offset_y) = (cell_x - left, cell_y - top);
let (left, top) = (left as isize, top as isize);
let corners = [
(left, top, (1.0 - offset_x) * (1.0 - offset_y)),
(left + 1, top, offset_x * (1.0 - offset_y)),
(left, top + 1, (1.0 - offset_x) * offset_y),
(left + 1, top + 1, offset_x * offset_y),
];
let (sum, weight) = corners.iter().fold((0.0, 0.0), |(sum, weight), &(column, row, corner_weight)| match average(column, row) {
Some(value) => (sum + value * corner_weight, weight + corner_weight),
None => (sum, weight),
});
if weight > MIN_COVERAGE_WEIGHT { sum / weight } else { values.get(y * width + x).copied().unwrap_or(0.0) }
})
.collect()
}
/// A generator's (possibly blurred) ramp after balance, contrast, invert and offset.
fn finish_generator(generator: &Generator, ramp: f32) -> f32 {
let value = generator.global.apply(ramp);
let value = if generator.invert { 1.0 - value } else { value };
let offset = if generator.offset.is_finite() { generator.offset } else { 0.0 };
(value + offset).clamp(0.0, 1.0)
}
/// Clamp filtered masks to 0..1, and turn filtered content back into straight values.
fn unpremultiply(data: &mut [f32], comps: usize) {
// Avoid amplifying rounding error near transparent texels
const MIN_COVERAGE: f32 = 1e-5;
data.par_chunks_mut(comps).with_min_len(MIN_PARALLEL_TEXELS).for_each(|px| match px {
[v] => *v = v.clamp(0.0, 1.0),
[r, g, b, cov] => {
*cov = cov.clamp(0.0, 1.0);
let inv = if *cov > MIN_COVERAGE { 1.0 / *cov } else { 0.0 };
*r *= inv;
*g *= inv;
*b *= inv;
}
_ => {}
});
}
/// Precompute the neighbourhood-filtered masks and content channels of every layer that needs
/// one, over `tiles` plus the filter's reach. Walks bottom → top so each field sees the fields
/// (and anchors) below it. Cheap when no layer has a blur or sharpen.
pub fn neighbourhood_fields(inp: &Inputs, channels: &[Channel], tiles: &[(u32, u32)]) -> Fields {
let stack = inp.project.texture_set(inp.ts).map(|s| s.stack.as_slice()).unwrap_or_default();
fields_of(inp, channels, stack, tiles)
}
/// [`neighbourhood_fields`] of the layers drawn by `list` only.
fn fields_of(inp: &Inputs, channels: &[Channel], list: &[LayerId], tiles: &[(u32, u32)]) -> Fields {
let mut out = Fields::new();
if tiles.is_empty() || inp.gbuf.width == 0 {
return out;
}
let working_width = inp.gbuf.width;
let mut order = Vec::new();
draw_order(inp.project, list, 0, &mut order);
prepare_curvature_sizes(inp, &order);
for id in order {
let Some(layer) = inp.project.content_layer(id) else { continue };
if let Some(mask) = layer_mask(inp.project, id).filter(|mask| mask.enabled && neighbourhood(&mask.effects, working_width).is_some())
&& let Some(filtered) = field(inp, channels, &out, id, Job::Mask(mask), tiles)
{
out.insert(FieldKey::Mask(id), filtered);
}
if layer.is_group() || neighbourhood(&layer.content_effects, working_width).is_none() {
continue;
}
for channel in channels.iter().filter(|channel| layer.channels.contains_key(channel)) {
if let Some(filtered) = field(inp, channels, &out, id, Job::Content(*channel), tiles) {
out.insert(FieldKey::Content(id, *channel), filtered);
}
}
}
out
}
/// Build the curvature detail sizes every visible generator of `layers` reads, once, before tiles composite in parallel.
fn prepare_curvature_sizes(inp: &Inputs, layers: &[LayerId]) {
let visible = layers.iter().filter(|id| inp.project.layers.get(id).is_some_and(|layer| layer.visible));
let masks = visible.filter_map(|id| layer_mask(inp.project, *id)).filter(|mask| mask.enabled);
prepare_mask_curvature_sizes(inp, masks);
}
/// Build the curvature detail sizes the visible generators of `masks` read, once, before tiles composite in parallel.
fn prepare_mask_curvature_sizes<'a>(inp: &Inputs, masks: impl Iterator<Item = &'a Mask>) {
let mut needed = [false; CurvatureDetail::BLURRED_SIZES];
for effect in masks.flat_map(|mask| &mask.effects).filter(|effect| effect.visible) {
if let EffectKind::Generator(Generator { detail: Some(detail), .. }) = &effect.kind {
for (slot, in_use) in needed.iter_mut().zip(detail.blurred_sizes_in_use()) {
*slot |= in_use;
}
}
}
CurvatureSizes::of(inp, &needed);
}
struct Node<'a> {
id: LayerId,
content: Content<'a>,
chans: Vec<ChanPlan<'a>>,
mask: Option<MaskPlan<'a>>,
/// Visible anchor points of the layer: recorded after it is applied, or (`Some(k)`, an
/// anchor with visible effects above it) with its content cut after `k` visible effects.
anchors: Vec<(LayerId, Option<usize>)>,
/// The node or one of its children records an anchor.
has_anchor: bool,
height_mask: HeightMask,
/// Geometry mask: whether the layer shows on each mesh submesh (None: everywhere).
parts: Option<Vec<bool>>,
}
/// Plans of the visible effects of a stack: mask effects (`channel` None) or the content
/// effects of one channel (paint effects then read that channel's pixels).
fn effect_plans<'a>(inp: &Inputs<'a>, effects: &'a [Effect], tile_x: u32, tile_y: u32, channel: Option<Channel>) -> Vec<EffectPlan<'a>> {
effects
.iter()
.filter(|effect| effect.visible)
.map(|effect| {
let (image, target) = match channel {
Some(channel) => (inp.pixels.layer(effect.id, channel), PaintTarget::Layer(effect.id)),
None => (inp.pixels.masks.get(&effect.id), PaintTarget::Mask(effect.id)),
};
let curvature_sizes = match &effect.kind {
EffectKind::Generator(Generator { detail: Some(detail), .. }) => CurvatureSizes::of(inp, &detail.blurred_sizes_in_use()),
_ => None,
};
EffectPlan {
id: effect.id,
kind: &effect.kind,
blend: effect.blend,
opacity: effect.opacity,
data: if effect.kind.painted() { tile_of(inp, image, tile_x, tile_y, channel) } else { None },
preview: previews(inp, target),
curvature_sizes,
filtered_mask: None,
}
})
.collect()
}
/// Whether the live stroke paints `target` in this composite (a stroke on a layer instanced in a
/// set of another size does not show there).
fn previews(inp: &Inputs, target: PaintTarget) -> bool {
inp.preview.is_some_and(|p| p.target == target && (p.alpha.width(), p.alpha.height()) == (inp.gbuf.width, inp.gbuf.height))
}
/// Tile (tx, ty) of painted pixels `img` (of `channel`, or a mask when None) at the size of the
/// set being composited: as stored, or resampled (bilinear, premultiplied) when the pixels
/// belong to a layer instanced from a set of another resolution.
fn tile_of<'a>(inp: &Inputs, img: Option<&'a TileImage>, tx: u32, ty: u32, channel: Option<Channel>) -> Option<Cow<'a, [u16]>> {
let img = img?;
let (w, h) = (inp.gbuf.width, inp.gbuf.height);
if (img.width(), img.height()) == (w, h) {
return img.tile(tx, ty).map(Cow::Borrowed);
}
// Empty texels of signed channels hold a signed zero.
let empty: Vec<u16> = match channel {
Some(c) if c.kind() == ChannelKind::Signed => [vec![to_u16_signed(0.0); c.components()], vec![0]].concat(),
_ => Vec::new(),
};
img.resampled_tile(w, h, tx, ty, &empty).map(Cow::Owned)
}
fn mask_plan<'a>(inp: &Inputs<'a>, id: LayerId, mask: &'a Mask, tx: u32, ty: u32, fields: Option<&'a Fields>) -> Option<MaskPlan<'a>> {
if !mask.enabled {
return None;
}
let background = if mask.background == MaskBackground::White { 1.0 } else { 0.0 };
let mut effects = effect_plans(inp, &mask.effects, tx, ty, None);
let filtered = fields.and_then(|fields| fields.get(&FieldKey::Mask(id)));
for effect in &mut effects {
effect.filtered_mask = filtered.and_then(|field| field.anchor_stages.iter().find(|(id, _)| *id == effect.id).map(|(_, field)| field));
}
let start = filtered.and_then(|field| neighbourhood(&mask.effects, inp.gbuf.width).map(|(index, _, _)| (index, field)));
Some(MaskPlan { background, effects, start })
}
fn plan<'a>(inp: &Inputs<'a>, list: &[LayerId], channels: &[Channel], tx: u32, ty: u32, depth: usize, fields: Option<&'a Fields>) -> Vec<Node<'a>> {
if depth > texturecraft_core::project::MAX_DEPTH {
return Vec::new();
}
list.iter().filter_map(|id| plan_node(inp, *id, channels, tx, ty, depth, fields, true)).collect()
}
/// The plan of layer `id` at `depth` (None where it draws nothing); a folder's children are
/// planned when `kids`.
#[allow(clippy::too_many_arguments)]
fn plan_node<'a>(
inp: &Inputs<'a>,
id: LayerId,
channels: &[Channel],
tx: u32,
ty: u32,
depth: usize,
fields: Option<&'a Fields>,
kids: bool,
) -> Option<Node<'a>> {
let own: &'a Layer = inp.project.layers.get(&id)?;
// Instances draw their source's content (a missing source draws nothing)
let layer: &'a Layer = inp.project.content_layer(id)?;
if !own.visible {
return None;
}
let paint = matches!(layer.kind, LayerKind::Paint);
let fx = !layer.is_group() && layer.content_effects.iter().any(|e| e.visible);
let fx_start = if fx { neighbourhood(&layer.content_effects, inp.gbuf.width).map(|n| n.0) } else { None };
let chans = channels
.iter()
.filter_map(|c| {
let b = layer.blend(*c)?;
if b.mode == BlendMode::Disable || b.opacity <= 0.0 {
return None;
}
let data = if paint { tile_of(inp, inp.pixels.layer(layer.id, *c), tx, ty, Some(*c)) } else { None };
let effects = if fx { effect_plans(inp, &layer.content_effects, tx, ty, Some(*c)) } else { Vec::new() };
let start = fx_start.zip(fields.and_then(|f| f.get(&FieldKey::Content(id, *c))));
Some(ChanPlan { ch: c.index(), kind: c.kind(), comps: c.components(), blend: b.mode, opacity: b.opacity.clamp(0.0, 1.0), data, effects, start })
})
.collect::<Vec<_>>();
let content = match &layer.kind {
LayerKind::Paint => Content::Paint { preview: previews(inp, PaintTarget::Layer(layer.id)) },
LayerKind::Fill(f) => Content::Fill(f),
LayerKind::Group { children, .. } => Content::Group(if kids { plan(inp, children, channels, tx, ty, depth + 1, fields) } else { Vec::new() }),
// `content_layer` already followed instance links
LayerKind::Instance { .. } => return None,
};
let mask = layer_mask(inp.project, id).and_then(|m| mask_plan(inp, id, m, tx, ty, fields));
// Anchors in the mask record even where the layer draws nothing
let mask_anchor = mask.as_ref().is_some_and(|m| m.effects.iter().any(|e| matches!(e.kind, EffectKind::Anchor)));
// An empty paint layer still matters if its mask records an anchor
if let Content::Paint { preview: false } = content
&& chans.iter().all(|c| c.data.is_none() && c.effects.is_empty())
&& !mask_anchor
{
return None;
}
if chans.is_empty() && !mask_anchor {
return None;
}
let anchors = if fx { anchor_cuts(&layer.content_effects) } else { Vec::new() };
let has_anchor = !anchors.is_empty() || mask_anchor || matches!(&content, Content::Group(nodes) if nodes.iter().any(|n| n.has_anchor));
// The geometry mask is the layer's own (an instance in another set has other parts)
let parts = own.geometry_mask.as_ref().map(|names| inp.mesh.submeshes.iter().map(|s| names.contains(&s.name)).collect());
Some(Node { id, content, chans, mask, anchors, has_anchor, height_mask: layer.height_mask, parts })
}
/// The visible anchor points of a content stack with where they cut it: after their index among
/// the visible effects, or None for anchors with only anchors above them (they record the
/// layer's full result).
fn anchor_cuts(effects: &[Effect]) -> Vec<(LayerId, Option<usize>)> {
let visible: Vec<&Effect> = effects.iter().filter(|e| e.visible).collect();
let last = visible.iter().rposition(|e| !matches!(e.kind, EffectKind::Anchor));
visible.iter().enumerate().filter(|(_, e)| matches!(e.kind, EffectKind::Anchor)).map(|(i, e)| (e.id, last.filter(|l| *l > i).map(|_| i))).collect()
}
/// One level of the path to the hot layer (see [`Level`]) planned for a tile.
struct LevelPlan<'a> {
below: Vec<Node<'a>>,
/// A folder planned without its children, or (last level) the hot layer.
at: Option<Node<'a>>,
above: Vec<Node<'a>>,
}
/// Plan the path to the hot layer for tile (tx, ty); the layers before the path are left out
/// on tiles the cache holds (`warm`).
fn plan_levels<'a>(inp: &Inputs<'a>, levels: &[Level], channels: &[Channel], tx: u32, ty: u32, fields: &'a Fields, warm: bool) -> Vec<LevelPlan<'a>> {
let last = levels.len().saturating_sub(1);
levels
.iter()
.enumerate()
.map(|(d, l)| LevelPlan {
below: if warm { Vec::new() } else { plan(inp, &l.below, channels, tx, ty, d, Some(fields)) },
at: plan_node(inp, l.at, channels, tx, ty, d, Some(fields), d == last),
above: plan(inp, &l.above, channels, tx, ty, d, Some(fields)),
})
.collect()
}
#[inline]
fn blend_chan(c: &ChanPlan, mode: BlendMode, a: [f32; 3], b: [f32; 3]) -> [f32; 3] {
if c.comps == 3 { blend3(mode, a, b) } else { [blend1(mode, a[0], b[0]); 3] }
}
/// Lay value `p` with weight `a` over a straight value and coverage (premultiplied "over").
fn over(c: &ChanPlan, mode: BlendMode, v: [f32; 3], cov: f32, p: [f32; 3], a: f32) -> ([f32; 3], f32) {
if a <= 0.0 {
return (v, cov);
}
let b = if cov > 0.0 { blend_chan(c, mode, v, p) } else { p };
let nc = a + cov * (1.0 - a);
(mix3(v, b, a / nc.max(1e-5)), nc)
}
/// The plain UV projection a decal's frame coordinates are sampled through.
const DECAL_UV: Projection = Projection::Uv { scale: [1.0, 1.0], rotation: 0.0, offset: [0.0, 0.0] };
/// Per-texel context.
struct Texel<'a, 'b> {
inp: &'b Inputs<'a>,
x: u32,
y: u32,
/// Offset of this texel inside a tile (in texels).
o: usize,
res: u32,
coords: Option<Coords>,
stroke: f32,
/// `eval` stops when it reaches this layer.
stop: Option<LayerId>,
/// Stack values recorded by the anchor points evaluated so far; true marks a mask anchor (gray, not channel values).
anchors: Vec<(LayerId, Acc, bool)>,
/// Where `eval` takes layer masks and content from.
tape: Tape<'b>,
}
/// What a layer contributes (its mask, its content value and coverage per channel): evaluated
/// (`Off`), evaluated and recorded, or replayed from a recording.
enum Tape<'t> {
Off,
Record(Vec<f32>),
Replay(&'t [f32], usize),
}
impl<'t> Tape<'t> {
fn next(&mut self) -> f32 {
self.take(1).first().copied().unwrap_or(0.0)
}
/// The next `n` replayed values (empty when not replaying).
fn take(&mut self, n: usize) -> &'t [f32] {
match self {
Tape::Replay(t, i) => {
let t: &'t [f32] = t;
let end = i.saturating_add(n);
let s = t.get(*i..end).unwrap_or_default();
*i = end;
s
}
_ => &[],
}
}
}
impl<'a, 'b> Texel<'a, 'b> {
fn new(inp: &'b Inputs<'a>, x: u32, y: u32, o: usize, stroke: f32) -> Self {
Texel { inp, x, y, o, res: inp.gbuf.width, coords: None, stroke, stop: None, anchors: Vec::new(), tape: Tape::Off }
}
/// Run `f` with `tape` as this texel's tape.
fn taped<R>(&mut self, tape: &mut Tape<'b>, f: impl FnOnce(&mut Self) -> R) -> R {
std::mem::swap(&mut self.tape, tape);
let r = f(self);
std::mem::swap(&mut self.tape, tape);
r
}
/// [`Texel::node_mask`] through the tape.
fn tape_mask(&mut self, n: &Node) -> f32 {
if let Tape::Replay(..) = self.tape {
return self.tape.next();
}
let m = self.node_mask(n);
if let Tape::Record(t) = &mut self.tape {
t.push(m);
}
m
}
/// [`Texel::content`] through the tape: the coverage (0 where empty), then the value.
fn tape_content(&mut self, content: &Content, c: &ChanPlan) -> Option<([f32; 3], f32)> {
if let Tape::Replay(..) = self.tape {
let cov = self.tape.next();
// Recorded as 0 where empty.
if cov <= 0.0 {
return None;
}
let v = if c.comps == 3 { [self.tape.next(), self.tape.next(), self.tape.next()] } else { [self.tape.next(); 3] };
return Some((v, cov));
}
let r = self.content(content, c);
if let Tape::Record(t) = &mut self.tape {
match r {
Some((v, cov)) => {
t.push(cov);
let n = if c.comps == 3 { 3 } else { 1 };
t.extend_from_slice(&v[..n]);
}
None => t.push(0.0),
}
}
r
}
fn coords(&mut self) -> Coords {
if let Some(c) = self.coords {
return c;
}
let g = self.inp.gbuf;
let i = (self.y * g.width + self.x) as usize;
let (lo, hi) = self.inp.bounds;
let center = (lo + hi) * 0.5;
let r = ((hi - lo).length() * 0.5).max(1e-4);
let mut c = match g.surface(self.inp.mesh, i) {
Some(s) => Coords { uv: s.uv, pos: (s.pos - center) / r, nrm: s.nrm },
None => Coords { uv: Vec2::new((self.x as f32 + 0.5) / g.width as f32, (self.y as f32 + 0.5) / g.height as f32), pos: Vec3::ZERO, nrm: Vec3::Y },
};
// UV-tiled sets: projections see the mesh's own UVs (patterns repeat per tile).
if let Ok(set) = self.inp.project.texture_set(self.inp.ts)
&& let Some(grid) = set.tile_grid()
{
c.uv = Vec2::from(set.from_atlas(&grid, c.uv.to_array()));
}
self.coords = Some(c);
c
}
/// World position of this texel (None when uncovered).
fn world(&self) -> Option<Vec3> {
let i = (self.y * self.inp.gbuf.width + self.x) as usize;
self.inp.gbuf.surface(self.inp.mesh, i).map(|s| s.pos)
}
fn baked(&self, m: BakedMap) -> Option<f32> {
self.baked_color(m).map(|value| value[0])
}
fn baked_color(&self, map: BakedMap) -> Option<[f32; 3]> {
self.inp.baked.sample_working(map, self.x, self.y, (self.res, self.inp.gbuf.height), &self.inp.block_scales)
}
/// Where projection `proj` samples this texel: the texel's coordinates, or for a decal its
/// position in the decal's frame (then sampled as UVs) and the decal's coverage.
fn projected<'p>(&mut self, proj: &'p Projection) -> (Coords, &'p Projection, f32) {
let c = self.coords();
let (lo, hi) = self.inp.bounds;
let center = (lo + hi) * 0.5;
match proj {
Projection::Decal(d) => match self.world().and_then(|p| decal_uv_symmetric(d, p, c.nrm, center)) {
Some((uv, w)) => (Coords { uv, ..c }, &DECAL_UV, w),
None => (c, &DECAL_UV, 0.0),
},
_ => (c, proj, 1.0),
}
}
/// How much a fill projected by `proj` covers this texel: 1, or for a decal its frame
/// coverage times the alpha of its first image source.
fn cover<'s>(&mut self, mut sources: impl Iterator<Item = &'s Source>, proj: &Projection) -> f32 {
if !matches!(proj, Projection::Decal(_)) {
return 1.0;
}
let (c, _, w) = self.projected(proj);
let image = sources.find_map(|s| match s {
Source::Image { name, .. } => self.inp.images.get(name),
_ => None,
});
w * image.map_or(1.0, |img| img.sample(c.uv.x, c.uv.y)[3].clamp(0.0, 1.0))
}
/// The stack value anchor point `anchor` recorded for `channel` (the channel default for an
/// anchor not evaluated yet)
fn anchored(&self, anchor: LayerId, channel: Channel) -> [f32; 3] {
let values = self.anchors.iter().rev().find(|(id, ..)| *id == anchor).and_then(|(_, values, _)| values.get(channel.index()).copied());
values.unwrap_or_else(|| channel.default_value())
}
/// Whether anchor point `anchor` sits in a mask, where every channel holds the mask's gray.
fn is_mask_anchor(&self, anchor: LayerId) -> bool {
self.anchors.iter().rev().find(|(id, ..)| *id == anchor).is_some_and(|(_, _, mask)| *mask)
}
/// The value `source` gives this texel through `projection`, read as a channel of `kind`
fn source(&mut self, source: &Source, projection: &Projection, kind: ChannelKind) -> [f32; 3] {
match source {
Source::Uniform(value) => *value,
Source::Anchor { anchor, channel, ramp } if kind == ChannelKind::Color && !ramp.is_empty() => {
let value = self.anchored(*anchor, *channel);
// Signed values (height) span -1..1; a mask anchor's gray already spans 0..1 in every channel
let signed = channel.kind() == ChannelKind::Signed && !self.is_mask_anchor(*anchor);
let lightness = if signed { lum(value) * 0.5 + 0.5 } else { lum(value) };
texturecraft_core::gradient(ramp, lightness).unwrap_or_default()
}
Source::Procedural { pattern, low, high, ramp } => {
let (coords, projection, _) = self.projected(projection);
let pixels = if pattern.resolution.can_reduce() {
let uv_tile = self.inp.tile_res_at(self.x, self.y);
let texture_set = self.inp.project.texture_set(self.inp.ts).map_or(uv_tile, |set| set.resolution);
pattern_pixels(pattern, uv_tile, texture_set)
} else {
None
};
let amount = procedural_in(pattern, projection, &coords, &PatternContext { pixels, images: Some(self.inp.images) });
if kind == ChannelKind::Color && !ramp.is_empty() {
texturecraft_core::gradient(ramp, amount).unwrap_or_default()
} else {
mix3(*low, *high, amount)
}
}
Source::Image { name, normal_format } => {
let Some(image) = self.inp.images.get(name) else { return [0.5; 3] };
let (coords, projection, _) = self.projected(projection);
let mut sum = [0.0f32; 4];
for (uv, weight) in image_samples(projection, &coords).into_iter().filter(|(_, weight)| *weight > 0.0) {
for (total, value) in sum.iter_mut().zip(image.sample(uv.x, uv.y)) {
*total += value * weight;
}
}
let rgb = [sum[0], sum[1], sum[2]];
match kind {
ChannelKind::Color if image.srgb => rgb.map(texturecraft_texel::srgb_to_linear),
// Normal channels are OpenGL (+Y up the image): a DirectX image's green flips
ChannelKind::NormalMap if *normal_format == NormalFormat::DirectX => [rgb[0], 1.0 - rgb[1], rgb[2]],
ChannelKind::Color | ChannelKind::NormalMap => rgb,
// A one-value channel or mask reads the image's gray, so a color image works as a mask
ChannelKind::Scalar => [lum(rgb); 3],
ChannelKind::Signed => [lum(rgb) * 2.0 - 1.0; 3],
}
}
Source::Anchor { anchor, channel, .. } => self.anchor_value(*anchor, *channel, kind),
}
}
/// The value anchor point `anchor` recorded for `channel`, read as `kind` (colors read as gray
/// where a scalar is needed). An anchor not evaluated yet (above this layer, hidden) reads the
/// channel default.
fn anchor_value(&self, anchor: LayerId, channel: Channel, kind: ChannelKind) -> [f32; 3] {
let value = self.anchored(anchor, channel);
let needs_gray = matches!(channel.kind(), ChannelKind::Color | ChannelKind::NormalMap) && matches!(kind, ChannelKind::Scalar | ChannelKind::Signed);
if needs_gray { [lum(value); 3] } else { value }
}
fn generator_ramp(&mut self, generator: &Generator, curvature_sizes: Option<&CurvatureSizes>) -> f32 {
let coords = self.coords();
let micro = generator.micro.map_or(0.0, |micro| self.micro_detail(generator.kind, micro));
let signal = match (generator.kind, &generator.detail) {
(GeneratorKind::Curvature | GeneratorKind::EdgeWear, Some(detail)) => {
// Detail sizes are blurred copies of the mesh map, so a replaced curvature input reads at its own size only
let sizes = if generator.inputs.contains_key(&BakedMap::Curvature) { None } else { curvature_sizes };
let curvature = self.generator_input(generator, BakedMap::Curvature);
self.curvature_detail(detail, sizes, curvature, micro)
}
(GeneratorKind::EdgeWear, None) => (self.generator_input(generator, BakedMap::Curvature).unwrap_or(0.5) - 0.5) * 2.0,
(GeneratorKind::Curvature, None) => self.generator_input(generator, BakedMap::Curvature).unwrap_or(0.5),
(GeneratorKind::Dirt, _) => 1.0 - self.generator_input(generator, BakedMap::AmbientOcclusion).unwrap_or(1.0),
(GeneratorKind::AmbientOcclusion, _) => self.generator_input(generator, BakedMap::AmbientOcclusion).unwrap_or(1.0),
(GeneratorKind::ThinAreas, _) => 1.0 - self.generator_input(generator, BakedMap::Thickness).unwrap_or(1.0),
(GeneratorKind::Position, _) => coords.pos.dot(Vec3::from(generator.direction).try_normalize().unwrap_or(Vec3::Y)) * 0.5 + 0.5,
(GeneratorKind::Direction, _) => coords.nrm.dot(Vec3::from(generator.direction).try_normalize().unwrap_or(Vec3::Y)) * 0.5 + 0.5,
};
let signal =
if matches!(generator.kind, GeneratorKind::Curvature | GeneratorKind::EdgeWear) && generator.detail.is_some() { signal } else { signal + micro };
let signal = if generator.noise_amount > 0.0 {
let noise = world_noise(coords.pos, generator.noise_scale, generator.seed);
if let (GeneratorKind::Curvature | GeneratorKind::EdgeWear, Some(detail)) = (generator.kind, &generator.detail) {
// Break up curvature without inventing edges or cavities on a flat surface
let neutral = if detail.mode == CurvatureMode::Raw { 0.5 } else { 0.0 };
neutral + (signal - neutral) * (1.0 - noise * generator.noise_amount).max(0.0)
} else {
signal + (noise - 0.5) * generator.noise_amount
}
} else {
signal
};
// A smooth step from black to white over 2 × softness around 1 − level
let threshold = 1.0 - generator.level.clamp(0.0, 1.0);
let softness = generator.softness.max(Generator::MIN_SOFTNESS);
let ramp = ((signal - (threshold - softness)) / (2.0 * softness)).clamp(0.0, 1.0);
ramp * ramp * (3.0 - 2.0 * ramp)
}
/// How a generator's micro detail moves its signal at this texel: the anchor's height (0 where
/// the anchor is not evaluated yet) as an edge where raised and a cavity where recessed.
fn micro_detail(&self, kind: GeneratorKind, micro: MicroDetail) -> f32 {
let height = self.anchor_value(micro.anchor, Channel::Height, ChannelKind::Signed)[0];
let amount = if micro.amount.is_finite() { micro.amount.clamp(0.0, 1.0) } else { 0.0 };
let response = height.clamp(-1.0, 1.0) * amount;
match kind {
GeneratorKind::Curvature | GeneratorKind::EdgeWear => response,
// Dirt gathers in dents; dents are occluded
GeneratorKind::Dirt => -response,
GeneratorKind::AmbientOcclusion => response,
GeneratorKind::ThinAreas | GeneratorKind::Position | GeneratorKind::Direction => 0.0,
}
}
/// The generator's value at this texel: its ramp finished by balance, contrast, invert and offset (its blur and resolution need neighbours: see [`generator_region`]).
fn generator(&mut self, generator: &Generator, curvature_sizes: Option<&CurvatureSizes>) -> f32 {
let ramp = self.generator_ramp(generator, curvature_sizes);
finish_generator(generator, ramp)
}
/// Generator input `map` at this texel: what replaces the mesh map in the generator's inputs, else the mesh map (None when not baked).
fn generator_input(&mut self, generator: &Generator, map: BakedMap) -> Option<f32> {
match generator.inputs.get(&map) {
Some(source) => Some(self.source(source, &Projection::default(), ChannelKind::Scalar)[0]),
None => self.baked(map),
}
}
/// The curvature of `detail`'s mode at this texel from `curvature` (None: nothing to read), with its blurred detail sizes when given.
fn curvature_detail(&self, detail: &CurvatureDetail, curvature_sizes: Option<&CurvatureSizes>, curvature: Option<f32>, micro: f32) -> f32 {
let combine = |edges: f32, cavities: f32| {
let edges = 1.0 - (1.0 - edges) * (1.0 - micro.max(0.0));
let cavities = 1.0 - (1.0 - cavities) * (1.0 + micro.min(0.0));
match detail.mode {
CurvatureMode::Edges => edges,
CurvatureMode::Cavities => cavities,
CurvatureMode::Both => 1.0 - (1.0 - edges) * (1.0 - cavities),
CurvatureMode::Raw => 0.5 + 0.5 * (edges - cavities),
}
};
// Without baked curvature, only painted micro height supplies edges or cavities
let Some(curvature) = curvature else { return combine(0.0, 0.0) };
let working_size = (self.res, self.inp.gbuf.height);
let texel_uv = [(self.x as f32 + 0.5) / working_size.0.max(1) as f32, (self.y as f32 + 0.5) / working_size.1.max(1) as f32];
let Some(baked_uv) = self.inp.block_scales.bake_uv(texel_uv, working_size) else { return combine(0.0, 0.0) };
let baked_size = (self.inp.baked.resolution, self.inp.baked.height(BakedMap::Curvature));
let (baked_x, baked_y) = ((baked_uv[0] * baked_size.0 as f32) as u32, (baked_uv[1] * baked_size.1 as f32) as u32);
let blurred = |index: usize| {
curvature_sizes.and_then(|sizes| sizes.levels.get(index)).and_then(Option::as_deref).map_or(0.0, |level| level.sample(baked_x, baked_y))
};
let (mut edges, mut cavities) = (0.0f32, 0.0f32);
for (index, (size, weight)) in CurvatureDetail::SIZES.iter().zip(detail.weights).enumerate() {
let deviation = if index == 0 { curvature - 0.5 } else { blurred(index - 1) };
let response = deviation * if *size == 0.0 { MAP_GAIN } else { GAIN_PER_DETAIL_TEXEL * size };
let weight = weight.clamp(0.0, 1.0);
edges = 1.0 - (1.0 - edges) * (1.0 - weight * response.clamp(0.0, 1.0));
cavities = 1.0 - (1.0 - cavities) * (1.0 - weight * (-response).clamp(0.0, 1.0));
}
combine(edges, cavities)
}
fn mask(&mut self, plan: &MaskPlan) -> f32 {
let mut value = plan.background;
let mut skip = 0;
if let Some((filtered_index, field)) = plan.start
&& let Some(filtered) = field.get(self.x, self.y).and_then(|texel| texel.first().copied())
{
value = filtered;
skip = filtered_index + 1;
}
// Replay the prefix to record anchors skipped by the precomputed filter
if let Some(last) = plan.effects.iter().take(skip).rposition(|e| matches!(e.kind, EffectKind::Anchor)) {
self.mask_effects(plan, plan.background, 0, last + 1);
}
self.mask_effects(plan, value, skip, plan.effects.len())
}
/// Mask effects `from..to` of `plan` over `value`, recording the anchors among them.
fn mask_effects(&mut self, plan: &MaskPlan, mut value: f32, from: usize, to: usize) -> f32 {
// Avoid amplifying rounding error when unpremultiplying faint paint
const MIN_PAINT_COVERAGE: f32 = 1e-5;
for effect in plan.effects.iter().take(to).skip(from) {
if let Some(filtered) = effect.filtered_mask.and_then(|field| field.get(self.x, self.y)).and_then(|texel| texel.first()) {
value = *filtered;
continue;
}
let opacity = effect.opacity.clamp(0.0, 1.0);
match effect.kind {
EffectKind::Paint | EffectKind::Path(_) => {
let (mut painted, mut coverage) = match effect.data.as_deref() {
Some(data) => (from_u16(data.get(self.o * 2).copied().unwrap_or(0)), from_u16(data.get(self.o * 2 + 1).copied().unwrap_or(0))),
None => (0.0, 0.0),
};
if effect.preview
&& let Some(preview) = self.inp.preview
{
let stroke = (self.stroke * preview.opacity).clamp(0.0, 1.0);
if preview.erase {
painted *= 1.0 - stroke;
coverage *= 1.0 - stroke;
} else {
// Clone and smudge show the values they carry instead of the mask gray
let deposited = preview.carried_mask.as_ref().map_or(preview.mask_value, |carried| from_u16(carried.get(self.x, self.y)[0]));
painted = deposited * stroke + painted * (1.0 - stroke);
coverage = stroke + coverage * (1.0 - stroke);
}
}
if coverage > 0.0 {
let layer_value = painted / coverage.max(MIN_PAINT_COVERAGE);
value += (blend1(effect.blend, value, layer_value) - value) * coverage * opacity;
}
}
EffectKind::Fill { source, projection } => {
let fill = self.source(source, projection, ChannelKind::Scalar)[0];
value += (blend1(effect.blend, value, fill) - value) * opacity * self.cover(std::iter::once(source), projection);
}
EffectKind::Generator(generator) => {
let generated = self.generator(generator, effect.curvature_sizes.as_deref());
value += (blend1(effect.blend, value, generated) - value) * opacity;
}
EffectKind::Levels(levels) => value += (levels.apply(value) - value) * opacity,
EffectKind::Filter(filter) => {
// A mask is gray (HSL only changes its lightness); neighbourhood filters come precomputed through `MaskPlan::start`
let filtered = filter.point(ChannelKind::Scalar, [value; 3]).map_or(value, |gray| gray[0]);
value += (filtered - value) * opacity;
}
EffectKind::ColorSelection { colors, tolerance } => {
let id = self.baked_color(BakedMap::Id);
let within = |picked: &[f32; 3], color: [f32; 3]| (0..3).all(|component| (picked[component] - color[component]).abs() <= *tolerance);
let selected = if id.is_some_and(|color| colors.iter().any(|picked| within(picked, color))) { 1.0 } else { 0.0 };
value += (blend1(effect.blend, value, selected) - value) * opacity;
}
EffectKind::Compare { op, value: compared, tolerance } => {
let pass = match op {
CompareOp::LesserThan => value < *compared,
CompareOp::GreaterThan => value > *compared,
CompareOp::WithinTolerance => (value - compared).abs() <= *tolerance,
};
let result = if pass { 1.0 } else { 0.0 };
value += (result - value) * opacity;
}
// Every channel of a mask anchor reads the mask's gray
EffectKind::Anchor => self.anchors.push((effect.id, [[value.clamp(0.0, 1.0); 3]; NCH], true)),
// Content-only effects
EffectKind::Material(_) => {}
}
}
value.clamp(0.0, 1.0)
}
/// Composite `nodes` over `acc`, recording anchors. Returns true when it reached the `stop`
/// layer (`acc` then holds the stack below it).
fn eval(&mut self, nodes: &[Node], acc: &mut Acc) -> bool {
for n in nodes {
if self.stop == Some(n.id) {
return true;
}
let m = self.tape_mask(n);
match &n.content {
// Masked-out groups still run when they record anchors or hold the stop layer
Content::Group(children) if m > 0.0 || n.has_anchor || self.stop.is_some() => {
let mut inner = *acc;
if self.eval(children, &mut inner) {
return true;
}
if m > 0.0 {
mix_group(acc, &inner, &n.chans, m);
}
}
Content::Fill(_) | Content::Paint { .. } if m > 0.0 => {
let before = if n.anchors.iter().any(|a| a.1.is_some()) { Some(*acc) } else { None };
for c in &n.chans {
if let Some((v, cov)) = self.tape_content(&n.content, c) {
apply(acc, c, v, cov, m);
}
}
// Anchors inside the content stack read the stack cut at that point
for (a, cut) in &n.anchors {
let rec = match (cut, before) {
(Some(k), Some(mut b)) => {
for c in &n.chans {
if let Some((v, cov)) = self.content_to(&n.content, c, *k) {
apply(&mut b, c, v, cov, m);
}
}
b
}
_ => *acc,
};
self.anchors.push((*a, rec, false));
}
continue;
}
_ => {}
}
for (a, _) in &n.anchors {
self.anchors.push((*a, *acc, false));
}
}
false
}
/// [`Texel::eval`] of the whole stack over `acc`, split along the path to the hot layer
/// (`levels`, top level first). Cold (`warm` false) it evaluates everything, leaving in
/// `accs` the stack before the path layer of each level and recording on `tape` the masks
/// of the folders on the path and what the layers after the path contribute. Warm (`accs`
/// loaded from the cache, `tape` replaying) only the hot layer is evaluated and the blends
/// after it are replayed. The order of evaluation differs from `eval` only in masks, which
/// read no stack values (given no anchor readers, see `BelowCache::prepare`), so the result
/// is identical.
fn eval_split(&mut self, mut acc: Acc, levels: &[LevelPlan], accs: &mut [Acc], masks: &mut [f32], warm: bool, tape: &mut Tape<'b>) -> Acc {
let last = levels.len().saturating_sub(1);
// Down the path: the deepest level the stack reaches (a folder masked out or not drawn
// here stops it).
let mut reach = last;
for (d, lv) in levels.iter().enumerate() {
if !warm {
self.eval(&lv.below, &mut acc);
if let Some(slot) = accs.get_mut(d) {
*slot = acc;
}
}
if d == last {
break;
}
let m = match &lv.at {
Some(g) => self.taped(tape, |t| t.tape_mask(g)),
None => 0.0,
};
if let Some(slot) = masks.get_mut(d) {
*slot = m;
}
if m > 0.0 {
continue;
}
reach = d;
break;
}
let mut acc = accs.get(reach).copied().unwrap_or(acc);
if reach == last
&& let Some(hot) = levels.get(last).and_then(|l| l.at.as_ref())
{
self.eval(std::slice::from_ref(hot), &mut acc);
}
// Back up: the layers after the path, then each folder's mix over the stack outside it.
for d in (0..=reach).rev() {
if let Some(lv) = levels.get(d) {
self.taped(tape, |t| t.eval(&lv.above, &mut acc));
}
if let Some(o) = d.checked_sub(1)
&& let (Some(outer), Some(g), Some(m)) = (accs.get(o), levels.get(o).and_then(|l| l.at.as_ref()), masks.get(o))
{
let inner = acc;
acc = *outer;
mix_group(&mut acc, &inner, &g.chans, *m);
}
}
acc
}
/// The mask of node `n` at this texel, combined with the layer's height when it masks with
/// height.
fn node_mask(&mut self, n: &Node) -> f32 {
if n.parts.as_ref().is_some_and(|p| !self.in_parts(p)) {
return 0.0;
}
let m = match &n.mask {
Some(mp) => self.mask(mp),
None => 1.0,
};
if !n.height_mask.enabled || m <= 0.0 || m >= 1.0 {
return m;
}
let height = Channel::Height.index();
let h = n.chans.iter().find(|c| c.ch == height).and_then(|c| self.content(&n.content, c)).map_or(0.0, |(v, _)| v[0]);
n.height_mask.apply(m, h)
}
/// Whether this texel's triangle lies in a submesh `allowed` marks (uncovered texels and
/// meshes without submeshes count as inside).
fn in_parts(&self, allowed: &[bool]) -> bool {
let g = self.inp.gbuf;
let tri = g.tri.get((self.y * g.width + self.x) as usize).copied().unwrap_or(NO_TRI);
if tri == NO_TRI {
return true;
}
let first = tri.saturating_mul(3);
let subs = &self.inp.mesh.submeshes;
let holds = |k: usize| subs.get(k).is_some_and(|s| s.start <= first && first < s.start.saturating_add(s.count));
// Submeshes are in index order; anything else is searched.
let k = subs.partition_point(|s| s.start <= first).checked_sub(1).filter(|k| holds(*k)).or_else(|| (0..subs.len()).find(|k| holds(*k)));
k.and_then(|k| allowed.get(k).copied()).unwrap_or(true)
}
/// Record the anchors of the stack below layer `id` (`full` is the planned stack), to
/// evaluate that layer on its own.
fn anchors_below(&mut self, full: &[Node], id: LayerId) {
self.anchors.clear();
self.stop = Some(id);
let mut acc = Channel::ALL.map(Channel::default_value);
self.eval(full, &mut acc);
self.stop = None;
}
/// Straight value and coverage of one channel of a paint or fill layer at this texel
/// (content effects and live stroke preview included). None where the layer is empty.
fn content(&mut self, content: &Content, c: &ChanPlan) -> Option<([f32; 3], f32)> {
self.content_to(content, c, usize::MAX)
}
/// [`Texel::content`] with only the first `end` visible content effects.
fn content_to(&mut self, content: &Content, c: &ChanPlan, end: usize) -> Option<([f32; 3], f32)> {
let start = c.start.filter(|(k, _)| *k < end);
let (mut v, mut cov, skip) = match start.and_then(|(k, f)| f.get(self.x, self.y).map(|d| (k, d))) {
Some((k, d)) => {
let px = |i: usize| d.get(i).copied().unwrap_or(0.0);
([px(0), px(1), px(2)], px(3), k + 1)
}
None => {
let (v, cov) = match content {
Content::Fill(f) => {
let ch = Channel::ALL.get(c.ch).copied()?;
// A channel without a source fills with its default (no clone per texel).
let v = match f.sources.get(&ch) {
Some(s) => self.source(s, &f.projection, ch.kind()),
None => ch.default_value(),
};
(v, self.cover(f.sources.values(), &f.projection))
}
Content::Paint { preview } => self.painted(c.data.as_deref(), c, *preview),
Content::Group(_) => return None,
};
(v, cov, 0)
}
};
for e in c.effects.iter().take(end).skip(skip) {
(v, cov) = self.content_effect(e, c, v, cov);
}
(cov > 0.0).then_some((v, cov.min(1.0)))
}
/// Straight value and coverage of painted data of one channel (premultiplied values plus
/// coverage per texel), with the live stroke when `preview`.
fn painted(&mut self, data: Option<&[u16]>, c: &ChanPlan, preview: bool) -> ([f32; 3], f32) {
let pv = if preview { self.inp.preview } else { None };
let mut sa = pv.map(|p| (self.stroke * p.opacity).clamp(0.0, 1.0)).unwrap_or(0.0);
// Projection: the stencil's alpha shapes the stroke and its color is the base color.
let stencil = match pv.and_then(|p| p.stencil.as_ref()) {
Some(st) if sa > 0.0 => {
let s = self.world().and_then(|w| st.sample_world(w));
sa *= s.map(|(_, a)| a).unwrap_or(0.0);
s.map(|(c, _)| c)
}
_ => None,
};
let mut val = [0.0f32; 3];
let mut cov = 0.0f32;
if let Some(d) = data {
let base = self.o * (c.comps + 1);
for (k, slot) in val.iter_mut().take(c.comps).enumerate() {
*slot = decode(c.kind, d.get(base + k).copied().unwrap_or(0));
}
cov = from_u16(d.get(base + c.comps).copied().unwrap_or(0));
}
if let Some(p) = pv
&& sa > 0.0
{
if p.erase {
val = val.map(|v| v * (1.0 - sa));
cov *= 1.0 - sa;
} else if let Some(ch) = Channel::ALL.get(c.ch)
&& let Some(pval) = p.values.get(ch)
{
let pval = match stencil {
Some(col) if *ch == Channel::BaseColor => col,
_ => match p.carried.get(ch) {
Some(img) => {
let raw = img.get(self.x, self.y).map(|v| decode(c.kind, v));
[raw[0], raw[1], raw[2]]
}
None => *pval,
},
};
for k in 0..c.comps {
val[k] = pval[k] * sa + val[k] * (1.0 - sa);
}
cov = sa + cov * (1.0 - sa);
}
}
if cov <= 0.0 {
return ([0.0; 3], 0.0);
}
let inv = 1.0 / cov.max(1e-5);
let v = if c.comps == 3 { val.map(|x| x * inv) } else { [val[0] * inv; 3] };
(v, cov.min(1.0))
}
/// Apply one content effect to a channel's straight value and coverage.
fn content_effect(&mut self, e: &EffectPlan, c: &ChanPlan, v: [f32; 3], cov: f32) -> ([f32; 3], f32) {
let o = e.opacity.clamp(0.0, 1.0);
match e.kind {
EffectKind::Paint | EffectKind::Path(_) => {
let (p, pc) = self.painted(e.data.as_deref(), c, e.preview);
over(c, e.blend, v, cov, p, pc * o)
}
EffectKind::Material(f) => match Channel::ALL.get(c.ch).and_then(|ch| f.sources.get(ch).map(|s| (*ch, s))) {
Some((ch, s)) => {
let p = self.source(s, &f.projection, ch.kind());
let w = o * self.cover(f.sources.values(), &f.projection);
over(c, e.blend, v, cov, p, w)
}
None => (v, cov),
},
EffectKind::Levels(l) => (mix3(v, per_unit(c.kind, v, |x| l.apply(x)), o), cov),
// Baked lighting reads the texel's normal and occlusion, and lights the base color only.
EffectKind::Filter(f @ Filter::BakedLighting { .. }) => match Channel::ALL.get(c.ch) {
Some(Channel::BaseColor) => {
let nrm = self.coords().nrm.to_array();
let k = f.baked_light(nrm, self.baked(BakedMap::AmbientOcclusion).unwrap_or(1.0)).unwrap_or(1.0);
(mix3(v, v.map(|x| (x * k).clamp(0.0, 1.0)), o), cov)
}
_ => (v, cov),
},
// Neighbourhood filters come precomputed through `ChanPlan::start`.
EffectKind::Filter(f) => (f.point(c.kind, v).map_or(v, |out| mix3(v, out, o)), cov),
// Anchors are recorded by `eval`; mask-only effects leave content as it is.
EffectKind::Anchor | EffectKind::Fill { .. } | EffectKind::Generator(_) | EffectKind::ColorSelection { .. } | EffectKind::Compare { .. } => {
(v, cov)
}
}
}
}
/// Mix a folder's inner stack into the stack outside it by its opacity and mask `m`.
fn mix_group(acc: &mut Acc, inner: &Acc, chans: &[ChanPlan], m: f32) {
for c in chans {
if let (Some(a), Some(b)) = (acc.get(c.ch).copied(), inner.get(c.ch).copied())
&& let Some(slot) = acc.get_mut(c.ch)
{
*slot = mix3(a, b, c.opacity * m);
}
}
}
#[inline]
fn apply(acc: &mut Acc, c: &ChanPlan, v: [f32; 3], cov: f32, mask: f32) {
let Some(a) = acc.get(c.ch).copied() else { return };
let w = if c.blend == BlendMode::Replace { c.opacity * mask } else { cov * c.opacity * mask };
let blended = blend_chan(c, c.blend, a, v);
if let Some(slot) = acc.get_mut(c.ch) {
*slot = mix3(a, blended, w);
}
}
/// Composite `tiles` of texture set `inp.ts` into `out` (other tiles are left as they are).
pub fn composite_tiles(inp: &Inputs, out: &mut Composite, tiles: &[(u32, u32)]) {
composite_tiles_cached(inp, out, tiles, None);
}
/// Tiles per side of the blocks a composite works through (bounds neighbourhood-filter memory).
pub const BLOCK: u32 = 16;
/// [`composite_tiles`], serving everything but the hot layer from `below` where it can (and
/// filling it). Results are identical to [`composite_tiles`].
pub fn composite_tiles_cached(inp: &Inputs, out: &mut Composite, tiles: &[(u32, u32)], mut below: Option<&mut BelowCache>) {
let Ok(set) = inp.project.texture_set(inp.ts) else { return };
if (inp.gbuf.width, inp.gbuf.height) != (out.resolution, out.height) {
return;
}
let split = below.as_deref_mut().and_then(|b| b.prepare(inp));
// Avoid caching tiles that would immediately evict each other
let levels = split.as_ref().map_or(1, Vec::len);
let estimate = TILE_AREA * levels * set.channel_list().iter().map(|c| c.components()).sum::<usize>() * std::mem::size_of::<f32>();
let tile_bytes = below.as_deref().and_then(BelowCache::tile_bytes).unwrap_or(estimate).max(1);
let fits = below.as_deref().is_some_and(|b| tiles.len().max(b.pass) <= b.limit() / tile_bytes);
let mut blocks: BTreeMap<(u32, u32), Vec<(u32, u32)>> = BTreeMap::new();
for t in tiles {
blocks.entry((t.1 / BLOCK, t.0 / BLOCK)).or_default().push(*t);
}
let channels = set.channel_list();
let hot = split.as_deref().and_then(<[Level]>::last);
// A stroke preview is absent from StackKey, so it disables field retention
let retain_fields = below.is_some() && inp.preview.is_none() && has_neighbourhood(inp, &set.stack);
let key = if retain_fields { StackKey::new(inp.project, inp.pixels, inp.baked, inp.images, inp.ts, &set.stack).map(Arc::new) } else { None };
let size = (inp.gbuf.width, inp.gbuf.height);
// Release fields when a stroke or stack change disables retention
if key.is_none()
&& let Some(cache) = below.as_deref_mut()
{
cache.held = None;
}
for (block_index, block) in &blocks {
let uncached = |tile: &(u32, u32)| below.as_deref().zip(split.as_deref()).is_none_or(|(cache, _)| cache.tile(*tile).is_none());
let fresh: Vec<(u32, u32)> = block.iter().copied().filter(uncached).collect();
let held = below.as_deref().and_then(|cache| cache.held.as_ref()).filter(|held| {
key.as_ref().is_some_and(|key| **key == *held.key)
&& held.size == size
&& fresh.iter().all(|tile| held.stack_tiles.contains(tile))
&& block.iter().all(|tile| held.hot_tiles.contains(tile))
});
let ahead: Vec<(u32, u32)> = match (&key, below.as_deref()) {
(Some(_), Some(cache)) if held.is_none() => {
cache.ahead.iter().copied().filter(|tile| (tile.1 / BLOCK, tile.0 / BLOCK) == *block_index && !block.contains(tile)).collect()
}
_ => Vec::new(),
};
let fields: Arc<Fields> = match (held, &key) {
(Some(held), _) => held.fields.clone(),
(None, Some(key)) if !ahead.is_empty() => {
// Filter the current and following tiles as one run
let planned_tiles: Vec<(u32, u32)> = block.iter().chain(&ahead).copied().collect();
let uncached_planned_tiles: Vec<(u32, u32)> = planned_tiles.iter().copied().filter(uncached).collect();
let fields = Arc::new(block_fields(inp, &channels, &set.stack, hot, &uncached_planned_tiles, &planned_tiles));
let hot_tiles: std::collections::BTreeSet<(u32, u32)> = planned_tiles.iter().copied().collect();
let stack_tiles = if hot.is_some() && uncached_planned_tiles.len() < planned_tiles.len() {
uncached_planned_tiles.into_iter().collect()
} else {
hot_tiles.clone()
};
if let Some(cache) = below.as_deref_mut() {
cache.held = Some(HeldFields { key: key.clone(), size, stack_tiles, hot_tiles, fields: fields.clone() });
}
fields
}
_ => Arc::new(block_fields(inp, &channels, &set.stack, hot, &fresh, block)),
};
let quota = match below.as_deref() {
Some(_) if fits => usize::MAX,
Some(b) => b.limit().saturating_sub(b.bytes()) / tile_bytes,
None => 0,
};
let cached = below.as_deref().zip(split.as_deref());
let records = composite_block(inp, &set.stack, out, block, cached, quota, &fields);
if let Some(b) = below.as_deref_mut() {
for t in block {
b.touch(*t);
}
for (t, bands) in records {
b.insert(t, bands);
}
}
}
// Release fields at the end of the pass
if let Some(cache) = below.filter(|cache| cache.ahead.is_empty()) {
cache.held = None;
}
}
/// Whether a layer drawn by `stack` has a neighbourhood filter in its mask or content effects.
fn has_neighbourhood(inp: &Inputs, stack: &[LayerId]) -> bool {
let working_width = inp.gbuf.width;
let mut order = Vec::new();
draw_order(inp.project, stack, 0, &mut order);
order.into_iter().any(|id| {
let masked = layer_mask(inp.project, id).is_some_and(|mask| mask.enabled && neighbourhood(&mask.effects, working_width).is_some());
masked || inp.project.content_layer(id).is_some_and(|layer| !layer.is_group() && neighbourhood(&layer.content_effects, working_width).is_some())
})
}
/// The neighbourhood fields compositing `tiles` reads: those of every layer of `stack` over the tiles the cache lacks (`fresh`),
/// and off the path to the `hot` layer only there; the hot layer's over all of `tiles`.
fn block_fields(inp: &Inputs, channels: &[Channel], stack: &[LayerId], hot: Option<&Level>, fresh: &[(u32, u32)], tiles: &[(u32, u32)]) -> Fields {
match hot {
Some(hot) if fresh.len() < tiles.len() => {
let mut fields = fields_of(inp, channels, stack, fresh);
fields.extend(fields_of(inp, channels, &[hot.at], tiles));
fields
}
_ => fields_of(inp, channels, stack, tiles),
}
}
/// Rows of a tile composited as one parallel task.
const BAND: u32 = 16;
/// One band of a tile: per-channel buffers, what to cache of it (when recorded) and whether
/// any texel is covered.
type BandResult = (Vec<Vec<u16>>, Option<Band>, bool);
/// Per-channel tiles of one composited tile and whether any texel is covered.
type Joined = (Vec<Option<std::sync::Arc<Vec<u16>>>>, bool);
/// Composite one block of tiles, split along the path to the hot layer when `below` holds it;
/// returns what to cache (for at most `quota` tiles).
fn composite_block(
inp: &Inputs,
stack: &[LayerId],
out: &mut Composite,
tiles: &[(u32, u32)],
below: Option<(&BelowCache, &[Level])>,
quota: usize,
fields: &Fields,
) -> Vec<((u32, u32), Vec<Band>)> {
let channels: Vec<Channel> = inp.project.texture_set(inp.ts).map(|s| s.channel_list()).unwrap_or_default();
let (w, h) = (out.resolution, out.height);
let split = below.map(|(_, l)| l);
let cached = |t: (u32, u32)| below.and_then(|(b, _)| b.tile(t));
let fresh: Vec<(u32, u32)> = tiles.iter().copied().filter(|t| cached(*t).is_none()).collect();
let recorded: std::collections::BTreeSet<(u32, u32)> = if split.is_some() { fresh.iter().copied().take(quota).collect() } else { Default::default() };
let lanes: Vec<Lane> = channels.iter().map(|c| Lane { ch: c.index(), n: c.components(), signed: c.kind() == ChannelKind::Signed }).collect();
let stride: usize = lanes.iter().map(|l| l.n).sum();
let level_count = split.map_or(0, <[Level]>::len);
let defaults: Acc = Channel::ALL.map(Channel::default_value);
// Tiles split into bands of rows, so a handful of tiles still keeps every thread busy.
let bands = TILE / BAND;
let tasks: Vec<((u32, u32), u32)> = tiles.iter().flat_map(|t| (0..bands).map(move |b| (*t, b))).collect();
let mut results: Vec<BandResult> = tasks
.par_iter()
.map(|&((tx, ty), band)| {
let warm = cached((tx, ty)).and_then(|b| b.get(band as usize));
let record = warm.is_none() && recorded.contains(&(tx, ty));
let levels = split.map(|l| plan_levels(inp, l, &channels, tx, ty, fields, warm.is_some()));
let nodes = if levels.is_none() { plan(inp, stack, &channels, tx, ty, 0, Some(fields)) } else { Vec::new() };
let rows = (BAND * TILE) as usize;
let mut level_values = vec![defaults; level_count];
let mut masks = vec![0.0f32; level_count];
let mut tape = match warm {
Some(b) => Tape::Replay(b, 0),
None if record => Tape::Record(Vec::new()),
None => Tape::Off,
};
// Empty lower stacks reuse the enclosing level instead of storing a duplicate
let stored: Vec<bool> = match (&levels, warm) {
(Some(_), Some(_)) => tape.take(level_count).iter().map(|v| *v > 0.0).collect(),
(Some(levels), None) => levels.iter().map(|l| !l.below.is_empty()).collect(),
(None, _) => Vec::new(),
};
if let Tape::Record(t) = &mut tape {
t.extend(stored.iter().map(|s| if *s { 1.0 } else { 0.0 }));
}
let slots = stored.iter().filter(|s| **s).count() * stride;
let preview_tile = inp.preview.and_then(|p| p.alpha.tile(tx, ty));
let mut channel_buffers: Vec<Vec<u16>> = channels.iter().map(|c| vec![0u16; rows * c.components()]).collect();
let mut anchors = Vec::new();
let mut any = false;
for ly in band * BAND..(band + 1) * BAND {
let y = ty * TILE + ly;
if y >= h {
break;
}
for lx in 0..TILE {
let x = tx * TILE + lx;
if x >= w {
break;
}
let gbuffer_index = (y * w + x) as usize;
let tile_offset = (ly * TILE + lx) as usize;
let band_offset = ((ly - band * BAND) * TILE + lx) as usize;
let covered = inp.gbuf.tri.get(gbuffer_index).is_some_and(|t| *t != NO_TRI);
let mut acc = defaults;
if covered {
any = true;
let mut texel = Texel::new(inp, x, y, tile_offset, stroke_at(preview_tile, tile_offset));
// Reuse one anchor buffer per band.
texel.anchors = std::mem::take(&mut anchors);
match &levels {
Some(levels) => {
// The texel's stream starts with the stack at each level.
let start = match &mut tape {
Tape::Record(t) => {
t.resize(t.len() + slots, 0.0);
t.len() - slots
}
_ => 0,
};
if warm.is_some() {
load_levels(tape.take(slots), &lanes, stride, &stored, &defaults, &mut level_values);
}
acc = texel.eval_split(defaults, levels, &mut level_values, &mut masks, warm.is_some(), &mut tape);
if let Tape::Record(t) = &mut tape
&& let Some(below) = t.get_mut(start..start + slots)
{
store_levels(below, &lanes, stride, &stored, &level_values);
}
}
None => {
texel.eval(&nodes, &mut acc);
}
}
anchors = texel.anchors;
anchors.clear();
}
for (l, buf) in lanes.iter().zip(&mut channel_buffers) {
let v = acc.get(l.ch).copied().unwrap_or([0.0; 3]);
for (k, x) in v.iter().take(l.n).enumerate() {
let encoded = if l.signed { to_u16_signed(*x) } else { to_u16(*x) };
if let Some(slot) = buf.get_mut(band_offset * l.n + k) {
*slot = encoded;
}
}
}
}
}
let cache = if let Tape::Record(t) = tape { Some(t) } else { None };
(channel_buffers, cache, any)
})
.collect();
// Join the bands of each tile (in parallel; uncovered tiles are freed).
let joined: Vec<Joined> = results
.par_chunks(bands as usize)
.map(|parts| {
let any = parts.iter().any(|p| p.2);
let data = (0..channels.len())
.map(|k| {
any.then(|| {
let mut v = Vec::with_capacity(parts.iter().map(|p| p.0.get(k).map_or(0, Vec::len)).sum());
for p in parts {
v.extend_from_slice(p.0.get(k).map_or(&[][..], Vec::as_slice));
}
std::sync::Arc::new(v)
})
})
.collect();
(data, any)
})
.collect();
let mut records = Vec::new();
for ((&(tx, ty), (data, any)), parts) in tiles.iter().zip(joined).zip(results.chunks_mut(bands as usize)) {
for (c, d) in channels.iter().zip(data) {
if let Some(img) = out.channels.get_mut(c) {
img.set_tile(tx, ty, d);
}
}
// Tiles without covered texels cost nothing to composite: not worth caching.
if any && let Some(bands) = parts.iter_mut().map(|p| p.1.take()).collect::<Option<Vec<Band>>>() {
records.push(((tx, ty), bands));
}
}
records
}
/// Restore the stack at each nesting level of a texel: the `stored` levels from `src`, the
/// others repeat the level above them (the defaults at the top).
fn load_levels(src: &[f32], lanes: &[Lane], stride: usize, stored: &[bool], defaults: &Acc, accs: &mut [Acc]) {
let (mut k, mut above) = (0, *defaults);
for (a, s) in accs.iter_mut().zip(stored) {
if *s {
load_below(src, lanes, stride, k, a);
k += 1;
} else {
*a = above;
}
above = *a;
}
}
/// Store the `stored` levels of a texel's stack (see [`load_levels`]).
fn store_levels(dst: &mut [f32], lanes: &[Lane], stride: usize, stored: &[bool], accs: &[Acc]) {
for (k, a) in accs.iter().zip(stored).filter(|(_, s)| **s).map(|(a, _)| a).enumerate() {
store_below(dst, lanes, stride, k, a);
}
}
/// Where a texture set channel lives in a stack value, its components and whether it is signed.
#[derive(Clone, Copy)]
struct Lane {
ch: usize,
n: usize,
signed: bool,
}
/// Restore the cached stack value of slot `o` (a texel at one nesting level). Scalars are
/// cached once: only their first component is ever read.
fn load_below(cache: &[f32], lanes: &[Lane], stride: usize, o: usize, acc: &mut Acc) {
let mut i = o * stride;
for l in lanes {
if let (Some(src), Some(slot)) = (cache.get(i..i + l.n), acc.get_mut(l.ch)) {
*slot = match src {
[a, b, c] => [*a, *b, *c],
_ => [src.first().copied().unwrap_or(0.0); 3],
};
}
i += l.n;
}
}
fn store_below(cache: &mut [f32], lanes: &[Lane], stride: usize, o: usize, acc: &Acc) {
let mut i = o * stride;
for l in lanes {
if let (Some(dst), Some(v)) = (cache.get_mut(i..i + l.n), acc.get(l.ch)) {
for (d, x) in dst.iter_mut().zip(v) {
*d = *x;
}
}
i += l.n;
}
}
/// UV padding for display: fill uncovered texels in `tiles` and their neighbours from their
/// nearest covered texel. Returns the tiles it wrote.
pub fn pad_tiles(out: &mut Composite, dmap: &DilationMap, tiles: &[(u32, u32)]) -> std::collections::BTreeSet<(u32, u32)> {
let mut written = std::collections::BTreeSet::new();
let (w, h) = (out.resolution, out.height);
if (dmap.width, dmap.height) != (w, h) {
return written;
}
let (nx, ny) = (w.div_ceil(TILE) as i64, h.div_ceil(TILE) as i64);
let mut set = std::collections::BTreeSet::new();
for &(tx, ty) in tiles {
for dy in -1..=1i64 {
for dx in -1..=1i64 {
let (x, y) = (tx as i64 + dx, ty as i64 + dy);
if x >= 0 && y >= 0 && x < nx && y < ny {
set.insert((x as u32, y as u32));
}
}
}
}
let set: Vec<(u32, u32)> = set.into_iter().collect();
for img in out.channels.values_mut() {
let comps = img.comps();
let src: &TileImage = img;
// Each tile pads from the original image, so parallel writes stay independent
let padded: Vec<((u32, u32), Vec<u16>)> = set
.par_iter()
.filter_map(|&(tx, ty)| {
let mut data: Option<Vec<u16>> = None;
for ly in 0..TILE {
for lx in 0..TILE {
let (x, y) = (tx * TILE + lx, ty * TILE + ly);
if x >= w || y >= h {
continue;
}
let Some((sx, sy)) = dmap.source(x, y) else { continue };
if (sx, sy) == (x, y) {
continue;
}
let v = src.get(sx, sy);
let d = data.get_or_insert_with(|| src.tile(tx, ty).map_or_else(|| vec![0; TILE_AREA * comps], <[u16]>::to_vec));
let o = (ly * TILE + lx) as usize * comps;
if let Some(px) = d.get_mut(o..o + comps) {
px.copy_from_slice(&v[..comps]);
}
}
}
Some(((tx, ty), data?))
})
.collect();
for ((tx, ty), d) in padded {
img.set_tile(tx, ty, Some(std::sync::Arc::new(d)));
written.insert((tx, ty));
}
}
written
}
/// The layer mask over the whole texture set as `0..=1` values, row by row from the top (the
/// orientation of the exported maps), `gbuf.width × gbuf.height` of them; black outside the mesh
/// Returns None without an enabled mask
pub fn mask_texels(inputs: &Inputs, id: LayerId) -> Option<Vec<f32>> {
let mask = layer_mask(inputs.project, id).filter(|mask| mask.enabled)?;
let channels = inputs.project.texture_set(inputs.ts).map(|set| set.channel_list()).unwrap_or_default();
let (width, height) = (inputs.gbuf.width, inputs.gbuf.height);
let coordinates = all_tiles(width, height);
// A hidden layer's mask is left out of the stack's preparation
prepare_mask_curvature_sizes(inputs, std::iter::once(mask));
let fields = neighbourhood_fields(inputs, &channels, &coordinates);
let width_usize = width as usize;
let tile_side = TILE as usize;
let mut output = vec![0.0f32; width_usize * height as usize];
// Write each tile into disjoint atlas rows without temporary tile buffers
output.par_chunks_mut(width_usize.max(1) * tile_side).enumerate().for_each(|(tile_y, rows)| {
for tile_x in 0..width.div_ceil(TILE) {
for (offset, value) in mask_tile(inputs, id, mask, &channels, &fields, (tile_x, tile_y as u32), 0..TILE_AREA) {
let x = tile_x as usize * tile_side + offset % tile_side;
if x < width_usize
&& let Some(destination) = rows.get_mut((offset / tile_side) * width_usize + x)
{
*destination = value;
}
}
}
});
Some(output)
}
/// The layer mask as a square grayscale image, using nearest texels and black outside the mesh
/// Keep preview tiles at 8 bits instead of retaining the export's full float atlas
/// Returns None without an enabled mask
pub fn mask_image(inputs: &Inputs, id: LayerId, size: u32) -> Option<Vec<u8>> {
let mask = layer_mask(inputs.project, id).filter(|mask| mask.enabled)?;
let channels = inputs.project.texture_set(inputs.ts).map(|set| set.channel_list()).unwrap_or_default();
let (width, height) = (inputs.gbuf.width, inputs.gbuf.height);
let coordinates = all_tiles(width, height);
// A hidden layer's mask is left out of the stack's preparation
prepare_mask_curvature_sizes(inputs, std::iter::once(mask));
let fields = neighbourhood_fields(inputs, &channels, &coordinates);
let width_usize = width as usize;
let tile_side = TILE as usize;
let mut atlas = vec![0u8; width_usize * height as usize];
// Write each tile row into disjoint atlas rows
atlas.par_chunks_mut(width_usize.max(1) * tile_side).enumerate().for_each(|(tile_y, rows)| {
for tile_x in 0..width.div_ceil(TILE) {
for (offset, value) in mask_tile(inputs, id, mask, &channels, &fields, (tile_x, tile_y as u32), 0..TILE_AREA) {
let x = tile_x as usize * tile_side + offset % tile_side;
if x < width_usize
&& let Some(destination) = rows.get_mut((offset / tile_side) * width_usize + x)
{
*destination = (value * 255.0 + 0.5) as u8;
}
}
}
});
let size = size.max(1);
if width == size && height == size {
return Some(atlas);
}
let mut output = vec![0u8; (size * size) as usize];
for y in 0..size {
for x in 0..size {
let sample_x = (u64::from(x) * u64::from(width) / u64::from(size)) as u32;
let sample_y = (u64::from(y) * u64::from(height) / u64::from(size)) as u32;
if let Some(value) = atlas.get(sample_y as usize * width_usize + sample_x as usize)
&& let Some(destination) = output.get_mut((y * size + x) as usize)
{
*destination = *value;
}
}
}
Some(output)
}
/// The layer mask as one-component values at the texture set's full resolution over `tiles`
/// (uncovered texels read zero). Clone and smudge read it. Unlike [`mask_image`] it also reads a
/// disabled mask; None when the layer has no mask.
pub fn mask_values(inputs: &Inputs, id: LayerId, tiles: &[(u32, u32)]) -> Option<TileImage> {
let mut image = TileImage::new(inputs.gbuf.width, inputs.gbuf.height, 1);
mask_values_into(inputs, id, tiles, &mut image)?;
Some(image)
}
/// Evaluate requested tiles directly into the stroke's mask image.
pub fn mask_values_into(inputs: &Inputs, id: LayerId, tiles: &[(u32, u32)], image: &mut TileImage) -> Option<()> {
let mask = layer_mask(inputs.project, id)?;
let channels = inputs.project.texture_set(inputs.ts).ok()?.channel_list();
prepare_mask_curvature_sizes(inputs, std::iter::once(mask));
let fields = neighbourhood_fields(inputs, &channels, tiles);
let computed: Vec<((u32, u32), Vec<u16>)> = tiles
.par_iter()
.map(|&tile| {
let mut values = vec![0u16; TILE_AREA];
for (offset, value) in mask_tile(inputs, id, mask, &channels, &fields, tile, 0..TILE_AREA) {
if let Some(destination) = values.get_mut(offset) {
*destination = to_u16(value.clamp(0.0, 1.0));
}
}
(tile, values)
})
.collect();
for ((tx, ty), values) in computed {
image.set_tile(tx, ty, Some(std::sync::Arc::new(values)));
}
Some(())
}
/// Mask values at texture-set coordinates, in request order; None without an enabled mask
/// Uncovered and out-of-range texels read zero; neighbourhood filters also evaluate surrounding texels
pub fn mask_at(inputs: &Inputs, id: LayerId, texels: &[(u32, u32)]) -> Option<Vec<f32>> {
let mask = layer_mask(inputs.project, id).filter(|mask| mask.enabled)?;
let mut output = vec![0.0; texels.len()];
// Group valid requests before planning effects, which may resample painted tiles
let mut requested: HashMap<(u32, u32), Vec<(usize, usize)>> = HashMap::new();
for (index, &(x, y)) in texels.iter().enumerate() {
if x >= inputs.gbuf.width || y >= inputs.gbuf.height {
continue;
}
let offset = ((y % TILE) * TILE + x % TILE) as usize;
requested.entry((x / TILE, y / TILE)).or_default().push((offset, index));
}
if requested.is_empty() {
return Some(output);
}
let channels = inputs.project.texture_set(inputs.ts).map(|set| set.channel_list()).unwrap_or_default();
// A hidden layer's mask is left out of the stack's preparation
prepare_mask_curvature_sizes(inputs, std::iter::once(mask));
// Filters and anchors can depend on texels outside the requested tiles
let fields = neighbourhood_fields(inputs, &channels, &all_tiles(inputs.gbuf.width, inputs.gbuf.height));
let values: Vec<(usize, f32)> = requested
.par_iter_mut()
.flat_map_iter(|(&tile, requests)| {
requests.sort_unstable_by_key(|&(offset, _)| offset);
let groups = requests.chunk_by(|left, right| left.0 == right.0);
let offsets = groups.clone().filter_map(|group| group.first().map(|&(offset, _)| offset));
mask_tile(inputs, id, mask, &channels, &fields, tile, offsets)
.zip(groups)
.flat_map(|((_, value), group)| group.iter().map(move |&(_, index)| (index, value)))
})
.collect();
for (index, value) in values {
if let Some(destination) = output.get_mut(index) {
*destination = value;
}
}
Some(output)
}
/// Mask values in offset order, including zeros for uncovered texels so request groups stay aligned
fn mask_tile<'a>(
inputs: &'a Inputs<'a>,
id: LayerId,
mask: &'a Mask,
channels: &[Channel],
fields: &'a Fields,
(tile_x, tile_y): (u32, u32),
offsets: impl Iterator<Item = usize> + 'a,
) -> impl Iterator<Item = (usize, f32)> + 'a {
let plan = mask_plan(inputs, id, mask, tile_x, tile_y, Some(fields));
let anchor_stack = anchor_plan(inputs, id, channels, tile_x, tile_y, Some(fields));
offsets.map(move |offset| {
let Some(plan) = plan.as_ref() else { return (offset, 0.0) };
let x = tile_x * TILE + (offset % TILE as usize) as u32;
let y = tile_y * TILE + (offset / TILE as usize) as u32;
if x >= inputs.gbuf.width || y >= inputs.gbuf.height || inputs.gbuf.tri.get((y * inputs.gbuf.width + x) as usize).is_none_or(|tri| *tri == NO_TRI) {
return (offset, 0.0);
}
let mut texel = Texel::new(inputs, x, y, offset, 0.0);
if !anchor_stack.is_empty() {
texel.anchors_below(&anchor_stack, id);
}
(offset, texel.mask(plan))
})
}
/// Tiles [`effect_histogram`] samples at most (a million texels).
const HISTOGRAM_TILES: usize = 256;
/// The tiles [`effect_histogram`] reads: an even sample of at most [`HISTOGRAM_TILES`], which
/// keeps the cost flat up to 8K. The stride is odd: a power of two would divide the row length
/// and sample the same few columns.
fn histogram_tiles(width: u32, height: u32) -> Vec<(u32, u32)> {
let all = all_tiles(width, height);
let stride = all.len().div_ceil(HISTOGRAM_TILES).max(1) | 1;
all.into_iter().step_by(stride).collect()
}
/// Histogram (`bins` buckets over 0..1) of the values entering effect `effect`: its layer's mask
/// below it, or (a content effect) the layer's `channel` below it where the layer has content,
/// color components pooled and signed values mapped to 0..1. Over the texels the mesh covers
/// (in an even sample of tiles on large sets); None for an unknown effect.
pub fn effect_histogram(inp: &Inputs, effect: LayerId, channel: Channel, bins: usize) -> Option<Vec<u32>> {
let (owner, _) = inp.project.effect(effect)?;
let bins = bins.max(1);
// Evaluate the layer forced visible, its mask enabled, cut just below the effect.
let mut cut = inp.project.clone();
let l = cut.layers.get_mut(&owner)?;
l.visible = true;
let in_mask = match l.mask.as_mut().and_then(|m| m.effects.iter().position(|e| e.id == effect).map(|k| (m, k))) {
Some((m, k)) => {
m.enabled = true;
m.effects.truncate(k);
true
}
None => {
let k = l.content_effects.iter().position(|e| e.id == effect)?;
l.content_effects.truncate(k);
false
}
};
let cut_inp = Inputs { project: &cut, preview: None, block_scales: inp.block_scales.clone(), ..*inp };
let channels = cut.texture_set(inp.ts).map(|t| t.channel_list()).unwrap_or_default();
let tiles = histogram_tiles(inp.gbuf.width, inp.gbuf.height);
// A field covers the bounding box of the tiles it is built for, which for a scattered sample
// is the whole set: with a neighbourhood filter below, each tile gets its own.
let probe = neighbourhood_fields(&cut_inp, &channels, tiles.get(..1).unwrap_or_default());
let shared = probe.is_empty().then_some(probe);
let bin = |v: f32| ((v.clamp(0.0, 1.0) * bins as f32) as usize).min(bins - 1);
let hist = tiles
.par_iter()
.map(|&(tx, ty)| {
let own;
let fields = match &shared {
Some(f) => f,
None => {
own = neighbourhood_fields(&cut_inp, &channels, &[(tx, ty)]);
&own
}
};
let mut h = vec![0u32; bins];
// The mask is planned on its own: a layer with nothing drawn plans no node.
let mask = if in_mask { layer_mask(&cut, owner).and_then(|m| mask_plan(&cut_inp, owner, m, tx, ty, Some(fields))) } else { None };
let nodes = if in_mask { Vec::new() } else { plan(&cut_inp, &[owner], &channels, tx, ty, 0, Some(fields)) };
let content = nodes.first().and_then(|n| n.chans.iter().find(|c| Channel::ALL.get(c.ch) == Some(&channel)).map(|c| (n, c)));
if mask.is_none() && content.is_none() {
return h;
}
let full = anchor_plan(&cut_inp, owner, &channels, tx, ty, Some(fields));
for (x, y, o) in tile_texels(inp.gbuf, tx, ty) {
let mut tex = Texel::new(&cut_inp, x, y, o, 0.0);
if !full.is_empty() {
tex.anchors_below(&full, owner);
}
if let Some(m) = &mask {
if let Some(b) = h.get_mut(bin(tex.mask(m))) {
*b += 1;
}
} else if let Some((n, c)) = content
&& let Some((v, _)) = tex.content(&n.content, c)
{
// As levels reads them (`per_unit`); normal maps pass through levels unchanged.
let (vals, signed) = match c.kind {
ChannelKind::Color => (&v[..], false),
ChannelKind::Scalar => (&v[..1], false),
ChannelKind::Signed => (&v[..1], true),
ChannelKind::NormalMap => (&v[..0], false),
};
for x in vals {
if let Some(b) = h.get_mut(bin(if signed { x * 0.5 + 0.5 } else { *x })) {
*b += 1;
}
}
}
}
h
})
.reduce(|| vec![0u32; bins], |a, b| a.iter().zip(&b).map(|(x, y)| x.saturating_add(*y)).collect());
Some(hist)
}
/// One flattened tile of one channel: (channel, tile, premultiplied value + coverage data).
pub type FlatTile = (Channel, (u32, u32), Vec<u16>);
/// Flatten one paint or fill layer: its content (with content effects) times its mask, as
/// premultiplied (value, coverage) tiles per enabled channel, ready to become a plain paint
/// layer. Groups are not supported (None).
pub fn flatten_layer(inputs: &Inputs, id: LayerId, tiles: &[(u32, u32)]) -> Option<Vec<FlatTile>> {
let set = inputs.project.texture_set(inputs.ts).ok()?;
if inputs.project.content_layer(id)?.is_group() {
return None;
}
let channels: Vec<Channel> = set.channel_list();
// Plan the layer forced visible so hidden layers flatten too
let mut solo = inputs.project.clone();
if let Some(l) = solo.layers.get_mut(&id) {
l.visible = true;
}
let visible_inputs = Inputs { project: &solo, preview: None, block_scales: inputs.block_scales.clone(), ..*inputs };
let fields = neighbourhood_fields(&visible_inputs, &channels, tiles);
let out: Vec<Vec<FlatTile>> = tiles
.par_iter()
.map(|&(tx, ty)| {
let nodes = plan(&visible_inputs, &[id], &channels, tx, ty, 0, Some(&fields));
let Some(n) = nodes.first() else { return Vec::new() };
let full = anchor_plan(&visible_inputs, id, &channels, tx, ty, Some(&fields));
let mut buffers: Vec<(Channel, Vec<u16>, bool)> =
n.chans.iter().filter_map(|c| Channel::ALL.get(c.ch).map(|ch| (*ch, vec![0u16; TILE_AREA * (c.comps + 1)], false))).collect();
for (ch, buffer, _) in &mut buffers {
if ch.kind() == ChannelKind::Signed {
for pixel in buffer.as_chunks_mut::<2>().0 {
pixel[0] = to_u16_signed(0.0);
}
}
}
for (x, y, o) in tile_texels(inputs.gbuf, tx, ty) {
let mut tex = Texel::new(&visible_inputs, x, y, o, 0.0);
if !full.is_empty() {
tex.anchors_below(&full, id);
}
let m = tex.node_mask(n);
for (c, (ch, buffer, any)) in n.chans.iter().zip(buffers.iter_mut()) {
let Some((v, cov)) = tex.content(&n.content, c) else { continue };
let a = (cov * m).clamp(0.0, 1.0);
if a <= 0.0 {
continue;
}
*any = true;
let comps = c.comps;
let Some(pixel) = buffer.get_mut(o * (comps + 1)..(o + 1) * (comps + 1)) else { continue };
for (slot, pv) in pixel.iter_mut().zip(v.iter().take(comps)) {
*slot = if ch.kind() == ChannelKind::Signed { to_u16_signed(pv * a) } else { to_u16(pv * a) };
}
if let Some(slot) = pixel.get_mut(comps) {
*slot = to_u16(a);
}
}
}
buffers.into_iter().filter(|(_, _, any)| *any).map(|(ch, buffer, _)| (ch, (tx, ty), buffer)).collect()
})
.collect();
Some(out.into_iter().flatten().collect())
}
#[cfg(test)]
mod tests {
use super::*;
use texturecraft_core::{ChannelBlend, Effect, Layer, OutputResolution, Procedural, ProceduralKind, ResolutionMode, TextureSet};
use texturecraft_geom::primitives;
struct Fixture {
project: Project,
mesh: Mesh,
gbuf: UvGBuffer,
pixels: PixelStore,
baked: BakedMaps,
}
fn fixture() -> Fixture {
let mesh = primitives::plane(2.0, 2);
let gbuf = UvGBuffer::new(&mesh, 0, 64, 64);
let mut project = Project::new("t", "builtin:plane");
project.texture_sets.push(TextureSet::new("Plane", 0, 64));
Fixture { project, mesh, gbuf, pixels: PixelStore::default(), baked: BakedMaps::default() }
}
fn run(f: &Fixture, preview: Option<&StrokePreview>) -> Composite {
let images = Default::default();
let inp = Inputs {
project: &f.project,
ts: 0,
mesh: &f.mesh,
gbuf: &f.gbuf,
pixels: &f.pixels,
baked: &f.baked,
block_scales: f.project.texture_sets[0].block_scales(),
preview,
images: &images,
bounds: f.mesh.bounds(),
};
let mut out = Composite::new(&f.project.texture_sets[0].channel_list(), 64);
composite_tiles(&inp, &mut out, &all_tiles(64, 64));
out
}
#[test]
fn procedural_resolution_uses_each_uv_tiles_scale() {
let mut fixture = fixture();
let set = &mut fixture.project.texture_sets[0];
set.uv_tiles = vec![1001, 1002];
set.resolution = 64;
set.tile_resolutions.insert(1002, 32);
fixture.gbuf = UvGBuffer::new(&fixture.mesh, 0, 128, 64);
let block_scales = set.block_scales();
let images = ImageStore::default();
let inputs = Inputs {
project: &fixture.project,
ts: 0,
mesh: &fixture.mesh,
gbuf: &fixture.gbuf,
pixels: &fixture.pixels,
baked: &fixture.baked,
block_scales,
preview: None,
images: &images,
bounds: fixture.mesh.bounds(),
};
assert_eq!(inputs.tile_res_at(0, 0), 64);
assert_eq!(inputs.tile_res_at(64, 0), 32);
let mut pattern = Procedural::new(ProceduralKind::Checker);
pattern.resolution.factor = -1;
assert_eq!(pattern_pixels(&pattern, inputs.tile_res_at(0, 0), 64), Some(32));
assert_eq!(pattern_pixels(&pattern, inputs.tile_res_at(64, 0), 64), Some(16));
}
fn fill_layer(p: &mut Project, color: [f32; 3], rough: f32) -> LayerId {
let id = p.alloc_id();
let mut fill = Fill::default();
fill.sources.insert(Channel::BaseColor, Source::Uniform(color));
fill.sources.insert(Channel::Roughness, Source::Uniform([rough; 3]));
let l = Layer::new(id, "Fill", LayerKind::Fill(fill), &[Channel::BaseColor, Channel::Roughness]);
p.insert_layer(0, l, None, false).unwrap()
}
fn close(a: [f32; 3], b: [f32; 3]) -> bool {
(0..3).all(|i| (a[i] - b[i]).abs() < 2e-4)
}
#[test]
fn retained_filter_buffers_release_after_the_last_tile() {
for resolution in [128, 512] {
for record_anchors in [false, true] {
let mut fixture = fixture();
fixture.gbuf = UvGBuffer::new(&fixture.mesh, 0, resolution, resolution);
fixture.project.texture_sets[0] = TextureSet::new("Plane", 0, resolution);
for color in [0.4, 0.2] {
let layer = fill_layer(&mut fixture.project, [color; 3], 0.5);
let mut mask = Mask::new(MaskBackground::White);
for radius in [8.0, 4.0, 2.0] {
mask.effects.push(Effect::new(fixture.project.alloc_id(), EffectKind::Filter(Filter::Blur { radius })));
if record_anchors && radius != 2.0 {
mask.effects.push(Effect::new(fixture.project.alloc_id(), EffectKind::Anchor));
}
}
fixture.project.layer_mut(layer).unwrap().mask = Some(mask);
}
let images = ImageStore::default();
let input = Inputs {
project: &fixture.project,
ts: 0,
mesh: &fixture.mesh,
gbuf: &fixture.gbuf,
pixels: &fixture.pixels,
baked: &fixture.baked,
block_scales: fixture.project.texture_sets[0].block_scales(),
preview: None,
images: &images,
bounds: fixture.mesh.bounds(),
};
let mut output = Composite::new(&fixture.project.texture_sets[0].channel_list(), resolution);
let mut cache = BelowCache::default();
cache.ahead = all_tiles(resolution, resolution).into_iter().skip(1).collect();
composite_tiles_cached(&input, &mut output, &[(0, 0)], Some(&mut cache));
let retained = cache.held.as_ref().expect("filter fields should be retained while tiles follow");
let fields = || retained.fields.values().flat_map(|field| std::iter::once(field).chain(field.anchor_stages.iter().map(|(_, stage)| stage)));
let field_bytes: usize = fields().map(|field| field.data.capacity() * std::mem::size_of::<f32>()).sum();
let field_count = fields().count();
let stage_index_bytes: usize =
retained.fields.values().map(|field| field.anchor_stages.capacity() * std::mem::size_of::<(LayerId, Field)>()).sum();
let weak_fields = Arc::downgrade(&retained.fields);
let expected_fields = if record_anchors { 6 } else { 2 };
assert_eq!(field_count, expected_fields, "only filter stages needed by anchors remain beside the final mask fields");
assert_eq!(field_bytes, expected_fields * resolution as usize * resolution as usize * std::mem::size_of::<f32>());
println!(
"resolution: {resolution}, mask layers: 2, anchors: {record_anchors}, fields: {field_count}, buffer capacity: {field_bytes} bytes, stage-index capacity: {stage_index_bytes} bytes"
);
cache.ahead.clear();
composite_tiles_cached(&input, &mut output, &[(1, 0)], Some(&mut cache));
assert!(weak_fields.upgrade().is_none(), "the last tile must release retained field buffers");
cache.ahead = all_tiles(resolution, resolution).into_iter().skip(1).collect();
composite_tiles_cached(&input, &mut output, &[(0, 0)], Some(&mut cache));
let weak_fields = Arc::downgrade(&cache.held.as_ref().unwrap().fields);
cache.clear();
assert!(weak_fields.upgrade().is_none(), "invalidating the cache releases intermediate anchor stages too");
composite_tiles_cached(&input, &mut output, &[(0, 0)], Some(&mut cache));
let weak_fields = Arc::downgrade(&cache.held.as_ref().unwrap().fields);
drop(cache);
assert!(weak_fields.upgrade().is_none(), "dropping the cache releases a cancelled run's fields");
}
}
}
#[test]
fn histogram_samples_spread_over_every_column() {
assert_eq!(histogram_tiles(1024, 1024), all_tiles(1024, 1024), "small sets are read whole");
for size in [2048, 4096, 8192] {
let tiles = histogram_tiles(size, size);
let columns: std::collections::BTreeSet<u32> = tiles.iter().map(|t| t.0).collect();
assert!(tiles.len() <= HISTOGRAM_TILES, "{size}: {} tiles", tiles.len());
assert!(columns.len() as u32 >= size / TILE / 2, "{size}: only {} columns", columns.len());
}
}
#[test]
fn empty_stack_gives_channel_defaults() {
let f = fixture();
let out = run(&f, None);
assert!(close(out.value(Channel::BaseColor, 10, 10), [0.5; 3]));
assert!(close(out.value(Channel::Roughness, 10, 10), [0.5; 3]));
assert!(close(out.value(Channel::Normal, 10, 10), [0.5, 0.5, 1.0]));
}
#[test]
fn fill_layers_blend_with_opacity_and_modes() {
let mut f = fixture();
fill_layer(&mut f.project, [1.0, 0.0, 0.0], 0.2);
let top = fill_layer(&mut f.project, [0.0, 0.0, 1.0], 0.8);
f.project.layer_mut(top).unwrap().channels.insert(Channel::BaseColor, ChannelBlend { mode: BlendMode::Normal, opacity: 0.25 });
let out = run(&f, None);
assert!(close(out.value(Channel::BaseColor, 5, 5), [0.75, 0.0, 0.25]));
assert!(close(out.value(Channel::Roughness, 5, 5), [0.8; 3]));
f.project.layer_mut(top).unwrap().channels.insert(Channel::BaseColor, ChannelBlend { mode: BlendMode::Multiply, opacity: 1.0 });
let out = run(&f, None);
assert!(close(out.value(Channel::BaseColor, 5, 5), [0.0, 0.0, 0.0]));
}
#[test]
fn paint_layers_unpremultiply_and_preview_and_masks() {
let mut f = fixture();
let id = f.project.alloc_id();
let l = Layer::new(id, "Paint", LayerKind::Paint, &[Channel::BaseColor]);
f.project.insert_layer(0, l, None, false).unwrap();
// Half-covered red texel has premultiplied color and 0.5 coverage
let img = f.pixels.layer_mut(id, Channel::BaseColor, (64, 64));
img.set(3, 3, &[to_u16(0.5), 0, 0, to_u16(0.5)]);
let out = run(&f, None);
assert!(close(out.value(Channel::BaseColor, 3, 3), [0.75, 0.25, 0.25]));
assert!(close(out.value(Channel::BaseColor, 4, 3), [0.5; 3]));
// A live stroke paints blue at full alpha on texel (4, 3)
let mut alpha = TileImage::new(64, 64, 1);
alpha.set(4, 3, &[to_u16(1.0)]);
let pv = StrokePreview {
target: PaintTarget::Layer(id),
alpha,
opacity: 1.0,
erase: false,
values: [(Channel::BaseColor, [0.0, 0.0, 1.0])].into_iter().collect(),
mask_value: 1.0,
stencil: None,
carried: BTreeMap::new(),
carried_mask: None,
};
let out = run(&f, Some(&pv));
assert!(close(out.value(Channel::BaseColor, 4, 3), [0.0, 0.0, 1.0]));
// A black mask hides the layer
f.project.layer_mut(id).unwrap().mask = Some(Mask::new(MaskBackground::Black));
let out = run(&f, None);
assert!(close(out.value(Channel::BaseColor, 3, 3), [0.5; 3]));
}
#[test]
fn mask_effects_and_procedural_fills_stay_in_range() {
let mut f = fixture();
let id = fill_layer(&mut f.project, [1.0, 1.0, 1.0], 1.0);
let eid = f.project.alloc_id();
let mut mask = Mask::new(MaskBackground::Black);
let pattern = Procedural::new(ProceduralKind::Checker);
mask.effects.push(Effect::new(
eid,
EffectKind::Fill { source: Source::Procedural { pattern, low: [0.0; 3], high: [1.0; 3], ramp: Vec::new() }, projection: Projection::default() },
));
f.project.layer_mut(id).unwrap().mask = Some(mask);
let out = run(&f, None);
let vals: Vec<f32> = (0..64).map(|x| out.value(Channel::BaseColor, x, 20)[0]).collect();
assert!(vals.iter().any(|v| *v > 0.99) && vals.iter().any(|v| *v < 0.51), "{vals:?}");
}
fn assert_sparse_mask_matches_image(fixture: &Fixture, layer: LayerId, texels: &[(u32, u32)]) -> Option<Vec<f32>> {
let images = ImageStore::default();
let inputs = Inputs {
project: &fixture.project,
ts: 0,
mesh: &fixture.mesh,
gbuf: &fixture.gbuf,
pixels: &fixture.pixels,
baked: &fixture.baked,
block_scales: fixture.project.texture_sets[0].block_scales(),
preview: None,
images: &images,
bounds: fixture.mesh.bounds(),
};
let sparse = mask_at(&inputs, layer, texels);
let image = mask_image(&inputs, layer, fixture.gbuf.width);
assert_eq!(sparse.is_some(), image.is_some());
let values = sparse?;
let image = image?;
assert_eq!(values.len(), texels.len());
for (&(x, y), &value) in texels.iter().zip(&values) {
let expected =
if x < fixture.gbuf.width && y < fixture.gbuf.height { f32::from(image[(y * fixture.gbuf.width + x) as usize]) / 255.0 } else { 0.0 };
assert!((value - expected).abs() <= 0.5 / 255.0 + 1e-6, "({x}, {y}): {value} vs {expected}");
}
Some(values)
}
#[test]
fn mask_at_reads_the_same_values_as_the_mask_image() {
let mut fixture = fixture();
fixture.gbuf = UvGBuffer::new(&fixture.mesh, 0, 128, 128);
fixture.project.texture_sets[0].resolution = 128;
fixture.gbuf.tri[30 * 128 + 90] = NO_TRI;
let layer = fill_layer(&mut fixture.project, [1.0; 3], 1.0);
let maskless = fill_layer(&mut fixture.project, [1.0; 3], 1.0);
let effect = fixture.project.alloc_id();
let mut mask = Mask::new(MaskBackground::Black);
let pattern = Procedural::new(ProceduralKind::Checker);
mask.effects.push(Effect::new(
effect,
EffectKind::Fill { source: Source::Procedural { pattern, low: [0.0; 3], high: [1.0; 3], ramp: Vec::new() }, projection: Projection::default() },
));
fixture.project.layer_mut(layer).unwrap().mask = Some(mask);
// Cross tile boundaries and include duplicates, a UV hole and invalid coordinates
let texels = [(0, 0), (0, 40), (63, 63), (64, 64), (127, 127), (0, 40), (90, 30), (128, 0), (0, 128), (u32::MAX, u32::MAX)];
let values = assert_sparse_mask_matches_image(&fixture, layer, &texels).unwrap();
assert!(values.iter().any(|value| *value > 0.99) && values.iter().take(6).any(|value| *value < 0.01));
assert_eq!(&values[6..], &[0.0; 4]);
assert_eq!(assert_sparse_mask_matches_image(&fixture, layer, &[]), Some(Vec::new()));
assert!(assert_sparse_mask_matches_image(&fixture, maskless, &texels).is_none());
let missing = fixture.project.alloc_id();
assert!(assert_sparse_mask_matches_image(&fixture, missing, &texels).is_none());
fixture.project.layer_mut(layer).unwrap().mask.as_mut().unwrap().enabled = false;
assert!(assert_sparse_mask_matches_image(&fixture, layer, &texels).is_none());
}
#[test]
fn mask_image_resamples_a_non_square_atlas() {
let mut fixture = fixture();
fixture.gbuf = UvGBuffer::new(&fixture.mesh, 0, 128, 64);
fixture.project.texture_sets[0].resolution = 128;
let layer = fill_layer(&mut fixture.project, [1.0; 3], 1.0);
let effect = fixture.project.alloc_id();
let mut mask = Mask::new(MaskBackground::Black);
mask.effects.push(Effect::new(
effect,
EffectKind::Fill {
source: Source::Procedural { pattern: Procedural::new(ProceduralKind::Checker), low: [0.0; 3], high: [1.0; 3], ramp: Vec::new() },
projection: Projection::default(),
},
));
fixture.project.layer_mut(layer).unwrap().mask = Some(mask);
let images = ImageStore::default();
let inputs = Inputs {
project: &fixture.project,
ts: 0,
mesh: &fixture.mesh,
gbuf: &fixture.gbuf,
pixels: &fixture.pixels,
baked: &fixture.baked,
block_scales: fixture.project.texture_sets[0].block_scales(),
preview: None,
images: &images,
bounds: fixture.mesh.bounds(),
};
let sampled_texels: Vec<_> = (0..64).flat_map(|y| (0..64).map(move |x| (x * 2, y))).collect();
let preview = mask_image(&inputs, layer, 64).unwrap();
let sparse = mask_at(&inputs, layer, &sampled_texels).unwrap();
let atlas = mask_texels(&inputs, layer).unwrap();
assert_eq!(preview.len(), 64 * 64);
assert_eq!(atlas.len(), 128 * 64);
assert!(preview.contains(&0));
assert!(preview.contains(&255));
for ((&preview_value, &sparse_value), &(x, y)) in preview.iter().zip(&sparse).zip(&sampled_texels) {
assert!((f32::from(preview_value) / 255.0 - sparse_value).abs() <= 0.5 / 255.0 + 1e-6);
assert!((atlas[(y * 128 + x) as usize] - sparse_value).abs() <= 1e-6);
}
}
#[test]
fn mask_at_ignores_out_of_range_texels_before_resampling_paint() {
let mut fixture = fixture();
let layer = fill_layer(&mut fixture.project, [1.0; 3], 1.0);
let paint = fixture.project.alloc_id();
let mut mask = Mask::new(MaskBackground::Black);
mask.effects.push(Effect::new(paint, EffectKind::Paint));
fixture.project.layer_mut(layer).unwrap().mask = Some(mask);
fixture.pixels.mask_mut(paint, (32, 32)).set(4, 5, &[u16::MAX; 2]);
let texels = [(8, 10), (u32::MAX, 0), (0, u32::MAX), (u32::MAX, u32::MAX), (64, 0), (0, 64)];
let values = assert_sparse_mask_matches_image(&fixture, layer, &texels).unwrap();
assert!(values[0] > 0.5, "valid texels still read resampled paint");
assert_eq!(&values[1..], &[0.0; 5]);
assert_eq!(assert_sparse_mask_matches_image(&fixture, layer, &texels[1..]), Some(vec![0.0; 5]));
}
#[test]
fn mask_at_preserves_anchors_and_neighbourhood_filters_across_tiles() {
let mut fixture = fixture();
fixture.gbuf = UvGBuffer::new(&fixture.mesh, 0, 128, 128);
fixture.project.texture_sets[0].resolution = 128;
let lower = fill_layer(&mut fixture.project, [0.0; 3], 1.0);
let LayerKind::Fill(fill) = &mut fixture.project.layer_mut(lower).unwrap().kind else { panic!("expected a fill layer") };
fill.sources.insert(
Channel::BaseColor,
Source::Procedural { pattern: Procedural::new(ProceduralKind::Checker), low: [0.0; 3], high: [1.0; 3], ramp: Vec::new() },
);
let anchor = content_fx(&mut fixture, lower, EffectKind::Anchor);
let upper = fill_layer(&mut fixture.project, [1.0; 3], 1.0);
let mut mask = Mask::new(MaskBackground::Black);
mask.effects.push(Effect::new(
fixture.project.alloc_id(),
EffectKind::Fill { source: Source::Anchor { anchor, channel: Channel::BaseColor, ramp: Vec::new() }, projection: Projection::default() },
));
fixture.project.layer_mut(upper).unwrap().mask = Some(mask.clone());
let texels: Vec<_> = (0..128).map(|x| (x, 63)).collect();
let original = assert_sparse_mask_matches_image(&fixture, upper, &texels).unwrap();
assert!(original.iter().any(|value| *value > 0.99) && original.iter().any(|value| *value < 0.01), "the anchor supplies the checker");
for filter in [Filter::Blur { radius: 64.0 }, Filter::DirectionalWarp { intensity: 256.0, angle: 90.0, scale: 4.0, seed: 3 }] {
let mut filtered = mask.clone();
filtered.effects.push(Effect::new(fixture.project.alloc_id(), EffectKind::Filter(filter)));
fixture.project.layer_mut(upper).unwrap().mask = Some(filtered);
let values = assert_sparse_mask_matches_image(&fixture, upper, &texels).unwrap();
assert!(values.iter().zip(&original).any(|(value, original)| (value - original).abs() > 0.1), "the filter changes the anchor values");
}
}
#[test]
fn a_mask_runs_every_neighbourhood_filter_in_order() {
let mut fixture = fixture();
fixture.gbuf = UvGBuffer::new(&fixture.mesh, 0, 128, 128);
fixture.project.texture_sets[0].resolution = 128;
let layer = fill_layer(&mut fixture.project, [1.0; 3], 1.0);
let checker = Source::Procedural { pattern: Procedural::new(ProceduralKind::Checker), low: [0.0; 3], high: [1.0; 3], ramp: Vec::new() };
let warp = Filter::DirectionalWarp { intensity: 256.0, angle: 90.0, scale: 4.0, seed: 3 };
let texels: Vec<_> = (0..128).map(|x| (x, 63)).collect();
let mut masked = |filters: &[Filter]| {
let mut mask = Mask::new(MaskBackground::Black);
mask.effects.push(Effect::new(fixture.project.alloc_id(), EffectKind::Fill { source: checker.clone(), projection: Projection::default() }));
for filter in filters {
mask.effects.push(Effect::new(fixture.project.alloc_id(), EffectKind::Filter(filter.clone())));
}
fixture.project.layer_mut(layer).unwrap().mask = Some(mask);
assert_sparse_mask_matches_image(&fixture, layer, &texels).unwrap()
};
let warped = masked(std::slice::from_ref(&warp));
let blurred_then_warped = masked(&[Filter::Blur { radius: 64.0 }, warp]);
assert!(blurred_then_warped.iter().zip(&warped).any(|(chained, single)| (chained - single).abs() > 0.1), "the blur under the warp still runs");
assert!(blurred_then_warped.iter().any(|value| *value > 0.05 && *value < 0.95), "the blur softens the checker before the warp moves it");
}
#[test]
fn a_content_stack_runs_every_neighbourhood_filter_in_order() {
let mut fixture = fixture();
let layer = fill_layer(&mut fixture.project, [0.0; 3], 1.0);
let LayerKind::Fill(fill) = &mut fixture.project.layer_mut(layer).unwrap().kind else { panic!("expected a fill layer") };
fill.sources.insert(
Channel::BaseColor,
Source::Procedural { pattern: Procedural::new(ProceduralKind::Checker), low: [0.0; 3], high: [1.0; 3], ramp: Vec::new() },
);
let warp = Filter::DirectionalWarp { intensity: 256.0, angle: 90.0, scale: 4.0, seed: 3 };
let warp_effect = content_fx(&mut fixture, layer, EffectKind::Filter(warp));
let row = |fixture: &Fixture| -> Vec<f32> {
let composite = run(fixture, None);
(0..64).map(|x| composite.value(Channel::BaseColor, x, 20)[0]).collect()
};
let warped = row(&fixture);
content_fx(&mut fixture, layer, EffectKind::Filter(Filter::Blur { radius: 64.0 }));
let effects = &mut fixture.project.layer_mut(layer).unwrap().content_effects;
let warp_index = effects.iter().position(|effect| effect.id == warp_effect).unwrap();
let warp_on_top = effects.remove(warp_index);
effects.push(warp_on_top);
let blurred_then_warped = row(&fixture);
assert!(blurred_then_warped.iter().zip(&warped).any(|(chained, single)| (chained - single).abs() > 0.1), "the blur under the warp still runs");
}
/// A 256² set whose curvature map has a one-texel ridge in column `ridge_x` (flat elsewhere), and a white fill layer to mask.
fn ridge_fixture(ridge_x: usize) -> (Fixture, LayerId) {
let mut fixture = fixture();
fixture.gbuf = UvGBuffer::new(&fixture.mesh, 0, 256, 256);
fixture.project.texture_sets[0].resolution = 256;
let ridge: Vec<f32> = (0..256 * 256).map(|texel| if texel % 256 == ridge_x { 1.0 } else { 0.5 }).collect();
fixture.baked = BakedMaps { resolution: 256, maps: [(BakedMap::Curvature, Arc::new(ridge))].into() };
let layer = fill_layer(&mut fixture.project, [1.0; 3], 1.0);
(fixture, layer)
}
/// `layer`'s mask made of `effects` (bottom first) on black, read along row 128 over `xs`.
fn mask_row(fixture: &mut Fixture, layer: LayerId, effects: Vec<Effect>, xs: std::ops::Range<u32>) -> Vec<f32> {
let mut mask = Mask::new(MaskBackground::Black);
mask.effects = effects;
fixture.project.layer_mut(layer).unwrap().mask = Some(mask);
let images = Default::default();
let inputs = Inputs {
project: &fixture.project,
ts: 0,
mesh: &fixture.mesh,
gbuf: &fixture.gbuf,
pixels: &fixture.pixels,
baked: &fixture.baked,
block_scales: BlockScales::default(),
preview: None,
images: &images,
bounds: fixture.mesh.bounds(),
};
mask_at(&inputs, layer, &xs.map(|x| (x, 128)).collect::<Vec<_>>()).unwrap()
}
/// A generator effect of `fixture`'s project.
fn generator_effect(fixture: &mut Fixture, generator: Generator) -> Effect {
Effect::new(fixture.project.alloc_id(), EffectKind::Generator(generator))
}
/// An edge wear generator that marks exactly the curvature ridge (the map as baked, a hard step).
fn ridge_generator() -> Generator {
Generator { level: 0.5, softness: 0.01, noise_amount: 0.0, detail: None, ..Generator::new(GeneratorKind::EdgeWear) }
}
#[test]
fn larger_curvature_detail_sizes_reach_further_from_an_edge() {
let (mut fixture, layer) = ridge_fixture(128);
let mut row_with = |weights: [f32; 7]| {
let detail = CurvatureDetail { mode: CurvatureMode::Edges, weights };
let generator = Generator { level: 0.5, softness: 0.5, noise_amount: 0.0, detail: Some(detail), ..Generator::new(GeneratorKind::Curvature) };
let effect = generator_effect(&mut fixture, generator);
mask_row(&mut fixture, layer, vec![effect], 120..137)
};
// The sampled ridge is index 8; five texels to its left is index 3
let (ridge, five_texels_away) = (8, 3);
let finest = row_with([1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]);
let largest = row_with([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]);
assert!(finest[ridge] > 0.99 && finest[five_texels_away] < 0.01, "the map itself marks only the ridge: {finest:?}");
assert!(largest[ridge] > 0.99 && largest[five_texels_away] > 0.5, "the largest size reaches texels away from it: {largest:?}");
}
#[test]
fn a_replaced_curvature_input_is_read_at_its_own_size_only() {
let (mut fixture, layer) = ridge_fixture(128);
let detail = CurvatureDetail { mode: CurvatureMode::Edges, weights: [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0] };
let mut generator = Generator { level: 0.5, softness: 0.5, noise_amount: 0.0, detail: Some(detail), ..Generator::new(GeneratorKind::Curvature) };
generator.inputs.insert(BakedMap::Curvature, Source::Uniform([0.5; 3]));
let effect = generator_effect(&mut fixture, generator);
let row = mask_row(&mut fixture, layer, vec![effect], 120..137);
// The largest size alone would mark the ridge and texels around it; the flat input marks nothing
assert!(row.iter().all(|value| *value < 0.01), "the detail sizes of the mesh map are not read: {row:?}");
}
#[test]
fn generator_blur_softens_only_the_generator_not_the_stack_below() {
let (mut fixture, layer) = ridge_fixture(100);
let mut row_with = |blur: f32| {
let checker = Source::Procedural { pattern: Procedural::new(ProceduralKind::Checker), low: [0.0; 3], high: [1.0; 3], ramp: Vec::new() };
let below = Effect::new(fixture.project.alloc_id(), EffectKind::Fill { source: checker, projection: Projection::default() });
let mut generator = ridge_generator();
generator.global.blur = blur;
let mut lighten = generator_effect(&mut fixture, generator);
lighten.blend = BlendMode::Lighten;
mask_row(&mut fixture, layer, vec![below, lighten], 40..111)
};
// The sampled row crosses a checker edge; indices below 30 are outside the blur
let (ridge, five_texels_away, far) = (60, 55, 0..30);
let sharp = row_with(0.0);
let blurred = row_with(1.0);
assert!(sharp[ridge] > 0.99 && sharp[five_texels_away] < 0.01, "unblurred, the ridge is one texel: {sharp:?}");
assert!(blurred[ridge] < 0.99 && blurred[ridge] > blurred[five_texels_away], "the blur spreads the ridge: {blurred:?}");
assert!(blurred[five_texels_away] > 0.01, "and reaches texels away from it: {blurred:?}");
for texel in far {
assert_eq!(blurred[texel], sharp[texel], "the checker below keeps its hard edges at texel {texel}");
}
}
#[test]
fn a_lower_generator_resolution_spreads_a_ridge_over_its_cell() {
let (mut fixture, layer) = ridge_fixture(100);
let mut row_with = |factor: i8| {
let mut generator = ridge_generator();
generator.resolution.factor = factor;
let effect = generator_effect(&mut fixture, generator);
mask_row(&mut fixture, layer, vec![effect], 80..121)
};
// At one eighth resolution, each cell spans eight texels
let (ridge, beside, far) = (20, 18, 0);
let full = row_with(0);
let eighth = row_with(-3);
assert!(full[ridge] > 0.99 && full[beside] < 0.01, "at full resolution the ridge is one texel: {full:?}");
assert!(eighth[ridge] < 0.5 && eighth[beside] > 0.01, "an eighth of the resolution averages it over its cell: {eighth:?}");
assert!(eighth[far] < 0.01, "texels a few cells away stay black: {eighth:?}");
}
#[test]
fn every_caller_lists_the_same_generator_stages_whatever_resolution_it_passes() {
let custom = OutputResolution { mode: ResolutionMode::Custom, custom: 1024, factor: 0 };
let effects = [Effect::new(LayerId(1), EffectKind::Generator(Generator { resolution: custom, ..Generator::new(GeneratorKind::Dirt) }))];
// Tile and whole-set resolutions must select the same generator stage
let at_tile: Vec<usize> = neighbourhood_filters(&effects, 1024).map(|stage| stage.0).collect();
let at_set_width: Vec<usize> = neighbourhood_filters(&effects, 2048).map(|stage| stage.0).collect();
assert_eq!(at_tile, at_set_width);
assert_eq!(at_tile, [0], "a custom resolution can be coarser than some UV tile, so it is a stage");
}
#[test]
fn a_generator_input_replaced_by_a_value_is_read_instead_of_the_mesh_map() {
let mut fixture = fixture();
fixture.baked = BakedMaps { resolution: 64, maps: [(BakedMap::AmbientOcclusion, Arc::new(vec![1.0; 64 * 64]))].into() };
let layer = fill_layer(&mut fixture.project, [1.0; 3], 1.0);
let value_with = |fixture: &mut Fixture, input: Option<f32>| -> f32 {
let mut generator = Generator { level: 0.5, softness: 0.1, noise_amount: 0.0, ..Generator::new(GeneratorKind::Dirt) };
if let Some(value) = input {
generator.inputs.insert(BakedMap::AmbientOcclusion, Source::Uniform([value; 3]));
}
let mut mask = Mask::new(MaskBackground::Black);
mask.effects.push(Effect::new(fixture.project.alloc_id(), EffectKind::Generator(generator)));
fixture.project.layer_mut(layer).unwrap().mask = Some(mask);
run(fixture, None).value(Channel::BaseColor, 20, 20)[0]
};
// Dark occlusion reveals dirt while the baked white map stays clear
let (baked, black) = (value_with(&mut fixture, None), value_with(&mut fixture, Some(0.0)));
assert!(black > 0.99 && baked < black - 0.2, "baked {baked}, black input {black}");
}
#[test]
fn curvature_detail_noise_keeps_flat_areas_neutral() {
let mut fixture = fixture();
fixture.baked = BakedMaps { resolution: 64, maps: [(BakedMap::Curvature, Arc::new(vec![0.5; 64 * 64]))].into() };
let layer = fill_layer(&mut fixture.project, [1.0; 3], 1.0);
let texels: Vec<_> = (0..64).map(|x| (x, 32)).collect();
for kind in [GeneratorKind::Curvature, GeneratorKind::EdgeWear] {
for mode in CurvatureMode::ALL {
let detail = CurvatureDetail { mode, weights: [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] };
let generator = Generator { level: 0.5, softness: 0.5, noise_amount: 2.0, detail: Some(detail), ..Generator::new(kind) };
let mut mask = Mask::new(MaskBackground::Black);
mask.effects.push(Effect::new(fixture.project.alloc_id(), EffectKind::Generator(generator)));
fixture.project.layer_mut(layer).unwrap().mask = Some(mask);
let values = assert_sparse_mask_matches_image(&fixture, layer, &texels).unwrap();
let expected = if mode == CurvatureMode::Raw { 0.5 } else { 0.0 };
assert!(values.iter().all(|value| (value - expected).abs() < 0.001), "{kind:?} {mode:?} paints noise on flat curvature: {values:?}");
}
}
}
#[test]
fn raw_curvature_reads_mid_gray_without_a_curvature_map() {
let mut fixture = fixture();
let layer = fill_layer(&mut fixture.project, [1.0; 3], 1.0);
let detail = CurvatureDetail { mode: CurvatureMode::Raw, ..CurvatureDetail::default() };
let generator = Generator { level: 0.5, softness: 0.5, noise_amount: 0.0, detail: Some(detail), ..Generator::new(GeneratorKind::Curvature) };
let mut mask = Mask::new(MaskBackground::Black);
mask.effects.push(Effect::new(fixture.project.alloc_id(), EffectKind::Generator(generator)));
fixture.project.layer_mut(layer).unwrap().mask = Some(mask);
let values = assert_sparse_mask_matches_image(&fixture, layer, &[(32, 32)]).unwrap();
assert!(values.iter().all(|value| (value - 0.5).abs() < 0.01), "flat curvature is mid gray in raw mode, not black: {values:?}");
}
#[test]
fn stack_reads_neighbours_sees_blurs_in_masks_and_content() {
let mut f = fixture();
let id = fill_layer(&mut f.project, [1.0; 3], 1.0);
assert!(!stack_reads_neighbours(&f.project, 0));
let mut mask = Mask::new(MaskBackground::White);
let eid = f.project.alloc_id();
mask.effects.push(Effect::new(eid, EffectKind::Filter(Filter::Blur { radius: 8.0 })));
f.project.layer_mut(id).unwrap().mask = Some(mask);
assert!(stack_reads_neighbours(&f.project, 0));
f.project.layer_mut(id).unwrap().mask = None;
assert!(!stack_reads_neighbours(&f.project, 0));
content_fx(&mut f, id, EffectKind::Filter(Filter::Mosaic { size: 8.0 }));
assert!(stack_reads_neighbours(&f.project, 0));
}
#[test]
fn blur_filter_softens_mask_edges() {
let mut f = fixture();
let id = fill_layer(&mut f.project, [1.0, 1.0, 1.0], 1.0);
let mut mask = Mask::new(MaskBackground::Black);
let pattern = Procedural::new(ProceduralKind::Checker);
let (e1, e2) = (f.project.alloc_id(), f.project.alloc_id());
mask.effects.push(Effect::new(
e1,
EffectKind::Fill { source: Source::Procedural { pattern, low: [0.0; 3], high: [1.0; 3], ramp: Vec::new() }, projection: Projection::default() },
));
f.project.layer_mut(id).unwrap().mask = Some(mask.clone());
let hard: Vec<f32> = (0..64).map(|x| run(&f, None).value(Channel::BaseColor, x, 20)[0]).collect();
mask.effects.push(Effect::new(e2, EffectKind::Filter(Filter::Blur { radius: 64.0 })));
f.project.layer_mut(id).unwrap().mask = Some(mask);
let soft_img = run(&f, None);
let soft: Vec<f32> = (0..64).map(|x| soft_img.value(Channel::BaseColor, x, 20)[0]).collect();
let mids = |v: &[f32]| v.iter().filter(|x| **x > 0.55 && **x < 0.95).count();
assert!(
mids(&soft) > mids(&hard) + 4,
"hard {hard:?}
soft {soft:?}"
);
}
#[test]
fn groups_pass_through_with_opacity() {
let mut f = fixture();
let gid = f.project.alloc_id();
let g = Layer::new(gid, "G", LayerKind::Group { children: vec![], collapsed: false }, &[Channel::BaseColor]);
f.project.insert_layer(0, g, None, false).unwrap();
f.project.layer_mut(gid).unwrap().channels.insert(Channel::BaseColor, ChannelBlend { mode: BlendMode::Passthrough, opacity: 0.5 });
let cid = f.project.alloc_id();
let mut fill = Fill::default();
fill.sources.insert(Channel::BaseColor, Source::Uniform([1.0, 1.0, 1.0]));
let child = Layer::new(cid, "C", LayerKind::Fill(fill), &[Channel::BaseColor]);
f.project.insert_layer(0, child, Some(gid), true).unwrap();
let out = run(&f, None);
assert!(close(out.value(Channel::BaseColor, 1, 1), [0.75; 3]));
}
#[test]
fn padding_copies_nearest_covered_value() {
let mut out = Composite::new(&[Channel::Roughness], 64);
out.channels.get_mut(&Channel::Roughness).unwrap().set(10, 10, &[to_u16(0.9)]);
let mut covered = vec![false; 64 * 64];
covered[10 * 64 + 10] = true;
let dmap = DilationMap::new(&covered, 64, 64, Some(4));
pad_tiles(&mut out, &dmap, &[(0, 0)]);
assert!((out.value(Channel::Roughness, 12, 12)[0] - 0.9).abs() < 1e-3);
assert!(out.value(Channel::Roughness, 30, 30)[0] < 0.1 || !out.channels[&Channel::Roughness].is_allocated(0, 0));
}
fn content_fx(f: &mut Fixture, id: LayerId, kind: EffectKind) -> LayerId {
let eid = f.project.alloc_id();
f.project.layer_mut(id).unwrap().content_effects.push(Effect::new(eid, kind));
eid
}
#[test]
fn content_filters_hsl_and_opacity_change_layer_values() {
let mut f = fixture();
let id = fill_layer(&mut f.project, [1.0, 0.0, 0.0], 0.2);
content_fx(&mut f, id, EffectKind::Filter(Filter::Hsl { hue: 1.0 / 3.0, saturation: 0.0, lightness: 0.0 }));
let out = run(&f, None);
assert!(close(out.value(Channel::BaseColor, 5, 5), [0.0, 1.0, 0.0]), "{:?}", out.value(Channel::BaseColor, 5, 5));
assert!(close(out.value(Channel::Roughness, 5, 5), [0.2; 3]), "a hue shift leaves scalars alone");
content_fx(&mut f, id, EffectKind::Filter(Filter::Invert));
let out = run(&f, None);
assert!(close(out.value(Channel::BaseColor, 5, 5), [1.0, 0.0, 1.0]));
assert!(close(out.value(Channel::Roughness, 5, 5), [0.8; 3]));
// Hidden effects are skipped and opacity fades an effect.
let fx = &mut f.project.layer_mut(id).unwrap().content_effects;
fx[0].visible = false;
fx[1].opacity = 0.5;
let out = run(&f, None);
assert!(close(out.value(Channel::BaseColor, 5, 5), [0.5; 3]));
assert!(close(out.value(Channel::Roughness, 5, 5), [0.5; 3]));
}
#[test]
fn hsl_on_a_mask_changes_its_lightness() {
let mut f = fixture();
let id = fill_layer(&mut f.project, [1.0; 3], 1.0);
let mut mask = Mask::new(MaskBackground::White);
mask.effects.push(Effect::new(f.project.alloc_id(), EffectKind::Filter(Filter::Hsl { hue: 0.3, saturation: 1.0, lightness: -0.5 })));
f.project.layer_mut(id).unwrap().mask = Some(mask);
assert!(close(run(&f, None).value(Channel::BaseColor, 5, 5), [0.75; 3]));
}
#[test]
fn content_blur_softens_fill_edges() {
let mut f = fixture();
let id = f.project.alloc_id();
let mut fill = Fill::default();
fill.sources.insert(
Channel::Roughness,
Source::Procedural { pattern: Procedural::new(ProceduralKind::Checker), low: [0.0; 3], high: [1.0; 3], ramp: Vec::new() },
);
f.project.insert_layer(0, Layer::new(id, "F", LayerKind::Fill(fill), &[Channel::Roughness]), None, false).unwrap();
let row = |f: &Fixture| {
let out = run(f, None);
(0..64).map(|x| out.value(Channel::Roughness, x, 20)[0]).collect::<Vec<f32>>()
};
let hard = row(&f);
content_fx(&mut f, id, EffectKind::Filter(Filter::Blur { radius: 64.0 }));
let soft = row(&f);
let mids = |v: &[f32]| v.iter().filter(|x| **x > 0.05 && **x < 0.95).count();
assert!(mids(&soft) > mids(&hard) + 4, "hard {hard:?}\nsoft {soft:?}");
assert!(soft.iter().all(|v| (0.0..=1.0).contains(v)));
}
#[test]
fn high_pass_edge_detect_directional_warp_grayscale_and_normal_invert() {
// Uniform content gives mid gray high pass and black edge detection
let mut f = fixture();
let id = fill_layer(&mut f.project, [1.0, 0.0, 0.0], 0.2);
let hp = content_fx(&mut f, id, EffectKind::Filter(Filter::HighPass { radius: 64.0 }));
let out = run(&f, None);
assert!(close(out.value(Channel::BaseColor, 30, 30), [0.5; 3]), "{:?}", out.value(Channel::BaseColor, 30, 30));
assert!(close(out.value(Channel::Roughness, 30, 30), [0.5; 3]));
f.project.layer_mut(id).unwrap().content_effects.retain(|e| e.id != hp);
content_fx(&mut f, id, EffectKind::Filter(Filter::EdgeDetect { width: 64.0 }));
assert!(close(run(&f, None).value(Channel::Roughness, 30, 30), [0.0; 3]));
// A checker's borders light up while cell interiors stay black
let mut f = fixture();
let id = f.project.alloc_id();
let mut fill = Fill::default();
fill.sources.insert(
Channel::Roughness,
Source::Procedural { pattern: Procedural::new(ProceduralKind::Checker), low: [0.0; 3], high: [1.0; 3], ramp: Vec::new() },
);
f.project.insert_layer(0, Layer::new(id, "F", LayerKind::Fill(fill), &[Channel::Roughness]), None, false).unwrap();
let plain = run(&f, None);
let edges = content_fx(&mut f, id, EffectKind::Filter(Filter::EdgeDetect { width: 32.0 }));
let out = run(&f, None);
let vals: Vec<f32> = (0..64).flat_map(|y| (0..64).map(move |x| (x, y))).map(|(x, y)| out.value(Channel::Roughness, x, y)[0]).collect();
assert!(vals.iter().all(|v| (0.0..=1.0).contains(v)));
assert!(vals.iter().filter(|v| **v > 0.5).count() > 64 && vals.iter().filter(|v| **v < 0.01).count() > 64, "{vals:?}");
f.project.layer_mut(id).unwrap().content_effects.retain(|e| e.id != edges);
content_fx(&mut f, id, EffectKind::Filter(Filter::DirectionalWarp { intensity: 256.0, angle: 90.0, scale: 4.0, seed: 3 }));
let warped = run(&f, None);
let differs = (0..64).any(|y| (0..64).any(|x| (warped.value(Channel::Roughness, x, y)[0] - plain.value(Channel::Roughness, x, y)[0]).abs() > 0.2));
assert!(differs, "the warp moves the checker");
// Point filters
assert!(close(Filter::Grayscale.point(ChannelKind::Color, [1.0, 0.0, 0.0]).unwrap(), [lum([1.0, 0.0, 0.0]); 3]));
assert_eq!(Filter::Grayscale.point(ChannelKind::Scalar, [0.3; 3]), Some([0.3; 3]));
assert_eq!(Filter::NormalInvert.point(ChannelKind::NormalMap, [0.5, 0.25, 1.0]), Some([0.5, 0.75, 1.0]));
assert_eq!(Filter::NormalInvert.point(ChannelKind::Color, [0.5, 0.25, 1.0]), Some([0.5, 0.25, 1.0]));
// Replace color shifts near colors while far colors and scalars stay
let rc = Filter::ReplaceColor { from: [0.8, 0.1, 0.1], to: [0.1, 0.1, 0.8], tolerance: 0.1, softness: 0.1 };
assert!(close(rc.point(ChannelKind::Color, [0.85, 0.1, 0.1]).unwrap(), [0.15, 0.1, 0.8]));
assert!(close(rc.point(ChannelKind::Color, [0.1, 0.8, 0.1]).unwrap(), [0.1, 0.8, 0.1]));
let half = rc.point(ChannelKind::Color, [0.8, 0.1 + 0.15 * 3f32.sqrt(), 0.1]).unwrap();
assert!((half[2] - 0.45).abs() < 0.02, "halfway through the softness: {half:?}");
assert_eq!(rc.point(ChannelKind::Scalar, [0.8; 3]), Some([0.8; 3]));
}
#[test]
fn bevel_glow_and_mosaic() {
let checker = |f: &mut Fixture| {
let id = f.project.alloc_id();
let mut fill = Fill::default();
fill.sources.insert(
Channel::Roughness,
Source::Procedural { pattern: Procedural::new(ProceduralKind::Checker), low: [0.0; 3], high: [1.0; 3], ramp: Vec::new() },
);
f.project.insert_layer(0, Layer::new(id, "F", LayerKind::Fill(fill), &[Channel::Roughness]), None, false).unwrap();
id
};
let values = |f: &Fixture| {
let out = run(f, None);
(0..64 * 64).map(|i| out.value(Channel::Roughness, i % 64, i / 64)[0]).collect::<Vec<f32>>()
};
let mut f = fixture();
let id = checker(&mut f);
let plain = values(&f);
// Bevel stays below the shape and turns edges into ramps
let fx = content_fx(&mut f, id, EffectKind::Filter(Filter::Bevel { width: 128.0 }));
let bevel = values(&f);
let mids = |v: &[f32]| v.iter().filter(|x| **x > 0.05 && **x < 0.95).count();
assert!(bevel.iter().zip(&plain).all(|(b, p)| *b <= p + 1e-4 && *b >= 0.0), "a bevel only lowers values");
assert!(mids(&bevel) > mids(&plain) + 64, "{} vs {}", mids(&bevel), mids(&plain));
// Mosaic reduces changes between adjacent texels
f.project.layer_mut(id).unwrap().content_effects.retain(|e| e.id != fx);
let fx = content_fx(&mut f, id, EffectKind::Filter(Filter::Mosaic { size: 768.0 }));
let mosaic = values(&f);
let steps = |v: &[f32]| v.windows(2).filter(|w| (w[0] - w[1]).abs() > 0.01).count();
assert!(steps(&mosaic) < steps(&plain), "{} vs {}", steps(&mosaic), steps(&plain));
assert!(mosaic.iter().all(|v| (0.0..=1.0).contains(v)));
// Glow on uniform content adds its own blur
f.project.layer_mut(id).unwrap().content_effects.retain(|e| e.id != fx);
let mut f = fixture();
let id = fill_layer(&mut f.project, [0.1; 3], 0.2);
content_fx(&mut f, id, EffectKind::Filter(Filter::Glow { radius: 32.0, amount: 1.0 }));
assert!(close(run(&f, None).value(Channel::Roughness, 30, 30), [0.4; 3]));
}
#[test]
fn baked_lighting_lights_the_base_color_by_the_normal() {
let lit = |elevation: f32| {
let mut f = fixture();
let id = fill_layer(&mut f.project, [0.5; 3], 0.3);
let fx = Filter::BakedLighting { azimuth: 0.0, elevation, light: 0.6, ambient: 0.4, occlusion: 1.0 };
content_fx(&mut f, id, EffectKind::Filter(fx));
let out = run(&f, None);
(out.value(Channel::BaseColor, 30, 30), out.value(Channel::Roughness, 30, 30))
};
let n = primitives::plane(2.0, 2).normals[0];
// Facing the light adds illumination; facing away keeps ambient only
let (toward, rough) = lit(if n.y > 0.0 { 90.0 } else { -90.0 });
assert!(close(toward, [0.5; 3]) && close(rough, [0.3; 3]), "{toward:?} {rough:?}");
let (away, _) = lit(if n.y > 0.0 { -90.0 } else { 90.0 });
assert!(close(away, [0.2; 3]), "{away:?}");
let f = Filter::BakedLighting { azimuth: 0.0, elevation: 0.0, light: 0.0, ambient: 1.0, occlusion: 0.5 };
assert_eq!(f.baked_light([0.0, 1.0, 0.0], 0.2), Some(0.6), "half the occlusion");
assert_eq!(Filter::Invert.baked_light([0.0; 3], 1.0), None);
}
#[test]
fn geometry_masks_show_layers_on_chosen_parts_only() {
let mut f = fixture();
// The plane's material spans both triangle groups
let n = f.mesh.indices.len() as u32 / 6 * 3;
f.mesh.submeshes = vec![
texturecraft_geom::SubMesh { name: "Lid".into(), material: 0, start: 0, count: n },
texturecraft_geom::SubMesh { name: "Body".into(), material: 0, start: n, count: f.mesh.indices.len() as u32 - n },
];
let id = fill_layer(&mut f.project, [1.0, 0.0, 0.0], 0.2);
let red = |f: &Fixture| {
let out = run(f, None);
(0..64 * 64).filter(|i| close(out.value(Channel::BaseColor, i % 64, i / 64), [1.0, 0.0, 0.0])).count()
};
let all = red(&f);
f.project.layer_mut(id).unwrap().geometry_mask = Some(vec!["Lid".into()]);
let lid = red(&f);
f.project.layer_mut(id).unwrap().geometry_mask = Some(vec!["Body".into()]);
let body = red(&f);
assert!(lid > 0 && body > 0 && lid + body == all, "{lid} + {body} of {all}");
f.project.layer_mut(id).unwrap().geometry_mask = Some(Vec::new());
assert_eq!(red(&f), 0, "no parts: hidden everywhere");
}
#[test]
fn content_paint_and_fill_effects_add_to_layers() {
let mut f = fixture();
let id = f.project.alloc_id();
f.project.insert_layer(0, Layer::new(id, "P", LayerKind::Paint, &[Channel::BaseColor, Channel::Roughness]), None, false).unwrap();
let mut material = Fill::default();
material.sources.insert(Channel::Roughness, Source::Uniform([0.2; 3]));
content_fx(&mut f, id, EffectKind::Material(material));
let paint = content_fx(&mut f, id, EffectKind::Paint);
// Roughness 0.9 is painted at half coverage
f.pixels.layer_mut(paint, Channel::Roughness, (64, 64)).set(3, 3, &[to_u16(0.45), to_u16(0.5)]);
let out = run(&f, None);
assert!(close(out.value(Channel::Roughness, 10, 10), [0.2; 3]), "the fill effect covers the empty paint layer");
assert!(close(out.value(Channel::Roughness, 3, 3), [0.55; 3]), "{:?}", out.value(Channel::Roughness, 3, 3));
assert!(close(out.value(Channel::BaseColor, 3, 3), [0.5; 3]), "channels without a source stay untouched");
// Flattening bakes in the content effects
let images = Default::default();
let inp = Inputs {
project: &f.project,
ts: 0,
mesh: &f.mesh,
gbuf: &f.gbuf,
pixels: &f.pixels,
baked: &f.baked,
block_scales: f.project.texture_sets[0].block_scales(),
preview: None,
images: &images,
bounds: f.mesh.bounds(),
};
let flat = flatten_layer(&inp, id, &all_tiles(64, 64)).unwrap();
assert!(flat.iter().all(|(c, _, _)| *c == Channel::Roughness));
let (_, _, data) = flat.iter().find(|(_, t, _)| *t == (0, 0)).unwrap();
let o = 3 * TILE as usize + 3;
assert!((from_u16(data[o * 2]) - 0.55).abs() < 1e-3 && (from_u16(data[o * 2 + 1]) - 1.0).abs() < 1e-3);
}
#[test]
fn anchors_feed_masks_above_in_stack_order() {
let mut f = fixture();
let low = f.project.alloc_id();
let mut fill = Fill::default();
fill.sources.insert(Channel::Height, Source::Uniform([0.4; 3]));
f.project.insert_layer(0, Layer::new(low, "Low", LayerKind::Fill(fill), &[Channel::Height]), None, false).unwrap();
let anchor = content_fx(&mut f, low, EffectKind::Anchor);
let top = fill_layer(&mut f.project, [1.0; 3], 0.5);
let mut mask = Mask::new(MaskBackground::Black);
let source = Source::Anchor { anchor, channel: Channel::Height, ramp: Vec::new() };
mask.effects.push(Effect::new(f.project.alloc_id(), EffectKind::Fill { source, projection: Projection::default() }));
f.project.layer_mut(top).unwrap().mask = Some(mask.clone());
assert!(close(run(&f, None).value(Channel::BaseColor, 5, 5), [0.7; 3]));
// The field pre-pass reads anchors under blur, preserving flat height
mask.effects.push(Effect::new(f.project.alloc_id(), EffectKind::Filter(Filter::Blur { radius: 32.0 })));
f.project.layer_mut(top).unwrap().mask = Some(mask);
assert!(close(run(&f, None).value(Channel::BaseColor, 5, 5), [0.7; 3]));
// An anchor above its reader is not evaluated yet, so it reads the channel default
f.project.move_layer(low, 1).unwrap();
assert!(close(run(&f, None).value(Channel::BaseColor, 5, 5), [0.5; 3]));
}
/// A white fill layer on top whose mask reads `anchor` (any channel: a mask anchor is gray).
fn anchor_reader(fixture: &mut Fixture, anchor: LayerId) -> LayerId {
let top = fill_layer(&mut fixture.project, [1.0; 3], 0.5);
let mut mask = Mask::new(MaskBackground::Black);
let source = Source::Anchor { anchor, channel: Channel::Roughness, ramp: Vec::new() };
mask.effects.push(Effect::new(fixture.project.alloc_id(), EffectKind::Fill { source, projection: Projection::default() }));
fixture.project.layer_mut(top).unwrap().mask = Some(mask);
top
}
#[test]
fn mask_anchors_record_the_mask_value_at_their_place() {
let mut fixture = fixture();
let low = fill_layer(&mut fixture.project, [0.0; 3], 0.5);
let (gray, anchor, full) = (fixture.project.alloc_id(), fixture.project.alloc_id(), fixture.project.alloc_id());
let mut mask = Mask::new(MaskBackground::Black);
mask.effects.push(Effect::new(gray, EffectKind::Fill { source: Source::Uniform([0.4; 3]), projection: Projection::default() }));
mask.effects.push(Effect::new(anchor, EffectKind::Anchor));
mask.effects.push(Effect::new(full, EffectKind::Fill { source: Source::Uniform([1.0; 3]), projection: Projection::default() }));
fixture.project.layer_mut(low).unwrap().mask = Some(mask.clone());
anchor_reader(&mut fixture, anchor);
// The low layer shows fully (black), the top one at the 0.4 the anchor recorded
assert!(close(run(&fixture, None).value(Channel::BaseColor, 5, 5), [0.4; 3]));
// Under a blur precomputed over the region the anchor still records its own place
mask.effects.push(Effect::new(fixture.project.alloc_id(), EffectKind::Filter(Filter::Blur { radius: 32.0 })));
fixture.project.layer_mut(low).unwrap().mask = Some(mask.clone());
let color = run(&fixture, None).value(Channel::BaseColor, 5, 5);
assert!(close(color, [0.4; 3]), "{color:?}");
// An empty paint layer still records its mask anchor for the layer above
fixture.project.layer_mut(low).unwrap().kind = LayerKind::Paint;
let color = run(&fixture, None).value(Channel::BaseColor, 5, 5);
assert!(close(color, [0.7; 3]), "{color:?}");
}
#[test]
fn mask_anchor_between_filters_keeps_the_filtered_value() {
let mut fixture = fixture();
fixture.gbuf = UvGBuffer::new(&fixture.mesh, 0, 128, 128);
fixture.project.texture_sets[0].resolution = 128;
let lower = fill_layer(&mut fixture.project, [0.0; 3], 1.0);
let anchor = fixture.project.alloc_id();
let mut mask = Mask::new(MaskBackground::Black);
let checker = Source::Procedural { pattern: Procedural::new(ProceduralKind::Checker), low: [0.0; 3], high: [1.0; 3], ramp: Vec::new() };
mask.effects.push(Effect::new(fixture.project.alloc_id(), EffectKind::Fill { source: checker, projection: Projection::default() }));
mask.effects.push(Effect::new(fixture.project.alloc_id(), EffectKind::Filter(Filter::Blur { radius: 64.0 })));
mask.effects.push(Effect::new(anchor, EffectKind::Anchor));
fixture.project.layer_mut(lower).unwrap().mask = Some(mask.clone());
let reader = anchor_reader(&mut fixture, anchor);
let texels: Vec<_> = (0..128).map(|x| (x, 63)).collect();
let expected = assert_sparse_mask_matches_image(&fixture, reader, &texels).unwrap();
assert!(expected.iter().any(|value| *value > 0.1 && *value < 0.9), "the anchor records a softened checker");
mask.effects.push(Effect::new(fixture.project.alloc_id(), EffectKind::Filter(Filter::Blur { radius: 128.0 })));
fixture.project.layer_mut(lower).unwrap().mask = Some(mask);
let actual = assert_sparse_mask_matches_image(&fixture, reader, &texels).unwrap();
assert_eq!(actual, expected, "a filter above the anchor must not change its recorded value");
}
#[test]
fn generator_micro_detail_follows_the_anchor_height() {
let mut fixture = fixture();
let low = fixture.project.alloc_id();
let mut fill = Fill::default();
fill.sources.insert(Channel::Height, Source::Uniform([0.5; 3]));
fixture.project.insert_layer(0, Layer::new(low, "Bumps", LayerKind::Fill(fill), &[Channel::Height]), None, false).unwrap();
let anchor = content_fx(&mut fixture, low, EffectKind::Anchor);
let top = fill_layer(&mut fixture.project, [1.0; 3], 0.5);
let mut generator = Generator { level: 0.5, softness: 0.5, noise_amount: 0.0, detail: None, ..Generator::new(GeneratorKind::Curvature) };
let with = |fixture: &mut Fixture, generator: &Generator| {
let mut mask = Mask::new(MaskBackground::Black);
mask.effects.push(Effect::new(LayerId(900), EffectKind::Generator(generator.clone())));
fixture.project.layer_mut(top).unwrap().mask = Some(mask);
run(fixture, None).value(Channel::BaseColor, 5, 5)[0]
};
// No curvature map: flat mid gray, so the mask is 0.5 and the base color 0.75
let flat = with(&mut fixture, &generator);
assert!((flat - 0.75).abs() < 0.02, "{flat}");
// Raised height reads as an edge
generator.micro = Some(MicroDetail { anchor, amount: 1.0 });
assert!(with(&mut fixture, &generator) > flat + 0.2);
// Recessed height reads as a cavity; dirt gathers there
if let LayerKind::Fill(fill) = &mut fixture.project.layer_mut(low).unwrap().kind {
fill.sources.insert(Channel::Height, Source::Uniform([-0.5; 3]));
}
assert!(with(&mut fixture, &generator) < flat - 0.2);
let dirt =
Generator { level: 0.5, softness: 0.5, noise_amount: 0.0, micro: Some(MicroDetail { anchor, amount: 1.0 }), ..Generator::new(GeneratorKind::Dirt) };
let plain = Generator { micro: None, ..dirt.clone() };
assert!(with(&mut fixture, &dirt) > with(&mut fixture, &plain) + 0.2);
// A hostile amount does nothing
generator.micro = Some(MicroDetail { anchor, amount: f32::NAN });
assert!((with(&mut fixture, &generator) - flat).abs() < 0.02);
}
#[test]
fn curvature_modes_classify_raised_and_recessed_micro_height() {
let mut fixture = fixture();
fixture.baked = BakedMaps { resolution: 64, maps: [(BakedMap::Curvature, Arc::new(vec![0.5; 64 * 64]))].into() };
let lower = fixture.project.alloc_id();
let mut fill = Fill::default();
fill.sources.insert(Channel::Height, Source::Uniform([0.5; 3]));
fixture.project.insert_layer(0, Layer::new(lower, "Bumps", LayerKind::Fill(fill), &[Channel::Height]), None, false).unwrap();
let anchor = content_fx(&mut fixture, lower, EffectKind::Anchor);
let top = fill_layer(&mut fixture.project, [1.0; 3], 0.5);
for kind in [GeneratorKind::Curvature, GeneratorKind::EdgeWear] {
for (height, mode, responds) in [
(0.5, CurvatureMode::Edges, true),
(-0.5, CurvatureMode::Edges, false),
(0.5, CurvatureMode::Cavities, false),
(-0.5, CurvatureMode::Cavities, true),
(0.5, CurvatureMode::Both, true),
(-0.5, CurvatureMode::Both, true),
] {
if let LayerKind::Fill(fill) = &mut fixture.project.layer_mut(lower).unwrap().kind {
fill.sources.insert(Channel::Height, Source::Uniform([height; 3]));
}
let detail = CurvatureDetail { mode, weights: [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] };
let generator = Generator {
level: 0.5,
softness: 0.5,
noise_amount: 0.0,
detail: Some(detail),
micro: Some(MicroDetail { anchor, amount: 1.0 }),
..Generator::new(kind)
};
let mut mask = Mask::new(MaskBackground::Black);
mask.effects.push(Effect::new(fixture.project.alloc_id(), EffectKind::Generator(generator)));
fixture.project.layer_mut(top).unwrap().mask = Some(mask);
let value = run(&fixture, None).value(Channel::BaseColor, 5, 5)[0];
let expected = if responds { 0.75 } else { 0.5 };
assert!((value - expected).abs() < 0.02, "{kind:?} {mode:?} height {height}: {value}");
}
}
}
#[test]
fn decal_fills_cover_only_their_frame_and_image_alpha() {
let mut f = fixture();
let s = f.gbuf.surface(&f.mesh, 32 * 64 + 32).unwrap();
let d = texturecraft_core::Decal {
center: s.pos.to_array(),
normal: s.nrm.to_array(),
up: s.nrm.any_orthonormal_vector().to_array(),
size: [1.0, 1.0],
rotation: 0.0,
offset: [0.0; 2],
depth: 0.5,
symmetry: None,
flip: [false; 2],
};
let id = f.project.alloc_id();
let mut fill = Fill { projection: Projection::Decal(d), ..Fill::default() };
fill.sources.insert(Channel::BaseColor, Source::image("decal"));
f.project.insert_layer(0, Layer::new(id, "Decal", LayerKind::Fill(fill), &[Channel::BaseColor]), None, false).unwrap();
let composite = |alpha: f32| {
let img = crate::store::ImageRes { width: 2, height: 2, rgba: vec![[1.0, 0.0, 0.0, alpha]; 4], srgb: false };
let images: ImageStore = [("decal".to_string(), std::sync::Arc::new(img))].into_iter().collect();
let inp = Inputs {
project: &f.project,
ts: 0,
mesh: &f.mesh,
gbuf: &f.gbuf,
pixels: &f.pixels,
baked: &f.baked,
block_scales: f.project.texture_sets[0].block_scales(),
preview: None,
images: &images,
bounds: f.mesh.bounds(),
};
let mut out = Composite::new(&f.project.texture_sets[0].channel_list(), 64);
composite_tiles(&inp, &mut out, &all_tiles(64, 64));
out
};
let out = composite(1.0);
assert!(close(out.value(Channel::BaseColor, 32, 32), [1.0, 0.0, 0.0]), "{:?}", out.value(Channel::BaseColor, 32, 32));
assert!(close(out.value(Channel::BaseColor, 2, 2), [0.5; 3]), "outside the frame");
let half = composite(0.5);
assert!(close(half.value(Channel::BaseColor, 32, 32), [0.75, 0.25, 0.25]), "the image alpha shapes the decal");
}
/// Composites a cube with a decal of a four-colored image, and checks each texel of the
/// faces picked by `expect` against the image at the coordinates it gives (None: the texel
/// is not part of the check). Returns how many texels were checked.
fn cube_decal_texels(d: texturecraft_core::Decal, expect: impl Fn(Vec3, Vec3) -> Option<Option<(f32, f32)>>) -> usize {
let mesh = primitives::cube(2.0);
let gbuf = UvGBuffer::new(&mesh, 0, 64, 64);
let mut project = Project::new("t", "builtin:cube");
project.texture_sets.push(TextureSet::new("Cube", 0, 64));
let id = project.alloc_id();
let mut fill = Fill { projection: Projection::Decal(d), ..Fill::default() };
fill.sources.insert(Channel::BaseColor, Source::image("decal"));
project.insert_layer(0, Layer::new(id, "Decal", LayerKind::Fill(fill), &[Channel::BaseColor]), None, false).unwrap();
// Top left red, top right blue, bottom left green, bottom right yellow
let img = crate::store::ImageRes {
width: 2,
height: 2,
rgba: vec![[1.0, 0.0, 0.0, 1.0], [0.0, 0.0, 1.0, 1.0], [0.0, 1.0, 0.0, 1.0], [1.0, 1.0, 0.0, 1.0]],
srgb: false,
};
let images: ImageStore = [("decal".to_string(), std::sync::Arc::new(img.clone()))].into_iter().collect();
let pixels = PixelStore::default();
let baked = BakedMaps::default();
let inp = Inputs {
project: &project,
ts: 0,
mesh: &mesh,
gbuf: &gbuf,
pixels: &pixels,
baked: &baked,
block_scales: project.texture_sets[0].block_scales(),
preview: None,
images: &images,
bounds: mesh.bounds(),
};
let mut out = Composite::new(&project.texture_sets[0].channel_list(), 64);
composite_tiles(&inp, &mut out, &all_tiles(64, 64));
let mut checked = 0;
for i in 0..64 * 64 {
let Some(surface) = gbuf.surface(&mesh, i) else { continue };
let Some(want) = expect(surface.pos, surface.nrm) else { continue };
let got = out.value(Channel::BaseColor, (i % 64) as u32, (i / 64) as u32);
let want = want.map_or([0.5; 3], |(u, v)| {
let c = img.sample(u, v);
[c[0], c[1], c[2]]
});
assert!(close(got, want), "texel at {:?} on a face turned to {:?}: {got:?}, expected {want:?}", surface.pos, surface.nrm);
checked += 1;
}
checked
}
/// A 1 by 1 decal on the cube's +X face (the image's right runs toward -Z, its up toward +Y)
fn cube_decal(center: [f32; 3], size: f32, symmetry: Option<texturecraft_core::DecalSymmetry>) -> texturecraft_core::Decal {
texturecraft_core::Decal {
center,
normal: [1.0, 0.0, 0.0],
up: [0.0, 1.0, 0.0],
size: [size; 2],
rotation: 0.0,
offset: [0.0; 2],
depth: 0.5,
symmetry,
flip: [false; 2],
}
}
/// What the decal of `size` centered at (cy, cz) on the +X face gives the point (y, z) of
/// that face: the image coordinates well inside the frame, None for a bare texel clearly
/// outside it, and None for texels near its edge (not part of the checks).
fn face_expect(y: f32, z: f32, (cy, cz): (f32, f32), size: f32) -> Option<Option<(f32, f32)>> {
let (u, v) = (0.5 - (z - cz) / size, 0.5 - (y - cy) / size);
let off = (u - 0.5).abs().max((v - 0.5).abs());
if off < 0.4 {
Some(Some((u, v)))
} else if off > 0.6 {
Some(None)
} else {
None
}
}
#[test]
fn a_mirrored_decal_lands_on_the_opposite_cube_face_with_its_flip() {
use texturecraft_core::{DecalFlip, DecalSymmetry};
let at = (0.1, -0.2);
let on_x = |flip| {
cube_decal_texels(cube_decal([1.0, at.0, at.1], 1.0, Some(DecalSymmetry { axis: 0, flip, offset: 0.0 })), |p, n| {
if n.x > 0.99 {
face_expect(p.y, p.z, at, 1.0)
} else if n.x < -0.99 {
// The mirror image: the point's reflection, then the flip of the copy
face_expect(p.y, p.z, at, 1.0).map(|texel| {
texel.map(|(u, v)| match flip {
DecalFlip::None => (u, v),
DecalFlip::U => (1.0 - u, v),
DecalFlip::V => (u, 1.0 - v),
})
})
} else {
Some(None)
}
})
};
for flip in [DecalFlip::None, DecalFlip::U, DecalFlip::V] {
assert!(on_x(flip) > 800, "{flip:?}: most of the cube was checked");
}
// No symmetry: the -X face stays bare
let bare = cube_decal_texels(cube_decal([1.0, at.0, at.1], 1.0, None), |p, n| if n.x > 0.99 { face_expect(p.y, p.z, at, 1.0) } else { Some(None) });
assert!(bare > 800);
// Mirrored across Z, the copy sits on the same face on the other side of the Z = 0 plane
let at = (0.1, -0.5);
let across_z = Some(DecalSymmetry { axis: 2, flip: DecalFlip::None, offset: 0.0 });
let on_z = cube_decal_texels(cube_decal([1.0, at.0, at.1], 0.4, across_z), |p, n| {
if n.x > 0.99 {
match (face_expect(p.y, p.z, at, 0.4), face_expect(p.y, -p.z, at, 0.4)) {
(Some(Some(texel)), _) | (_, Some(Some(texel))) => Some(Some(texel)),
(Some(None), Some(None)) => Some(None),
_ => None,
}
} else {
Some(None)
}
});
assert!(on_z > 800);
}
#[test]
fn the_mirror_plane_can_be_moved_along_its_axis() {
use texturecraft_core::{DecalFlip, DecalSymmetry};
// Mirrored across Z with the plane at z = 0.3: a decal at z = -0.2 gets its copy at z = 0.8
let at = (0.1, -0.2);
let moved = Some(DecalSymmetry { axis: 2, flip: DecalFlip::None, offset: 0.3 });
let checked = cube_decal_texels(cube_decal([1.0, at.0, at.1], 0.4, moved), |p, n| {
if n.x > 0.99 {
match (face_expect(p.y, p.z, at, 0.4), face_expect(p.y, 0.6 - p.z, at, 0.4)) {
(Some(Some(texel)), _) | (_, Some(Some(texel))) => Some(Some(texel)),
(Some(None), Some(None)) => Some(None),
_ => None,
}
} else {
Some(None)
}
});
assert!(checked > 800);
}
#[test]
fn moving_the_decal_moves_its_mirrored_copy() {
use texturecraft_core::{DecalFlip, DecalSymmetry};
let symmetry = Some(DecalSymmetry { axis: 0, flip: DecalFlip::None, offset: 0.0 });
for at in [(0.5, 0.3), (-0.4, -0.5)] {
let checked =
cube_decal_texels(
cube_decal([1.0, at.0, at.1], 0.4, symmetry),
|p, n| {
if n.x.abs() > 0.99 { face_expect(p.y, p.z, at, 0.4) } else { Some(None) }
},
);
assert!(checked > 800, "{at:?}");
}
}
#[test]
fn flipping_a_decal_mirrors_its_image_inside_the_frame() {
let mut f = fixture();
let s = f.gbuf.surface(&f.mesh, 32 * 64 + 32).unwrap();
// The frame's center sits a quarter of its width to the right of the texel, so the texel reads the image's left half
let d = texturecraft_core::Decal {
center: s.pos.to_array(),
normal: s.nrm.to_array(),
up: s.nrm.any_orthonormal_vector().to_array(),
size: [1.0, 1.0],
rotation: 0.0,
offset: [0.25, 0.0],
depth: 0.5,
symmetry: None,
flip: [false; 2],
};
let id = f.project.alloc_id();
let mut fill = Fill { projection: Projection::Decal(d), ..Fill::default() };
fill.sources.insert(Channel::BaseColor, Source::image("decal"));
f.project.insert_layer(0, Layer::new(id, "Decal", LayerKind::Fill(fill), &[Channel::BaseColor]), None, false).unwrap();
// Left half red, right half blue
let img = crate::store::ImageRes { width: 2, height: 1, rgba: vec![[1.0, 0.0, 0.0, 1.0], [0.0, 0.0, 1.0, 1.0]], srgb: false };
let images: ImageStore = [("decal".to_string(), std::sync::Arc::new(img))].into_iter().collect();
let texel = |f: &Fixture, flip: [bool; 2]| {
let mut project = f.project.clone();
if let Ok(layer) = project.layer_mut(id)
&& let LayerKind::Fill(fill) = &mut layer.kind
{
fill.projection = Projection::Decal(texturecraft_core::Decal { flip, ..d });
}
let inp = Inputs {
project: &project,
ts: 0,
mesh: &f.mesh,
gbuf: &f.gbuf,
pixels: &f.pixels,
baked: &f.baked,
block_scales: project.texture_sets[0].block_scales(),
preview: None,
images: &images,
bounds: f.mesh.bounds(),
};
let mut out = Composite::new(&project.texture_sets[0].channel_list(), 64);
composite_tiles(&inp, &mut out, &all_tiles(64, 64));
out.value(Channel::BaseColor, 32, 32)
};
assert!(close(texel(&f, [false, false]), [1.0, 0.0, 0.0]), "the left half shows red");
assert!(close(texel(&f, [true, false]), [0.0, 0.0, 1.0]), "Flip U shows the right half there");
assert!(close(texel(&f, [false, true]), [1.0, 0.0, 0.0]), "Flip V leaves the left half");
}
#[test]
fn anchors_read_colors_as_gray_in_fill_layers() {
let mut f = fixture();
let low = fill_layer(&mut f.project, [0.2, 0.4, 0.6], 0.5);
let anchor = content_fx(&mut f, low, EffectKind::Anchor);
let id = f.project.alloc_id();
let mut fill = Fill::default();
fill.sources.insert(Channel::Roughness, Source::Anchor { anchor, channel: Channel::BaseColor, ramp: Vec::new() });
f.project.insert_layer(0, Layer::new(id, "Top", LayerKind::Fill(fill), &[Channel::Roughness]), None, false).unwrap();
let expect = texturecraft_core::lum([0.2, 0.4, 0.6]);
assert!(close(run(&f, None).value(Channel::Roughness, 9, 9), [expect; 3]));
}
const RAMP: [[f32; 3]; 3] = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];
#[test]
fn an_anchor_gradient_map_recolors_the_stack_below_by_its_lightness() {
// The stops at 0, 0.5 and 1, and halfway between them
for (gray, want) in [(0.0, [1.0, 0.0, 0.0]), (0.25, [0.5, 0.5, 0.0]), (0.5, [0.0, 1.0, 0.0]), (0.75, [0.0, 0.5, 0.5]), (1.0, [0.0, 0.0, 1.0])] {
let mut f = fixture();
let low = fill_layer(&mut f.project, [gray; 3], 0.5);
let anchor = content_fx(&mut f, low, EffectKind::Anchor);
let id = f.project.alloc_id();
let mut fill = Fill::default();
fill.sources.insert(Channel::BaseColor, Source::Anchor { anchor, channel: Channel::BaseColor, ramp: RAMP.to_vec() });
// A scalar channel reading the same anchor with stops keeps reading its gray
fill.sources.insert(Channel::Roughness, Source::Anchor { anchor, channel: Channel::BaseColor, ramp: RAMP.to_vec() });
fill.sources.insert(Channel::Metallic, Source::Uniform([0.3; 3]));
let channels = [Channel::BaseColor, Channel::Roughness, Channel::Metallic];
f.project.insert_layer(0, Layer::new(id, "Top", LayerKind::Fill(fill), &channels), None, false).unwrap();
let out = run(&f, None);
assert!(close(out.value(Channel::BaseColor, 9, 9), want), "gray {gray}: {:?}", out.value(Channel::BaseColor, 9, 9));
assert!(close(out.value(Channel::Roughness, 9, 9), [gray; 3]), "gray {gray}: {:?}", out.value(Channel::Roughness, 9, 9));
assert!(close(out.value(Channel::Metallic, 9, 9), [0.3; 3]));
}
}
#[test]
fn an_anchor_gradient_map_reads_signed_height_from_minus_one_to_one() {
for (height, want) in [(-1.0, [1.0, 0.0, 0.0]), (0.0, [0.0, 1.0, 0.0]), (0.5, [0.0, 0.5, 0.5])] {
let mut f = fixture();
let low = f.project.alloc_id();
let mut below = Fill::default();
below.sources.insert(Channel::Height, Source::Uniform([height; 3]));
f.project.insert_layer(0, Layer::new(low, "Below", LayerKind::Fill(below), &[Channel::Height]), None, false).unwrap();
let anchor = content_fx(&mut f, low, EffectKind::Anchor);
let id = f.project.alloc_id();
let mut fill = Fill::default();
fill.sources.insert(Channel::BaseColor, Source::Anchor { anchor, channel: Channel::Height, ramp: RAMP.to_vec() });
f.project.insert_layer(0, Layer::new(id, "Top", LayerKind::Fill(fill), &[Channel::BaseColor]), None, false).unwrap();
let out = run(&f, None);
assert!(close(out.value(Channel::BaseColor, 9, 9), want), "height {height}: {:?}", out.value(Channel::BaseColor, 9, 9));
}
}
#[test]
fn a_gradient_map_reads_a_mask_anchors_gray_from_zero_to_one_in_every_channel() {
for channel in [Channel::BaseColor, Channel::Height] {
for (gray, want) in [(0.0, [1.0, 0.0, 0.0]), (0.25, [0.5, 0.5, 0.0]), (0.5, [0.0, 1.0, 0.0]), (1.0, [0.0, 0.0, 1.0])] {
let mut f = fixture();
let low = fill_layer(&mut f.project, [0.0; 3], 0.5);
let anchor = f.project.alloc_id();
let mut mask = Mask::new(MaskBackground::Black);
mask.effects
.push(Effect::new(f.project.alloc_id(), EffectKind::Fill { source: Source::Uniform([gray; 3]), projection: Projection::default() }));
mask.effects.push(Effect::new(anchor, EffectKind::Anchor));
f.project.layer_mut(low).unwrap().mask = Some(mask);
let id = f.project.alloc_id();
let mut fill = Fill::default();
fill.sources.insert(Channel::BaseColor, Source::Anchor { anchor, channel, ramp: RAMP.to_vec() });
f.project.insert_layer(0, Layer::new(id, "Top", LayerKind::Fill(fill), &[Channel::BaseColor]), None, false).unwrap();
let out = run(&f, None);
assert!(close(out.value(Channel::BaseColor, 9, 9), want), "{channel:?}, gray {gray}: {:?}", out.value(Channel::BaseColor, 9, 9));
}
}
}
#[test]
fn a_procedural_gradient_map_replaces_low_and_high_and_no_stops_keep_them() {
let (low, high) = ([0.2, 0.3, 0.4], [0.8, 0.7, 0.6]);
let composite = |ramp: Vec<[f32; 3]>, lo: [f32; 3], hi: [f32; 3]| {
let mut f = fixture();
let id = f.project.alloc_id();
let mut fill = Fill::default();
let pattern = Procedural::new(ProceduralKind::Gradient);
fill.sources.insert(Channel::BaseColor, Source::Procedural { pattern: pattern.clone(), low: lo, high: hi, ramp: ramp.clone() });
fill.sources.insert(Channel::Roughness, Source::Procedural { pattern, low: lo, high: hi, ramp });
f.project.insert_layer(0, Layer::new(id, "Fill", LayerKind::Fill(fill), &[Channel::BaseColor, Channel::Roughness]), None, false).unwrap();
let out = run(&f, None);
(0..64).map(|x| (out.value(Channel::BaseColor, x, 20), out.value(Channel::Roughness, x, 20))).collect::<Vec<_>>()
};
// The pattern's own 0..1 values, then the same pattern through low and high and through the stops
let gray = composite(Vec::new(), [0.0; 3], [1.0; 3]);
let plain = composite(Vec::new(), low, high);
let mapped = composite(RAMP.to_vec(), low, high);
let near = |a: [f32; 3], b: [f32; 3]| (0..3).all(|i| (a[i] - b[i]).abs() < 1e-3);
assert!(gray.iter().any(|(v, _)| v[0] < 0.25) && gray.iter().any(|(v, _)| v[0] > 0.75), "the gradient spans dark to light");
for (((t, _), (p, _)), (m, rough)) in gray.iter().zip(&plain).zip(&mapped) {
assert!(near(*p, mix3(low, high, t[0])), "no stops: low to high");
assert!(near(*m, texturecraft_core::gradient(&RAMP, t[0]).unwrap()), "{t:?} -> {m:?}");
assert!((rough[0] - mix3(low, high, t[0])[0]).abs() < 1e-3, "roughness ignores the stops: {rough:?}");
}
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.