mirror of
https://github.com/storytold/texturecraft.git
synced 2026-11-21 15:00:42 +01:00
A Geometry mask tool (key 8) shows or hides the selected layer on the mesh part under a click,
so geometry masks can be set on the model instead of from the part list.
- Tool::GeometryMask; tool.geometryMask selects it and tool.click toggles the part under the
point ({layer, part, shown, geometryMask}); showing every part again clears the mask; one
undo step per click; refused on empty space, without a selected layer, or on a part of
another texture set
- the tool shelf, the tool bar hint and Properties (the layer's parts, shown or hidden, and Show
on all parts); the hint is translated in all eight UI languages
- test: clicks on a two-object OBJ hide, show and clear, undo, and a click on empty space
222 lines
9.8 KiB
Rust
222 lines
9.8 KiB
Rust
//! Instance layers (linked copies that draw another layer, possibly in another texture set) and
|
||
//! per-layer properties set through `layer.set`.
|
||
|
||
use serde_json::{Value, json};
|
||
use texturecraft_core::{Layer, LayerId, LayerKind};
|
||
|
||
use crate::commands::{CommandSpec, bad, boolp, content_param, f32p, has_layer, layer_param, u64p};
|
||
use crate::session::{Document, StackTarget};
|
||
use crate::{EngineError, Result, Session, cmd};
|
||
|
||
pub fn specs() -> Vec<CommandSpec> {
|
||
vec![
|
||
cmd!(
|
||
"layer.instance",
|
||
"Create instance",
|
||
["Layers"],
|
||
None,
|
||
"{layer?, ts?: texture set (default active)} — a linked instance above that set's selection; edits to the source show in every instance",
|
||
has_layer,
|
||
instance
|
||
),
|
||
cmd!(
|
||
"layer.pasteInstance",
|
||
"Paste as instance",
|
||
["Layers"],
|
||
None,
|
||
"{} — an instance of the copied layer above the selection",
|
||
can_paste_instance,
|
||
paste_instance
|
||
),
|
||
cmd!(
|
||
"layer.set",
|
||
"Set layer properties",
|
||
[],
|
||
None,
|
||
"{layer?, heightMask?: {enabled?, contrast?: 0..64, offset?: -1..1} | bool, geometryMask?: [part names] | null} — mask with height: m' = saturate(m + contrast·4m(1−m)·(height + offset)); geometry mask: the mesh parts (textureSet.parts) the layer shows on, null for all",
|
||
has_layer,
|
||
set
|
||
),
|
||
]
|
||
}
|
||
|
||
/// Insert an instance of `source` (an instance's own source) into texture set `ts` above that
|
||
/// set's selection, and select it.
|
||
pub(crate) fn make_instance(s: &mut Session, source: LayerId, ts: usize) -> Result<LayerId> {
|
||
let src = s.doc.project.content_layer(source).ok_or_else(|| EngineError::Other(format!("layer {} has no source to instance", source.0)))?;
|
||
let (src_id, name) = (src.id, src.name.clone());
|
||
let id = s.doc.project.alloc_id();
|
||
let sel = s.selected.get(&ts).copied().filter(|l| s.doc.project.locate(*l).is_some_and(|(t, _, _)| t == ts));
|
||
let inside = sel.and_then(|l| s.doc.project.layer(l).ok()).is_some_and(Layer::is_group);
|
||
s.doc.project.insert_layer(ts, Layer::new(id, name, LayerKind::Instance { source: src_id }, &[]), sel, inside)?;
|
||
s.selected.insert(ts, id);
|
||
if ts == s.ts() {
|
||
s.target = StackTarget::Content;
|
||
}
|
||
Ok(id)
|
||
}
|
||
|
||
fn instance(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let source = layer_param(s, "layer.instance", p)?;
|
||
let ts = match u64p(p, "ts") {
|
||
Some(t) => usize::try_from(t).ok().filter(|t| *t < s.set_count()).ok_or_else(|| bad("layer.instance", format!("no texture set {t}")))?,
|
||
None => s.ts(),
|
||
};
|
||
let id = s.edit("Create instance", |s| make_instance(s, source, ts))?;
|
||
Ok(json!({ "layer": id.0, "textureSet": ts }))
|
||
}
|
||
|
||
fn can_paste_instance(s: &Session) -> std::result::Result<(), String> {
|
||
match &s.clipboard {
|
||
Some((_, id)) if s.doc.project.locate(*id).is_some() => Ok(()),
|
||
Some(_) => Err("the copied layer is no longer in the project (paste it instead)".into()),
|
||
None => Err("the layer clipboard is empty".into()),
|
||
}
|
||
}
|
||
|
||
fn paste_instance(s: &mut Session, _: &Value) -> Result<Value> {
|
||
let id = s.clipboard.as_ref().map(|(_, id)| *id).ok_or_else(|| EngineError::Other("the layer clipboard is empty".into()))?;
|
||
let ts = s.ts();
|
||
let new = s.edit("Paste as instance", |s| make_instance(s, id, ts))?;
|
||
Ok(json!({ "layer": new.0 }))
|
||
}
|
||
|
||
/// Replace instance `inst` with an independent copy of its source taken from `src` (its name,
|
||
/// visibility, color tag and own mask are kept). Returns the copy.
|
||
pub(crate) fn detach(s: &mut Session, src: &Document, inst: LayerId) -> Result<LayerId> {
|
||
let layer = s.doc.project.layer(inst)?.clone();
|
||
let source = layer.instance_source().ok_or_else(|| EngineError::Other(format!("\"{}\" is not an instance", layer.name)))?;
|
||
let (ts, _, _) = s.doc.project.locate(inst).ok_or_else(|| EngineError::Other("layer not in a stack".into()))?;
|
||
let copy = crate::layer_ops::copy_tree(src, source, &mut s.doc, ts, Some(inst), false, 0)?;
|
||
let l = s.doc.project.layer_mut(copy)?;
|
||
l.name = layer.name;
|
||
l.visible = layer.visible;
|
||
l.color_tag = layer.color_tag;
|
||
if layer.mask.is_some() {
|
||
l.mask = layer.mask;
|
||
}
|
||
s.doc.project.remove_layer(inst)?;
|
||
if s.selected.get(&ts) == Some(&inst) {
|
||
s.selected.insert(ts, copy);
|
||
}
|
||
Ok(copy)
|
||
}
|
||
|
||
/// After layers were removed: instances of a removed layer become independent copies (taken
|
||
/// from `before`, the document before the removal), then pixels of removed layers are dropped.
|
||
pub(crate) fn detach_orphans(s: &mut Session, before: &Document) -> Result<()> {
|
||
// Copies can hold instances of removed layers in turn; the depth bounds the rounds.
|
||
for _ in 0..=texturecraft_core::project::MAX_DEPTH {
|
||
let orphans: Vec<LayerId> = s
|
||
.doc
|
||
.project
|
||
.layers
|
||
.values()
|
||
.filter(|l| l.instance_source().is_some_and(|src| !s.doc.project.layers.contains_key(&src) && before.project.layers.contains_key(&src)))
|
||
.map(|l| l.id)
|
||
.collect();
|
||
if orphans.is_empty() {
|
||
break;
|
||
}
|
||
for inst in orphans {
|
||
detach(s, before, inst)?;
|
||
}
|
||
}
|
||
prune_pixels(&mut s.doc);
|
||
Ok(())
|
||
}
|
||
|
||
/// Drop pixels of layers and effects that no longer exist.
|
||
pub(crate) fn prune_pixels(doc: &mut Document) {
|
||
let p = &doc.project;
|
||
let alive: std::collections::BTreeSet<LayerId> = p
|
||
.layers
|
||
.values()
|
||
.flat_map(|l| std::iter::once(l.id).chain(l.mask.iter().flat_map(|m| m.effects.iter()).chain(l.content_effects.iter()).map(|e| e.id)))
|
||
.collect();
|
||
doc.pixels.retain(|x| alive.contains(&x));
|
||
}
|
||
|
||
/// Show or hide the selected layer on the mesh part under viewport point `screen` (the Geometry
|
||
/// mask tool): `{layer, part, shown, geometryMask}`.
|
||
pub(crate) fn toggle_part_at(s: &mut Session, screen: texturecraft_geom::glam::Vec2, viewport: texturecraft_geom::glam::Vec2) -> Result<Value> {
|
||
let cmd = "tool.click";
|
||
let hit = s.pick(screen, viewport).ok_or_else(|| bad(cmd, "nothing under the point"))?;
|
||
let first = hit.tri.saturating_mul(3);
|
||
let part = s.mesh.submeshes.iter().find(|m| m.start <= first && first < m.start.saturating_add(m.count)).map(|m| m.name.clone());
|
||
let part = part.ok_or_else(|| bad(cmd, "the mesh has no parts"))?;
|
||
let layer = s.selected_layer().ok_or_else(|| bad(cmd, "select a layer first"))?;
|
||
let ts = s.doc.project.locate(layer).map_or(s.ts(), |(ts, _, _)| ts);
|
||
let parts = crate::set_cmds::parts(s, ts);
|
||
if !parts.contains(&part) {
|
||
return Err(bad(cmd, format!("mesh part `{part}` is not in the selected layer's texture set")));
|
||
}
|
||
let mut shown = s.doc.project.layers.get(&layer).and_then(|l| l.geometry_mask.clone()).unwrap_or_else(|| parts.clone());
|
||
let on = !shown.contains(&part);
|
||
if on {
|
||
shown.push(part.clone());
|
||
} else {
|
||
shown.retain(|p| *p != part);
|
||
}
|
||
// In mesh order; showing every part again clears the mask.
|
||
let ordered: Vec<String> = parts.iter().filter(|p| shown.contains(p)).cloned().collect();
|
||
let mask = (ordered.len() != parts.len()).then_some(ordered);
|
||
s.edit(if on { "Show layer on part" } else { "Hide layer on part" }, |s| {
|
||
s.doc.project.layer_mut(layer)?.geometry_mask = mask.clone();
|
||
Ok(())
|
||
})?;
|
||
Ok(json!({ "layer": layer.0, "part": part, "shown": on, "geometryMask": mask }))
|
||
}
|
||
|
||
fn set(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let cmd = "layer.set";
|
||
// Linked properties live on an instance's source; the geometry mask is the layer's own
|
||
// (an instance in another texture set has other parts).
|
||
let (own, id) = (layer_param(s, cmd, p)?, content_param(s, cmd, p)?);
|
||
let hm = match p.get("heightMask") {
|
||
Some(Value::Bool(on)) => Some(json!({ "enabled": on })),
|
||
Some(v @ Value::Object(_)) => Some(v.clone()),
|
||
Some(_) => return Err(bad(cmd, "`heightMask` must be an object {enabled?, contrast?, offset?} or a bool")),
|
||
None => None,
|
||
};
|
||
let geometry = match p.get("geometryMask") {
|
||
None => None,
|
||
Some(Value::Null) => Some(None),
|
||
Some(Value::Array(a)) => {
|
||
let names: Option<Vec<String>> = a.iter().map(|v| v.as_str().map(str::to_string)).collect();
|
||
let names = names.ok_or_else(|| bad(cmd, "`geometryMask` must be a list of part names or null"))?;
|
||
let ts = s.doc.project.locate(own).map_or(s.ts(), |(ts, _, _)| ts);
|
||
let known = crate::set_cmds::parts(s, ts);
|
||
if let Some(unknown) = names.iter().find(|n| !known.contains(n)) {
|
||
return Err(bad(cmd, format!("unknown mesh part `{unknown}` (parts: {})", known.join(", "))));
|
||
}
|
||
Some(Some(names))
|
||
}
|
||
Some(_) => return Err(bad(cmd, "`geometryMask` must be a list of part names or null")),
|
||
};
|
||
if hm.is_none() && geometry.is_none() {
|
||
return Err(bad(cmd, "give `heightMask` or `geometryMask`"));
|
||
}
|
||
let out = s.edit("Layer properties", |s| {
|
||
if let Some(g) = geometry {
|
||
s.doc.project.layer_mut(own)?.geometry_mask = g;
|
||
}
|
||
let h = &mut s.doc.project.layer_mut(id)?.height_mask;
|
||
if let Some(hm) = &hm {
|
||
if let Some(on) = boolp(hm, "enabled") {
|
||
h.enabled = on;
|
||
}
|
||
if let Some(c) = f32p(hm, "contrast") {
|
||
h.contrast = c.clamp(0.0, 64.0);
|
||
}
|
||
if let Some(o) = f32p(hm, "offset") {
|
||
h.offset = o.clamp(-1.0, 1.0);
|
||
}
|
||
}
|
||
let h = *h;
|
||
let g = s.doc.project.layers.get(&own).and_then(|l| l.geometry_mask.clone());
|
||
Ok(json!({ "layer": own.0, "heightMask": { "enabled": h.enabled, "contrast": h.contrast, "offset": h.offset }, "geometryMask": g }))
|
||
})?;
|
||
Ok(out)
|
||
}
|