d84914ef1e5a
instance_cmds.rs
//! 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.select_one(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((doc, id)) if doc.project.effect(*id).is_some() => Err("the clipboard holds an effect (effect.paste)".into()),
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.select_one(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)
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.