diff --git a/crates/engine/src/photocraft_cmds.rs b/crates/engine/src/photocraft_cmds.rs index 2d4e8dcf..7a844a2b 100644 --- a/crates/engine/src/photocraft_cmds.rs +++ b/crates/engine/src/photocraft_cmds.rs @@ -788,6 +788,10 @@ mod tests { execute(&mut s, "layer.rename", &json!({"layer": fill.0, "name": "Red"})).unwrap(); execute(&mut s, "mask.add.black", &Value::Null).unwrap(); execute(&mut s, "layer.group", &json!({"layer": fill.0})).unwrap(); + // TextureCraft folders blend their children with what is below them whatever their mode, + // so even a Normal folder is a pass-through group in the PSD. + let folder = s.doc.project.locate(fill).unwrap().1.unwrap(); + execute(&mut s, "layer.blend", &json!({"layer": folder.0, "channel": "all", "mode": "Normal", "opacity": 0.5})).unwrap(); let r = execute(&mut s, SEND, &json!({"dir": dir.path().display().to_string(), "channels": ["baseColor", "roughness"], "open": false})).unwrap(); let files = r["files"].as_array().unwrap(); assert_eq!(files.len(), 1, "{r}"); @@ -799,6 +803,8 @@ mod tests { // Top-first: the folder holding "Red", then the project's first paint layer. assert_eq!(doc.layers.len(), 2, "{:?}", doc.layers.iter().map(|l| &l.name).collect::>()); assert!(find(children(&doc.layers[0]), "Red").is_some()); + assert_eq!(&doc.layers[0].blend, b"pass"); + assert!((doc.layers[0].opacity - 0.5).abs() < 0.01); assert_eq!(doc.layers[1].name, "Layer 1"); // A paint layer without a mask hides nothing, so its group has no mask (also where it // holds no paint). @@ -1012,6 +1018,40 @@ mod tests { assert!(execute(&mut s, "layer.assignChannel", &json!({"layer": folder.0, "channel": "roughness"})).is_err()); } + #[test] + fn a_layer_made_after_undoing_an_update_is_not_taken_for_the_undone_one() { + let dir = tempdir("psd_undo"); + let mut s = session(); + let (path, doc) = send_psd(&mut s, &dir); + let (w, h) = s.caches[0].size; + let with = |px: [u16; 4]| { + let mut layers = vec![psd::Layer { id: 1, ..new_layer("Base Color", (w, h), px, true) }]; + layers.extend(doc.layers.iter().map(|n| rewrite(n, (w, h)))); + layers + }; + save(&path, with([0, 65535, 0, 65535]), (w, h), 1); + assert_eq!(s.sync_photocraft().len(), 1); + let imported = by_name(&s, "Base Color"); + execute(&mut s, "edit.undo", &Value::Null).unwrap(); + // A layer made now must not get the undone layer's id... + execute(&mut s, "layer.add.fill", &json!({"roughness": 0.3})).unwrap(); + let fill = s.selected_layer().unwrap(); + assert_ne!(fill, imported); + // ...so the next save, which still names that id, leaves the fill alone. + save(&path, with([65535, 0, 0, 65535]), (w, h), 2); + assert_eq!(s.sync_photocraft().len(), 1); + let l = s.doc.project.layer(fill).unwrap(); + assert!(matches!(l.kind, LayerKind::Fill(_))); + assert!(l.channels.contains_key(&Channel::Roughness) && l.channels.contains_key(&Channel::BaseColor), "{:?}", l.channels); + let again = by_name(&s, "Base Color"); + assert!(s.doc.pixels.layer(again, Channel::BaseColor).is_some()); + // Redo after an undo hands out no id twice either. + execute(&mut s, "edit.undo", &Value::Null).unwrap(); + execute(&mut s, "edit.redo", &Value::Null).unwrap(); + let next = s.doc.project.next_id; + assert!(s.doc.project.layers.keys().all(|id| id.0 < next)); + } + #[test] fn edits_to_sent_layers_change_those_layers_and_removals_remove_them() { let dir = tempdir("psd_edit"); @@ -1054,7 +1094,10 @@ mod tests { assert!(s.log.iter().any(|l| l.contains("now a paint layer")), "{:?}", s.log); // One undo brings it all back. execute(&mut s, "edit.undo", &Value::Null).unwrap(); - assert_eq!(s.doc.project, before.project); + let mut restored = s.doc.project.clone(); + restored.next_id = before.project.next_id; + assert_eq!(restored, before.project); + assert!(s.doc.project.next_id >= before.project.next_id, "ids are not handed out twice"); } #[test] diff --git a/crates/engine/src/photocraft_psd.rs b/crates/engine/src/photocraft_psd.rs index ac9188c1..f797e523 100644 --- a/crates/engine/src/photocraft_psd.rs +++ b/crates/engine/src/photocraft_psd.rs @@ -209,19 +209,18 @@ impl Tree<'_> { } let node = match &layer.kind { LayerKind::Group { children, .. } => { - // A folder has one blend mode and opacity in the PSD; TextureCraft has one per channel. - let first = enabled.first().map(|(_, b)| *b).unwrap_or_default(); - let uniform = enabled.iter().all(|(_, b)| b.mode == first.mode && (b.opacity - first.opacity).abs() < 1e-4); - let (blend, opacity) = if uniform { - let (key, note) = psd_key(first.mode); - if let Some(note) = note { - self.warn(&layer.name, note); - } - (key, first.opacity) + // A TextureCraft folder blends its children with the layers below it and then mixes + // the result in by its opacity, whatever its mode: a pass-through group. An + // isolated PSD group would render a Multiply child differently. The PSD has one + // opacity per group; TextureCraft has one per channel. + let first = enabled.first().map(|(_, b)| b.opacity).unwrap_or(1.0); + let opacity = if enabled.iter().all(|(_, b)| (b.opacity - first).abs() < 1e-4) { + first } else { - self.warn(&layer.name, "the folder blends its channels differently; it is sent as a pass-through group at 100%"); - (*b"pass", 1.0) + self.warn(&layer.name, "the folder's channels have different opacities; it is sent at 100%"); + 1.0 }; + let blend = *b"pass"; let id_ = self.id(Role::Folder(id)); let children = self.nodes(children, depth + 1)?; psd::Layer { diff --git a/crates/engine/src/photocraft_sync.rs b/crates/engine/src/photocraft_sync.rs index 4468436f..735dd2c5 100644 --- a/crates/engine/src/photocraft_sync.rs +++ b/crates/engine/src/photocraft_sync.rs @@ -182,10 +182,10 @@ impl Apply<'_> { let id = self.s.doc.project.alloc_id(); let mut layer = Layer::new(id, node.name.clone(), LayerKind::Group { children: Vec::new(), collapsed: false }, &self.channels); layer.visible = node.visible; - let mode = if &node.blend == b"pass" { BlendMode::Passthrough } else { mode_of(&node.blend) }; for b in layer.channels.values_mut() { - *b = ChannelBlend { mode, opacity: node.opacity }; + *b = ChannelBlend { mode: BlendMode::Passthrough, opacity: node.opacity }; } + self.isolated_note(node); self.s.doc.project.layers.insert(id, layer); self.placed.insert(id); let grid = self.grid(node.mask.as_ref(), inherit); @@ -225,23 +225,27 @@ impl Apply<'_> { (rec.is_some_and(|r| r.blend != node.blend), rec.is_some_and(|r| r.opacity != opacity)) } + /// A folder's opacity, when PhotoCraft changed it. Folders always pass through in + /// TextureCraft, so another blend mode on the group only gets a note. fn folder_blend(&mut self, f: LayerId, node: &ReadLayer) -> Result<()> { let (blend, opacity) = self.changed_blend(node); - if !blend && !opacity { - return Ok(()); + if blend { + self.isolated_note(node); } - let mode = if &node.blend == b"pass" { BlendMode::Passthrough } else { mode_of(&node.blend) }; - for b in self.layer_mut(f)?.channels.values_mut().filter(|b| b.mode != BlendMode::Disable) { - if blend { - b.mode = mode; - } - if opacity { + if opacity { + for b in self.layer_mut(f)?.channels.values_mut().filter(|b| b.mode != BlendMode::Disable) { b.opacity = node.opacity; } } Ok(()) } + fn isolated_note(&mut self, node: &ReadLayer) { + if &node.blend != b"pass" { + self.note(format!("\"{}\": folders in TextureCraft pass through, so the group's blend mode is not kept", node.name)); + } + } + /// The mask of `node`, when PhotoCraft changed it. fn mask(&mut self, id: LayerId, node: &ReadLayer) -> Result<()> { if self.sent_of(node).is_some_and(|r| r.mask == record(node, Role::Folder(id)).mask) { diff --git a/crates/engine/src/session.rs b/crates/engine/src/session.rs index 12f5ff32..ef255249 100644 --- a/crates/engine/src/session.rs +++ b/crates/engine/src/session.rs @@ -672,6 +672,9 @@ impl Session { } fn after_history(&mut self, other: &Document) { + // Ids are never handed out twice, even after an undo: links outside the document (such as + // a PhotoCraft hand-off's record) name layers by id, and must not find a later layer. + self.doc.project.next_id = self.doc.project.next_id.max(other.project.next_id); self.modified = true; self.revision = self.revision.wrapping_add(1); self.invalidate_changed(other); diff --git a/crates/formats/src/psd.rs b/crates/formats/src/psd.rs index 4b5933ed..d780020b 100644 --- a/crates/formats/src/psd.rs +++ b/crates/formats/src/psd.rs @@ -901,11 +901,14 @@ pub fn read_psd(bytes: &[u8]) -> Result { _ => {} } } - let pixels = (rec.section.is_none() || rec.section == Some(0)).then(|| ReadKind::Pixels { - x: rec.rect.1, - y: rec.rect.0, - image: interleave(&planes, (rw, rh)), - }); + let pixels = if rec.section.is_none() || rec.section == Some(0) { + // The interleaved image is allocated whatever channels the record has. + let need = (rw as u64).saturating_mul(rh as u64).saturating_mul(8); + budget = budget.checked_sub(need).ok_or_else(|| FormatError::TooLarge("the document's layers are too large to read back".into()))?; + Some(ReadKind::Pixels { x: rec.rect.1, y: rec.rect.0, image: interleave(&planes, (rw, rh)) }) + } else { + None + }; let mask = match rec.mask { Some((mrect, default, true)) => { let (mw, mh) = rect_size(mrect)?; @@ -1117,6 +1120,46 @@ mod tests { assert_eq!(&image.data[4..8], &[10 * 257, 20 * 257, 30 * 257, 65535]); } + #[test] + fn a_huge_layer_without_channels_is_refused_before_it_is_allocated() { + // One pixel layer claiming 30000×30000 texels but storing no channels: nothing to decode, + // yet its image would take 7 GB. + let mut rec = Vec::new(); + for v in [0, 0, 30000, 30000] { + rec.i32(v); + } + rec.u16(0); + rec.bytes(b"8BIMnorm"); + rec.bytes(&[255, 0, 8, 0]); + rec.u32(12); + rec.u32(0); // no mask + rec.u32(0); // no blending ranges + rec.bytes(&[0, 0, 0, 0]); // empty name, padded + let mut info = Vec::new(); + info.i16(1); + info.bytes(&rec); + let mut section = Vec::new(); + section.u32(info.len() as u32); + section.bytes(&info); + section.u32(0); + let mut f = Vec::new(); + f.bytes(b"8BPS"); + f.u16(1); + f.bytes(&[0; 6]); + f.u16(4); + f.u32(1); + f.u32(1); + f.u16(16); + f.u16(3); + f.u32(0); + f.u32(0); + f.u32(section.len() as u32); + f.bytes(§ion); + f.u16(0); + f.bytes(&[0; 8]); + assert!(matches!(read_psd(&f), Err(FormatError::TooLarge(_))), "{:?}", read_psd(&f).map(|d| d.layers.len())); + } + #[test] fn hostile_input_is_an_error() { assert!(read_psd(b"").is_err()); diff --git a/crates/ui-egui/src/dock.rs b/crates/ui-egui/src/dock.rs index bbda399c..b0826ca3 100644 --- a/crates/ui-egui/src/dock.rs +++ b/crates/ui-egui/src/dock.rs @@ -448,7 +448,25 @@ fn layer_row(app: &mut TextureCraftApp, ui: &mut Ui, layer: &Layer, depth: usize let ch = app.ui.layer_channel; let blend_rect = Rect::from_min_size(pos2(rect.right() - right_w - 2.0, rect.top() + 3.0), vec2(right_w, 16.0)); let op_rect = Rect::from_min_size(pos2(rect.right() - right_w - 2.0, rect.top() + 19.0), vec2(right_w, 16.0)); - if let Some(b) = blend { + // A paint layer with no channel on (its name named none) offers the picker even when the + // displayed channel is the one holding its pixels. + if let Some(choices) = channel_choices(app, layer) { + let r = ui + .interact(blend_rect.union(op_rect), ui.scope_id().with(("assign", layer.id.0)), Sense::click()) + .on_hover_text(tr("This layer has no channel on: choose the channel its painting is for")); + p.text(blend_rect.right_center() - vec2(10.0, 0.0), egui::Align2::RIGHT_CENTER, ic::WARNING, egui::FontId::proportional(12.0), tk.warning); + p.text(blend_rect.right_center(), egui::Align2::RIGHT_CENTER, ic::CARET_DOWN, egui::FontId::proportional(8.0), tk.text_dim); + egui::Popup::menu(&r).show(|ui| { + ui.set_min_width(160.0); + ui.label(RichText::new(tr("Choose channel")).strong()); + for c in choices { + if ui.button(tr(c.label())).clicked() { + app.run("layer.assignChannel", json!({"layer": layer.id.0, "channel": c.id()})); + ui.close(); + } + } + }); + } else if let Some(b) = blend { let br = ui.interact(blend_rect, ui.scope_id().with(("blend", layer.id.0)), Sense::click()).on_hover_text(tr("Blending mode of the displayed channel")); p.text(blend_rect.right_center() - vec2(10.0, 0.0), egui::Align2::RIGHT_CENTER, b.mode.short(), egui::FontId::proportional(11.0), tk.text); p.text(blend_rect.right_center(), egui::Align2::RIGHT_CENTER, ic::CARET_DOWN, egui::FontId::proportional(8.0), tk.text_dim); @@ -478,23 +496,6 @@ fn layer_row(app: &mut TextureCraftApp, ui: &mut Ui, layer: &Layer, depth: usize if r.changed() { app.run("layer.blend", json!({"layer": layer.id.0, "channel": ch.id(), "opacity": op / 100.0})); } - } else if let Some(choices) = channel_choices(app, layer) { - // A paint layer brought in with no channel on (its name named none): pick one here. - let r = ui - .interact(blend_rect.union(op_rect), ui.scope_id().with(("assign", layer.id.0)), Sense::click()) - .on_hover_text(tr("This layer has no channel on: choose the channel its painting is for")); - p.text(blend_rect.right_center() - vec2(10.0, 0.0), egui::Align2::RIGHT_CENTER, ic::WARNING, egui::FontId::proportional(12.0), tk.warning); - p.text(blend_rect.right_center(), egui::Align2::RIGHT_CENTER, ic::CARET_DOWN, egui::FontId::proportional(8.0), tk.text_dim); - egui::Popup::menu(&r).show(|ui| { - ui.set_min_width(160.0); - ui.label(RichText::new(tr("Choose channel")).strong()); - for c in choices { - if ui.button(tr(c.label())).clicked() { - app.run("layer.assignChannel", json!({"layer": layer.id.0, "channel": c.id()})); - ui.close(); - } - } - }); } else { p.text(blend_rect.right_center(), egui::Align2::RIGHT_CENTER, tr("off"), egui::FontId::proportional(11.0), tk.text_dim); } diff --git a/docs/control-protocol.md b/docs/control-protocol.md index 47ea4d60..1ac68202 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -346,8 +346,10 @@ else on `PATH`). The menu item sends every texture set. written from the public file format specification), holding every channel so that a mask edited once shapes all of them: -- Every folder is a group, with the folder's mask and, when all its channels blend alike, their - blend mode and opacity (otherwise a pass-through group at 100%, with a warning). +- Every folder is a pass-through group with the folder's mask and, when all its channels share one, + its opacity (otherwise 100%, with a warning). A TextureCraft folder blends its children with the + layers below it and mixes the result in by its opacity, whatever its mode, which is what a + pass-through group does; an isolated group would render a Multiply child differently. - Every layer is a pass-through group of the same name. The layer's mask (painted, generators, filters, geometry and height masks included) is the group's own editable layer mask; it is left out when it hides nothing. @@ -373,13 +375,14 @@ stack** in one undo step: - A group sent as a folder stays that folder, and a group sent as a layer stays that layer; their names, visibility, order and masks follow the document. An edited mask becomes a painted mask - (generators and filters it had are replaced by the result). A folder's changed blend mode or - opacity applies to all its channels; a layer group's changed opacity scales its channels'. + (generators and filters it had are replaced by the result). A folder's changed opacity + applies to all its channels (a blend mode other than pass-through only gets a note, since + folders always pass through); a layer group's changed opacity scales its channels'. - A channel pixel layer whose pixels changed becomes that channel's paint. A fill, instance or other procedural layer becomes a paint layer first, keeping its other channels as they rendered (its content effects are baked in). A changed blend mode or opacity applies to that channel. A removed channel layer turns the channel off. -- A new group becomes a folder (pass-through stays pass-through). A new pixel layer becomes a paint +- A new group becomes a pass-through folder with its opacity and mask. A new pixel layer becomes a paint layer of the same name, painted in the channel its name says: an id or label in any case and spacing (`Base Color`, `base_color 2`, `rough copy`) or a common name (`Albedo`, `Diffuse`, `Bump`, `Metalness`, `Gloss`, ...). Its transparency and own mask become its coverage. When the