diff --git a/ATTRIBUTION.md b/ATTRIBUTION.md index 6716328..6538b68 100644 --- a/ATTRIBUTION.md +++ b/ATTRIBUTION.md @@ -22,6 +22,7 @@ images, materials, sample graphs, presets, environments) may ever be added. | `docs/images/materialcraft-new-graph.png` | README screenshot: the New graph dialog | MaterialCraft contributors | Offscreen render of MaterialCraft's UI | MIT OR Apache-2.0 | | `docs/images/materialcraft-materials.png` | README render: six sample materials on the material ball | MaterialCraft contributors | `materialcraft-cli render --scene material_ball --full`, six renders side by side | MIT OR Apache-2.0 | | `docs/brand/artcraft-*.svg`, `docs/brand/artcraft-*.png` | ArtCraft logo and mark | ArtCraft Team | storytold/craftrules `assets/brand/` | ArtCraft brand terms, not open source ([`docs/brand/LICENSE-brand.txt`](docs/brand/LICENSE-brand.txt)) | +| `crates/nodes/src/text.rs` (`GLYPHS`) | Single-stroke vector font of the Text node (A–Z, a–z, 0–9, punctuation) | MaterialCraft contributors | Original, designed as stroke data in code | MIT OR Apache-2.0 | ## Third-party assets compiled into the binary diff --git a/crates/nodes/src/catalog.rs b/crates/nodes/src/catalog.rs index 5ddc40a..aed5b9b 100644 --- a/crates/nodes/src/catalog.rs +++ b/crates/nodes/src/catalog.rs @@ -317,15 +317,21 @@ pub fn catalog() -> &'static [NodeDef] { CAT.get_or_init(|| { let mut v = Vec::new(); v.extend(crate::atomic::defs()); + v.extend(crate::fx_map::defs()); + v.extend(crate::svg::defs()); + v.extend(crate::text::defs()); v.extend(crate::generators::defs()); v.extend(crate::noises_more::defs()); + v.extend(crate::noise3d::defs()); v.extend(crate::patterns::defs()); v.extend(crate::patterns_more::defs()); v.extend(crate::filters::defs()); v.extend(crate::filters_more::defs()); + v.extend(crate::filters_extra::defs()); v.extend(crate::flood_fill::defs()); v.extend(crate::material::defs()); v.extend(crate::material_more::defs()); + v.extend(crate::weathering::defs()); v }) } diff --git a/crates/nodes/src/filters_extra.rs b/crates/nodes/src/filters_extra.rs new file mode 100644 index 0000000..4d1de25 --- /dev/null +++ b/crates/nodes/src/filters_extra.rs @@ -0,0 +1,244 @@ +//! More filters: random per-tile transforms, horizon-based ambient occlusion, a 5×5 Sobel normal +//! map, value band selection, palette quantization and block-averaged pixelation. + +use std::f32::consts::TAU; + +use materialcraft_image::{Image, Kind, luminance}; +use rayon::prelude::*; + +use crate::catalog::{CookResult, Ctx, NodeDef, node}; +use crate::filters_more::pack; +use crate::noise::rand2; +use crate::noises_more::smoothstep; + +const ADJ: &str = "Filters/Adjustments"; +const EFFECTS: &str = "Filters/Effects"; +const NORMAL: &str = "Filters/Normal map"; +const TILING: &str = "Filters/Tiling"; + +pub(crate) fn defs() -> Vec { + vec![ + node("tile_random", "Tile Random", TILING) + .desc("Cuts the image into a grid and shows a randomly offset, flipped and rotated window of the input in each tile (breaks up repetition).") + .any_in("input", "Input") + .int("x_amount", "X amount", 4, 1, 256) + .int("y_amount", "Y amount", 4, 1, 256) + .float("offset_random", "Offset random", 1.0, 0.0, 1.0) + .boolean("rotate", "Random 90° rotation", true) + .boolean("flip", "Random flip", true) + .float("luminance_random", "Luminance random", 0.0, 0.0, 1.0) + .cook(tile_random), + node("ambient_occlusion_fast", "Ambient Occlusion (Fast)", EFFECTS) + .desc("Horizon-based ambient occlusion of a height map: how much of the sky each pixel sees within the radius.") + .gray_in("height", "Height") + .float("radius", "Radius", 12.0, 1.0, 128.0) + .float("height_depth", "Height depth", 0.3, 0.0, 1.0) + .float("intensity", "Intensity", 1.0, 0.0, 2.0) + .gray_out() + .cook(ambient_occlusion_fast), + node("normal_from_height_hq", "Normal from Height HQ", NORMAL) + .desc("A smooth normal map from a height map with 5×5 Sobel slopes.") + .gray_in("input", "Height") + .float("intensity", "Intensity", 1.0, 0.0, 10.0) + .choice("format", "Normal format", &["OpenGL", "DirectX"], 0) + .color_out() + .cook(normal_from_height_hq), + node("histogram_select", "Histogram Select", ADJ) + .desc("White where values lie in a band around the position, fading out with the contrast.") + .gray_in("input", "Input") + .float("position", "Position", 0.5, 0.0, 1.0) + .float("range", "Range", 0.25, 0.0, 1.0) + .float("contrast", "Contrast", 0.5, 0.0, 1.0) + .gray_out() + .cook(histogram_select), + node("quantize_color", "Quantize Color", ADJ) + .desc("Reduces the image to a palette of its most representative colors (k-means), with optional ordered dithering.") + .color_in("input", "Input") + .int("colors", "Colors", 8, 2, 64) + .float("dither", "Dither", 0.0, 0.0, 1.0) + .color_out() + .cook(quantize_color), + node("pixelate_color", "Pixelate Color", EFFECTS) + .desc("Averages the image over blocks (separate X and Y counts).") + .any_in("input", "Input") + .int("x_cells", "X cells", 32, 1, 1024) + .int("y_cells", "Y cells", 32, 1, 1024) + .cook(pixelate_color), + ] +} + +fn tile_random(ctx: &Ctx) -> CookResult { + let img = ctx.any_or(0, Kind::Gray, [0.0; 4]); + let (nx, ny) = (ctx.i("x_amount").clamp(1, 256) as f32, ctx.i("y_amount").clamp(1, 256) as f32); + let (off, rot, flip, lr, s) = (ctx.f("offset_random"), ctx.b("rotate"), ctx.b("flip"), ctx.f("luminance_random"), ctx.seed); + Ok(vec![Image::generate_uv(ctx.w, ctx.h, img.kind, |u, v| { + let (cx, cy) = ((u * nx).floor(), (v * ny).floor()); + let (ci, cj) = ((cx as i32).rem_euclid(nx as i32), (cy as i32).rem_euclid(ny as i32)); + let r = |k: u32| rand2(ci, cj, s ^ k.wrapping_mul(0x2545_f491)); + // Offset from the tile center in uv, flipped and turned by quarter turns. + let (mut a, mut b) = ((u * nx - cx - 0.5) / nx, (v * ny - cy - 0.5) / ny); + if flip && r(1) < 0.5 { + a = -a; + } + if rot { + for _ in 0..(r(2) * 4.0) as i32 { + (a, b) = (-b, a); + } + } + let su = (cx + 0.5) / nx + a + (r(3) - 0.5) * off; + let sv = (cy + 0.5) / ny + b + (r(4) - 0.5) * off; + let p = img.sample(su, sv, true); + let k = 1.0 - lr * r(5); + [p[0] * k, p[1] * k, p[2] * k, p[3]] + })]) +} + +fn ambient_occlusion_fast(ctx: &Ctx) -> CookResult { + const DIRS: usize = 8; + const STEPS: usize = 6; + let h = ctx.gray_or(0, 0.0); + let scale = ctx.w as f32 / 256.0; + let rad = (ctx.f("radius") * scale).clamp(1.0, 1024.0); + let hs = ctx.f("height_depth") * 64.0 * scale; + let k = ctx.f("intensity"); + // Integer offsets along each direction, denser near the pixel, and their true distances. + let taps: Vec<(i64, i64, f32)> = (0..DIRS) + .flat_map(|d| { + let (sn, cs) = ((d as f32 + 0.5) / DIRS as f32 * TAU).sin_cos(); + (1..=STEPS).map(move |s| { + let dist = rad * (s as f32 / STEPS as f32).powf(1.5); + let (ox, oy) = ((cs * dist).round(), (sn * dist).round()); + (ox as i64, oy as i64, (ox * ox + oy * oy).sqrt().max(1.0)) + }) + }) + .collect(); + let tile = ctx.tile; + Ok(vec![Image::generate(ctx.w, ctx.h, Kind::Gray, |x, y| { + let (x, y) = (x as i64, y as i64); + let h0 = h.get_gray(x, y, tile); + let occ: f32 = taps + .chunks(STEPS) + .map(|dir| { + // Tangent of the highest horizon in this direction, as the sine of its angle. + let m = dir.iter().fold(0.0f32, |m, &(ox, oy, d)| m.max((h.get_gray(x + ox, y + oy, tile) - h0) * hs / d)); + m / (1.0 + m * m).sqrt() + }) + .sum(); + [(1.0 - k * occ / DIRS as f32).clamp(0.0, 1.0), 0.0, 0.0, 0.0] + })]) +} + +fn normal_from_height_hq(ctx: &Ctx) -> CookResult { + const SMOOTH: [f32; 5] = [1.0, 4.0, 6.0, 4.0, 1.0]; + const DERIV: [f32; 5] = [-1.0, -2.0, 0.0, 2.0, 1.0]; + let h = ctx.gray_or(0, 0.0); + // The kernels sum to 128 × the slope of a linear ramp. + let k = ctx.f("intensity") * ctx.w as f32 / 32.0 / 128.0; + let dx_fmt = ctx.i("format") == 1; + Ok(vec![Image::generate(ctx.w, ctx.h, Kind::Color, |x, y| { + let (mut gx, mut gy) = (0.0, 0.0); + for j in 0..5 { + for i in 0..5 { + let v = h.get_gray(x as i64 + i as i64 - 2, y as i64 + j as i64 - 2, ctx.tile); + gx += SMOOTH[j] * DERIV[i] * v; + gy += DERIV[j] * SMOOTH[i] * v; + } + } + let ny = gy * k; + pack([-gx * k, if dx_fmt { -ny } else { ny }, 1.0], 1.0) + })]) +} + +fn histogram_select(ctx: &Ctx) -> CookResult { + let (pos, half) = (ctx.f("position"), ctx.f("range") * 0.5); + let soft = (1.0 - ctx.f("contrast").clamp(0.0, 1.0)) * 0.25 + 1e-3; + let img = ctx.gray_or(0, 0.0); + Ok(vec![img.map(Kind::Gray, |p| [1.0 - smoothstep(half, half + soft, (p[0] - pos).abs()), 0.0, 0.0, 0.0])]) +} + +/// Index of the color in `pal` nearest to `c`. +fn nearest(pal: &[[f32; 3]], c: [f32; 3]) -> usize { + let d = |p: &[f32; 3]| (p[0] - c[0]).powi(2) + (p[1] - c[1]).powi(2) + (p[2] - c[2]).powi(2); + pal.iter().enumerate().min_by(|a, b| d(a.1).total_cmp(&d(b.1))).map_or(0, |(i, _)| i) +} + +fn quantize_color(ctx: &Ctx) -> CookResult { + const BAYER: [f32; 16] = [0.0, 8.0, 2.0, 10.0, 12.0, 4.0, 14.0, 6.0, 3.0, 11.0, 1.0, 9.0, 15.0, 7.0, 13.0, 5.0]; + let img = ctx.any_or(0, Kind::Color, [0.5, 0.5, 0.5, 1.0]).to_color(); + let k = ctx.i("colors").clamp(2, 64) as usize; + let rgb = |p: &[f32]| [p[0], p[1], p[2]]; + // Lloyd's k-means on up to ~4096 samples, seeded at luminance quantiles. + let step = (img.data.len() / 4 / 4096).max(1); + let mut samples: Vec<[f32; 3]> = img.data.chunks_exact(4).step_by(step).map(rgb).collect(); + samples.sort_by(|a, b| luminance([a[0], a[1], a[2], 1.0]).total_cmp(&luminance([b[0], b[1], b[2], 1.0]))); + let mut pal: Vec<[f32; 3]> = (0..k).filter_map(|j| samples.get(((j as f32 + 0.5) / k as f32 * samples.len() as f32) as usize).copied()).collect(); + for _ in 0..8 { + let mut acc = vec![[0.0f32; 4]; pal.len()]; + for s in &samples { + if let Some(a) = acc.get_mut(nearest(&pal, *s)) { + *a = [a[0] + s[0], a[1] + s[1], a[2] + s[2], a[3] + 1.0]; + } + } + for (p, a) in pal.iter_mut().zip(&acc) { + if a[3] > 0.0 { + *p = [a[0] / a[3], a[1] / a[3], a[2] / a[3]]; + } + } + } + let spread = ctx.f("dither") / (k as f32).cbrt(); + Ok(vec![Image::generate(img.w, img.h, Kind::Color, |x, y| { + let p = img.get(x as i64, y as i64, false); + let d = ((BAYER[(y as usize % 4) * 4 + x as usize % 4] + 0.5) / 16.0 - 0.5) * spread; + let c = pal.get(nearest(&pal, [p[0] + d, p[1] + d, p[2] + d])).copied().unwrap_or([p[0], p[1], p[2]]); + [c[0], c[1], c[2], p[3]] + })]) +} + +fn pixelate_color(ctx: &Ctx) -> CookResult { + let img = ctx.any_or(0, Kind::Color, [0.0, 0.0, 0.0, 1.0]); + let (w, h) = (img.w as usize, img.h as usize); + let (nx, ny) = (ctx.i("x_cells").clamp(1, 1024) as usize, ctx.i("y_cells").clamp(1, 1024) as usize); + // Block `b` of `n` over `len` pixels covers `b·len/n .. (b+1)·len/n` (at least one pixel). + let range = |n: usize, len: usize, b: usize| (b * len / n, ((b + 1) * len / n).max(b * len / n + 1).min(len)); + let block = |n: usize, len: usize, p: usize| (((p + 1) * n).saturating_sub(1) / len).min(n - 1); + let means: Vec<[f32; 4]> = (0..nx * ny) + .into_par_iter() + .map(|bi| { + let ((x0, x1), (y0, y1)) = (range(nx, w, bi % nx), range(ny, h, bi / nx)); + let mut s = [0.0f32; 4]; + for y in y0..y1 { + for x in x0..x1 { + let p = img.get(x as i64, y as i64, false); + s = std::array::from_fn(|c| s[c] + p[c]); + } + } + let n = ((x1 - x0) * (y1 - y0)).max(1) as f32; + s.map(|v| v / n) + }) + .collect(); + Ok(vec![Image::generate(img.w, img.h, img.kind, |x, y| { + means.get(block(ny, h, y as usize) * nx + block(nx, w, x as usize)).copied().unwrap_or([0.0, 0.0, 0.0, 1.0]) + })]) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn nearest_and_block_math() { + assert_eq!(nearest(&[[0.0; 3], [1.0; 3]], [0.7; 3]), 1); + // Pixelate: a 2-cell split of a black/white image averages each half exactly. + let img = Image::gray(8, 2, |x, _| if x < 4 { 0.0 } else { 1.0 }); + let def = crate::catalog::find("pixelate_color").unwrap(); + let mut p = crate::catalog::resolve_params(def, &Default::default()); + p.insert("x_cells".into(), materialcraft_core::Value::Int(2)); + p.insert("y_cells".into(), materialcraft_core::Value::Int(1)); + let no_res = |_: &str| None; + let vars = Default::default(); + let inputs = [Some(img)]; + let ctx = Ctx { w: 8, h: 2, seed: 0, tile: true, inputs: &inputs, params: &p, resource: &no_res, vars: &vars }; + let out = &pixelate_color(&ctx).unwrap()[0]; + assert_eq!((out.get(3, 1, false)[0], out.get(4, 0, false)[0]), (0.0, 1.0)); + } +} diff --git a/crates/nodes/src/fx_map.rs b/crates/nodes/src/fx_map.rs new file mode 100644 index 0000000..baae5ad --- /dev/null +++ b/crates/nodes/src/fx_map.rs @@ -0,0 +1,282 @@ +//! Atomic › FX-Map: a pattern instancer (regular grid, random scatter or random quadtree +//! subdivision), plus the shared splatting engine of the scatter nodes. Instances wrap across the +//! edges, so the output tiles. + +use std::f32::consts::{SQRT_2, TAU}; + +use materialcraft_image::{Image, Kind}; + +use crate::atomic::ATOMIC; +use crate::catalog::{CookResult, Ctx, NodeDef, node}; +use crate::noise::{hash, rand1}; +use crate::patterns::{PATTERNS, SHAPES, shape}; + +/// One placed pattern: center (uv), half extents (uv), rotation (turns), luminance and the index +/// of the pattern it shows. +#[derive(Clone, Copy, Debug)] +pub(crate) struct Inst { + pub c: [f32; 2], + pub r: [f32; 2], + pub rot: f32, + pub lum: f32, + pub pat: usize, +} + +pub(crate) const BLENDS: &[&str] = &["Max", "Add", "Alpha over"]; + +/// Renders `items` over black. Item `i` covers the rotated box ±`r` around its center, where +/// `pat(i, x, y)` is its pattern (0..1) at local coordinates -1..1. Items are binned on a grid about +/// their size so a pixel only tests its neighbours; later items draw on top (Alpha over). +pub(crate) fn splat(ctx: &Ctx, items: &[Inst], blend: i32, pat: impl Fn(usize, f32, f32) -> f32 + Sync) -> Image { + let valid = |it: &Inst| it.r[0] > 1e-6 && it.r[1] > 1e-6 && it.c.iter().chain(&it.r).all(|v| v.is_finite()); + let n = items.iter().filter(|it| valid(it)).count().max(1); + let mean_r = items.iter().filter(|it| valid(it)).map(|it| it.r[0].max(it.r[1])).sum::() / n as f32; + let g = ((0.5 / mean_r.max(1e-4)) as usize).clamp(1, 256); + let gf = g as f32; + let mut bins: Vec> = vec![Vec::new(); g * g]; + for (i, it) in items.iter().enumerate().filter(|(_, it)| valid(it)) { + let br = it.r[0].max(it.r[1]) * SQRT_2; + // At most one full turn of bins per axis, so no item lands twice in a bin. + let span = |c: f32| { + let a = ((c - br) * gf).floor() as i64; + (a, (((c + br) * gf).floor() as i64).min(a + g as i64 - 1)) + }; + let ((x0, x1), (y0, y1)) = (span(it.c[0]), span(it.c[1])); + for gy in y0..=y1 { + for gx in x0..=x1 { + if let Some(b) = bins.get_mut(gy.rem_euclid(g as i64) as usize * g + gx.rem_euclid(g as i64) as usize) { + b.push(i as u32); + } + } + } + } + let rots: Vec<(f32, f32)> = items.iter().map(|it| (-it.rot * TAU).sin_cos()).collect(); + let tile = ctx.tile; + Image::generate_uv(ctx.w, ctx.h, Kind::Gray, |u, v| { + let mut acc = 0.0f32; + let bin = bins.get(((v * gf) as usize).min(g - 1) * g + ((u * gf) as usize).min(g - 1)); + for &i in bin.into_iter().flatten() { + let (Some(it), Some(&(s, c))) = (items.get(i as usize), rots.get(i as usize)) else { continue }; + let (mut dx, mut dy) = (u - it.c[0], v - it.c[1]); + if tile { + dx -= dx.round(); + dy -= dy.round(); + } + let (x, y) = ((dx * c - dy * s) / it.r[0], (dx * s + dy * c) / it.r[1]); + if x.abs() > 1.0 || y.abs() > 1.0 { + continue; + } + let p = pat(i as usize, x, y); + if p <= 0.0 { + continue; + } + acc = match blend { + 1 => acc + p * it.lum, + 2 => acc + (it.lum - acc) * p.min(1.0), + _ => acc.max(p * it.lum), + }; + } + [acc, 0.0, 0.0, 0.0] + }) +} + +pub(crate) fn defs() -> Vec { + vec![ + node("fx_map", "FX-Map", ATOMIC) + .desc( + "Instances up to three patterns on a grid, at random positions or in a random quadtree, with per-instance scale, rotation, \ + position and luminance jitter. Scale 1 fills an instance's cell. Unconnected: soft discs. Tiles.", + ) + .atomic() + .generator() + .gray_in("pattern0", "Pattern 0") + .gray_in("pattern1", "Pattern 1") + .gray_in("pattern2", "Pattern 2") + .choice("mode", "Mode", &["Grid", "Random", "Quadtree"], 2) + .int("count", "Count (random)", 64, 1, 20000) + .int("x_amount", "X amount", 4, 1, 256) + .int("y_amount", "Y amount", 4, 1, 256) + .int("subdivisions", "Subdivisions (quadtree)", 3, 0, 8) + .float("split_chance", "Subdivide chance", 0.5, 0.0, 1.0) + .float("scale", "Scale", 0.9, 0.0, 2.0) + .float("scale_random", "Scale random", 0.2, 0.0, 1.0) + .angle("rotation", "Rotation", 0.0) + .float("rotation_random", "Rotation random", 0.0, 0.0, 1.0) + .float("position_random", "Position random", 0.0, 0.0, 1.0) + .float("luminance", "Luminance", 1.0, 0.0, 1.0) + .float("luminance_random", "Luminance random", 0.4, 0.0, 1.0) + .float("pattern_random", "Pattern random", 1.0, 0.0, 1.0) + .choice("blending", "Blending", BLENDS, 0) + .int("seed_offset", "Seed offset", 0, 0, 10000) + .gray_out() + .cook(fx_map), + node("shape_splatter", "Shape Splatter", PATTERNS) + .desc("Scatters the pattern input (or a shape) with random scale, rotation and luminance; the mask input sets where instances land.") + .generator() + .gray_in("pattern", "Pattern") + .gray_in("mask", "Mask") + .choice("shape", "Shape (no input)", SHAPES, 3) + .int("count", "Count", 300, 1, 20000) + .float("size", "Size", 0.05, 0.0, 1.0) + .float("size_random", "Size random", 0.5, 0.0, 1.0) + .float("rotation_random", "Rotation random", 1.0, 0.0, 1.0) + .float("luminance_random", "Luminance random", 0.4, 0.0, 1.0) + .choice("blending", "Blending", BLENDS, 0) + .gray_out() + .cook(shape_splatter), + ] +} + +/// A connected pattern at local `(x, y)` (-1..1), or a soft disc when there is none. +pub(crate) fn sample_pattern(pats: &[Image], k: usize, x: f32, y: f32) -> f32 { + match pats.get(k) { + Some(img) => img.sample_gray((x + 1.0) * 0.5, (y + 1.0) * 0.5, false), + None => shape(3, x, y), + } +} + +/// Cells of a random quadtree over an `nx × ny` root grid: (center, size, key). A cell splits +/// with probability `chance` until `depth`. +fn quadtree(nx: i32, ny: i32, depth: i32, chance: f32, seed: u32) -> Vec<([f32; 2], [f32; 2], u32)> { + const MAX_CELLS: usize = 1 << 18; + let mut out = Vec::new(); + let mut stack: Vec<([f32; 2], [f32; 2], i32, u32)> = Vec::new(); + for j in (0..ny).rev() { + for i in (0..nx).rev() { + let size = [1.0 / nx as f32, 1.0 / ny as f32]; + stack.push(([i as f32 * size[0], j as f32 * size[1]], size, 0, hash((j * nx + i) as u32 ^ 0x5157_0000))); + } + } + while let Some((p, s, lvl, key)) = stack.pop() { + if lvl < depth && rand1(key, seed ^ 0x51ed) < chance && out.len() + stack.len() + 4 <= MAX_CELLS { + let h = [s[0] * 0.5, s[1] * 0.5]; + for q in (0..4u32).rev() { + let o = [p[0] + (q & 1) as f32 * h[0], p[1] + (q >> 1) as f32 * h[1]]; + stack.push((o, h, lvl + 1, hash(key.wrapping_mul(4).wrapping_add(q + 1)))); + } + } else { + out.push(([p[0] + s[0] * 0.5, p[1] + s[1] * 0.5], s, key)); + } + } + out +} + +/// The instances an FX-Map places (separate from rendering, so it can be tested). +pub(crate) fn fx_instances(ctx: &Ctx, n_patterns: usize) -> Vec { + let seed = ctx.seed.wrapping_add(ctx.i("seed_offset") as u32); + let (nx, ny) = (ctx.i("x_amount").clamp(1, 256), ctx.i("y_amount").clamp(1, 256)); + let cells: Vec<([f32; 2], [f32; 2], u32)> = match ctx.i("mode") { + 0 => (0..ny) + .flat_map(|j| { + (0..nx).map(move |i| ([(i as f32 + 0.5) / nx as f32, (j as f32 + 0.5) / ny as f32], [1.0 / nx as f32, 1.0 / ny as f32], (j * nx + i) as u32)) + }) + .collect(), + 1 => { + let count = ctx.i("count").clamp(1, 20000) as u32; + let side = 1.0 / (count as f32).sqrt(); + (0..count).map(|i| ([rand1(i * 2, seed ^ 0xa11), rand1(i * 2 + 1, seed ^ 0xa11)], [side, side], i)).collect() + } + _ => quadtree(nx, ny, ctx.i("subdivisions").clamp(0, 8), ctx.f("split_chance"), seed), + }; + let (sc, sr, rot, rr, pr) = (ctx.f("scale"), ctx.f("scale_random"), ctx.f("rotation"), ctx.f("rotation_random"), ctx.f("position_random")); + let (lum, lr, patr) = (ctx.f("luminance"), ctx.f("luminance_random"), ctx.f("pattern_random")); + let n = n_patterns.max(1); + cells + .into_iter() + .map(|(c, size, key)| { + let r = |k: u32| rand1(key.wrapping_mul(8).wrapping_add(k), seed); + let s = sc * (1.0 - sr * r(2)); + Inst { + c: [c[0] + (r(0) - 0.5) * pr * size[0], c[1] + (r(1) - 0.5) * pr * size[1]], + r: [size[0] * 0.5 * s, size[1] * 0.5 * s], + rot: rot + (r(3) - 0.5) * rr, + lum: lum * (1.0 - lr * r(4)), + pat: if r(5) < patr { ((r(6) * n as f32) as usize).min(n - 1) } else { 0 }, + } + }) + .collect() +} + +fn fx_map(ctx: &Ctx) -> CookResult { + let pats: Vec = (0..3).filter_map(|i| ctx.input(i).map(Image::to_gray)).collect(); + let items = fx_instances(ctx, pats.len()); + Ok(vec![splat(ctx, &items, ctx.i("blending"), |i, x, y| sample_pattern(&pats, items.get(i).map_or(0, |it| it.pat), x, y))]) +} + +fn shape_splatter(ctx: &Ctx) -> CookResult { + let pats: Vec = ctx.input(0).map(Image::to_gray).into_iter().collect(); + let mask = ctx.input(1); + let (k, s) = (ctx.i("shape"), ctx.seed); + let (size, sr, rr, lr) = (ctx.f("size"), ctx.f("size_random"), ctx.f("rotation_random"), ctx.f("luminance_random")); + let items: Vec = (0..ctx.i("count").clamp(1, 20000) as u32) + .filter_map(|i| { + let r = |k: u32| rand1(i * 8 + k, s); + let c = [r(0), r(1)]; + // Instances land where the mask is bright: kept with probability = mask value. + if mask.is_some_and(|m| r(2) >= m.sample_gray(c[0], c[1], ctx.tile)) { + return None; + } + let rad = size * (1.0 - sr * r(3)); + Some(Inst { c, r: [rad, rad], rot: (r(4) - 0.5) * rr, lum: 1.0 - lr * r(5), pat: 0 }) + }) + .collect(); + Ok(vec![splat(ctx, &items, ctx.i("blending"), |_, x, y| if pats.is_empty() { shape(k, x, y) } else { sample_pattern(&pats, 0, x, y) })]) +} + +#[cfg(test)] +mod tests { + use std::collections::BTreeMap; + + use materialcraft_core::Value; + + use super::*; + use crate::catalog::{find, resolve_params}; + + fn with(params: &[(&str, Value)], f: impl FnOnce(&Ctx)) { + let def = find("fx_map").unwrap(); + let mut p = resolve_params(def, &BTreeMap::new()); + for (k, v) in params { + p.insert(k.to_string(), v.clone()); + } + let no_res = |_: &str| None; + let vars = BTreeMap::new(); + let inputs = [None, None, None]; + f(&Ctx { w: 64, h: 64, seed: 3, tile: true, inputs: &inputs, params: &p, resource: &no_res, vars: &vars }); + } + + #[test] + fn fx_map_instance_counts() { + with(&[("mode", Value::Enum(0)), ("x_amount", Value::Int(5)), ("y_amount", Value::Int(3))], |c| assert_eq!(fx_instances(c, 1).len(), 15)); + with(&[("mode", Value::Enum(1)), ("count", Value::Int(77))], |c| assert_eq!(fx_instances(c, 1).len(), 77)); + let quad = |chance: f32, depth: i32| { + let mut n = 0; + with( + &[ + ("mode", Value::Enum(2)), + ("x_amount", Value::Int(2)), + ("y_amount", Value::Int(1)), + ("subdivisions", Value::Int(depth)), + ("split_chance", Value::Float(chance)), + ], + |c| n = fx_instances(c, 1).len(), + ); + n + }; + assert_eq!(quad(0.0, 3), 2); + assert_eq!(quad(1.0, 3), 2 * 64); + let some = quad(0.5, 4); + assert!(some > 2 && some < 2 * 256, "{some}"); + } + + #[test] + fn fx_map_is_deterministic_per_seed() { + let cook = |off: i32| { + let mut img = None; + with(&[("seed_offset", Value::Int(off))], |c| img = Some(fx_map(c).unwrap().remove(0))); + img.unwrap() + }; + assert_eq!(cook(0), cook(0)); + assert_ne!(cook(0), cook(1)); + assert!(cook(0).mean()[0] > 0.05); + } +} diff --git a/crates/nodes/src/lib.rs b/crates/nodes/src/lib.rs index 8f6db3a..d51c3d9 100644 --- a/crates/nodes/src/lib.rs +++ b/crates/nodes/src/lib.rs @@ -10,17 +10,23 @@ pub mod atomic; pub mod catalog; pub mod filters; +pub mod filters_extra; pub mod filters_more; pub mod flood_fill; pub mod function; +pub mod fx_map; pub mod generators; pub mod material; pub mod material_more; pub mod noise; +pub mod noise3d; pub mod noises_more; pub mod ops; pub mod patterns; pub mod patterns_more; +pub mod svg; +pub mod text; +pub mod weathering; pub use catalog::{CookResult, Ctx, NodeDef, ParamDef, PortDef, PortKind, catalog, categories, find, resolve_params}; @@ -99,6 +105,16 @@ mod tests { "chevron", "basketweave", "tread_plate", + "fx_map", + "shape_splatter", + "perlin_noise_3d", + "simplex_noise_3d", + "worley_noise_3d", + "cracks", + "paint_strokes", + "scratches_generator", + "rust", + "moss", ] { let def = find(id).unwrap(); let img = &cook(def, &[], 64).unwrap()[0]; diff --git a/crates/nodes/src/noise3d.rs b/crates/nodes/src/noise3d.rs new file mode 100644 index 0000000..a443440 --- /dev/null +++ b/crates/nodes/src/noise3d.rs @@ -0,0 +1,281 @@ +//! Texture generators › Noises: 3D noises that still tile. Perlin and Worley use a 3D lattice that +//! is periodic in x and y (whole-number scales) and free in z, so scrubbing `z` animates the +//! pattern. The simplex variant samples 4D simplex noise on a flat torus (u and v each mapped to a +//! circle), which tiles at any scale; `z` slides the torus through the 4D field. + +use std::f32::consts::TAU; + +use crate::catalog::{B, CookResult, Ctx, NodeDef, node}; +use crate::generators::NOISES; +use crate::noise::{hash, hash3}; +use crate::noises_more::fractal; + +#[inline] +fn wrap(i: i32, p: i32) -> i32 { + if p <= 0 { i } else { i.rem_euclid(p) } +} + +/// A hash of a 3D lattice point, periodic in x and y. +#[inline] +fn hash_xyz(i: i32, j: i32, k: i32, px: i32, py: i32, seed: u32) -> u32 { + hash(hash3(wrap(i, px), wrap(j, py), seed) ^ (k as u32).wrapping_mul(0x9e37_79b1)) +} + +#[inline] +fn fade(t: f32) -> f32 { + t * t * t * (t * (t * 6.0 - 15.0) + 10.0) +} + +/// 3D gradient (Perlin) noise in about -1..1, periods `px`, `py` cells in x and y. +pub fn perlin3(x: f32, y: f32, z: f32, px: i32, py: i32, seed: u32) -> f32 { + const G: [[f32; 3]; 12] = [ + [1.0, 1.0, 0.0], + [-1.0, 1.0, 0.0], + [1.0, -1.0, 0.0], + [-1.0, -1.0, 0.0], + [1.0, 0.0, 1.0], + [-1.0, 0.0, 1.0], + [1.0, 0.0, -1.0], + [-1.0, 0.0, -1.0], + [0.0, 1.0, 1.0], + [0.0, -1.0, 1.0], + [0.0, 1.0, -1.0], + [0.0, -1.0, -1.0], + ]; + let (x0, y0, z0) = (x.floor(), y.floor(), z.floor()); + let (fx, fy, fz) = (x - x0, y - y0, z - z0); + let (ix, iy, iz) = (x0 as i32, y0 as i32, z0 as i32); + let g = |a: i32, b: i32, c: i32| { + let gr = G[(hash_xyz(ix + a, iy + b, iz + c, px, py, seed) % 12) as usize]; + gr[0] * (fx - a as f32) + gr[1] * (fy - b as f32) + gr[2] * (fz - c as f32) + }; + let (u, v, w) = (fade(fx), fade(fy), fade(fz)); + let lerp = |a: f32, b: f32, t: f32| a + (b - a) * t; + let x00 = lerp(g(0, 0, 0), g(1, 0, 0), u); + let x10 = lerp(g(0, 1, 0), g(1, 1, 0), u); + let x01 = lerp(g(0, 0, 1), g(1, 0, 1), u); + let x11 = lerp(g(0, 1, 1), g(1, 1, 1), u); + lerp(lerp(x00, x10, v), lerp(x01, x11, v), w) +} + +/// Uniform 0..1 from a hash. +#[inline] +fn unit(h: u32) -> f32 { + (h >> 8) as f32 / (1u32 << 24) as f32 +} + +/// 3D Worley noise: nearest and second-nearest feature distances (cells), periodic in x and y. +pub fn worley3(x: f32, y: f32, z: f32, px: i32, py: i32, jitter: f32, seed: u32) -> (f32, f32) { + let (ix, iy, iz) = (x.floor() as i32, y.floor() as i32, z.floor() as i32); + let (mut f1, mut f2) = (f32::MAX, f32::MAX); + for k in -1..=1 { + for j in -1..=1 { + for i in -1..=1 { + let (cx, cy, cz) = (ix + i, iy + j, iz + k); + let h = hash_xyz(cx, cy, cz, px, py, seed); + let o = |s: u32| 0.5 + (unit(hash(h ^ s)) - 0.5) * jitter; + let (dx, dy, dz) = (cx as f32 + o(1) - x, cy as f32 + o(2) - y, cz as f32 + o(3) - z); + let d = (dx * dx + dy * dy + dz * dz).sqrt(); + if d < f1 { + f2 = f1; + f1 = d; + } else if d < f2 { + f2 = d; + } + } + } + } + (f1, f2) +} + +/// 4D simplex noise in about -1..1 (after Gustavson's public description of the algorithm). +pub fn simplex4(p: [f32; 4], seed: u32) -> f32 { + const F4: f32 = 0.309_017; // (√5 − 1) / 4 + const G4: f32 = 0.138_196_6; // (5 − √5) / 20 + let s = (p[0] + p[1] + p[2] + p[3]) * F4; + let i: [f32; 4] = std::array::from_fn(|k| (p[k] + s).floor()); + let t = (i[0] + i[1] + i[2] + i[3]) * G4; + let x0: [f32; 4] = std::array::from_fn(|k| p[k] - (i[k] - t)); + // Rank the coordinates to find the simplex the point is in. + let mut rank = [0i32; 4]; + for a in 0..4 { + for b in a + 1..4 { + if x0[a] > x0[b] { + rank[a] += 1; + } else { + rank[b] += 1; + } + } + } + let ii: [i32; 4] = std::array::from_fn(|k| i[k] as i32); + let mut n = 0.0; + for c in 0..5 { + let off: [i32; 4] = std::array::from_fn(|k| (rank[k] >= 4 - c) as i32); + let x: [f32; 4] = std::array::from_fn(|k| x0[k] - off[k] as f32 + c as f32 * G4); + let t = 0.6 - x.iter().map(|v| v * v).sum::(); + if t <= 0.0 { + continue; + } + let h = hash(hash3(ii[0] + off[0], ii[1] + off[1], seed) ^ hash3(ii[2] + off[2], ii[3] + off[3], seed ^ 0x68e3_1da4)); + // 32 gradients: one coordinate zero, the other three ±1. + let zero = (h >> 3) as usize & 3; + let mut dot = 0.0; + let mut bit = 0; + for k in 0..4 { + if k != zero { + dot += if h >> bit & 1 == 0 { x[k] } else { -x[k] }; + bit += 1; + } + } + n += t * t * t * t * dot; + } + 27.0 * n +} + +/// Fractal 4D simplex on a torus at `(u, v)`: tiles in u and v for any scale. +fn simplex_torus(u: f32, v: f32, z: f32, scale: f32, octaves: i32, gain: f32, seed: u32) -> f32 { + let (su, cu) = (u * TAU).sin_cos(); + let (sv, cv) = (v * TAU).sin_cos(); + // Circumference `scale` cells per axis. + let r = scale / TAU; + fractal(octaves, gain, |m, o| { + let (r, z) = (r * m, z * m); + let p = [r * cu + z * 0.7, r * su + z * 0.3, r * cv - z * 0.5, r * sv + z * 0.4]; + (simplex4(p, seed.wrapping_add(o * 977)) * 0.5 + 0.5).clamp(0.0, 1.0) + }) +} + +/// Shared noise parameters. +fn noise_params(b: B, scale: f32, octaves: i32) -> B { + b.generator() + .float("scale", "Scale", scale, 1.0, 64.0) + .int("octaves", "Octaves", octaves, 1, 10) + .float("roughness", "Roughness", 0.5, 0.0, 1.0) + .float("z", "Z (slice)", 0.0, 0.0, 16.0) + .float("contrast", "Contrast", 0.5, 0.0, 1.0) + .gray_out() +} + +pub(crate) fn defs() -> Vec { + let n = |id, label| node(id, label, NOISES); + vec![ + noise_params(n("perlin_noise_3d", "Perlin Noise 3D").desc("Fractal 3D gradient noise; Z scrubs through the volume. Tiles."), 4.0, 5) + .cook(perlin_noise_3d), + noise_params( + n("simplex_noise_3d", "Simplex Noise 3D").desc("Fractal simplex noise sampled on a 4D torus; Z moves through it. Tiles at any scale."), + 4.0, + 5, + ) + .cook(simplex_noise_3d), + noise_params( + n("worley_noise_3d", "Worley Noise 3D") + .desc("Cellular noise from 3D feature points; Z scrubs through the cells. Tiles.") + .choice("distance", "Distance", &["F1", "F2", "F2 - F1"], 0) + .float("jitter", "Jitter", 1.0, 0.0, 1.0), + 6.0, + 1, + ) + .cook(worley_noise_3d), + ] +} + +/// Common noise settings: whole-number scale, octaves, gain, z, contrast gain, seed. +fn settings(ctx: &Ctx) -> (f32, i32, f32, f32, f32, u32) { + (ctx.f("scale").max(1.0).round(), ctx.i("octaves"), ctx.f("roughness"), ctx.f("z"), 1.0 + ctx.f("contrast") * 3.0, ctx.seed) +} + +/// Expand around mid gray by `k`. +#[inline] +fn spread(v: f32, k: f32) -> f32 { + ((v - 0.5) * k + 0.5).clamp(0.0, 1.0) +} + +fn perlin_noise_3d(ctx: &Ctx) -> CookResult { + let (s, oct, gain, z, k, seed) = settings(ctx); + Ok(vec![ctx.gen_gray(|u, v| { + let n = fractal(oct, gain, |m, o| { + let p = s * m; + perlin3(u * p, v * p, z * m + o as f32 * 17.31, p as i32, p as i32, seed.wrapping_add(o * 977)) * 0.5 + 0.5 + }); + spread(n, k) + })]) +} + +fn simplex_noise_3d(ctx: &Ctx) -> CookResult { + let (_, oct, gain, z, k, seed) = settings(ctx); + let s = ctx.f("scale").max(0.1); + Ok(vec![ctx.gen_gray(|u, v| spread(simplex_torus(u, v, z, s, oct, gain, seed), k))]) +} + +fn worley_noise_3d(ctx: &Ctx) -> CookResult { + let (s, oct, gain, z, k, seed) = settings(ctx); + let (mode, jit) = (ctx.i("distance"), ctx.f("jitter").clamp(0.0, 1.0)); + Ok(vec![ctx.gen_gray(|u, v| { + let n = fractal(oct, gain, |m, o| { + let p = s * m; + let (f1, f2) = worley3(u * p, v * p, z * m, p as i32, p as i32, jit, seed.wrapping_add(o * 977)); + match mode { + 1 => f2 * 0.75, + 2 => (f2 - f1) * 1.5, + _ => f1, + } + .clamp(0.0, 1.0) + }); + // Cell distances already span 0..1: contrast 0.5 leaves them as they are. + spread(n, k * 0.4) + })]) +} + +#[cfg(test)] +mod tests { + use std::collections::BTreeMap; + + use super::*; + use crate::catalog::{find, resolve_params}; + + #[test] + fn primitives_tile_and_stay_in_range() { + for k in 0..20 { + let (y, z) = (k as f32 * 0.37, k as f32 * 0.11); + assert!((perlin3(0.0, y, z, 4, 4, 7) - perlin3(4.0, y, z, 4, 4, 7)).abs() < 1e-5); + assert!((perlin3(y, 0.0, z, 4, 4, 7) - perlin3(y, 4.0, z, 4, 4, 7)).abs() < 1e-5); + assert!((worley3(0.0, y, z, 5, 5, 1.0, 3).0 - worley3(5.0, y, z, 5, 5, 1.0, 3).0).abs() < 1e-4); + } + let mut lo = f32::MAX; + let mut hi = f32::MIN; + for k in 0..20000 { + let p = [k as f32 * 0.131, k as f32 * 0.071 + 0.3, (k as f32 * 0.017).sin() * 9.0, k as f32 * 0.029]; + let v = simplex4(p, 1); + lo = lo.min(v); + hi = hi.max(v); + } + assert!(lo > -1.2 && hi < 1.2 && hi - lo > 1.0, "{lo} {hi}"); + } + + /// Each 3D noise matches across u = 0/1 and v = 0/1, and z changes it. + #[test] + fn noises_3d_tile_both_ways() { + let no_res = |_: &str| None; + let vars = BTreeMap::new(); + for id in ["perlin_noise_3d", "simplex_noise_3d", "worley_noise_3d"] { + let def = find(id).unwrap(); + let cook = |z: f32| { + let mut p = resolve_params(def, &BTreeMap::new()); + p.insert("z".into(), materialcraft_core::Value::Float(z)); + let ctx = Ctx { w: 64, h: 64, seed: 5, tile: true, inputs: &[], params: &p, resource: &no_res, vars: &vars }; + (def.cook)(&ctx).unwrap().remove(0) + }; + let img = cook(0.5); + let (mut seam_x, mut seam_y, mut inner) = (0.0f32, 0.0f32, 0.0f32); + for i in 0..64 { + seam_x += (img.get(63, i, false)[0] - img.get(0, i, false)[0]).abs(); + seam_y += (img.get(i, 63, false)[0] - img.get(i, 0, false)[0]).abs(); + inner += (img.get(31, i, false)[0] - img.get(32, i, false)[0]).abs() + (img.get(i, 31, false)[0] - img.get(i, 32, false)[0]).abs(); + } + assert!(seam_x <= inner * 1.5 + 0.2 && seam_y <= inner * 1.5 + 0.2, "{id}: seams {seam_x} {seam_y} vs inner {inner}"); + assert_ne!(img, cook(1.7), "{id}: z changes the slice"); + let (lo, hi) = img.range(); + assert!(hi - lo > 0.3, "{id}: contrast {lo}..{hi}"); + } + } +} diff --git a/crates/nodes/src/noises_more.rs b/crates/nodes/src/noises_more.rs index 4b6777b..d59f7cd 100644 --- a/crates/nodes/src/noises_more.rs +++ b/crates/nodes/src/noises_more.rs @@ -38,7 +38,7 @@ pub(crate) fn perlin_xy(x: f32, y: f32, px: i32, py: i32, seed: u32) -> f32 { /// Fractal sum of `f(level multiplier, octave)` (each 0..1): `octaves` layers, each twice as fine /// and `gain` times weaker. Normalized to 0..1. -fn fractal(octaves: i32, gain: f32, f: impl Fn(f32, u32) -> f32) -> f32 { +pub(crate) fn fractal(octaves: i32, gain: f32, f: impl Fn(f32, u32) -> f32) -> f32 { let (mut sum, mut amp, mut norm, mut m) = (0.0, 1.0, 0.0, 1.0); for o in 0..octaves.clamp(1, 10) as u32 { sum += f(m, o) * amp; diff --git a/crates/nodes/src/svg.rs b/crates/nodes/src/svg.rs new file mode 100644 index 0000000..564477b --- /dev/null +++ b/crates/nodes/src/svg.rs @@ -0,0 +1,487 @@ +//! Atomic › SVG: rasterizes SVG path data (the `d` attribute: M L H V C S Q T Z, absolute and +//! relative) with an even-odd or non-zero fill and an optional stroke. Fill coverage is exact +//! horizontally over four sub-scanlines per pixel. Also the shared capsule (thick line) +//! rasterizer used by the stroke, the Text node and the scratches. + +use materialcraft_image::{Image, Kind}; +use rayon::prelude::*; + +use crate::atomic::ATOMIC; +use crate::catalog::{CookResult, Ctx, NodeDef, node}; + +/// A leaf with a midrib slit, in 0..100 units. +const DEFAULT_PATH: &str = "M50 4 C80 20 94 55 52 96 L50 90 L48 96 C6 55 20 20 50 4 Z M49 22 Q46 55 50 84 Q54 55 51 22 Z"; + +/// Most points a path may flatten to (an allocation cap for hostile input). +const MAX_POINTS: usize = 400_000; + +pub(crate) fn defs() -> Vec { + vec![ + node("svg", "SVG", ATOMIC) + .desc("Draws SVG path data (M L H V C S Q T Z, absolute and relative; y points down) filled and optionally stroked, anti-aliased.") + .atomic() + .generator() + .text("path", "Path data", DEFAULT_PATH) + .choice("units", "Units", &["0..1", "0..100"], 1) + .color("fill", "Fill color", [1.0, 1.0, 1.0, 1.0]) + .choice("fill_rule", "Fill rule", &["Even-odd", "Non-zero"], 1) + .float("stroke_width", "Stroke width", 0.0, 0.0, 64.0) + .color("stroke", "Stroke color", [0.5, 0.5, 0.5, 1.0]) + .color_out() + .cook(svg), + ] +} + +/// A flattened subpath in path units; `closed` after Z. +#[derive(Clone, Debug, PartialEq)] +pub struct Poly { + pub pts: Vec<[f32; 2]>, + pub closed: bool, +} + +struct Lexer<'a> { + s: &'a [u8], + i: usize, +} + +impl Lexer<'_> { + fn skip(&mut self) { + while self.s.get(self.i).is_some_and(|c| c.is_ascii_whitespace() || *c == b',') { + self.i += 1; + } + } + + fn peek(&mut self) -> Option { + self.skip(); + self.s.get(self.i).copied() + } + + fn at_number(&mut self) -> bool { + self.peek().is_some_and(|c| c.is_ascii_digit() || matches!(c, b'-' | b'+' | b'.')) + } + + fn number(&mut self) -> Result { + self.skip(); + let (start, s) = (self.i, self.s); + let digit = |j: usize| s.get(j).is_some_and(u8::is_ascii_digit); + let mut j = start + matches!(s.get(start), Some(b'+' | b'-')) as usize; + let mut digits = 0; + while digit(j) { + j += 1; + digits += 1; + } + if s.get(j) == Some(&b'.') { + j += 1; + while digit(j) { + j += 1; + digits += 1; + } + } + if digits == 0 { + return Err(format!("expected a number at byte {start}")); + } + if matches!(s.get(j), Some(b'e' | b'E')) { + let mut k = j + 1 + matches!(s.get(j + 1), Some(b'+' | b'-')) as usize; + let k0 = k; + while digit(k) { + k += 1; + } + if k > k0 { + j = k; + } + } + let txt = s.get(start..j).and_then(|b| std::str::from_utf8(b).ok()).unwrap_or(""); + let v: f32 = txt.parse().map_err(|_| format!("bad number '{txt}' at byte {start}"))?; + if !v.is_finite() { + return Err(format!("number out of range at byte {start}")); + } + self.i = j; + Ok(v) + } + + fn pair(&mut self) -> Result<[f32; 2], String> { + Ok([self.number()?, self.number()?]) + } +} + +/// Builds flattened subpaths while parsing. +struct Pen { + polys: Vec, + cur: [f32; 2], + start: [f32; 2], + /// The previous segment's last control point and whether it was cubic (for S and T). + ctrl: Option<([f32; 2], bool)>, + steps_per_unit: f32, + points: usize, +} + +impl Pen { + fn push(&mut self, p: [f32; 2]) -> Result<(), String> { + self.points += 1; + if self.points > MAX_POINTS { + return Err(format!("path too complex (over {MAX_POINTS} points)")); + } + match self.polys.last_mut() { + Some(poly) if !poly.closed => poly.pts.push(p), + // Drawing after Z starts a new subpath at the closed one's start. + _ => self.polys.push(Poly { pts: vec![self.start, p], closed: false }), + } + self.cur = p; + Ok(()) + } + + fn move_to(&mut self, p: [f32; 2]) { + self.polys.push(Poly { pts: vec![p], closed: false }); + (self.cur, self.start) = (p, p); + } + + /// A Bézier through `ctrl` (2 or 3 points after the current one), flattened in steps of + /// about 1 / `steps_per_unit` along its control polygon. + fn curve(&mut self, ctrl: &[[f32; 2]]) -> Result<(), String> { + let mut pts = vec![self.cur]; + pts.extend_from_slice(ctrl); + let len: f32 = pts.windows(2).map(|w| ((w[1][0] - w[0][0]).powi(2) + (w[1][1] - w[0][1]).powi(2)).sqrt()).sum(); + let n = (len * self.steps_per_unit).ceil().clamp(2.0, 256.0) as usize; + for k in 1..=n { + let t = k as f32 / n as f32; + // De Casteljau. + let mut q = pts.clone(); + while q.len() > 1 { + q = q.windows(2).map(|w| [w[0][0] + (w[1][0] - w[0][0]) * t, w[0][1] + (w[1][1] - w[0][1]) * t]).collect(); + } + self.push(q.first().copied().unwrap_or(self.cur))?; + } + Ok(()) + } + + fn reflect(&self, cubic: bool) -> [f32; 2] { + match self.ctrl { + Some((c, was_cubic)) if was_cubic == cubic => [2.0 * self.cur[0] - c[0], 2.0 * self.cur[1] - c[1]], + _ => self.cur, + } + } +} + +/// Parses SVG path data into flattened subpaths. Curves get about `steps_per_unit` segments per +/// unit of control-polygon length (2..256 per curve). Bad input is an error, never a panic. +pub fn parse_path(d: &str, steps_per_unit: f32) -> Result, String> { + let mut lx = Lexer { s: d.as_bytes(), i: 0 }; + let steps_per_unit = if steps_per_unit.is_finite() { steps_per_unit.max(0.0) } else { 0.0 }; + let mut pen = Pen { polys: Vec::new(), cur: [0.0; 2], start: [0.0; 2], ctrl: None, steps_per_unit, points: 0 }; + let mut prev: Option = None; + while let Some(c) = lx.peek() { + let op = if c.is_ascii_alphabetic() { + lx.i += 1; + c + } else if lx.at_number() { + // Repeated arguments repeat the command; extra pairs after a move are lines. + match prev { + Some(b'M') => b'L', + Some(b'm') => b'l', + Some(p) if !matches!(p, b'Z' | b'z') => p, + _ => return Err(format!("number without a command at byte {}", lx.i)), + } + } else { + return Err(format!("unexpected '{}' at byte {}", c as char, lx.i)); + }; + if prev.is_none() && !matches!(op, b'M' | b'm') { + return Err("path data must start with a move (M)".into()); + } + let rel = op.is_ascii_lowercase(); + let o = if rel { pen.cur } else { [0.0; 2] }; + let at = |p: [f32; 2]| [p[0] + o[0], p[1] + o[1]]; + let mut ctrl = None; + match op.to_ascii_uppercase() { + b'M' => pen.move_to(at(lx.pair()?)), + b'L' => pen.push(at(lx.pair()?))?, + b'H' => pen.push([lx.number()? + o[0], pen.cur[1]])?, + b'V' => pen.push([pen.cur[0], lx.number()? + o[1]])?, + b'C' => { + let (c1, c2, p) = (at(lx.pair()?), at(lx.pair()?), at(lx.pair()?)); + pen.curve(&[c1, c2, p])?; + ctrl = Some((c2, true)); + } + b'S' => { + let c1 = pen.reflect(true); + let (c2, p) = (at(lx.pair()?), at(lx.pair()?)); + pen.curve(&[c1, c2, p])?; + ctrl = Some((c2, true)); + } + b'Q' => { + let (c1, p) = (at(lx.pair()?), at(lx.pair()?)); + pen.curve(&[c1, p])?; + ctrl = Some((c1, false)); + } + b'T' => { + let c1 = pen.reflect(false); + pen.curve(&[c1, at(lx.pair()?)])?; + ctrl = Some((c1, false)); + } + b'Z' => { + if let Some(p) = pen.polys.last_mut() { + p.closed = true; + } + pen.cur = pen.start; + } + b'A' => return Err("arc commands (A) are not supported; use curves".into()), + _ => return Err(format!("unknown command '{}'", op as char)), + } + pen.ctrl = ctrl; + prev = Some(op); + } + Ok(pen.polys) +} + +/// Fill coverage (0..1 per pixel, row-major) of polygons in pixel coordinates (each implicitly +/// closed): exact horizontal span coverage on four sub-scanlines per pixel row. +pub(crate) fn fill(w: u32, h: u32, polys: &[Vec<[f32; 2]>], even_odd: bool) -> Vec { + // Edges as (x0, y0, x1, y1, winding) with y0 < y1. + let mut edges: Vec<(f32, f32, f32, f32, i32)> = Vec::new(); + for p in polys { + for (k, a) in p.iter().enumerate() { + let b = p.get(k + 1).or(p.first()).copied().unwrap_or(*a); + if a[1] < b[1] { + edges.push((a[0], a[1], b[0], b[1], 1)); + } else if b[1] < a[1] { + edges.push((b[0], b[1], a[0], a[1], -1)); + } + } + } + let wu = w as usize; + let rows: Vec> = (0..h) + .into_par_iter() + .map(|y| { + let mut row = vec![0.0f32; wu]; + let mut xs: Vec<(f32, i32)> = Vec::new(); + for s in 0..4 { + let sy = y as f32 + (s as f32 + 0.5) * 0.25; + xs.clear(); + xs.extend(edges.iter().filter(|e| e.1 <= sy && sy < e.3).map(|e| (e.0 + (sy - e.1) * (e.2 - e.0) / (e.3 - e.1), e.4))); + xs.sort_by(|a, b| a.0.total_cmp(&b.0)); + let mut wind = 0; + for k in 0..xs.len() { + wind += xs[k].1; + let inside = if even_odd { wind & 1 != 0 } else { wind != 0 }; + if let (true, Some(next)) = (inside, xs.get(k + 1)) { + add_span(&mut row, xs[k].0, next.0, 0.25); + } + } + } + row + }) + .collect(); + rows.concat() +} + +/// Adds `wt` × the overlap of `[a, b)` with each pixel of `row`. +fn add_span(row: &mut [f32], a: f32, b: f32, wt: f32) { + let n = row.len() as f32; + let (a, b) = (a.clamp(0.0, n), b.clamp(0.0, n)); + if b <= a { + return; + } + for px in a.floor() as usize..(b.ceil() as usize).min(row.len()) { + let ov = b.min(px as f32 + 1.0) - a.max(px as f32); + if let Some(v) = row.get_mut(px) { + *v += ov.max(0.0) * wt; + } + } +} + +/// A line segment with a weight (its peak coverage). +#[derive(Clone, Copy, Debug)] +pub(crate) struct Seg { + pub a: [f32; 2], + pub b: [f32; 2], + pub wt: f32, +} + +/// Thick line segments ("capsules") of radius `r` in pixel space, binned on a grid for fast +/// lookups. Coverage ramps over one pixel at the border (anti-aliased); with `tile` it wraps. +pub(crate) struct Capsules { + segs: Vec, + r: f32, + g: usize, + cell: [f32; 2], + bins: Vec>, + size: [f32; 2], + tile: bool, +} + +impl Capsules { + pub fn new(segs: Vec, r: f32, w: u32, h: u32, tile: bool) -> Capsules { + let r = if r.is_finite() { r.max(0.0) } else { 0.0 }; + let reach = r + 1.0; + let g = ((w.max(h) as f32 / (reach * 4.0).max(8.0)) as usize).clamp(1, 128); + let cell = [w as f32 / g as f32, h as f32 / g as f32]; + let mut bins: Vec> = vec![Vec::new(); g * g]; + for (i, s) in segs.iter().enumerate() { + if !s.a.iter().chain(&s.b).all(|v| v.is_finite()) { + continue; + } + let span = |a: f32, b: f32, c: f32| { + let lo = ((a.min(b) - reach) / c).floor() as i64; + (lo, (((a.max(b) + reach) / c).floor() as i64).min(lo + g as i64 - 1)) + }; + let ((x0, x1), (y0, y1)) = (span(s.a[0], s.b[0], cell[0]), span(s.a[1], s.b[1], cell[1])); + for gy in y0..=y1 { + for gx in x0..=x1 { + if !tile && (gx < 0 || gy < 0 || gx >= g as i64 || gy >= g as i64) { + continue; + } + if let Some(b) = bins.get_mut(gy.rem_euclid(g as i64) as usize * g + gx.rem_euclid(g as i64) as usize) { + b.push(i as u32); + } + } + } + } + Capsules { segs, r, g, cell, bins, size: [w as f32, h as f32], tile } + } + + /// Coverage (0..1, the strongest segment's weight) at pixel coordinates `(x, y)`. + pub fn coverage(&self, x: f32, y: f32) -> f32 { + let (gx, gy) = (((x / self.cell[0]) as usize).min(self.g - 1), ((y / self.cell[1]) as usize).min(self.g - 1)); + let mut best = 0.0f32; + for &i in self.bins.get(gy * self.g + gx).into_iter().flatten() { + let Some(s) = self.segs.get(i as usize) else { continue }; + let (mut px, mut py) = (x - s.a[0], y - s.a[1]); + if self.tile { + px -= (px / self.size[0]).round() * self.size[0]; + py -= (py / self.size[1]).round() * self.size[1]; + } + let (dx, dy) = (s.b[0] - s.a[0], s.b[1] - s.a[1]); + let t = ((px * dx + py * dy) / (dx * dx + dy * dy).max(1e-12)).clamp(0.0, 1.0); + let d = ((px - dx * t).powi(2) + (py - dy * t).powi(2)).sqrt(); + best = best.max((self.r - d + 0.5).clamp(0.0, 1.0) * s.wt); + } + best + } +} + +/// A color image from fill and stroke coverage over transparent black (premultiplied). +pub(crate) fn composite( + w: u32, + h: u32, + fill: [f32; 4], + cover: impl Fn(u32, u32) -> f32 + Sync, + stroke: [f32; 4], + stroke_cover: impl Fn(u32, u32) -> f32 + Sync, +) -> Image { + Image::generate(w, h, Kind::Color, |x, y| { + let f = cover(x, y).clamp(0.0, 1.0) * fill[3]; + let s = stroke_cover(x, y).clamp(0.0, 1.0) * stroke[3]; + let k = f * (1.0 - s); + [fill[0] * k + stroke[0] * s, fill[1] * k + stroke[1] * s, fill[2] * k + stroke[2] * s, k + s] + }) +} + +fn svg(ctx: &Ctx) -> CookResult { + let unit = if ctx.i("units") == 1 { 100.0 } else { 1.0 }; + let (sx, sy) = (ctx.w as f32 / unit, ctx.h as f32 / unit); + // About one curve segment per 3 pixels. + let polys = parse_path(ctx.text("path"), sx.max(sy) / 3.0)?; + let rings: Vec> = polys.iter().map(|p| p.pts.iter().map(|q| [q[0] * sx, q[1] * sy]).collect()).collect(); + let cov = fill(ctx.w, ctx.h, &rings, ctx.i("fill_rule") == 0); + let sw = ctx.f("stroke_width").max(0.0) * ctx.w as f32 / 256.0; + let caps = (sw > 0.0).then(|| { + let mut segs = Vec::new(); + for (p, ring) in polys.iter().zip(&rings) { + segs.extend(ring.windows(2).map(|w| Seg { a: w[0], b: w[1], wt: 1.0 })); + if let (true, Some(a), Some(b)) = (p.closed, ring.last(), ring.first()) { + segs.push(Seg { a: *a, b: *b, wt: 1.0 }); + } + if ring.len() == 1 { + segs.extend(ring.first().map(|a| Seg { a: *a, b: *a, wt: 1.0 })); + } + } + Capsules::new(segs, sw * 0.5, ctx.w, ctx.h, false) + }); + let w = ctx.w as usize; + Ok(vec![composite( + ctx.w, + ctx.h, + ctx.v4("fill"), + |x, y| cov.get(y as usize * w + x as usize).copied().unwrap_or(0.0), + ctx.v4("stroke"), + |x, y| caps.as_ref().map_or(0.0, |c| c.coverage(x as f32 + 0.5, y as f32 + 0.5)), + )]) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn pts(d: &str) -> Vec> { + parse_path(d, 1.0).unwrap().into_iter().map(|p| p.pts).collect() + } + + #[test] + fn parses_lines_absolute_and_relative() { + assert_eq!(pts("M0 0 L10 0 L10 10 Z"), vec![vec![[0.0, 0.0], [10.0, 0.0], [10.0, 10.0]]]); + assert_eq!(pts("m1,1 l2,0 0,2 h-2 v-1"), vec![vec![[1.0, 1.0], [3.0, 1.0], [3.0, 3.0], [1.0, 3.0], [1.0, 2.0]]]); + // Extra pairs after M are lines; compact number syntax. + assert_eq!(pts("M0 0 1 1 2-2"), vec![vec![[0.0, 0.0], [1.0, 1.0], [2.0, -2.0]]]); + assert_eq!(pts("M.5.5L1e1-1E0"), vec![vec![[0.5, 0.5], [10.0, -1.0]]]); + assert_eq!(pts("M0 0H5V5H0z M8 8 L9 9").len(), 2); + } + + #[test] + fn parses_curves_to_their_endpoints() { + for d in + ["M0 0 C0 10 10 10 10 0", "M0 0 c0 10 10 10 10 0", "M0 0 Q5 10 10 0", "M0 0 q5 10 10 0", "M0 0 Q5 5 5 0 T10 0", "M0 0 C0 5 5 5 5 0 S10 -5 10 0"] + { + let p = pts(d); + let last = *p[0].last().unwrap(); + assert!((last[0] - 10.0).abs() < 1e-4 && last[1].abs() < 1e-4, "{d}: {last:?}"); + assert!(p[0].len() > 3, "{d} is flattened"); + } + // The cubic's midpoint bulges to 7.5. + let p = parse_path("M0 0 C0 10 10 10 10 0", 0.0).unwrap(); + assert_eq!(p[0].pts.len(), 3); + assert!((p[0].pts[1][1] - 7.5).abs() < 1e-4); + } + + #[test] + fn bad_paths_are_errors() { + for d in ["L0 0", "M0", "M0 0 L1", "M0 0 X1 1", "M0 0 L1 1e99", "M0 0 A1 1 0 0 1 2 2", "5 5", "M0 0 Z 3 4", "M 0 0 L - 1"] { + assert!(parse_path(d, 1.0).is_err(), "{d}"); + } + assert!(parse_path("", 1.0).unwrap().is_empty()); + assert!(parse_path("M0 0 C1 1 2 2 3 3", f32::NAN).is_ok()); + } + + #[test] + fn fill_rules_and_coverage() { + let sq = |a: f32, b: f32, ccw: bool| { + let mut v = vec![[a, a], [b, a], [b, b], [a, b]]; + if ccw { + v.reverse(); + } + v + }; + // Square of 4..12 on a 16×16 grid: area 64; a half-pixel edge gives half coverage. + let c = fill(16, 16, &[sq(4.0, 12.0, false)], false); + assert!((c.iter().sum::() - 64.0).abs() < 1e-3); + let c = fill(16, 16, &[sq(4.5, 12.0, false)], false); + assert!((c[8 * 16 + 4] - 0.5).abs() < 1e-4); + // A hole: even-odd always; non-zero only with opposite winding. + let eo = fill(16, 16, &[sq(2.0, 14.0, false), sq(6.0, 10.0, false)], true); + let nz_same = fill(16, 16, &[sq(2.0, 14.0, false), sq(6.0, 10.0, false)], false); + let nz_opp = fill(16, 16, &[sq(2.0, 14.0, false), sq(6.0, 10.0, true)], false); + let center = 8 * 16 + 8; + assert_eq!((eo[center], nz_same[center], nz_opp[center]), (0.0, 1.0, 0.0)); + } + + #[test] + fn default_svg_draws_the_leaf() { + let def = crate::catalog::find("svg").unwrap(); + let p = crate::catalog::resolve_params(def, &Default::default()); + let no_res = |_: &str| None; + let vars = Default::default(); + let ctx = Ctx { w: 64, h: 64, seed: 0, tile: true, inputs: &[], params: &p, resource: &no_res, vars: &vars }; + let img = &svg(&ctx).unwrap()[0]; + let a = img.mean()[3]; + assert!(a > 0.2 && a < 0.7, "{a}"); + assert!(img.get(20, 32, false)[3] > 0.9 && img.get(2, 2, false)[3] == 0.0); + } +} diff --git a/crates/nodes/src/text.rs b/crates/nodes/src/text.rs new file mode 100644 index 0000000..c0903e4 --- /dev/null +++ b/crates/nodes/src/text.rs @@ -0,0 +1,219 @@ +//! Atomic › Text: renders a string with MaterialCraft's own single-stroke vector font, drawn as +//! anti-aliased capsules. The font is original data defined below. + +use std::f32::consts::TAU; + +use crate::atomic::ATOMIC; +use crate::catalog::{CookResult, Ctx, NodeDef, node}; +use crate::svg::{Capsules, Seg, composite}; + +/// The font: each glyph is strokes separated by spaces, each stroke a polyline of `xy` digit +/// pairs on a grid 4 wide where y = 0 is the cap height, 2 the x-height, 6 the baseline and 8 +/// the descender. A single pair is a dot. Original design for MaterialCraft. +const GLYPHS: &[(char, &str)] = &[ + ('A', "062046 1333"), + ('B', "06003041423303 3344453606"), + ('C', "4130100105163645"), + ('D', "06003041453606"), + ('E', "40000646 0333"), + ('F', "400006 0333"), + ('G', "41301001051636454323"), + ('H', "0006 4046 0343"), + ('I', "1030 2026 1636"), + ('J', "4045361605"), + ('K', "0006 4004 1346"), + ('L', "000646"), + ('M', "0600234046"), + ('N', "06004640"), + ('O', "103041453616050110"), + ('P', "06003041423303"), + ('Q', "103041453616050110 2446"), + ('R', "06003041423303 2346"), + ('S', "413010010213334445361605"), + ('T', "0040 2026"), + ('U', "000516364540"), + ('V', "002640"), + ('W', "0016233640"), + ('X', "0046 4006"), + ('Y', "002340 2326"), + ('Z', "00400646"), + ('a', "4246 4332120305163645"), + ('b', "0006 0312324345361605"), + ('c', "4332120305163645"), + ('d', "4046 4332120305163645"), + ('e', "04444332120305163645"), + ('f', "4130201116 0232"), + ('g', "4247381807 4332120305163645"), + ('h', "0006 0312324346"), + ('i', "2226 20"), + ('j', "3237281807 30"), + ('k', "0006 3205 1436"), + ('l', "10202536"), + ('m', "0206 03122326 23324346"), + ('n', "0206 0312324346"), + ('o', "123243453616050312"), + ('p', "0208 0312324345361605"), + ('q', "4248 4332120305163645"), + ('r', "0206 04223243"), + ('s', "43321203143445361605"), + ('t', "10152636 0232"), + ('u', "0205163645 4246"), + ('v', "022642"), + ('w', "0216243642"), + ('x', "0246 4206"), + ('y', "0226 4218"), + ('z', "02420646"), + ('0', "103041453616050110 3115"), + ('1', "112026 1636"), + ('2', "01103041420646"), + ('3', "01103041423313 334445361605"), + ('4', "36300444"), + ('5', "400003334445361605"), + ('6', "30100105163645443303"), + ('7', "004016"), + ('8', "13020110304142331304051636454433"), + ('9', "43130201103041453616"), + ('.', "26"), + (',', "2617"), + ('!', "2024 26"), + ('?', "0110304142332324 26"), + (':', "22 26"), + (';', "22 2617"), + ('-', "1333"), + ('+', "1333 2224"), + ('=', "1232 1434"), + ('*', "1135 3115 0333"), + ('/', "4006"), + ('\\', "0046"), + ('(', "30212536"), + (')', "10212516"), + ('[', "30202636"), + (']', "10202616"), + ('<', "410345"), + ('>', "014305"), + ('\'', "2021"), + ('"', "1011 3031"), + ('_', "0747"), + ('#', "1115 3135 0242 0444"), + ('%', "4006 01 45"), + (' ', ""), +]; + +/// A character's strokes; unknown characters show as `?`. +fn glyph(c: char) -> &'static str { + let find = |c: char| GLYPHS.iter().find(|(g, _)| *g == c).map(|(_, s)| *s); + find(c).or_else(|| find('?')).unwrap_or("") +} + +/// The strokes of `s` as polylines in grid units. +fn strokes(s: &str) -> impl Iterator> + '_ { + s.split(' ') + .filter(|t| !t.is_empty()) + .map(|t| t.as_bytes().chunks_exact(2).map(|p| [p[0].saturating_sub(b'0') as f32, p[1].saturating_sub(b'0') as f32]).collect()) +} + +/// Longest text drawn (an allocation cap). +const MAX_CHARS: usize = 10_000; + +pub(crate) fn defs() -> Vec { + vec![ + node("text", "Text", ATOMIC) + .desc("Draws text with a built-in single-stroke font (A–Z, a–z, 0–9, punctuation). \\n starts a new line.") + .atomic() + .generator() + .text("text", "Text", "MaterialCraft") + .float("size", "Size", 0.09, 0.0, 1.0) + .float2("position", "Position", [0.5, 0.5], 0.0, 1.0) + .choice("alignment", "Alignment", &["Left", "Center", "Right"], 1) + .color("color", "Color", [1.0, 1.0, 1.0, 1.0]) + .float("weight", "Stroke weight", 0.7, 0.05, 3.0) + .float("letter_spacing", "Letter spacing", 1.0, 0.0, 5.0) + .float("line_spacing", "Line spacing", 1.0, 0.0, 5.0) + .angle("rotation", "Rotation", 0.0) + .boolean("tiling", "Tiling (wrap at edges)", true) + .color_out() + .cook(text), + ] +} + +/// The capsule segments of `txt` in pixel space. +fn layout(ctx: &Ctx, txt: &str) -> Vec { + let unit = ctx.f("size").max(0.0) * ctx.h as f32 / 8.0; + let (adv, line_h) = (4.0 + 2.0 * ctx.f("letter_spacing"), 10.0 * ctx.f("line_spacing")); + let (align, pos) = (ctx.i("alignment"), ctx.v2("position")); + let (s, c) = (ctx.f("rotation") * TAU).sin_cos(); + let anchor = [pos[0] * ctx.w as f32, pos[1] * ctx.h as f32]; + let lines: Vec<&str> = txt.split('\n').collect(); + // The block is centered vertically on the anchor (cap height of the first line to baseline of the last). + let top = -((lines.len().max(1) - 1) as f32 * line_h + 6.0) * 0.5; + let mut segs = Vec::new(); + for (li, line) in lines.iter().enumerate() { + let n = line.chars().count() as f32; + let width = if n > 0.0 { (n - 1.0) * adv + 4.0 } else { 0.0 }; + let x0 = match align { + 0 => 0.0, + 1 => -width * 0.5, + _ => -width, + }; + let y0 = top + li as f32 * line_h; + for (ci, ch) in line.chars().enumerate() { + let gx = x0 + ci as f32 * adv; + for stroke in strokes(glyph(ch)) { + let px: Vec<[f32; 2]> = stroke + .iter() + .map(|p| { + let (x, y) = ((gx + p[0]) * unit, (y0 + p[1]) * unit); + [anchor[0] + x * c + y * s, anchor[1] - x * s + y * c] + }) + .collect(); + match px.as_slice() { + [a] => segs.push(Seg { a: *a, b: *a, wt: 1.0 }), + _ => segs.extend(px.windows(2).map(|w| Seg { a: w[0], b: w[1], wt: 1.0 })), + } + } + } + } + segs +} + +fn text(ctx: &Ctx) -> CookResult { + let txt: String = ctx.text("text").replace("\\n", "\n").chars().take(MAX_CHARS).collect(); + let r = ctx.f("weight").max(0.0) * ctx.f("size").max(0.0) * ctx.h as f32 / 16.0; + let caps = Capsules::new(layout(ctx, &txt), r, ctx.w, ctx.h, ctx.b("tiling")); + Ok(vec![composite(ctx.w, ctx.h, ctx.v4("color"), |x, y| caps.coverage(x as f32 + 0.5, y as f32 + 0.5), [0.0; 4], |_, _| 0.0)]) +} + +#[cfg(test)] +mod tests { + use std::collections::BTreeMap; + + use super::*; + use crate::catalog::{find, resolve_params}; + + #[test] + fn font_data_is_well_formed() { + for (c, s) in GLYPHS { + for t in s.split(' ').filter(|t| !t.is_empty()) { + assert!(t.len() % 2 == 0 && t.bytes().all(|b| b.is_ascii_digit()), "{c:?}: {t}"); + assert!(t.as_bytes().chunks(2).all(|p| p[0] <= b'4' && p[1] <= b'8'), "{c:?}: {t} leaves the grid"); + } + } + for c in ('A'..='Z').chain('a'..='z').chain('0'..='9') { + assert!(GLYPHS.iter().any(|(g, _)| *g == c), "{c} missing"); + } + } + + #[test] + fn renders_material_craft() { + let def = find("text").unwrap(); + let p = resolve_params(def, &BTreeMap::new()); + let no_res = |_: &str| None; + let vars = BTreeMap::new(); + let ctx = Ctx { w: 256, h: 256, seed: 0, tile: true, inputs: &[], params: &p, resource: &no_res, vars: &vars }; + let img = &text(&ctx).unwrap()[0]; + let lit = img.data.chunks(4).filter(|p| p[3] > 0.5).count(); + assert!(lit > 300, "{lit} pixels"); + // Centered: nothing in the top and bottom quarters. + assert!((0..256).all(|x| img.get(x, 20, false)[3] == 0.0 && img.get(x, 236, false)[3] == 0.0)); + } +} diff --git a/crates/nodes/src/weathering.rs b/crates/nodes/src/weathering.rs new file mode 100644 index 0000000..4c1cfa4 --- /dev/null +++ b/crates/nodes/src/weathering.rs @@ -0,0 +1,296 @@ +//! Wear and weathering: cracks, paint strokes, scratches along a direction field, rust, moss and +//! lichen, leaks (drips running down from a mask) and chipped edges. The generators tile. + +use std::f32::consts::{PI, TAU}; + +use materialcraft_image::{Image, Kind}; +use rayon::prelude::*; + +use crate::catalog::{CookResult, Ctx, NodeDef, PortKind, node}; +use crate::fx_map::{BLENDS, Inst, splat}; +use crate::generators::NOISES; +use crate::noise::{cellular, fbm, rand1, value}; +use crate::noises_more::smoothstep; +use crate::ops; +use crate::patterns::PATTERNS; +use crate::svg::{Capsules, Seg}; + +const WEATHER: &str = "Material filters/Weathering"; + +pub(crate) fn defs() -> Vec { + vec![ + node("cracks", "Cracks", NOISES) + .desc("A connected network of thin cracks along warped cell borders, with finer branching cracks. White = crack.") + .generator() + .float("scale", "Scale", 5.0, 1.0, 32.0) + .float("width", "Width", 1.5, 0.0, 16.0) + .float("warp", "Warp", 0.5, 0.0, 1.0) + .float("branches", "Branches", 0.5, 0.0, 1.0) + .gray_out() + .cook(cracks), + node("paint_strokes", "Paint Strokes", PATTERNS) + .desc("Overlapping brush strokes with bristle streaks and ragged ends.") + .generator() + .int("count", "Count", 150, 1, 5000) + .float("length", "Length", 0.35, 0.0, 1.0) + .float("width", "Width", 0.07, 0.0, 0.5) + .angle("angle", "Angle", 0.0) + .float("angle_random", "Angle random", 0.08, 0.0, 1.0) + .int("bristles", "Bristles", 20, 1, 256) + .float("luminance_random", "Luminance random", 0.5, 0.0, 1.0) + .choice("blending", "Blending", BLENDS, 2) + .gray_out() + .cook(paint_strokes), + node("scratches_generator", "Scratches Generator", PATTERNS) + .desc("Thin tapered scratches that bend along a direction field (gray = angle in turns) and land where the mask is bright.") + .generator() + .gray_in("direction", "Direction field") + .gray_in("mask", "Mask") + .int("count", "Count", 200, 0, 5000) + .float("length", "Length", 0.25, 0.0, 1.0) + .float("width", "Width", 1.0, 0.1, 16.0) + .angle("angle", "Angle", 0.0) + .float("angle_random", "Angle random", 0.15, 0.0, 1.0) + .float("curvature", "Curvature", 0.1, 0.0, 1.0) + .float("field_intensity", "Field intensity", 0.25, 0.0, 1.0) + .float("luminance_random", "Luminance random", 0.6, 0.0, 1.0) + .gray_out() + .cook(scratches_generator), + node("rust", "Rust", WEATHER) + .desc("A mask of rust blotches and pitting; with a mask input it grows out from the mask (edges, cavities).") + .generator() + .gray_in("mask", "Mask (optional)") + .float("amount", "Amount", 0.45, 0.0, 1.0) + .float("scale", "Scale", 6.0, 1.0, 64.0) + .float("spread", "Spread", 12.0, 0.0, 128.0) + .float("pitting", "Pitting", 0.5, 0.0, 1.0) + .float("contrast", "Contrast", 0.7, 0.0, 1.0) + .gray_out() + .cook(rust), + node("moss", "Moss / Lichen", WEATHER) + .desc("Fuzzy moss clumps (gathering in low areas) or round lichen rosettes (on high areas) of an optional height map.") + .generator() + .gray_in("height", "Height (optional)") + .choice("style", "Style", &["Moss", "Lichen"], 0) + .float("amount", "Amount", 0.5, 0.0, 1.0) + .float("scale", "Scale", 6.0, 1.0, 64.0) + .float("height_bias", "Height bias", 0.5, 0.0, 1.0) + .float("contrast", "Contrast", 0.6, 0.0, 1.0) + .gray_out() + .cook(moss), + node("leaks", "Leaks", WEATHER) + .desc("Streaky drips running down from a mask (unconnected: random stains), fading with length and meandering.") + .gray_in("mask", "Mask") + .float("length", "Length", 0.35, 0.0, 1.0) + .float("length_random", "Length random", 0.7, 0.0, 1.0) + .float("streaks", "Streaks", 32.0, 1.0, 256.0) + .float("wobble", "Wobble", 0.3, 0.0, 1.0) + .gray_out() + .cook(leaks), + node("edge_damage", "Edge Damage", WEATHER) + .desc("Chips the edges of a height mask (white = material) in chunky, ragged bites; also outputs the damage mask.") + .gray_in("height", "Height") + .float("width", "Width", 8.0, 0.0, 64.0) + .float("amount", "Amount", 0.5, 0.0, 1.0) + .float("scale", "Chip scale", 12.0, 1.0, 64.0) + .float("roughness", "Roughness", 0.5, 0.0, 1.0) + .float("depth", "Depth", 1.0, 0.0, 1.0) + .gray_out() + .output("mask", "Damage mask", PortKind::Gray) + .cook(edge_damage), + ] +} + +/// `v` pixels at 256 px, at the output size. +fn px(ctx: &Ctx, v: f32) -> f32 { + v * ctx.w as f32 / 256.0 +} + +fn whole(ctx: &Ctx, id: &str) -> f32 { + ctx.f(id).max(1.0).round() +} + +/// A soft threshold: 1 where `v` is above `1 - amount`; `contrast` 1 is hard, 0 soft. +fn thresh(v: f32, amount: f32, contrast: f32) -> f32 { + let soft = (1.0 - contrast.clamp(0.0, 1.0)) * 0.25 + 0.005; + smoothstep(1.0 - amount - soft, 1.0 - amount + soft, v) +} + +/// A gray image from `f(pixel index, u, v)`. +fn gen_px(ctx: &Ctx, f: impl Fn(usize, f32, f32) -> f32 + Sync) -> Image { + let (w, h) = (ctx.w.max(1), ctx.h.max(1)); + Image::generate(w, h, Kind::Gray, |x, y| [f(y as usize * w as usize + x as usize, (x as f32 + 0.5) / w as f32, (y as f32 + 0.5) / h as f32), 0.0, 0.0, 0.0]) +} + +fn cracks(ctx: &Ctx) -> CookResult { + let (s, wpx, warp, br, seed) = (whole(ctx, "scale"), px(ctx, ctx.f("width")), ctx.f("warp"), ctx.f("branches"), ctx.seed); + let cell_px = ctx.w as f32 / s; + Ok(vec![ctx.gen_gray(|u, v| { + // Broad bends plus fine jaggedness, both in cell units. + let k = warp / s; + let wu = u + (fbm(u, v, 4.0, 4, 0.5, seed ^ 11) - 0.5) * 2.0 * k + (fbm(u, v, s * 4.0, 3, 0.5, seed ^ 14) - 0.5) * 0.3 * k; + let wv = v + (fbm(u, v, 4.0, 4, 0.5, seed ^ 12) - 0.5) * 2.0 * k + (fbm(u, v, s * 4.0, 3, 0.5, seed ^ 15) - 0.5) * 0.3 * k; + let line = |m: f32, sd: u32, half: f32| { + let c = cellular(wu * s * m, wv * s * m, (s * m) as i32, 1.0, 0, sd); + 1.0 - smoothstep(half, half + 1.0, (c.f2 - c.f1) * 0.5 * cell_px / m) + }; + let main = line(1.0, seed, wpx * 0.5); + if br <= 0.0 { + return main; + } + let keep = smoothstep(1.0 - br, 1.0 - br + 0.2, fbm(u, v, s, 3, 0.5, seed ^ 13)); + main.max(line(3.0, seed ^ 7, wpx * 0.3) * keep * 0.8) + })]) +} + +fn paint_strokes(ctx: &Ctx) -> CookResult { + let (len, wid, ang, ar, lr, s) = (ctx.f("length"), ctx.f("width"), ctx.f("angle"), ctx.f("angle_random"), ctx.f("luminance_random"), ctx.seed); + let bristles = ctx.i("bristles").clamp(1, 256) as f32; + let items: Vec = (0..ctx.i("count").clamp(1, 5000) as u32) + .map(|i| { + let r = |k: u32| rand1(i * 8 + k, s); + Inst { + c: [r(0), r(1)], + r: [len * 0.5 * (0.7 + 0.3 * r(2)), wid * 0.5 * (0.8 + 0.4 * r(3))], + rot: ang + (r(4) - 0.5) * ar, + lum: 1.0 - lr * r(5), + pat: 0, + } + }) + .collect(); + Ok(vec![splat(ctx, &items, ctx.i("blending"), |i, x, y| { + let sd = s ^ (i as u32).wrapping_mul(0x9e37_79b9); + // Bristle density across the stroke; the ends are ragged per bristle. + let b = value(y * bristles + 0.5, 0.5, 0, sd); + let ragged = value(y * bristles * 0.5 + 3.1, x * 2.0, 0, sd ^ 1); + let end = 1.0 - smoothstep(0.55 + 0.4 * ragged, 1.0, x.abs()); + let edge = 1.0 - smoothstep(0.7, 1.0, y.abs()); + end * edge * (0.45 + 0.55 * b) + })]) +} + +fn scratches_generator(ctx: &Ctx) -> CookResult { + const STEPS: u32 = 12; + let (len, ang, ar, curv, fi, lr, s) = + (ctx.f("length"), ctx.f("angle"), ctx.f("angle_random"), ctx.f("curvature"), ctx.f("field_intensity"), ctx.f("luminance_random"), ctx.seed); + let (field, mask) = (ctx.input(0), ctx.input(1)); + let (w, h) = (ctx.w as f32, ctx.h as f32); + let mut segs = Vec::new(); + for i in 0..ctx.i("count").clamp(0, 5000) as u32 { + let r = |k: u32| rand1(i * 8 + k, s); + let mut p = [r(0), r(1)]; + if mask.is_some_and(|m| r(2) >= m.sample_gray(p[0], p[1], ctx.tile)) { + continue; + } + let (base, bend, lum) = (ang + (r(3) - 0.5) * ar, (r(4) - 0.5) * curv, 1.0 - lr * r(6)); + let step = len * (0.4 + 0.6 * r(5)) / STEPS as f32; + for k in 0..STEPS { + let t = k as f32 / STEPS as f32; + let a = (base + bend * t + field.map_or(0.0, |f| f.sample_gray(p[0], p[1], ctx.tile) * fi)) * TAU; + let q = [p[0] + a.cos() * step, p[1] - a.sin() * step]; + let taper = ((t + 0.5 / STEPS as f32) * PI).sin().sqrt(); + segs.push(Seg { a: [p[0] * w, p[1] * h], b: [q[0] * w, q[1] * h], wt: lum * taper }); + p = q; + } + } + let caps = Capsules::new(segs, px(ctx, ctx.f("width")) * 0.5, ctx.w, ctx.h, ctx.tile); + Ok(vec![Image::generate(ctx.w, ctx.h, Kind::Gray, |x, y| [caps.coverage(x as f32 + 0.5, y as f32 + 0.5), 0.0, 0.0, 0.0])]) +} + +fn rust(ctx: &Ctx) -> CookResult { + let (amt, s, pit, con, seed) = (ctx.f("amount"), whole(ctx, "scale"), ctx.f("pitting"), ctx.f("contrast"), ctx.seed); + let grow = ctx.sized(0).map(|m| ops::gaussian(&m.to_gray(), px(ctx, ctx.f("spread")), ctx.tile)); + Ok(vec![gen_px(ctx, |i, u, v| { + let blotch = fbm(u, v, s, 6, 0.55, seed); + let base = match &grow { + Some(g) => 0.5 * blotch + 0.6 * g.data.get(i).copied().unwrap_or(0.0), + None => blotch, + }; + let c = cellular(u * s * 8.0, v * s * 8.0, (s * 8.0) as i32, 1.0, 0, seed ^ 3); + let pits = (1.0 - smoothstep(0.05, 0.4, c.f1)) * (c.id < pit) as i32 as f32; + // Pits speckle the surroundings of the blotches only. + thresh(base + pits * 0.2 * smoothstep(0.3, 0.5, base), amt, con) * (0.7 + 0.3 * fbm(u, v, s * 16.0, 3, 0.6, seed ^ 5)) + })]) +} + +fn moss(ctx: &Ctx) -> CookResult { + let (lichen, amt, s, bias, con, seed) = (ctx.i("style") == 1, ctx.f("amount"), whole(ctx, "scale"), ctx.f("height_bias"), ctx.f("contrast"), ctx.seed); + let hgt = ctx.sized(0).map(|h| h.to_gray()); + Ok(vec![gen_px(ctx, |i, u, v| { + let hb = hgt.as_ref().map_or(0.0, |h| (h.data.get(i).copied().unwrap_or(0.5) - 0.5) * bias); + let fine = |m: f32, sd: u32| value(u * s * m, v * s * m, (s * m) as i32, seed ^ sd); + if !lichen { + // Fuzzy clumps, thicker in low areas. + let clump = fbm(u, v, s, 5, 0.6, seed) - hb + (fine(24.0, 9) - 0.5) * 0.25; + return thresh(clump, amt, con) * (0.55 + 0.45 * fine(48.0, 10)); + } + // Round rosettes with brighter rims, on high areas. + let c = cellular(u * s, v * s, s as i32, 0.9, 0, seed); + if c.id >= amt * 1.4 + hb { + return 0.0; + } + let rad = (0.25 + 0.35 * (c.id * 7.31).fract()) * (0.8 + 0.4 * fbm(u, v, s * 8.0, 3, 0.5, seed ^ 4)); + let soft = 0.01 + (1.0 - con) * 0.06; + (1.0 - smoothstep(rad - soft, rad, c.f1)) * (0.55 + 0.45 * smoothstep(rad * 0.4, rad, c.f1)) * (0.8 + 0.2 * fine(32.0, 6)) + })]) +} + +fn leaks(ctx: &Ctx) -> CookResult { + let (w, h, seed) = (ctx.w as usize, ctx.h as usize, ctx.seed); + let src = match ctx.sized(0) { + Some(m) => m.to_gray(), + None => ctx.gen_gray(|u, v| smoothstep(0.62, 0.7, fbm(u, v, 4.0, 4, 0.5, seed ^ 21))), + }; + let (len, lr, streaks, wob) = (ctx.f("length").max(0.0) * h as f32, ctx.f("length_random"), whole(ctx, "streaks"), ctx.f("wobble")); + // Each column carries its value down, fading over a length that varies across columns. + let cols: Vec> = (0..w) + .into_par_iter() + .map(|x| { + let u = (x as f32 + 0.5) / w as f32; + let r = 0.6 * value(u * streaks, 0.5, streaks as i32, seed ^ 23) + 0.4 * value(u * streaks * 4.0, 0.5, (streaks * 4.0) as i32, seed ^ 24); + let decay = (-3.0 / (len * (1.0 - lr * r)).max(1.0)).exp(); + let mut col = vec![0.0f32; h]; + let mut acc = 0.0f32; + // Tiling: a second pass carries drips over the bottom edge to the top. + let passes = if ctx.tile { 2 } else { 1 }; + for pass in 0..passes { + for (y, out) in col.iter_mut().enumerate() { + acc = src.data.get(y * w + x).copied().unwrap_or(0.0).max(acc * decay); + if pass + 1 == passes { + *out = acc; + } + } + } + col + }) + .collect(); + let run = Image::gray(ctx.w, ctx.h, |x, y| cols.get(x as usize).and_then(|c| c.get(y as usize)).copied().unwrap_or(0.0)); + Ok(vec![ctx.gen_gray(|u, v| { + let dx = (fbm(u, v, 8.0, 3, 0.5, seed ^ 22) - 0.5) * wob * 0.04; + run.sample_gray(u + dx, v, ctx.tile) * (0.75 + 0.25 * value(u * streaks * 2.0, v * 3.0, (streaks * 2.0) as i32, seed ^ 25)) + })]) +} + +fn edge_damage(ctx: &Ctx) -> CookResult { + let hgt = ctx.gray_or(0, 0.0); + let data = hgt.data.clone(); + let solid = |i: usize| data.get(i).is_some_and(|v| *v > 0.5); + let dist = ops::distance_sq(ctx.w, ctx.h, |i| !solid(i), ctx.tile); + let (wpx, amt, s, rough, depth, seed) = (px(ctx, ctx.f("width")), ctx.f("amount"), whole(ctx, "scale"), ctx.f("roughness"), ctx.f("depth"), ctx.seed); + let mask = gen_px(ctx, |i, u, v| { + if !solid(i) { + return 0.0; + } + let d = dist.get(i).map_or(0.0, |d| d.sqrt()); + // Chunky bites per cell, made ragged by noise. + let c = cellular(u * s, v * s, s as i32, 1.0, 0, seed); + let r = c.id * (1.0 - rough * 0.5) + (fbm(u, v, s * 2.0, 4, 0.5, seed ^ 3) - 0.5) * rough * 1.5; + let reach = wpx * 2.0 * amt * r.max(0.0); + 1.0 - smoothstep(reach - 0.75, reach + 0.75, d) + }); + let out = Image::gray(ctx.w, ctx.h, |x, y| { + let i = (y * ctx.w + x) as usize; + data.get(i).copied().unwrap_or(0.0) * (1.0 - depth * mask.data.get(i).copied().unwrap_or(0.0)) + }); + Ok(vec![out, mask]) +}