mirror of
https://github.com/storytold/texturecraft.git
synced 2026-11-15 19:51:48 +00:00
ec859420d5
An open-source, clean-room implementation of a Substance 3D Painter-style texturing workflow, written in pure Rust with egui and wgpu. - Layer stack with 32 blend modes, masks, generators, content effects and anchor points - Painting, projection, smudge, clone, path, lasso fill, particle brush and quick mask - 43 procedural materials, 17 smart materials and 10 smart masks - Mesh map baking with high-poly, cage and match-by-name support - PBR viewport with HDR environments, TAA and a path-traced Rendering mode - glTF, FBX, COLLADA, OBJ, PLY and STL import; texture export presets; OBJ and GLB export - Dockable Painter-style UI, shortcut editor, web build, MCP server and CLI Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
233 lines
12 KiB
Rust
233 lines
12 KiB
Rust
//! Instance layers across texture sets, mask with height, change-driven invalidation and the
|
|
//! frame-budgeted compositor, through engine commands.
|
|
|
|
use serde_json::{Value, json};
|
|
use texturecraft_engine::core::{Channel, LayerId, LayerKind};
|
|
use texturecraft_engine::geom::glam::Vec2;
|
|
use texturecraft_engine::geom::primitives;
|
|
use texturecraft_engine::{Session, execute};
|
|
|
|
/// Two texture sets (ball and base) at 256².
|
|
fn session() -> Session {
|
|
let mut s = Session::new_project("t", primitives::material_ball(), "builtin:material_ball", None, 256).unwrap();
|
|
s.viewport = Vec2::new(400.0, 400.0);
|
|
s.update();
|
|
s
|
|
}
|
|
|
|
fn id(v: Value, key: &str) -> LayerId {
|
|
LayerId(v[key].as_u64().unwrap())
|
|
}
|
|
|
|
/// A texel covered by texture set `ts`.
|
|
fn covered(s: &Session, ts: usize) -> (u32, u32) {
|
|
let g = &s.caches[ts].gbuf;
|
|
let i = g.tri.iter().position(|t| *t != texturecraft_engine::geom::NO_TRI).unwrap();
|
|
(i as u32 % g.width, i as u32 / g.width)
|
|
}
|
|
|
|
fn rough(s: &mut Session, ts: usize) -> f32 {
|
|
s.update();
|
|
let (x, y) = covered(s, ts);
|
|
s.caches[ts].composite.value(Channel::Roughness, x, y)[0]
|
|
}
|
|
|
|
/// Texels of set `ts` whose base color is red.
|
|
fn reds(s: &Session, ts: usize) -> usize {
|
|
let c = &s.caches[ts].composite;
|
|
(0..256)
|
|
.flat_map(|y| (0..256).map(move |x| (x, y)))
|
|
.filter(|&(x, y)| s.caches[ts].gbuf.tri[(y * 256 + x) as usize] != u32::MAX)
|
|
.filter(|&(x, y)| {
|
|
let v = c.value(Channel::BaseColor, x, y);
|
|
v[0] > 0.8 && v[1] < 0.2
|
|
})
|
|
.count()
|
|
}
|
|
|
|
#[test]
|
|
fn instances_follow_their_source_across_texture_sets() {
|
|
let mut s = session();
|
|
let src = id(execute(&mut s, "layer.add.fill", &json!({"roughness": 0.8})).unwrap(), "layer");
|
|
let inst = id(execute(&mut s, "layer.instance", &json!({"layer": src.0, "ts": 1})).unwrap(), "layer");
|
|
assert!(matches!(s.doc.project.layer(inst).unwrap().kind, LayerKind::Instance { source } if source == src));
|
|
assert_eq!(s.doc.project.locate(inst).map(|l| l.0), Some(1));
|
|
assert!((rough(&mut s, 1) - 0.8).abs() < 1e-3);
|
|
// Editing the source (directly or through the instance) updates the instance's set.
|
|
execute(&mut s, "layer.fill.set", &json!({"layer": src.0, "channel": "roughness", "value": 0.3})).unwrap();
|
|
assert!(!s.caches[1].dirty.is_empty(), "the instance's set is invalidated");
|
|
assert!((rough(&mut s, 1) - 0.3).abs() < 1e-3);
|
|
execute(&mut s, "layer.fill.set", &json!({"layer": inst.0, "channel": "roughness", "value": 0.6})).unwrap();
|
|
assert!((rough(&mut s, 0) - 0.6).abs() < 1e-3 && (rough(&mut s, 1) - 0.6).abs() < 1e-3);
|
|
execute(&mut s, "layer.blend", &json!({"layer": inst.0, "channel": "roughness", "opacity": 0.5})).unwrap();
|
|
assert_eq!(s.doc.project.layer(src).unwrap().blend(Channel::Roughness).unwrap().opacity, 0.5, "blending is linked");
|
|
// Inspect shows the link; an instance of an instance links to the source.
|
|
let stack = execute(&mut s, "layer.list", &json!({"ts": 1})).unwrap();
|
|
assert_eq!(stack[0]["instanceOf"]["layer"], src.0, "{stack}");
|
|
let again = id(execute(&mut s, "layer.instance", &json!({"layer": inst.0, "ts": 1})).unwrap(), "layer");
|
|
assert_eq!(s.doc.project.layer(again).unwrap().instance_source(), Some(src));
|
|
// Save/load keeps instances; undo removes them.
|
|
let back = Session::from_project_bytes(&s.to_project_bytes().unwrap()).unwrap();
|
|
assert_eq!(back.doc.project, s.doc.project);
|
|
execute(&mut s, "edit.undo", &Value::Null).unwrap();
|
|
assert!(s.doc.project.layer(again).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn painting_a_source_paints_its_instances() {
|
|
let mut s = session();
|
|
let paint = s.selected_layer().unwrap();
|
|
execute(&mut s, "layer.instance", &json!({"layer": paint.0, "ts": 1})).unwrap();
|
|
execute(&mut s, "textureSet.select", &json!({"ts": 0})).unwrap();
|
|
execute(&mut s, "layer.select", &json!({"layer": paint.0})).unwrap();
|
|
execute(&mut s, "tool.material", &json!({"channel": "baseColor", "color": [1.0, 0.0, 0.0]})).unwrap();
|
|
execute(&mut s, "tool.brush", &json!({"size": 30, "hardness": 90})).unwrap();
|
|
assert_eq!(reds(&s, 1), 0);
|
|
// The live stroke shows in the instance before it is committed.
|
|
s.begin_stroke(Vec2::new(200.0, 170.0), s.viewport, 1.0).unwrap();
|
|
s.continue_stroke(Vec2::new(230.0, 170.0), 1.0);
|
|
s.update();
|
|
let live = reds(&s, 1);
|
|
assert!(live > 0, "the instance shows the live stroke");
|
|
s.end_stroke().unwrap();
|
|
s.update();
|
|
assert!(reds(&s, 1) >= live);
|
|
// Painting through the instance paints the source.
|
|
let inst = s.doc.project.texture_sets[1].stack.last().copied().unwrap();
|
|
execute(&mut s, "layer.select", &json!({"layer": inst.0})).unwrap();
|
|
let before = s.doc.pixels.layer(paint, Channel::BaseColor).map(|i| i.allocated_count()).unwrap_or(0);
|
|
execute(&mut s, "tool.stroke", &json!({"points": [[150, 330], [250, 330]]})).unwrap();
|
|
assert!(s.doc.pixels.layer(paint, Channel::BaseColor).unwrap().allocated_count() >= before);
|
|
assert!(s.doc.pixels.layers.keys().all(|(l, _)| *l != inst), "instances hold no pixels");
|
|
}
|
|
|
|
#[test]
|
|
fn cycles_are_refused_and_removed_sources_detach() {
|
|
let mut s = session();
|
|
let g = id(execute(&mut s, "layer.add.group", &Value::Null).unwrap(), "layer");
|
|
let fill = id(execute(&mut s, "layer.add.fill", &json!({"roughness": 0.9})).unwrap(), "layer");
|
|
assert_eq!(s.doc.project.locate(fill).unwrap().1, Some(g));
|
|
// The folder selected: the instance would land inside it and draw itself.
|
|
execute(&mut s, "layer.select", &json!({"layer": g.0})).unwrap();
|
|
let doc = s.doc.project.clone();
|
|
assert!(execute(&mut s, "layer.instance", &json!({"layer": g.0})).is_err());
|
|
assert_eq!(s.doc.project, doc, "a refused edit leaves the document as it was");
|
|
// Moving an instance of the folder into it is refused too.
|
|
execute(&mut s, "layer.select", &json!({"layer": fill.0})).unwrap();
|
|
execute(&mut s, "layer.move", &json!({"layer": fill.0, "above": Value::Null})).unwrap();
|
|
execute(&mut s, "layer.select", &json!({"layer": fill.0})).unwrap();
|
|
let inst = id(execute(&mut s, "layer.instance", &json!({"layer": g.0})).unwrap(), "layer");
|
|
assert!(execute(&mut s, "layer.move", &json!({"layer": inst.0, "above": Value::Null, "inside": false})).is_ok());
|
|
assert!(execute(&mut s, "layer.move", &json!({"layer": inst.0, "above": g.0, "inside": true})).is_err());
|
|
|
|
// Removing a source turns its instances into copies that look the same.
|
|
let src = id(execute(&mut s, "layer.add.fill", &json!({"roughness": 0.15})).unwrap(), "layer");
|
|
execute(&mut s, "layer.instantiateAll", &json!({"layer": src.0})).unwrap();
|
|
let inst = s.doc.project.texture_sets[1].stack.last().copied().unwrap();
|
|
assert!(s.doc.project.layer(inst).unwrap().instance_source() == Some(src));
|
|
let look = rough(&mut s, 1);
|
|
assert!((look - 0.15).abs() < 1e-3);
|
|
execute(&mut s, "layer.remove", &json!({"layer": src.0})).unwrap();
|
|
assert!(s.doc.project.layer(inst).is_err());
|
|
let copy = s.doc.project.texture_sets[1].stack.last().copied().unwrap();
|
|
assert!(matches!(s.doc.project.layer(copy).unwrap().kind, LayerKind::Fill(_)));
|
|
assert!((rough(&mut s, 1) - look).abs() < 1e-4);
|
|
s.doc.project.validate().unwrap();
|
|
execute(&mut s, "edit.undo", &Value::Null).unwrap();
|
|
assert_eq!(s.doc.project.layer(inst).unwrap().instance_source(), Some(src));
|
|
}
|
|
|
|
#[test]
|
|
fn paste_as_instance_and_instantiate_or_copy_across_sets() {
|
|
let mut s = session();
|
|
let src = id(execute(&mut s, "layer.add.fill", &json!({"roughness": 0.7})).unwrap(), "layer");
|
|
assert!(execute(&mut s, "layer.pasteInstance", &Value::Null).is_err(), "empty clipboard");
|
|
execute(&mut s, "layer.copy", &json!({"layer": src.0})).unwrap();
|
|
execute(&mut s, "textureSet.select", &json!({"ts": 1})).unwrap();
|
|
let pasted = id(execute(&mut s, "layer.pasteInstance", &Value::Null).unwrap(), "layer");
|
|
assert_eq!(s.doc.project.layer(pasted).unwrap().instance_source(), Some(src));
|
|
assert_eq!(s.selected_layer(), Some(pasted));
|
|
// A cut layer is gone: paste it, not an instance of it.
|
|
execute(&mut s, "layer.cut", &json!({"layer": pasted.0})).unwrap();
|
|
assert!(execute(&mut s, "layer.pasteInstance", &Value::Null).is_err());
|
|
|
|
let made = execute(&mut s, "layer.instantiateAll", &json!({"layer": src.0})).unwrap();
|
|
let inst = LayerId(made["layers"][0].as_u64().unwrap());
|
|
assert_eq!(s.doc.project.layer(inst).unwrap().instance_source(), Some(src));
|
|
let made = execute(&mut s, "layer.instantiateAll", &json!({"layer": src.0, "copy": true})).unwrap();
|
|
let copy = LayerId(made["layers"][0].as_u64().unwrap());
|
|
assert!(matches!(s.doc.project.layer(copy).unwrap().kind, LayerKind::Fill(_)));
|
|
// Flattening an instance makes it an independent paint layer with the same look.
|
|
let look = rough(&mut s, 1);
|
|
execute(&mut s, "layer.remove", &json!({"layer": copy.0})).unwrap();
|
|
execute(&mut s, "layer.flatten", &json!({"layer": inst.0})).unwrap();
|
|
let l = s.doc.project.layer(inst).unwrap();
|
|
assert!(matches!(l.kind, LayerKind::Paint) && l.blend(Channel::Roughness).is_some());
|
|
assert!((rough(&mut s, 1) - look).abs() < 2e-3);
|
|
}
|
|
|
|
#[test]
|
|
fn mask_with_height_through_layer_set() {
|
|
let mut s = session();
|
|
let l = id(execute(&mut s, "layer.add.fill", &json!({"color": [1.0, 1.0, 1.0], "height": 0.5})).unwrap(), "layer");
|
|
execute(&mut s, "mask.add.black", &Value::Null).unwrap();
|
|
execute(&mut s, "effect.add.fill", &json!({"value": 0.5})).unwrap();
|
|
let (x, y) = covered(&s, 0);
|
|
s.update();
|
|
let plain = s.caches[0].composite.value(Channel::BaseColor, x, y)[0];
|
|
let r = execute(&mut s, "layer.set", &json!({"layer": l.0, "heightMask": {"enabled": true, "contrast": 1.0, "offset": 0.0}})).unwrap();
|
|
assert_eq!(r["heightMask"]["enabled"], true);
|
|
s.update();
|
|
let with = s.caches[0].composite.value(Channel::BaseColor, x, y)[0];
|
|
assert!((plain - 0.75).abs() < 0.01 && (with - 1.0).abs() < 0.01, "{plain} {with}");
|
|
let inspect = execute(&mut s, "layer.list", &Value::Null).unwrap();
|
|
assert_eq!(inspect[0]["heightMask"]["contrast"], 1.0);
|
|
execute(&mut s, "layer.set", &json!({"layer": l.0, "heightMask": false})).unwrap();
|
|
assert!(!s.doc.project.layer(l).unwrap().height_mask.enabled);
|
|
assert!(execute(&mut s, "layer.set", &json!({"layer": l.0})).is_err());
|
|
assert!(execute(&mut s, "layer.set", &json!({"layer": l.0, "heightMask": 3})).is_err());
|
|
let hostile = execute(&mut s, "layer.set", &json!({"layer": l.0, "heightMask": {"contrast": 1e30, "offset": -1e30}})).unwrap();
|
|
assert_eq!(hostile["heightMask"]["contrast"], 64.0);
|
|
assert_eq!(hostile["heightMask"]["offset"], -1.0);
|
|
}
|
|
|
|
#[test]
|
|
fn edits_invalidate_only_the_sets_they_change() {
|
|
let mut s = session();
|
|
let l = id(execute(&mut s, "layer.add.fill", &json!({"roughness": 0.4})).unwrap(), "layer");
|
|
s.update();
|
|
execute(&mut s, "layer.rename", &json!({"layer": l.0, "name": "Renamed"})).unwrap();
|
|
assert_eq!(s.pending_tiles(), 0, "a rename changes no pixels");
|
|
execute(&mut s, "layer.fill.set", &json!({"layer": l.0, "channel": "roughness", "value": 0.2})).unwrap();
|
|
assert!(!s.caches[0].dirty.is_empty() && s.caches[1].dirty.is_empty(), "only the edited set");
|
|
s.update();
|
|
execute(&mut s, "edit.undo", &Value::Null).unwrap();
|
|
assert!(!s.caches[0].dirty.is_empty() && s.caches[1].dirty.is_empty());
|
|
assert!((rough(&mut s, 0) - 0.4).abs() < 1e-3);
|
|
}
|
|
|
|
#[test]
|
|
fn budgeted_updates_spread_work_and_end_identical() {
|
|
let mut s = session();
|
|
execute(&mut s, "textureSet.resolution", &json!({"ts": 0, "resolution": 1024})).unwrap();
|
|
execute(&mut s, "layer.add.fill", &Value::Null).unwrap();
|
|
execute(&mut s, "layer.fill.set", &json!({"channel": "baseColor", "procedural": "grunge"})).unwrap();
|
|
execute(&mut s, "mask.add.black", &Value::Null).unwrap();
|
|
execute(&mut s, "effect.add.generator", &json!({"generator": "position"})).unwrap();
|
|
execute(&mut s, "effect.add.filter", &json!({"filter": "blur", "radius": 30})).unwrap();
|
|
s.update();
|
|
let full = s.caches[0].composite.clone();
|
|
s.caches[0].invalidate_all();
|
|
// A clock that is always over budget: one chunk per call.
|
|
let mut calls = 0;
|
|
while s.pending_tiles() > 0 {
|
|
let before = s.pending_tiles();
|
|
s.update_for(0.0, || 1.0);
|
|
assert!(s.pending_tiles() < before);
|
|
calls += 1;
|
|
}
|
|
assert!(calls > 1, "the work was spread over calls");
|
|
assert!(s.caches[0].composite == full, "chunked compositing gives the same pixels");
|
|
assert!(s.memory().composites > 0);
|
|
}
|