Files
chasse20 6f8e984d7a Auto: Integrate main and reduce repeated procedural sampling work
Reuse two fur seed tables per worker, share knot noise, and skip invisible decay and brocade detail. Normalize each catalog lookup once while preserving label and saved-name aliases.

Consolidate periodic sampling helpers, move FurLock into its own module, and strengthen coverage of coarse-grid fallback and saved pattern names. Preserve main's project and Assets changes and document the expanded catalog.
2026-11-18 21:52:15 +00:00

1620 lines
66 KiB
Rust
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Layers, masks, effects and fill sources.
use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use crate::{BakedMap, BlendMode, Channel, ChannelKind, lum};
mod curvature_detail;
mod curvature_mode;
mod decal_flip;
mod decal_symmetry;
mod generator_global;
mod micro_detail;
mod output_resolution;
mod resolution_mode;
mod tile_blending;
mod tile_generator;
mod tile_input_distribution;
mod tile_shape;
mod tile_size_mode;
mod tile_symmetry;
pub use curvature_detail::CurvatureDetail;
pub use curvature_mode::CurvatureMode;
pub use decal_flip::DecalFlip;
pub use decal_symmetry::DecalSymmetry;
pub use generator_global::GeneratorGlobal;
pub use micro_detail::MicroDetail;
pub use output_resolution::OutputResolution;
pub use resolution_mode::ResolutionMode;
pub use tile_blending::TileBlending;
pub use tile_generator::TileGenerator;
pub use tile_input_distribution::TileInputDistribution;
pub use tile_shape::TileShape;
pub use tile_size_mode::TileSizeMode;
pub use tile_symmetry::TileSymmetry;
/// Id of a layer or effect (one id space per project).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
pub struct LayerId(pub u64);
/// Blend mode and opacity of one channel of a layer. A channel missing from
/// [`Layer::channels`] is disabled for that layer.
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
pub struct ChannelBlend {
pub mode: BlendMode,
pub opacity: f32,
}
impl Default for ChannelBlend {
fn default() -> Self {
ChannelBlend { mode: BlendMode::Normal, opacity: 1.0 }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Layer {
pub id: LayerId,
pub name: String,
pub visible: bool,
pub kind: LayerKind,
pub channels: BTreeMap<Channel, ChannelBlend>,
#[serde(default)]
pub mask: Option<Mask>,
/// Effects applied to the layer's content, bottom → top.
#[serde(default)]
pub content_effects: Vec<Effect>,
/// Color tag (0..8), shown as a stripe on the layer row.
#[serde(default)]
pub color_tag: Option<u8>,
/// Combine the mask with the layer's height ("mask with height").
#[serde(default)]
pub height_mask: HeightMask,
/// Geometry mask: the mesh parts (submesh names) the layer shows on; None shows it on all.
#[serde(default)]
pub geometry_mask: Option<Vec<String>>,
}
/// Mask with height: partial mask values follow the layer's own height, so a transition
/// reveals the high parts first. With mask `m` and the layer's height `h` (−1..1):
/// `m' = saturate(m + contrast · 4m(1 − m) · (h + offset))`. Fully hidden (0) and fully shown
/// (1) texels are unchanged, as is everything where the layer has no height.
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct HeightMask {
pub enabled: bool,
/// How strongly the height pushes the mask (0 = plain mask), 0..64.
pub contrast: f32,
/// Added to the height before it pushes the mask, −1..1.
pub offset: f32,
}
impl Default for HeightMask {
fn default() -> Self {
HeightMask { enabled: false, contrast: 1.0, offset: 0.0 }
}
}
impl HeightMask {
/// The mask `m` combined with height `h` (see [`HeightMask`]).
pub fn apply(&self, m: f32, h: f32) -> f32 {
if !self.enabled || !h.is_finite() {
return m;
}
(m + self.contrast * 4.0 * m * (1.0 - m) * (h + self.offset)).clamp(0.0, 1.0)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum LayerKind {
/// Painted pixels, stored per channel by the engine under the layer id.
Paint,
/// A procedural or uniform material applied everywhere (shaped by the mask).
Fill(Fill),
/// A folder of layers, bottom → top.
Group { children: Vec<LayerId>, collapsed: bool },
/// A linked instance of `source` (possibly in another texture set): renders the source's
/// content, content effects and channel blending, and its mask unless the instance has its
/// own. Edits to the source show in every instance.
Instance { source: LayerId },
}
impl LayerKind {
pub fn name(&self) -> &'static str {
match self {
LayerKind::Paint => "paint",
LayerKind::Fill(_) => "fill",
LayerKind::Group { .. } => "group",
LayerKind::Instance { .. } => "instance",
}
}
}
impl Layer {
/// A layer with every channel of `channels` enabled at Normal/100%.
pub fn new(id: LayerId, name: impl Into<String>, kind: LayerKind, channels: &[Channel]) -> Layer {
Layer {
id,
name: name.into(),
visible: true,
kind,
channels: channels.iter().map(|c| (*c, ChannelBlend::default())).collect(),
mask: None,
content_effects: Vec::new(),
color_tag: None,
height_mask: HeightMask::default(),
geometry_mask: None,
}
}
pub fn is_group(&self) -> bool {
matches!(self.kind, LayerKind::Group { .. })
}
pub fn children(&self) -> &[LayerId] {
match &self.kind {
LayerKind::Group { children, .. } => children,
_ => &[],
}
}
pub fn blend(&self, c: Channel) -> Option<ChannelBlend> {
self.channels.get(&c).copied()
}
/// The layer this one instances, if it is an instance.
pub fn instance_source(&self) -> Option<LayerId> {
match self.kind {
LayerKind::Instance { source } => Some(source),
_ => None,
}
}
}
/// Where a texture or procedural is sampled from on the surface.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Projection {
/// Texture coordinates of the mesh.
Uv { scale: [f32; 2], rotation: f32, offset: [f32; 2] },
/// World-space box projection blended by the normal.
Triplanar { scale: f32, sharpness: f32, offset: [f32; 3] },
/// World-space planar projection along an axis (0 = X, 1 = Y, 2 = Z).
Planar { scale: f32, axis: u8, offset: [f32; 3] },
/// Spherical projection around the mesh center.
Spherical { scale: f32 },
/// Cylindrical projection around an axis.
Cylindrical { scale: f32, axis: u8 },
/// A geometry decal: the image projected from a frame placed on the surface (outside the
/// frame, behind it or beyond its depth the fill does not cover).
Decal(Decal),
}
/// The frame a decal projects from (world space).
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
pub struct Decal {
/// The surface point the decal was placed on.
pub center: [f32; 3],
/// The surface normal there: the decal projects along it.
pub normal: [f32; 3],
/// Up direction of the unrotated frame.
pub up: [f32; 3],
/// Width and height (world units).
pub size: [f32; 2],
/// Rotation around the normal (degrees).
pub rotation: f32,
/// Shift of the frame from `center` along the unrotated right and up directions (world units).
pub offset: [f32; 2],
/// How far in front of and behind the frame the decal reaches (world units).
pub depth: f32,
/// A mirrored copy of the decal on the other side of the mesh (None: no copy). The copy
/// follows this frame, so moving, scaling or turning the decal moves it too.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub symmetry: Option<DecalSymmetry>,
/// Mirror the image inside the frame: left to right (`[0]`), top to bottom (`[1]`). Old projects have neither.
#[serde(default, skip_serializing_if = "not_flipped")]
pub flip: [bool; 2],
}
/// Serde helper: a decal that mirrors nothing saves without the field
fn not_flipped(flip: &[bool; 2]) -> bool {
!flip[0] && !flip[1]
}
impl Default for Projection {
fn default() -> Self {
Projection::Uv { scale: [1.0, 1.0], rotation: 0.0, offset: [0.0, 0.0] }
}
}
impl Projection {
pub fn label(&self) -> &'static str {
match self {
Projection::Uv { .. } => "UV projection",
Projection::Triplanar { .. } => "Tri-planar projection",
Projection::Planar { .. } => "Planar projection",
Projection::Spherical { .. } => "Spherical projection",
Projection::Cylindrical { .. } => "Cylindrical projection",
Projection::Decal(_) => "Decal projection",
}
}
}
/// Procedural patterns available to fills, generators and masks.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ProceduralKind {
/// Smooth fractal value noise.
Clouds,
/// Gradient (Perlin-style) noise.
Perlin,
/// Fine high-frequency noise.
Noise,
/// Worley / cellular noise.
Cells,
/// Blotchy grunge: thresholded multi-scale noise.
Grunge,
/// Thin random scratches.
Scratches,
/// Checkerboard.
Checker,
/// Stripes.
Stripes,
/// Linear gradient along U (or the projection axis).
Gradient,
/// Wood grain: growth rings with fibers along X.
Wood,
/// Running-bond bricks with mortar joints (0 = mortar).
Bricks,
/// Square tiles with grout joints (0 = grout).
Tiles,
/// Plain fabric weave.
Weave,
/// 2/2 twill: diagonal ribs, the warp brighter than the weft (denim, carbon fiber).
Twill,
/// Leather grain: pebbled cells with creases.
Leather,
/// Hammered metal dimples.
Hammered,
/// Fine brushed-metal lines along X.
Brushed,
/// Marble veins.
Marble,
/// Flat random tone per Voronoi cell (crystals, spangle, stones).
Voronoi,
/// Vertical streaks and leaks (along the projection's up axis).
Streaks,
/// Fingerprints and smudges.
Smudges,
/// Small round pores and pits (0 = pore).
Pores,
/// Sharp-edged paint chips.
Chips,
/// Hexagon tiles with joints (0 = joint).
HexagonTiles,
/// Rows of overlapping fan-shaped waves, each a set of concentric arcs.
WaveScales,
/// Herringbone planks with gaps and grain (0 = gap).
HerringbonePlanks,
/// A halftone screen: dots on a diagonal grid, growing and shrinking across the pattern.
HalftoneDots,
/// Raised diamonds of concentric rings on a twill ground.
DiamondBrocade,
/// Truchet tiles: quarter-circle arcs that join into winding paths.
TruchetArcs,
/// Long smooth locks of fur, shaded like a height map.
SmoothFur,
/// Crowded soft cloudlets over a dark sky.
MackerelSky,
/// Warped clouds crossed by fine strands.
Billow,
/// Overlapping reptile scales, domed and lit from above.
ReptileScales,
/// Young bark: tall plates parted by wandering furrows (0 = furrow).
Bark,
/// Rotting flesh: soft lobes, veins and patches of decay.
Flesh,
/// Four flat tones of interlocking blotches, for camouflage.
Camouflage,
/// Stockinette knit: V-shaped stitches of twisted yarn.
Knit,
/// A basket weave: threads in pairs, alternately across and down.
BasketWeave,
/// A goose-eye twill: diagonal ribs that turn back into small diamonds.
GooseEye,
/// Raw silk with slubs: threads that swell here and there.
SlubSilk,
/// Strip flooring: long boards with staggered butt joints (0 = gap).
StripFlooring,
/// Wood grain that bends around knots.
KnottyWood,
/// Shapes laid out in a grid of tiles, with the settings in [`Procedural::tile`]
TileGenerator,
}
impl ProceduralKind {
pub const ALL: [ProceduralKind; 43] = [
ProceduralKind::Clouds,
ProceduralKind::Perlin,
ProceduralKind::Noise,
ProceduralKind::Cells,
ProceduralKind::Grunge,
ProceduralKind::Scratches,
ProceduralKind::Checker,
ProceduralKind::Stripes,
ProceduralKind::Gradient,
ProceduralKind::Wood,
ProceduralKind::Bricks,
ProceduralKind::Tiles,
ProceduralKind::Weave,
ProceduralKind::Twill,
ProceduralKind::Leather,
ProceduralKind::Hammered,
ProceduralKind::Brushed,
ProceduralKind::Marble,
ProceduralKind::Voronoi,
ProceduralKind::Streaks,
ProceduralKind::Smudges,
ProceduralKind::Pores,
ProceduralKind::Chips,
ProceduralKind::HexagonTiles,
ProceduralKind::WaveScales,
ProceduralKind::HerringbonePlanks,
ProceduralKind::HalftoneDots,
ProceduralKind::DiamondBrocade,
ProceduralKind::TruchetArcs,
ProceduralKind::SmoothFur,
ProceduralKind::MackerelSky,
ProceduralKind::Billow,
ProceduralKind::ReptileScales,
ProceduralKind::Bark,
ProceduralKind::Flesh,
ProceduralKind::Camouflage,
ProceduralKind::Knit,
ProceduralKind::BasketWeave,
ProceduralKind::GooseEye,
ProceduralKind::SlubSilk,
ProceduralKind::StripFlooring,
ProceduralKind::KnottyWood,
ProceduralKind::TileGenerator,
];
pub fn label(self) -> &'static str {
match self {
ProceduralKind::Clouds => "Clouds",
ProceduralKind::Perlin => "Perlin noise",
ProceduralKind::Noise => "Fine noise",
ProceduralKind::Cells => "Cells",
ProceduralKind::Grunge => "Grunge",
ProceduralKind::Scratches => "Scratches",
ProceduralKind::Checker => "Checker",
ProceduralKind::Stripes => "Stripes",
ProceduralKind::Gradient => "Gradient",
ProceduralKind::Wood => "Wood grain",
ProceduralKind::Bricks => "Bricks",
ProceduralKind::Tiles => "Tiles",
ProceduralKind::Weave => "Fabric weave",
ProceduralKind::Twill => "Twill weave",
ProceduralKind::Leather => "Leather grain",
ProceduralKind::Hammered => "Hammered",
ProceduralKind::Brushed => "Brushed lines",
ProceduralKind::Marble => "Marble veins",
ProceduralKind::Voronoi => "Voronoi",
ProceduralKind::Streaks => "Streaks",
ProceduralKind::Smudges => "Fingerprints",
ProceduralKind::Pores => "Pores",
ProceduralKind::Chips => "Paint chips",
ProceduralKind::HexagonTiles => "Hexagon tiles",
ProceduralKind::WaveScales => "Wave scales",
ProceduralKind::HerringbonePlanks => "Herringbone planks",
ProceduralKind::HalftoneDots => "Halftone dots",
ProceduralKind::DiamondBrocade => "Diamond brocade",
ProceduralKind::TruchetArcs => "Truchet arcs",
ProceduralKind::SmoothFur => "Smooth fur",
ProceduralKind::MackerelSky => "Mackerel sky",
ProceduralKind::Billow => "Soft billow",
ProceduralKind::ReptileScales => "Reptile scales",
ProceduralKind::Bark => "Young bark",
ProceduralKind::Flesh => "Rotting flesh",
ProceduralKind::Camouflage => "Camouflage",
ProceduralKind::Knit => "Knit stitches",
ProceduralKind::BasketWeave => "Basket weave",
ProceduralKind::GooseEye => "Goose-eye twill",
ProceduralKind::SlubSilk => "Slub silk",
ProceduralKind::StripFlooring => "Strip flooring",
ProceduralKind::KnottyWood => "Knotty wood",
ProceduralKind::TileGenerator => "Tile Generator",
}
}
pub fn parse(name: &str) -> Option<ProceduralKind> {
let normalize = |text: &str| text.to_ascii_lowercase().replace([' ', '_', '-'], "");
let name = normalize(name);
ProceduralKind::ALL.into_iter().find(|kind| normalize(kind.label()) == name || normalize(&format!("{kind:?}")) == name)
}
}
/// A procedural grayscale pattern. Its output maps 0..1 between `low` and `high` values.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Procedural {
pub kind: ProceduralKind,
/// Pattern frequency (repeats per projection unit).
pub scale: f32,
pub seed: u32,
/// Contrast around 0.5 (1 = unchanged).
pub contrast: f32,
/// Shifts the pattern brighter (+) or darker (−).
pub balance: f32,
pub invert: bool,
/// The Tile Generator's settings; `None` for other kinds (and reads as the defaults); loaded in range, as drawing trusts them
#[serde(default, skip_serializing_if = "Option::is_none", deserialize_with = "tile_in_range")]
pub tile: Option<Box<TileGenerator>>,
/// The resolution the pattern is computed at before it is sampled onto the texture set
#[serde(default, skip_serializing_if = "OutputResolution::is_default")]
pub resolution: OutputResolution,
}
/// Saved Tile Generator settings brought into range (a saved project is hostile input)
fn tile_in_range<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<Option<Box<TileGenerator>>, D::Error> {
let saved: Option<Box<TileGenerator>> = Deserialize::deserialize(deserializer)?;
Ok(saved.map(|tile| Box::new(tile.clamped())))
}
impl Procedural {
/// The scales a command accepts (repeats per projection unit)
pub const MIN_SCALE: f32 = 0.001;
pub const MAX_SCALE: f32 = 1000.0;
/// The strongest contrast a command accepts, and the furthest balance either way
pub const MAX_CONTRAST: f32 = 20.0;
pub const MAX_BALANCE: f32 = 1.0;
pub fn new(kind: ProceduralKind) -> Procedural {
let tile = (kind == ProceduralKind::TileGenerator).then(Box::default);
// The Tile Generator lays its whole grid over one projection unit, as its tile counts set its frequency
let scale = if tile.is_some() { 1.0 } else { 4.0 };
Procedural { kind, scale, seed: 1, contrast: 1.0, balance: 0.0, invert: false, tile, resolution: OutputResolution::default() }
}
}
/// What a fill writes into one channel.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Source {
/// A constant value (linear RGB for colors; `[v, v, v]` for scalars).
Uniform([f32; 3]),
/// A procedural pattern mixing two values, or on a color channel colored by `ramp` when it
/// has stops (a gradient map: dark to light through evenly spaced linear RGB colors).
Procedural {
pattern: Procedural,
low: [f32; 3],
high: [f32; 3],
#[serde(default, skip_serializing_if = "Vec::is_empty")]
ramp: Vec<[f32; 3]>,
},
/// An imported image resource, by name. `normal_format` is the convention of a normal map
/// image (DirectX images have their green flipped where a normal channel samples them).
Image {
name: String,
#[serde(default)]
normal_format: crate::NormalFormat,
},
/// The stack value recorded by an anchor point effect (`anchor` is the effect id) for
/// `channel`; colors read as gray where a scalar is needed. On a color channel a `ramp` with
/// stops recolors the value by its lightness (a gradient map).
Anchor {
anchor: LayerId,
channel: Channel,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
ramp: Vec<[f32; 3]>,
},
}
impl Source {
pub fn uniform_of(c: Channel) -> Source {
Source::Uniform(c.default_value())
}
/// Image resource `name` (an OpenGL normal map where a normal channel samples it).
pub fn image(name: impl Into<String>) -> Source {
Source::Image { name: name.into(), normal_format: crate::NormalFormat::OpenGl }
}
/// The image resources this source reads: its image, or the images of a Tile Generator pattern
pub fn images(&self) -> Vec<&str> {
match self {
Source::Image { name, .. } => vec![name.as_str()],
Source::Procedural { pattern, .. } => pattern.tile.iter().flat_map(|tile| tile.images()).collect(),
Source::Uniform(_) | Source::Anchor { .. } => Vec::new(),
}
}
/// The gradient map stops of a procedural or anchor source (empty: none).
pub fn ramp(&self) -> &[[f32; 3]] {
match self {
Source::Procedural { ramp, .. } | Source::Anchor { ramp, .. } => ramp,
_ => &[],
}
}
/// The anchor point this source reads, if any.
pub fn anchor(&self) -> Option<LayerId> {
match self {
Source::Anchor { anchor, .. } => Some(*anchor),
_ => None,
}
}
}
/// A fill layer's material: one source per channel, plus how it is projected.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Fill {
pub sources: BTreeMap<Channel, Source>,
pub projection: Projection,
/// Set when the sources are maps cooked from a MaterialCraft material.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub link: Option<Box<MaterialLink>>,
}
/// A MaterialCraft material behind a fill (from a `.mcmat` portable material): its channel
/// sources are image resources cooked from the graph, and changing a parameter re-cooks them
/// through `materialcraft-cli`.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct MaterialLink {
pub name: String,
/// The image resource holding the material's package (`.mcraft`).
pub package: String,
/// The package's graph the maps come from.
pub graph: String,
pub params: Vec<LinkParam>,
#[serde(default)]
pub presets: Vec<LinkPreset>,
/// Image inputs of the graph (identifiers such as `curvature`), fed from baked mesh maps.
#[serde(default)]
pub inputs: Vec<String>,
/// Size the maps were cooked at (pixels across).
pub size: u32,
}
/// An exposed input of a linked material. Values keep MaterialCraft's typed form,
/// `{"t": "float" | "float2" | "float3" | "float4" | "int" | "int2" | "bool" | "color" | "enum", "v": …}`.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LinkParam {
pub id: String,
pub label: String,
#[serde(default)]
pub group: String,
pub value: serde_json::Value,
pub default: serde_json::Value,
#[serde(default)]
pub min: f32,
#[serde(default = "one")]
pub max: f32,
/// Labels of an `enum` value.
#[serde(default)]
pub options: Vec<String>,
}
fn one() -> f32 {
1.0
}
/// A named set of linked-material values.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LinkPreset {
pub name: String,
pub values: BTreeMap<String, serde_json::Value>,
}
impl Fill {
/// Value used for `c` when the fill has no source for it: the channel default.
pub fn source(&self, c: Channel) -> Source {
self.sources.get(&c).cloned().unwrap_or_else(|| Source::uniform_of(c))
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
pub enum MaskBackground {
#[default]
White,
Black,
}
/// A layer mask: a background color with a stack of effects on top.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Mask {
pub enabled: bool,
pub background: MaskBackground,
/// Effects bottom → top. Paint effects hold bitmap data keyed by their id.
pub effects: Vec<Effect>,
}
impl Mask {
pub fn new(background: MaskBackground) -> Mask {
Mask { enabled: true, background, effects: Vec::new() }
}
}
/// Levels remap: input range, gamma, output range.
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
pub struct Levels {
pub in_low: f32,
pub in_high: f32,
pub gamma: f32,
pub out_low: f32,
pub out_high: f32,
}
impl Default for Levels {
fn default() -> Self {
Levels { in_low: 0.0, in_high: 1.0, gamma: 1.0, out_low: 0.0, out_high: 1.0 }
}
}
impl Levels {
pub fn apply(&self, x: f32) -> f32 {
let t = ((x - self.in_low) / (self.in_high - self.in_low).max(1e-5)).clamp(0.0, 1.0);
let t = t.powf(1.0 / self.gamma.max(1e-3));
self.out_low + (self.out_high - self.out_low) * t
}
}
/// Mesh-map driven mask generators (the "smart mask" building blocks).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum GeneratorKind {
/// Convex edges from the curvature map.
EdgeWear,
/// Crevices from ambient occlusion.
Dirt,
/// Thin parts from the thickness map.
ThinAreas,
/// Raw curvature.
Curvature,
/// Raw ambient occlusion.
AmbientOcclusion,
/// Gradient along a world axis (bottom → top by default).
Position,
/// Surfaces facing a direction (e.g. up for dust).
Direction,
}
impl GeneratorKind {
pub const ALL: [GeneratorKind; 7] = [
GeneratorKind::EdgeWear,
GeneratorKind::Dirt,
GeneratorKind::ThinAreas,
GeneratorKind::Curvature,
GeneratorKind::AmbientOcclusion,
GeneratorKind::Position,
GeneratorKind::Direction,
];
pub fn label(self) -> &'static str {
match self {
GeneratorKind::EdgeWear => "Mask Editor: Edge wear",
GeneratorKind::Dirt => "Dirt",
GeneratorKind::ThinAreas => "Thin areas",
GeneratorKind::Curvature => "Curvature",
GeneratorKind::AmbientOcclusion => "Ambient occlusion",
GeneratorKind::Position => "Position gradient",
GeneratorKind::Direction => "Light / direction",
}
}
/// The mesh maps this kind reads, each an input that an image, a uniform value or an anchor can replace.
pub fn inputs(self) -> &'static [BakedMap] {
match self {
GeneratorKind::EdgeWear | GeneratorKind::Curvature => &[BakedMap::Curvature],
GeneratorKind::Dirt | GeneratorKind::AmbientOcclusion => &[BakedMap::AmbientOcclusion],
GeneratorKind::ThinAreas => &[BakedMap::Thickness],
GeneratorKind::Position | GeneratorKind::Direction => &[],
}
}
pub fn parse(s: &str) -> Option<GeneratorKind> {
let norm = |x: &str| x.to_ascii_lowercase().replace([' ', '_', '-', ':'], "");
GeneratorKind::ALL.into_iter().find(|k| norm(&format!("{k:?}")) == norm(s) || norm(k.label()) == norm(s))
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Generator {
pub kind: GeneratorKind,
/// Where the mask starts (0..1, generator specific threshold).
pub level: f32,
/// Edge softness (0 = hard).
pub softness: f32,
/// Breaks the result up with world-space noise (0 = none).
pub noise_amount: f32,
pub noise_scale: f32,
pub seed: u32,
/// Added to the finished mask value and clamped to 0..1 (−1..1; 0 = unchanged).
#[serde(default)]
pub offset: f32,
/// Direction for `Position` / `Direction` generators (world space).
pub direction: [f32; 3],
pub invert: bool,
/// Mode and detail sizes of `Curvature` / `EdgeWear` generators (None: the curvature map as baked, as before detail sizes existed).
#[serde(default, skip_serializing_if = "Option::is_none")]
pub detail: Option<CurvatureDetail>,
/// Blur, balance and contrast of the finished value (neutral for generators saved before they existed).
#[serde(default, skip_serializing_if = "GeneratorGlobal::is_neutral")]
pub global: GeneratorGlobal,
/// The resolution the generator is computed at (the texture set's for generators saved before it existed).
#[serde(default, skip_serializing_if = "OutputResolution::is_default")]
pub resolution: OutputResolution,
/// What an input reads instead of its mesh map (an image, a uniform value or an anchor); inputs not listed read their mesh map.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub inputs: BTreeMap<BakedMap, Source>,
/// Painted height read from an anchor point below, added as micro detail (None: baked maps only).
#[serde(default, skip_serializing_if = "Option::is_none")]
pub micro: Option<MicroDetail>,
}
impl Generator {
/// The softest a ramp gets, so its threshold never divides by zero.
pub const MIN_SOFTNESS: f32 = 1e-3;
/// The most noise a generator mixes in, and the range of its noise scale.
pub const MAX_NOISE_AMOUNT: f32 = 2.0;
pub const MIN_NOISE_SCALE: f32 = 0.01;
pub const MAX_NOISE_SCALE: f32 = 1000.0;
pub fn new(kind: GeneratorKind) -> Generator {
let (level, softness, noise_amount) = match kind {
GeneratorKind::EdgeWear => (0.5, 0.25, 0.3),
GeneratorKind::Curvature => (0.5, 0.5, 0.0),
GeneratorKind::Dirt => (0.55, 0.25, 0.35),
GeneratorKind::ThinAreas => (0.3, 0.2, 0.0),
_ => (0.5, 0.25, 0.0),
};
let detail = match kind {
GeneratorKind::Curvature => Some(CurvatureDetail::default()),
GeneratorKind::EdgeWear => Some(CurvatureDetail { mode: CurvatureMode::Edges, weights: CurvatureDetail::EDGE_WEIGHTS }),
_ => None,
};
Generator {
kind,
level,
softness,
noise_amount,
noise_scale: 8.0,
seed: 7,
offset: 0.0,
direction: [0.0, 1.0, 0.0],
invert: false,
detail,
global: GeneratorGlobal::default(),
resolution: OutputResolution::default(),
inputs: BTreeMap::new(),
micro: None,
}
}
/// The mask value for a (noise-broken) signal `s`: the smooth threshold at `level` over
/// `softness`, inverted if asked, then shifted by `offset` (a non-finite offset counts as 0).
pub fn shape(&self, s: f32) -> f32 {
let th = 1.0 - self.level.clamp(0.0, 1.0);
let soft = self.softness.max(1e-3);
let t = ((s - (th - soft)) / (2.0 * soft)).clamp(0.0, 1.0);
let v = t * t * (3.0 - 2.0 * t);
let v = if self.invert { 1.0 - v } else { v };
let offset = if self.offset.is_finite() { self.offset } else { 0.0 };
(v + offset).clamp(0.0, 1.0)
}
}
/// Filters usable on masks and content.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Filter {
Blur {
radius: f32,
},
Sharpen {
amount: f32,
},
Invert,
Threshold {
level: f32,
},
/// Hue/saturation/lightness shift (color channels; lightness only on grays and masks).
/// `hue` is in turns, `saturation` and `lightness` in −1..1; all zero = unchanged.
Hsl {
hue: f32,
saturation: f32,
lightness: f32,
},
/// Contrast around mid gray and a luminosity shift, both −1..1 (0 = unchanged).
ContrastLuminosity {
contrast: f32,
luminosity: f32,
},
/// Color offsets (−1..1 per component) weighted towards the shadows, midtones and highlights.
ColorBalance {
shadows: [f32; 3],
midtones: [f32; 3],
highlights: [f32; 3],
},
/// Luminance mapped through evenly spaced colors (linear RGB; scalars read their gray).
GradientMap {
colors: Vec<[f32; 3]>,
},
/// Quantize to `levels` steps (2..64).
Posterize {
levels: f32,
},
/// Keep values within `min..max`.
Clamp {
min: f32,
max: f32,
},
/// A ramp slid through the values: those above `position` go towards white, those below
/// towards black, over a width `contrast` (0..1) narrows to a hard step.
HistogramScan {
position: f32,
contrast: f32,
},
/// The values squeezed towards `position`: `range` 1 keeps them, 0 sets them all to it.
HistogramRange {
range: f32,
position: f32,
},
/// The values offset by `offset` (−1..1), wrapping around past white and black.
HistogramShift {
offset: f32,
},
/// Shift each texel's lookup along a noise vector field: `intensity` in texels at 2K,
/// `scale` noise features per UV unit.
Warp {
intensity: f32,
scale: f32,
seed: u32,
},
/// Blur along one direction: `radius` in texels at 2K, `angle` in degrees.
DirectionalBlur {
radius: f32,
angle: f32,
},
/// Smear values downhill along a noise height field ("slope blur"): `radius` in texels at
/// 2K, `scale` noise features per UV unit.
SlopeBlur {
radius: f32,
scale: f32,
seed: u32,
},
/// The detail finer than `radius` (texels at 2K) around mid gray: the value minus its blur.
HighPass {
radius: f32,
},
/// Gradient magnitude across `width` texels at 2K: edges light, flat areas black.
EdgeDetect {
width: f32,
},
/// Like [`Filter::Warp`], but every texel moves along one direction (`angle` in degrees).
DirectionalWarp {
intensity: f32,
angle: f32,
scale: f32,
seed: u32,
},
/// Colors to their luminance (scalars and masks unchanged).
Grayscale,
/// Flip the green component of normal maps (OpenGL ↔ DirectX); other channels unchanged.
NormalInvert,
/// Shapes rounded off at their edges: values ramp up from 0 at a shape's edge to their own
/// level over about `width` texels at 2K (a mask's or height's bevel).
Bevel {
width: f32,
},
/// Square cells `size` texels at 2K across, each the value at its center.
Mosaic {
size: f32,
},
/// Adds a blur of the values (`radius` texels at 2K) times `amount`: light bleeds around
/// bright areas.
Glow {
radius: f32,
amount: f32,
},
/// Lighting painted into the base color: `ambient` (times the baked ambient occlusion by
/// `occlusion`) plus a directional light of strength `light` from `azimuth` around +Y
/// (degrees from +Z) and `elevation` above the horizon (degrees), on the mesh's normals.
BakedLighting {
azimuth: f32,
elevation: f32,
light: f32,
ambient: f32,
occlusion: f32,
},
/// Colors near `from` (within `tolerance`, fading out over `softness`, as RGB distance
/// 0..1) shifted by `to − from`, so their shading and texture stay (linear RGB).
ReplaceColor {
from: [f32; 3],
to: [f32; 3],
tolerance: f32,
softness: f32,
},
}
/// Push `x` (0..1) towards 1 (`amount` > 0) or 0 (`amount` < 0); `amount` in −1..1.
fn shift_unit(x: f32, amount: f32) -> f32 {
let a = amount.clamp(-1.0, 1.0);
if a >= 0.0 { x + (1.0 - x) * a } else { x * (1.0 + a) }
}
fn hue_to_rgb(p: f32, q: f32, t: f32) -> f32 {
let t = t.rem_euclid(1.0);
if t < 1.0 / 6.0 {
p + (q - p) * 6.0 * t
} else if t < 0.5 {
q
} else if t < 2.0 / 3.0 {
p + (q - p) * (2.0 / 3.0 - t) * 6.0
} else {
p
}
}
/// HSL adjustment of a 0..1 color (see [`Filter::Hsl`]). A gray stays gray and only its
/// lightness changes.
pub fn hsl_adjust(rgb: [f32; 3], hue: f32, saturation: f32, lightness: f32) -> [f32; 3] {
let [r, g, b] = rgb.map(|v| if v.is_finite() { v.clamp(0.0, 1.0) } else { 0.0 });
let (mx, mn) = (r.max(g).max(b), r.min(g).min(b));
let (d, l) = (mx - mn, (mx + mn) * 0.5);
let (h, s) = if d <= 1e-6 {
(0.0, 0.0)
} else {
let s = if l > 0.5 { d / (2.0 - mx - mn) } else { d / (mx + mn) };
let h = if mx == r {
((g - b) / d).rem_euclid(6.0)
} else if mx == g {
(b - r) / d + 2.0
} else {
(r - g) / d + 4.0
};
(h / 6.0, s)
};
let h = h + if hue.is_finite() { hue } else { 0.0 };
let (s, l) = (if d <= 1e-6 { 0.0 } else { shift_unit(s, saturation) }, shift_unit(l, lightness));
if s <= 0.0 {
return [l; 3];
}
let q = if l < 0.5 { l * (1.0 + s) } else { l + s - l * s };
let p = 2.0 * l - q;
[hue_to_rgb(p, q, h + 1.0 / 3.0), hue_to_rgb(p, q, h), hue_to_rgb(p, q, h - 1.0 / 3.0)]
}
/// Apply a 0..1 function to each component of a channel value: signed values map through
/// 0..1, normals are left alone.
pub fn per_unit(kind: ChannelKind, v: [f32; 3], f: impl Fn(f32) -> f32) -> [f32; 3] {
match kind {
ChannelKind::NormalMap => v,
// One-component channels hold their value in the first slot (read as gray).
ChannelKind::Signed => [f(v[0] * 0.5 + 0.5) * 2.0 - 1.0; 3],
ChannelKind::Scalar => [f(v[0]); 3],
ChannelKind::Color => v.map(f),
}
}
/// The color at `t` (0..1) of a gradient through evenly spaced `colors` (None when empty).
pub fn gradient(colors: &[[f32; 3]], t: f32) -> Option<[f32; 3]> {
let last = colors.len().checked_sub(1)?;
let pos = if t.is_finite() { t.clamp(0.0, 1.0) * last as f32 } else { 0.0 };
let i = (pos.floor() as usize).min(last);
let (a, b) = (colors.get(i)?, colors.get((i + 1).min(last))?);
let f = pos - i as f32;
Some(std::array::from_fn(|k| a[k] + (b[k] - a[k]) * f))
}
impl Filter {
/// Whether the filter reads neighbouring texels (the compositor runs it over a region).
pub fn is_neighbourhood(&self) -> bool {
matches!(
self,
Filter::Blur { .. }
| Filter::Sharpen { .. }
| Filter::Warp { .. }
| Filter::DirectionalBlur { .. }
| Filter::SlopeBlur { .. }
| Filter::HighPass { .. }
| Filter::EdgeDetect { .. }
| Filter::DirectionalWarp { .. }
| Filter::Bevel { .. }
| Filter::Mosaic { .. }
| Filter::Glow { .. }
)
}
/// The filter applied to one value of a channel of `kind` (masks are scalars). None for
/// neighbourhood filters and where it changes nothing (an empty gradient).
pub fn point(&self, kind: ChannelKind, v: [f32; 3]) -> Option<[f32; 3]> {
let unit = |x: f32| if x.is_finite() { x.clamp(0.0, 1.0) } else { 0.0 };
Some(match self {
Filter::Invert => per_unit(kind, v, |x| 1.0 - x),
Filter::Threshold { level } => per_unit(kind, v, |x| if x >= *level { 1.0 } else { 0.0 }),
Filter::Hsl { hue, saturation, lightness } => match kind {
ChannelKind::Color => hsl_adjust(v, *hue, *saturation, *lightness),
_ => per_unit(kind, v, |x| hsl_adjust([x; 3], 0.0, 0.0, *lightness)[0]),
},
Filter::ContrastLuminosity { contrast, luminosity } => {
let k = 1.0 + contrast.clamp(-1.0, 1.0);
per_unit(kind, v, |x| unit((x - 0.5) * k + 0.5 + luminosity))
}
Filter::ColorBalance { shadows, midtones, highlights } => {
// Smooth weights summing to 1: shadows fade out and highlights in with lightness.
let weights = |l: f32| {
let l = unit(l);
((1.0 - l) * (1.0 - l), 2.0 * l * (1.0 - l), l * l)
};
let shift = |k: usize, l: f32| {
let (s, m, h) = weights(l);
shadows.get(k).copied().unwrap_or(0.0) * s + midtones.get(k).copied().unwrap_or(0.0) * m + highlights.get(k).copied().unwrap_or(0.0) * h
};
match kind {
ChannelKind::Color => {
let l = lum(v);
std::array::from_fn(|k| unit(v[k] + shift(k, l)))
}
_ => per_unit(kind, v, |x| unit(x + (shift(0, x) + shift(1, x) + shift(2, x)) / 3.0)),
}
}
Filter::GradientMap { colors } => match kind {
ChannelKind::Color => gradient(colors, lum(v))?,
_ => per_unit(kind, v, |x| gradient(colors, x).map_or(x, lum)),
},
Filter::Posterize { levels } => {
let steps = (levels.clamp(2.0, 64.0).round() - 1.0).max(1.0);
per_unit(kind, v, |x| (unit(x) * steps).round() / steps)
}
Filter::Clamp { min, max } => {
let (lo, hi) = (min.min(*max), min.max(*max));
per_unit(kind, v, |x| x.max(lo).min(hi))
}
// Full contrast is a threshold: the position itself goes to white.
Filter::HistogramScan { position, contrast } if *contrast >= 1.0 => per_unit(kind, v, |x| if x >= *position { 1.0 } else { 0.0 }),
Filter::HistogramScan { position, contrast } => {
let width = (1.0 - contrast.clamp(0.0, 1.0)).max(1e-3);
per_unit(kind, v, |x| unit((x - position) / width + 0.5))
}
Filter::HistogramRange { range, position } => per_unit(kind, v, |x| unit(position + (x - position) * range)),
Filter::HistogramShift { offset } => per_unit(kind, v, |x| {
// Wrapped by hand: `rem_euclid` would also send white (1 + 0) to black.
let y = unit(x) + offset.clamp(-1.0, 1.0);
unit(if y > 1.0 {
y - 1.0
} else if y < 0.0 {
y + 1.0
} else {
y
})
}),
Filter::Grayscale => match kind {
ChannelKind::Color => [lum(v); 3],
_ => v,
},
Filter::NormalInvert => match kind {
ChannelKind::NormalMap => [v[0], 1.0 - v[1], v[2]],
_ => v,
},
Filter::ReplaceColor { from, to, tolerance, softness } => match kind {
ChannelKind::Color => {
let d = ((v[0] - from[0]).powi(2) + (v[1] - from[1]).powi(2) + (v[2] - from[2]).powi(2)).sqrt() / 3f32.sqrt();
let (t, s) = (tolerance.clamp(0.0, 1.0), softness.clamp(0.0, 1.0));
let w = if d <= t {
1.0
} else if d >= t + s {
0.0
} else {
let x = 1.0 - (d - t) / s.max(1e-6);
x * x * (3.0 - 2.0 * x)
};
std::array::from_fn(|k| unit(v[k] + (to[k] - from[k]) * w))
}
_ => v,
},
Filter::Blur { .. }
| Filter::Sharpen { .. }
| Filter::Warp { .. }
| Filter::DirectionalBlur { .. }
| Filter::SlopeBlur { .. }
| Filter::HighPass { .. }
| Filter::EdgeDetect { .. }
| Filter::DirectionalWarp { .. }
| Filter::Bevel { .. }
| Filter::Mosaic { .. }
| Filter::Glow { .. }
| Filter::BakedLighting { .. } => return None,
})
}
pub fn label(&self) -> &'static str {
match self {
Filter::Blur { .. } => "Blur",
Filter::Sharpen { .. } => "Sharpen",
Filter::Invert => "Invert",
Filter::Threshold { .. } => "Threshold",
Filter::Hsl { .. } => "HSL Perceptive",
Filter::ContrastLuminosity { .. } => "Contrast/Luminosity",
Filter::ColorBalance { .. } => "Color Balance",
Filter::GradientMap { .. } => "Gradient Map",
Filter::Posterize { .. } => "Posterize",
Filter::Clamp { .. } => "Clamp",
Filter::HistogramScan { .. } => "Histogram Scan",
Filter::HistogramRange { .. } => "Histogram Range",
Filter::HistogramShift { .. } => "Histogram Shift",
Filter::Warp { .. } => "Warp",
Filter::DirectionalBlur { .. } => "Blur Directional",
Filter::SlopeBlur { .. } => "Slope Blur",
Filter::HighPass { .. } => "High Pass",
Filter::EdgeDetect { .. } => "Edge Detect",
Filter::DirectionalWarp { .. } => "Warp Directional",
Filter::Grayscale => "Grayscale",
Filter::NormalInvert => "Normal Invert",
Filter::Bevel { .. } => "Bevel",
Filter::Mosaic { .. } => "Mosaic",
Filter::Glow { .. } => "Glow",
Filter::BakedLighting { .. } => "Baked Lighting",
Filter::ReplaceColor { .. } => "Replace Color",
}
}
/// Baked lighting's factor on the base color of a surface facing `nrm` (world space) with
/// ambient occlusion `ao` (None for other filters).
pub fn baked_light(&self, nrm: [f32; 3], ao: f32) -> Option<f32> {
let Filter::BakedLighting { azimuth, elevation, light, ambient, occlusion } = self else { return None };
let (sa, ca) = azimuth.to_radians().sin_cos();
let (se, ce) = elevation.to_radians().sin_cos();
let facing = (nrm[0] * ce * sa + nrm[1] * se + nrm[2] * ce * ca).max(0.0);
let ao = if ao.is_finite() { ao.clamp(0.0, 1.0) } else { 1.0 };
let k = ambient * (1.0 + (ao - 1.0) * occlusion.clamp(0.0, 1.0)) + light * facing;
Some(if k.is_finite() { k.max(0.0) } else { 1.0 })
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum EffectKind {
/// Painted grayscale (mask) or material (content) pixels keyed by the effect id.
Paint,
/// A path sublayer: pixels keyed by the effect id like [`EffectKind::Paint`], but painted
/// only from its stored paths and repainted whenever one is added, edited or removed.
Path(Vec<PathShape>),
/// A uniform or procedural grayscale fill.
Fill {
source: Source,
projection: Projection,
},
Generator(Generator),
Levels(Levels),
Filter(Filter),
/// Select ID-map colors within a tolerance.
ColorSelection {
colors: Vec<[f32; 3]>,
tolerance: f32,
},
/// Compare the mask with a constant.
Compare {
op: CompareOp,
value: f32,
tolerance: f32,
},
/// Content only: a material fill (one source per channel; channels without a source are
/// left as they are).
Material(Fill),
/// Records the stack at its place so masks, fills and generators above can read it
/// ([`Source::Anchor`]). In a content stack it records the composited stack right after its
/// layer (that layer and everything below); in a mask, the mask value at that point (every
/// channel reads that gray).
Anchor,
}
/// One path of a path sublayer: its control points and how it was painted.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PathShape {
/// Surface positions (3D view) or texture coordinates with z = 0 (2D view).
pub points: Vec<[f32; 3]>,
/// Per point: the curve turns sharply there instead of passing smoothly through. Empty (and absent from old
/// projects) when every point is smooth; a missing entry is smooth too.
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub corners: Vec<bool>,
pub uv: bool,
pub closed: bool,
/// A closed path fills its interior instead of stroking the curve.
pub fill: bool,
/// Viewport size (pixels) the path was painted in.
pub viewport: [f32; 2],
/// Brush, material and camera the engine paints the path with (owned by the engine).
pub paint: serde_json::Value,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum CompareOp {
LesserThan,
WithinTolerance,
GreaterThan,
}
impl EffectKind {
pub fn name(&self) -> &'static str {
match self {
EffectKind::Paint => "Paint",
EffectKind::Path(_) => "Path",
EffectKind::Fill { .. } => "Fill",
EffectKind::Generator(_) => "Generator",
EffectKind::Levels(_) => "Levels",
EffectKind::Filter(f) => f.label(),
EffectKind::ColorSelection { .. } => "Color selection",
EffectKind::Compare { .. } => "Compare mask",
EffectKind::Material(_) => "Fill",
EffectKind::Anchor => "Anchor point",
}
}
/// Whether the effect belongs in a layer's content stack (`true`), its mask (`false`), or
/// both (`None`).
pub fn content_only(&self) -> Option<bool> {
match self {
EffectKind::Material(_) => Some(true),
EffectKind::Fill { .. } | EffectKind::Generator(_) | EffectKind::ColorSelection { .. } | EffectKind::Compare { .. } => Some(false),
EffectKind::Paint | EffectKind::Path(_) | EffectKind::Levels(_) | EffectKind::Filter(_) | EffectKind::Anchor => None,
}
}
/// Holds painted pixels keyed by the effect id (paint and path sublayers).
pub fn painted(&self) -> bool {
matches!(self, EffectKind::Paint | EffectKind::Path(_))
}
/// Whether a source of this effect (a fill, a material or a generator input) reads an anchor point.
fn reads_anchor(&self) -> bool {
match self {
EffectKind::Fill { source, .. } => source.anchor().is_some(),
EffectKind::Material(fill) => fill.sources.values().any(|source| source.anchor().is_some()),
EffectKind::Generator(generator) => generator.micro.is_some() || generator.inputs.values().any(|source| source.anchor().is_some()),
_ => false,
}
}
/// The anchor points this effect's sources read, with the channel each reads.
pub fn anchors_read(&self) -> Vec<(LayerId, Channel)> {
let sources: Vec<&Source> = match self {
EffectKind::Fill { source, .. } => vec![source],
EffectKind::Material(fill) => fill.sources.values().collect(),
EffectKind::Generator(generator) => generator.inputs.values().collect(),
_ => Vec::new(),
};
let mut anchors: Vec<_> = sources
.into_iter()
.filter_map(|source| match source {
Source::Anchor { anchor, channel, .. } => Some((*anchor, *channel)),
_ => None,
})
.collect();
if let EffectKind::Generator(generator) = self
&& let Some(micro) = generator.micro
{
anchors.push((micro.anchor, Channel::Height));
}
anchors
}
/// The image resources this effect's sources read (a fill, its patterns, a material or a generator input)
pub fn images_read(&self) -> impl Iterator<Item = &str> {
let sources: Vec<&Source> = match self {
EffectKind::Fill { source, .. } => vec![source],
EffectKind::Material(fill) => fill.sources.values().collect(),
EffectKind::Generator(generator) => generator.inputs.values().collect(),
_ => Vec::new(),
};
sources.into_iter().flat_map(Source::images)
}
}
impl Layer {
/// Whether any source of the layer (fill, mask or content effects) reads an anchor point.
pub fn reads_anchor(&self) -> bool {
let fill = match &self.kind {
LayerKind::Fill(f) => f.sources.values().any(|s| s.anchor().is_some()),
_ => false,
};
fill || self.mask.iter().flat_map(|m| m.effects.iter()).chain(self.content_effects.iter()).any(|e| e.kind.reads_anchor())
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Effect {
pub id: LayerId,
pub name: String,
pub visible: bool,
pub kind: EffectKind,
pub blend: BlendMode,
pub opacity: f32,
}
impl Effect {
pub fn new(id: LayerId, kind: EffectKind) -> Effect {
// Generators and fills that build a mask usually add on top of the background
Effect { id, name: kind.name().to_string(), visible: true, kind, blend: BlendMode::Normal, opacity: 1.0 }
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_decal_saved_without_symmetry_loads_unchanged_and_saves_without_it() {
let old = r#"{"center":[0.0,0.0,1.0],"normal":[0.0,0.0,1.0],"up":[0.0,1.0,0.0],"size":[1.0,1.0],"rotation":0.0,"offset":[0.0,0.0],"depth":0.5}"#;
let decal: Decal = serde_json::from_str(old).unwrap();
assert_eq!(decal.symmetry, None);
assert_eq!(serde_json::to_string(&decal).unwrap(), old.replace(' ', ""), "nothing new is written for a decal without a copy");
let mirrored = Decal { symmetry: Some(DecalSymmetry { axis: 2, flip: DecalFlip::V, offset: 0.0 }), ..decal };
let json = serde_json::to_string(&mirrored).unwrap();
assert!(json.contains(r#""symmetry":{"axis":2,"flip":"v"}"#), "{json}");
assert_eq!(serde_json::from_str::<Decal>(&json).unwrap(), mirrored);
let without_flip = json.replace(r#","flip":"v""#, "");
assert_eq!(serde_json::from_str::<Decal>(&without_flip).unwrap().symmetry, Some(DecalSymmetry { axis: 2, flip: DecalFlip::None, offset: 0.0 }));
// The plane's offset is written only when it is not zero
let moved = Decal { symmetry: Some(DecalSymmetry { axis: 1, flip: DecalFlip::None, offset: -0.25 }), ..decal };
let json = serde_json::to_string(&moved).unwrap();
assert!(json.contains(r#""offset":-0.25}"#), "{json}");
assert_eq!(serde_json::from_str::<Decal>(&json).unwrap(), moved);
}
#[test]
fn material_effect_images_are_reported_as_used() {
let mut fill = Fill::default();
fill.sources.insert(Channel::BaseColor, Source::image("material.png"));
let effect = EffectKind::Material(fill);
assert_eq!(effect.images_read().collect::<Vec<_>>(), vec!["material.png"]);
}
#[test]
fn generator_offset_shifts_the_mask_value() {
let mut g = Generator::new(GeneratorKind::Position);
let base = g.shape(0.2);
assert!(base < 0.5);
g.offset = 0.3;
assert!((g.shape(0.2) - (base + 0.3)).abs() < 1e-6, "the offset is added");
g.offset = 1.0;
assert_eq!(g.shape(0.2), 1.0, "and the result is clamped");
g.offset = -1.0;
assert_eq!(g.shape(0.9), 0.0);
}
#[test]
fn generator_non_finite_offset_counts_as_zero() {
let mut g = Generator::new(GeneratorKind::Position);
let base: Vec<f32> = [0.0, 0.2, 0.5, 0.9].iter().map(|&s| g.shape(s)).collect();
for bad in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {
g.offset = bad;
let got: Vec<f32> = [0.0, 0.2, 0.5, 0.9].iter().map(|&s| g.shape(s)).collect();
assert_eq!(got, base, "offset {bad} behaves like 0");
}
}
#[test]
fn patterns_saved_before_tile_settings_keep_their_form() {
let saved = serde_json::json!({"kind": "Clouds", "scale": 4.0, "seed": 1, "contrast": 1.0, "balance": 0.0, "invert": false});
let loaded: Procedural = serde_json::from_value(saved.clone()).unwrap();
assert_eq!(loaded, Procedural::new(ProceduralKind::Clouds));
assert_eq!(serde_json::to_value(&loaded).unwrap(), saved, "a pattern at its defaults saves as before");
let tile = serde_json::to_value(Procedural::new(ProceduralKind::TileGenerator)).unwrap();
assert!(
tile.get("tile").is_some() && tile.get("resolution").is_none(),
"only the Tile Generator carries tile settings, and a default resolution is not saved"
);
}
#[test]
fn tile_settings_saved_with_missing_or_hostile_values_load_in_range() {
let tile = serde_json::json!({"amount": [0, 4000], "specific": 7.0, "quarter_turns": 6, "inputs": ["a", "b", "c", "d", "e", "f", "g"]});
let saved = serde_json::json!({"kind": "TileGenerator", "scale": 1.0, "seed": 1, "contrast": 1.0, "balance": 0.0, "invert": false, "tile": tile});
let loaded: Procedural = serde_json::from_value(saved).unwrap();
let tile = loaded.tile.unwrap();
assert_eq!(tile.amount, [1, 64]);
assert_eq!(tile.specific, 1.0);
assert_eq!(tile.quarter_turns, 2);
assert_eq!(tile.inputs.len(), TileGenerator::MAX_INPUTS);
assert_eq!(tile.middle_size, TileGenerator::default().middle_size, "a missing setting reads its default");
let not_finite = TileGenerator { scale: f32::NAN, rotation: f32::INFINITY, ..TileGenerator::default() }.clamped();
assert_eq!((not_finite.scale, not_finite.rotation), (1.0, 0.0));
}
#[test]
fn curvature_generators_saved_before_detail_sizes_load_without_them() {
let mut saved = serde_json::to_value(Generator::new(GeneratorKind::Curvature)).unwrap();
assert!(saved.get("detail").is_some(), "new curvature generators have detail sizes");
saved.as_object_mut().unwrap().remove("detail");
let loaded: Generator = serde_json::from_value(saved).unwrap();
assert_eq!(loaded.detail, None);
assert_eq!(Generator::new(GeneratorKind::Dirt).detail, None, "only curvature and edge wear generators have detail sizes");
}
#[test]
fn generators_saved_before_the_new_settings_load_and_save_unchanged() {
let saved = serde_json::to_value(Generator::new(GeneratorKind::Dirt)).unwrap();
for field in ["global", "resolution", "inputs"] {
assert!(saved.get(field).is_none(), "a default `{field}` is not written, so saved files stay as they were");
}
let loaded: Generator = serde_json::from_value(saved).unwrap();
assert!(loaded.global.is_neutral());
let mut blurred = Generator::new(GeneratorKind::Dirt);
blurred.global.blur = 0.5;
let round_trip: Generator = serde_json::from_value(serde_json::to_value(&blurred).unwrap()).unwrap();
assert_eq!(round_trip, blurred);
}
#[test]
fn levels_map_range_and_gamma() {
let l = Levels { in_low: 0.2, in_high: 0.6, gamma: 1.0, out_low: 0.0, out_high: 1.0 };
assert!((l.apply(0.4) - 0.5).abs() < 1e-6);
assert_eq!(l.apply(0.0), 0.0);
assert_eq!(l.apply(1.0), 1.0);
let g = Levels { gamma: 2.0, ..Levels::default() };
assert!((g.apply(0.25) - 0.5).abs() < 1e-6);
// Degenerate ranges never divide by zero.
let d = Levels { in_low: 0.5, in_high: 0.5, ..Levels::default() };
assert!(d.apply(0.7).is_finite());
}
#[test]
fn hsl_adjust_shifts_hue_saturation_and_lightness() {
let close = |a: [f32; 3], b: [f32; 3]| (0..3).all(|i| (a[i] - b[i]).abs() < 1e-4);
let c = [0.8, 0.3, 0.1];
assert!(close(hsl_adjust(c, 0.0, 0.0, 0.0), c), "identity");
assert!(close(hsl_adjust([1.0, 0.0, 0.0], 1.0 / 3.0, 0.0, 0.0), [0.0, 1.0, 0.0]), "red → green");
assert!(close(hsl_adjust([1.0, 0.0, 0.0], -1.0 / 3.0, 0.0, 0.0), [0.0, 0.0, 1.0]), "red → blue");
let gray = hsl_adjust(c, 0.0, -1.0, 0.0);
assert!((gray[0] - gray[1]).abs() < 1e-6 && (gray[1] - gray[2]).abs() < 1e-6);
// Grays only change lightness, whatever the hue and saturation.
assert!(close(hsl_adjust([0.4; 3], 0.3, 1.0, 0.5), [0.7; 3]));
assert!(close(hsl_adjust([0.4; 3], 0.0, 0.0, -0.5), [0.2; 3]));
assert!(hsl_adjust([f32::NAN, 2.0, -1.0], f32::NAN, 5.0, -5.0).iter().all(|v| v.is_finite()));
}
#[test]
fn point_filters_map_values_and_skip_neighbourhood_filters() {
let c = ChannelKind::Color;
let close = |a: [f32; 3], b: [f32; 3]| (0..3).all(|i| (a[i] - b[i]).abs() < 1e-4);
let cl = Filter::ContrastLuminosity { contrast: 1.0, luminosity: 0.0 };
assert!(close(cl.point(c, [0.25, 0.5, 0.75]).unwrap(), [0.0, 0.5, 1.0]));
assert!(close(Filter::ContrastLuminosity { contrast: 0.0, luminosity: 0.2 }.point(ChannelKind::Scalar, [0.5; 3]).unwrap(), [0.7; 3]));
let gm = Filter::GradientMap { colors: vec![[1.0, 0.0, 0.0], [0.0, 0.0, 1.0]] };
assert!(close(gm.point(c, [0.0; 3]).unwrap(), [1.0, 0.0, 0.0]));
assert!(close(gm.point(c, [1.0; 3]).unwrap(), [0.0, 0.0, 1.0]));
assert_eq!(Filter::GradientMap { colors: vec![] }.point(c, [0.3; 3]), None, "an empty gradient changes nothing");
assert!(close(Filter::Posterize { levels: 2.0 }.point(c, [0.2, 0.6, 0.9]).unwrap(), [0.0, 1.0, 1.0]));
assert!(close(Filter::Clamp { min: 0.8, max: 0.3 }.point(c, [0.1, 0.5, 0.9]).unwrap(), [0.3, 0.5, 0.8]), "swapped bounds never panic");
let scan = |position, contrast| Filter::HistogramScan { position, contrast }.point(c, [0.2, 0.5, 0.9]).unwrap();
assert!(close(scan(0.5, 0.0), [0.2, 0.5, 0.9]), "a full-width ramp at the middle keeps the values");
assert!(close(scan(0.4, 1.0), [0.0, 1.0, 1.0]), "full contrast is a step at the position");
assert!(close(scan(0.5, 1.0), [0.0, 1.0, 1.0]), "the position itself goes to white");
assert!(close(scan(0.7, 0.5), [0.0, 0.1, 0.9]));
let range = |range, position| Filter::HistogramRange { range, position }.point(c, [0.2, 0.5, 0.9]).unwrap();
assert!(close(range(1.0, 0.3), [0.2, 0.5, 0.9]) && close(range(0.0, 0.3), [0.3; 3]));
assert!(close(range(0.5, 0.5), [0.35, 0.5, 0.7]));
let shift = |offset| Filter::HistogramShift { offset }.point(c, [0.0, 0.5, 1.0]).unwrap();
assert!(close(shift(0.0), [0.0, 0.5, 1.0]), "no offset keeps white white");
assert!(close(shift(0.25), [0.25, 0.75, 0.25]) && close(shift(-0.25), [0.75, 0.25, 0.75]));
let cb = Filter::ColorBalance { shadows: [0.2, 0.0, 0.0], midtones: [0.0; 3], highlights: [0.0, 0.0, 0.2] };
assert!(cb.point(c, [0.05; 3]).unwrap()[0] > 0.2 && cb.point(c, [0.95; 3]).unwrap()[2] > 0.99);
assert!(close(Filter::Invert.point(ChannelKind::Signed, [0.5; 3]).unwrap(), [-0.5; 3]));
assert_eq!(Filter::Invert.point(ChannelKind::NormalMap, [0.5, 0.5, 1.0]), Some([0.5, 0.5, 1.0]));
for f in [Filter::Blur { radius: 1.0 }, Filter::Warp { intensity: 1.0, scale: 1.0, seed: 0 }, Filter::DirectionalBlur { radius: 1.0, angle: 0.0 }] {
assert!(f.is_neighbourhood() && f.point(c, [0.5; 3]).is_none());
}
let nan = Filter::ContrastLuminosity { contrast: f32::NAN, luminosity: f32::NAN };
assert!(nan.point(c, [0.5; 3]).unwrap().iter().all(|v| v.is_finite()));
}
#[test]
fn gradient_map_stops_round_trip_and_sources_without_them_save_as_before() {
let ramp = vec![[1.0, 0.0, 0.0], [0.0, 0.0, 1.0]];
let procedural = |ramp: Vec<[f32; 3]>| Source::Procedural { pattern: Procedural::new(ProceduralKind::Clouds), low: [0.25; 3], high: [0.75; 3], ramp };
let anchor = |ramp: Vec<[f32; 3]>| Source::Anchor { anchor: LayerId(7), channel: Channel::BaseColor, ramp };
for source in [procedural(ramp.clone()), anchor(ramp.clone())] {
let json = serde_json::to_value(&source).unwrap();
assert!(json.to_string().contains("\"ramp\""), "{json}");
assert_eq!(serde_json::from_value::<Source>(json).unwrap(), source);
assert_eq!(source.ramp(), ramp.as_slice());
}
// Empty ramps preserve older projects' JSON shape
let old_procedural = serde_json::json!({"Procedural": {"pattern": serde_json::to_value(Procedural::new(ProceduralKind::Clouds)).unwrap(), "low": [0.25, 0.25, 0.25], "high": [0.75, 0.75, 0.75]}});
let old_anchor = serde_json::json!({"Anchor": {"anchor": 7, "channel": "BaseColor"}});
for (old, source) in [(old_procedural, procedural(Vec::new())), (old_anchor, anchor(Vec::new()))] {
assert_eq!(serde_json::to_value(&source).unwrap(), old);
assert_eq!(serde_json::from_value::<Source>(old).unwrap(), source);
assert!(source.ramp().is_empty());
}
assert!(Source::Uniform([0.5; 3]).ramp().is_empty());
}
#[test]
fn effect_targets_and_anchor_reads() {
assert_eq!(EffectKind::Anchor.content_only(), None, "anchors go on content and masks");
assert_eq!(EffectKind::Generator(Generator::new(GeneratorKind::Dirt)).content_only(), Some(false));
assert_eq!(EffectKind::Filter(Filter::Invert).content_only(), None);
let mut fill_layer = Layer::new(LayerId(1), "l", LayerKind::Paint, &[Channel::BaseColor]);
assert!(!fill_layer.reads_anchor());
let source = Source::Anchor { anchor: LayerId(9), channel: Channel::Height, ramp: Vec::new() };
fill_layer.mask = Some(Mask {
effects: vec![Effect::new(LayerId(2), EffectKind::Fill { source, projection: Projection::default() })],
..Mask::new(MaskBackground::Black)
});
assert!(fill_layer.reads_anchor());
// A generator with micro detail reads its anchor too
let mut generator_layer = Layer::new(LayerId(3), "g", LayerKind::Paint, &[Channel::BaseColor]);
let mut generator = Generator::new(GeneratorKind::Dirt);
generator.micro = Some(MicroDetail { anchor: LayerId(9), amount: 0.5 });
assert_eq!(EffectKind::Generator(generator.clone()).anchors_read(), [(LayerId(9), Channel::Height)]);
generator_layer.mask = Some(Mask { effects: vec![Effect::new(LayerId(4), EffectKind::Generator(generator))], ..Mask::new(MaskBackground::Black) });
assert!(generator_layer.reads_anchor());
}
#[test]
fn height_mask_keeps_the_ends_and_follows_height() {
let off = HeightMask::default();
assert_eq!(off.apply(0.3, 1.0), 0.3, "disabled");
let hm = HeightMask { enabled: true, contrast: 1.0, offset: 0.0 };
for h in [-1.0, 0.0, 1.0] {
assert_eq!(hm.apply(0.0, h), 0.0);
assert_eq!(hm.apply(1.0, h), 1.0);
}
assert_eq!(hm.apply(0.5, 0.0), 0.5, "no height, no change");
assert_eq!(hm.apply(0.5, 0.5), 1.0);
assert_eq!(hm.apply(0.5, -0.5), 0.0);
assert!(hm.apply(0.5, 0.1) > 0.5 && hm.apply(0.5, -0.1) < 0.5);
assert!(HeightMask { offset: 0.5, ..hm }.apply(0.5, 0.0) > 0.5);
assert_eq!(hm.apply(0.5, f32::NAN), 0.5);
}
#[test]
fn old_decals_load_unflipped_and_save_unchanged() {
let old = r#"{"center":[0.0,0.0,0.0],"normal":[0.0,0.0,1.0],"up":[0.0,1.0,0.0],"size":[1.0,2.0],"rotation":0.0,"offset":[0.0,0.0],"depth":0.5}"#;
let decal: Decal = serde_json::from_str(old).unwrap();
assert_eq!(decal.flip, [false, false]);
assert_eq!(
serde_json::from_str::<serde_json::Value>(&serde_json::to_string(&decal).unwrap()).unwrap(),
serde_json::from_str::<serde_json::Value>(old).unwrap()
);
let flipped = Decal { flip: [true, false], ..decal };
let saved = serde_json::to_string(&flipped).unwrap();
assert!(saved.contains(r#""flip":[true,false]"#), "{saved}");
assert_eq!(serde_json::from_str::<Decal>(&saved).unwrap(), flipped);
}
#[test]
fn generator_kinds_parse() {
for kind in GeneratorKind::ALL {
assert_eq!(GeneratorKind::parse(&format!("{kind:?}")), Some(kind));
}
}
#[test]
fn procedural_kinds_parse_labels_and_saved_names() {
for kind in ProceduralKind::ALL {
let saved_name = format!("{kind:?}");
assert_eq!(ProceduralKind::parse(kind.label()), Some(kind));
assert_eq!(ProceduralKind::parse(&saved_name), Some(kind));
assert_eq!(serde_json::to_value(kind).unwrap(), serde_json::Value::String(saved_name));
assert_eq!(serde_json::from_value::<ProceduralKind>(serde_json::to_value(kind).unwrap()).unwrap(), kind);
}
}
}