Document sliders apply live while dragged, as one undo step

This commit is contained in:
bflatastic committed 2026-11-02 16:28:51 +07:00
1 parent c2c5987bf2
commit e828af5c35
9 files changed
+132 -75

No files matched your search

+6 -2
View File
@@ -88,11 +88,15 @@ pub fn find(id: &str) -> Option<&'static CommandSpec> {
command_specs().iter().find(|c| c.id == id)
}
/// Run a command by id with JSON params (empty params = defaults, never a dialog).
/// Run a command by id with JSON params (empty params = defaults, never a dialog). With
/// `merge: true` its edits continue the previous undo step of the same label (drags).
pub fn execute(s: &mut Session, id: &str, params: &Value) -> Result<Value> {
let spec = find(id).ok_or_else(|| EngineError::UnknownCommand(id.to_string()))?;
(spec.enabled)(s).map_err(|why| EngineError::Disabled { cmd: id.to_string(), why })?;
(spec.run)(s, params)
let outer = std::mem::replace(&mut s.merge_edits, boolp(params, "merge").unwrap_or(false));
let result = (spec.run)(s, params);
s.merge_edits = outer;
result
}
/// Every command, as JSON (for `commands` listings and MCP).
+1 -1
View File
@@ -162,7 +162,7 @@ fn set(s: &mut Session, p: &Value) -> Result<Value> {
{
return Err(bad(cmd, format!("no image resource `{name}`")));
}
s.edit_merging("Edit decal", crate::commands::boolp(p, "merge").unwrap_or(false), |s| {
s.edit("Edit decal", |s| {
if let LayerKind::Fill(f) = &mut s.doc.project.layer_mut(id)?.kind {
f.projection = Projection::Decal(d);
if let Some(name) = image {
+5 -1
View File
@@ -325,6 +325,9 @@ pub struct Session {
pub caches: Vec<SetCache>,
pub(crate) undo: Vec<(String, Document)>,
pub(crate) redo: Vec<(String, Document)>,
/// Set by [`crate::execute`] from a command's `merge` param: its edits continue the previous
/// undo step with the same label (a slider drag is one step however many values it applies).
pub(crate) merge_edits: bool,
pub tool: ToolState,
pub active_set: usize,
/// Selected layer per texture set.
@@ -385,6 +388,7 @@ impl Session {
caches,
undo: Vec::new(),
redo: Vec::new(),
merge_edits: false,
tool: ToolState::default(),
active_set: 0,
selected,
@@ -480,7 +484,7 @@ impl Session {
/// Run an undoable edit. On error the document is left untouched.
pub fn edit<T>(&mut self, label: &str, f: impl FnOnce(&mut Session) -> Result<T>) -> Result<T> {
self.edit_merging(label, false, f)
self.edit_merging(label, self.merge_edits, f)
}
/// [`Session::edit`] that, with `merge`, continues the previous undo step when it has the
+21
View File
@@ -260,3 +260,24 @@ fn histogram_counts_what_an_effect_reads() {
assert!(execute(&mut s, "effect.histogram", &json!({"effect": 999_999})).is_err());
assert!(execute(&mut s, "effect.histogram", &json!({"effect": lv, "channel": "nope"})).is_err());
}
/// `merge: true` on any command folds its edit into the previous step of the same label (a
/// slider drag applies a value per frame and is one undo step); the next command starts afresh.
#[test]
fn merged_edits_are_one_undo_step() {
let mut s = session();
execute(&mut s, "layer.add.fill", &json!({"color": [1.0, 0.0, 0.0]})).unwrap();
let hsl = LayerId(id(execute(&mut s, "effect.add.filter", &json!({"target": "content", "filter": "hsl"})).unwrap(), "effect"));
let opacity = |s: &Session| s.doc.project.effect(hsl).unwrap().1.opacity;
let depth = s.history_labels().len();
for (i, op) in [0.8, 0.6, 0.4].into_iter().enumerate() {
execute(&mut s, "effect.set", &json!({"effect": hsl.0, "opacity": op, "merge": i > 0})).unwrap();
}
assert_eq!(s.history_labels().len(), depth + 1, "one step for the drag");
execute(&mut s, "effect.set", &json!({"effect": hsl.0, "opacity": 0.2})).unwrap();
assert_eq!(s.history_labels().len(), depth + 2, "a later edit without merge is its own step");
execute(&mut s, "edit.undo", &Value::Null).unwrap();
assert_eq!(opacity(&s), 0.4);
execute(&mut s, "edit.undo", &Value::Null).unwrap();
assert_eq!(opacity(&s), 1.0, "one undo reverts the whole drag");
}
+54 -54
View File
@@ -798,8 +798,8 @@ pub(crate) fn texture_set_settings(app: &mut TextureCraftApp, ui: &mut Ui) {
}
ui.add_space(6.0);
let mut hs = set.height_strength;
if slider(ui, tr("Height to normal strength"), &mut hs, 0.0..=10.0, 2).changed() {
app.run("textureSet.settings", json!({"ts": ts, "heightStrength": hs}));
if let Some(merge) = slider_edit(ui, tr("Height to normal strength"), &mut hs, 0.0..=10.0, 2) {
app.run("textureSet.settings", json!({"ts": ts, "heightStrength": hs, "merge": merge}));
}
let directx = app.session.doc.project.normal_format == texturecraft_engine::core::NormalFormat::DirectX;
combo(ui, tr("Normal map format"), if directx { "DirectX" } else { "OpenGL" }, |ui| {
@@ -981,11 +981,11 @@ fn height_mask_section(app: &mut TextureCraftApp, ui: &mut Ui, layer: &Layer) {
}
ui.add_enabled_ui(hm.enabled, |ui| {
let (mut contrast, mut offset) = (hm.contrast, hm.offset);
if slider_edit(ui, tr("Contrast"), &mut contrast, 0.0..=16.0, 2) {
app.run("layer.set", json!({"layer": id, "heightMask": {"contrast": contrast}}));
if let Some(merge) = slider_edit(ui, tr("Contrast"), &mut contrast, 0.0..=16.0, 2) {
app.run("layer.set", json!({"layer": id, "heightMask": {"contrast": contrast}, "merge": merge}));
}
if slider_edit(ui, tr("Height offset"), &mut offset, -1.0..=1.0, 2) {
app.run("layer.set", json!({"layer": id, "heightMask": {"offset": offset}}));
if let Some(merge) = slider_edit(ui, tr("Height offset"), &mut offset, -1.0..=1.0, 2) {
app.run("layer.set", json!({"layer": id, "heightMask": {"offset": offset}, "merge": merge}));
}
});
});
@@ -1628,34 +1628,34 @@ fn projection_editor(app: &mut TextureCraftApp, ui: &mut Ui, fill: &Fill, base:
Projection::Decal(_) => return,
};
let mut edit = |extra: Value| app.run("layer.fill.projection", with(base, extra));
if slider_edit(ui, tr("Scale / tiling"), &mut scale, 0.01..=20.0, 2) {
edit(json!({"scale": scale}));
if let Some(merge) = slider_edit(ui, tr("Scale / tiling"), &mut scale, 0.01..=20.0, 2) {
edit(json!({"scale": scale, "merge": merge}));
}
match &fill.projection {
Projection::Uv { rotation, offset, .. } => {
let mut r = *rotation;
if slider_edit(ui, tr("Rotation"), &mut r, 0.0..=360.0, 0) {
edit(json!({"rotation": r}));
if let Some(merge) = slider_edit(ui, tr("Rotation"), &mut r, 0.0..=360.0, 0) {
edit(json!({"rotation": r, "merge": merge}));
}
if let Some(o) = offset_sliders(ui, ["U", "V"], *offset) {
edit(json!({"offset": o}));
if let Some((o, merge)) = offset_sliders(ui, ["U", "V"], *offset) {
edit(json!({"offset": o, "merge": merge}));
}
}
Projection::Triplanar { sharpness, offset, .. } => {
let mut s = *sharpness;
if slider_edit(ui, tr("Blend sharpness"), &mut s, 1.0..=64.0, 1) {
edit(json!({"sharpness": s}));
if let Some(merge) = slider_edit(ui, tr("Blend sharpness"), &mut s, 1.0..=64.0, 1) {
edit(json!({"sharpness": s, "merge": merge}));
}
if let Some(o) = offset_sliders(ui, ["X", "Y", "Z"], *offset) {
edit(json!({"offset": o}));
if let Some((o, merge)) = offset_sliders(ui, ["X", "Y", "Z"], *offset) {
edit(json!({"offset": o, "merge": merge}));
}
}
Projection::Planar { axis, offset, .. } => {
if let Some(a) = axis_combo(ui, *axis) {
edit(json!({"axis": a}));
}
if let Some(o) = offset_sliders(ui, ["X", "Y", "Z"], *offset) {
edit(json!({"offset": o}));
if let Some((o, merge)) = offset_sliders(ui, ["X", "Y", "Z"], *offset) {
edit(json!({"offset": o, "merge": merge}));
}
}
Projection::Cylindrical { axis, .. } => {
@@ -1667,13 +1667,14 @@ fn projection_editor(app: &mut TextureCraftApp, ui: &mut Ui, fill: &Fill, base:
}
}
/// A slider per offset component ("Offset U", …): the whole offset once one is edited.
fn offset_sliders<const N: usize>(ui: &mut Ui, axes: [&str; N], mut v: [f32; N]) -> Option<[f32; N]> {
let mut done = false;
/// A slider per offset component ("Offset U", …): the whole offset once one is edited, with
/// [`slider_edit`]'s `merge`.
fn offset_sliders<const N: usize>(ui: &mut Ui, axes: [&str; N], mut v: [f32; N]) -> Option<([f32; N], bool)> {
let mut edit = None;
for (axis, x) in axes.iter().zip(v.iter_mut()) {
done |= slider_edit(ui, &trf("Offset {axis}", &[("axis", axis)]), x, -1.0..=1.0, 2);
edit = edit.or(slider_edit(ui, &trf("Offset {axis}", &[("axis", axis)]), x, -1.0..=1.0, 2));
}
done.then_some(v)
edit.map(|merge| (v, merge))
}
/// The axis a planar or cylindrical projection runs along: the one picked, if any.
@@ -1709,12 +1710,12 @@ fn decal_editor(app: &mut TextureCraftApp, ui: &mut Ui, d: &Decal, layer: LayerI
(tr("Offset up"), -diag..=diag),
(tr("Depth"), diag * 0.005..=diag),
];
let mut done = false;
let mut edit = None;
for ((label, range), x) in rows.into_iter().zip(v.iter_mut()) {
done |= slider_edit(ui, label, x, range, 3);
edit = edit.or(slider_edit(ui, label, x, range, 3));
}
if done {
app.run("layer.decal.set", json!({"layer": layer.0, "size": [v[0], v[1]], "rotation": v[2], "offset": [v[3], v[4]], "depth": v[5]}));
if let Some(merge) = edit {
app.run("layer.decal.set", json!({"layer": layer.0, "size": [v[0], v[1]], "rotation": v[2], "offset": [v[3], v[4]], "depth": v[5], "merge": merge}));
}
ui.label(
RichText::new(tr("The image's alpha cuts the decal's shape; faces turned away and surfaces beyond its depth stay clear."))
@@ -1776,9 +1777,8 @@ fn fill_channel(app: &mut TextureCraftApp, ui: &mut Ui, fill: &Fill, base: &Valu
}
} else {
let range = if c.kind() == ChannelKind::Signed { -1.0..=1.0 } else { 0.0..=1.0 };
let r = slider(ui, tr("Value"), &mut v[0], range, 2);
if r.changed() {
app.run("layer.fill.set", set(json!({"value": v[0]})));
if let Some(merge) = slider_edit(ui, tr("Value"), &mut v[0], range, 2) {
app.run("layer.fill.set", set(json!({"value": v[0], "merge": merge})));
}
}
}
@@ -1796,10 +1796,10 @@ fn fill_channel(app: &mut TextureCraftApp, ui: &mut Ui, fill: &Fill, base: &Valu
let r2 = slider_edit(ui, tr("Contrast"), &mut con, 0.0..=8.0, 2);
let mut seed = pattern.seed as f32;
let r3 = slider_edit(ui, tr("Seed"), &mut seed, 0.0..=999.0, 0);
if r1 || r2 || r3 {
if let Some(merge) = r1.or(r2).or(r3) {
app.run(
"layer.fill.set",
set(json!({"procedural": pattern.kind.label(), "scale": s, "contrast": con, "seed": seed as u64, "low": low, "high": high})),
set(json!({"procedural": pattern.kind.label(), "scale": s, "contrast": con, "seed": seed as u64, "low": low, "high": high, "merge": merge})),
);
}
if c.kind() == ChannelKind::Color {
@@ -1849,8 +1849,8 @@ fn effect_properties(app: &mut TextureCraftApp, ui: &mut Ui, layer: &Layer, eid:
});
});
let mut op = e.opacity;
if slider_edit(ui, tr("Opacity"), &mut op, 0.0..=1.0, 2) {
app.run("effect.set", json!({"effect": id, "opacity": op}));
if let Some(merge) = slider_edit(ui, tr("Opacity"), &mut op, 0.0..=1.0, 2) {
app.run("effect.set", json!({"effect": id, "opacity": op, "merge": merge}));
}
ui.separator();
match &e.kind {
@@ -1872,8 +1872,8 @@ fn effect_properties(app: &mut TextureCraftApp, ui: &mut Ui, layer: &Layer, eid:
let r4 = slider_edit(ui, tr("Noise scale"), &mut ns, 0.1..=64.0, 1);
let mut inv = g.invert;
let r5 = ui.checkbox(&mut inv, tr("Invert"));
if r1 || r2 || r3 || r4 || r5.changed() {
app.run("effect.set", json!({"effect": id, "level": level, "softness": soft, "noise": noise, "noiseScale": ns, "invert": inv}));
if let Some(merge) = r1.or(r2).or(r3).or(r4).or(r5.changed().then_some(false)) {
app.run("effect.set", json!({"effect": id, "level": level, "softness": soft, "noise": noise, "noiseScale": ns, "invert": inv, "merge": merge}));
}
if !app.session.doc.baked.contains_key(&app.session.ts()) {
ui.label(
@@ -1886,13 +1886,13 @@ fn effect_properties(app: &mut TextureCraftApp, ui: &mut Ui, layer: &Layer, eid:
levels_histogram(app, ui, layer, eid, (l.in_low, l.in_high));
let mut v = [l.in_low, l.in_high, l.gamma, l.out_low, l.out_high];
let labels = [tr("Input low"), tr("Input high"), tr("Gamma"), tr("Output low"), tr("Output high")];
let mut done = false;
let mut edit = None;
for (i, label) in labels.iter().enumerate() {
let range = if i == 2 { 0.1..=5.0 } else { 0.0..=1.0 };
done |= slider_edit(ui, label, &mut v[i], range, 2);
edit = edit.or(slider_edit(ui, label, &mut v[i], range, 2));
}
if done {
app.run("effect.set", json!({"effect": id, "inLow": v[0], "inHigh": v[1], "gamma": v[2], "outLow": v[3], "outHigh": v[4]}));
if let Some(merge) = edit {
app.run("effect.set", json!({"effect": id, "inLow": v[0], "inHigh": v[1], "gamma": v[2], "outLow": v[3], "outHigh": v[4], "merge": merge}));
}
}
EffectKind::Fill { source, .. } => {
@@ -1917,8 +1917,8 @@ fn effect_properties(app: &mut TextureCraftApp, ui: &mut Ui, layer: &Layer, eid:
match source {
Source::Uniform(v) => {
let mut x = v[0];
if slider_edit(ui, tr("Value"), &mut x, 0.0..=1.0, 2) {
app.run("effect.set", json!({"effect": id, "value": x}));
if let Some(merge) = slider_edit(ui, tr("Value"), &mut x, 0.0..=1.0, 2) {
app.run("effect.set", json!({"effect": id, "value": x, "merge": merge}));
}
}
Source::Anchor { channel, .. } => {
@@ -2024,16 +2024,16 @@ fn levels_histogram(app: &TextureCraftApp, ui: &mut Ui, layer: &Layer, eid: Laye
/// The parameters of filter effect `id`.
fn filter_properties(app: &mut TextureCraftApp, ui: &mut Ui, id: u64, f: &Filter) {
let tk = Tokens::get(ui.ctx());
let set = |app: &mut TextureCraftApp, key: &str, v: Value| {
let mut p = json!({ "effect": id });
let set = |app: &mut TextureCraftApp, key: &str, v: Value, merge: bool| {
let mut p = json!({ "effect": id, "merge": merge });
p[key] = v;
app.run("effect.set", p);
};
ui.label(caption(tr(f.label())));
if let Filter::Hsl { hue, .. } = f {
let mut h = hue * 360.0;
if slider_edit(ui, tr("Hue shift (degrees)"), &mut h, -180.0..=180.0, 0) {
set(app, "hue", json!(h / 360.0));
if let Some(merge) = slider_edit(ui, tr("Hue shift (degrees)"), &mut h, -180.0..=180.0, 0) {
set(app, "hue", json!(h / 360.0), merge);
}
}
for (key, label, mut v, lo, hi) in scalar_params(f) {
@@ -2044,8 +2044,8 @@ fn filter_properties(app: &mut TextureCraftApp, ui: &mut Ui, id: u64, f: &Filter
} else {
2
};
if slider_edit(ui, tr(label), &mut v, lo..=hi, decimals) {
set(app, key, json!(v));
if let Some(merge) = slider_edit(ui, tr(label), &mut v, lo..=hi, decimals) {
set(app, key, json!(v), merge);
}
}
match f {
@@ -2054,12 +2054,12 @@ fn filter_properties(app: &mut TextureCraftApp, ui: &mut Ui, id: u64, f: &Filter
{
ui.label(RichText::new(label).strong());
let mut v = *rgb;
let mut done = false;
let mut edit = None;
for (x, name) in v.iter_mut().zip([tr("Cyan / red"), tr("Magenta / green"), tr("Yellow / blue")]) {
done |= slider_edit(ui, name, x, -1.0..=1.0, 2);
edit = edit.or(slider_edit(ui, name, x, -1.0..=1.0, 2));
}
if done {
set(app, key, json!(v));
if let Some(merge) = edit {
set(app, key, json!(v), merge);
}
}
}
@@ -2068,7 +2068,7 @@ fn filter_properties(app: &mut TextureCraftApp, ui: &mut Ui, id: u64, f: &Filter
let mut v = *rgb;
ui.horizontal(|ui| {
if color_swatch(ui, &format!("replace_{key}_{id}"), &mut v, 36.0) {
set(app, key, json!(v));
set(app, key, json!(v), false);
}
ui.label(label);
});
@@ -2094,7 +2094,7 @@ fn filter_properties(app: &mut TextureCraftApp, ui: &mut Ui, id: u64, f: &Filter
}
});
if changed {
set(app, "colors", json!(c));
set(app, "colors", json!(c), false);
}
ui.label(RichText::new(tr("Dark to light: the content's luminance picks a color along these stops.")).size(10.5).color(tk.text_dim));
}
+14 -15
View File
@@ -14,23 +14,25 @@ pub fn dnd_release<T: std::any::Any + Send + Sync>(resp: &Response) -> Option<st
}
/// A labelled slider in two rows: "Label ........ value" over a slim track with a round knob.
/// Returns the response of the track (`.changed()` while dragged); for a value that is applied
/// once the edit is done, use [`slider_edit`].
/// Returns the response of the track (`.changed()` while dragged); for a value kept in the
/// document, use [`slider_edit`].
pub fn slider(ui: &mut Ui, label: &str, value: &mut f32, range: std::ops::RangeInclusive<f32>, decimals: usize) -> Response {
slider_inner(ui, label, value, range, decimals).0
}
/// [`slider`] for a value re-read from the document every frame: true on the frame an edit is
/// done (a drag released, a click on the track, a typed value), with `value` holding the result.
pub fn slider_edit(ui: &mut Ui, label: &str, value: &mut f32, range: std::ops::RangeInclusive<f32>, decimals: usize) -> bool {
/// [`slider`] for a value re-read from the document every frame: `Some(merge)` on every frame
/// that changes `value` (live while dragging, a click on the track, a typed value). `merge` is
/// true for the later changes of one drag, so the edit that applies them (with the command's
/// `merge` param) continues the drag's first undo step.
pub fn slider_edit(ui: &mut Ui, label: &str, value: &mut f32, range: std::ops::RangeInclusive<f32>, decimals: usize) -> Option<bool> {
slider_inner(ui, label, value, range, decimals).1
}
fn slider_inner(ui: &mut Ui, label: &str, value: &mut f32, range: std::ops::RangeInclusive<f32>, decimals: usize) -> (Response, bool) {
fn slider_inner(ui: &mut Ui, label: &str, value: &mut f32, range: std::ops::RangeInclusive<f32>, decimals: usize) -> (Response, Option<bool>) {
let tk = Tokens::get(ui.ctx());
let (lo, hi) = (*range.start(), *range.end());
let w = ui.available_width();
let mut done = false;
let mut edit = None;
ui.horizontal(|ui| {
ui.label(RichText::new(label).color(tk.text));
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
@@ -41,7 +43,7 @@ fn slider_inner(ui: &mut Ui, label: &str, value: &mut f32, range: std::ops::Rang
&& v.is_finite()
{
*value = v.clamp(lo, hi);
done = true;
edit = Some(false);
}
});
});
@@ -51,22 +53,19 @@ fn slider_inner(ui: &mut Ui, label: &str, value: &mut f32, range: std::ops::Rang
{
let t = ((p.x - rect.left() - 5.0) / (rect.width() - 10.0).max(1.0)).clamp(0.0, 1.0);
let v = lo + (hi - lo) * t;
// Remembered for the release frame, where the pointer no longer drags.
ui.data_mut(|d| d.insert_temp(resp.id, v));
if (v - *value).abs() > f32::EPSILON {
*value = v;
resp.mark_changed();
// Whether this drag already applied a value (cleared when it ends).
edit = Some(ui.data_mut(|d| std::mem::replace(d.get_temp_mut_or_default::<bool>(resp.id), true)));
}
}
if resp.drag_stopped() || resp.clicked() {
if let Some(v) = ui.data_mut(|d| d.remove_temp::<f32>(resp.id)) {
*value = v;
}
done = true;
ui.data_mut(|d| d.remove_temp::<bool>(resp.id));
}
let t = if hi > lo { ((*value - lo) / (hi - lo)).clamp(0.0, 1.0) } else { 0.0 };
track(ui, &resp, rect.left() + 5.0..=rect.right() - 5.0, rect.center().y, t, 2.0, 4.5);
(resp, done)
(resp, edit)
}
/// A small inline slider for the top tool bar: "Label value" above a short track.
+2 -2
View File
@@ -268,8 +268,8 @@ pub(crate) fn shader(app: &mut TextureCraftApp, ui: &mut Ui) {
let ts = app.session.ts();
if let Some(set) = app.session.doc.project.texture_sets.get(ts) {
let mut hs = set.height_strength;
if slider_edit(ui, tr("Height to normal strength"), &mut hs, 0.0..=10.0, 2) {
app.run("textureSet.settings", json!({"ts": ts, "heightStrength": hs}));
if let Some(merge) = slider_edit(ui, tr("Height to normal strength"), &mut hs, 0.0..=10.0, 2) {
app.run("textureSet.settings", json!({"ts": ts, "heightStrength": hs, "merge": merge}));
}
}
let mut ao = app.session.doc.project.display.ao_intensity;
+27
View File
@@ -51,6 +51,33 @@ fn dragging_the_effect_opacity_applies_it() {
assert!(opacity(&h, effect) < 0.5, "the dragged opacity applies: {}", opacity(&h, effect));
}
/// A generator slider applies while it is dragged (the texture follows the pointer), and the
/// whole drag is one undo step.
#[test]
fn dragging_a_generator_slider_applies_live_as_one_undo_step() {
let (mut h, effect) = harness();
let level = |h: &Harness<'_, TextureCraftApp>| match &h.state().session.doc.project.effect(effect).unwrap().1.kind {
EffectKind::Generator(g) => g.level,
_ => panic!("a generator"),
};
let steps = h.state().session.history_labels().len();
let t = track(&h, "Level");
let at = |x: f32| egui::pos2(t.left() + x, t.center().y);
h.drag_at(at(10.0));
h.run_steps(2);
let mut last = 0.0;
for x in [60.0, 160.0] {
h.hover_at(at(x));
h.run_steps(2);
assert!(level(&h) > last && level(&h) != 0.5, "the level follows the drag before it is released: {last} -> {}", level(&h));
last = level(&h);
}
h.drop_at(at(160.0));
h.run_steps(3);
assert_eq!(level(&h), last);
assert_eq!(h.state().session.history_labels().len(), steps + 1, "one undo step for the drag");
}
/// The combo box in the row of the "Channel" label.
fn channel_picker<'a>(h: &'a Harness<'_, TextureCraftApp>) -> egui_kittest::Node<'a> {
let row = h.get_by_label("Channel").rect().center().y;
+2
View File
@@ -21,6 +21,8 @@ layer clipboard, and `effect.paste {layer?, target?}` adds it to another layer's
`edit.undo {steps?}` and `edit.redo {steps?}` go back or forward several steps at once (as far
as the history reaches); `edit.history` lists the steps done and the undone ones, next first.
Any command takes `merge: true` to fold its edit into the previous undo step when that step has
the same label: a drag that applies a value on every frame stays one step.
## Control channel (desktop app)