Files
texturecraft/crates/engine/src/layer_cmds.rs
bflatastic 7e78a2cba6 Material channels: Alt+click keeps one channel
Alt+click on a channel of a fill's or the brush's Material section turns
that channel on and every other one off (one undo step for a fill).
tool.material and layer.fill.set take solo: true for the same.

Fixes #74.
2026-11-02 06:37:04 +07:00

413 lines
18 KiB
Rust

//! Layer stack commands: add, remove, duplicate, select, rename, visibility, reorder, group,
//! per-channel blending and fill sources.
use serde_json::{Value, json};
use texturecraft_core::{BlendMode, Channel, ChannelBlend, EffectKind, Fill, Layer, LayerId, LayerKind, Procedural, ProceduralKind, Projection, Source};
use crate::commands::{CommandSpec, always, bad, blend_param, boolp, channel_param, color_param, content_param, f32p, has_layer, layer_param, strp, u64p};
use crate::{EngineError, Result, Session, cmd, session::StackTarget};
pub fn specs() -> Vec<CommandSpec> {
vec![
cmd!("layer.add.paint", "Add paint layer", ["Layers"], None, "{name?}", always, add_paint),
cmd!("layer.add.fill", "Add fill layer", ["Layers"], None, "{name?, color?, roughness?, metallic?}", always, add_fill),
cmd!("layer.add.group", "Add folder", ["Layers"], None, "{name?}", always, add_group),
cmd!("layer.remove", "Remove layer(s)", ["Layers"], Some("Delete"), "{layer?}", has_layer, remove),
cmd!("layer.duplicate", "Duplicate layer(s)", ["Layers"], Some("Ctrl+D"), "{layer?}", has_layer, duplicate),
cmd!("layer.group", "Group layer(s)", ["Layers"], Some("Ctrl+G"), "{layer?}", has_layer, group),
cmd!("layer.select", "Select layer", [], None, "{layer, target?: content|mask|<effect id>}", always, select),
cmd!("layer.rename", "Rename layer", [], None, "{layer?, name}", has_layer, rename),
cmd!("layer.visible", "Toggle layer visibility", [], None, "{layer?, visible?}", has_layer, visible),
cmd!("layer.move", "Move layer", [], None, "{layer?, index?} | {layer?, above?: id|null, inside?: bool} | {layer?, delta: ±n}", has_layer, move_layer),
cmd!("layer.blend", "Set channel blending", [], None, "{layer?, channel?: id|all, mode?, opacity?: 0..1, enabled?}", has_layer, blend),
cmd!(
"layer.fill.set",
"Set fill source",
[],
None,
"{layer? | effect?: content fill effect id, channel, color?|value?|procedural?: kind, scale?, seed?, contrast?, balance?, invert?, low?, high?|image?|anchor?: anchor effect id, anchorChannel?, enabled?, solo?: true (this channel on, every other one off)}",
has_layer,
fill_set
),
cmd!(
"layer.fill.projection",
"Set fill projection",
[],
None,
"{layer? | effect?: content fill effect id, projection: uv|triplanar|planar|spherical|cylindrical, scale?, rotation?, sharpness?, axis?}",
has_layer,
fill_projection
),
cmd!("layer.colorTag", "Set layer color tag", [], None, "{layer?, tag?: 0..7 (absent clears)}", has_layer, color_tag),
cmd!("layer.list", "List layers", [], None, "{ts?}", always, list),
]
}
/// Insert a layer above the selection (inside it when it is a group) and select it.
pub(crate) fn insert_selected(s: &mut Session, layer: Layer) -> Result<LayerId> {
let ts = s.ts();
let sel = s.selected_layer();
let inside = sel.and_then(|id| s.doc.project.layer(id).ok()).is_some_and(|l| l.is_group());
let id = s.doc.project.insert_layer(ts, layer, sel, inside)?;
s.selected.insert(ts, id);
s.target = StackTarget::Content;
Ok(id)
}
fn channels_of(s: &Session) -> Vec<Channel> {
s.doc.project.texture_set(s.ts()).map(|t| t.channel_list()).unwrap_or_default()
}
fn add_paint(s: &mut Session, p: &Value) -> Result<Value> {
let ts = s.ts();
let name = strp(p, "name").map(str::to_string).unwrap_or_else(|| s.doc.project.next_layer_name(ts, "Layer"));
let id = s.edit("Add paint layer", |s| {
let id = s.doc.project.alloc_id();
insert_selected(s, Layer::new(id, name, LayerKind::Paint, &channels_of(s)))
})?;
Ok(json!({ "layer": id.0 }))
}
/// A uniform fill from the `color`, `roughness`, `metallic`, `height` and `opacity` params.
pub(crate) fn fill_from(p: &Value) -> Fill {
let mut fill = Fill::default();
if let Some(c) = color_param(p, "color") {
fill.sources.insert(Channel::BaseColor, Source::Uniform(c));
}
for (key, ch) in [("roughness", Channel::Roughness), ("metallic", Channel::Metallic), ("height", Channel::Height), ("opacity", Channel::Opacity)] {
if let Some(v) = f32p(p, key) {
fill.sources.insert(ch, Source::Uniform([v; 3]));
}
}
fill
}
fn add_fill(s: &mut Session, p: &Value) -> Result<Value> {
let ts = s.ts();
let name = strp(p, "name").map(str::to_string).unwrap_or_else(|| s.doc.project.next_layer_name(ts, "Fill layer"));
let fill = fill_from(p);
let id = s.edit("Add fill layer", |s| {
let id = s.doc.project.alloc_id();
insert_selected(s, Layer::new(id, name, LayerKind::Fill(fill), &channels_of(s)))
})?;
Ok(json!({ "layer": id.0 }))
}
fn add_group(s: &mut Session, p: &Value) -> Result<Value> {
let ts = s.ts();
let name = strp(p, "name").map(str::to_string).unwrap_or_else(|| s.doc.project.next_layer_name(ts, "Folder"));
let id = s.edit("Add folder", |s| {
let id = s.doc.project.alloc_id();
let mut l = Layer::new(id, name, LayerKind::Group { children: Vec::new(), collapsed: false }, &channels_of(s));
for b in l.channels.values_mut() {
b.mode = BlendMode::Passthrough;
}
insert_selected(s, l)
})?;
Ok(json!({ "layer": id.0 }))
}
fn remove(s: &mut Session, p: &Value) -> Result<Value> {
let id = layer_param(s, "layer.remove", p)?;
let before = s.doc.clone();
let removed = s.edit("Remove layer", |s| {
let (ts, parent, i) = s.doc.project.locate(id).ok_or(EngineError::Other("layer not in a stack".into()))?;
let removed = s.doc.project.remove_layer(id)?;
// Instances of what was removed keep their look as independent layers.
crate::instance_cmds::detach_orphans(s, &before)?;
// Select the layer below (or above) the removed one.
let list = match parent {
Some(g) => s.doc.project.layer(g).map(|l| l.children().to_vec()).unwrap_or_default(),
None => s.doc.project.texture_set(ts).map(|t| t.stack.clone()).unwrap_or_default(),
};
let next = list.get(i.saturating_sub(1)).or(list.first()).copied().or(parent);
match next {
Some(n) => s.selected.insert(ts, n),
None => s.selected.remove(&ts),
};
Ok(removed)
})?;
Ok(json!({ "removed": removed.iter().map(|l| l.0).collect::<Vec<_>>() }))
}
fn duplicate(s: &mut Session, p: &Value) -> Result<Value> {
let id = layer_param(s, "layer.duplicate", p)?;
let (ts, _, _) = s.doc.project.locate(id).ok_or(EngineError::Other("layer not in a stack".into()))?;
let src = s.doc.clone();
let new = s.edit("Duplicate layer", |s| {
let new = crate::layer_ops::copy_tree(&src, id, &mut s.doc, ts, Some(id), false, 0)?;
let name = format!("{} copy", src.project.layer(id)?.name);
s.doc.project.layer_mut(new)?.name = name;
Ok(new)
})?;
s.selected.insert(ts, new);
Ok(json!({ "layer": new.0 }))
}
fn group(s: &mut Session, p: &Value) -> Result<Value> {
let id = layer_param(s, "layer.group", p)?;
let g = s.edit("Group layers", |s| {
let (ts, _, _) = s.doc.project.locate(id).ok_or(EngineError::Other("layer not in a stack".into()))?;
let gid = s.doc.project.alloc_id();
let name = s.doc.project.next_layer_name(ts, "Folder");
let channels = s.doc.project.texture_set(ts)?.channel_list();
let mut gl = Layer::new(gid, name, LayerKind::Group { children: Vec::new(), collapsed: false }, &channels);
for b in gl.channels.values_mut() {
b.mode = BlendMode::Passthrough;
}
s.doc.project.insert_layer(ts, gl, Some(id), false)?;
s.doc.project.move_above(id, Some(gid), true)?;
s.selected.insert(ts, gid);
Ok(gid)
})?;
Ok(json!({ "layer": g.0 }))
}
fn select(s: &mut Session, p: &Value) -> Result<Value> {
let id = layer_param(s, "layer.select", p)?;
let (ts, _, _) = s.doc.project.locate(id).ok_or_else(|| bad("layer.select", "layer not in a stack"))?;
s.active_set = ts;
s.selected.insert(ts, id);
s.target = match p.get("target") {
Some(Value::String(t)) if t == "mask" => {
if s.doc.project.layer(s.doc.project.mask_owner(id))?.mask.is_none() {
return Err(bad("layer.select", "the layer has no mask"));
}
StackTarget::Mask
}
Some(Value::String(t)) if t == "content" => StackTarget::Content,
Some(v) => match v.as_u64() {
Some(e) if s.doc.project.effect(LayerId(e)).is_some_and(|(owner, _)| owner == id) => StackTarget::Effect(LayerId(e)),
_ => return Err(bad("layer.select", "target must be content, mask or an effect id of this layer")),
},
None => StackTarget::Content,
};
s.revision = s.revision.wrapping_add(1);
Ok(json!({ "layer": id.0, "textureSet": ts }))
}
fn rename(s: &mut Session, p: &Value) -> Result<Value> {
let id = layer_param(s, "layer.rename", p)?;
let name = strp(p, "name").map(str::trim).filter(|n| !n.is_empty()).ok_or_else(|| bad("layer.rename", "`name` is required"))?.to_string();
if name.chars().count() > 256 {
return Err(bad("layer.rename", "name is longer than 256 characters"));
}
s.edit("Rename layer", |s| {
s.doc.project.layer_mut(id)?.name = name;
Ok(())
})?;
Ok(Value::Null)
}
fn visible(s: &mut Session, p: &Value) -> Result<Value> {
let id = layer_param(s, "layer.visible", p)?;
let v = s.edit("Layer visibility", |s| {
let l = s.doc.project.layer_mut(id)?;
l.visible = boolp(p, "visible").unwrap_or(!l.visible);
Ok(l.visible)
})?;
Ok(json!({ "visible": v }))
}
fn move_layer(s: &mut Session, p: &Value) -> Result<Value> {
let id = layer_param(s, "layer.move", p)?;
s.edit("Move layer", |s| {
if let Some(d) = p.get("delta").and_then(Value::as_i64) {
let (_, _, i) = s.doc.project.locate(id).ok_or(EngineError::Other("layer not in a stack".into()))?;
let to = (i as i64 + d).max(0) as usize;
s.doc.project.move_layer(id, to)?;
} else if let Some(i) = u64p(p, "index") {
s.doc.project.move_layer(id, usize::try_from(i).unwrap_or(usize::MAX))?;
} else if p.get("above").is_some() {
let above = u64p(p, "above").map(LayerId);
s.doc.project.move_above(id, above, boolp(p, "inside").unwrap_or(false))?;
} else {
return Err(bad("layer.move", "give `delta`, `index` or `above`"));
}
Ok(())
})?;
Ok(Value::Null)
}
fn blend(s: &mut Session, p: &Value) -> Result<Value> {
let id = content_param(s, "layer.blend", p)?;
let all = strp(p, "channel") == Some("all");
let ch = if all { None } else { channel_param("layer.blend", p, "channel")? };
let mode = blend_param("layer.blend", p, "mode")?;
let opacity = f32p(p, "opacity").map(|o| o.clamp(0.0, 1.0));
let enabled = boolp(p, "enabled");
let ts_channels = channels_of(s);
s.edit("Layer blending", |s| {
let l = s.doc.project.layer_mut(id)?;
let targets: Vec<Channel> = match ch {
Some(c) => vec![c],
None => ts_channels.clone(),
};
for c in targets {
match enabled {
Some(false) => {
l.channels.remove(&c);
continue;
}
Some(true) => {
let mode = if l.is_group() { BlendMode::Passthrough } else { BlendMode::Normal };
l.channels.entry(c).or_insert(ChannelBlend { mode, opacity: 1.0 });
}
None => {}
}
if let Some(b) = l.channels.get_mut(&c) {
if let Some(m) = mode {
b.mode = m;
}
if let Some(o) = opacity {
b.opacity = o;
}
}
}
Ok(())
})?;
Ok(Value::Null)
}
/// Which fill `layer.fill.*` edits: a fill layer's (`layer`) or a content fill effect's
/// (`effect`).
#[derive(Clone, Copy)]
enum FillTarget {
Layer(LayerId),
Effect(LayerId),
}
fn fill_target(s: &Session, p: &Value, cmd: &str) -> Result<FillTarget> {
match u64p(p, "effect").map(LayerId) {
Some(e) => match s.doc.project.effect(e) {
Some((_, x)) if matches!(x.kind, EffectKind::Material(_)) => Ok(FillTarget::Effect(e)),
_ => Err(bad(cmd, format!("{} is not a content fill effect", e.0))),
},
None => Ok(FillTarget::Layer(content_param(s, cmd, p)?)),
}
}
fn fill_mut(s: &mut Session, target: FillTarget) -> Result<&mut Fill> {
match target {
FillTarget::Layer(id) => match &mut s.doc.project.layer_mut(id)?.kind {
LayerKind::Fill(f) => Ok(f),
_ => Err(EngineError::Other("not a fill layer".into())),
},
FillTarget::Effect(e) => match s.doc.project.effect_mut(e).map(|x| &mut x.kind) {
Some(EffectKind::Material(f)) => Ok(f),
_ => Err(EngineError::Other("not a content fill effect".into())),
},
}
}
fn fill_set(s: &mut Session, p: &Value) -> Result<Value> {
let target = fill_target(s, p, "layer.fill.set")?;
let ch = channel_param("layer.fill.set", p, "channel")?.ok_or_else(|| bad("layer.fill.set", "`channel` is required"))?;
// `solo`: this channel on, every other one off.
let solo = boolp(p, "solo") == Some(true);
let enabled = if solo { Some(true) } else { boolp(p, "enabled") };
let source = if let Some(kind) = strp(p, "procedural") {
let kind = ProceduralKind::parse(kind).ok_or_else(|| bad("layer.fill.set", format!("unknown procedural `{kind}`")))?;
let mut pr = Procedural::new(kind);
if let Some(v) = f32p(p, "scale") {
pr.scale = v.clamp(0.001, 1000.0);
}
if let Some(v) = u64p(p, "seed") {
pr.seed = v as u32;
}
if let Some(v) = f32p(p, "contrast") {
pr.contrast = v.clamp(0.0, 20.0);
}
if let Some(v) = f32p(p, "balance") {
pr.balance = v.clamp(-1.0, 1.0);
}
pr.invert = boolp(p, "invert").unwrap_or(false);
Some(Source::Procedural { pattern: pr, low: color_param(p, "low").unwrap_or([0.0; 3]), high: color_param(p, "high").unwrap_or([1.0; 3]) })
} else if let Some(c) = color_param(p, "color").or_else(|| color_param(p, "value")) {
Some(Source::Uniform(c))
} else if let Some(name) = strp(p, "image") {
Some(Source::Image { name: name.to_string() })
} else if let Some(a) = u64p(p, "anchor") {
let reader = match target {
FillTarget::Layer(id) => Some(id),
FillTarget::Effect(e) => s.doc.project.effect(e).map(|(owner, _)| owner),
};
let reader = reader.ok_or_else(|| bad("layer.fill.set", "the fill is not in a layer"))?;
let anchor_channel = channel_param("layer.fill.set", p, "anchorChannel")?.unwrap_or(ch);
Some(crate::mask_cmds::anchor_source(s, "layer.fill.set", reader, LayerId(a), anchor_channel)?)
} else if enabled.is_some() {
None
} else {
return Err(bad("layer.fill.set", "give `color`, `value`, `procedural`, `image`, `anchor`, `enabled` or `solo`"));
};
s.edit("Set fill", |s| {
let f = fill_mut(s, target)?;
match target {
// A fill effect's channel is on while it has a source.
FillTarget::Effect(_) if enabled == Some(false) => {
f.sources.remove(&ch);
}
FillTarget::Effect(_) => {
let src = source.unwrap_or_else(|| f.source(ch));
f.sources.insert(ch, src);
if solo {
f.sources.retain(|c, _| *c == ch);
}
}
FillTarget::Layer(id) => {
if let Some(src) = source {
f.sources.insert(ch, src);
}
let l = s.doc.project.layer_mut(id)?;
if enabled == Some(false) {
l.channels.remove(&ch);
} else {
l.channels.entry(ch).or_default();
}
if solo {
l.channels.retain(|c, _| *c == ch);
}
}
}
Ok(())
})?;
Ok(Value::Null)
}
pub(crate) fn projection_from(p: &Value, cmd: &str) -> Result<Projection> {
let scale = f32p(p, "scale").unwrap_or(1.0).clamp(0.001, 1000.0);
Ok(match strp(p, "projection").unwrap_or("uv") {
"uv" => Projection::Uv { scale: [scale, scale], rotation: f32p(p, "rotation").unwrap_or(0.0), offset: [0.0, 0.0] },
"triplanar" | "tri-planar" => Projection::Triplanar { scale, sharpness: f32p(p, "sharpness").unwrap_or(8.0).clamp(1.0, 64.0), offset: [0.0; 3] },
"planar" => Projection::Planar { scale, axis: u64p(p, "axis").unwrap_or(2).min(2) as u8, offset: [0.0; 3] },
"spherical" => Projection::Spherical { scale },
"cylindrical" => Projection::Cylindrical { scale, axis: u64p(p, "axis").unwrap_or(1).min(2) as u8 },
other => return Err(bad(cmd, format!("unknown projection `{other}`"))),
})
}
fn fill_projection(s: &mut Session, p: &Value) -> Result<Value> {
let target = fill_target(s, p, "layer.fill.projection")?;
let proj = projection_from(p, "layer.fill.projection")?;
s.edit("Fill projection", |s| {
fill_mut(s, target)?.projection = proj;
Ok(())
})?;
Ok(Value::Null)
}
fn color_tag(s: &mut Session, p: &Value) -> Result<Value> {
let id = layer_param(s, "layer.colorTag", p)?;
let tag = u64p(p, "tag").map(|t| t.min(7) as u8);
s.edit("Layer color tag", |s| {
s.doc.project.layer_mut(id)?.color_tag = tag;
Ok(())
})?;
Ok(Value::Null)
}
fn list(s: &mut Session, p: &Value) -> Result<Value> {
let ts = u64p(p, "ts").map(|t| t as usize).unwrap_or(s.ts());
Ok(crate::inspect::stack(s, ts))
}