From e0404360e4cf7f7cd1cd7a59ffcc364a27b20ae2 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Tue, 3 Nov 2026 22:42:10 +0100 Subject: [PATCH 01/39] 2D view: draw the brush outline under the pointer while painting Fixes #179 Co-Authored-By: Claude Sonnet 5.5 --- crates/ui-egui/src/viewport.rs | 30 ++++++++++++++++++ crates/ui-egui/tests/brush_cursor_2d.rs | 41 +++++++++++++++++++++++++ 2 files changed, 71 insertions(+) create mode 100644 crates/ui-egui/tests/brush_cursor_2d.rs diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs index a809c341..a0ab8bb9 100644 --- a/crates/ui-egui/src/viewport.rs +++ b/crates/ui-egui/src/viewport.rs @@ -1056,6 +1056,20 @@ fn view_2d(app: &mut TextureCraftApp, ui: &mut Ui, rect: Rect, sync: &mut Pendin painter.circle_stroke(hover, r, Stroke::new(1.0, Color32::from_white_alpha(200))); } } + // Brush cursor: the stamp's size and hardness at the pointer, as in the 3D view. + let cursor_mode = app.ui.mode == crate::state::Mode::Painting && !alt && !v_held; + if cursor_mode + && !path_tool + && brush_tool(app.session.tool.tool) + && !resp.dragged_by(PointerButton::Middle) + // While a Ctrl+drag changes the brush, its cursor stays where the drag began. + && let Some(hp) = if adjusting { ui.input(|i| i.pointer.press_origin()) } else { resp.hover_pos().or_else(|| resp.interact_pointer_pos()) } + { + // A UV brush stamp has a radius of twice the brush size, as in `continue_stroke_uv`. + let r = (to(app.session.tool.brush.size * 2.0, 0.0).x - to(0.0, 0.0).x).abs().max(1.5); + ui.ctx().set_cursor_icon(egui::CursorIcon::None); + brush_cursor_2d(&painter, hp, r, app.session.tool.brush.hardness); + } brush_readout(app, ui, &resp, adjusting); view_header(app, ui, rect, "v2d"); axis_gizmo(ui, rect, app, true); @@ -1064,6 +1078,22 @@ fn view_2d(app: &mut TextureCraftApp, ui: &mut Ui, rect: Rect, sync: &mut Pendin let _ = (RichText::new(""), Channel::BaseColor); } +/// The brush outline (and its hardness ring) as screen circles around `c`, radius `r` in points. +fn brush_cursor_2d(p: &egui::Painter, c: egui::Pos2, r: f32, hardness: f32) { + p.circle_stroke(c, r, Stroke::new(2.5, Color32::from_black_alpha(140))); + p.circle_stroke(c, r, Stroke::new(1.2, Color32::from_white_alpha(230))); + if hardness > 0.05 { + let inner: Vec = (0..=48) + .map(|k| { + let a = k as f32 / 48.0 * std::f32::consts::TAU; + c + vec2(a.cos(), a.sin()) * r * hardness + }) + .collect(); + p.add(egui::Shape::dashed_line(&inner, Stroke::new(1.0, Color32::from_white_alpha(120)), 3.0, 3.0)); + } + p.circle_filled(c, 1.5, Color32::WHITE); +} + /// Paint the skew map under the pointer in the 2D view (a click is one dab, a drag a stroke). fn skew_input(app: &mut TextureCraftApp, ui: &Ui, resp: &egui::Response, to_uv: &dyn Fn(egui::Pos2) -> Vec2) { let last = ui.scope_id().with("skew_last"); diff --git a/crates/ui-egui/tests/brush_cursor_2d.rs b/crates/ui-egui/tests/brush_cursor_2d.rs new file mode 100644 index 00000000..58cb4a8e --- /dev/null +++ b/crates/ui-egui/tests/brush_cursor_2d.rs @@ -0,0 +1,41 @@ +//! The 2D view hides the system pointer and draws the brush outline under it while painting. + +use egui::CursorIcon; +use egui_kittest::Harness; +use texturecraft_ui_egui::TextureCraftApp; +use texturecraft_ui_egui::state::{Mode, ViewLayout}; + +fn harness() -> Harness<'static, TextureCraftApp> { + let session = texturecraft_engine::sample_session(256, 64).unwrap(); + let mut h = Harness::builder().with_size(egui::vec2(1600.0, 960.0)).build_eframe(|cc| TextureCraftApp::new(cc, session)); + h.state_mut().ui.layout = ViewLayout::Only2D; + h.run_steps(4); + h +} + +fn cursor(h: &Harness<'_, TextureCraftApp>) -> CursorIcon { + h.output().platform_output.cursor_icon +} + +#[test] +fn painting_in_the_2d_view_replaces_the_pointer_with_the_brush_outline() { + let mut h = harness(); + let c = egui::pos2(800.0, 480.0); + h.hover_at(c); + h.run_steps(3); + assert_eq!(cursor(&h), CursorIcon::None, "the brush outline replaces the pointer"); + h.hover_at(egui::pos2(2.0, 2.0)); + h.run_steps(3); + assert_ne!(cursor(&h), CursorIcon::None, "outside the view the pointer is back"); +} + +#[test] +fn outside_painting_the_2d_view_keeps_the_normal_pointer() { + let mut h = harness(); + h.state_mut().ui.mode = Mode::Baking; + h.run_steps(3); + let c = egui::pos2(800.0, 480.0); + h.hover_at(c); + h.run_steps(3); + assert_ne!(cursor(&h), CursorIcon::None); +} From e59bf5569e86780b5bbc4f2efe9635075b56f9ee Mon Sep 17 00:00:00 2001 From: vangel76 Date: Tue, 3 Nov 2026 23:36:50 +0100 Subject: [PATCH 02/39] Add an offset to mesh-map generators The generator panel had level, softness and noise but no way to lift or lower the finished mask. The new offset is added to the result and clamped to 0..1. The thresholding now lives in Generator::shape, shared by the compositor and the preview. Co-Authored-By: Claude Sonnet 5.5 --- crates/compose/src/eval.rs | 6 +----- crates/core/src/layer.rs | 29 ++++++++++++++++++++++++++++- crates/engine/src/inspect.rs | 2 +- crates/engine/src/mask_cmds.rs | 7 +++++-- crates/engine/src/preview.rs | 5 +---- crates/engine/tests/session.rs | 26 ++++++++++++++++++++++++++ crates/ui-egui/src/dock.rs | 10 +++++++--- 7 files changed, 69 insertions(+), 16 deletions(-) diff --git a/crates/compose/src/eval.rs b/crates/compose/src/eval.rs index de26d5bd..d2f6d2ce 100644 --- a/crates/compose/src/eval.rs +++ b/crates/compose/src/eval.rs @@ -1122,11 +1122,7 @@ impl<'a, 'b> Texel<'a, 'b> { GeneratorKind::Direction => c.nrm.dot(Vec3::from(g.direction).try_normalize().unwrap_or(Vec3::Y)) * 0.5 + 0.5, }; let s = if g.noise_amount > 0.0 { s + (world_noise(c.pos, g.noise_scale, g.seed) - 0.5) * g.noise_amount } else { s }; - let th = 1.0 - g.level.clamp(0.0, 1.0); - let soft = g.softness.max(1e-3); - let t = ((s - (th - soft)) / (2.0 * soft)).clamp(0.0, 1.0); - let v = t * t * (3.0 - 2.0 * t); - if g.invert { 1.0 - v } else { v } + g.shape(s) } fn mask(&mut self, m: &MaskPlan) -> f32 { diff --git a/crates/core/src/layer.rs b/crates/core/src/layer.rs index 551c9803..d1adcde0 100644 --- a/crates/core/src/layer.rs +++ b/crates/core/src/layer.rs @@ -537,6 +537,9 @@ pub struct Generator { pub noise_amount: f32, pub noise_scale: f32, pub seed: u32, + /// Added to the finished mask value and clamped to 0..1 (−1..1; 0 = unchanged). + #[serde(default)] + pub offset: f32, /// Direction for `Position` / `Direction` generators (world space). pub direction: [f32; 3], pub invert: bool, @@ -550,7 +553,18 @@ impl Generator { GeneratorKind::ThinAreas => (0.3, 0.2, 0.0), _ => (0.5, 0.25, 0.0), }; - Generator { kind, level, softness, noise_amount, noise_scale: 8.0, seed: 7, direction: [0.0, 1.0, 0.0], invert: false } + Generator { kind, level, softness, noise_amount, noise_scale: 8.0, seed: 7, offset: 0.0, direction: [0.0, 1.0, 0.0], invert: false } + } + + /// The mask value for a (noise-broken) signal `s`: the smooth threshold at `level` over + /// `softness`, inverted if asked, then shifted by `offset`. + pub fn shape(&self, s: f32) -> f32 { + let th = 1.0 - self.level.clamp(0.0, 1.0); + let soft = self.softness.max(1e-3); + let t = ((s - (th - soft)) / (2.0 * soft)).clamp(0.0, 1.0); + let v = t * t * (3.0 - 2.0 * t); + let v = if self.invert { 1.0 - v } else { v }; + (v + self.offset).clamp(0.0, 1.0) } } @@ -1050,6 +1064,19 @@ impl Effect { mod tests { use super::*; + #[test] + fn generator_offset_shifts_the_mask_value() { + let mut g = Generator::new(GeneratorKind::Position); + let base = g.shape(0.2); + assert!(base < 0.5); + g.offset = 0.3; + assert!((g.shape(0.2) - (base + 0.3)).abs() < 1e-6, "the offset is added"); + g.offset = 1.0; + assert_eq!(g.shape(0.2), 1.0, "and the result is clamped"); + g.offset = -1.0; + assert_eq!(g.shape(0.9), 0.0); + } + #[test] fn levels_map_range_and_gamma() { let l = Levels { in_low: 0.2, in_high: 0.6, gamma: 1.0, out_low: 0.0, out_high: 1.0 }; diff --git a/crates/engine/src/inspect.rs b/crates/engine/src/inspect.rs index 228d37e1..cbd31942 100644 --- a/crates/engine/src/inspect.rs +++ b/crates/engine/src/inspect.rs @@ -38,7 +38,7 @@ fn effect_json(s: &Session, e: &Effect, content: bool) -> Value { let mut ej = json!({ "id": e.id.0, "name": e.name, "kind": e.kind.name(), "visible": e.visible, "blend": e.blend.label(), "opacity": e.opacity }); match &e.kind { EffectKind::Generator(g) => { - ej["generator"] = json!({ "type": format!("{:?}", g.kind), "level": g.level, "softness": g.softness, "noise": g.noise_amount, "invert": g.invert }) + ej["generator"] = json!({ "type": format!("{:?}", g.kind), "level": g.level, "softness": g.softness, "noise": g.noise_amount, "offset": g.offset, "invert": g.invert }) } EffectKind::Levels(lv) => ej["levels"] = json!([lv.in_low, lv.in_high, lv.gamma, lv.out_low, lv.out_high]), EffectKind::Path(paths) => { diff --git a/crates/engine/src/mask_cmds.rs b/crates/engine/src/mask_cmds.rs index 2656bd15..315e90c4 100644 --- a/crates/engine/src/mask_cmds.rs +++ b/crates/engine/src/mask_cmds.rs @@ -49,7 +49,7 @@ pub fn specs() -> Vec { "Add generator", ["Layers", "Effects"], None, - "{layer?, name?, generator?: edgeWear|dirt|thinAreas|curvature|ambientOcclusion|position|direction, level?, softness?, noise?, invert?}", + "{layer?, name?, generator?: edgeWear|dirt|thinAreas|curvature|ambientOcclusion|position|direction, level?, softness?, noise?, offset?: -1..1 added to the result, invert?}", has_layer, add_generator ), @@ -94,7 +94,7 @@ pub fn specs() -> Vec { "Edit effect", [], None, - "{effect, visible?, blend?, opacity?, name?, level?, softness?, noise?, noiseScale?, invert?, value?, anchor?, anchorChannel?, inLow?, inHigh?, gamma?, outLow?, outHigh?, tolerance?, filter parameters (see effect.add.filter)}", + "{effect, visible?, blend?, opacity?, name?, level?, softness?, noise?, noiseScale?, offset?, invert?, value?, anchor?, anchorChannel?, inLow?, inHigh?, gamma?, outLow?, outHigh?, tolerance?, filter parameters (see effect.add.filter)}", has_layer, set ), @@ -324,6 +324,9 @@ fn generator_from(p: &Value, g: &mut Generator) { if let Some(v) = f32p(p, "noise") { g.noise_amount = v.clamp(0.0, 2.0); } + if let Some(v) = f32p(p, "offset") { + g.offset = v.clamp(-1.0, 1.0); + } if let Some(v) = f32p(p, "noiseScale") { g.noise_scale = v.clamp(0.01, 1000.0); } diff --git a/crates/engine/src/preview.rs b/crates/engine/src/preview.rs index 3c3aa130..170989b6 100644 --- a/crates/engine/src/preview.rs +++ b/crates/engine/src/preview.rs @@ -63,10 +63,7 @@ fn generator(g: &Generator, c: &Coords) -> f32 { }; // Same thresholding as the compositor. let s = if g.noise_amount > 0.0 { s + (world_noise(c.pos, g.noise_scale, g.seed) - 0.5) * g.noise_amount } else { s }; - let soft = g.softness.max(1e-3); - let t = ((s - (1.0 - g.level.clamp(0.0, 1.0) - soft)) / (2.0 * soft)).clamp(0.0, 1.0); - let v = t * t * (3.0 - 2.0 * t); - if g.invert { 1.0 - v } else { v } + g.shape(s) } fn mask(m: &Mask, c: &Coords) -> f32 { diff --git a/crates/engine/tests/session.rs b/crates/engine/tests/session.rs index 02be7a8d..af1dbc6a 100644 --- a/crates/engine/tests/session.rs +++ b/crates/engine/tests/session.rs @@ -54,6 +54,32 @@ fn layers_masks_materials_and_bake() { assert_eq!(s.doc.project.walk(0).len(), 1, "back to the initial paint layer"); } +#[test] +fn generator_offset_is_settable_and_clamped() { + let mut s = session(); + execute(&mut s, "layer.add.fill", &json!({})).unwrap(); + execute(&mut s, "mask.add.black", &Value::Null).unwrap(); + let r = execute(&mut s, "effect.add.generator", &json!({"generator": "position", "offset": 0.25})).unwrap(); + let eff = r["effect"].as_u64().unwrap(); + let offset = |s: &Session| { + let layer = s.doc.project.layers.values().find(|l| l.mask.is_some()).unwrap(); + layer + .mask + .as_ref() + .unwrap() + .effects + .iter() + .find_map(|e| match &e.kind { + texturecraft_engine::core::EffectKind::Generator(g) => Some(g.offset), + _ => None, + }) + .unwrap() + }; + assert_eq!(offset(&s), 0.25); + execute(&mut s, "effect.set", &json!({"effect": eff, "offset": 5.0})).unwrap(); + assert_eq!(offset(&s), 1.0, "clamped to 1"); +} + #[test] fn layer_rename_and_undo() { let mut s = session(); diff --git a/crates/ui-egui/src/dock.rs b/crates/ui-egui/src/dock.rs index 471f164d..7bfe926a 100644 --- a/crates/ui-egui/src/dock.rs +++ b/crates/ui-egui/src/dock.rs @@ -1875,15 +1875,19 @@ fn effect_properties(app: &mut TextureCraftApp, ui: &mut Ui, layer: &Layer, eid: } } }); - let (mut level, mut soft, mut noise, mut ns) = (g.level, g.softness, g.noise_amount, g.noise_scale); + let (mut level, mut soft, mut noise, mut ns, mut off) = (g.level, g.softness, g.noise_amount, g.noise_scale, g.offset); let r1 = slider_edit(ui, tr("Level"), &mut level, 0.0..=1.0, 2); let r2 = slider_edit(ui, tr("Softness"), &mut soft, 0.0..=1.0, 2); let r3 = slider_edit(ui, tr("Noise amount"), &mut noise, 0.0..=2.0, 2); let r4 = slider_edit(ui, tr("Noise scale"), &mut ns, 0.1..=64.0, 1); + let r6 = slider_edit(ui, tr("Offset"), &mut off, -1.0..=1.0, 2); let mut inv = g.invert; let r5 = ui.checkbox(&mut inv, tr("Invert")); - 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 let Some(merge) = r1.or(r2).or(r3).or(r4).or(r6).or(r5.changed().then_some(false)) { + app.run( + "effect.set", + json!({"effect": id, "level": level, "softness": soft, "noise": noise, "noiseScale": ns, "offset": off, "invert": inv, "merge": merge}), + ); } if !app.session.doc.baked.contains_key(&app.session.ts()) { ui.label( From 9c570137f7b5557559c3d64c612ac068e2a98b47 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sat, 7 Nov 2026 15:37:56 +0100 Subject: [PATCH 03/39] Keep the pointer over the 2D view header and size the brush outline by pen pressure The brush cursor in the 2D view hid the system pointer and drew the outline over the view header pickers. Its radius also ignored pen pressure, while painting shrinks the stamp towards min_size. Both now follow the painted footprint (BrushSettings::uv_stamp_radius, shared with continue_stroke_uv), with regression tests for header hover and partial pressure. Co-Authored-By: Claude Sonnet 5.5 --- crates/engine/src/painting.rs | 3 +- crates/paint/src/brush.rs | 16 +++++++ crates/ui-egui/src/viewport.rs | 20 +++++---- crates/ui-egui/tests/brush_cursor_2d.rs | 59 ++++++++++++++++++++++++- 4 files changed, 87 insertions(+), 11 deletions(-) diff --git a/crates/engine/src/painting.rs b/crates/engine/src/painting.rs index 6f2a74ff..388758b9 100644 --- a/crates/engine/src/painting.rs +++ b/crates/engine/src/painting.rs @@ -318,8 +318,7 @@ impl Session { let Some((last, carry)) = st.uv.as_mut() else { return }; let Some(cache) = self.caches.get_mut(st.ts) else { return }; let b = &st.stroke.settings; - let p = pressure.clamp(0.0, 1.0); - let radius = b.size * 2.0 * if p < 1.0 { b.min_size + (1.0 - b.min_size) * p } else { 1.0 }; + let radius = b.uv_stamp_radius(pressure); let step = (b.spacing * 2.0 * radius).max(1e-5); let mut points = Vec::new(); match *last { diff --git a/crates/paint/src/brush.rs b/crates/paint/src/brush.rs index 61313d57..45c9ed30 100644 --- a/crates/paint/src/brush.rs +++ b/crates/paint/src/brush.rs @@ -291,6 +291,13 @@ impl Default for BrushSettings { } impl BrushSettings { + /// Radius of a 2D (UV) stamp as a fraction of the UV square, for pen `pressure` 0..1: twice the + /// brush size, shrunk towards `min_size` by a light pen. Painting and the 2D cursor share it. + pub fn uv_stamp_radius(&self, pressure: f32) -> f32 { + let p = pressure.clamp(0.0, 1.0); + self.size * 2.0 * if p < 1.0 { self.min_size + (1.0 - self.min_size) * p } else { 1.0 } + } + /// Clamp every value into its valid range (input from UI, CLI or agents). pub fn sanitized(&self) -> BrushSettings { let f = |v: f32, lo: f32, hi: f32, d: f32| if v.is_finite() { v.clamp(lo, hi) } else { d }; @@ -323,6 +330,15 @@ impl BrushSettings { #[cfg(test)] mod tests { + #[test] + fn uv_stamp_radius_follows_pen_pressure() { + let b = BrushSettings { size: 0.1, min_size: 0.5, ..BrushSettings::default() }; + assert!((b.uv_stamp_radius(1.0) - 0.2).abs() < 1e-6); + assert!((b.uv_stamp_radius(0.5) - 0.15).abs() < 1e-6); + assert!((b.uv_stamp_radius(0.0) - 0.1).abs() < 1e-6); + assert!((b.uv_stamp_radius(7.0) - 0.2).abs() < 1e-6, "pressure clamps to 1"); + } + use super::*; #[test] diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs index 24ed251c..213dc8f0 100644 --- a/crates/ui-egui/src/viewport.rs +++ b/crates/ui-egui/src/viewport.rs @@ -332,14 +332,16 @@ const VIEW_HEADER_TOP_GAP: f32 = 8.0; /// Width of each of the two pickers const VIEW_PICKER_WIDTH: f32 = 130.0; +/// Where `view_header` draws its pickers in a view of `rect`; `None` when the view is too narrow. +fn view_header_rect(rect: Rect) -> Option { + (rect.width() >= VIEW_HEADER_WIDTH).then(|| { + Rect::from_min_size(rect.min + vec2((rect.width() - VIEW_HEADER_WIDTH) * 0.5, VIEW_HEADER_TOP_GAP), vec2(VIEW_HEADER_WIDTH, VIEW_HEADER_HEIGHT)) + }) +} + /// The camera and view pickers at the top of a view, left out when the view is too narrow to hold them fn view_header(app: &mut TextureCraftApp, ui: &mut Ui, rect: Rect, id: &str) { - if rect.width() < VIEW_HEADER_WIDTH { - return; - } - - let header_min = rect.min + vec2((rect.width() - VIEW_HEADER_WIDTH) * 0.5, VIEW_HEADER_TOP_GAP); - let header = Rect::from_min_size(header_min, vec2(VIEW_HEADER_WIDTH, VIEW_HEADER_HEIGHT)); + let Some(header) = view_header_rect(rect) else { return }; let mut child = ui.new_child(egui::UiBuilder::new().max_rect(header).layout(egui::Layout::left_to_right(egui::Align::Center))); let current = texturecraft_engine::camera_cmds::current(&app.session); @@ -1300,9 +1302,11 @@ fn view_2d(app: &mut TextureCraftApp, ui: &mut Ui, rect: Rect, sync: &mut Pendin && !response.dragged_by(PointerButton::Middle) // While a Ctrl+drag changes the brush, its cursor stays where the drag began. && let Some(hp) = if adjusting { ui.input(|i| i.pointer.press_origin()) } else { response.hover_pos().or_else(|| response.interact_pointer_pos()) } + // The view header's pickers keep the normal pointer. + && !view_header_rect(rect).is_some_and(|header| header.expand(2.0).contains(hp)) { - // A UV brush stamp has a radius of twice the brush size, as in `continue_stroke_uv`. - let r = (to_screen(app.session.tool.brush.size * 2.0, 0.0).x - to_screen(0.0, 0.0).x).abs().max(1.5); + // The stamp's radius as `continue_stroke_uv` paints it, including a light pen's smaller footprint. + let r = (to_screen(app.session.tool.brush.uv_stamp_radius(pen_pressure(ui)), 0.0).x - to_screen(0.0, 0.0).x).abs().max(1.5); ui.ctx().set_cursor_icon(egui::CursorIcon::None); brush_cursor_2d(&painter, hp, r, app.session.tool.brush.hardness); } diff --git a/crates/ui-egui/tests/brush_cursor_2d.rs b/crates/ui-egui/tests/brush_cursor_2d.rs index 58cb4a8e..d205c541 100644 --- a/crates/ui-egui/tests/brush_cursor_2d.rs +++ b/crates/ui-egui/tests/brush_cursor_2d.rs @@ -1,6 +1,6 @@ //! The 2D view hides the system pointer and draws the brush outline under it while painting. -use egui::CursorIcon; +use egui::{CursorIcon, Event, Pos2, Shape, TouchDeviceId, TouchId, TouchPhase}; use egui_kittest::Harness; use texturecraft_ui_egui::TextureCraftApp; use texturecraft_ui_egui::state::{Mode, ViewLayout}; @@ -39,3 +39,60 @@ fn outside_painting_the_2d_view_keeps_the_normal_pointer() { h.run_steps(3); assert_ne!(cursor(&h), CursorIcon::None); } + +/// Radii of the white brush-outline rings (stroke 1.2) around `c` in the last frame. +fn rings_at(h: &Harness<'_, TextureCraftApp>, c: Pos2) -> Vec { + fn walk(shape: &Shape, c: Pos2, out: &mut Vec) { + match shape { + Shape::Vec(shapes) => shapes.iter().for_each(|s| walk(s, c, out)), + Shape::Circle(circle) if (circle.stroke.width - 1.2).abs() < 1e-3 && circle.center.distance(c) < 0.5 => out.push(circle.radius), + _ => {} + } + } + let mut out = Vec::new(); + h.output().shapes.iter().for_each(|clipped| walk(&clipped.shape, c, &mut out)); + out +} + +#[test] +fn the_view_header_keeps_the_normal_pointer_and_gets_no_brush_outline() { + let mut h = harness(); + // The view's top edge is where the brush outline first replaces the pointer; the header is + // centred 8 points below it and 22 high. + let view_top = (0..200).map(|y| y as f32).find(|&y| { + h.hover_at(egui::pos2(300.0, y)); + h.run_steps(2); + cursor(&h) == CursorIcon::None + }); + let top = view_top.expect("the view has a top edge"); + let header = egui::pos2(800.0, top + 8.0 + 11.0); + h.hover_at(header); + h.run_steps(3); + assert_ne!(cursor(&h), CursorIcon::None, "over the pickers the pointer stays"); + assert!(rings_at(&h, header).is_empty(), "no brush outline over the pickers"); + let below = egui::pos2(800.0, top + 120.0); + h.hover_at(below); + h.run_steps(3); + assert_eq!(cursor(&h), CursorIcon::None, "below the header the brush outline is back"); + assert!(!rings_at(&h, below).is_empty()); +} + +#[test] +fn a_light_pen_shows_the_smaller_footprint_it_paints() { + let mut h = harness(); + h.state_mut().session.tool.brush.size = 0.05; + h.state_mut().session.tool.brush.min_size = 0.5; + let c = egui::pos2(800.0, 600.0); + h.hover_at(c); + h.run_steps(3); + let full = rings_at(&h, c); + assert_eq!(full.len(), 1, "one outline at full pressure"); + // A pen sample at half pressure: stamp radius is min + (1 - min) * p = 0.75 of full. + let events = &mut h.input_mut().events; + events.push(Event::Touch { device_id: TouchDeviceId(1), id: TouchId(1), phase: TouchPhase::Move, pos: c, force: Some(0.5) }); + events.push(Event::PointerMoved(c)); + h.step(); + let light = rings_at(&h, c); + assert_eq!(light.len(), 1); + assert!((light[0] / full[0] - 0.75).abs() < 1e-3, "half pressure shows 0.75 of the radius: {} vs {}", light[0], full[0]); +} From 8d902bea6fe28a607be989064373aba6ff0de146 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sat, 7 Nov 2026 16:54:02 +0100 Subject: [PATCH 04/39] Hide the system pointer only while it is over the 2D view Co-Authored-By: Claude Sonnet 5.5 --- crates/ui-egui/src/viewport.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs index 213dc8f0..2443e182 100644 --- a/crates/ui-egui/src/viewport.rs +++ b/crates/ui-egui/src/viewport.rs @@ -1300,6 +1300,9 @@ fn view_2d(app: &mut TextureCraftApp, ui: &mut Ui, rect: Rect, sync: &mut Pendin && !path_tool && brush_tool(app.session.tool.tool) && !response.dragged_by(PointerButton::Middle) + // During a drag egui keeps reporting a hover position after the pointer left the view: + // the system pointer is hidden only while the pointer is really over it. + && ui.input(|i| i.pointer.latest_pos()).is_some_and(|p| rect.contains(p)) // While a Ctrl+drag changes the brush, its cursor stays where the drag began. && let Some(hp) = if adjusting { ui.input(|i| i.pointer.press_origin()) } else { response.hover_pos().or_else(|| response.interact_pointer_pos()) } // The view header's pickers keep the normal pointer. From 3f13752155c4f45f305b66483185410956c6347b Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sun, 8 Nov 2026 00:54:31 +0100 Subject: [PATCH 05/39] Test that the generator offset survives save and reopen and undoes Co-Authored-By: Claude Sonnet 5.5 --- crates/engine/tests/session.rs | 36 ++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/crates/engine/tests/session.rs b/crates/engine/tests/session.rs index af1dbc6a..e73b7a47 100644 --- a/crates/engine/tests/session.rs +++ b/crates/engine/tests/session.rs @@ -80,6 +80,42 @@ fn generator_offset_is_settable_and_clamped() { assert_eq!(offset(&s), 1.0, "clamped to 1"); } +fn generator_offset_of(s: &Session) -> f32 { + let layer = s.doc.project.layers.values().find(|l| l.mask.is_some()).unwrap(); + layer + .mask + .as_ref() + .unwrap() + .effects + .iter() + .find_map(|e| match &e.kind { + texturecraft_engine::core::EffectKind::Generator(g) => Some(g.offset), + _ => None, + }) + .unwrap() +} + +#[test] +fn generator_offset_survives_save_and_reopen_and_undo_restores_it() { + let mut s = session(); + execute(&mut s, "layer.add.fill", &json!({})).unwrap(); + execute(&mut s, "mask.add.black", &Value::Null).unwrap(); + let r = execute(&mut s, "effect.add.generator", &json!({"generator": "position", "offset": 0.25})).unwrap(); + let eff = r["effect"].as_u64().unwrap(); + execute(&mut s, "effect.set", &json!({"effect": eff, "offset": -0.6})).unwrap(); + assert_eq!(generator_offset_of(&s), -0.6); + + let path = std::env::temp_dir().join(format!("tc-generator-offset-{}.tcraft", std::process::id())); + let path = path.to_str().unwrap(); + execute(&mut s, "file.saveCopy", &json!({"path": path})).unwrap(); + let reopened = texturecraft_engine::file_cmds::open_path(path); + let _ = std::fs::remove_file(path); + assert_eq!(generator_offset_of(&reopened.unwrap()), -0.6, "the offset is saved and read back"); + + execute(&mut s, "edit.undo", &Value::Null).unwrap(); + assert_eq!(generator_offset_of(&s), 0.25, "undo restores the previous offset"); +} + #[test] fn layer_rename_and_undo() { let mut s = session(); From d0967df09eacb8fe6737e5b538c0de3f5a9bcebe Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sun, 8 Nov 2026 00:54:33 +0100 Subject: [PATCH 06/39] Test that the system pointer returns when a drag leaves the 2D view Co-Authored-By: Claude Sonnet 5.5 --- crates/ui-egui/tests/brush_cursor_2d.rs | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/crates/ui-egui/tests/brush_cursor_2d.rs b/crates/ui-egui/tests/brush_cursor_2d.rs index d205c541..3b7cca9c 100644 --- a/crates/ui-egui/tests/brush_cursor_2d.rs +++ b/crates/ui-egui/tests/brush_cursor_2d.rs @@ -96,3 +96,23 @@ fn a_light_pen_shows_the_smaller_footprint_it_paints() { assert_eq!(light.len(), 1); assert!((light[0] / full[0] - 0.75).abs() < 1e-3, "half pressure shows 0.75 of the radius: {} vs {}", light[0], full[0]); } + +#[test] +fn dragging_out_of_the_2d_view_brings_the_system_pointer_back() { + let mut h = harness(); + let c = egui::pos2(800.0, 480.0); + h.hover_at(c); + h.run_steps(3); + assert_eq!(cursor(&h), CursorIcon::None, "inside the view the brush outline replaces the pointer"); + // Press inside the view, then carry the pointer out of the view (top-left corner) with the button held. + h.event(Event::PointerButton { pos: c, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() }); + h.run_steps(2); + assert_eq!(cursor(&h), CursorIcon::None, "still inside while dragging"); + let outside = egui::pos2(2.0, 2.0); + h.hover_at(outside); + h.run_steps(3); + assert_ne!(cursor(&h), CursorIcon::None, "outside the view the pointer is visible even during a drag"); + assert!(rings_at(&h, outside).is_empty(), "no brush outline outside the view"); + h.event(Event::PointerButton { pos: outside, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() }); + h.run_steps(2); +} From c3a59ed421996439db27424de589989a6d91c784 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sun, 8 Nov 2026 01:40:50 +0100 Subject: [PATCH 07/39] Keep the anchored brush outline when a Ctrl+right drag leaves the 2D view The outline is drawn at the press origin for the whole adjustment drag; only the system-pointer hiding depends on the pointer being in the view. Co-Authored-By: Claude Sonnet 5.5 --- crates/ui-egui/src/viewport.rs | 14 ++++++++++---- crates/ui-egui/tests/brush_cursor_2d.rs | 25 +++++++++++++++++++++++++ 2 files changed, 35 insertions(+), 4 deletions(-) diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs index 2443e182..9c7c8808 100644 --- a/crates/ui-egui/src/viewport.rs +++ b/crates/ui-egui/src/viewport.rs @@ -1054,7 +1054,9 @@ fn brush_readout(app: &TextureCraftApp, ui: &Ui, resp: &egui::Response, adjustin let Some(right) = brush_drag_button(resp).filter(|_| adjusting) else { return }; let Some(at) = ui.input(|i| i.pointer.press_origin()) else { return }; // The pointer would cover the values; the brush cursor stays where the drag began. - ui.ctx().set_cursor_icon(egui::CursorIcon::None); + if ui.input(|i| i.pointer.latest_pos()).is_some_and(|p| resp.rect.contains(p)) { + ui.ctx().set_cursor_icon(egui::CursorIcon::None); + } let b = &app.session.tool.brush; let text = if right { format!("{} {:.1} {} {:.0}", tr("Size"), b.size / 0.25 * 100.0, tr("Hardness"), b.hardness * 100.0) @@ -1296,13 +1298,15 @@ fn view_2d(app: &mut TextureCraftApp, ui: &mut Ui, rect: Rect, sync: &mut Pendin } // Brush cursor: the stamp's size and hardness at the pointer, as in the 3D view. let cursor_mode = app.ui.mode == crate::state::Mode::Painting && !alt && !v_held; + let pointer_in_view = ui.input(|i| i.pointer.latest_pos()).is_some_and(|p| rect.contains(p)); if cursor_mode && !path_tool && brush_tool(app.session.tool.tool) && !response.dragged_by(PointerButton::Middle) // During a drag egui keeps reporting a hover position after the pointer left the view: - // the system pointer is hidden only while the pointer is really over it. - && ui.input(|i| i.pointer.latest_pos()).is_some_and(|p| rect.contains(p)) + // the system pointer is hidden only while the pointer is really over it. A Ctrl+drag that + // changes the brush keeps its outline at the press origin wherever the pointer goes. + && (adjusting || pointer_in_view) // While a Ctrl+drag changes the brush, its cursor stays where the drag began. && let Some(hp) = if adjusting { ui.input(|i| i.pointer.press_origin()) } else { response.hover_pos().or_else(|| response.interact_pointer_pos()) } // The view header's pickers keep the normal pointer. @@ -1310,7 +1314,9 @@ fn view_2d(app: &mut TextureCraftApp, ui: &mut Ui, rect: Rect, sync: &mut Pendin { // The stamp's radius as `continue_stroke_uv` paints it, including a light pen's smaller footprint. let r = (to_screen(app.session.tool.brush.uv_stamp_radius(pen_pressure(ui)), 0.0).x - to_screen(0.0, 0.0).x).abs().max(1.5); - ui.ctx().set_cursor_icon(egui::CursorIcon::None); + if pointer_in_view { + ui.ctx().set_cursor_icon(egui::CursorIcon::None); + } brush_cursor_2d(&painter, hp, r, app.session.tool.brush.hardness); } brush_readout(app, ui, &response, adjusting); diff --git a/crates/ui-egui/tests/brush_cursor_2d.rs b/crates/ui-egui/tests/brush_cursor_2d.rs index 3b7cca9c..8f790099 100644 --- a/crates/ui-egui/tests/brush_cursor_2d.rs +++ b/crates/ui-egui/tests/brush_cursor_2d.rs @@ -116,3 +116,28 @@ fn dragging_out_of_the_2d_view_brings_the_system_pointer_back() { h.event(Event::PointerButton { pos: outside, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() }); h.run_steps(2); } + +#[test] +fn a_ctrl_right_drag_out_of_the_2d_view_keeps_its_outline_at_the_anchor() { + let mut h = harness(); + let c = egui::pos2(800.0, 480.0); + let ctrl = egui::Modifiers::COMMAND; + h.hover_at(c); + h.run_steps(2); + h.event(Event::ModifiersChanged(ctrl)); + h.event(Event::PointerButton { pos: c, button: egui::PointerButton::Secondary, pressed: true, modifiers: ctrl }); + h.run_steps(2); + // Drag a little inside the view: the outline is anchored and the pointer hidden. + h.hover_at(c + egui::vec2(10.0, 0.0)); + h.run_steps(3); + assert_eq!(rings_at(&h, c).len(), 1, "anchored outline while the pointer is in the view"); + assert_eq!(cursor(&h), CursorIcon::None); + // Carry the pointer out of the view: the outline stays at the anchor, the system pointer is back. + h.hover_at(egui::pos2(2.0, 2.0)); + h.run_steps(3); + assert_eq!(rings_at(&h, c).len(), 1, "the outline stays at the press origin outside the view"); + assert_ne!(cursor(&h), CursorIcon::None, "outside the view the pointer is visible"); + h.event(Event::PointerButton { pos: egui::pos2(2.0, 2.0), button: egui::PointerButton::Secondary, pressed: false, modifiers: ctrl }); + h.event(Event::ModifiersChanged(egui::Modifiers::NONE)); + h.run_steps(2); +} From 21856d778347e13857f65c8f1107170797bd070f Mon Sep 17 00:00:00 2001 From: test-bit-sys Date: Wed, 11 Nov 2026 08:57:31 +0100 Subject: [PATCH 08/39] fix(formats): preserve existing OBJ UVs when only some objects lack UVs (#286) (#394) Previously, if any object in an OBJ mesh lacked texture coordinates, all UVs across all objects were discarded and replaced with a full automatic unwrap. Skip empty models without indices, preserve existing UVs on textured objects while assigning default UVs to untextured helper/sub-objects, and report a warning without forcing a full mesh unwrap. --- crates/formats/src/mesh_import/obj.rs | 20 ++++++++++-------- crates/formats/src/mesh_import/tests.rs | 27 +++++++++++++++++++++++++ 2 files changed, 39 insertions(+), 8 deletions(-) diff --git a/crates/formats/src/mesh_import/obj.rs b/crates/formats/src/mesh_import/obj.rs index 44277208..2f284704 100644 --- a/crates/formats/src/mesh_import/obj.rs +++ b/crates/formats/src/mesh_import/obj.rs @@ -36,10 +36,14 @@ fn read_inner(bytes: &[u8]) -> Result { let materials = materials.unwrap_or_default(); let mut raw = RawMesh::default(); - let (mut normals, mut uvs, mut colors) = (Some(Vec::new()), Some(Vec::new()), Vec::new()); + let any_uvs = models.iter().any(|m| !m.mesh.indices.is_empty() && m.mesh.texcoords.len() == (m.mesh.positions.len() / 3) * 2); + let (mut normals, mut uvs, mut colors) = (Some(Vec::new()), any_uvs.then(Vec::new), Vec::new()); let mut partial_uvs = false; for model in &models { let mesh = &model.mesh; + if mesh.indices.is_empty() { + continue; + } let vertex_count = mesh.positions.len() / 3; check_vertices(raw.positions.len().saturating_add(vertex_count))?; @@ -56,14 +60,14 @@ fn read_inner(bytes: &[u8]) -> Result { } else { normals = None; } - if mesh.texcoords.len() == vertex_count * 2 { - if let Some(v) = &mut uvs { + if let Some(v) = &mut uvs { + if mesh.texcoords.len() == vertex_count * 2 { // OBJ UVs have their origin bottom-left v.extend(mesh.texcoords.as_chunks::<2>().0.iter().map(|t| Vec2::new(t[0], 1.0 - t[1]))); + } else { + v.extend(std::iter::repeat_n(Vec2::ZERO, vertex_count)); + partial_uvs = true; } - } else { - partial_uvs |= vertex_count > 0 && !mesh.indices.is_empty(); - uvs = None; } // `v x y z r g b`: objects without colors are white @@ -94,8 +98,8 @@ fn read_inner(bytes: &[u8]) -> Result { } } - if partial_uvs && models.iter().any(|model| !model.mesh.texcoords.is_empty()) { - raw.warnings.push("some objects have no UVs; the whole mesh was unwrapped automatically".into()); + if partial_uvs { + raw.warnings.push("some objects have no UVs; default UVs were assigned".into()); } raw.normals = normals; diff --git a/crates/formats/src/mesh_import/tests.rs b/crates/formats/src/mesh_import/tests.rs index fd45cc87..e55f8eae 100644 --- a/crates/formats/src/mesh_import/tests.rs +++ b/crates/formats/src/mesh_import/tests.rs @@ -235,6 +235,33 @@ fn obj_without_uvs_or_normals_is_completed() { assert!(n0.len() > 1 && n0.iter().all(|n| (*n - n0[0]).length() < 1e-5)); } +#[test] +fn obj_with_some_objects_having_uvs_preserves_uvs_without_full_unwrap() { + let obj = "o Body +v 0 0 0 +v 1 0 0 +v 1 1 0 +vt 0 0 +vt 1 0 +vt 1 1 +f 1/1 2/2 3/3 +o Helper +v 2 0 0 +v 3 0 0 +v 3 1 0 +f 4 5 6 +"; + let im = import_mesh_bytes("character.obj", obj.as_bytes()).unwrap(); + assert!(!im.report.uvs_generated); + assert_eq!(im.mesh.uvs[0], Vec2::new(0.0, 1.0)); + assert_eq!(im.mesh.uvs[1], Vec2::new(1.0, 1.0)); + assert_eq!(im.mesh.uvs[2], Vec2::new(1.0, 0.0)); + assert_eq!(im.mesh.uvs[3], Vec2::ZERO); + assert_eq!(im.mesh.uvs[4], Vec2::ZERO); + assert_eq!(im.mesh.uvs[5], Vec2::ZERO); + assert!(im.report.warnings.iter().any(|w| w.contains("some objects have no UVs"))); +} + #[test] fn polygons_keep_their_edges_for_the_wireframe() { // An OBJ quad and pentagon (with UVs, so no unwrap splits them), a triangle, and a PLY quad. From 42c1e51b982a4fb01d0bd59cf88616fb03355d32 Mon Sep 17 00:00:00 2001 From: Morion Date: Wed, 11 Nov 2026 09:39:33 -0500 Subject: [PATCH 09/39] Migrate TextureCraft UI translations to shared craft-i18n --- Cargo.lock | 1 + Cargo.toml | 2 + craft-i18n.rev | 1 + crates/ui-egui/Cargo.toml | 1 + crates/ui-egui/build.rs | 3 + crates/ui-egui/i18n_build.rs | 76 ++ crates/ui-egui/src/i18n.rs | 180 ++-- crates/ui-egui/src/i18n/ar.rs | 1135 ------------------------ crates/ui-egui/src/i18n/de.rs | 1181 ------------------------- crates/ui-egui/src/i18n/es.rs | 1172 ------------------------- crates/ui-egui/src/i18n/fr.rs | 1196 -------------------------- crates/ui-egui/src/i18n/it.rs | 1178 ------------------------- crates/ui-egui/src/i18n/ja.rs | 1163 ------------------------- crates/ui-egui/src/i18n/ko.rs | 1148 ------------------------ crates/ui-egui/src/i18n/pt_br.rs | 1166 ------------------------- crates/ui-egui/src/i18n/zh_hans.rs | 1091 ----------------------- crates/ui-egui/src/windows.rs | 4 +- crates/ui-egui/tests/i18n_build.rs | 78 ++ crates/ui-egui/tests/ui_snapshots.rs | 18 + docs/internationalization.md | 29 + docs/localization-parity.md | 13 +- 21 files changed, 320 insertions(+), 10516 deletions(-) create mode 100644 craft-i18n.rev create mode 100644 crates/ui-egui/i18n_build.rs delete mode 100644 crates/ui-egui/src/i18n/ar.rs delete mode 100644 crates/ui-egui/src/i18n/de.rs delete mode 100644 crates/ui-egui/src/i18n/es.rs delete mode 100644 crates/ui-egui/src/i18n/fr.rs delete mode 100644 crates/ui-egui/src/i18n/it.rs delete mode 100644 crates/ui-egui/src/i18n/ja.rs delete mode 100644 crates/ui-egui/src/i18n/ko.rs delete mode 100644 crates/ui-egui/src/i18n/pt_br.rs delete mode 100644 crates/ui-egui/src/i18n/zh_hans.rs create mode 100644 crates/ui-egui/tests/i18n_build.rs create mode 100644 docs/internationalization.md diff --git a/Cargo.lock b/Cargo.lock index 94579b6f..6cc81216 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4443,6 +4443,7 @@ version = "0.3.1" dependencies = [ "base64 0.22.1", "craft-dialogs", + "craft-i18n", "craft-keymap", "craft-quit", "craft-ui", diff --git a/Cargo.toml b/Cargo.toml index 29de448b..b02f6cca 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -65,6 +65,8 @@ getrandom = "0.3" rustix = { version = "1", default-features = false, features = ["std", "fs", "process"] } # Shared Craft egui components (widget palette, icon buttons, panel docking): storytold/craft-libs, # MIT OR Apache-2.0, pinned to one rev. +# Shared catalog lookup, pinned with the other Craft libraries. +craft-i18n = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d" } craft-ui = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", features = ["serde"] } # Who draws the window frame, and the app-drawn strip as the title bar (crates/ui-egui/src/titlebar.rs). craft-window = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", features = ["egui"] } diff --git a/craft-i18n.rev b/craft-i18n.rev new file mode 100644 index 00000000..5ee3326c --- /dev/null +++ b/craft-i18n.rev @@ -0,0 +1 @@ +cdf4401147d573dbc200042a771690e3b1d80623 diff --git a/crates/ui-egui/Cargo.toml b/crates/ui-egui/Cargo.toml index 46f84fd7..63b79f77 100644 --- a/crates/ui-egui/Cargo.toml +++ b/crates/ui-egui/Cargo.toml @@ -14,6 +14,7 @@ texturecraft-render = { workspace = true } eframe = { workspace = true, features = ["default_fonts", "wgpu", "persistence"] } egui = { workspace = true } craft-ui = { workspace = true } +craft-i18n = { workspace = true } craft-window = { workspace = true } craft-keymap = { workspace = true } craft-quit = { workspace = true } diff --git a/crates/ui-egui/build.rs b/crates/ui-egui/build.rs index 86168323..738ceaec 100644 --- a/crates/ui-egui/build.rs +++ b/crates/ui-egui/build.rs @@ -4,6 +4,8 @@ //! recipe follows craft-fonts' `docs/integration.md`; no font file is committed here. The Latin //! faces are embedded without their Private Use Area ([`without_private_use`]). +mod i18n_build; + use std::fmt::Write as _; use std::path::PathBuf; @@ -23,6 +25,7 @@ const LATIN: Faces = &[("Inter", "Regular"), ("Inter", "SemiBold")]; type Faces = &'static [(&'static str, &'static str)]; fn main() { + i18n_build::embed(); println!("cargo::rerun-if-env-changed=CRAFT_FONTS_DIR"); println!("cargo::rerun-if-env-changed=CRAFT_FONTS_REQUIRED"); let mut src = String::from("pub static CRAFT_FONTS: &[CraftFont] = &[\n"); diff --git a/crates/ui-egui/i18n_build.rs b/crates/ui-egui/i18n_build.rs new file mode 100644 index 00000000..bc5c3820 --- /dev/null +++ b/crates/ui-egui/i18n_build.rs @@ -0,0 +1,76 @@ +//! Optional shared translation catalogs, embedded at build time. +use std::fmt::Write as _; +use std::path::Path; + +pub fn generate(dir: Option<&Path>, required: bool) -> Result { + let mut source = String::from("pub static CRAFT_I18N: &craft_i18n::Embedded = &[\n"); + let Some(dir) = dir else { + if required { + return Err("CRAFT_I18N_REQUIRED=1 requires CRAFT_I18N_DIR".into()); + } + source.push_str("];\n"); + return Ok(source); + }; + if !dir.is_absolute() { + return Err("CRAFT_I18N_DIR must be an absolute path".into()); + } + let locales = dir.join("locales"); + let entries = std::fs::read_dir(&locales).map_err(|e| format!("{}: {e}", locales.display()))?; + println!("cargo::rerun-if-changed={}", locales.display()); + let mut paths = Vec::new(); + for entry in entries { + let entry = entry.map_err(|e| e.to_string())?; + if entry.file_type().map_err(|e| e.to_string())?.is_dir() { + paths.push(entry.path()); + } + } + paths.sort(); + let mut count = 0; + for path in paths { + // Watch directories too: adding/removing an app catalog must rebuild the embedding. + println!("cargo::rerun-if-changed={}", path.display()); + let app = path.join("texturecraft.tsv"); + if !app.is_file() { + continue; + } + let locale = path.file_name().and_then(|n| n.to_str()).ok_or("non-UTF-8 locale")?; + let common = path.join("common.tsv"); + let embed = |file: &Path| -> Result { + std::fs::read_to_string(file).map_err(|e| format!("{}: {e}", file.display()))?; + let name = file.to_str().ok_or("non-UTF-8 catalog path")?; + println!("cargo::rerun-if-changed={name}"); + Ok(format!("include_str!({name:?})")) + }; + let shared = if common.is_file() { embed(&common)? } else { "\"\"".into() }; + let app = embed(&app)?; + let _ = writeln!(source, " ({locale:?}, {shared}, {app}),"); + count += 1; + } + if required && count == 0 { + return Err("no TextureCraft translation catalogs found".into()); + } + source.push_str("];\n"); + Ok(source) +} + +pub fn embed() { + println!("cargo::rerun-if-env-changed=CRAFT_I18N_DIR"); + println!("cargo::rerun-if-env-changed=CRAFT_I18N_REQUIRED"); + let dir = std::env::var_os("CRAFT_I18N_DIR").map(std::path::PathBuf::from); + let required = std::env::var("CRAFT_I18N_REQUIRED").is_ok_and(|v| v == "1"); + let source = match generate(dir.as_deref(), required) { + Ok(source) => source, + Err(error) => { + if required { + println!("cargo::error={error}"); + } else { + println!("cargo::warning=building without craft-i18n: {error}"); + } + "pub static CRAFT_I18N: &craft_i18n::Embedded = &[];\n".into() + } + }; + let out = std::path::PathBuf::from(std::env::var_os("OUT_DIR").unwrap_or_default()).join("craft_i18n.rs"); + if let Err(error) = std::fs::write(&out, source) { + println!("cargo::error=writing {}: {error}", out.display()); + } +} diff --git a/crates/ui-egui/src/i18n.rs b/crates/ui-egui/src/i18n.rs index 7ccc1d84..a9431af1 100644 --- a/crates/ui-egui/src/i18n.rs +++ b/crates/ui-egui/src/i18n.rs @@ -1,22 +1,31 @@ -//! UI text lookup. Keys are the English strings, so English needs no table and a missing -//! translation falls back to English. Every user-visible literal goes through [`tr`] (or [`trf`] -//! for text with `{name}` placeholders); each language is a static `(English, translation)` -//! table, indexed into a hash map the first time the language is used. `Prefs::language` picks it. +//! UI text lookup over the optional shared craft-i18n catalogs. +//! Missing translations and builds without catalogs use the English source text. -use std::collections::HashMap; use std::fmt::Display; -use std::sync::OnceLock; use std::sync::atomic::{AtomicUsize, Ordering}; +use std::sync::{LazyLock, OnceLock}; -mod ar; -mod de; -mod es; -mod fr; -mod it; -mod ja; -mod ko; -mod pt_br; -mod zh_hans; +include!(concat!(env!("OUT_DIR"), "/craft_i18n.rs")); + +static I18N: LazyLock = LazyLock::new(|| { + let offered: Vec<_> = LANGUAGES.iter().map(|l| l.code).collect(); + let (i18n, problems) = craft_i18n::I18n::new(CRAFT_I18N, &offered); + for problem in problems { + log::warn!("translation catalog: {problem}"); + } + i18n +}); + +static SHARED_LANGUAGES: OnceLock<[craft_i18n::Lang; COUNT]> = OnceLock::new(); + +fn shared_languages() -> &'static [craft_i18n::Lang; COUNT] { + SHARED_LANGUAGES.get_or_init(|| LANGUAGES.each_ref().map(|l| I18N.from_code(l.code).unwrap_or(craft_i18n::Lang::EN))) +} + +/// Whether this build embeds a catalog for a supported language. +pub fn available(code: &str) -> bool { + I18N.from_code(code).is_some() +} pub struct Language { /// BCP 47 code ("en", "pt-BR", "zh-Hans"). @@ -25,26 +34,23 @@ pub struct Language { pub name: &'static str, /// Its English name (the picker's fallback when no font can draw `name`). pub english: &'static str, - /// `(English, translation)` pairs, in any order. - pub table: &'static [(&'static str, &'static str)], } const COUNT: usize = 10; pub static LANGUAGES: [Language; COUNT] = [ - Language { code: "en", name: "English", english: "English", table: &[] }, - Language { code: "fr", name: "Français", english: "French", table: fr::TABLE }, - Language { code: "de", name: "Deutsch", english: "German", table: de::TABLE }, - Language { code: "es", name: "Español", english: "Spanish", table: es::TABLE }, - Language { code: "pt-BR", name: "Português (Brasil)", english: "Portuguese (Brazil)", table: pt_br::TABLE }, - Language { code: "it", name: "Italiano", english: "Italian", table: it::TABLE }, - Language { code: "ja", name: "日本語", english: "Japanese", table: ja::TABLE }, - Language { code: "zh-Hans", name: "简体中文", english: "Chinese (Simplified)", table: zh_hans::TABLE }, - Language { code: "ko", name: "한국어", english: "Korean", table: ko::TABLE }, - Language { code: "ar", name: "العربية", english: "Arabic", table: ar::TABLE }, + Language { code: "en", name: "English", english: "English" }, + Language { code: "fr", name: "Français", english: "French" }, + Language { code: "de", name: "Deutsch", english: "German" }, + Language { code: "es", name: "Español", english: "Spanish" }, + Language { code: "pt-BR", name: "Português (Brasil)", english: "Portuguese (Brazil)" }, + Language { code: "it", name: "Italiano", english: "Italian" }, + Language { code: "ja", name: "日本語", english: "Japanese" }, + Language { code: "zh-Hans", name: "简体中文", english: "Chinese (Simplified)" }, + Language { code: "ko", name: "한국어", english: "Korean" }, + Language { code: "ar", name: "العربية", english: "Arabic" }, ]; -static MAPS: [OnceLock>; COUNT] = [const { OnceLock::new() }; COUNT]; static CURRENT: AtomicUsize = AtomicUsize::new(0); /// Display labels belong to the UI; the model exposes only map identities @@ -67,7 +73,7 @@ pub(crate) fn baked_map_label(map: texturecraft_engine::core::BakedMap) -> &'sta /// Switch the UI language (unknown codes fall back to English). pub fn set_language(code: &str) { - CURRENT.store(LANGUAGES.iter().position(|l| l.code == code).unwrap_or(0), Ordering::Relaxed); + CURRENT.store(LANGUAGES.iter().position(|l| l.code.eq_ignore_ascii_case(code) && available(l.code)).unwrap_or(0), Ordering::Relaxed); } /// The current UI language. @@ -77,12 +83,8 @@ pub fn current() -> &'static Language { /// `text` in the current language (unchanged when it has no translation). pub fn tr(text: &str) -> &str { - let i = CURRENT.load(Ordering::Relaxed); - let (Some(lang), Some(map)) = (LANGUAGES.get(i), MAPS.get(i)) else { return text }; - if lang.table.is_empty() { - return text; - } - map.get_or_init(|| lang.table.iter().copied().collect()).get(text).copied().unwrap_or(text) + let lang = shared_languages().get(CURRENT.load(Ordering::Relaxed)).copied().unwrap_or(craft_i18n::Lang::EN); + I18N.t(lang, text) } /// Marks a static string for translation where it is defined (gettext's `N_`); it is translated @@ -93,25 +95,9 @@ pub const fn n_(text: &'static str) -> &'static str { /// `template` translated, with each `{name}` replaced by its value in `args`. pub fn trf(template: &str, args: &[(&str, &dyn Display)]) -> String { - let mut out = String::with_capacity(template.len() + 16); - let mut rest = tr(template); - while let Some(open) = rest.find('{') { - out.push_str(&rest[..open]); - let after = &rest[open + 1..]; - match after.find('}').and_then(|close| args.iter().find(|(k, _)| *k == &after[..close]).map(|(_, v)| (close, v))) { - Some((close, v)) => { - use std::fmt::Write as _; - let _ = write!(out, "{v}"); - rest = &after[close + 1..]; - } - None => { - out.push('{'); - rest = after; - } - } - } - out.push_str(rest); - out + let values: Vec<_> = args.iter().map(|(name, value)| (*name, value.to_string())).collect(); + let args: Vec<_> = values.iter().map(|(name, value)| (*name, value.as_str())).collect(); + craft_i18n::fmt(tr(template), &args) } /// The supported language for a locale such as "de-AT", "pt_BR.UTF-8" or "zh-Hant-TW" ("en" when @@ -142,6 +128,7 @@ pub(crate) static TEST_LANGUAGE: std::sync::Mutex<()> = std::sync::Mutex::new(() mod tests { use super::TEST_LANGUAGE as LANGUAGE; use super::*; + use std::collections::{BTreeSet, HashMap}; /// Every key the UI looks up: `tr("…")` / `trf("…"` literals in the sources, plus the /// static catalogs whose labels are translated where they are shown. @@ -252,43 +239,51 @@ mod tests", } } - fn placeholders(s: &str) -> Vec<&str> { - let mut v: Vec<&str> = s.split('{').skip(1).filter_map(|p| p.split_once('}').map(|(name, _)| name)).collect(); - v.sort_unstable(); - v + #[test] + fn embedded_catalogs_are_valid() { + assert!(I18N.check_all().is_empty(), "{:?}", I18N.check_all()); } + /// Translation work never blocks a feature: report missing/stale keys without failing. #[test] - fn every_key_is_translated_in_every_language() { + fn translation_coverage_report() { let keys = keys(); assert!(keys.len() > 300, "found only {} keys", keys.len()); - let mut missing = Vec::new(); - for l in LANGUAGES.iter().skip(1) { - let map: HashMap<&str, &str> = l.table.iter().copied().collect(); - assert_eq!(map.len(), l.table.len(), "{}: duplicate keys", l.code); - for k in &keys { - if !map.contains_key(k.as_str()) { - missing.push(format!("{}: {k:?}", l.code)); + let used: BTreeSet<_> = keys.iter().map(String::as_str).collect(); + for &(locale, common, app) in CRAFT_I18N { + let Some(lang) = I18N.from_code(locale) else { continue }; + let missing: Vec<_> = keys.iter().filter(|key| I18N.get(lang, "", key).is_none()).collect(); + // Decode TSV escapes for comparison with the literal source strings. + let mut rows = HashMap::new(); + for text in [common, app] { + for line in text.lines().filter(|l| !l.starts_with('#')) { + let columns: Vec<_> = line.split('\t').collect(); + if let ["", source, _] = columns.as_slice() { + let mut decoded = String::new(); + let mut chars = source.chars(); + while let Some(c) = chars.next() { + decoded.push(if c == '\\' { + match chars.next() { + Some('n') => '\n', + Some('t') => '\t', + Some(c) => c, + None => '\\', + } + } else { + c + }); + } + rows.insert(decoded, ()); + } } } + let stale: Vec<_> = rows.keys().filter(|key| !used.contains(key.as_str())).collect(); + eprintln!("{locale}: missing {} {missing:?}; unused/shared {} {stale:?}", missing.len(), stale.len()); } - assert!(missing.is_empty(), "{} missing translations:\n{}", missing.len(), missing.join("\n")); } - /// Catalog labels that read the same in every language (names and formats). const UNTRANSLATED: &[&str] = &["RGB", "RGBA"]; - #[test] - fn translations_keep_placeholders_and_are_not_empty() { - for l in &LANGUAGES { - for (en, t) in l.table { - assert!(!t.trim().is_empty(), "{}: empty translation of {en:?}", l.code); - assert_eq!(placeholders(en), placeholders(t), "{}: placeholders of {en:?} in {t:?}", l.code); - assert_eq!(en.ends_with("..."), t.ends_with("...") || t.ends_with('…'), "{}: ellipsis of {en:?} in {t:?}", l.code); - } - } - } - #[test] fn lookup_formatting_and_fallbacks() { let _lock = LANGUAGE.lock().unwrap_or_else(std::sync::PoisonError::into_inner); @@ -304,11 +299,36 @@ mod tests", assert_eq!(language_for_locale(locale), code, "{locale}"); } set_language("de"); - assert_eq!(current().code, "de"); + assert_eq!(current().code, if available("de") { "de" } else { "en" }); assert_eq!(tr("not a key"), "not a key"); set_language("en"); } + #[test] + fn shared_lookup_overrides_and_missing_translations() { + static CATALOGS: &craft_i18n::Embedded = &[("es", "\tSave\tGuardar\n\tOpen\tAbrir\n", "\tSave\tGuardar proyecto\n")]; + let (runtime, problems) = craft_i18n::I18n::new(CATALOGS, &["es"]); + assert!(problems.is_empty()); + assert!(runtime.check_all().is_empty()); + let lang = runtime.from_code("es").unwrap(); + assert_eq!(runtime.t(lang, "Save"), "Guardar proyecto"); + assert_eq!(runtime.t(lang, "Open"), "Abrir"); + assert_eq!(runtime.t(lang, "New feature"), "New feature"); + assert_eq!(runtime.t(craft_i18n::Lang::EN, "Save"), "Save"); + } + + #[test] + fn saved_language_codes_and_spanish_lookup() { + let _lock = LANGUAGE.lock().unwrap_or_else(std::sync::PoisonError::into_inner); + for language in &LANGUAGES { + set_language(language.code); + assert_eq!(current().code, if available(language.code) { language.code } else { "en" }); + } + set_language("es"); + assert_eq!(tr("Layers"), if available("es") { "Capas" } else { "Layers" }); + set_language("en"); + } + #[test] fn lookup_is_fast() { let _lock = LANGUAGE.lock().unwrap_or_else(std::sync::PoisonError::into_inner); diff --git a/crates/ui-egui/src/i18n/ar.rs b/crates/ui-egui/src/i18n/ar.rs deleted file mode 100644 index 95373f3d..00000000 --- a/crates/ui-egui/src/i18n/ar.rs +++ /dev/null @@ -1,1135 +0,0 @@ -//! Arabic UI text: (English key, translation). Keys are the English strings passed to `tr`. - -pub const TABLE: &[(&str, &str)] = &[ - ("Baking {map} ({n}/{total})", "جارٍ خبز {map} ({n}/{total})"), - ("Baking {map} ({n}/{total}), texture set {set} of {sets}", "جارٍ خبز {map} ({n}/{total})، مجموعة الخامات {set} من {sets}"), - ("Follow Newest Map", "تتبّع أحدث خريطة"), - ( - "Painting is paused while a bake is shown. Cancel the bake or wait for it to finish.", - "الرسم متوقف مؤقتًا أثناء عرض عملية الخبز. ألغِ الخبز أو انتظر حتى ينتهي.", - ), - ( - "What the 3D view shows while the bake runs: the newest finished map, one finished map, or the material. Maps not baked yet show a neutral value.", - "ما يعرضه العرض ثلاثي الأبعاد أثناء الخبز: أحدث خريطة مكتملة، أو أي خريطة مكتملة تختارها، أو الخامة. الخرائط التي لم تُخبز بعد تعرض قيمة محايدة.", - ), - ("\"{layer}\" has no paint yet: the filter changes what you paint on it.", "لا يوجد رسم على \"{layer}\" بعد: يغيّر المرشح ما ترسمه عليها."), - ("0 turns autosave off. Copies go to {folder}", "0 يعطل الحفظ التلقائي. تُحفظ النُسخ في {folder}"), - ("2D view only", "عرض ثنائي الأبعاد فقط"), - ("32 bits (float)", "32 بت (فاصلة عائمة)"), - ("3D mesh", "مجسم ثلاثي الأبعاد"), - ("3D meshes", "مجسمات ثلاثية الأبعاد"), - ( - "3D texture painting: layers, masks, smart materials, mesh map baking and export.", - "رسم الخامات ثلاثية الأبعاد: طبقات، أقنعة، مواد ذكية، خبز خرائط المجسم والتصدير.", - ), - ("3D view only", "عرض ثلاثي الأبعاد فقط"), - ("3D/2D views", "عرض 3D/2D"), - ( - "A folder blends its children (pass-through). Set per-channel opacity in the layer rows.", - "المجلد يدمج عناصره الفرعية (تمرير مباشر). حدد عتامة كل قناة في صفوف الطبقات.", - ), - ("ACES filmic", "ACES سينمائي"), - ("Ambient", "المحيط"), - ("AO intensity", "شدة الانسداد المحيطي (AO)"), - ("About TextureCraft", "حول TextureCraft"), - ("About TextureCraft...", "حول TextureCraft..."), - ("Add an anchor point to a layer below to use its stack as a mask.", "أضف نقطة ارتكاز إلى طبقة سفلية لاستخدام مكدسها كقناع."), - ("Add anchor point", "إضافة نقطة ارتكاز"), - ("Add as decal (view center)", "إضافة كملصق (مركز العرض)"), - ("Add black mask", "إضافة قناع أسود"), - ("Add channel", "إضافة قناة"), - ("Add color", "إضافة لون"), - ("Add compare mask", "إضافة قناع مقارنة"), - ("Add effect", "إضافة تأثير"), - ("Add fill", "إضافة تعبئة"), - ("Add fill layer", "إضافة طبقة تعبئة"), - ("Add filter", "إضافة مرشح"), - ("Add folder", "إضافة مجلد"), - ("Add generator", "إضافة مولّد"), - ("Add levels", "إضافة مستويات"), - ("Add mask", "إضافة قناع"), - ("Add mask with color selection", "إضافة قناع مع تحديد لوني"), - ("Add output", "إضافة مخرج"), - ("Add paint", "إضافة رسم"), - ("Add paint layer", "إضافة طبقة رسم"), - ("Add smart material from the shelf", "إضافة مادة ذكية من الرف"), - ("Add to the layer content", "إضافة إلى محتوى الطبقة"), - ("Add to the mask", "إضافة إلى القناع"), - ("Add white mask", "إضافة قناع أبيض"), - ("Adjustments", "تعديلات"), - ( - "Aligned: the offset set by the first stroke is kept. V + click sets a new source.", - "محاذاة: يُحتفظ بالإزاحة المحددة بالضربة الأولى. V + النقر يحدد مصدراً جديداً.", - ), - ("Alignment", "محاذاة"), - ("Alignment and culling", "المحاذاة والاستبعاد"), - ("All layers", "كل الطبقات"), - ("Alpha", "ألفا"), - ("Alphas", "أقنعة ألفا"), - ("Also bound to {item} ({menu})", "مرتبط أيضاً بـ {item} ({menu})"), - ("Alt + LMB drag", "سحب بـ Alt + زر الفأرة الأيسر"), - ("Always", "دائماً"), - ("Ambient Occlusion", "الانسداد المحيطي (AO)"), - ("Ambient occlusion", "الانسداد المحيطي (AO)"), - ("Amount", "المقدار"), - ("Anchor point", "نقطة ارتكاز"), - ("Anchor: {name}", "نقطة ارتكاز: {name}"), - ("Anchor: {name} ({channel})", "نقطة ارتكاز: {name} ({channel})"), - ("Angle", "الزاوية"), - ("Angle (degrees)", "الزاوية (بالدرجات)"), - ("Angle fade from", "تلاشي الزاوية من"), - ("Angle fade to", "تلاشي الزاوية إلى"), - ("Angle jitter", "اضطراب الزاوية"), - ("Anisotropy angle", "زاوية تباين الخواص"), - ("Anisotropy level", "مستوى تباين الخواص"), - ("Antialiasing", "تنعيم الحواف"), - ("Aperture", "فتحة العدسة"), - ("Apply", "تطبيق"), - ("ArtCraft website...", "موقع ArtCraft الإلكتروني..."), - ("Assets", "الأصول"), - ("Auto", "تلقائي"), - ("Automatic (from the mesh UVs)", "تلقائي (من إحداثيات UV للمجسم)"), - ("Autosave every", "حفظ تلقائي كل"), - ( - "Autosaves, smart materials, presets, templates and UI layouts go to the data folder. A new folder applies on restart; files already saved stay where they are.", - "تُحفظ النسخ التلقائية والمواد الذكية والإعدادات المسبقة والقوالب وتخطيطات الواجهة في مجلد البيانات. يُطبَّق المجلد الجديد عند إعادة التشغيل، وتبقى الملفات المحفوظة في مكانها.", - ), - ("Axis", "المحور"), - ("Back to painting", "العودة إلى الرسم"), - ("Backface culling", "استبعاد الوجوه الخلفية"), - ("Bake an ID map (F8) to pick colors from the mesh.", "اخبز خريطة المعرّفات ID (F8) لالتقاط الألوان من الشبكة."), - ("Bake Mesh Maps", "خبز خرائط المجسم"), - ("Bake mesh maps", "خبز خرائط المجسم"), - ( - "Bake mesh maps (F8) for curvature, AO and thickness based generators.", - "اخبز خرائط المجسم (F8) للمولدات المعتمدة على الانحناء والانسداد المحيطي والسماكة.", - ), - ("Baked Lighting", "إضاءة مخبوزة"), - ("Baking", "الخبز"), - ("Base color", "اللون الأساسي"), - ( - "Base color is the diffuse color, Specular the F0 color and Glossiness 1 - roughness (add these channels in the texture set settings).", - "اللون الأساسي هو اللون المنتشر، واللمعان هو لون F0، والصفاء هو 1 - الخشونة (أضف هذه القنوات في إعدادات مجموعة الخامات).", - ), - ("Base color, Metallic, Roughness and Specular level.", "اللون الأساسي، المعدنية، الخشونة ومستوى اللمعان."), - ("Based on each texture set's size", "بناءً على حجم كل مجموعة خامات"), - ("Basic settings", "الإعدادات الأساسية"), - ("Bent Normals", "النواظم المنحنية"), - ("Bevel", "شطف الحواف"), - ("Black", "أسود"), - ("Blending", "الدمج"), - ("Blending mode of the displayed channel", "نمط الدمج للقناة المعروضة"), - ("Blur", "تمويه"), - ("Blur Directional", "تمويه اتجاهي"), - ("Blur and sharpen", "تمويه وتوضيح"), - ("Bounces", "الارتدادات"), - ("Bricks", "طوب"), - ("Brush", "فرشاة"), - ("Brush size", "حجم الفرشاة"), - ("Brush size down / up", "تصغير / تكبير حجم الفرشاة"), - ("Brushed lines", "خطوط مصقولة بالفرشاة"), - ("Built-in (read-only): duplicate it to edit", "مدمج (للقراءة فقط): انسخه لتعديله"), - ("Built-in templates are read-only: duplicate one to edit it", "القوالب المدمجة للقراءة فقط: انسخ قالباً لتعديله"), - ("Built-in: {mesh}", "مدمج: {mesh}"), - ("Cage: {name}", "القفص (Cage): {name}"), - ("Camera", "الكاميرا"), - ("Colors", "الألوان"), - ("Go to camera 1", "الانتقال إلى الكاميرا 1"), - ("Go to camera 2", "الانتقال إلى الكاميرا 2"), - ("Go to camera 3", "الانتقال إلى الكاميرا 3"), - ("Go to camera 4", "الانتقال إلى الكاميرا 4"), - ("Go to camera 5", "الانتقال إلى الكاميرا 5"), - ("Go to camera 6", "الانتقال إلى الكاميرا 6"), - ("Go to camera 7", "الانتقال إلى الكاميرا 7"), - ("Go to camera 8", "الانتقال إلى الكاميرا 8"), - ("Go to camera 9", "الانتقال إلى الكاميرا 9"), - ("Camera settings", "إعدادات الكاميرا"), - ("Cancel", "إلغاء"), - ("Cancel the stroke", "إلغاء ضربة الفرشاة"), - ("Cell size (texels at 2K)", "حجم الخلية (تكسل بدقة 2K)"), - ("Cells", "خلايا"), - ("Channel", "القناة"), - ("Channel source: uniform value, procedural, image or anchor", "مصدر القناة: قيمة موحدة، إجرائي، صورة أو نقطة ارتكاز"), - ("Channels", "القنوات"), - ("Check for Updates...", "التحقق من وجود تحديثات..."), - ("Checker", "رقعة شطرنج"), - ("Clamp", "تقييد القيم"), - ("Clear", "مسح"), - ("Clear mask", "مسح القناع"), - ("Clear recent projects", "مسح المشاريع الأخيرة"), - ("Click a mesh part to show or hide the selected layer on it.", "انقر على جزء من المجسم لإظهار أو إخفاء الطبقة المحددة عليه."), - ("Click the mesh to pick its material into the brush", "انقر على المجسم لالتقاط مادته إلى الفرشاة"), - ("Click the mesh to place the decal", "انقر على المجسم لوضع الملصق"), - ("Click, then press the new shortcut (Esc cancels)", "انقر، ثم اضغط الاختصار الجديد (Esc للإلغاء)"), - ("Clone", "استنساخ"), - ("Close", "إغلاق"), - ("Closed path", "مسار مغلق"), - ("Cloud", "سحابة"), - ("Clouds", "سحب"), - ("Coat normal", "ناظم الطبقة الشفافة"), - ("Coat roughness", "خشونة الطبقة الشفافة"), - ("Coat weight", "وزن الطبقة الشفافة"), - ("Color", "اللون"), - ("Color Balance", "توازن الألوان"), - ("Color burn", "حرق لوني (Color Burn)"), - ("Color dodge", "تفتيح لوني (Color Dodge)"), - ("Color of the light that travels under the surface (each channel goes as far as its value)", "لون الضوء المنتقل تحت السطح (تصل كل قناة بقدر قيمتها)"), - ("Color picker", "منتقي الألوان"), - ("Color selection", "تحديد لوني"), - ("Color to replace", "اللون المراد استبداله"), - ("Colors near the first shift towards the second, keeping their shading.", "الألوان القريبة من الأولى تتحول نحو الثانية مع الحفاظ على تظليلها."), - ("Colors read as gray. Add a levels or blur effect above to shape the result.", "تُقرأ الألوان كرمادي. أضف تأثير مستويات أو تمويه في الأعلى لتشكيل النتيجة."), - ("Combine with the layer's height", "الدمج مع ارتفاع الطبقة"), - ("Compare mask", "قناع مقارنة"), - ("Compositing", "التركيب"), - ("Constant", "ثابت"), - ("Constants", "ثوابت"), - ("Contrast", "التباين"), - ("Contrast/Luminosity", "التباين / الإضاءة"), - ("Converted maps", "الخرائط المحوّلة"), - ("Copy RGB values", "نسخ قيم RGB"), - ("Copy effect", "نسخ التأثير"), - ("Copy from", "نسخ من"), - ("Copy layer(s)", "نسخ الطبقة (الطبقات)"), - ("Copy the selected layer alone (its empty parts copy nothing)", "نسخ الطبقة المحددة وحدها (الأجزاء الفارغة لا تنسخ شيئاً)"), - ("Copy to all texture sets", "نسخ إلى جميع مجموعات الخامات"), - ("Copy what the texture set shows", "نسخ ما تعرضه مجموعة الخامات"), - ("Couldn't encode the render", "تعذر ترميز التصيير"), - ("Couldn't export textures: {error}", "تعذر تصدير الخامات: {error}"), - ("Couldn't export the mesh: {error}", "تعذر تصدير المجسم: {error}"), - ("Couldn't export the template: {error}", "تعذر تصدير القالب: {error}"), - ("Couldn't import {name}: {error}", "تعذر استيراد {name}: {error}"), - ("Couldn't open {name}: {error}", "تعذر فتح {name}: {error}"), - ("Couldn't read the render back from the GPU", "تعذرت قراءة التصيير من وحدة معالجة الرسوميات (GPU)"), - ("Couldn't save the render: {error}", "تعذر حفظ التصيير: {error}"), - ("Couldn't save {name}: {error}", "تعذر حفظ {name}: {error}"), - ("Count per stamp", "العدد لكل طبعة"), - ("Crate", "صندوق"), - ("Create", "إنشاء"), - ("Create smart material", "إنشاء مادة ذكية"), - ( - "Ctrl+right-drag in a view sets the size and hardness, Ctrl+left-drag the flow and angle.", - "Ctrl+السحب بالزر الأيمن في عرض يضبط الحجم والصلابة، وCtrl+السحب بالزر الأيسر يضبط التدفق والزاوية.", - ), - ("Cube", "مكعب"), - ("Current layer", "الطبقة الحالية"), - ("Curvature", "الانحناء"), - ("Cut effect", "قص التأثير"), - ("Cut layer(s)", "قص الطبقة (الطبقات)"), - ("Cyan / red", "سماوي / أحمر"), - ("Cylinder", "أسطوانة"), - ("Cylindrical projection", "إسقاط أسطواني"), - ("Dark to light: the content's luminance picks a color along these stops.", "من الداكن إلى الفاتح: تحدد إضاءة المحتوى لوناً على طول نقاط التوقف هذه."), - ("Darken (Min)", "تغميق (الحد الأدنى)"), - ("Data folder", "مجلد البيانات"), - ("Decal", "ملصق"), - ("Decal projection", "إسقاط الملصق"), - ("Default", "افتراضي"), - ("Default camera", "الكاميرا الافتراضية"), - ("Delete the selected template", "حذف القالب المحدد"), - ("Delete this camera", "حذف هذه الكاميرا"), - ("Deleted template \"{name}\"", "تم حذف القالب \"{name}\""), - ("Denoise", "إزالة الضوضاء"), - ("Depth", "العمق"), - ("Depth of field", "عمق الميدان"), - ("Depth of field (viewport and Rendering mode)", "عمق الميدان (منفذ العرض ونمط التصيير)"), - ("Depth of the sharp plane along the view (0: the orbit center)", "عمق المستوى الحاد على طول خط النظر (0: مركز المدار)"), - ("Details saved to {file}", "حُفظت التفاصيل في {file}"), - ("Difference", "الفرق"), - ("Dilation + default background color", "تمديد + لون الخلفية الافتراضي"), - ("Dilation + transparent", "تمديد + شفاف"), - ("Dilation infinite", "تمديد لا نهائي"), - ("DirectX normal map", "خريطة نواظم DirectX"), - ("Dirt", "أوساخ"), - ("Disable", "تعطيل"), - ("Dismiss", "تجاهل"), - ("Displacement (height channel)", "إزاحة (قناة الارتفاع)"), - ("Display Settings", "إعدادات العرض"), - ("Display material", "عرض المادة"), - ("Display next channel", "عرض القناة التالية"), - ("Display next mesh map", "عرض خريطة المجسم التالية"), - ("Display previous channel", "عرض القناة السابقة"), - ("Display previous mesh map", "عرض خريطة المجسم السابقة"), - ("Distance", "المسافة"), - ("Distort", "تشويه"), - ("Divide", "قسمة"), - ("Document resolution", "دقة المستند"), - ("Documentation...", "التوثيق..."), - ("Done on CPU: {n} / {max} samples, {s} s", "اكتمل على المعالج (CPU): {n} / {max} عينة، {s} ث"), - ("Done on GPU: {n} / {max} samples, {s} s", "اكتمل على المعالج الرسومي (GPU): {n} / {max} عينة، {s} ث"), - ("Double-click to rename", "انقر نقراً مزدوجاً لإعادة التسمية"), - ("Download as", "تنزيل باسم"), - ("Downloaded {name}", "تم تنزيل {name}"), - ("Drag onto an output channel", "اسحب إلى قناة إخراج"), - ("Drags the layer stack's values along the stroke into the selected layer.", "يسحب قيم مكدس الطبقات على طول الضربة إلى الطبقة المحددة."), - ( - "Draws {name} of texture set \"{set}\". Edits to the source show in every instance.", - "يرسم {name} لمجموعة الخامات \"{set}\". التعديلات على المصدر تظهر في كل نسخة.", - ), - ( - "Drag the frame to move the decal, a corner to scale it, the round handle to turn it", - "اسحب الإطار لتحريك الملصق، أو الزاوية لتغيير حجمه، أو المقبض الدائري لتدويره", - ), - ("Drop an image from the Assets panel here to use it as this mesh map", "أفلت صورة من لوحة الأصول هنا لاستخدامها كخريطة المجسم هذه"), - ("Dry streaks", "خطوط جافة"), - ("Duplicate effect", "تكرار التأثير"), - ("Duplicate layer(s)", "تكرار الطبقة (الطبقات)"), - ("Duplicate the selected template", "تكرار القالب المحدد"), - ("Edge Detect", "اكتشاف الحواف"), - ("Edit", "تحرير"), - ("Edit keyboard shortcuts...", "تعديل اختصارات لوحة المفاتيح..."), - ("Edit quick mask", "تحرير القناع السريع"), - ("Editing quick mask: paint where painting is allowed (U to finish)", "تحرير القناع السريع: ارسم حيث يُسمح بالرسم (اضغط U للإنهاء)"), - ( - "Editing the quick mask: strokes paint where painting is allowed. Press U to finish.", - "تحرير القناع السريع: ترسم الضربات حيث يُسمح بالرسم. اضغط U للإنهاء.", - ), - ("Emissive", "إشعاع"), - ("Enable or disable the effect", "تمكين أو تعطيل التأثير"), - ("Enable quick mask", "تمكين القناع السريع"), - ("Environment blur", "تمويه البيئة"), - ("Environment exposure (EV)", "تعريض البيئة (EV)"), - ("Environment map", "خريطة البيئة"), - ("Environment opacity", "عتامة البيئة"), - ("Environment rotation", "دوران البيئة"), - ("Environment settings", "إعدادات البيئة"), - ("Environment: {name}", "البيئة: {name}"), - ("Environments", "البيئات"), - ("Eraser", "ممحاة"), - ("Exclusion", "استبعاد (Exclusion)"), - ("Expand or collapse the folder", "توسيع المجلد أو طيه"), - ("Export", "تصدير"), - ("Export Mesh...", "تصدير المجسم..."), - ("Export Textures...", "تصدير الخامات..."), - ("Export mesh", "تصدير المجسم"), - ("Export template", "تصدير القالب"), - ("Export templates", "تصدير القوالب"), - ("Export textures", "تصدير الخامات"), - ("Export the selected template (.json)", "تصدير القالب المحدد (.json)"), - ("Exported mesh to {path}", "تم تصدير المجسم إلى {path}"), - ("Exported template \"{name}\" to {path}", "تم تصدير القالب \"{name}\" إلى {path}"), - ("Exported {n} textures to {folder}", "تم تصدير {n} خامة إلى {folder}"), - ("F0 from specular level", "F0 من مستوى اللمعان"), - ("Fabric weave", "نسيج قماش"), - ("Field of view (deg)", "مجال الرؤية (بالدرجات)"), - ("File", "ملف"), - ("File name without extension; variables insert names", "اسم الملف بدون الامتداد؛ تُدرج المتغيرات الأسماء"), - ("File type", "نوع الملف"), - ("Fill", "تعبئة"), - ("Fill the closed path (lasso)", "تعبئة المسار المغلق (حبل التحديد)"), - ("Fill the path (close it first)", "تعبئة المسار (أغلقه أولاً)"), - ("Filter", "مرشح"), - ("Filter the remaining noise while keeping edges and texture detail", "تصفية الضوضاء المتبقية مع الحفاظ على الحواف وتفاصيل الخامة"), - ("Filters", "مرشحات"), - ("Fine noise", "ضوضاء دقيقة"), - ("Fingerprints", "بصمات أصابع"), - ("Enter a finite number", "أدخل عددًا محدودًا"), - ("Double-click or press Enter to edit", "انقر نقرًا مزدوجًا أو اضغط Enter للتعديل"), - ("Fit the input range to the histogram", "ملاءمة نطاق الإدخال مع المدرج التكراري"), - ("Flatten layer", "تسطيح الطبقة"), - ( - "Flips the image's green channel, for normal maps made with Y pointing down", - "يقلب القناة الخضراء للصورة، لخرائط النواظم المصنوعة ومحور Y يشير إلى الأسفل", - ), - ("Flow", "التدفق"), - ("Flow and opacity", "التدفق والعتامة"), - ("Flow jitter", "اضطراب التدفق"), - ("Focus distance", "مسافة التركيز"), - ("Folder", "مجلد"), - ("Folders", "مجلدات"), - ("Follow path", "اتباع المسار"), - ( - "For the whole project: how normal map images set as mesh maps are read (set them again after a change), and the default for export", - "للمشروع كله: طريقة قراءة صور خرائط النواظم المعيَّنة كخرائط للمجسم (أعد تعيينها بعد التغيير) والقيمة الافتراضية للتصدير", - ), - ("Free and open source (MIT OR Apache-2.0), written in Rust.", "مجاني ومفتوح المصدر (MIT أو Apache-2.0)، كُتب بلغة Rust."), - ("From template", "من قالب"), - ("From template / project", "من قالب / مشروع"), - ("Full", "كامل"), - ("GPU error: {error}", "خطأ في GPU: {error}"), - ("Geometry mask", "قناع هندسي"), - ( - "GGX specular with height-correlated Smith visibility, Lambert diffuse, split-sum image-based lighting with spherical-harmonics irradiance and horizon fading.", - "لمعان GGX مع رؤية سميث المرتبطة بالارتفاع، وانتشار لامبرت، وإضاءة معتمدة على الصور بمجموع مقسم مع إشعاع توافقيات كروية وتلاشي الأفق.", - ), - ("Gamma", "غاما (Gamma)"), - ("General export parameters", "معلمات التصدير العامة"), - ("General properties", "الخصائص العامة"), - ("Generator", "مولّد"), - ("Geometry and UVs only", "الهندسة وإحداثيات UV فقط"), - ("Glossiness", "الصفاء (Glossiness)"), - ("Glossiness from roughness", "الصفاء من الخشونة"), - ("Glow", "توهج"), - ("Gradient", "تدرج لوني"), - ("Gradient Map", "خريطة التدرج"), - ("Gravity", "الجاذبية"), - ("Gray", "رمادي"), - ("Gray + A", "رمادي + A"), - ("Gray 50%", "رمادي 50%"), - ("Grayscale", "تدرج رمادي"), - ("Group layer(s)", "تجميع الطبقة (الطبقات)"), - ("Grunge", "تعتيق (Grunge)"), - ("HDR environments", "بيئات HDR"), - ("High Pass", "تمرير عالي (High Pass)"), - ("HSL Perceptive", "HSL إدراكي"), - ("Half", "نصف"), - ("Hammered", "مطروق"), - ("Hard light", "ضوء ساطع (Hard Light)"), - ("Hardness", "الصلابة"), - ("Height", "الارتفاع"), - ("Height offset", "إزاحة الارتفاع"), - ("Height to normal strength", "قوة تحويل الارتفاع إلى ناظم"), - ("Help", "مساعدة"), - ("Hide UI", "إخفاء واجهة المستخدم"), - ("High", "عالي"), - ("High poly: {name}", "عالي الدقة: {name}"), - ("Highlights", "المناطق المضيئة"), - ("Histogram Range", "نطاق المدرج التكراري"), - ("Histogram Scan", "مسح المدرج التكراري"), - ("Histogram Shift", "إزاحة المدرج التكراري"), - ("History", "السجل"), - ( - "Hold S: left-drag rotates, right-drag scales, middle-drag moves the stencil.", - "استمر بالضغط على S: السحب بالزر الأيسر يدوّر، والأيمن يغيّر الحجم، والأوسط يحرّك الستنسل.", - ), - ("Hold V and click the mesh to set the clone source", "استمر بالضغط على V وانقر على المجسم لتعيين مصدر الاستنساخ"), - ( - "Hold V and click the mesh to set the source, then paint elsewhere to copy it.", - "استمر بالضغط على V وانقر على المجسم لتعيين المصدر، ثم ارسم في مكان آخر لنسخه.", - ), - ( - "How far light travels under the surface, as a fraction of the mesh size (where the Scattering weight channel is painted)", - "المسافة التي ينتقل بها الضوء تحت السطح، كنسبة من حجم المجسم (حيث تُرسَم قناة وزن التشتت)", - ), - ( - "How strongly transmissive surfaces bend light (where the Transmission channel is painted): water 1.33, glass 1.5, diamond 2.42", - "مدى انكسار الضوء في الأسطح النافذة (حيث تُرسَم قناة النفاذية): ماء 1.33، زجاج 1.5، ألماس 2.42", - ), - ("Hue shift (degrees)", "إزاحة تدرج اللون (بالدرجات)"), - ("ID", "المُعرّف (ID)"), - ("Image: {name}", "صورة: {name}"), - ("Images", "صور"), - ("Import HDR...", "استيراد HDR..."), - ("Import a template (.json)", "استيراد قالب (.json)"), - ("Import an image (File > Import resources) to project it onto the mesh.", "استورد صورة (ملف > استيراد الموارد) لإسقاطها على المجسم."), - ("Import images to use them in fills and masks", "استورد الصور لاستخدامها في التعبئة والأقنعة"), - ("Import resources...", "استيراد الموارد..."), - ("Import MaterialX material...", "استيراد مادة MaterialX..."), - ("MaterialX materials", "مواد MaterialX"), - ("Import...", "استيراد..."), - ("Imported template \"{name}\"", "تم استيراد القالب \"{name}\""), - ("Imported {name}", "تم استيراد {name}"), - ("Index of refraction", "معامل الانكسار"), - ("Input high", "المدخل العالي"), - ("Input low", "المدخل المنخفض"), - ("Input maps", "خرائط المدخلات"), - ("Insert a variable", "إدراج متغير"), - ("Instance", "نسخة مرتبطة (Instance)"), - ("Instantiate across texture sets", "إنشاء نسخ مرتبطة عبر مجموعات الخامات"), - ("Intensity (texels at 2K)", "الشدة (تكسل بدقة 2K)"), - ("Interface", "الواجهة"), - ("Interface scale", "مقياس الواجهة"), - ("Inverse Subtract", "طرح عكسي"), - ("Inverse divide", "قسمة عكسية"), - ("Invert", "عكس"), - ("Invert mask", "عكس القناع"), - ("Invert mask background", "عكس خلفية القناع"), - ("Invert mask value", "عكس قيمة القناع"), - ("Invert quick mask", "عكس القناع السريع"), - ("Jitters", "اضطرابات (Jitters)"), - ("Join the ArtCraft community on Discord", "انضم إلى مجتمع ArtCraft على Discord"), - ("Join the community (Discord)...", "الانضمام إلى المجتمع (Discord)..."), - ("Key light (shadow-casting light, direct only)", "الضوء الرئيسي (ضوء ملقي للظلال، مباشر فقط)"), - ("Keyboard", "لوحة المفاتيح"), - ("Keyboard shortcuts", "اختصارات لوحة المفاتيح"), - ("Light azimuth (degrees)", "سمت الضوء (بالدرجات)"), - ("Light elevation (degrees)", "ارتفاع الضوء (بالدرجات)"), - ("Light intensity", "شدة الضوء"), - ("LMB", "زر الفأرة الأيسر"), - ("Language", "اللغة"), - ("Layer mask", "قناع الطبقة"), - ("Layer memory: {mb} MB", "ذاكرة الطبقات: {mb} ميغابايت"), - ("Layers", "الطبقات"), - ("Lazy mouse", "الفأرة الكسولة (Lazy mouse)"), - ("Lazy mouse distance", "مسافة الفأرة الكسولة"), - ("Leather grain", "حبيبات جلدية"), - ("Lens size: how quickly things blur away from the focus distance", "حجم العدسة: سرعة تمويه العناصر البعيدة عن مسافة التركيز"), - ("Level", "المستوى"), - ("Levels", "المستويات"), - ("Lifetime (steps)", "عمر الجسيم (بالخطوات)"), - ("Light / direction", "الضوء / الاتجاه"), - ("Lighten (Max)", "تفتيح (الحد الأقصى)"), - ("Lightness", "الإضاءة"), - ("Linear", "خطي"), - ("Linear burn", "حرق خطي (Linear Burn)"), - ("Linear dodge (Add)", "تفتيح خطي (إضافة)"), - ("Linear light", "ضوء خطي (Linear Light)"), - ("List of exports", "قائمة الصادرات"), - ("Load UI Layout", "تحميل تخطيط الواجهة"), - ("Loaded UI layout {path}", "تم تحميل تخطيط الواجهة {path}"), - ("Log", "السجل"), - ("Low", "منخفض"), - ("Luminosity", "اللمعان (Luminosity)"), - ("MMB drag / Alt + MMB", "سحب بزر الفأرة الأوسط / Alt + زر الفأرة الأوسط"), - ("Made by the ArtCraft team and community.", "صُنع بواسطة فريق ArtCraft والمجتمع."), - ("Magenta / green", "أرجواني / أخضر"), - ("Main shader", "المظلل الرئيسي"), - ("Marble veins", "عروق الرخام"), - ("Mask", "قناع"), - ("Mask Editor: Edge wear", "محرر الأقنعة: تآكل الحواف"), - ("Mask value (gray)", "قيمة القناع (رمادي)"), - ("Mask with height", "قناع بالارتفاع"), - ("MatFinish Grind", "إنهاء المادة: جلخ"), - ("MatFinish Hammered", "إنهاء المادة: مطروق"), - ("MatFinish Raw", "إنهاء المادة: خام"), - ("MatFinish Sanded", "إنهاء المادة: مصنفر"), - ("Material", "المادة"), - ("Material ball", "كرة المادة"), - ("Material finish", "إنهاء المادة"), - ("Materials", "المواد"), - ("Maximum", "الحد الأقصى"), - ("Mesh fill", "تعبئة المجسم"), - ("Mesh map: {map}", "خريطة المجسم: {map}"), - ("Mesh maps", "خرائط المجسم"), - ("Mesh maps baked", "تم خبز خرائط المجسم"), - ("Meshes", "المجسمات"), - ("Metallic", "معدنية"), - ("Midtones", "درجات الإضاءة المتوسطة"), - ("Minimum", "الحد الأدنى"), - ("Minimum size (%)", "الحد الأدنى للحجم (%)"), - ("Missing (bake to create)", "مفقود (اخبز للإنشاء)"), - ("Mixed AO", "انسداد محيطي مختلط"), - ("Mode", "النمط"), - ("More in Assets > Alphas: click one, or drag it here", "المزيد في الأصول > أقنعة ألفا: انقر على واحد، أو اسحبه إلى هنا"), - ("Mosaic", "فسيفساء"), - ("Move down", "تحريك لأسفل"), - ("Move up", "تحريك لأعلى"), - ( - "Moves the surface by the height channel on a finer copy of the mesh, at the height to normal strength (viewport only: painting follows the base surface)", - "يحرك السطح وفق قناة الارتفاع على نسخة أدق من المجسم، بقوة تحويل الارتفاع إلى ناظم (منفذ العرض فقط: الرسم يتبع السطح الأساسي)", - ), - ("Multiply", "ضرب"), - ("My smart materials", "موادي الذكية"), - ("Name", "الاسم"), - ("New project", "مشروع جديد"), - ("New project...", "مشروع جديد..."), - ("New template", "قالب جديد"), - ("No GPU renderer available", "لا يتوفر مصيّر GPU"), - ("No font on this system can show this language", "لا يوجد خط على هذا النظام يمكنه عرض هذه اللغة"), - ("No outputs yet: add one above, then drag input maps onto its channels.", "لا توجد مخرجات بعد: أضف مخرجاً بالأعلى، ثم اسحب خرائط المدخلات إلى قنواته."), - ("No padding (passthrough)", "بدون حشو (تمرير مباشر)"), - ("Noise amount", "كمية الضوضاء"), - ("Noise scale", "مقياس الضوضاء"), - ("None", "بلا"), - ("Normal", "عادي"), - ("Normal DirectX", "ناظم DirectX"), - ("Normal Invert", "عكس الناظم"), - ("Normal OpenGL", "ناظم OpenGL"), - ("Normal from height", "ناظم من الارتفاع"), - ("Normal map combine", "دمج خرائط النواظم"), - ("Normal map detail", "تفاصيل خريطة النواظم"), - ("Color space", "فضاء الألوان"), - ("Normal map format", "صيغة خريطة النواظم"), - ("Normal map inverse detail", "عكس تفاصيل خريطة النواظم"), - ("Normal: painting uses the flat normal", "عادي: يستخدم الرسم الناظم المسطح"), - ( - "Not enough GPU memory to show texture set \"{name}\" fully: lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "لا توجد ذاكرة GPU كافية لعرض مجموعة الخامات \"{name}\" كاملة: خفّض دقة الخامة لمنفذ العرض في الإعدادات. لا يتأثر الرسم والتصدير.", - ), - ( - "Not enough GPU memory to show {count} texture sets fully ({names}): lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "لا توجد ذاكرة GPU كافية لعرض {count} من مجموعات الخامات كاملة ({names}): خفّض دقة الخامة لمنفذ العرض في الإعدادات. لا يتأثر الرسم والتصدير.", - ), - ("Not exported: no source in this texture set", "لم يتم التصدير: لا يوجد مصدر في مجموعة الخامات هذه"), - ("Not saved: {error}", "لم يتم الحفظ: {error}"), - ("Off", "معطل"), - ("Offset", "إزاحة"), - ("Offset right", "إزاحة لليمين"), - ("Offset up", "إزاحة لأعلى"), - ("Offset {axis}", "إزاحة {axis}"), - ("Offsets the textures by the height channel, at the height to normal strength", "يزيح الخامات وفق قناة الارتفاع، بقوة تحويل الارتفاع إلى ناظم"), - ("On", "مفعل"), - ("Opacity", "العتامة"), - ("Open sample project...", "فتح مشروع نموذجي..."), - ("Open...", "فتح..."), - ("Opened {name}", "تم فتح {name}"), - ( - "Optional channels add a clear coat (Coat weight, Coat roughness, Coat normal), sheen (Sheen weight, color, roughness), anisotropy (Anisotropy level, angle), subsurface scattering (Scattering weight) and transmission (Transmission).", - "تضيف القنوات الاختيارية طبقة طلاء شفافة (وزن الطلاء، خشونة الطلاء، ناظم الطلاء)، ولمعاناً (وزن اللمعان، لونه، خشونته)، وتباين الخواص (مستوى التباين، زاويته)، وتشتتاً تحت السطح (وزن التشتت)، ونفاذية (النفاذية).", - ), - ("Orbit", "مدار"), - ("Orthographic", "متوازي (إملائي)"), - ("Perspective", "منظوري"), - ("Output directory", "دليل الإخراج"), - ("Output high", "المخرج العالي"), - ("Output low", "المخرج المنخفض"), - ("Output template", "قالب الإخراج"), - ("Output templates", "قوالب الإخراج"), - ("Overlay", "تراكب (Overlay)"), - ("Overlay opacity", "عتامة التراكب"), - ("PBR - Metallic Roughness (TextureCraft)", "PBR - خشونة ومعدنية (TextureCraft)"), - ("Pick color", "التقاط لون"), - ("PNG image", "صورة PNG"), - ("Padding", "الحشو (Padding)"), - ("Paint", "رسم"), - ("Paint chips", "قشور الطلاء"), - ("Paint on the mesh to edit the layer content.", "ارسم على المجسم لتعديل محتوى الطبقة."), - ( - "Paint on the mesh to edit this mask. Use the Material tab's mask value for gray.", - "ارسم على المجسم لتعديل هذا القناع. استخدم قيمة القناع في لسان تبويب المادة للتدرج الرمادي.", - ), - ("Paint with the current tool", "الرسم بالأداة الحالية"), - ( - "Painted layer pixels {pixels} MB, composited channels {composites} MB, compositing cache {cache} MB", - "بكسلات الطبقات المرسومة {pixels} ميغابايت، القنوات المركبة {composites} ميغابايت، ذاكرة التخزين المؤقت للتركيب {cache} ميغابايت", - ), - ("Painting", "الرسم"), - ("Pan", "تحريك العرض (Pan)"), - ("Parallax occlusion (height channel)", "إزاحة المنظور (قناة الارتفاع)"), - ("Partial mask values follow the layer's height: high parts show first", "قيم القناع الجزئية تتبع ارتفاع الطبقة: تظهر الأجزاء المرتفعة أولاً"), - ("Particle brush (slides down the surface)", "فرشاة الجسيمات (تنزلق على السطح)"), - ("Particle brush: particles slide down the surface", "فرشاة الجسيمات: تنزلق الجسيمات على السطح"), - ("Particles", "جسيمات"), - ("Passthrough", "تمرير مباشر (Passthrough)"), - ("Paste as instance", "لصق كنسخة مرتبطة (Instance)"), - ("Paste effect", "لصق التأثير"), - ("Paste layer(s)", "لصق الطبقة (الطبقات)"), - ("Path", "مسار"), - ("Path trace on the processor instead of the graphics card (slower)", "تتبع المسار على المعالج بدلاً من بطاقة الرسوميات (أبطأ)"), - ( - "Path: click adds a point, click the curve inserts one, drag moves it, Enter applies, Esc cancels", - "المسار: النقر يضيف نقطة، والنقر على المنحنى يُدرج نقطة، والسحب يحركها، وEnter يطبق، وEsc يلغي", - ), - ("Pattern scale", "مقياس النمط"), - ("Perlin noise", "ضوضاء بيرلن (Perlin)"), - ("Pick focus in the viewport", "اختر نقطة التركيز في منفذ العرض"), - ("Pin light", "ضوء مثبت (Pin Light)"), - ("Place on the surface", "وضع على السطح"), - ("Place path points on the mesh", "وضع نقاط المسار على المجسم"), - ("Planar projection", "إسقاط مستوٍ"), - ("Plane", "مستوٍ"), - ("Polygon fill", "تعبئة مضلع"), - ("Pores", "مسام"), - ("Position", "الموضع"), - ("Position gradient", "تدرج الموضع"), - ("Position jitter", "اضطراب الموضع"), - ("Posterize", "تبسيط الألوان (Posterize)"), - ("Press a key...", "اضغط على مفتاح..."), - ("Procedurals", "إجرائيات"), - ("Project", "المشروع"), - ("Project Configuration...", "تكوين المشروع..."), - ("Project opened", "تم فتح المشروع"), - ("Project template", "قالب المشروع"), - ("Projection", "الإسقاط"), - ("Projects and meshes", "المشاريع والمجسمات"), - ("Properties", "الخصائص"), - ("Quarter", "ربع"), - ("Quick mask", "قناع سريع"), - ("Quit", "إنهاء"), - ("Radius (texels at 2K)", "نصف القطر (تكسل بدقة 2K)"), - ("RENDERING", "التصيير"), - ("Range", "النطاق"), - ("Rebind any menu item, tool or command", "إعادة ربط أي عنصر قائمة، أو أداة أو أمر"), - ("Recent projects", "المشاريع الأخيرة"), - ( - "Records the stack up to this layer. Fill effects in masks (and fill layers) above can read it as a source.", - "يسجل المكدس حتى هذه الطبقة. يمكن لتأثيرات التعبئة في الأقنعة (وطبقات التعبئة) بالأعلى قراءته كمصدر.", - ), - ("Redo", "إعادة"), - ("Reimport mesh", "إعادة استيراد المجسم"), - ("Remove", "إزالة"), - ("Remove channel", "إزالة القناة"), - ("Remove effect", "إزالة التأثير"), - ("Remove last", "إزالة الأخير"), - ("Remove layer", "إزالة الطبقة"), - ("Remove layer(s)", "إزالة الطبقة (الطبقات)"), - ("Remove mask", "إزالة القناع"), - ("Remove point", "إزالة النقطة"), - ("Remove resource", "إزالة المورد"), - ("Remove the shortcut", "إزالة الاختصار"), - ("Remove this output", "إزالة هذا المخرج"), - ("Remove unused resources...", "إزالة الموارد غير المستخدمة..."), - ("Rename the selected template", "إعادة تسمية القالب المحدد"), - ("Render on the CPU", "التصيير على المعالج (CPU)"), - ("Rendering", "التصيير"), - ("Rendering (path traced)", "التصيير (بتتبع المسار)"), - ("Rendering on CPU: {n} / {max} samples, {s} s", "التصيير على المعالج (CPU): {n} / {max} عينة، {s} ث"), - ("Rendering on GPU: {n} / {max} samples, {s} s", "التصيير على المعالج الرسومي (GPU): {n} / {max} عينة، {s} ث"), - ("Rendering, path traced", "التصيير، بتتبع المسار"), - ("Replace", "استبدال"), - ("Replace Color", "استبدال اللون"), - ("Replacement color", "لون الاستبدال"), - ("Report a bug...", "الإبلاغ عن خطأ..."), - ("Rescan the library folder", "إعادة فحص مجلد المكتبة"), - ("Reset", "إعادة تعيين"), - ("Reset UI", "إعادة ضبط واجهة المستخدم"), - ("Reset all", "إعادة ضبط الكل"), - ("Reset to defaults", "إعادة الضبط إلى الإعدادات الافتراضية"), - ("Reset to {shortcut}", "إعادة الضبط إلى {shortcut}"), - ("Resizing", "تغيير الحجم"), - ("Restore every default shortcut", "استعادة كل الاختصارات الافتراضية"), - ("Return to this step", "العودة إلى هذه الخطوة"), - ("Right-click a layer > Create smart material", "انقر بزر الفأرة الأيمن على طبقة > إنشاء مادة ذكية"), - ("Rotation", "التدوير"), - ("Rotation (degrees)", "التدوير (بالدرجات)"), - ("Roughness", "الخشونة"), - ("Roughness from glossiness", "الخشونة من الصفاء"), - ("Round", "دائري"), - ("Rounded cube", "مكعب مدور الزوايا"), - ("Samples", "العينات"), - ("Saturation", "التشبع"), - ("Save", "حفظ"), - ("Save UI Layout", "حفظ تخطيط الواجهة"), - ("Save a copy...", "حفظ نسخة..."), - ("Save as...", "حفظ باسم..."), - ("Save current layout...", "حفظ التخطيط الحالي..."), - ("Save render...", "حفظ التصيير..."), - ("Save view as camera", "حفظ المنظور ككاميرا"), - ("Saved UI layout {path}", "تم حفظ تخطيط الواجهة {path}"), - ("Saved {path}", "تم الحفظ في {path}"), - ("Saving UI layouts to files is available in the desktop app", "حفظ تخطيطات الواجهة إلى ملفات متاح في تطبيق سطح المكتب"), - ("Scale", "المقياس"), - ("Scale / tiling", "المقياس / التكرار"), - ("Scatter color", "لون التشتت"), - ("Scatter radius", "نصف قطر التشتت"), - ("Scattering weight", "وزن التشتت"), - ("Scratches", "خدوش"), - ("Screen", "شاشة (Screen)"), - ("Screenshot of the viewport", "لقطة شاشة لمنفذ العرض"), - ("Search", "بحث"), - ("Search all assets", "البحث في جميع الأصول"), - ("Search commands or keys", "البحث في الأوامر أو المفاتيح"), - ("Seed", "البذرة العشوائية (Seed)"), - ("Select a layer", "تحديد طبقة"), - ("Select an output template", "تحديد قالب إخراج"), - ("Select source", "تحديد المصدر"), - ("Select the mask (Alt+click: show it in the viewport)", "تحديد القناع (Alt+نقر: عرضه في منفذ العرض)"), - ("Select...", "تحديد..."), - ("Settings", "الإعدادات"), - ("Settings...", "الإعدادات..."), - ("Shader Settings", "إعدادات المظلل"), - ("Shader instance", "نسخة المظلل"), - ("Shadows", "الظلال"), - ("Sharpen", "توضيح الحواف (Sharpen)"), - ("Sheen color", "لون اللمعان"), - ("Sheen color × weight", "لون اللمعان × الوزن"), - ("Sheen roughness", "خشونة اللمعان"), - ("Sheen weight", "وزن اللمعان"), - ("Shift + wheel", "Shift + عجلة الفأرة"), - ("Shortcuts list...", "قائمة الاختصارات..."), - ("Show on all parts", "إظهار على جميع الأجزاء"), - ("Show UV wireframe in the 2D view", "إظهار الهيكل السلكي لـ UV في العرض ثنائي الأبعاد"), - ("Show entire mesh", "إظهار المجسم كاملاً"), - ("Show log...", "إظهار السجل..."), - ("Show or hide the layer", "إظهار أو إخفاء الطبقة"), - ("Show or hide the texture set", "إظهار أو إخفاء مجموعة الخامات"), - ("Show wireframe in the 3D view", "إظهار الهيكل السلكي في العرض ثلاثي الأبعاد"), - ("Signed addition (AddSub)", "جمع ذو إشارة (AddSub)"), - ("Size", "الحجم"), - ("Size in screen space", "الحجم في فضاء الشاشة"), - ("Size jitter", "اضطراب الحجم"), - ( - "Size of the textures the viewport shows: lower uses less GPU memory with large texture sets. Painting and export keep full resolution.", - "حجم الخامات التي يعرضها منفذ العرض: الحجم الأصغر يستهلك ذاكرة GPU أقل مع مجموعات الخامات الكبيرة. يحتفظ الرسم والتصدير بالدقة الكاملة.", - ), - ("Slope Blur", "تمويه المنحدر (Slope Blur)"), - ("Slope scale", "مقياس المنحدر"), - ("Smart masks", "أقنعة ذكية"), - ("Smart material saved to {path}", "تم حفظ المادة الذكية في {path}"), - ("Smart materials", "مواد ذكية"), - ("Smudge", "تلطيخ (Smudge)"), - ("Soft light", "ضوء خافت (Soft Light)"), - ("Softness", "النعومة"), - ("Source", "المصدر"), - ("Source U {u} V {v}", "المصدر U {u} V {v}"), - ("Spacing", "التباعد"), - ("Specular", "اللمعان (Specular)"), - ("Specular level", "مستوى اللمعان"), - ("Sphere", "كرة"), - ("Spherical projection", "إسقاط كروي"), - ("Spray", "رش (Spray)"), - ("Square", "مربع"), - ("Stamp depth", "عمق الطبعة"), - ("Star", "نجمة"), - ("Starting render...", "بدء التصيير..."), - ("Stencil", "ستنسل (Stencil)"), - ("Steps", "الخطوات"), - ("Streaks", "خطوط"), - ("Strength", "القوة"), - ("Stripes", "أشرطة"), - ("Stroke opacity", "عتامة الضربة"), - ("Subsampling 2x2", "استعيان فرعي 2×2"), - ("Subsampling 4x4", "استعيان فرعي 4×4"), - ("Subsampling 8x8", "استعيان فرعي 8×8"), - ("Subsurface scattering", "تشتت تحت السطح (SSS)"), - ("Subtract", "طرح"), - ("Tangent | Wrap", "مماس | التفاف"), - ("Temporal anti-aliasing (refines the 3D view while it is still)", "تنعيم حواف زمني (يحسّن العرض ثلاثي الأبعاد أثناء ثباته)"), - ("Texture Sets", "مجموعات الخامات"), - ("Texture Set Settings", "إعدادات مجموعة الخامات"), - ("Texture resolution", "دقة الخامة"), - ("Texture set channels", "قنوات مجموعة الخامات"), - ("Texture sets", "مجموعات الخامات"), - ("TextureCraft had to close:", "اضطر TextureCraft إلى الإغلاق:"), - ("TextureCraft PBR - Metallic Roughness", "TextureCraft PBR - خشونة ومعدنية"), - ("TextureCraft PBR - Specular Glossiness", "TextureCraft PBR - لمعان وصفاء"), - ("TextureCraft project", "مشروع TextureCraft"), - ("TextureCraft project or mesh", "مشروع أو مجسم TextureCraft"), - ("Textures", "الخامات"), - ("Textures embedded; for game engines and most viewers", "الخامات مدمجة؛ لمحركات الألعاب ومعظم برامج العرض"), - ("Textures packaged; for USD tools and AR Quick Look", "الخامات محزومة؛ لأدوات USD وميزة المعاينة السريعة للواقع المعزز"), - ("The GPU couldn't render this scene: {error}", "تعذر على معالج الرسوميات (GPU) تصيير هذا المشهد: {error}"), - ("The bake worker stopped", "توقف عامل الخبز"), - ("The eraser removes paint from the enabled channels.", "تزيل الممحاة الطلاء من القنوات الممكنة."), - ("The first stroke sets the offset from the source.", "تحدد الضربة الأولى الإزاحة عن المصدر."), - ( - "The image's alpha cuts the decal's shape; faces turned away and surfaces beyond its depth stay clear.", - "تقطع ألفا الصورة شكل الملصق؛ وتبقى الوجوه المتجهة بعيداً والأسطح التي تتجاوز عمقها واضحة.", - ), - ("The next click in the 3D view moves the decal there", "النقر التالي في العرض ثلاثي الأبعاد ينقل الملصق إلى هناك"), - ("The resize worker stopped", "توقف عامل تغيير الحجم"), - ("Thickness", "السماكة"), - ("Thin areas", "المناطق الرقيقة"), - ("Threshold", "العتبة (Threshold)"), - ("Tile", "تكرار (Tile)"), - ("Tiles", "بلاطات"), - ("Tint", "صبغة"), - ("Toggle mask", "تبديل القناع"), - ("Tolerance", "التفاوت (Tolerance)"), - ("Tone mapping", "مطابقة درجات الألوان (Tone mapping)"), - ("Tools", "الأدوات"), - ("Torus", "طارة (Torus)"), - ("Transmission", "النفاذية (Transmission)"), - ("Tri-planar projection", "إسقاط ثلاثي المستويات (Tri-planar)"), - ("Triangle fill", "تعبئة مثلث"), - ("UDIM plane", "مستوي UDIM"), - ("UDIM tiles painted by this texture set, each at the set's size", "بلاطات UDIM المرسومة بمجموعة الخامات هذه، كل منها بحجم المجموعة"), - ("UI layout", "تخطيط الواجهة"), - ("UI layout: {error}", "تخطيط الواجهة: {error}"), - ("UI layouts", "تخطيطات الواجهة"), - ("UI {ms} ms", "واجهة المستخدم {ms} مللي ثانية"), - ("USD binary, textures alongside", "USD ثنائي، الخامات بجانبه"), - ("USD text, textures alongside", "USD نصي، الخامات بجانبه"), - ("USDZ with textures", "USDZ مع الخامات"), - ("UV checker", "رقعة فحص UV"), - ("UV island fill", "تعبئة جزيرة UV"), - ("UV transformations", "تحويلات UV"), - ("UV projection", "إسقاط UV"), - ("UV tiles", "بلاطات UV"), - ("UV tiles (UDIM)", "بلاطات UV (UDIM)"), - ("Undo", "تراجع"), - ("Uniform value", "قيمة موحدة"), - ("Use an equirectangular .hdr or .exr image as the environment", "استخدم صورة .hdr أو .exr متساوية المستطيلات كبيئة"), - ("Use the control channel or `texturecraft-cli render` for screenshots", "استخدم قناة التحكم أو الأمر `texturecraft-cli render` لالتقاط لقطات الشاشة"), - ("Value", "القيمة"), - ("Version {version}", "الإصدار {version}"), - ("Version: {version} ({gpu})", "الإصدار: {version} ({gpu})"), - ("View through this camera", "الرؤية من خلال هذه الكاميرا"), - ("Viewer settings", "إعدادات العارض"), - ("Viewport", "منفذ العرض"), - ("Viewport and brush (fixed)", "منفذ العرض والفرشاة (ثابت)"), - ("Views", "طرق العرض"), - ("Vivid light", "ضوء ساطع (Vivid Light)"), - ("Voronoi", "فورونوي (Voronoi)"), - ("Warp", "التواء (Warp)"), - ("Warp Directional", "التواء اتجاهي"), - ("Wavefront OBJ with MTL, textures alongside", "Wavefront OBJ مع MTL، والخامات بجانبه"), - ( - "WebGPU isn't available in this browser, so TextureCraft runs on WebGL2: Rendering mode path traces on the CPU (slower) and large texture sets show at reduced resolution. A current Chrome, Edge or Safari has WebGPU.", - "WebGPU غير متاح في هذا المتصفح، لذا يعمل TextureCraft على WebGL2: نمط التصيير يتتبع المسار على المعالج (أبطأ) ومجموعات الخامات الكبيرة تظهر بدقة مخفضة. يتوفر WebGPU في الإصدارات الحديثة من Chrome وEdge وSafari.", - ), - ("Wheel / Alt + RMB drag", "العجلة / سحب بـ Alt + زر الفأرة الأيمن"), - ("White", "أبيض"), - ("Width", "العرض"), - ("Width (texels at 2K)", "العرض (تكسل بدقة 2K)"), - ("Window", "نافذة"), - ("Wood grain", "حبيبات الخشب"), - ("Works in texture space, like the blur: it does not cross UV seams.", "يعمل في فضاء الخامات، مثل التمويه: لا يعبر درزات UV."), - ("World Space Normal", "ناظم الفضاء العالمي"), - ("Yellow / blue", "أصفر / أزرق"), - ("Zoom", "تكبير/تصغير"), - ("a missing layer", "طبقة مفقودة"), - ("aniso", "تباين"), - ("aniso angle", "زاوية التباين"), - ("ao", "انسداد محيطي"), - ("coat", "طلاء"), - ("coat nrm", "ناظم الطلاء"), - ("coat rough", "خشونة الطلاء"), - ("color", "لون"), - ("emiss", "إشعاع"), - ("glTF binary with textures", "glTF ثنائي مع الخامات"), - ("gloss", "صفاء"), - ("height", "ارتفاع"), - ("metal", "معدن"), - ("min", "د"), - ("missing", "مفقود"), - ("missing source", "مصدر مفقود"), - ("no GPU", "بدون GPU"), - ("none", "بلا"), - ("nrm", "ناظم"), - ("off", "معطل"), - ("op", "عتامة"), - ("rough", "خشونة"), - ("scatter", "تشتت"), - ("sheen", "لمعان"), - ("sheen color", "لون اللمعان"), - ("sheen rough", "خشونة اللمعان"), - ("spec", "لمعان"), - ("specular", "لمعان"), - ("transm", "نفاذية"), - ("{action} (undone)", "{action} (تم التراجع)"), - ( - "{file}: add above the selected layer (or drag it into the layer stack or onto the viewport)", - "{file}: إضافة فوق الطبقة المحددة (أو اسحبها إلى مكدس الطبقات أو إلى منفذ العرض)", - ), - ("{name} copy", "نسخة من {name}"), - ("{n} bits", "{n} بت"), - ( - "{n} control points. Click the mesh (or the 2D view) to add points and drag them to adjust; click the first point to close the path. Enter paints it with the brush (a closed, filled path fills its inside), Esc cancels.", - "{n} نقاط تحكم. انقر على المجسم (أو العرض ثنائي الأبعاد) لإضافة نقاط واسحبها للضبط؛ وانقر على النقطة الأولى لإغلاق المسار. مفتاح Enter يرسمه بالفرشاة (المسار المغلق والمملوء يملأ داخله)، وEsc يلغي.", - ), - ("{n} items share a shortcut; the first one listed wins.", "{n} عناصر تشترك في نفس الاختصار؛ العنصر الأول المدرج له الأولوية."), - ("{pattern} (scale {scale}, seed {seed})", "{pattern} (المقياس {scale}، البذرة {seed})"), - ("Template name", "اسم القالب"), - ("Save current project as template", "حفظ المشروع الحالي كقالب"), - ("Distribution", "التوزيع"), - ("Cosine", "جيب التمام (Cosine)"), - ("Uniform", "موحد (Uniform)"), - ("Normalization", "تسوية (Normalization)"), - ("Brightness", "السطوع"), - ("Dark", "داكن"), - ("Medium dark", "متوسط الدكنة"), - ("Medium light", "متوسط السطوع"), - ("Light", "فاتح"), - ("Accent color", "لون التمييز"), - ("Copper", "نحاسي"), - ("Coral", "مرجاني"), - ("Blue", "أزرق"), - ("Violet", "بنفسجي"), - ("Green", "أخضر"), - ("Amber", "كهرماني"), - ("Pink", "وردي"), - ("Minimize", "تصغير"), - ("Maximize", "تكبير"), - ("Restore", "استعادة"), - ("Title bar", "شريط العنوان"), - ("System title bar (applies on restart)", "شريط عنوان النظام (يُطبّق عند إعادة التشغيل)"), - ( - "Use the operating system's window frame and buttons instead of TextureCraft's own title bar", - "استخدام إطار وأزرار نافذة نظام التشغيل بدلاً من شريط عنوان TextureCraft الخاص", - ), - ("Brushes", "الفرش"), - ("My brushes", "فرشي"), - ("Use this brush (keeps its size)", "استخدام هذه الفرشاة (مع الحفاظ على حجمها)"), - ("Brush name", "اسم الفرشاة"), - ("Save current brush", "حفظ الفرشاة الحالية"), - ("Start window", "نافذة البدء"), - ("Show at startup", "إظهار عند بدء التشغيل"), - ("Continue with the sample project", "المتابعة مع المشروع النموذجي"), - ("No recent projects yet", "لا توجد مشاريع حديثة بعد"), - ("Text", "نص"), - ("Font", "الخط"), - ("Style", "النمط"), - ("Use as brush alpha", "استخدام كألفا للفرشاة"), - ("Place as decal", "وضع كملصق"), - ("Click: turn this channel on or off. Alt+click: this channel only", "انقر: تشغيل هذه القناة أو إيقافها. Alt+نقر: هذه القناة فقط"), - ("Show all", "إظهار الكل"), - ("Hide all", "إخفاء الكل"), - ("Invert show/hide", "عكس الإظهار/الإخفاء"), - ("Show or hide texture sets", "إظهار مجموعات الخامات أو إخفاؤها"), - ("Focus: show only the active texture set", "تركيز: إظهار مجموعة الخامات النشطة فقط"), - ("Unsaved changes", "تغييرات غير محفوظة"), - ("Don't save", "عدم الحفظ"), - ("Save the changes to {name} before closing?", "هل تريد حفظ التغييرات في {name} قبل الإغلاق؟"), - ("Radius", "نصف القطر"), - ("Remove skew correction", "إزالة تصحيح الانحراف"), - ("Twill weave", "نسيج مائل"), - ("Save the changes to {name} first?", "هل تريد حفظ التغييرات في {name} أولًا؟"), - ( - "Paths stay editable: pick one to move its points or change its brush and material, and the sublayer repaints at once. Add paths with the Path tool.", - "تبقى المسارات قابلة للتعديل: اختر مسارًا لتحريك نقاطه أو تغيير فرشاته ومادته، فتُعاد رسم الطبقة الفرعية فورًا. أضف المسارات بأداة المسار.", - ), - ("Import material...", "استيراد خامة..."), - ("MaterialCraft material", "خامة MaterialCraft"), - ("Cooked at {size} px", "حُسبت بدقة {size} بكسل"), - ("Preset", "إعداد مسبق"), - ("Re-cook", "إعادة الحساب"), - ("Open in MaterialCraft", "فتح في MaterialCraft"), - ( - "Opened in MaterialCraft: use File > Send to TextureCraft there to bring your changes back", - "فُتحت في MaterialCraft: استخدم هناك ملف > إرسال إلى TextureCraft لإعادة تغييراتك", - ), - ("Parameters change in the desktop app, with MaterialCraft installed", "تتغير المعلمات في تطبيق سطح المكتب مع تثبيت MaterialCraft"), - ("Add High-Poly Meshes", "إضافة مجسمات عالية التفاصيل"), - ("All", "الكل"), - ("Apply Diffusion", "تطبيق الانتشار"), - ("Attenuation", "التوهين"), - ("Auto Tonemapping", "تعيين درجات الألوان تلقائيًا"), - ("Average Normals", "توسيط النواظم"), - ("BBox", "صندوق الإحاطة"), - ("BSphere", "كرة الإحاطة"), - ("Mesh Map Bakers", "مُخبِزات خرائط المجسم"), - ("Common Settings", "الإعدادات المشتركة"), - ("Mesh Map Settings", "إعدادات خرائط المجسم"), - ("Check All", "تحديد الكل"), - ("No Parameters", "لا توجد معلمات"), - ("Bake Selected Textures ({n})", "خبز الخامات المحددة ({n})"), - ("By Mesh Name", "حسب اسم المجسم"), - ("Cage", "القفص"), - ("Cage Scene", "مشهد القفص"), - ("Cage Type", "نوع القفص"), - ("Color Generator", "مولد الألوان"), - ("Color Source", "مصدر اللون"), - ("Common Parameters", "المعلمات المشتركة"), - ("Custom File", "ملف مخصص"), - ("Details", "التفاصيل"), - ("Dilation Width", "عرض التمديد"), - ("Distance-Based", "حسب المسافة"), - ("Edge Contrast", "تباين الحواف"), - ("Edge Distance", "مسافة الحواف"), - ("Edge Protection", "حماية الحواف"), - ("Enable Seams", "تفعيل الوصلات"), - ("File ID", "معرّف الملف"), - ("Full Scene", "المشهد الكامل"), - ("Generate from Mesh", "إنشاء من المجسم"), - ("Generate from Normal Map", "إنشاء من خريطة المتجهات العمودية"), - ("Ground Plane", "مستوى الأرض"), - ("Ground Plane Offset", "إزاحة مستوى الأرض"), - ("High Poly Mesh Suffix", "لاحقة المجسم عالي الدقة"), - ("High Poly Scene", "مشهد عالي التفاصيل"), - ("High-Poly Parameters", "معلمات المجسم عالي التفاصيل"), - ("Hue Shift", "إزاحة تدرج اللون"), - ("Ignore Backface", "تجاهل الوجه الخلفي"), - ("Ignore Backface Suffix", "لاحقة تجاهل الوجه الخلفي"), - ("Include in Bake", "تضمين في الخبز"), - ("Load Cage", "تحميل القفص"), - ("Lock Output Size", "قفل حجم الإخراج"), - ("Low Poly Mesh Suffix", "لاحقة المجسم منخفض الدقة"), - ("Manual", "يدوي"), - ("Material Color", "لون المادة"), - ("Max Frontal Distance", "أقصى مسافة أمامية"), - ("Max Occluder Distance", "أقصى مسافة للحاجب"), - ("Max Rear Distance", "أقصى مسافة خلفية"), - ("Mesh ID", "معرّف المجسم"), - ("Method", "الطريقة"), - ("Min Occluder Distance", "أدنى مسافة للحاجب"), - ("Never", "أبدًا"), - ("No High-Poly Meshes", "لا توجد مجسمات عالية التفاصيل"), - ("Normalization Scale", "نطاق التطبيع"), - ("Normalization Type", "نوع التطبيع"), - ("Only Same Mesh Name", "نفس اسم المجسم فقط"), - ("Output Size", "حجم المخرج"), - ("Match", "المطابقة"), - ("Skew Correction Method", "طريقة تصحيح الانحراف"), - ("Mesh Normals Based", "استنادًا إلى متجهات الشبكة العمودية"), - ("Face Normals Based", "استنادًا إلى متجهات الأوجه العمودية"), - ("Reset Painted Cage", "إعادة تعيين القفص المرسوم"), - ("Paint Cage", "رسم القفص"), - ("Paint Skew Correction", "رسم تصحيح الميل"), - ("Per Material", "لكل مادة"), - ("Random", "عشوائي"), - ("Relative to Bounding Box", "بالنسبة إلى صندوق الإحاطة"), - ("Relative to Low Mesh", "بالنسبة إلى المجسم منخفض التفاصيل"), - ("Relative to Min/Max", "بالنسبة إلى الحد الأدنى والأقصى"), - ("Relative to Ray Distances", "بالنسبة إلى مسافات الأشعة"), - ("Remove Cage", "إزالة القفص"), - ("Remove Skew Correction", "إزالة تصحيح الانحراف"), - ("Restore Defaults", "استعادة الإعدادات الافتراضية"), - ("Return to Painting Mode", "العودة إلى نمط الرسم"), - ("Sampling Radius", "نصف قطر العينات"), - ("Scaling Divisor", "قاسم المقياس"), - ("Seams Intensity", "شدة الوصلات"), - ("Secondary Rays", "أشعة ثانوية"), - ("Self Intersection", "التقاطع الذاتي"), - ("Self Occlusion", "انسداد ذاتي"), - ("Skew Correction", "تصحيح الانحراف"), - ("Smooth", "ناعم"), - ("Spread Angle", "زاوية الانتشار"), - ("Submesh", "مجسم فرعي"), - ("Use Low Poly Mesh as High Poly Mesh", "استخدام المجسم منخفض الدقة كمجسم عالي الدقة"), - ("Value Bounds Max", "الحد الأقصى للقيمة"), - ("Value Bounds Min", "الحد الأدنى للقيمة"), - ("Vertex Color", "لون الرأس"), - ("Select the layer content", "تحديد محتوى الطبقة"), - ("Paint layer", "طبقة رسم"), - ("Fill layer", "طبقة تعبئة"), - ("1 effect", "تأثير واحد"), - ("{count} effects", "{count} تأثيرات"), - ("Mask effects", "تأثيرات القناع"), - ("Content effects", "تأثيرات المحتوى"), - ("Fold or unfold these effects", "طيّ هذه التأثيرات أو فردها"), - ("Remove resolution override", "إزالة تجاوز الدقة"), - ("Texture set resolution", "دقة مجموعة الخامات"), - ("UV tile {tile} resolution", "دقة بلاطة UV {tile}"), - ("Angle span", "مدى الزاوية"), - ("Axis position", "موضع المحور"), - ("Count", "العدد"), - ("Display", "العرض"), - ("Hide while painting", "إخفاء أثناء الرسم"), - ("Manipulator size", "حجم أداة التحريك"), - ("Mirror symmetry", "تناظر مرآوي"), - ("Radial settings", "إعدادات التناظر الدائري"), - ("Radial symmetry", "تناظر دائري"), - ("Show axis", "إظهار المحور"), - ("Show axis position manipulator", "إظهار أداة تحريك موضع المحور"), - ("Show cursor", "إظهار المؤشر"), - ("Show intersection", "إظهار التقاطع"), - ("Show plane", "إظهار المستوى"), - ("Symmetry", "التناظر"), - ("Symmetry color display", "لون عرض التناظر"), - ("Symmetry settings", "إعدادات التناظر"), - ("Type", "النوع"), - ("Advanced settings", "إعدادات متقدمة"), - ("Import baked maps", "استيراد خرائط مخبوزة"), - ("Name each file after its texture set, like Body_normal.png", "سمِّ كل ملف باسم مجموعة الخامات الخاصة به، مثل Body_normal.png"), - ("Add...", "إضافة..."), - ("Baked maps imported: {count}", "الخرائط المخبوزة المستوردة: {count}"), - ("Not imported: {files}", "لم يتم استيرادها: {files}"), - ("Baking Visualization", "تصور الخبز"), - ("Show for Selected Texture Set Only", "العرض لمجموعة الخامات المحددة فقط"), - ("High Definition Mesh (HP)", "المجسم عالي الدقة (HP)"), - ("UV Seams", "فواصل UV"), - ("Project Mesh (LP)", "مجسم الإسقاط (LP)"), - ("Edges", "الحواف"), - ("Cavities", "التجاويف"), - ("Edges and cavities", "الحواف والتجاويف"), - ("Raw curvature", "الانحناء الخام"), - ("Detail sizes", "أحجام التفاصيل"), - ( - "Reads the curvature map as baked: changing the mode or a size turns detail sizes on.", - "يقرأ خريطة الانحناء كما خُبزت: تغيير الوضع أو أحد الأحجام يفعّل أحجام التفاصيل.", - ), - ( - "A click fills what is under it; a dragged rectangle fills what it selects as it grows", - "النقرة تملأ ما تحتها، والمستطيل المسحوب يملأ ما يحدده أثناء اتساعه", - ), - ("Contained center: fill polygons whose center is in the rectangle", "المركز المحتوى: تعبئة المضلعات التي يقع مركزها داخل المستطيل"), - ("Editing the quick mask: fills paint where painting is allowed. Press U to finish.", "تحرير القناع السريع: ترسم التعبئات حيث يُسمح بالرسم. اضغط U للإنهاء."), - ("Fill mode", "وضع التعبئة"), - ("Fill only polygons the camera sees (3D view)", "تعبئة المضلعات التي تراها الكاميرا فقط (العرض ثلاثي الأبعاد)"), - ("Hit-test", "اختبار الإصابة"), - ("How a rectangle selects polygons", "كيف يحدد المستطيل المضلعات"), - ("Intersection: fill polygons the rectangle touches", "التقاطع: تعبئة المضلعات التي يلمسها المستطيل"), - ("Rectangle fill", "تعبئة مستطيلة"), - ("Select a paint layer or a layer's mask to fill", "حدد طبقة رسم أو قناع طبقة للتعبئة"), - ("Selection mode", "وضع التحديد"), - ( - "Triangle fills single triangles, Polygon whole quads and n-gons, Mesh the connected geometry, UV island the UV islands", - "المثلث يملأ مثلثات منفردة، والمضلع رباعيات ومضلعات كاملة، والمجسم الهندسة المتصلة، وجزيرة UV جزر UV", - ), - ("Visible polygons only", "المضلعات المرئية فقط"), - ("\"{layer}\" can't be filled: select a paint layer or a layer's mask", "\"{layer}\" لا يمكن تعبئتها: حدد طبقة رسم أو قناع طبقة"), - ("The file dialog couldn't be shown: {error}", "تعذر عرض نافذة الملفات: {error}"), - ("The project changed while the dialog was open, so nothing was done", "تغيّر المشروع أثناء فتح النافذة، لذا لم يُنفَّذ أي إجراء"), - ("Cores kept for the UI", "أنوية محجوزة للواجهة"), - ("Max RAM while saving", "أقصى ذاكرة عند الحفظ"), - ( - "Saving uses the other cores and at most this share of the free RAM. At least one core always works.", - "يستخدم الحفظ الأنوية الأخرى وحدًا أقصى بهذه النسبة من الذاكرة الحرة. يعمل نواة واحدة على الأقل دائمًا.", - ), - ("Max project size on open", "الحد الأقصى لحجم المشروع عند الفتح"), - ( - "Maximum decompressed project data. Increase this limit to open larger projects.", - "الحد الأقصى لبيانات المشروع بعد فك الضغط. ارفع هذا الحد لفتح مشاريع أكبر.", - ), -]; diff --git a/crates/ui-egui/src/i18n/de.rs b/crates/ui-egui/src/i18n/de.rs deleted file mode 100644 index 0f7e7c35..00000000 --- a/crates/ui-egui/src/i18n/de.rs +++ /dev/null @@ -1,1181 +0,0 @@ -//! German UI text: (English key, translation). Keys are the English strings passed to `tr`. - -pub const TABLE: &[(&str, &str)] = &[ - ("Baking {map} ({n}/{total})", "{map} wird gebacken ({n}/{total})"), - ("Baking {map} ({n}/{total}), texture set {set} of {sets}", "{map} wird gebacken ({n}/{total}), Texturset {set} von {sets}"), - ("Follow Newest Map", "Neueste Map verfolgen"), - ( - "Painting is paused while a bake is shown. Cancel the bake or wait for it to finish.", - "Das Malen ist pausiert, solange ein Bake angezeigt wird. Brich den Bake ab oder warte, bis er fertig ist.", - ), - ( - "What the 3D view shows while the bake runs: the newest finished map, one finished map, or the material. Maps not baked yet show a neutral value.", - "Was die 3D-Ansicht während des Backens zeigt: die zuletzt fertige Map, eine fertige Map deiner Wahl oder das Material. Noch nicht gebackene Maps zeigen einen neutralen Wert.", - ), - ("\"{layer}\" has no paint yet: the filter changes what you paint on it.", "\"{layer}\" ist noch nicht bemalt: Der Filter verändert, was du darauf malst."), - ("0 turns autosave off. Copies go to {folder}", "0 deaktiviert die automatische Speicherung. Kopien werden in {folder} abgelegt"), - ("2D view only", "Nur 2D-Ansicht"), - ("32 bits (float)", "32 Bit (Float)"), - ("3D mesh", "3D-Mesh"), - ("3D meshes", "3D-Meshes"), - ( - "3D texture painting: layers, masks, smart materials, mesh map baking and export.", - "3D-Texturmalerei: Ebenen, Masken, Smart-Materialien, Backen von Mesh-Maps und Export.", - ), - ("3D view only", "Nur 3D-Ansicht"), - ("3D/2D views", "3D-/2D-Ansicht"), - ( - "A folder blends its children (pass-through). Set per-channel opacity in the layer rows.", - "Ein Ordner überblendet seine Unterelemente (Hindurchwirken). Die Deckkraft pro Kanal wird in den Ebenenzeilen festgelegt.", - ), - ("ACES filmic", "ACES Filmic"), - ("Ambient", "Umgebung"), - ("AO intensity", "AO-Intensität"), - ("About TextureCraft", "Über TextureCraft"), - ("About TextureCraft...", "Über TextureCraft..."), - ( - "Add an anchor point to a layer below to use its stack as a mask.", - "Einer darunterliegenden Ebene einen Ankerpunkt hinzufügen, um ihren Stapel als Maske zu verwenden.", - ), - ("Add anchor point", "Ankerpunkt hinzufügen"), - ("Add as decal (view center)", "Als Decal hinzufügen (Ansichtsmitte)"), - ("Add black mask", "Schwarze Maske hinzufügen"), - ("Add channel", "Kanal hinzufügen"), - ("Add color", "Farbe hinzufügen"), - ("Add compare mask", "Vergleichsmaske hinzufügen"), - ("Add effect", "Effekt hinzufügen"), - ("Add fill", "Füllung hinzufügen"), - ("Add fill layer", "Füllebene hinzufügen"), - ("Add filter", "Filter hinzufügen"), - ("Add folder", "Ordner hinzufügen"), - ("Add generator", "Generator hinzufügen"), - ("Add levels", "Tonwertkorrektur hinzufügen"), - ("Add mask", "Maske hinzufügen"), - ("Add mask with color selection", "Maske mit Farbauswahl hinzufügen"), - ("Add output", "Ausgabe hinzufügen"), - ("Add paint", "Malen hinzufügen"), - ("Add paint layer", "Malebene hinzufügen"), - ("Add smart material from the shelf", "Smart-Material aus der Ablage hinzufügen"), - ("Add to the layer content", "Zum Ebeneninhalt hinzufügen"), - ("Add to the mask", "Zur Maske hinzufügen"), - ("Add white mask", "Weiße Maske hinzufügen"), - ("Adjustments", "Korrekturen"), - ( - "Aligned: the offset set by the first stroke is kept. V + click sets a new source.", - "Ausgerichtet: Der beim ersten Strich festgelegte Versatz bleibt erhalten. V + Klick legt eine neue Quelle fest.", - ), - ("Alignment", "Ausrichtung"), - ("Alignment and culling", "Ausrichtung und Culling"), - ("All layers", "Alle Ebenen"), - ("Alpha", "Alpha"), - ("Alphas", "Alphas"), - ("Also bound to {item} ({menu})", "Auch belegt für {item} ({menu})"), - ("Alt + LMB drag", "Alt + LMT ziehen"), - ("Always", "Immer"), - ("Ambient Occlusion", "Ambient Occlusion"), - ("Ambient occlusion", "Ambient occlusion"), - ("Amount", "Stärke"), - ("Anchor point", "Ankerpunkt"), - ("Anchor: {name}", "Anker: {name}"), - ("Anchor: {name} ({channel})", "Anker: {name} ({channel})"), - ("Angle", "Winkel"), - ("Angle (degrees)", "Winkel (Grad)"), - ("Angle fade from", "Winkelausblendung ab"), - ("Angle fade to", "Winkelausblendung bis"), - ("Angle jitter", "Winkelstreuung"), - ("Anisotropy angle", "Anisotropiewinkel"), - ("Anisotropy level", "Anisotropiestärke"), - ("Antialiasing", "Kantenglättung"), - ("Aperture", "Blende"), - ("Apply", "Anwenden"), - ("ArtCraft website...", "ArtCraft-Website..."), - ("Assets", "Assets"), - ("Auto", "Auto"), - ("Automatic (from the mesh UVs)", "Automatisch (aus den UVs des Meshs)"), - ("Autosave every", "Automatisch speichern alle"), - ( - "Autosaves, smart materials, presets, templates and UI layouts go to the data folder. A new folder applies on restart; files already saved stay where they are.", - "Automatische Sicherungen, Smart-Materialien, Vorgaben, Vorlagen und UI-Layouts werden im Datenordner gespeichert. Ein neuer Ordner gilt nach einem Neustart; bereits gespeicherte Dateien bleiben, wo sie sind.", - ), - ("Axis", "Achse"), - ("Back to painting", "Zurück zum Malen"), - ("Backface culling", "Rückseiten-Culling"), - ("Bake an ID map (F8) to pick colors from the mesh.", "Backe eine ID-Map (F8), um Farben vom Mesh aufzunehmen."), - ("Bake Mesh Maps", "Mesh-Maps backen"), - ("Bake mesh maps", "Mesh-Maps backen"), - ("Bake mesh maps (F8) for curvature, AO and thickness based generators.", "Mesh-Maps backen (F8) für Generatoren auf Basis von Krümmung, AO und Dicke."), - ("Baked Lighting", "Gebackene Beleuchtung"), - ("Baking", "Backen"), - ("Base color", "Grundfarbe"), - ( - "Base color is the diffuse color, Specular the F0 color and Glossiness 1 - roughness (add these channels in the texture set settings).", - "Grundfarbe ist die diffuse Farbe, Specular die F0-Farbe und Glanz 1 - Rauheit (diese Kanäle in den Texturset-Einstellungen hinzufügen).", - ), - ("Base color, Metallic, Roughness and Specular level.", "Grundfarbe, Metallisch, Rauheit und Specular-Stärke."), - ("Based on each texture set's size", "Basierend auf der Größe jedes Textursets"), - ("Basic settings", "Grundeinstellungen"), - ("Bent Normals", "Gebogene Normalen"), - ("Bevel", "Abschrägung"), - ("Black", "Schwarz"), - ("Blending", "Überblendung"), - ("Blending mode of the displayed channel", "Füllmethode des angezeigten Kanals"), - ("Blur", "Weichzeichnen"), - ("Blur Directional", "Richtungsweichzeichnung"), - ("Blur and sharpen", "Weichzeichnen und Scharfzeichnen"), - ("Bounces", "Lichtsprünge"), - ("Bricks", "Ziegel"), - ("Brush", "Pinsel"), - ("Brush size", "Pinselgröße"), - ("Brush size down / up", "Pinselgröße verkleinern / vergrößern"), - ("Brushed lines", "Gebürstete Linien"), - ("Built-in (read-only): duplicate it to edit", "Integriert (schreibgeschützt): zum Bearbeiten duplizieren"), - ("Built-in templates are read-only: duplicate one to edit it", "Integrierte Vorlagen sind schreibgeschützt: zum Bearbeiten eine duplizieren"), - ("Built-in: {mesh}", "Integriert: {mesh}"), - ("Cage: {name}", "Cage: {name}"), - ("Camera", "Kamera"), - ("Colors", "Farben"), - ("Go to camera 1", "Zu Kamera 1 wechseln"), - ("Go to camera 2", "Zu Kamera 2 wechseln"), - ("Go to camera 3", "Zu Kamera 3 wechseln"), - ("Go to camera 4", "Zu Kamera 4 wechseln"), - ("Go to camera 5", "Zu Kamera 5 wechseln"), - ("Go to camera 6", "Zu Kamera 6 wechseln"), - ("Go to camera 7", "Zu Kamera 7 wechseln"), - ("Go to camera 8", "Zu Kamera 8 wechseln"), - ("Go to camera 9", "Zu Kamera 9 wechseln"), - ("Camera settings", "Kameraeinstellungen"), - ("Cancel", "Abbrechen"), - ("Cancel the stroke", "Strich abbrechen"), - ("Cell size (texels at 2K)", "Zellengröße (Texel bei 2K)"), - ("Cells", "Zellen"), - ("Channel", "Kanal"), - ("Channel source: uniform value, procedural, image or anchor", "Kanalquelle: einheitlicher Wert, prozedural, Bild oder Anker"), - ("Channels", "Kanäle"), - ("Check for Updates...", "Nach Updates suchen..."), - ("Checker", "Schachbrett"), - ("Clamp", "Begrenzen"), - ("Clear", "Leeren"), - ("Clear mask", "Maske leeren"), - ("Clear recent projects", "Letzte Projekte leeren"), - ( - "Click a mesh part to show or hide the selected layer on it.", - "Klicken Sie auf einen Teil des Meshs, um die ausgewählte Ebene dort ein- oder auszublenden.", - ), - ("Click the mesh to pick its material into the brush", "Auf das Mesh klicken, um sein Material in den Pinsel aufzunehmen"), - ("Click the mesh to place the decal", "Auf das Mesh klicken, um das Decal zu platzieren"), - ("Click, then press the new shortcut (Esc cancels)", "Klicken, dann das neue Tastenkürzel drücken (Esc bricht ab)"), - ("Clone", "Klonen"), - ("Close", "Schließen"), - ("Closed path", "Geschlossener Pfad"), - ("Cloud", "Wolke"), - ("Clouds", "Wolken"), - ("Coat normal", "Klarlack-Normale"), - ("Coat roughness", "Klarlack-Rauheit"), - ("Coat weight", "Klarlack-Gewichtung"), - ("Color", "Farbe"), - ("Color Balance", "Farbbalance"), - ("Color burn", "Farbig nachbelichten"), - ("Color dodge", "Farbig abwedeln"), - ( - "Color of the light that travels under the surface (each channel goes as far as its value)", - "Farbe des Lichts, das unter der Oberfläche wandert (jeder Kanal reicht so weit wie sein Wert)", - ), - ("Color picker", "Farbpipette"), - ("Color selection", "Farbauswahl"), - ("Color to replace", "Zu ersetzende Farbe"), - ( - "Colors near the first shift towards the second, keeping their shading.", - "Farben nahe der ersten verschieben sich zur zweiten und behalten ihre Schattierung.", - ), - ( - "Colors read as gray. Add a levels or blur effect above to shape the result.", - "Farben werden als Grau gelesen. Darüber eine Tonwertkorrektur oder einen Weichzeichnen-Effekt hinzufügen, um das Ergebnis zu formen.", - ), - ("Combine with the layer's height", "Mit der Höhe der Ebene kombinieren"), - ("Compare mask", "Vergleichsmaske"), - ("Compositing", "Compositing"), - ("Constant", "Konstante"), - ("Constants", "Konstanten"), - ("Contrast", "Kontrast"), - ("Contrast/Luminosity", "Kontrast/Luminanz"), - ("Converted maps", "Konvertierte Maps"), - ("Copy RGB values", "RGB-Werte kopieren"), - ("Copy effect", "Effekt kopieren"), - ("Copy from", "Kopieren aus"), - ("Copy layer(s)", "Ebene(n) kopieren"), - ("Copy the selected layer alone (its empty parts copy nothing)", "Nur die ausgewählte Ebene kopieren (ihre leeren Bereiche kopieren nichts)"), - ("Copy to all texture sets", "In alle Textursets kopieren"), - ("Copy what the texture set shows", "Kopieren, was das Texturset anzeigt"), - ("Couldn't encode the render", "Das Rendering konnte nicht kodiert werden"), - ("Couldn't export textures: {error}", "Texturen konnten nicht exportiert werden: {error}"), - ("Couldn't export the mesh: {error}", "Das Mesh konnte nicht exportiert werden: {error}"), - ("Couldn't export the template: {error}", "Die Vorlage konnte nicht exportiert werden: {error}"), - ("Couldn't import {name}: {error}", "{name} konnte nicht importiert werden: {error}"), - ("Couldn't open {name}: {error}", "{name} konnte nicht geöffnet werden: {error}"), - ("Couldn't read the render back from the GPU", "Das Rendering konnte nicht von der GPU zurückgelesen werden"), - ("Couldn't save the render: {error}", "Das Rendering konnte nicht gespeichert werden: {error}"), - ("Couldn't save {name}: {error}", "{name} konnte nicht gespeichert werden: {error}"), - ("Count per stamp", "Anzahl pro Abdruck"), - ("Crate", "Kiste"), - ("Create", "Erstellen"), - ("Create smart material", "Smart-Material erstellen"), - ( - "Ctrl+right-drag in a view sets the size and hardness, Ctrl+left-drag the flow and angle.", - "Strg+Ziehen mit RMT in einer Ansicht stellt Größe und Härte ein, Strg+Ziehen mit LMT Fluss und Winkel.", - ), - ("Cube", "Würfel"), - ("Current layer", "Aktuelle Ebene"), - ("Curvature", "Krümmung"), - ("Cut effect", "Effekt ausschneiden"), - ("Cut layer(s)", "Ebene(n) ausschneiden"), - ("Cyan / red", "Cyan / Rot"), - ("Cylinder", "Zylinder"), - ("Cylindrical projection", "Zylindrische Projektion"), - ( - "Dark to light: the content's luminance picks a color along these stops.", - "Dunkel nach hell: Die Luminanz des Inhalts wählt eine Farbe entlang dieser Farbunterbrechungen.", - ), - ("Darken (Min)", "Abdunkeln (Min)"), - ("Data folder", "Datenordner"), - ("Decal", "Decal"), - ("Decal projection", "Decal-Projektion"), - ("Default", "Standard"), - ("Default camera", "Standardkamera"), - ("Delete the selected template", "Ausgewählte Vorlage löschen"), - ("Delete this camera", "Diese Kamera löschen"), - ("Deleted template \"{name}\"", "Vorlage „{name}“ gelöscht"), - ("Denoise", "Entrauschen"), - ("Depth", "Tiefe"), - ("Depth of field", "Schärfentiefe"), - ("Depth of field (viewport and Rendering mode)", "Schärfentiefe (Ansichtsfenster und Rendermodus)"), - ("Depth of the sharp plane along the view (0: the orbit center)", "Tiefe der Schärfeebene entlang der Blickrichtung (0: Orbit-Mittelpunkt)"), - ("Details saved to {file}", "Details gespeichert in {file}"), - ("Difference", "Differenz"), - ("Dilation + default background color", "Dilatation + Standard-Hintergrundfarbe"), - ("Dilation + transparent", "Dilatation + transparent"), - ("Dilation infinite", "Dilatation unendlich"), - ("DirectX normal map", "DirectX-Normal-Map"), - ("Dirt", "Schmutz"), - ("Disable", "Deaktivieren"), - ("Dismiss", "Schließen"), - ("Displacement (height channel)", "Verschiebung (Höhenkanal)"), - ("Display Settings", "Anzeigeeinstellungen"), - ("Display material", "Material anzeigen"), - ("Display next channel", "Nächsten Kanal anzeigen"), - ("Display next mesh map", "Nächste Mesh-Map anzeigen"), - ("Display previous channel", "Vorherigen Kanal anzeigen"), - ("Display previous mesh map", "Vorherige Mesh-Map anzeigen"), - ("Distance", "Distanz"), - ("Distort", "Verzerren"), - ("Divide", "Dividieren"), - ("Document resolution", "Dokumentauflösung"), - ("Documentation...", "Dokumentation..."), - ("Done on CPU: {n} / {max} samples, {s} s", "Fertig auf CPU: {n} / {max} Samples, {s} s"), - ("Done on GPU: {n} / {max} samples, {s} s", "Fertig auf GPU: {n} / {max} Samples, {s} s"), - ("Double-click to rename", "Doppelklicken zum Umbenennen"), - ("Download as", "Herunterladen als"), - ("Downloaded {name}", "{name} heruntergeladen"), - ("Drag onto an output channel", "Auf einen Ausgabekanal ziehen"), - ( - "Drags the layer stack's values along the stroke into the selected layer.", - "Zieht die Werte des Ebenenstapels entlang des Strichs in die ausgewählte Ebene.", - ), - ( - "Draws {name} of texture set \"{set}\". Edits to the source show in every instance.", - "Zeichnet {name} aus Texturset „{set}“. Änderungen an der Quelle erscheinen in jeder Instanz.", - ), - ( - "Drag the frame to move the decal, a corner to scale it, the round handle to turn it", - "Rahmen ziehen, um das Decal zu verschieben, eine Ecke zum Skalieren, den runden Griff zum Drehen", - ), - ( - "Drop an image from the Assets panel here to use it as this mesh map", - "Ein Bild aus dem Assets-Panel hier ablegen, um es als diese Mesh-Map zu verwenden", - ), - ("Dry streaks", "Trockene Schlieren"), - ("Duplicate effect", "Effekt duplizieren"), - ("Duplicate layer(s)", "Ebene(n) duplizieren"), - ("Duplicate the selected template", "Ausgewählte Vorlage duplizieren"), - ("Edge Detect", "Kantenerkennung"), - ("Edit", "Bearbeiten"), - ("Edit keyboard shortcuts...", "Tastenkürzel bearbeiten..."), - ("Edit quick mask", "Schnellmaske bearbeiten"), - ( - "Editing quick mask: paint where painting is allowed (U to finish)", - "Schnellmaske bearbeiten: Bereiche malen, in denen Malen erlaubt ist (U zum Beenden)", - ), - ( - "Editing the quick mask: strokes paint where painting is allowed. Press U to finish.", - "Schnellmaske wird bearbeitet: Striche markieren, wo Malen erlaubt ist. Zum Beenden U drücken.", - ), - ("Emissive", "Emissiv"), - ("Enable or disable the effect", "Effekt aktivieren oder deaktivieren"), - ("Enable quick mask", "Schnellmaske aktivieren"), - ("Environment blur", "Umgebungsunschärfe"), - ("Environment exposure (EV)", "Umgebungsbelichtung (EV)"), - ("Environment map", "Umgebungs-Map"), - ("Environment opacity", "Umgebungsdeckkraft"), - ("Environment rotation", "Umgebungsdrehung"), - ("Environment settings", "Umgebungseinstellungen"), - ("Environment: {name}", "Umgebung: {name}"), - ("Environments", "Umgebungen"), - ("Eraser", "Radierer"), - ("Exclusion", "Ausschluss"), - ("Expand or collapse the folder", "Ordner auf- oder zuklappen"), - ("Export", "Exportieren"), - ("Export Mesh...", "Mesh exportieren..."), - ("Export Textures...", "Texturen exportieren..."), - ("Export mesh", "Mesh exportieren"), - ("Export template", "Vorlage exportieren"), - ("Export templates", "Exportvorlagen"), - ("Export textures", "Texturen exportieren"), - ("Export the selected template (.json)", "Ausgewählte Vorlage exportieren (.json)"), - ("Exported mesh to {path}", "Mesh nach {path} exportiert"), - ("Exported template \"{name}\" to {path}", "Vorlage „{name}“ nach {path} exportiert"), - ("Exported {n} textures to {folder}", "{n} Texturen nach {folder} exportiert"), - ("F0 from specular level", "F0 aus Specular-Stärke"), - ("Fabric weave", "Stoffgewebe"), - ("Field of view (deg)", "Sichtfeld (Grad)"), - ("File", "Datei"), - ("File name without extension; variables insert names", "Dateiname ohne Erweiterung; Variablen fügen Namen ein"), - ("File type", "Dateityp"), - ("Fill", "Füllung"), - ("Fill the closed path (lasso)", "Geschlossenen Pfad füllen (Lasso)"), - ("Fill the path (close it first)", "Pfad füllen (zuerst schließen)"), - ("Filter", "Filter"), - ("Filter the remaining noise while keeping edges and texture detail", "Restrauschen filtern und dabei Kanten und Texturdetails erhalten"), - ("Filters", "Filter"), - ("Fine noise", "Feines Rauschen"), - ("Fingerprints", "Fingerabdrücke"), - ("Enter a finite number", "Eine endliche Zahl eingeben"), - ("Double-click or press Enter to edit", "Doppelklicken oder Eingabetaste zum Bearbeiten drücken"), - ("Fit the input range to the histogram", "Eingabebereich an das Histogramm anpassen"), - ("Flatten layer", "Ebene reduzieren"), - ( - "Flips the image's green channel, for normal maps made with Y pointing down", - "Kehrt den Grünkanal des Bildes um, für Normal-Maps mit nach unten zeigendem Y", - ), - ("Flow", "Fluss"), - ("Flow and opacity", "Fluss und Deckkraft"), - ("Flow jitter", "Flussstreuung"), - ("Focus distance", "Fokusdistanz"), - ("Folder", "Ordner"), - ("Folders", "Ordner"), - ("Follow path", "Pfad folgen"), - ( - "For the whole project: how normal map images set as mesh maps are read (set them again after a change), and the default for export", - "Für das ganze Projekt: wie Normal-Map-Bilder als Mesh-Maps gelesen werden (nach einer Änderung neu zuweisen), und die Vorgabe für den Export", - ), - ("Free and open source (MIT OR Apache-2.0), written in Rust.", "Frei und quelloffen (MIT OR Apache-2.0), geschrieben in Rust."), - ("From template", "Aus Vorlage"), - ("From template / project", "Aus Vorlage / Projekt"), - ("Full", "Voll"), - ("GPU error: {error}", "GPU-Fehler: {error}"), - ("Geometry mask", "Geometriemaske"), - ( - "GGX specular with height-correlated Smith visibility, Lambert diffuse, split-sum image-based lighting with spherical-harmonics irradiance and horizon fading.", - "GGX-Specular mit höhenkorrelierter Smith-Sichtbarkeit, Lambert-Diffus, bildbasierte Split-Sum-Beleuchtung mit Irradianz aus sphärischen Harmonischen und Horizont-Ausblendung.", - ), - ("Gamma", "Gamma"), - ("General export parameters", "Allgemeine Exportparameter"), - ("General properties", "Allgemeine Eigenschaften"), - ("Generator", "Generator"), - ("Geometry and UVs only", "Nur Geometrie und UVs"), - ("Glossiness", "Glanz"), - ("Glossiness from roughness", "Glanz aus Rauheit"), - ("Glow", "Glühen"), - ("Gradient", "Verlauf"), - ("Gradient Map", "Verlaufsumsetzung"), - ("Gravity", "Schwerkraft"), - ("Gray", "Grau"), - ("Gray + A", "Grau + A"), - ("Gray 50%", "Grau 50%"), - ("Grayscale", "Graustufen"), - ("Group layer(s)", "Ebene(n) gruppieren"), - ("Grunge", "Grunge"), - ("HDR environments", "HDR-Umgebungen"), - ("High Pass", "Hochpass"), - ("HSL Perceptive", "HSL perzeptiv"), - ("Half", "Halb"), - ("Hammered", "Gehämmert"), - ("Hard light", "Hartes Licht"), - ("Hardness", "Härte"), - ("Height", "Höhe"), - ("Height offset", "Höhenversatz"), - ("Height to normal strength", "Stärke Höhe zu Normale"), - ("Help", "Hilfe"), - ("Hide UI", "UI ausblenden"), - ("High", "Hoch"), - ("High poly: {name}", "High-Poly: {name}"), - ("Highlights", "Lichter"), - ("Histogram Range", "Histogrammbereich"), - ("Histogram Scan", "Histogramm-Scan"), - ("Histogram Shift", "Histogramm-Verschiebung"), - ("History", "Verlauf"), - ( - "Hold S: left-drag rotates, right-drag scales, middle-drag moves the stencil.", - "S gedrückt halten: Ziehen mit LMT dreht, mit RMT skaliert, mit MMT verschiebt die Schablone.", - ), - ("Hold V and click the mesh to set the clone source", "V gedrückt halten und auf das Mesh klicken, um die Klonquelle festzulegen"), - ( - "Hold V and click the mesh to set the source, then paint elsewhere to copy it.", - "V gedrückt halten und auf das Mesh klicken, um die Quelle festzulegen, dann an anderer Stelle malen, um sie zu kopieren.", - ), - ( - "How far light travels under the surface, as a fraction of the mesh size (where the Scattering weight channel is painted)", - "Wie weit Licht unter der Oberfläche wandert, als Anteil der Mesh-Größe (wo der Kanal Streuungsgewichtung bemalt ist)", - ), - ( - "How strongly transmissive surfaces bend light (where the Transmission channel is painted): water 1.33, glass 1.5, diamond 2.42", - "Wie stark transmissive Oberflächen Licht brechen (wo der Kanal Transmission bemalt ist): Wasser 1,33, Glas 1,5, Diamant 2,42", - ), - ("Hue shift (degrees)", "Farbtonverschiebung (Grad)"), - ("ID", "ID"), - ("Image: {name}", "Bild: {name}"), - ("Images", "Bilder"), - ("Import HDR...", "HDR importieren..."), - ("Import a template (.json)", "Vorlage importieren (.json)"), - ( - "Import an image (File > Import resources) to project it onto the mesh.", - "Ein Bild importieren (Datei > Ressourcen importieren), um es auf das Mesh zu projizieren.", - ), - ("Import images to use them in fills and masks", "Bilder importieren, um sie in Füllungen und Masken zu verwenden"), - ("Import resources...", "Ressourcen importieren..."), - ("Import MaterialX material...", "MaterialX-Material importieren..."), - ("MaterialX materials", "MaterialX-Materialien"), - ("Import...", "Importieren..."), - ("Imported template \"{name}\"", "Vorlage „{name}“ importiert"), - ("Imported {name}", "{name} importiert"), - ("Index of refraction", "Brechungsindex"), - ("Input high", "Eingabe hoch"), - ("Input low", "Eingabe tief"), - ("Input maps", "Eingabe-Maps"), - ("Insert a variable", "Variable einfügen"), - ("Instance", "Instanz"), - ("Instantiate across texture sets", "In allen Textursets instanziieren"), - ("Intensity (texels at 2K)", "Intensität (Texel bei 2K)"), - ("Interface", "Oberfläche"), - ("Interface scale", "Oberflächenskalierung"), - ("Inverse Subtract", "Umgekehrt subtrahieren"), - ("Inverse divide", "Umgekehrt dividieren"), - ("Invert", "Invertieren"), - ("Invert mask", "Maske invertieren"), - ("Invert mask background", "Maskenhintergrund invertieren"), - ("Invert mask value", "Maskenwert invertieren"), - ("Invert quick mask", "Schnellmaske invertieren"), - ("Jitters", "Streuung"), - ("Join the ArtCraft community on Discord", "Der ArtCraft-Community auf Discord beitreten"), - ("Join the community (Discord)...", "Der Community beitreten (Discord)..."), - ("Key light (shadow-casting light, direct only)", "Führungslicht (schattenwerfendes Licht, nur direkt)"), - ("Keyboard", "Tastatur"), - ("Keyboard shortcuts", "Tastenkürzel"), - ("Light azimuth (degrees)", "Lichtazimut (Grad)"), - ("Light elevation (degrees)", "Lichthöhe (Grad)"), - ("Light intensity", "Lichtintensität"), - ("LMB", "LMT"), - ("Language", "Sprache"), - ("Layer mask", "Ebenenmaske"), - ("Layer memory: {mb} MB", "Ebenenspeicher: {mb} MB"), - ("Layers", "Ebenen"), - ("Lazy mouse", "Lazy Mouse"), - ("Lazy mouse distance", "Lazy-Mouse-Distanz"), - ("Leather grain", "Ledernarbung"), - ("Lens size: how quickly things blur away from the focus distance", "Linsengröße: wie schnell Objekte außerhalb der Fokusdistanz unscharf werden"), - ("Level", "Stufe"), - ("Levels", "Tonwertkorrektur"), - ("Lifetime (steps)", "Lebensdauer (Schritte)"), - ("Light / direction", "Licht / Richtung"), - ("Lighten (Max)", "Aufhellen (Max)"), - ("Lightness", "Helligkeit"), - ("Linear", "Linear"), - ("Linear burn", "Linear nachbelichten"), - ("Linear dodge (Add)", "Linear abwedeln (Addieren)"), - ("Linear light", "Lineares Licht"), - ("List of exports", "Exportliste"), - ("Load UI Layout", "UI-Layout laden"), - ("Loaded UI layout {path}", "UI-Layout {path} geladen"), - ("Log", "Protokoll"), - ("Low", "Niedrig"), - ("Luminosity", "Luminanz"), - ("MMB drag / Alt + MMB", "MMT ziehen / Alt + MMT"), - ("Made by the ArtCraft team and community.", "Entwickelt vom ArtCraft-Team und der Community."), - ("Magenta / green", "Magenta / Grün"), - ("Main shader", "Haupt-Shader"), - ("Marble veins", "Marmoradern"), - ("Mask", "Maske"), - ("Mask Editor: Edge wear", "Masken-Editor: Kantenabnutzung"), - ("Mask value (gray)", "Maskenwert (Grau)"), - ("Mask with height", "Mit Höhe maskieren"), - ("MatFinish Grind", "MatFinish Schliff"), - ("MatFinish Hammered", "MatFinish Gehämmert"), - ("MatFinish Raw", "MatFinish Roh"), - ("MatFinish Sanded", "MatFinish Geschmirgelt"), - ("Material", "Material"), - ("Material ball", "Materialkugel"), - ("Material finish", "Materialoberfläche"), - ("Materials", "Materialien"), - ("Maximum", "Maximum"), - ("Mesh fill", "Mesh-Füllung"), - ("Mesh map: {map}", "Mesh-Map: {map}"), - ("Mesh maps", "Mesh-Maps"), - ("Mesh maps baked", "Mesh-Maps gebacken"), - ("Meshes", "Meshes"), - ("Metallic", "Metallisch"), - ("Midtones", "Mitteltöne"), - ("Minimum", "Minimum"), - ("Minimum size (%)", "Mindestgröße (%)"), - ("Missing (bake to create)", "Fehlt (zum Erstellen backen)"), - ("Mixed AO", "Gemischte AO"), - ("Mode", "Modus"), - ("More in Assets > Alphas: click one, or drag it here", "Mehr unter Assets > Alphas: eines anklicken oder hierher ziehen"), - ("Mosaic", "Mosaik"), - ("Move down", "Nach unten"), - ("Move up", "Nach oben"), - ( - "Moves the surface by the height channel on a finer copy of the mesh, at the height to normal strength (viewport only: painting follows the base surface)", - "Verschiebt die Oberfläche anhand des Höhenkanals auf einer feineren Kopie des Meshs, mit der Stärke von Höhe zu Normale (nur im Viewport: Malen folgt der Grundoberfläche)", - ), - ("Multiply", "Multiplizieren"), - ("My smart materials", "Meine Smart-Materialien"), - ("Name", "Name"), - ("New project", "Neues Projekt"), - ("New project...", "Neues Projekt..."), - ("New template", "Neue Vorlage"), - ("No GPU renderer available", "Kein GPU-Renderer verfügbar"), - ("No font on this system can show this language", "Keine Schriftart auf diesem System kann diese Sprache darstellen"), - ( - "No outputs yet: add one above, then drag input maps onto its channels.", - "Noch keine Ausgaben: Oben eine hinzufügen, dann Eingabe-Maps auf ihre Kanäle ziehen.", - ), - ("No padding (passthrough)", "Kein Padding (unverändert)"), - ("Noise amount", "Rauschstärke"), - ("Noise scale", "Rauschskalierung"), - ("None", "Keine"), - ("Normal", "Normale"), - ("Normal DirectX", "Normale DirectX"), - ("Normal Invert", "Normale invertieren"), - ("Normal OpenGL", "Normale OpenGL"), - ("Normal from height", "Normale aus Höhe"), - ("Normal map combine", "Normal-Map kombinieren"), - ("Normal map detail", "Normal-Map-Detail"), - ("Color space", "Farbraum"), - ("Normal map format", "Normal-Map-Format"), - ("Normal map inverse detail", "Normal-Map-Detail invertiert"), - ("Normal: painting uses the flat normal", "Normale: Malen verwendet die flache Normale"), - ( - "Not enough GPU memory to show texture set \"{name}\" fully: lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "Nicht genug GPU-Speicher, um das Texturset \"{name}\" vollständig anzuzeigen: Verringere in den Einstellungen die Texturauflösung des Ansichtsfensters. Malen und Export sind nicht betroffen.", - ), - ( - "Not enough GPU memory to show {count} texture sets fully ({names}): lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "Nicht genug GPU-Speicher, um {count} Texturesets vollständig anzuzeigen ({names}): Verringere in den Einstellungen die Texturauflösung des Ansichtsfensters. Malen und Export sind nicht betroffen.", - ), - ("Not exported: no source in this texture set", "Nicht exportiert: keine Quelle in diesem Texturset"), - ("Not saved: {error}", "Nicht gespeichert: {error}"), - ("Off", "Aus"), - ("Offset", "Versatz"), - ("Offset right", "Versatz rechts"), - ("Offset up", "Versatz oben"), - ("Offset {axis}", "Versatz {axis}"), - ( - "Offsets the textures by the height channel, at the height to normal strength", - "Verschiebt die Texturen anhand des Höhenkanals, mit der Stärke Höhe zu Normale", - ), - ("On", "Ein"), - ("Opacity", "Deckkraft"), - ("Open sample project...", "Beispielprojekt öffnen..."), - ("Open...", "Öffnen..."), - ("Opened {name}", "{name} geöffnet"), - ( - "Optional channels add a clear coat (Coat weight, Coat roughness, Coat normal), sheen (Sheen weight, color, roughness), anisotropy (Anisotropy level, angle), subsurface scattering (Scattering weight) and transmission (Transmission).", - "Optionale Kanäle ergänzen Klarlack (Klarlack-Gewichtung, Klarlack-Rauheit, Klarlack-Normale), Schimmer (Schimmer-Gewichtung, -Farbe, -Rauheit), Anisotropie (Anisotropiestärke, -winkel), Subsurface Scattering (Streuungsgewichtung) und Transmission (Transmission).", - ), - ("Orbit", "Orbit"), - ("Orthographic", "Orthografisch"), - ("Perspective", "Perspektivisch"), - ("Output directory", "Ausgabeverzeichnis"), - ("Output high", "Ausgabe hoch"), - ("Output low", "Ausgabe tief"), - ("Output template", "Ausgabevorlage"), - ("Output templates", "Ausgabevorlagen"), - ("Overlay", "Ineinanderkopieren"), - ("Overlay opacity", "Überlagerungsdeckkraft"), - ("PBR - Metallic Roughness (TextureCraft)", "PBR - Metallisch/Rauheit (TextureCraft)"), - ("Pick color", "Farbe aufnehmen"), - ("PNG image", "PNG-Bild"), - ("Padding", "Padding"), - ("Paint", "Malen"), - ("Paint chips", "Lackabplatzer"), - ("Paint on the mesh to edit the layer content.", "Auf das Mesh malen, um den Ebeneninhalt zu bearbeiten."), - ( - "Paint on the mesh to edit this mask. Use the Material tab's mask value for gray.", - "Auf das Mesh malen, um diese Maske zu bearbeiten. Für Grau den Maskenwert im Tab Material verwenden.", - ), - ("Paint with the current tool", "Mit dem aktuellen Werkzeug malen"), - ( - "Painted layer pixels {pixels} MB, composited channels {composites} MB, compositing cache {cache} MB", - "Gemalte Ebenenpixel {pixels} MB, zusammengesetzte Kanäle {composites} MB, Compositing-Cache {cache} MB", - ), - ("Painting", "Malen"), - ("Pan", "Schwenken"), - ("Parallax occlusion (height channel)", "Parallax Occlusion (Höhenkanal)"), - ( - "Partial mask values follow the layer's height: high parts show first", - "Teilweise Maskenwerte folgen der Höhe der Ebene: Hohe Bereiche erscheinen zuerst", - ), - ("Particle brush (slides down the surface)", "Partikelpinsel (gleitet die Oberfläche hinab)"), - ("Particle brush: particles slide down the surface", "Partikelpinsel: Partikel gleiten die Oberfläche hinab"), - ("Particles", "Partikel"), - ("Passthrough", "Hindurchwirken"), - ("Paste as instance", "Als Instanz einfügen"), - ("Paste effect", "Effekt einfügen"), - ("Paste layer(s)", "Ebene(n) einfügen"), - ("Path", "Pfad"), - ("Path trace on the processor instead of the graphics card (slower)", "Path Tracing auf dem Prozessor statt auf der Grafikkarte (langsamer)"), - ( - "Path: click adds a point, click the curve inserts one, drag moves it, Enter applies, Esc cancels", - "Pfad: Klicken fügt einen Punkt hinzu, Klicken auf die Kurve fügt einen ein, Ziehen verschiebt ihn, Eingabe wendet an, Esc bricht ab", - ), - ("Pattern scale", "Musterskalierung"), - ("Perlin noise", "Perlin-Rauschen"), - ("Pick focus in the viewport", "Fokus im Ansichtsfenster wählen"), - ("Pin light", "Lichtpunkt"), - ("Place on the surface", "Auf der Oberfläche platzieren"), - ("Place path points on the mesh", "Pfadpunkte auf dem Mesh platzieren"), - ("Planar projection", "Planare Projektion"), - ("Plane", "Fläche"), - ("Polygon fill", "Polygonfüllung"), - ("Pores", "Poren"), - ("Position", "Position"), - ("Position gradient", "Positionsverlauf"), - ("Position jitter", "Positionsstreuung"), - ("Posterize", "Tontrennung"), - ("Press a key...", "Taste drücken..."), - ("Procedurals", "Prozedurale"), - ("Project", "Projekt"), - ("Project Configuration...", "Projektkonfiguration..."), - ("Project opened", "Projekt geöffnet"), - ("Project template", "Projektvorlage"), - ("Projection", "Projektion"), - ("Projects and meshes", "Projekte und Meshes"), - ("Properties", "Eigenschaften"), - ("Quarter", "Viertel"), - ("Quick mask", "Schnellmaske"), - ("Quit", "Beenden"), - ("Radius (texels at 2K)", "Radius (Texel bei 2K)"), - ("RENDERING", "RENDERING"), - ("Range", "Bereich"), - ("Rebind any menu item, tool or command", "Beliebige Menüeinträge, Werkzeuge oder Befehle neu belegen"), - ("Recent projects", "Letzte Projekte"), - ( - "Records the stack up to this layer. Fill effects in masks (and fill layers) above can read it as a source.", - "Erfasst den Stapel bis zu dieser Ebene. Fülleffekte in Masken (und Füllebenen) darüber können ihn als Quelle lesen.", - ), - ("Redo", "Wiederholen"), - ("Reimport mesh", "Mesh neu importieren"), - ("Remove", "Entfernen"), - ("Remove channel", "Kanal entfernen"), - ("Remove effect", "Effekt entfernen"), - ("Remove last", "Letzte entfernen"), - ("Remove layer", "Ebene entfernen"), - ("Remove layer(s)", "Ebene(n) entfernen"), - ("Remove mask", "Maske entfernen"), - ("Remove point", "Punkt entfernen"), - ("Remove resource", "Ressource entfernen"), - ("Remove the shortcut", "Tastenkürzel entfernen"), - ("Remove this output", "Diese Ausgabe entfernen"), - ("Remove unused resources...", "Unbenutzte Ressourcen entfernen..."), - ("Rename the selected template", "Ausgewählte Vorlage umbenennen"), - ("Render on the CPU", "Auf der CPU rendern"), - ("Rendering", "Rendering"), - ("Rendering (path traced)", "Rendering (Path Tracing)"), - ("Rendering on CPU: {n} / {max} samples, {s} s", "Rendern auf CPU: {n} / {max} Samples, {s} s"), - ("Rendering on GPU: {n} / {max} samples, {s} s", "Rendern auf GPU: {n} / {max} Samples, {s} s"), - ("Rendering, path traced", "Rendering, Path Tracing"), - ("Replace", "Ersetzen"), - ("Replace Color", "Farbe ersetzen"), - ("Replacement color", "Ersatzfarbe"), - ("Report a bug...", "Fehler melden..."), - ("Rescan the library folder", "Bibliotheksordner neu einlesen"), - ("Reset", "Zurücksetzen"), - ("Reset UI", "UI zurücksetzen"), - ("Reset all", "Alle zurücksetzen"), - ("Reset to defaults", "Auf Standardwerte zurücksetzen"), - ("Reset to {shortcut}", "Auf {shortcut} zurücksetzen"), - ("Resizing", "Größe wird geändert"), - ("Restore every default shortcut", "Alle Standard-Tastenkürzel wiederherstellen"), - ("Return to this step", "Zu diesem Schritt zurückkehren"), - ("Right-click a layer > Create smart material", "Rechtsklick auf eine Ebene > Smart-Material erstellen"), - ("Rotation", "Drehung"), - ("Rotation (degrees)", "Drehung (Grad)"), - ("Roughness", "Rauheit"), - ("Roughness from glossiness", "Rauheit aus Glanz"), - ("Round", "Rund"), - ("Rounded cube", "Abgerundeter Würfel"), - ("Samples", "Samples"), - ("Saturation", "Sättigung"), - ("Save", "Speichern"), - ("Save UI Layout", "UI-Layout speichern"), - ("Save a copy...", "Kopie speichern..."), - ("Save as...", "Speichern unter..."), - ("Save current layout...", "Aktuelles Layout speichern..."), - ("Save render...", "Rendering speichern..."), - ("Save view as camera", "Ansicht als Kamera speichern"), - ("Saved UI layout {path}", "UI-Layout {path} gespeichert"), - ("Saved {path}", "{path} gespeichert"), - ("Saving UI layouts to files is available in the desktop app", "Das Speichern von UI-Layouts in Dateien ist in der Desktop-App verfügbar"), - ("Scale", "Skalierung"), - ("Scale / tiling", "Skalierung / Kachelung"), - ("Scatter color", "Streufarbe"), - ("Scatter radius", "Streuradius"), - ("Scattering weight", "Streuungsgewichtung"), - ("Scratches", "Kratzer"), - ("Screen", "Negativ multiplizieren"), - ("Screenshot of the viewport", "Screenshot des Ansichtsfensters"), - ("Search", "Suchen"), - ("Search all assets", "Alle Assets durchsuchen"), - ("Search commands or keys", "Befehle oder Tasten suchen"), - ("Seed", "Startwert"), - ("Select a layer", "Ebene auswählen"), - ("Select an output template", "Ausgabevorlage auswählen"), - ("Select source", "Quelle auswählen"), - ("Select the mask (Alt+click: show it in the viewport)", "Maske auswählen (Alt+Klick: im Ansichtsfenster anzeigen)"), - ("Select...", "Auswählen..."), - ("Settings", "Einstellungen"), - ("Settings...", "Einstellungen..."), - ("Shader Settings", "Shader-Einstellungen"), - ("Shader instance", "Shader-Instanz"), - ("Shadows", "Tiefen"), - ("Sharpen", "Scharfzeichnen"), - ("Sheen color", "Schimmerfarbe"), - ("Sheen color × weight", "Schimmerfarbe × Gewichtung"), - ("Sheen roughness", "Schimmer-Rauheit"), - ("Sheen weight", "Schimmer-Gewichtung"), - ("Shift + wheel", "Umschalt + Mausrad"), - ("Shortcuts list...", "Liste der Tastenkürzel..."), - ("Show on all parts", "Auf allen Teilen zeigen"), - ("Show UV wireframe in the 2D view", "UV-Drahtgitter in der 2D-Ansicht anzeigen"), - ("Show entire mesh", "Gesamtes Mesh anzeigen"), - ("Show log...", "Protokoll anzeigen..."), - ("Show or hide the layer", "Ebene ein- oder ausblenden"), - ("Show or hide the texture set", "Texturset ein- oder ausblenden"), - ("Show wireframe in the 3D view", "Drahtgitter in der 3D-Ansicht anzeigen"), - ("Signed addition (AddSub)", "Vorzeichenbehaftete Addition (AddSub)"), - ("Size", "Größe"), - ("Size in screen space", "Größe im Bildschirmraum"), - ("Size jitter", "Größenstreuung"), - ( - "Size of the textures the viewport shows: lower uses less GPU memory with large texture sets. Painting and export keep full resolution.", - "Größe der Texturen, die das Ansichtsfenster zeigt: niedriger braucht bei großen Texturesets weniger GPU-Speicher. Malen und Export behalten die volle Auflösung.", - ), - ("Slope Blur", "Neigungsweichzeichnung"), - ("Slope scale", "Neigungsskalierung"), - ("Smart masks", "Smart-Masken"), - ("Smart material saved to {path}", "Smart-Material in {path} gespeichert"), - ("Smart materials", "Smart-Materialien"), - ("Smudge", "Verwischen"), - ("Soft light", "Weiches Licht"), - ("Softness", "Weichheit"), - ("Source", "Quelle"), - ("Source U {u} V {v}", "Quelle U {u} V {v}"), - ("Spacing", "Abstand"), - ("Specular", "Specular"), - ("Specular level", "Specular-Stärke"), - ("Sphere", "Kugel"), - ("Spherical projection", "Sphärische Projektion"), - ("Spray", "Spray"), - ("Square", "Quadrat"), - ("Stamp depth", "Abdrucktiefe"), - ("Star", "Stern"), - ("Starting render...", "Rendering wird gestartet..."), - ("Stencil", "Schablone"), - ("Steps", "Stufen"), - ("Streaks", "Schlieren"), - ("Strength", "Stärke"), - ("Stripes", "Streifen"), - ("Stroke opacity", "Strichdeckkraft"), - ("Subsampling 2x2", "Subsampling 2x2"), - ("Subsampling 4x4", "Subsampling 4x4"), - ("Subsampling 8x8", "Subsampling 8x8"), - ("Subsurface scattering", "Subsurface Scattering"), - ("Subtract", "Subtrahieren"), - ("Tangent | Wrap", "Tangente | Umhüllen"), - ("Temporal anti-aliasing (refines the 3D view while it is still)", "Temporale Kantenglättung (verfeinert die 3D-Ansicht im Stillstand)"), - ("Texture Sets", "Textursets"), - ("Texture Set Settings", "Texturset-Einstellungen"), - ("Texture resolution", "Texturauflösung"), - ("Texture set channels", "Texturset-Kanäle"), - ("Texture sets", "Textursets"), - ("TextureCraft had to close:", "TextureCraft musste beendet werden:"), - ("TextureCraft PBR - Metallic Roughness", "TextureCraft PBR - Metallisch/Rauheit"), - ("TextureCraft PBR - Specular Glossiness", "TextureCraft PBR - Specular/Glanz"), - ("TextureCraft project", "TextureCraft-Projekt"), - ("TextureCraft project or mesh", "TextureCraft-Projekt oder Mesh"), - ("Textures", "Texturen"), - ("Textures embedded; for game engines and most viewers", "Texturen eingebettet; für Game-Engines und die meisten Viewer"), - ("Textures packaged; for USD tools and AR Quick Look", "Texturen gepackt; für USD-Tools und AR Quick Look"), - ("The GPU couldn't render this scene: {error}", "Die GPU konnte diese Szene nicht rendern: {error}"), - ("The bake worker stopped", "Der Back-Prozess wurde beendet"), - ("The eraser removes paint from the enabled channels.", "Der Radierer entfernt Farbe aus den aktivierten Kanälen."), - ("The first stroke sets the offset from the source.", "Der erste Strich legt den Versatz zur Quelle fest."), - ( - "The image's alpha cuts the decal's shape; faces turned away and surfaces beyond its depth stay clear.", - "Der Alphakanal des Bildes schneidet die Form des Decals aus; abgewandte Flächen und Oberflächen jenseits seiner Tiefe bleiben frei.", - ), - ("The next click in the 3D view moves the decal there", "Der nächste Klick in der 3D-Ansicht verschiebt das Decal dorthin"), - ("The resize worker stopped", "Der Skalierungsprozess wurde beendet"), - ("Thickness", "Dicke"), - ("Thin areas", "Dünne Bereiche"), - ("Threshold", "Schwellenwert"), - ("Tile", "Kacheln"), - ("Tiles", "Kacheln"), - ("Tint", "Tönung"), - ("Toggle mask", "Maske umschalten"), - ("Tolerance", "Toleranz"), - ("Tone mapping", "Tone Mapping"), - ("Tools", "Werkzeuge"), - ("Torus", "Torus"), - ("Transmission", "Transmission"), - ("Tri-planar projection", "Triplanare Projektion"), - ("Triangle fill", "Dreiecksfüllung"), - ("UDIM plane", "UDIM-Fläche"), - ("UDIM tiles painted by this texture set, each at the set's size", "Von diesem Texturset bemalte UDIM-Kacheln, jeweils in der Größe des Sets"), - ("UI layout", "UI-Layout"), - ("UI layout: {error}", "UI-Layout: {error}"), - ("UI layouts", "UI-Layouts"), - ("UI {ms} ms", "UI {ms} ms"), - ("USD binary, textures alongside", "USD binär, Texturen daneben"), - ("USD text, textures alongside", "USD-Text, Texturen daneben"), - ("USDZ with textures", "USDZ mit Texturen"), - ("UV checker", "UV-Schachbrett"), - ("UV island fill", "UV-Insel-Füllung"), - ("UV transformations", "UV-Transformationen"), - ("UV projection", "UV-Projektion"), - ("UV tiles", "UV-Kacheln"), - ("UV tiles (UDIM)", "UV-Kacheln (UDIM)"), - ("Undo", "Rückgängig"), - ("Uniform value", "Einheitlicher Wert"), - ("Use an equirectangular .hdr or .exr image as the environment", "Ein equirektangulares .hdr- oder .exr-Bild als Umgebung verwenden"), - ("Use the control channel or `texturecraft-cli render` for screenshots", "Für Screenshots den Steuerkanal oder `texturecraft-cli render` verwenden"), - ("Value", "Wert"), - ("Version {version}", "Version {version}"), - ("Version: {version} ({gpu})", "Version: {version} ({gpu})"), - ("View through this camera", "Durch diese Kamera sehen"), - ("Viewer settings", "Ansichtseinstellungen"), - ("Viewport", "Ansichtsfenster"), - ("Viewport and brush (fixed)", "Ansichtsfenster und Pinsel (fest)"), - ("Views", "Ansichten"), - ("Vivid light", "Strahlendes Licht"), - ("Voronoi", "Voronoi"), - ("Warp", "Verkrümmen"), - ("Warp Directional", "Richtungsverkrümmung"), - ("Wavefront OBJ with MTL, textures alongside", "Wavefront OBJ mit MTL, Texturen daneben"), - ( - "WebGPU isn't available in this browser, so TextureCraft runs on WebGL2: Rendering mode path traces on the CPU (slower) and large texture sets show at reduced resolution. A current Chrome, Edge or Safari has WebGPU.", - "WebGPU ist in diesem Browser nicht verfügbar, daher läuft TextureCraft mit WebGL2: Der Rendering-Modus berechnet Path Tracing auf der CPU (langsamer), und große Texturesets werden in reduzierter Auflösung angezeigt. Aktuelle Versionen von Chrome, Edge und Safari unterstützen WebGPU.", - ), - ("Wheel / Alt + RMB drag", "Mausrad / Alt + RMT ziehen"), - ("White", "Weiß"), - ("Width", "Breite"), - ("Width (texels at 2K)", "Breite (Texel bei 2K)"), - ("Window", "Fenster"), - ("Wood grain", "Holzmaserung"), - ( - "Works in texture space, like the blur: it does not cross UV seams.", - "Arbeitet im Texturraum wie das Weichzeichnen: UV-Nähte werden nicht überschritten.", - ), - ("World Space Normal", "Normale (Weltkoordinaten)"), - ("Yellow / blue", "Gelb / Blau"), - ("Zoom", "Zoomen"), - ("a missing layer", "eine fehlende Ebene"), - ("aniso", "aniso"), - ("aniso angle", "aniso w"), - ("ao", "ao"), - ("coat", "lack"), - ("coat nrm", "lack nrm"), - ("coat rough", "lack rau"), - ("color", "farbe"), - ("emiss", "emiss"), - ("glTF binary with textures", "glTF binär mit Texturen"), - ("gloss", "glanz"), - ("height", "höhe"), - ("metal", "metall"), - ("min", "Min."), - ("missing", "fehlt"), - ("missing source", "Quelle fehlt"), - ("no GPU", "keine GPU"), - ("none", "keins"), - ("nrm", "nrm"), - ("off", "aus"), - ("op", "deck"), - ("rough", "rau"), - ("scatter", "streu"), - ("sheen", "schim"), - ("sheen color", "schim fb"), - ("sheen rough", "schim rau"), - ("spec", "spec"), - ("specular", "specular"), - ("transm", "transm"), - ("{action} (undone)", "{action} (rückgängig gemacht)"), - ( - "{file}: add above the selected layer (or drag it into the layer stack or onto the viewport)", - "{file}: über der ausgewählten Ebene hinzufügen (oder in den Ebenenstapel bzw. in das Ansichtsfenster ziehen)", - ), - ("{name} copy", "{name} Kopie"), - ("{n} bits", "{n} Bit"), - ( - "{n} control points. Click the mesh (or the 2D view) to add points and drag them to adjust; click the first point to close the path. Enter paints it with the brush (a closed, filled path fills its inside), Esc cancels.", - "{n} Kontrollpunkte. Klicken Sie auf das Mesh (oder die 2D-Ansicht), um Punkte hinzuzufügen, und ziehen Sie sie zum Anpassen; ein Klick auf den ersten Punkt schließt den Pfad. Eingabe malt ihn mit dem Pinsel (ein geschlossener, gefüllter Pfad füllt sein Inneres), Esc bricht ab.", - ), - ("{n} items share a shortcut; the first one listed wins.", "{n} Einträge teilen sich ein Tastenkürzel; der erste in der Liste hat Vorrang."), - ("{pattern} (scale {scale}, seed {seed})", "{pattern} (Skalierung {scale}, Startwert {seed})"), - ("Template name", "Vorlagenname"), - ("Save current project as template", "Aktuelles Projekt als Vorlage speichern"), - ("Distribution", "Verteilung"), - ("Cosine", "Kosinus"), - ("Uniform", "Gleichmäßig"), - ("Normalization", "Normalisierung"), - // Settings › Interface: brightness and accent color. - ("Brightness", "Helligkeit"), - ("Dark", "Dunkel"), - ("Medium dark", "Mitteldunkel"), - ("Medium light", "Mittelhell"), - ("Light", "Hell"), - ("Accent color", "Akzentfarbe"), - ("Copper", "Kupfer"), - ("Coral", "Koralle"), - ("Blue", "Blau"), - ("Violet", "Violett"), - ("Green", "Grün"), - ("Amber", "Bernstein"), - ("Pink", "Pink"), - ("Minimize", "Minimieren"), - ("Maximize", "Maximieren"), - ("Restore", "Wiederherstellen"), - ("Title bar", "Titelleiste"), - ("System title bar (applies on restart)", "Titelleiste des Systems (ab dem nächsten Start)"), - ( - "Use the operating system's window frame and buttons instead of TextureCraft's own title bar", - "Fensterrahmen und Fenstertasten des Betriebssystems statt der eigenen Titelleiste von TextureCraft verwenden", - ), - ("Brushes", "Pinsel"), - ("My brushes", "Meine Pinsel"), - ("Use this brush (keeps its size)", "Diesen Pinsel verwenden (Größe bleibt)"), - ("Brush name", "Pinselname"), - ("Save current brush", "Aktuellen Pinsel speichern"), - ("Start window", "Startfenster"), - ("Show at startup", "Beim Start anzeigen"), - ("Continue with the sample project", "Mit dem Beispielprojekt fortfahren"), - ("No recent projects yet", "Noch keine zuletzt geöffneten Projekte"), - ("Text", "Text"), - ("Font", "Schrift"), - ("Style", "Schnitt"), - ("Use as brush alpha", "Als Pinsel-Alpha verwenden"), - ("Place as decal", "Als Decal platzieren"), - ("Click: turn this channel on or off. Alt+click: this channel only", "Klick: diesen Kanal ein- oder ausschalten. Alt+Klick: nur diesen Kanal"), - ("Show all", "Alle einblenden"), - ("Hide all", "Alle ausblenden"), - ("Invert show/hide", "Ein-/Ausblenden umkehren"), - ("Show or hide texture sets", "Texturesets ein- oder ausblenden"), - ("Focus: show only the active texture set", "Fokus: nur das aktive Textureset zeigen"), - ("Unsaved changes", "Ungespeicherte Änderungen"), - ("Don't save", "Nicht speichern"), - ("Save the changes to {name} before closing?", "Änderungen an {name} vor dem Schließen speichern?"), - ("Radius", "Radius"), - ("Remove skew correction", "Skew-Korrektur entfernen"), - ("Twill weave", "Köperbindung"), - ("Save the changes to {name} first?", "Änderungen an {name} zuerst speichern?"), - ( - "Paths stay editable: pick one to move its points or change its brush and material, and the sublayer repaints at once. Add paths with the Path tool.", - "Pfade bleiben bearbeitbar: Wähle einen, um seine Punkte zu verschieben oder Pinsel und Material zu ändern, und die Unterebene wird sofort neu gemalt. Füge Pfade mit dem Pfad-Werkzeug hinzu.", - ), - ("Import material...", "Material importieren..."), - ("MaterialCraft material", "MaterialCraft-Material"), - ("Cooked at {size} px", "Berechnet mit {size} px"), - ("Preset", "Vorgabe"), - ("Re-cook", "Neu berechnen"), - ("Open in MaterialCraft", "In MaterialCraft öffnen"), - ( - "Opened in MaterialCraft: use File > Send to TextureCraft there to bring your changes back", - "In MaterialCraft geöffnet: Dort mit Datei > An TextureCraft senden die Änderungen zurückholen", - ), - ("Parameters change in the desktop app, with MaterialCraft installed", "Parameter lassen sich in der Desktop-App mit installiertem MaterialCraft ändern"), - ("Add High-Poly Meshes", "High-Poly-Meshes hinzufügen"), - ("All", "Alle"), - ("Apply Diffusion", "Diffusion anwenden"), - ("Attenuation", "Abschwächung"), - ("Auto Tonemapping", "Automatisches Tonemapping"), - ("Average Normals", "Normalen mitteln"), - ("BBox", "Begrenzungsrahmen"), - ("BSphere", "Begrenzungskugel"), - ("Mesh Map Bakers", "Mesh-Map-Baker"), - ("Common Settings", "Allgemeine Einstellungen"), - ("Mesh Map Settings", "Mesh-Map-Einstellungen"), - ("Check All", "Alle auswählen"), - ("No Parameters", "Keine Parameter"), - ("Bake Selected Textures ({n})", "Ausgewählte Texturen backen ({n})"), - ("By Mesh Name", "Nach Mesh-Name"), - ("Cage", "Käfig"), - ("Cage Scene", "Käfigszene"), - ("Cage Type", "Käfigtyp"), - ("Color Generator", "Farbgenerator"), - ("Color Source", "Farbquelle"), - ("Common Parameters", "Gemeinsame Parameter"), - ("Custom File", "Benutzerdefinierte Datei"), - ("Details", "Details"), - ("Dilation Width", "Dilatationsbreite"), - ("Distance-Based", "Distanzbasiert"), - ("Edge Contrast", "Kantenkontrast"), - ("Edge Distance", "Kantenabstand"), - ("Edge Protection", "Kantenschutz"), - ("Enable Seams", "Nähte aktivieren"), - ("File ID", "Datei-ID"), - ("Full Scene", "Gesamte Szene"), - ("Generate from Mesh", "Aus Mesh erzeugen"), - ("Generate from Normal Map", "Aus Normal-Map erzeugen"), - ("Ground Plane", "Bodenebene"), - ("Ground Plane Offset", "Bodenversatz"), - ("High Poly Mesh Suffix", "Suffix für High-Poly-Mesh"), - ("High Poly Scene", "High-Poly-Szene"), - ("High-Poly Parameters", "High-Poly-Parameter"), - ("Hue Shift", "Farbtonverschiebung"), - ("Ignore Backface", "Rückseiten ignorieren"), - ("Ignore Backface Suffix", "Suffix für ignorierte Rückseiten"), - ("Include in Bake", "Beim Backen einschließen"), - ("Load Cage", "Käfig laden"), - ("Lock Output Size", "Ausgabegröße sperren"), - ("Low Poly Mesh Suffix", "Suffix für Low-Poly-Mesh"), - ("Manual", "Manuell"), - ("Material Color", "Materialfarbe"), - ("Max Frontal Distance", "Max. vordere Distanz"), - ("Max Occluder Distance", "Max. Verdeckerdistanz"), - ("Max Rear Distance", "Max. hintere Distanz"), - ("Mesh ID", "Mesh-ID"), - ("Method", "Methode"), - ("Min Occluder Distance", "Minimaler Verdeckungsabstand"), - ("Never", "Nie"), - ("No High-Poly Meshes", "Keine High-Poly-Meshes"), - ("Normalization Scale", "Normalisierungsskala"), - ("Normalization Type", "Normalisierungstyp"), - ("Only Same Mesh Name", "Nur gleicher Mesh-Name"), - ("Output Size", "Ausgabegröße"), - ("Match", "Zuordnung"), - ("Skew Correction Method", "Methode der Verzerrungskorrektur"), - ("Mesh Normals Based", "Basierend auf Mesh-Normalen"), - ("Face Normals Based", "Basierend auf Flächennormalen"), - ("Reset Painted Cage", "Gemalten Käfig Zurücksetzen"), - ("Paint Cage", "Käfig malen"), - ("Paint Skew Correction", "Verzerrungskorrektur malen"), - ("Per Material", "Pro Material"), - ("Random", "Zufällig"), - ("Relative to Bounding Box", "Relativ zum Begrenzungsrahmen"), - ("Relative to Low Mesh", "Relativ zum Low-Poly-Mesh"), - ("Relative to Min/Max", "Relativ zu Min/Max"), - ("Relative to Ray Distances", "Relativ zu Strahlabständen"), - ("Remove Cage", "Käfig entfernen"), - ("Remove Skew Correction", "Skew-Korrektur entfernen"), - ("Restore Defaults", "Standardwerte wiederherstellen"), - ("Return to Painting Mode", "Zurück zum Malmodus"), - ("Sampling Radius", "Abtastradius"), - ("Scaling Divisor", "Skalierungsdivisor"), - ("Seams Intensity", "Nahtintensität"), - ("Secondary Rays", "Sekundärstrahlen"), - ("Self Intersection", "Selbstüberschneidung"), - ("Self Occlusion", "Eigenverdeckung"), - ("Skew Correction", "Skew-Korrektur"), - ("Smooth", "Glatt"), - ("Spread Angle", "Streuwinkel"), - ("Submesh", "Teilmesh"), - ("Use Low Poly Mesh as High Poly Mesh", "Low-Poly-Mesh als High-Poly-Mesh verwenden"), - ("Value Bounds Max", "Maximaler Grenzwert"), - ("Value Bounds Min", "Minimaler Grenzwert"), - ("Vertex Color", "Scheitelpunktfarbe"), - ("Select the layer content", "Ebeneninhalt auswählen"), - ("Paint layer", "Malebene"), - ("Fill layer", "Füllebene"), - ("1 effect", "1 Effekt"), - ("{count} effects", "{count} Effekte"), - ("Mask effects", "Maskeneffekte"), - ("Content effects", "Inhaltseffekte"), - ("Fold or unfold these effects", "Diese Effekte ein- oder ausklappen"), - ("Remove resolution override", "Auflösungsüberschreibung entfernen"), - ("Texture set resolution", "Auflösung des Textursets"), - ("UV tile {tile} resolution", "Auflösung der UV-Kachel {tile}"), - ("Angle span", "Winkelbereich"), - ("Axis position", "Achsenposition"), - ("Count", "Anzahl"), - ("Display", "Anzeige"), - ("Hide while painting", "Beim Malen ausblenden"), - ("Manipulator size", "Manipulatorgröße"), - ("Mirror symmetry", "Spiegelsymmetrie"), - ("Radial settings", "Radial-Einstellungen"), - ("Radial symmetry", "Radialsymmetrie"), - ("Show axis", "Achse anzeigen"), - ("Show axis position manipulator", "Manipulator für die Achsenposition anzeigen"), - ("Show cursor", "Cursor anzeigen"), - ("Show intersection", "Schnittlinie anzeigen"), - ("Show plane", "Ebene anzeigen"), - ("Symmetry", "Symmetrie"), - ("Symmetry color display", "Anzeigefarbe der Symmetrie"), - ("Symmetry settings", "Symmetrie-Einstellungen"), - ("Type", "Typ"), - ("Advanced settings", "Erweiterte Einstellungen"), - ("Import baked maps", "Gebackene Maps importieren"), - ("Name each file after its texture set, like Body_normal.png", "Benennen Sie jede Datei nach ihrem Texturset, z. B. Body_normal.png"), - ("Add...", "Hinzufügen..."), - ("Baked maps imported: {count}", "Gebackene Maps importiert: {count}"), - ("Not imported: {files}", "Nicht importiert: {files}"), - ("Baking Visualization", "Bake-Visualisierung"), - ("Show for Selected Texture Set Only", "Nur für das ausgewählte Texturset anzeigen"), - ("High Definition Mesh (HP)", "High-Poly-Mesh (HP)"), - ("UV Seams", "UV-Nähte"), - ("Project Mesh (LP)", "Projektions-Mesh (LP)"), - ("Edges", "Kanten"), - ("Cavities", "Vertiefungen"), - ("Edges and cavities", "Kanten und Vertiefungen"), - ("Raw curvature", "Rohe Krümmung"), - ("Detail sizes", "Detailgrößen"), - ( - "Reads the curvature map as baked: changing the mode or a size turns detail sizes on.", - "Liest die Krümmungskarte wie gebacken: Eine Änderung des Modus oder einer Größe schaltet die Detailgrößen ein.", - ), - ( - "A click fills what is under it; a dragged rectangle fills what it selects as it grows", - "Ein Klick füllt, was darunter liegt; ein aufgezogenes Rechteck füllt, was es beim Aufziehen erfasst", - ), - ("Contained center: fill polygons whose center is in the rectangle", "Enthaltener Mittelpunkt: Polygone füllen, deren Mittelpunkt im Rechteck liegt"), - ( - "Editing the quick mask: fills paint where painting is allowed. Press U to finish.", - "Schnellmaske wird bearbeitet: Füllungen markieren, wo Malen erlaubt ist. Zum Beenden U drücken.", - ), - ("Fill mode", "Füllmodus"), - ("Fill only polygons the camera sees (3D view)", "Nur Polygone füllen, die die Kamera sieht (3D-Ansicht)"), - ("Hit-test", "Treffertest"), - ("How a rectangle selects polygons", "Wie ein Rechteck Polygone auswählt"), - ("Intersection: fill polygons the rectangle touches", "Schnittmenge: Polygone füllen, die das Rechteck berührt"), - ("Rectangle fill", "Rechteckfüllung"), - ("Select a paint layer or a layer's mask to fill", "Wähle zum Füllen eine Malebene oder eine Ebenenmaske"), - ("Selection mode", "Auswahlmodus"), - ( - "Triangle fills single triangles, Polygon whole quads and n-gons, Mesh the connected geometry, UV island the UV islands", - "Dreieck füllt einzelne Dreiecke, Polygon ganze Vierecke und N-Ecke, Mesh die zusammenhängende Geometrie, UV-Insel die UV-Inseln", - ), - ("Visible polygons only", "Nur sichtbare Polygone"), - ("\"{layer}\" can't be filled: select a paint layer or a layer's mask", "\"{layer}\" kann nicht gefüllt werden: Wähle eine Malebene oder eine Ebenenmaske"), - ("The file dialog couldn't be shown: {error}", "Der Dateidialog konnte nicht angezeigt werden: {error}"), - ( - "The project changed while the dialog was open, so nothing was done", - "Das Projekt hat sich geändert, während der Dialog geöffnet war, daher wurde nichts ausgeführt", - ), - ("Cores kept for the UI", "Für die Oberfläche reservierte Kerne"), - ("Max RAM while saving", "Max. RAM beim Speichern"), - ( - "Saving uses the other cores and at most this share of the free RAM. At least one core always works.", - "Das Speichern nutzt die übrigen Kerne und höchstens diesen Anteil des freien RAMs. Mindestens ein Kern arbeitet immer.", - ), - ("Max project size on open", "Max. Projektgröße beim Öffnen"), - ( - "Maximum decompressed project data. Increase this limit to open larger projects.", - "Maximale entpackte Projektdaten. Erhöhen Sie diesen Grenzwert, um größere Projekte zu öffnen.", - ), -]; diff --git a/crates/ui-egui/src/i18n/es.rs b/crates/ui-egui/src/i18n/es.rs deleted file mode 100644 index b5361801..00000000 --- a/crates/ui-egui/src/i18n/es.rs +++ /dev/null @@ -1,1172 +0,0 @@ -//! Spanish UI text: (English key, translation). Keys are the English strings passed to `tr`. - -pub const TABLE: &[(&str, &str)] = &[ - ("Baking {map} ({n}/{total})", "Horneando {map} ({n}/{total})"), - ("Baking {map} ({n}/{total}), texture set {set} of {sets}", "Horneando {map} ({n}/{total}), conjunto de texturas {set} de {sets}"), - ("Follow Newest Map", "Seguir el mapa más reciente"), - ( - "Painting is paused while a bake is shown. Cancel the bake or wait for it to finish.", - "La pintura está en pausa mientras se muestra un horneado. Cancela el horneado o espera a que termine.", - ), - ( - "What the 3D view shows while the bake runs: the newest finished map, one finished map, or the material. Maps not baked yet show a neutral value.", - "Lo que muestra la vista 3D mientras se hornea: el último mapa terminado, un mapa terminado a elección o el material. Los mapas aún sin hornear muestran un valor neutro.", - ), - ("\"{layer}\" has no paint yet: the filter changes what you paint on it.", "\"{layer}\" aún no tiene pintura: el filtro cambia lo que pintes en ella."), - ("0 turns autosave off. Copies go to {folder}", "0 desactiva el autoguardado. Las copias se guardan en {folder}"), - ("2D view only", "Solo vista 2D"), - ("32 bits (float)", "32 bits (float)"), - ("3D mesh", "Malla 3D"), - ("3D meshes", "Mallas 3D"), - ( - "3D texture painting: layers, masks, smart materials, mesh map baking and export.", - "Pintura de texturas 3D: capas, máscaras, materiales inteligentes, horneado de mapas de malla y exportación.", - ), - ("3D view only", "Solo vista 3D"), - ("3D/2D views", "Vistas 3D/2D"), - ( - "A folder blends its children (pass-through). Set per-channel opacity in the layer rows.", - "Una carpeta fusiona sus elementos (paso directo). Define la opacidad por canal en las filas de capa.", - ), - ("ACES filmic", "ACES fílmico"), - ("Ambient", "Ambiente"), - ("AO intensity", "Intensidad de AO"), - ("About TextureCraft", "Acerca de TextureCraft"), - ("About TextureCraft...", "Acerca de TextureCraft..."), - ("Add an anchor point to a layer below to use its stack as a mask.", "Añade un punto de anclaje a una capa inferior para usar su pila como máscara."), - ("Add anchor point", "Añadir punto de anclaje"), - ("Add as decal (view center)", "Añadir como calcomanía (centro de la vista)"), - ("Add black mask", "Añadir máscara negra"), - ("Add channel", "Añadir canal"), - ("Add color", "Añadir color"), - ("Add compare mask", "Añadir máscara de comparación"), - ("Add effect", "Añadir efecto"), - ("Add fill", "Añadir relleno"), - ("Add fill layer", "Añadir capa de relleno"), - ("Add filter", "Añadir filtro"), - ("Add folder", "Añadir carpeta"), - ("Add generator", "Añadir generador"), - ("Add levels", "Añadir niveles"), - ("Add mask", "Añadir máscara"), - ("Add mask with color selection", "Añadir máscara con selección de color"), - ("Add output", "Añadir salida"), - ("Add paint", "Añadir pintura"), - ("Add paint layer", "Añadir capa de pintura"), - ("Add smart material from the shelf", "Añadir material inteligente desde la biblioteca"), - ("Add to the layer content", "Añadir al contenido de la capa"), - ("Add to the mask", "Añadir a la máscara"), - ("Add white mask", "Añadir máscara blanca"), - ("Adjustments", "Ajustes de imagen"), - ( - "Aligned: the offset set by the first stroke is kept. V + click sets a new source.", - "Alineado: se mantiene el desplazamiento definido por el primer trazo. V + clic define un nuevo origen.", - ), - ("Alignment", "Alineación"), - ("Alignment and culling", "Alineación y descarte"), - ("All layers", "Todas las capas"), - ("Alpha", "Alfa"), - ("Alphas", "Alfas"), - ("Also bound to {item} ({menu})", "También asignado a {item} ({menu})"), - ("Alt + LMB drag", "Alt + arrastrar con botón izq."), - ("Always", "Siempre"), - ("Ambient Occlusion", "Oclusión ambiental"), - ("Ambient occlusion", "Oclusión ambiental"), - ("Amount", "Cantidad"), - ("Anchor point", "Punto de anclaje"), - ("Anchor: {name}", "Anclaje: {name}"), - ("Anchor: {name} ({channel})", "Anclaje: {name} ({channel})"), - ("Angle", "Ángulo"), - ("Angle (degrees)", "Ángulo (grados)"), - ("Angle fade from", "Atenuación por ángulo desde"), - ("Angle fade to", "Atenuación por ángulo hasta"), - ("Angle jitter", "Variación de ángulo"), - ("Anisotropy angle", "Ángulo de anisotropía"), - ("Anisotropy level", "Nivel de anisotropía"), - ("Antialiasing", "Antialiasing"), - ("Aperture", "Apertura"), - ("Apply", "Aplicar"), - ("ArtCraft website...", "Sitio web de ArtCraft..."), - ("Assets", "Recursos"), - ("Auto", "Auto"), - ("Automatic (from the mesh UVs)", "Automático (según las UV de la malla)"), - ("Autosave every", "Autoguardar cada"), - ( - "Autosaves, smart materials, presets, templates and UI layouts go to the data folder. A new folder applies on restart; files already saved stay where they are.", - "Las copias automáticas, los materiales inteligentes, los ajustes preestablecidos, las plantillas y los diseños de la interfaz se guardan en la carpeta de datos. Una carpeta nueva se aplica al reiniciar; los archivos ya guardados se quedan donde están.", - ), - ("Axis", "Eje"), - ("Back to painting", "Volver a pintar"), - ("Backface culling", "Descarte de caras traseras"), - ("Bake an ID map (F8) to pick colors from the mesh.", "Hornea un mapa de ID (F8) para tomar colores de la malla."), - ("Bake Mesh Maps", "Hornear mapas de malla"), - ("Bake mesh maps", "Hornear mapas de malla"), - ( - "Bake mesh maps (F8) for curvature, AO and thickness based generators.", - "Hornea los mapas de malla (F8) para los generadores basados en curvatura, AO y grosor.", - ), - ("Baked Lighting", "Iluminación horneada"), - ("Baking", "Horneado"), - ("Base color", "Color base"), - ( - "Base color is the diffuse color, Specular the F0 color and Glossiness 1 - roughness (add these channels in the texture set settings).", - "Color base es el color difuso, Especular el color F0 y Brillo 1 - rugosidad (añade estos canales en los ajustes del conjunto de texturas).", - ), - ("Base color, Metallic, Roughness and Specular level.", "Color base, Metálico, Rugosidad y Nivel especular."), - ("Based on each texture set's size", "Según el tamaño de cada conjunto de texturas"), - ("Basic settings", "Ajustes básicos"), - ("Bent Normals", "Normales curvadas"), - ("Bevel", "Bisel"), - ("Black", "Negro"), - ("Blending", "Fusión"), - ("Blending mode of the displayed channel", "Modo de fusión del canal mostrado"), - ("Blur", "Desenfoque"), - ("Blur Directional", "Desenfoque direccional"), - ("Blur and sharpen", "Desenfocar y enfocar"), - ("Bounces", "Rebotes"), - ("Bricks", "Ladrillos"), - ("Brush", "Pincel"), - ("Brush size", "Tamaño del pincel"), - ("Brush size down / up", "Reducir / aumentar tamaño del pincel"), - ("Brushed lines", "Líneas cepilladas"), - ("Built-in (read-only): duplicate it to edit", "Integrada (solo lectura): duplícala para editarla"), - ("Built-in templates are read-only: duplicate one to edit it", "Las plantillas integradas son de solo lectura: duplica una para editarla"), - ("Built-in: {mesh}", "Integrada: {mesh}"), - ("Cage: {name}", "Jaula: {name}"), - ("Camera", "Cámara"), - ("Colors", "Colores"), - ("Go to camera 1", "Ir a la cámara 1"), - ("Go to camera 2", "Ir a la cámara 2"), - ("Go to camera 3", "Ir a la cámara 3"), - ("Go to camera 4", "Ir a la cámara 4"), - ("Go to camera 5", "Ir a la cámara 5"), - ("Go to camera 6", "Ir a la cámara 6"), - ("Go to camera 7", "Ir a la cámara 7"), - ("Go to camera 8", "Ir a la cámara 8"), - ("Go to camera 9", "Ir a la cámara 9"), - ("Camera settings", "Ajustes de cámara"), - ("Cancel", "Cancelar"), - ("Cancel the stroke", "Cancelar el trazo"), - ("Cell size (texels at 2K)", "Tamaño de celda (téxeles a 2K)"), - ("Cells", "Celdas"), - ("Channel", "Canal"), - ("Channel source: uniform value, procedural, image or anchor", "Origen del canal: valor uniforme, procedural, imagen o anclaje"), - ("Channels", "Canales"), - ("Check for Updates...", "Buscar actualizaciones..."), - ("Checker", "Damero"), - ("Clamp", "Limitar"), - ("Clear", "Borrar"), - ("Clear mask", "Borrar máscara"), - ("Clear recent projects", "Borrar proyectos recientes"), - ("Click a mesh part to show or hide the selected layer on it.", "Haz clic en una parte de la malla para mostrar u ocultar en ella la capa seleccionada."), - ("Click the mesh to pick its material into the brush", "Haz clic en la malla para tomar su material en el pincel"), - ("Click the mesh to place the decal", "Haz clic en la malla para colocar la calcomanía"), - ("Click, then press the new shortcut (Esc cancels)", "Haz clic y pulsa el nuevo atajo (Esc cancela)"), - ("Clone", "Clonar"), - ("Close", "Cerrar"), - ("Closed path", "Trazado cerrado"), - ("Cloud", "Nube"), - ("Clouds", "Nubes"), - ("Coat normal", "Normal del barniz"), - ("Coat roughness", "Rugosidad del barniz"), - ("Coat weight", "Peso del barniz"), - ("Color", "Color"), - ("Color Balance", "Equilibrio de color"), - ("Color burn", "Subexponer color"), - ("Color dodge", "Sobreexponer color"), - ( - "Color of the light that travels under the surface (each channel goes as far as its value)", - "Color de la luz que viaja bajo la superficie (cada canal llega tan lejos como su valor)", - ), - ("Color picker", "Cuentagotas"), - ("Color selection", "Selección de color"), - ("Color to replace", "Color a reemplazar"), - ( - "Colors near the first shift towards the second, keeping their shading.", - "Los colores cercanos al primero se desplazan hacia el segundo y conservan su sombreado.", - ), - ( - "Colors read as gray. Add a levels or blur effect above to shape the result.", - "Los colores se leen como gris. Añade encima un efecto de niveles o desenfoque para ajustar el resultado.", - ), - ("Combine with the layer's height", "Combinar con la altura de la capa"), - ("Compare mask", "Máscara de comparación"), - ("Compositing", "Composición"), - ("Constant", "Constante"), - ("Constants", "Constantes"), - ("Contrast", "Contraste"), - ("Contrast/Luminosity", "Contraste/Luminosidad"), - ("Converted maps", "Mapas convertidos"), - ("Copy RGB values", "Copiar los valores RGB"), - ("Copy effect", "Copiar efecto"), - ("Copy from", "Copiar de"), - ("Copy layer(s)", "Copiar capa(s)"), - ("Copy the selected layer alone (its empty parts copy nothing)", "Copiar solo la capa seleccionada (sus partes vacías no copian nada)"), - ("Copy to all texture sets", "Copiar a todos los conjuntos de texturas"), - ("Copy what the texture set shows", "Copiar lo que muestra el conjunto de texturas"), - ("Couldn't encode the render", "No se pudo codificar el render"), - ("Couldn't export textures: {error}", "No se pudieron exportar las texturas: {error}"), - ("Couldn't export the mesh: {error}", "No se pudo exportar la malla: {error}"), - ("Couldn't export the template: {error}", "No se pudo exportar la plantilla: {error}"), - ("Couldn't import {name}: {error}", "No se pudo importar {name}: {error}"), - ("Couldn't open {name}: {error}", "No se pudo abrir {name}: {error}"), - ("Couldn't read the render back from the GPU", "No se pudo recuperar el render de la GPU"), - ("Couldn't save the render: {error}", "No se pudo guardar el render: {error}"), - ("Couldn't save {name}: {error}", "No se pudo guardar {name}: {error}"), - ("Count per stamp", "Cantidad por estampado"), - ("Crate", "Caja"), - ("Create", "Crear"), - ("Create smart material", "Crear material inteligente"), - ( - "Ctrl+right-drag in a view sets the size and hardness, Ctrl+left-drag the flow and angle.", - "Ctrl+arrastrar con botón der. en una vista ajusta el tamaño y la dureza; Ctrl+arrastrar con botón izq., el flujo y el ángulo.", - ), - ("Cube", "Cubo"), - ("Current layer", "Capa actual"), - ("Curvature", "Curvatura"), - ("Cut effect", "Cortar efecto"), - ("Cut layer(s)", "Cortar capa(s)"), - ("Cyan / red", "Cian / rojo"), - ("Cylinder", "Cilindro"), - ("Cylindrical projection", "Proyección cilíndrica"), - ( - "Dark to light: the content's luminance picks a color along these stops.", - "De oscuro a claro: la luminancia del contenido elige un color a lo largo de estos puntos.", - ), - ("Darken (Min)", "Oscurecer (mín.)"), - ("Data folder", "Carpeta de datos"), - ("Decal", "Calcomanía"), - ("Decal projection", "Proyección de calcomanía"), - ("Default", "Predeterminado"), - ("Default camera", "Cámara predeterminada"), - ("Delete the selected template", "Eliminar la plantilla seleccionada"), - ("Delete this camera", "Eliminar esta cámara"), - ("Deleted template \"{name}\"", "Plantilla \"{name}\" eliminada"), - ("Denoise", "Eliminar ruido"), - ("Depth", "Profundidad"), - ("Depth of field", "Profundidad de campo"), - ("Depth of field (viewport and Rendering mode)", "Profundidad de campo (ventana gráfica y modo Renderizado)"), - ("Depth of the sharp plane along the view (0: the orbit center)", "Profundidad del plano nítido a lo largo de la vista (0: el centro de órbita)"), - ("Details saved to {file}", "Detalles guardados en {file}"), - ("Difference", "Diferencia"), - ("Dilation + default background color", "Dilatación + color de fondo predeterminado"), - ("Dilation + transparent", "Dilatación + transparente"), - ("Dilation infinite", "Dilatación infinita"), - ("DirectX normal map", "Mapa de normales DirectX"), - ("Dirt", "Suciedad"), - ("Disable", "Desactivado"), - ("Dismiss", "Cerrar"), - ("Displacement (height channel)", "Desplazamiento (canal de altura)"), - ("Display Settings", "Ajustes de visualización"), - ("Display material", "Mostrar material"), - ("Display next channel", "Mostrar canal siguiente"), - ("Display next mesh map", "Mostrar mapa de malla siguiente"), - ("Display previous channel", "Mostrar canal anterior"), - ("Display previous mesh map", "Mostrar mapa de malla anterior"), - ("Distance", "Distancia"), - ("Distort", "Distorsionar"), - ("Divide", "Dividir"), - ("Document resolution", "Resolución del documento"), - ("Documentation...", "Documentación..."), - ("Done on CPU: {n} / {max} samples, {s} s", "Terminado en CPU: {n} / {max} muestras, {s} s"), - ("Done on GPU: {n} / {max} samples, {s} s", "Terminado en GPU: {n} / {max} muestras, {s} s"), - ("Double-click to rename", "Doble clic para cambiar el nombre"), - ("Download as", "Descargar como"), - ("Downloaded {name}", "{name} descargado"), - ("Drag onto an output channel", "Arrastrar a un canal de salida"), - ( - "Drags the layer stack's values along the stroke into the selected layer.", - "Arrastra los valores de la pila de capas a lo largo del trazo hacia la capa seleccionada.", - ), - ( - "Draws {name} of texture set \"{set}\". Edits to the source show in every instance.", - "Dibuja {name} del conjunto de texturas \"{set}\". Los cambios en el original se ven en todas las instancias.", - ), - ( - "Drag the frame to move the decal, a corner to scale it, the round handle to turn it", - "Arrastra el marco para mover la calcomanía, una esquina para escalarla y el tirador redondo para girarla", - ), - ("Drop an image from the Assets panel here to use it as this mesh map", "Suelta aquí una imagen del panel Recursos para usarla como este mapa de malla"), - ("Dry streaks", "Trazos secos"), - ("Duplicate effect", "Duplicar efecto"), - ("Duplicate layer(s)", "Duplicar capa(s)"), - ("Duplicate the selected template", "Duplicar la plantilla seleccionada"), - ("Edge Detect", "Detección de bordes"), - ("Edit", "Editar"), - ("Edit keyboard shortcuts...", "Editar atajos de teclado..."), - ("Edit quick mask", "Editar máscara rápida"), - ("Editing quick mask: paint where painting is allowed (U to finish)", "Editando máscara rápida: pinta donde se permite pintar (U para terminar)"), - ( - "Editing the quick mask: strokes paint where painting is allowed. Press U to finish.", - "Editando la máscara rápida: los trazos pintan donde se permite pintar. Pulsa U para terminar.", - ), - ("Emissive", "Emisivo"), - ("Enable or disable the effect", "Activar o desactivar el efecto"), - ("Enable quick mask", "Activar máscara rápida"), - ("Environment blur", "Desenfoque del entorno"), - ("Environment exposure (EV)", "Exposición del entorno (EV)"), - ("Environment map", "Mapa de entorno"), - ("Environment opacity", "Opacidad del entorno"), - ("Environment rotation", "Rotación del entorno"), - ("Environment settings", "Ajustes de entorno"), - ("Environment: {name}", "Entorno: {name}"), - ("Environments", "Entornos"), - ("Eraser", "Borrador"), - ("Exclusion", "Exclusión"), - ("Expand or collapse the folder", "Expandir o contraer la carpeta"), - ("Export", "Exportar"), - ("Export Mesh...", "Exportar malla..."), - ("Export Textures...", "Exportar texturas..."), - ("Export mesh", "Exportar malla"), - ("Export template", "Plantilla de exportación"), - ("Export templates", "Plantillas de exportación"), - ("Export textures", "Exportar texturas"), - ("Export the selected template (.json)", "Exportar la plantilla seleccionada (.json)"), - ("Exported mesh to {path}", "Malla exportada a {path}"), - ("Exported template \"{name}\" to {path}", "Plantilla \"{name}\" exportada a {path}"), - ("Exported {n} textures to {folder}", "{n} texturas exportadas a {folder}"), - ("F0 from specular level", "F0 desde nivel especular"), - ("Fabric weave", "Tejido"), - ("Field of view (deg)", "Campo de visión (grados)"), - ("File", "Archivo"), - ("File name without extension; variables insert names", "Nombre de archivo sin extensión; las variables insertan nombres"), - ("File type", "Tipo de archivo"), - ("Fill", "Relleno"), - ("Fill the closed path (lasso)", "Rellenar el trazado cerrado (lazo)"), - ("Fill the path (close it first)", "Rellenar el trazado (ciérralo antes)"), - ("Filter", "Filtro"), - ("Filter the remaining noise while keeping edges and texture detail", "Filtrar el ruido restante conservando los bordes y el detalle de la textura"), - ("Filters", "Filtros"), - ("Fine noise", "Ruido fino"), - ("Fingerprints", "Huellas dactilares"), - ("Enter a finite number", "Introduce un número finito"), - ("Double-click or press Enter to edit", "Haz doble clic o pulsa Intro para editar"), - ("Fit the input range to the histogram", "Ajustar el rango de entrada al histograma"), - ("Flatten layer", "Acoplar capa"), - ( - "Flips the image's green channel, for normal maps made with Y pointing down", - "Invierte el canal verde de la imagen, para mapas de normales hechos con Y hacia abajo", - ), - ("Flow", "Flujo"), - ("Flow and opacity", "Flujo y opacidad"), - ("Flow jitter", "Variación de flujo"), - ("Focus distance", "Distancia de enfoque"), - ("Folder", "Carpeta"), - ("Folders", "Carpetas"), - ("Follow path", "Seguir trayectoria"), - ( - "For the whole project: how normal map images set as mesh maps are read (set them again after a change), and the default for export", - "Para todo el proyecto: cómo se leen las imágenes de mapas de normales usadas como mapas de malla (vuelve a asignarlas tras un cambio) y el valor predeterminado al exportar", - ), - ("Free and open source (MIT OR Apache-2.0), written in Rust.", "Libre y de código abierto (MIT OR Apache-2.0), escrito en Rust."), - ("From template", "Desde la plantilla"), - ("From template / project", "Desde la plantilla / el proyecto"), - ("Full", "Completa"), - ("GPU error: {error}", "Error de GPU: {error}"), - ("Geometry mask", "Máscara de geometría"), - ( - "GGX specular with height-correlated Smith visibility, Lambert diffuse, split-sum image-based lighting with spherical-harmonics irradiance and horizon fading.", - "Especular GGX con visibilidad Smith correlacionada con la altura, difuso Lambert, iluminación basada en imagen de suma dividida con irradiancia por armónicos esféricos y atenuación en el horizonte.", - ), - ("Gamma", "Gamma"), - ("General export parameters", "Parámetros generales de exportación"), - ("General properties", "Propiedades generales"), - ("Generator", "Generador"), - ("Geometry and UVs only", "Solo geometría y UV"), - ("Glossiness", "Brillo"), - ("Glossiness from roughness", "Brillo desde rugosidad"), - ("Glow", "Resplandor"), - ("Gradient", "Degradado"), - ("Gradient Map", "Mapa de degradado"), - ("Gravity", "Gravedad"), - ("Gray", "Gris"), - ("Gray + A", "Gris + A"), - ("Gray 50%", "Gris 50%"), - ("Grayscale", "Escala de grises"), - ("Group layer(s)", "Agrupar capa(s)"), - ("Grunge", "Grunge"), - ("HDR environments", "Entornos HDR"), - ("High Pass", "Paso alto"), - ("HSL Perceptive", "HSL perceptivo"), - ("Half", "Mitad"), - ("Hammered", "Martillado"), - ("Hard light", "Luz fuerte"), - ("Hardness", "Dureza"), - ("Height", "Altura"), - ("Height offset", "Desplazamiento de altura"), - ("Height to normal strength", "Intensidad de altura a normal"), - ("Help", "Ayuda"), - ("Hide UI", "Ocultar interfaz"), - ("High", "Alto"), - ("High poly: {name}", "High poly: {name}"), - ("Highlights", "Iluminaciones"), - ("Histogram Range", "Rango de histograma"), - ("Histogram Scan", "Barrido de histograma"), - ("Histogram Shift", "Desplazamiento de histograma"), - ("History", "Historial"), - ( - "Hold S: left-drag rotates, right-drag scales, middle-drag moves the stencil.", - "Mantén S: arrastrar con botón izq. rota, con botón der. escala y con botón central mueve la plantilla.", - ), - ("Hold V and click the mesh to set the clone source", "Mantén V y haz clic en la malla para definir el origen de clonado"), - ( - "Hold V and click the mesh to set the source, then paint elsewhere to copy it.", - "Mantén V y haz clic en la malla para definir el origen; luego pinta en otro lugar para copiarlo.", - ), - ( - "How far light travels under the surface, as a fraction of the mesh size (where the Scattering weight channel is painted)", - "Distancia que recorre la luz bajo la superficie, como fracción del tamaño de la malla (donde se pinta el canal Peso de dispersión)", - ), - ( - "How strongly transmissive surfaces bend light (where the Transmission channel is painted): water 1.33, glass 1.5, diamond 2.42", - "Cuánto desvían la luz las superficies transmisivas (donde se pinta el canal Transmisión): agua 1.33, vidrio 1.5, diamante 2.42", - ), - ("Hue shift (degrees)", "Cambio de tono (grados)"), - ("ID", "ID"), - ("Image: {name}", "Imagen: {name}"), - ("Images", "Imágenes"), - ("Import HDR...", "Importar HDR..."), - ("Import a template (.json)", "Importar una plantilla (.json)"), - ( - "Import an image (File > Import resources) to project it onto the mesh.", - "Importa una imagen (Archivo > Importar recursos) para proyectarla sobre la malla.", - ), - ("Import images to use them in fills and masks", "Importar imágenes para usarlas en rellenos y máscaras"), - ("Import resources...", "Importar recursos..."), - ("Import MaterialX material...", "Importar material MaterialX..."), - ("MaterialX materials", "Materiales MaterialX"), - ("Import...", "Importar..."), - ("Imported template \"{name}\"", "Plantilla \"{name}\" importada"), - ("Imported {name}", "{name} importado"), - ("Index of refraction", "Índice de refracción"), - ("Input high", "Entrada alta"), - ("Input low", "Entrada baja"), - ("Input maps", "Mapas de entrada"), - ("Insert a variable", "Insertar una variable"), - ("Instance", "Instancia"), - ("Instantiate across texture sets", "Instanciar en los conjuntos de texturas"), - ("Intensity (texels at 2K)", "Intensidad (téxeles a 2K)"), - ("Interface", "Interfaz"), - ("Interface scale", "Escala de la interfaz"), - ("Inverse Subtract", "Resta inversa"), - ("Inverse divide", "División inversa"), - ("Invert", "Invertir"), - ("Invert mask", "Invertir máscara"), - ("Invert mask background", "Invertir fondo de la máscara"), - ("Invert mask value", "Invertir valor de máscara"), - ("Invert quick mask", "Invertir máscara rápida"), - ("Jitters", "Variaciones"), - ("Join the ArtCraft community on Discord", "Únete a la comunidad de ArtCraft en Discord"), - ("Join the community (Discord)...", "Unirse a la comunidad (Discord)..."), - ("Key light (shadow-casting light, direct only)", "Luz principal (proyecta sombras, solo directa)"), - ("Keyboard", "Teclado"), - ("Keyboard shortcuts", "Atajos de teclado"), - ("Light azimuth (degrees)", "Acimut de la luz (grados)"), - ("Light elevation (degrees)", "Elevación de la luz (grados)"), - ("Light intensity", "Intensidad de la luz"), - ("LMB", "Botón izq."), - ("Language", "Idioma"), - ("Layer mask", "Máscara de capa"), - ("Layer memory: {mb} MB", "Memoria de capas: {mb} MB"), - ("Layers", "Capas"), - ("Lazy mouse", "Ratón perezoso"), - ("Lazy mouse distance", "Distancia del ratón perezoso"), - ("Leather grain", "Grano de cuero"), - ("Lens size: how quickly things blur away from the focus distance", "Tamaño de la lente: lo rápido que se desenfoca todo fuera de la distancia de enfoque"), - ("Level", "Nivel"), - ("Levels", "Niveles"), - ("Lifetime (steps)", "Duración (pasos)"), - ("Light / direction", "Luz / dirección"), - ("Lighten (Max)", "Aclarar (máx.)"), - ("Lightness", "Claridad"), - ("Linear", "Lineal"), - ("Linear burn", "Subexposición lineal"), - ("Linear dodge (Add)", "Sobreexposición lineal (añadir)"), - ("Linear light", "Luz lineal"), - ("List of exports", "Lista de exportaciones"), - ("Load UI Layout", "Cargar diseño de interfaz"), - ("Loaded UI layout {path}", "Diseño de interfaz cargado: {path}"), - ("Log", "Registro"), - ("Low", "Bajo"), - ("Luminosity", "Luminosidad"), - ("MMB drag / Alt + MMB", "Arrastrar con botón central / Alt + botón central"), - ("Made by the ArtCraft team and community.", "Creado por el equipo y la comunidad de ArtCraft."), - ("Magenta / green", "Magenta / verde"), - ("Main shader", "Sombreador principal"), - ("Marble veins", "Vetas de mármol"), - ("Mask", "Máscara"), - ("Mask Editor: Edge wear", "Editor de máscaras: desgaste de bordes"), - ("Mask value (gray)", "Valor de máscara (gris)"), - ("Mask with height", "Enmascarar con la altura"), - ("MatFinish Grind", "Acabado amolado"), - ("MatFinish Hammered", "Acabado martillado"), - ("MatFinish Raw", "Acabado en bruto"), - ("MatFinish Sanded", "Acabado lijado"), - ("Material", "Material"), - ("Material ball", "Bola de material"), - ("Material finish", "Acabado de material"), - ("Materials", "Materiales"), - ("Maximum", "Máximo"), - ("Mesh fill", "Relleno de malla"), - ("Mesh map: {map}", "Mapa de malla: {map}"), - ("Mesh maps", "Mapas de malla"), - ("Mesh maps baked", "Mapas de malla horneados"), - ("Meshes", "Mallas"), - ("Metallic", "Metálico"), - ("Midtones", "Medios tonos"), - ("Minimum", "Mínimo"), - ("Minimum size (%)", "Tamaño mínimo (%)"), - ("Missing (bake to create)", "Falta (hornear para crear)"), - ("Mixed AO", "AO mixta"), - ("Mode", "Modo"), - ("More in Assets > Alphas: click one, or drag it here", "Más en Recursos > Alfas: haz clic en uno o arrástralo aquí"), - ("Mosaic", "Mosaico"), - ("Move down", "Bajar"), - ("Move up", "Subir"), - ( - "Moves the surface by the height channel on a finer copy of the mesh, at the height to normal strength (viewport only: painting follows the base surface)", - "Desplaza la superficie según el canal de altura sobre una copia más fina de la malla, con la intensidad de altura a normal (solo en el visor: la pintura sigue la superficie base)", - ), - ("Multiply", "Multiplicar"), - ("My smart materials", "Mis materiales inteligentes"), - ("Name", "Nombre"), - ("New project", "Nuevo proyecto"), - ("New project...", "Nuevo proyecto..."), - ("New template", "Nueva plantilla"), - ("No GPU renderer available", "No hay ningún renderizador de GPU disponible"), - ("No font on this system can show this language", "Ninguna fuente del sistema puede mostrar este idioma"), - ( - "No outputs yet: add one above, then drag input maps onto its channels.", - "Aún no hay salidas: añade una arriba y arrastra mapas de entrada a sus canales.", - ), - ("No padding (passthrough)", "Sin margen (paso directo)"), - ("Noise amount", "Cantidad de ruido"), - ("Noise scale", "Escala del ruido"), - ("None", "Ninguno"), - ("Normal", "Normal"), - ("Normal DirectX", "Normal DirectX"), - ("Normal Invert", "Invertir normal"), - ("Normal OpenGL", "Normal OpenGL"), - ("Normal from height", "Normal desde altura"), - ("Normal map combine", "Combinar mapa de normales"), - ("Normal map detail", "Detalle de mapa de normales"), - ("Color space", "Espacio de color"), - ("Normal map format", "Formato del mapa de normales"), - ("Normal map inverse detail", "Detalle inverso de mapa de normales"), - ("Normal: painting uses the flat normal", "Normal: la pintura usa la normal plana"), - ( - "Not enough GPU memory to show texture set \"{name}\" fully: lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "No hay suficiente memoria de GPU para mostrar el conjunto de texturas \"{name}\" por completo: reduce en Ajustes la resolución de texturas de la ventana gráfica. La pintura y la exportación no se ven afectadas.", - ), - ( - "Not enough GPU memory to show {count} texture sets fully ({names}): lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "No hay suficiente memoria de GPU para mostrar por completo {count} conjuntos de texturas ({names}): reduce en Ajustes la resolución de texturas de la ventana gráfica. La pintura y la exportación no se ven afectadas.", - ), - ("Not exported: no source in this texture set", "No exportado: no hay origen en este conjunto de texturas"), - ("Not saved: {error}", "No guardado: {error}"), - ("Off", "Desactivado"), - ("Offset", "Desplazamiento"), - ("Offset right", "Desplazamiento a la derecha"), - ("Offset up", "Desplazamiento hacia arriba"), - ("Offset {axis}", "Desplazamiento {axis}"), - ( - "Offsets the textures by the height channel, at the height to normal strength", - "Desplaza las texturas según el canal de altura, con la intensidad de altura a normal", - ), - ("On", "Activado"), - ("Opacity", "Opacidad"), - ("Open sample project...", "Abrir proyecto de ejemplo..."), - ("Open...", "Abrir..."), - ("Opened {name}", "{name} abierto"), - ( - "Optional channels add a clear coat (Coat weight, Coat roughness, Coat normal), sheen (Sheen weight, color, roughness), anisotropy (Anisotropy level, angle), subsurface scattering (Scattering weight) and transmission (Transmission).", - "Los canales opcionales añaden barniz (Peso del barniz, Rugosidad del barniz, Normal del barniz), lustre (Peso del lustre, color, rugosidad), anisotropía (Nivel de anisotropía, ángulo), dispersión subsuperficial (Peso de dispersión) y transmisión (Transmisión).", - ), - ("Orbit", "Orbitar"), - ("Orthographic", "Ortográfica"), - ("Perspective", "Perspectiva"), - ("Output directory", "Directorio de salida"), - ("Output high", "Salida alta"), - ("Output low", "Salida baja"), - ("Output template", "Plantilla de salida"), - ("Output templates", "Plantillas de salida"), - ("Overlay", "Superponer"), - ("Overlay opacity", "Opacidad de superposición"), - ("PBR - Metallic Roughness (TextureCraft)", "PBR - Metálico Rugosidad (TextureCraft)"), - ("Pick color", "Tomar color"), - ("PNG image", "Imagen PNG"), - ("Padding", "Margen"), - ("Paint", "Pintar"), - ("Paint chips", "Pintura desconchada"), - ("Paint on the mesh to edit the layer content.", "Pinta sobre la malla para editar el contenido de la capa."), - ( - "Paint on the mesh to edit this mask. Use the Material tab's mask value for gray.", - "Pinta sobre la malla para editar esta máscara. Usa el valor de máscara de la pestaña Material para el gris.", - ), - ("Paint with the current tool", "Pintar con la herramienta actual"), - ( - "Painted layer pixels {pixels} MB, composited channels {composites} MB, compositing cache {cache} MB", - "Píxeles de capas pintadas {pixels} MB, canales compuestos {composites} MB, caché de composición {cache} MB", - ), - ("Painting", "Pintura"), - ("Pan", "Desplazar"), - ("Parallax occlusion (height channel)", "Oclusión de paralaje (canal de altura)"), - ( - "Partial mask values follow the layer's height: high parts show first", - "Los valores parciales de la máscara siguen la altura de la capa: las partes altas aparecen primero", - ), - ("Particle brush (slides down the surface)", "Pincel de partículas (se deslizan por la superficie)"), - ("Particle brush: particles slide down the surface", "Pincel de partículas: las partículas se deslizan por la superficie"), - ("Particles", "Partículas"), - ("Passthrough", "Paso directo"), - ("Paste as instance", "Pegar como instancia"), - ("Paste effect", "Pegar efecto"), - ("Paste layer(s)", "Pegar capa(s)"), - ("Path", "Trazado"), - ("Path trace on the processor instead of the graphics card (slower)", "Trazar trayectorias en el procesador en lugar de la tarjeta gráfica (más lento)"), - ( - "Path: click adds a point, click the curve inserts one, drag moves it, Enter applies, Esc cancels", - "Trazado: clic añade un punto, clic en la curva inserta uno, arrastrar lo mueve, Intro aplica, Esc cancela", - ), - ("Pattern scale", "Escala del patrón"), - ("Perlin noise", "Ruido Perlin"), - ("Pick focus in the viewport", "Elegir el enfoque en la ventana gráfica"), - ("Pin light", "Luz focal"), - ("Place on the surface", "Colocar en la superficie"), - ("Place path points on the mesh", "Coloca puntos del trazado sobre la malla"), - ("Planar projection", "Proyección planar"), - ("Plane", "Plano"), - ("Polygon fill", "Relleno de polígonos"), - ("Pores", "Poros"), - ("Position", "Posición"), - ("Position gradient", "Degradado de posición"), - ("Position jitter", "Variación de posición"), - ("Posterize", "Posterizar"), - ("Press a key...", "Pulsa una tecla..."), - ("Procedurals", "Procedurales"), - ("Project", "Proyecto"), - ("Project Configuration...", "Configuración del proyecto..."), - ("Project opened", "Proyecto abierto"), - ("Project template", "Plantilla de proyecto"), - ("Projection", "Proyección"), - ("Projects and meshes", "Proyectos y mallas"), - ("Properties", "Propiedades"), - ("Quarter", "Cuarto"), - ("Quick mask", "Máscara rápida"), - ("Quit", "Salir"), - ("Radius (texels at 2K)", "Radio (téxeles a 2K)"), - ("RENDERING", "RENDERIZADO"), - ("Range", "Rango"), - ("Rebind any menu item, tool or command", "Reasignar cualquier elemento de menú, herramienta o comando"), - ("Recent projects", "Proyectos recientes"), - ( - "Records the stack up to this layer. Fill effects in masks (and fill layers) above can read it as a source.", - "Registra la pila hasta esta capa. Los efectos de relleno de las máscaras (y las capas de relleno) superiores pueden leerla como origen.", - ), - ("Redo", "Rehacer"), - ("Reimport mesh", "Reimportar malla"), - ("Remove", "Quitar"), - ("Remove channel", "Quitar canal"), - ("Remove effect", "Quitar efecto"), - ("Remove last", "Quitar el último"), - ("Remove layer", "Eliminar capa"), - ("Remove layer(s)", "Eliminar capa(s)"), - ("Remove mask", "Quitar máscara"), - ("Remove point", "Quitar punto"), - ("Remove resource", "Quitar recurso"), - ("Remove the shortcut", "Quitar el atajo"), - ("Remove this output", "Quitar esta salida"), - ("Remove unused resources...", "Quitar recursos no usados..."), - ("Rename the selected template", "Cambiar el nombre de la plantilla seleccionada"), - ("Render on the CPU", "Renderizar en la CPU"), - ("Rendering", "Renderizado"), - ("Rendering (path traced)", "Renderizado (trazado de trayectorias)"), - ("Rendering on CPU: {n} / {max} samples, {s} s", "Renderizando en CPU: {n} / {max} muestras, {s} s"), - ("Rendering on GPU: {n} / {max} samples, {s} s", "Renderizando en GPU: {n} / {max} muestras, {s} s"), - ("Rendering, path traced", "Renderizado con trazado de trayectorias"), - ("Replace", "Reemplazar"), - ("Replace Color", "Reemplazar color"), - ("Replacement color", "Color de reemplazo"), - ("Report a bug...", "Informar de un error..."), - ("Rescan the library folder", "Volver a examinar la carpeta de la biblioteca"), - ("Reset", "Restablecer"), - ("Reset UI", "Restablecer interfaz"), - ("Reset all", "Restablecer todo"), - ("Reset to defaults", "Restablecer valores predeterminados"), - ("Reset to {shortcut}", "Restablecer a {shortcut}"), - ("Resizing", "Redimensionando"), - ("Restore every default shortcut", "Restaurar todos los atajos predeterminados"), - ("Return to this step", "Volver a este paso"), - ("Right-click a layer > Create smart material", "Clic derecho en una capa > Crear material inteligente"), - ("Rotation", "Rotación"), - ("Rotation (degrees)", "Rotación (grados)"), - ("Roughness", "Rugosidad"), - ("Roughness from glossiness", "Rugosidad desde brillo"), - ("Round", "Redondo"), - ("Rounded cube", "Cubo redondeado"), - ("Samples", "Muestras"), - ("Saturation", "Saturación"), - ("Save", "Guardar"), - ("Save UI Layout", "Guardar diseño de interfaz"), - ("Save a copy...", "Guardar una copia..."), - ("Save as...", "Guardar como..."), - ("Save current layout...", "Guardar diseño actual..."), - ("Save render...", "Guardar render..."), - ("Save view as camera", "Guardar vista como cámara"), - ("Saved UI layout {path}", "Diseño de interfaz guardado: {path}"), - ("Saved {path}", "Guardado: {path}"), - ("Saving UI layouts to files is available in the desktop app", "Guardar diseños de interfaz en archivos está disponible en la aplicación de escritorio"), - ("Scale", "Escala"), - ("Scale / tiling", "Escala / repetición"), - ("Scatter color", "Color de dispersión"), - ("Scatter radius", "Radio de dispersión"), - ("Scattering weight", "Peso de dispersión"), - ("Scratches", "Arañazos"), - ("Screen", "Trama"), - ("Screenshot of the viewport", "Captura de la ventana gráfica"), - ("Search", "Buscar"), - ("Search all assets", "Buscar en todos los recursos"), - ("Search commands or keys", "Buscar comandos o teclas"), - ("Seed", "Semilla"), - ("Select a layer", "Selecciona una capa"), - ("Select an output template", "Selecciona una plantilla de salida"), - ("Select source", "Seleccionar origen"), - ("Select the mask (Alt+click: show it in the viewport)", "Seleccionar la máscara (Alt+clic: mostrarla en la ventana gráfica)"), - ("Select...", "Seleccionar..."), - ("Settings", "Ajustes"), - ("Settings...", "Ajustes..."), - ("Shader Settings", "Ajustes del sombreador"), - ("Shader instance", "Instancia de sombreador"), - ("Shadows", "Sombras"), - ("Sharpen", "Enfocar"), - ("Sheen color", "Color del lustre"), - ("Sheen color × weight", "Color del lustre × peso"), - ("Sheen roughness", "Rugosidad del lustre"), - ("Sheen weight", "Peso del lustre"), - ("Shift + wheel", "Mayús + rueda"), - ("Shortcuts list...", "Lista de atajos..."), - ("Show on all parts", "Mostrar en todas las partes"), - ("Show UV wireframe in the 2D view", "Mostrar la malla de alambre UV en la vista 2D"), - ("Show entire mesh", "Mostrar toda la malla"), - ("Show log...", "Mostrar registro..."), - ("Show or hide the layer", "Mostrar u ocultar la capa"), - ("Show or hide the texture set", "Mostrar u ocultar el conjunto de texturas"), - ("Show wireframe in the 3D view", "Mostrar la malla de alambre en la vista 3D"), - ("Signed addition (AddSub)", "Suma con signo (AddSub)"), - ("Size", "Tamaño"), - ("Size in screen space", "Tamaño en espacio de pantalla"), - ("Size jitter", "Variación de tamaño"), - ( - "Size of the textures the viewport shows: lower uses less GPU memory with large texture sets. Painting and export keep full resolution.", - "Tamaño de las texturas que muestra la ventana gráfica: un valor menor usa menos memoria de GPU con conjuntos de texturas grandes. La pintura y la exportación mantienen la resolución completa.", - ), - ("Slope Blur", "Desenfoque de pendiente"), - ("Slope scale", "Escala de pendiente"), - ("Smart masks", "Máscaras inteligentes"), - ("Smart material saved to {path}", "Material inteligente guardado en {path}"), - ("Smart materials", "Materiales inteligentes"), - ("Smudge", "Difuminar"), - ("Soft light", "Luz suave"), - ("Softness", "Suavidad"), - ("Source", "Origen"), - ("Source U {u} V {v}", "Origen U {u} V {v}"), - ("Spacing", "Espaciado"), - ("Specular", "Especular"), - ("Specular level", "Nivel especular"), - ("Sphere", "Esfera"), - ("Spherical projection", "Proyección esférica"), - ("Spray", "Aerosol"), - ("Square", "Cuadrado"), - ("Stamp depth", "Profundidad del estampado"), - ("Star", "Estrella"), - ("Starting render...", "Iniciando render..."), - ("Stencil", "Plantilla"), - ("Steps", "Pasos"), - ("Streaks", "Chorreones"), - ("Strength", "Intensidad"), - ("Stripes", "Rayas"), - ("Stroke opacity", "Opacidad del trazo"), - ("Subsampling 2x2", "Submuestreo 2x2"), - ("Subsampling 4x4", "Submuestreo 4x4"), - ("Subsampling 8x8", "Submuestreo 8x8"), - ("Subsurface scattering", "Dispersión subsuperficial"), - ("Subtract", "Restar"), - ("Tangent | Wrap", "Tangente | Envolver"), - ("Temporal anti-aliasing (refines the 3D view while it is still)", "Antialiasing temporal (refina la vista 3D mientras está quieta)"), - ("Texture Sets", "Conjuntos de texturas"), - ("Texture Set Settings", "Ajustes del conjunto de texturas"), - ("Texture resolution", "Resolución de texturas"), - ("Texture set channels", "Canales del conjunto de texturas"), - ("Texture sets", "Conjuntos de texturas"), - ("TextureCraft had to close:", "TextureCraft tuvo que cerrarse:"), - ("TextureCraft PBR - Metallic Roughness", "TextureCraft PBR - Metálico Rugosidad"), - ("TextureCraft PBR - Specular Glossiness", "TextureCraft PBR - Especular Brillo"), - ("TextureCraft project", "Proyecto de TextureCraft"), - ("TextureCraft project or mesh", "Proyecto o malla de TextureCraft"), - ("Textures", "Texturas"), - ("Textures embedded; for game engines and most viewers", "Texturas incrustadas; para motores de juego y la mayoría de visores"), - ("Textures packaged; for USD tools and AR Quick Look", "Texturas empaquetadas; para herramientas USD y AR Quick Look"), - ("The GPU couldn't render this scene: {error}", "La GPU no pudo renderizar esta escena: {error}"), - ("The bake worker stopped", "El proceso de horneado se detuvo"), - ("The eraser removes paint from the enabled channels.", "El borrador elimina la pintura de los canales activados."), - ("The first stroke sets the offset from the source.", "El primer trazo define el desplazamiento respecto al origen."), - ( - "The image's alpha cuts the decal's shape; faces turned away and surfaces beyond its depth stay clear.", - "El alfa de la imagen recorta la forma de la calcomanía; las caras orientadas hacia atrás y las superficies más allá de su profundidad quedan libres.", - ), - ("The next click in the 3D view moves the decal there", "El próximo clic en la vista 3D mueve la calcomanía allí"), - ("The resize worker stopped", "El proceso de redimensionado se detuvo"), - ("Thickness", "Grosor"), - ("Thin areas", "Zonas finas"), - ("Threshold", "Umbral"), - ("Tile", "Mosaico"), - ("Tiles", "Baldosas"), - ("Tint", "Tinte"), - ("Toggle mask", "Activar/desactivar máscara"), - ("Tolerance", "Tolerancia"), - ("Tone mapping", "Mapeo de tonos"), - ("Tools", "Herramientas"), - ("Torus", "Toro"), - ("Transmission", "Transmisión"), - ("Tri-planar projection", "Proyección triplanar"), - ("Triangle fill", "Relleno de triángulos"), - ("UDIM plane", "Plano UDIM"), - ("UDIM tiles painted by this texture set, each at the set's size", "Mosaicos UDIM pintados por este conjunto de texturas, cada uno al tamaño del conjunto"), - ("UI layout", "Diseño de interfaz"), - ("UI layout: {error}", "Diseño de interfaz: {error}"), - ("UI layouts", "Diseños de interfaz"), - ("UI {ms} ms", "Interfaz {ms} ms"), - ("USD binary, textures alongside", "USD binario, texturas aparte"), - ("USD text, textures alongside", "USD texto, texturas aparte"), - ("USDZ with textures", "USDZ con texturas"), - ("UV checker", "Damero UV"), - ("UV island fill", "Relleno de islas UV"), - ("UV transformations", "Transformaciones UV"), - ("UV projection", "Proyección UV"), - ("UV tiles", "Mosaicos UV"), - ("UV tiles (UDIM)", "Mosaicos UV (UDIM)"), - ("Undo", "Deshacer"), - ("Uniform value", "Valor uniforme"), - ("Use an equirectangular .hdr or .exr image as the environment", "Usar una imagen equirrectangular .hdr o .exr como entorno"), - ("Use the control channel or `texturecraft-cli render` for screenshots", "Usa el canal de control o `texturecraft-cli render` para las capturas"), - ("Value", "Valor"), - ("Version {version}", "Versión {version}"), - ("Version: {version} ({gpu})", "Versión: {version} ({gpu})"), - ("View through this camera", "Ver a través de esta cámara"), - ("Viewer settings", "Ajustes del visor"), - ("Viewport", "Ventana gráfica"), - ("Viewport and brush (fixed)", "Ventana gráfica y pincel (fijos)"), - ("Views", "Vistas"), - ("Vivid light", "Luz intensa"), - ("Voronoi", "Voronoi"), - ("Warp", "Deformar"), - ("Warp Directional", "Deformación direccional"), - ("Wavefront OBJ with MTL, textures alongside", "Wavefront OBJ con MTL, texturas al lado"), - ( - "WebGPU isn't available in this browser, so TextureCraft runs on WebGL2: Rendering mode path traces on the CPU (slower) and large texture sets show at reduced resolution. A current Chrome, Edge or Safari has WebGPU.", - "WebGPU no está disponible en este navegador, así que TextureCraft usa WebGL2: el modo Renderizado calcula el trazado de trayectorias en la CPU (más lento) y los conjuntos de texturas grandes se muestran a resolución reducida. Las versiones actuales de Chrome, Edge y Safari admiten WebGPU.", - ), - ("Wheel / Alt + RMB drag", "Rueda / Alt + arrastrar con botón der."), - ("White", "Blanco"), - ("Width", "Ancho"), - ("Width (texels at 2K)", "Anchura (téxeles a 2K)"), - ("Window", "Ventana"), - ("Wood grain", "Veta de madera"), - ("Works in texture space, like the blur: it does not cross UV seams.", "Funciona en espacio de textura, como el desenfoque: no cruza las costuras UV."), - ("World Space Normal", "Normal en espacio de mundo"), - ("Yellow / blue", "Amarillo / azul"), - ("Zoom", "Zoom"), - ("a missing layer", "una capa inexistente"), - ("aniso", "aniso"), - ("aniso angle", "áng anis"), - ("ao", "ao"), - ("coat", "barniz"), - ("coat nrm", "nrm barn"), - ("coat rough", "rug barn"), - ("color", "color"), - ("emiss", "emis"), - ("glTF binary with textures", "glTF binario con texturas"), - ("gloss", "brillo"), - ("height", "altura"), - ("metal", "metal"), - ("min", "min"), - ("missing", "no encontrado"), - ("missing source", "origen no encontrado"), - ("no GPU", "sin GPU"), - ("none", "ninguno"), - ("nrm", "nrm"), - ("off", "desact."), - ("op", "opac"), - ("rough", "rugos"), - ("scatter", "dispers"), - ("sheen", "lustre"), - ("sheen color", "col lust"), - ("sheen rough", "rug lust"), - ("spec", "niv esp"), - ("specular", "especul"), - ("transm", "transm"), - ("{action} (undone)", "{action} (deshecho)"), - ( - "{file}: add above the selected layer (or drag it into the layer stack or onto the viewport)", - "{file}: añadir sobre la capa seleccionada (o arrastrarlo a la pila de capas o a la ventana gráfica)", - ), - ("{name} copy", "Copia de {name}"), - ("{n} bits", "{n} bits"), - ( - "{n} control points. Click the mesh (or the 2D view) to add points and drag them to adjust; click the first point to close the path. Enter paints it with the brush (a closed, filled path fills its inside), Esc cancels.", - "{n} puntos de control. Haz clic en la malla (o en la vista 2D) para añadir puntos y arrástralos para ajustarlos; haz clic en el primer punto para cerrar el trazado. Intro lo pinta con el pincel (un trazado cerrado y relleno rellena su interior), Esc cancela.", - ), - ("{n} items share a shortcut; the first one listed wins.", "{n} elementos comparten un atajo; prevalece el primero de la lista."), - ("{pattern} (scale {scale}, seed {seed})", "{pattern} (escala {scale}, semilla {seed})"), - ("Template name", "Nombre de la plantilla"), - ("Save current project as template", "Guardar el proyecto actual como plantilla"), - ("Distribution", "Distribución"), - ("Cosine", "Coseno"), - ("Uniform", "Uniforme"), - ("Normalization", "Normalización"), - // Settings › Interface: brightness and accent color. - ("Brightness", "Brillo"), - ("Dark", "Oscuro"), - ("Medium dark", "Medio oscuro"), - ("Medium light", "Medio claro"), - ("Light", "Claro"), - ("Accent color", "Color de acento"), - ("Copper", "Cobre"), - ("Coral", "Coral"), - ("Blue", "Azul"), - ("Violet", "Violeta"), - ("Green", "Verde"), - ("Amber", "Ámbar"), - ("Pink", "Rosa"), - ("Minimize", "Minimizar"), - ("Maximize", "Maximizar"), - ("Restore", "Restaurar"), - ("Title bar", "Barra de título"), - ("System title bar (applies on restart)", "Barra de título del sistema (se aplica al reiniciar)"), - ( - "Use the operating system's window frame and buttons instead of TextureCraft's own title bar", - "Usar el marco y los botones de ventana del sistema operativo en lugar de la barra de título propia de TextureCraft", - ), - ("Brushes", "Pinceles"), - ("My brushes", "Mis pinceles"), - ("Use this brush (keeps its size)", "Usar este pincel (conserva su tamaño)"), - ("Brush name", "Nombre del pincel"), - ("Save current brush", "Guardar el pincel actual"), - ("Start window", "Ventana de inicio"), - ("Show at startup", "Mostrar al iniciar"), - ("Continue with the sample project", "Continuar con el proyecto de ejemplo"), - ("No recent projects yet", "Aún no hay proyectos recientes"), - ("Text", "Texto"), - ("Font", "Fuente"), - ("Style", "Estilo"), - ("Use as brush alpha", "Usar como alfa del pincel"), - ("Place as decal", "Colocar como calcomanía"), - ("Click: turn this channel on or off. Alt+click: this channel only", "Clic: activa o desactiva este canal. Alt+clic: solo este canal"), - ("Show all", "Mostrar todo"), - ("Hide all", "Ocultar todo"), - ("Invert show/hide", "Invertir mostrar/ocultar"), - ("Show or hide texture sets", "Mostrar u ocultar conjuntos de texturas"), - ("Focus: show only the active texture set", "Enfoque: mostrar solo el conjunto de texturas activo"), - ("Unsaved changes", "Cambios sin guardar"), - ("Don't save", "No guardar"), - ("Save the changes to {name} before closing?", "¿Guardar los cambios de {name} antes de cerrar?"), - ("Radius", "Radio"), - ("Remove skew correction", "Quitar la corrección de sesgo"), - ("Twill weave", "Tejido de sarga"), - ("Save the changes to {name} first?", "¿Guardar primero los cambios de {name}?"), - ( - "Paths stay editable: pick one to move its points or change its brush and material, and the sublayer repaints at once. Add paths with the Path tool.", - "Los trazados siguen siendo editables: elige uno para mover sus puntos o cambiar su pincel y material, y la subcapa se vuelve a pintar al instante. Añade trazados con la herramienta Trazado.", - ), - ("Import material...", "Importar material..."), - ("MaterialCraft material", "Material de MaterialCraft"), - ("Cooked at {size} px", "Calculado a {size} px"), - ("Preset", "Preajuste"), - ("Re-cook", "Recalcular"), - ("Open in MaterialCraft", "Abrir en MaterialCraft"), - ( - "Opened in MaterialCraft: use File > Send to TextureCraft there to bring your changes back", - "Abierto en MaterialCraft: usa allí Archivo > Enviar a TextureCraft para traer tus cambios", - ), - ("Parameters change in the desktop app, with MaterialCraft installed", "Los parámetros se cambian en la app de escritorio, con MaterialCraft instalado"), - ("Add High-Poly Meshes", "Añadir mallas de alta resolución"), - ("All", "Todos"), - ("Apply Diffusion", "Aplicar difusión"), - ("Attenuation", "Atenuación"), - ("Auto Tonemapping", "Mapeo tonal automático"), - ("Average Normals", "Promediar normales"), - ("BBox", "Caja delimitadora"), - ("BSphere", "Esfera delimitadora"), - ("Mesh Map Bakers", "Horneadores de mapas de malla"), - ("Common Settings", "Ajustes comunes"), - ("Mesh Map Settings", "Ajustes de mapas de malla"), - ("Check All", "Marcar todo"), - ("No Parameters", "Sin parámetros"), - ("Bake Selected Textures ({n})", "Hornear texturas seleccionadas ({n})"), - ("By Mesh Name", "Por nombre de malla"), - ("Cage", "Jaula"), - ("Cage Scene", "Escena de jaula"), - ("Cage Type", "Tipo de jaula"), - ("Color Generator", "Generador de color"), - ("Color Source", "Origen del color"), - ("Common Parameters", "Parámetros comunes"), - ("Custom File", "Archivo personalizado"), - ("Details", "Detalles"), - ("Dilation Width", "Ancho de dilatación"), - ("Distance-Based", "Basada en distancia"), - ("Edge Contrast", "Contraste de bordes"), - ("Edge Distance", "Distancia de bordes"), - ("Edge Protection", "Protección de bordes"), - ("Enable Seams", "Activar costuras"), - ("File ID", "ID de archivo"), - ("Full Scene", "Escena completa"), - ("Generate from Mesh", "Generar desde la malla"), - ("Generate from Normal Map", "Generar desde el mapa de normales"), - ("Ground Plane", "Plano del suelo"), - ("Ground Plane Offset", "Desplazamiento del suelo"), - ("High Poly Mesh Suffix", "Sufijo de malla high poly"), - ("High Poly Scene", "Escena de alta resolución"), - ("High-Poly Parameters", "Parámetros de alta resolución"), - ("Hue Shift", "Cambio de tono"), - ("Ignore Backface", "Ignorar caras traseras"), - ("Ignore Backface Suffix", "Sufijo para ignorar caras traseras"), - ("Include in Bake", "Incluir en el horneado"), - ("Load Cage", "Cargar jaula"), - ("Lock Output Size", "Bloquear tamaño de salida"), - ("Low Poly Mesh Suffix", "Sufijo de malla low poly"), - ("Manual", "Manual"), - ("Material Color", "Color del material"), - ("Max Frontal Distance", "Distancia frontal máx."), - ("Max Occluder Distance", "Distancia máx. de oclusor"), - ("Max Rear Distance", "Distancia trasera máx."), - ("Mesh ID", "ID de malla"), - ("Method", "Método"), - ("Min Occluder Distance", "Distancia mínima del oclusor"), - ("Never", "Nunca"), - ("No High-Poly Meshes", "Sin mallas de alta resolución"), - ("Normalization Scale", "Escala de normalización"), - ("Normalization Type", "Tipo de normalización"), - ("Only Same Mesh Name", "Solo el mismo nombre de malla"), - ("Output Size", "Tamaño de salida"), - ("Match", "Coincidencia"), - ("Skew Correction Method", "Método de Corrección de Sesgo"), - ("Mesh Normals Based", "Basado en Normales de Malla"), - ("Face Normals Based", "Basado en Normales de Cara"), - ("Reset Painted Cage", "Restablecer Jaula Pintada"), - ("Paint Cage", "Pintar jaula"), - ("Paint Skew Correction", "Pintar corrección de inclinación"), - ("Per Material", "Por material"), - ("Random", "Aleatorio"), - ("Relative to Bounding Box", "Relativo a la caja delimitadora"), - ("Relative to Low Mesh", "Relativo a la malla de baja resolución"), - ("Relative to Min/Max", "Relativo al mínimo/máximo"), - ("Relative to Ray Distances", "Relativo a distancias de rayos"), - ("Remove Cage", "Eliminar jaula"), - ("Remove Skew Correction", "Quitar la corrección de sesgo"), - ("Restore Defaults", "Restaurar valores predeterminados"), - ("Return to Painting Mode", "Volver al modo de pintura"), - ("Sampling Radius", "Radio de muestreo"), - ("Scaling Divisor", "Divisor de escala"), - ("Seams Intensity", "Intensidad de costuras"), - ("Secondary Rays", "Rayos secundarios"), - ("Self Intersection", "Autointersección"), - ("Self Occlusion", "Autooclusión"), - ("Skew Correction", "Corrección de sesgo"), - ("Smooth", "Suave"), - ("Spread Angle", "Ángulo de dispersión"), - ("Submesh", "Submalla"), - ("Use Low Poly Mesh as High Poly Mesh", "Usar la malla low poly como malla high poly"), - ("Value Bounds Max", "Límite máximo"), - ("Value Bounds Min", "Límite mínimo"), - ("Vertex Color", "Color de vértice"), - ("Select the layer content", "Seleccionar el contenido de la capa"), - ("Paint layer", "Capa de pintura"), - ("Fill layer", "Capa de relleno"), - ("1 effect", "1 efecto"), - ("{count} effects", "{count} efectos"), - ("Mask effects", "Efectos de la máscara"), - ("Content effects", "Efectos del contenido"), - ("Fold or unfold these effects", "Plegar o desplegar estos efectos"), - ("Remove resolution override", "Quitar resolución personalizada"), - ("Texture set resolution", "Resolución del conjunto de texturas"), - ("UV tile {tile} resolution", "Resolución del mosaico UV {tile}"), - ("Angle span", "Amplitud del ángulo"), - ("Axis position", "Posición del eje"), - ("Count", "Cantidad"), - ("Display", "Visualización"), - ("Hide while painting", "Ocultar al pintar"), - ("Manipulator size", "Tamaño del manipulador"), - ("Mirror symmetry", "Simetría de espejo"), - ("Radial settings", "Ajustes radiales"), - ("Radial symmetry", "Simetría radial"), - ("Show axis", "Mostrar eje"), - ("Show axis position manipulator", "Mostrar manipulador de posición del eje"), - ("Show cursor", "Mostrar cursor"), - ("Show intersection", "Mostrar intersección"), - ("Show plane", "Mostrar plano"), - ("Symmetry", "Simetría"), - ("Symmetry color display", "Color de visualización de simetría"), - ("Symmetry settings", "Ajustes de simetría"), - ("Type", "Tipo"), - ("Advanced settings", "Ajustes avanzados"), - ("Import baked maps", "Importar mapas horneados"), - ("Name each file after its texture set, like Body_normal.png", "Nombra cada archivo según su conjunto de texturas, p. ej. Body_normal.png"), - ("Add...", "Añadir..."), - ("Baked maps imported: {count}", "Mapas horneados importados: {count}"), - ("Not imported: {files}", "Sin importar: {files}"), - ("Baking Visualization", "Visualización del horneado"), - ("Show for Selected Texture Set Only", "Mostrar solo para el conjunto de texturas seleccionado"), - ("High Definition Mesh (HP)", "Malla de alta resolución (HP)"), - ("UV Seams", "Costuras UV"), - ("Project Mesh (LP)", "Malla de proyección (LP)"), - ("Edges", "Bordes"), - ("Cavities", "Cavidades"), - ("Edges and cavities", "Bordes y cavidades"), - ("Raw curvature", "Curvatura sin procesar"), - ("Detail sizes", "Tamaños de detalle"), - ( - "Reads the curvature map as baked: changing the mode or a size turns detail sizes on.", - "Lee el mapa de curvatura tal como se horneó: cambiar el modo o un tamaño activa los tamaños de detalle.", - ), - ( - "A click fills what is under it; a dragged rectangle fills what it selects as it grows", - "Un clic rellena lo que hay debajo; un rectángulo arrastrado rellena lo que selecciona mientras crece", - ), - ("Contained center: fill polygons whose center is in the rectangle", "Centro contenido: rellenar los polígonos cuyo centro está en el rectángulo"), - ( - "Editing the quick mask: fills paint where painting is allowed. Press U to finish.", - "Editando la máscara rápida: los rellenos pintan donde se permite pintar. Pulsa U para terminar.", - ), - ("Fill mode", "Modo de relleno"), - ("Fill only polygons the camera sees (3D view)", "Rellenar solo los polígonos que ve la cámara (vista 3D)"), - ("Hit-test", "Prueba de selección"), - ("How a rectangle selects polygons", "Cómo selecciona polígonos un rectángulo"), - ("Intersection: fill polygons the rectangle touches", "Intersección: rellenar los polígonos que toca el rectángulo"), - ("Rectangle fill", "Relleno rectangular"), - ("Select a paint layer or a layer's mask to fill", "Selecciona una capa de pintura o una máscara de capa para rellenar"), - ("Selection mode", "Modo de selección"), - ( - "Triangle fills single triangles, Polygon whole quads and n-gons, Mesh the connected geometry, UV island the UV islands", - "Triángulo rellena triángulos sueltos, Polígono cuadriláteros y n-gonos enteros, Malla la geometría conectada, Isla UV las islas UV", - ), - ("Visible polygons only", "Solo polígonos visibles"), - ( - "\"{layer}\" can't be filled: select a paint layer or a layer's mask", - "\"{layer}\" no se puede rellenar: selecciona una capa de pintura o una máscara de capa", - ), - ("The file dialog couldn't be shown: {error}", "No se pudo mostrar el cuadro de diálogo de archivos: {error}"), - ( - "The project changed while the dialog was open, so nothing was done", - "El proyecto cambió mientras el cuadro de diálogo estaba abierto, así que no se hizo nada", - ), - ("Cores kept for the UI", "Núcleos reservados para la interfaz"), - ("Max RAM while saving", "RAM máx. al guardar"), - ( - "Saving uses the other cores and at most this share of the free RAM. At least one core always works.", - "Guardar usa los demás núcleos y como máximo esta parte de la RAM libre. Siempre trabaja al menos un núcleo.", - ), - ("Max project size on open", "Tamaño máximo al abrir"), - ( - "Maximum decompressed project data. Increase this limit to open larger projects.", - "Máximo de datos descomprimidos del proyecto. Aumenta este límite para abrir proyectos más grandes.", - ), -]; diff --git a/crates/ui-egui/src/i18n/fr.rs b/crates/ui-egui/src/i18n/fr.rs deleted file mode 100644 index 00b8c2af..00000000 --- a/crates/ui-egui/src/i18n/fr.rs +++ /dev/null @@ -1,1196 +0,0 @@ -//! French UI text: (English key, translation). Keys are the English strings passed to `tr`. - -pub const TABLE: &[(&str, &str)] = &[ - ("Baking {map} ({n}/{total})", "Cuisson de {map} ({n}/{total})"), - ("Baking {map} ({n}/{total}), texture set {set} of {sets}", "Cuisson de {map} ({n}/{total}), jeu de textures {set} sur {sets}"), - ("Follow Newest Map", "Suivre la dernière carte"), - ( - "Painting is paused while a bake is shown. Cancel the bake or wait for it to finish.", - "La peinture est suspendue tant qu'une cuisson est affichée. Annulez la cuisson ou attendez qu'elle se termine.", - ), - ( - "What the 3D view shows while the bake runs: the newest finished map, one finished map, or the material. Maps not baked yet show a neutral value.", - "Ce que la vue 3D affiche pendant la cuisson : la dernière carte terminée, une carte terminée au choix ou le matériau. Les cartes pas encore cuites affichent une valeur neutre.", - ), - ( - "\"{layer}\" has no paint yet: the filter changes what you paint on it.", - "\"{layer}\" n'a pas encore de peinture : le filtre modifie ce que vous y peignez.", - ), - ("0 turns autosave off. Copies go to {folder}", "0 désactive la sauvegarde automatique. Les copies vont dans {folder}"), - ("2D view only", "Vue 2D seule"), - ("32 bits (float)", "32 bits (flottant)"), - ("3D mesh", "Maillage 3D"), - ("3D meshes", "Maillages 3D"), - ( - "3D texture painting: layers, masks, smart materials, mesh map baking and export.", - "Peinture de textures 3D : calques, masques, matériaux intelligents, précalcul des cartes de maillage et export.", - ), - ("3D view only", "Vue 3D seule"), - ("3D/2D views", "Vues 3D/2D"), - ( - "A folder blends its children (pass-through). Set per-channel opacity in the layer rows.", - "Un dossier fusionne ses enfants (transfert). Réglez l'opacité par canal dans les lignes des calques.", - ), - ("ACES filmic", "ACES filmique"), - ("Ambient", "Ambiante"), - ("AO intensity", "Intensité de l'AO"), - ("About TextureCraft", "À propos de TextureCraft"), - ("About TextureCraft...", "À propos de TextureCraft..."), - ( - "Add an anchor point to a layer below to use its stack as a mask.", - "Ajoutez un point d'ancrage à un calque inférieur pour utiliser sa pile comme masque.", - ), - ("Add anchor point", "Ajouter un point d'ancrage"), - ("Add as decal (view center)", "Ajouter comme décalque (centre de la vue)"), - ("Add black mask", "Ajouter un masque noir"), - ("Add channel", "Ajouter un canal"), - ("Add color", "Ajouter une couleur"), - ("Add compare mask", "Ajouter un masque de comparaison"), - ("Add effect", "Ajouter un effet"), - ("Add fill", "Ajouter un remplissage"), - ("Add fill layer", "Ajouter un calque de remplissage"), - ("Add filter", "Ajouter un filtre"), - ("Add folder", "Ajouter un dossier"), - ("Add generator", "Ajouter un générateur"), - ("Add levels", "Ajouter des niveaux"), - ("Add mask", "Ajouter un masque"), - ("Add mask with color selection", "Ajouter un masque par sélection de couleur"), - ("Add output", "Ajouter une sortie"), - ("Add paint", "Ajouter de la peinture"), - ("Add paint layer", "Ajouter un calque de peinture"), - ("Add smart material from the shelf", "Ajouter un matériau intelligent depuis la bibliothèque"), - ("Add to the layer content", "Ajouter au contenu du calque"), - ("Add to the mask", "Ajouter au masque"), - ("Add white mask", "Ajouter un masque blanc"), - ("Adjustments", "Réglages"), - ( - "Aligned: the offset set by the first stroke is kept. V + click sets a new source.", - "Aligné : le décalage défini par le premier trait est conservé. V + clic définit une nouvelle source.", - ), - ("Alignment", "Alignement"), - ("Alignment and culling", "Alignement et élimination"), - ("All layers", "Tous les calques"), - ("Alpha", "Alpha"), - ("Alphas", "Alphas"), - ("Also bound to {item} ({menu})", "Également attribué à {item} ({menu})"), - ("Alt + LMB drag", "Alt + glisser (clic gauche)"), - ("Always", "Toujours"), - ("Ambient Occlusion", "Occlusion ambiante"), - ("Ambient occlusion", "Occlusion ambiante"), - ("Amount", "Quantité"), - ("Anchor point", "Point d'ancrage"), - ("Anchor: {name}", "Ancrage : {name}"), - ("Anchor: {name} ({channel})", "Ancrage : {name} ({channel})"), - ("Angle", "Angle"), - ("Angle (degrees)", "Angle (degrés)"), - ("Angle fade from", "Atténuation angulaire (début)"), - ("Angle fade to", "Atténuation angulaire (fin)"), - ("Angle jitter", "Variation d'angle"), - ("Anisotropy angle", "Angle d'anisotropie"), - ("Anisotropy level", "Niveau d'anisotropie"), - ("Antialiasing", "Anticrénelage"), - ("Aperture", "Ouverture"), - ("Apply", "Appliquer"), - ("ArtCraft website...", "Site web d'ArtCraft..."), - ("Assets", "Ressources"), - ("Auto", "Auto"), - ("Automatic (from the mesh UVs)", "Automatique (d'après les UV du maillage)"), - ("Autosave every", "Sauvegarde automatique toutes les"), - ( - "Autosaves, smart materials, presets, templates and UI layouts go to the data folder. A new folder applies on restart; files already saved stay where they are.", - "Les sauvegardes automatiques, matériaux intelligents, préréglages, modèles et dispositions de l'interface vont dans le dossier de données. Un nouveau dossier s'applique au redémarrage ; les fichiers déjà enregistrés restent où ils sont.", - ), - ("Axis", "Axe"), - ("Back to painting", "Retour à la peinture"), - ("Backface culling", "Élimination des faces arrière"), - ("Bake an ID map (F8) to pick colors from the mesh.", "Précalculez une carte d'ID (F8) pour prélever des couleurs sur le maillage."), - ("Bake Mesh Maps", "Précalculer les cartes de maillage"), - ("Bake mesh maps", "Précalculer les cartes de maillage"), - ( - "Bake mesh maps (F8) for curvature, AO and thickness based generators.", - "Précalculez les cartes de maillage (F8) pour les générateurs basés sur la courbure, l'AO et l'épaisseur.", - ), - ("Baked Lighting", "Éclairage précalculé"), - ("Baking", "Précalcul"), - ("Base color", "Couleur de base"), - ( - "Base color is the diffuse color, Specular the F0 color and Glossiness 1 - roughness (add these channels in the texture set settings).", - "Couleur de base est la couleur diffuse, Spéculaire la couleur F0 et Brillance 1 - rugosité (ajoutez ces canaux dans les paramètres de l'ensemble de textures).", - ), - ("Base color, Metallic, Roughness and Specular level.", "Couleur de base, Métallique, Rugosité et Niveau spéculaire."), - ("Based on each texture set's size", "Selon la taille de chaque ensemble de textures"), - ("Basic settings", "Paramètres de base"), - ("Bent Normals", "Normales déviées"), - ("Bevel", "Biseau"), - ("Black", "Noir"), - ("Blending", "Fusion"), - ("Blending mode of the displayed channel", "Mode de fusion du canal affiché"), - ("Blur", "Flou"), - ("Blur Directional", "Flou directionnel"), - ("Blur and sharpen", "Flou et netteté"), - ("Bounces", "Rebonds"), - ("Bricks", "Briques"), - ("Brush", "Pinceau"), - ("Brush size", "Taille du pinceau"), - ("Brush size down / up", "Réduire / augmenter la taille du pinceau"), - ("Brushed lines", "Lignes brossées"), - ("Built-in (read-only): duplicate it to edit", "Intégré (lecture seule) : dupliquez-le pour le modifier"), - ("Built-in templates are read-only: duplicate one to edit it", "Les modèles intégrés sont en lecture seule : dupliquez-en un pour le modifier"), - ("Built-in: {mesh}", "Intégré : {mesh}"), - ("Cage: {name}", "Cage : {name}"), - ("Camera", "Caméra"), - ("Colors", "Couleurs"), - ("Go to camera 1", "Aller à la caméra 1"), - ("Go to camera 2", "Aller à la caméra 2"), - ("Go to camera 3", "Aller à la caméra 3"), - ("Go to camera 4", "Aller à la caméra 4"), - ("Go to camera 5", "Aller à la caméra 5"), - ("Go to camera 6", "Aller à la caméra 6"), - ("Go to camera 7", "Aller à la caméra 7"), - ("Go to camera 8", "Aller à la caméra 8"), - ("Go to camera 9", "Aller à la caméra 9"), - ("Camera settings", "Paramètres de la caméra"), - ("Cancel", "Annuler"), - ("Cancel the stroke", "Annuler le trait"), - ("Cell size (texels at 2K)", "Taille des cellules (texels en 2K)"), - ("Cells", "Cellules"), - ("Channel", "Canal"), - ("Channel source: uniform value, procedural, image or anchor", "Source du canal : valeur uniforme, procédural, image ou ancrage"), - ("Channels", "Canaux"), - ("Check for Updates...", "Rechercher des mises à jour..."), - ("Checker", "Damier"), - ("Clamp", "Limiter"), - ("Clear", "Effacer"), - ("Clear mask", "Effacer le masque"), - ("Clear recent projects", "Effacer les projets récents"), - ("Click a mesh part to show or hide the selected layer on it.", "Cliquez sur une partie du maillage pour y afficher ou masquer le calque sélectionné."), - ("Click the mesh to pick its material into the brush", "Cliquez sur le maillage pour prélever son matériau dans le pinceau"), - ("Click the mesh to place the decal", "Cliquez sur le maillage pour placer le décalque"), - ("Click, then press the new shortcut (Esc cancels)", "Cliquez, puis appuyez sur le nouveau raccourci (Esc pour annuler)"), - ("Clone", "Clonage"), - ("Close", "Fermer"), - ("Closed path", "Tracé fermé"), - ("Cloud", "Nuage"), - ("Clouds", "Nuages"), - ("Coat normal", "Normale du vernis"), - ("Coat roughness", "Rugosité du vernis"), - ("Coat weight", "Poids du vernis"), - ("Color", "Couleur"), - ("Color Balance", "Balance des couleurs"), - ("Color burn", "Densité couleur +"), - ("Color dodge", "Densité couleur -"), - ( - "Color of the light that travels under the surface (each channel goes as far as its value)", - "Couleur de la lumière qui se propage sous la surface (chaque canal va aussi loin que sa valeur)", - ), - ("Color picker", "Pipette"), - ("Color selection", "Sélection de couleur"), - ("Color to replace", "Couleur à remplacer"), - ( - "Colors near the first shift towards the second, keeping their shading.", - "Les couleurs proches de la première glissent vers la seconde en gardant leur ombrage.", - ), - ( - "Colors read as gray. Add a levels or blur effect above to shape the result.", - "Les couleurs sont lues en niveaux de gris. Ajoutez un effet de niveaux ou de flou au-dessus pour ajuster le résultat.", - ), - ("Combine with the layer's height", "Combiner avec la hauteur du calque"), - ("Compare mask", "Masque de comparaison"), - ("Compositing", "Composition"), - ("Constant", "Constante"), - ("Constants", "Constantes"), - ("Contrast", "Contraste"), - ("Contrast/Luminosity", "Contraste/Luminosité"), - ("Converted maps", "Cartes converties"), - ("Copy RGB values", "Copier les valeurs RVB"), - ("Copy effect", "Copier l'effet"), - ("Copy from", "Copier depuis"), - ("Copy layer(s)", "Copier le(s) calque(s)"), - ("Copy the selected layer alone (its empty parts copy nothing)", "Copier uniquement le calque sélectionné (ses parties vides ne copient rien)"), - ("Copy to all texture sets", "Copier dans tous les ensembles de textures"), - ("Copy what the texture set shows", "Copier ce qu'affiche l'ensemble de textures"), - ("Couldn't encode the render", "Impossible d'encoder le rendu"), - ("Couldn't export textures: {error}", "Impossible d'exporter les textures : {error}"), - ("Couldn't export the mesh: {error}", "Impossible d'exporter le maillage : {error}"), - ("Couldn't export the template: {error}", "Impossible d'exporter le modèle : {error}"), - ("Couldn't import {name}: {error}", "Impossible d'importer {name} : {error}"), - ("Couldn't open {name}: {error}", "Impossible d'ouvrir {name} : {error}"), - ("Couldn't read the render back from the GPU", "Impossible de relire le rendu depuis le GPU"), - ("Couldn't save the render: {error}", "Impossible d'enregistrer le rendu : {error}"), - ("Couldn't save {name}: {error}", "Impossible d'enregistrer {name} : {error}"), - ("Count per stamp", "Nombre par empreinte"), - ("Crate", "Caisse"), - ("Create", "Créer"), - ("Create smart material", "Créer un matériau intelligent"), - ( - "Ctrl+right-drag in a view sets the size and hardness, Ctrl+left-drag the flow and angle.", - "Ctrl+glisser (clic droit) dans une vue règle la taille et la dureté, Ctrl+glisser (clic gauche) le flux et l'angle.", - ), - ("Cube", "Cube"), - ("Current layer", "Calque actuel"), - ("Curvature", "Courbure"), - ("Cut effect", "Couper l'effet"), - ("Cut layer(s)", "Couper le(s) calque(s)"), - ("Cyan / red", "Cyan / rouge"), - ("Cylinder", "Cylindre"), - ("Cylindrical projection", "Projection cylindrique"), - ( - "Dark to light: the content's luminance picks a color along these stops.", - "Du sombre au clair : la luminance du contenu choisit une couleur le long de ces repères.", - ), - ("Darken (Min)", "Obscurcir (Min)"), - ("Data folder", "Dossier de données"), - ("Decal", "Décalque"), - ("Decal projection", "Projection de décalque"), - ("Default", "Par défaut"), - ("Default camera", "Caméra par défaut"), - ("Delete the selected template", "Supprimer le modèle sélectionné"), - ("Delete this camera", "Supprimer cette caméra"), - ("Deleted template \"{name}\"", "Modèle « {name} » supprimé"), - ("Denoise", "Débruitage"), - ("Depth", "Profondeur"), - ("Depth of field", "Profondeur de champ"), - ("Depth of field (viewport and Rendering mode)", "Profondeur de champ (fenêtre d'affichage et mode Rendu)"), - ("Depth of the sharp plane along the view (0: the orbit center)", "Profondeur du plan net le long de la vue (0 : le centre d'orbite)"), - ("Details saved to {file}", "Détails enregistrés dans {file}"), - ("Difference", "Différence"), - ("Dilation + default background color", "Dilatation + couleur de fond par défaut"), - ("Dilation + transparent", "Dilatation + transparent"), - ("Dilation infinite", "Dilatation infinie"), - ("DirectX normal map", "Carte de normales DirectX"), - ("Dirt", "Saleté"), - ("Disable", "Désactivé"), - ("Dismiss", "Fermer"), - ("Displacement (height channel)", "Déplacement (canal de hauteur)"), - ("Display Settings", "Paramètres d'affichage"), - ("Display material", "Afficher le matériau"), - ("Display next channel", "Afficher le canal suivant"), - ("Display next mesh map", "Afficher la carte de maillage suivante"), - ("Display previous channel", "Afficher le canal précédent"), - ("Display previous mesh map", "Afficher la carte de maillage précédente"), - ("Distance", "Distance"), - ("Distort", "Déformation"), - ("Divide", "Division"), - ("Document resolution", "Résolution du document"), - ("Documentation...", "Documentation..."), - ("Done on CPU: {n} / {max} samples, {s} s", "Terminé sur CPU : {n} / {max} échantillons, {s} s"), - ("Done on GPU: {n} / {max} samples, {s} s", "Terminé sur GPU : {n} / {max} échantillons, {s} s"), - ("Double-click to rename", "Double-cliquer pour renommer"), - ("Download as", "Télécharger en"), - ("Downloaded {name}", "{name} téléchargé"), - ("Drag onto an output channel", "Glisser sur un canal de sortie"), - ( - "Drags the layer stack's values along the stroke into the selected layer.", - "Entraîne les valeurs de la pile de calques le long du trait dans le calque sélectionné.", - ), - ( - "Draws {name} of texture set \"{set}\". Edits to the source show in every instance.", - "Affiche {name} de l'ensemble de textures « {set} ». Les modifications de la source apparaissent dans chaque instance.", - ), - ( - "Drag the frame to move the decal, a corner to scale it, the round handle to turn it", - "Faites glisser le cadre pour déplacer le décalque, un coin pour le mettre à l'échelle, la poignée ronde pour le faire pivoter", - ), - ( - "Drop an image from the Assets panel here to use it as this mesh map", - "Déposez ici une image du panneau Ressources pour l'utiliser comme cette carte de maillage", - ), - ("Dry streaks", "Traînées sèches"), - ("Duplicate effect", "Dupliquer l'effet"), - ("Duplicate layer(s)", "Dupliquer le(s) calque(s)"), - ("Duplicate the selected template", "Dupliquer le modèle sélectionné"), - ("Edge Detect", "Détection des contours"), - ("Edit", "Édition"), - ("Edit keyboard shortcuts...", "Modifier les raccourcis clavier..."), - ("Edit quick mask", "Modifier le masque rapide"), - ( - "Editing quick mask: paint where painting is allowed (U to finish)", - "Modification du masque rapide : peignez là où la peinture est autorisée (U pour terminer)", - ), - ( - "Editing the quick mask: strokes paint where painting is allowed. Press U to finish.", - "Modification du masque rapide : les traits peignent là où la peinture est autorisée. Appuyez sur U pour terminer.", - ), - ("Emissive", "Émissif"), - ("Enable or disable the effect", "Activer ou désactiver l'effet"), - ("Enable quick mask", "Activer le masque rapide"), - ("Environment blur", "Flou de l'environnement"), - ("Environment exposure (EV)", "Exposition de l'environnement (EV)"), - ("Environment map", "Carte d'environnement"), - ("Environment opacity", "Opacité de l'environnement"), - ("Environment rotation", "Rotation de l'environnement"), - ("Environment settings", "Paramètres d'environnement"), - ("Environment: {name}", "Environnement : {name}"), - ("Environments", "Environnements"), - ("Eraser", "Gomme"), - ("Exclusion", "Exclusion"), - ("Expand or collapse the folder", "Déplier ou replier le dossier"), - ("Export", "Exporter"), - ("Export Mesh...", "Exporter le maillage..."), - ("Export Textures...", "Exporter les textures..."), - ("Export mesh", "Exporter le maillage"), - ("Export template", "Modèle d'export"), - ("Export templates", "Modèles d'export"), - ("Export textures", "Exporter les textures"), - ("Export the selected template (.json)", "Exporter le modèle sélectionné (.json)"), - ("Exported mesh to {path}", "Maillage exporté vers {path}"), - ("Exported template \"{name}\" to {path}", "Modèle « {name} » exporté vers {path}"), - ("Exported {n} textures to {folder}", "{n} textures exportées vers {folder}"), - ("F0 from specular level", "F0 depuis le niveau spéculaire"), - ("Fabric weave", "Tissage"), - ("Field of view (deg)", "Champ de vision (degrés)"), - ("File", "Fichier"), - ("File name without extension; variables insert names", "Nom de fichier sans extension ; les variables insèrent des noms"), - ("File type", "Type de fichier"), - ("Fill", "Remplissage"), - ("Fill the closed path (lasso)", "Remplir le tracé fermé (lasso)"), - ("Fill the path (close it first)", "Remplir le tracé (le fermer d'abord)"), - ("Filter", "Filtre"), - ("Filter the remaining noise while keeping edges and texture detail", "Filtrer le bruit restant en préservant les contours et les détails de texture"), - ("Filters", "Filtres"), - ("Fine noise", "Bruit fin"), - ("Fingerprints", "Empreintes digitales"), - ("Enter a finite number", "Saisissez un nombre fini"), - ("Double-click or press Enter to edit", "Double-cliquez ou appuyez sur Entrée pour modifier"), - ("Fit the input range to the histogram", "Ajuster la plage d'entrée à l'histogramme"), - ("Flatten layer", "Aplatir le calque"), - ( - "Flips the image's green channel, for normal maps made with Y pointing down", - "Inverse le canal vert de l'image, pour les cartes de normales faites avec Y vers le bas", - ), - ("Flow", "Flux"), - ("Flow and opacity", "Flux et opacité"), - ("Flow jitter", "Variation du flux"), - ("Focus distance", "Distance de mise au point"), - ("Folder", "Dossier"), - ("Folders", "Dossiers"), - ("Follow path", "Suivre le tracé"), - ( - "For the whole project: how normal map images set as mesh maps are read (set them again after a change), and the default for export", - "Pour tout le projet : comment les images de carte de normales utilisées comme cartes de maillage sont lues (réaffectez-les après un changement), et la valeur par défaut à l'export", - ), - ("Free and open source (MIT OR Apache-2.0), written in Rust.", "Libre et open source (MIT OR Apache-2.0), écrit en Rust."), - ("From template", "Selon le modèle"), - ("From template / project", "Selon le modèle / projet"), - ("Full", "Pleine"), - ("GPU error: {error}", "Erreur GPU : {error}"), - ("Geometry mask", "Masque de géométrie"), - ( - "GGX specular with height-correlated Smith visibility, Lambert diffuse, split-sum image-based lighting with spherical-harmonics irradiance and horizon fading.", - "Spéculaire GGX avec visibilité de Smith corrélée à la hauteur, diffus Lambert, éclairage basé sur l'image en split-sum avec irradiance en harmoniques sphériques et atténuation à l'horizon.", - ), - ("Gamma", "Gamma"), - ("General export parameters", "Paramètres d'export généraux"), - ("General properties", "Propriétés générales"), - ("Generator", "Générateur"), - ("Geometry and UVs only", "Géométrie et UV uniquement"), - ("Glossiness", "Brillance"), - ("Glossiness from roughness", "Brillance depuis la rugosité"), - ("Glow", "Lueur"), - ("Gradient", "Dégradé"), - ("Gradient Map", "Carte de dégradé"), - ("Gravity", "Gravité"), - ("Gray", "Gris"), - ("Gray + A", "Gris + A"), - ("Gray 50%", "Gris 50 %"), - ("Grayscale", "Niveaux de gris"), - ("Group layer(s)", "Grouper le(s) calque(s)"), - ("Grunge", "Grunge"), - ("HDR environments", "Environnements HDR"), - ("High Pass", "Passe-haut"), - ("HSL Perceptive", "TSL perceptuel"), - ("Half", "Moitié"), - ("Hammered", "Martelé"), - ("Hard light", "Lumière crue"), - ("Hardness", "Dureté"), - ("Height", "Hauteur"), - ("Height offset", "Décalage de hauteur"), - ("Height to normal strength", "Intensité hauteur vers normale"), - ("Help", "Aide"), - ("Hide UI", "Masquer l'interface"), - ("High", "Haut"), - ("High poly: {name}", "High poly : {name}"), - ("Highlights", "Tons clairs"), - ("Histogram Range", "Plage d'histogramme"), - ("Histogram Scan", "Balayage d'histogramme"), - ("Histogram Shift", "Décalage d'histogramme"), - ("History", "Historique"), - ( - "Hold S: left-drag rotates, right-drag scales, middle-drag moves the stencil.", - "Maintenez S : glisser (clic gauche) fait pivoter, glisser (clic droit) redimensionne, glisser (clic milieu) déplace le pochoir.", - ), - ("Hold V and click the mesh to set the clone source", "Maintenez V et cliquez sur le maillage pour définir la source du clonage"), - ( - "Hold V and click the mesh to set the source, then paint elsewhere to copy it.", - "Maintenez V et cliquez sur le maillage pour définir la source, puis peignez ailleurs pour la copier.", - ), - ( - "How far light travels under the surface, as a fraction of the mesh size (where the Scattering weight channel is painted)", - "Distance parcourue par la lumière sous la surface, en fraction de la taille du maillage (là où le canal Poids de diffusion est peint)", - ), - ( - "How strongly transmissive surfaces bend light (where the Transmission channel is painted): water 1.33, glass 1.5, diamond 2.42", - "Degré de déviation de la lumière par les surfaces transmissives (là où le canal Transmission est peint) : eau 1,33, verre 1,5, diamant 2,42", - ), - ("Hue shift (degrees)", "Décalage de teinte (degrés)"), - ("ID", "ID"), - ("Image: {name}", "Image : {name}"), - ("Images", "Images"), - ("Import HDR...", "Importer un HDR..."), - ("Import a template (.json)", "Importer un modèle (.json)"), - ( - "Import an image (File > Import resources) to project it onto the mesh.", - "Importez une image (Fichier > Importer des ressources) pour la projeter sur le maillage.", - ), - ("Import images to use them in fills and masks", "Importez des images pour les utiliser dans les remplissages et les masques"), - ("Import resources...", "Importer des ressources..."), - ("Import MaterialX material...", "Importer un matériau MaterialX..."), - ("MaterialX materials", "Matériaux MaterialX"), - ("Import...", "Importer..."), - ("Imported template \"{name}\"", "Modèle « {name} » importé"), - ("Imported {name}", "{name} importé"), - ("Index of refraction", "Indice de réfraction"), - ("Input high", "Entrée haute"), - ("Input low", "Entrée basse"), - ("Input maps", "Cartes d'entrée"), - ("Insert a variable", "Insérer une variable"), - ("Instance", "Instance"), - ("Instantiate across texture sets", "Instancier dans les ensembles de textures"), - ("Intensity (texels at 2K)", "Intensité (texels en 2K)"), - ("Interface", "Interface"), - ("Interface scale", "Échelle de l'interface"), - ("Inverse Subtract", "Soustraction inverse"), - ("Inverse divide", "Division inverse"), - ("Invert", "Inverser"), - ("Invert mask", "Inverser le masque"), - ("Invert mask background", "Inverser le fond du masque"), - ("Invert mask value", "Inverser la valeur du masque"), - ("Invert quick mask", "Inverser le masque rapide"), - ("Jitters", "Variations"), - ("Join the ArtCraft community on Discord", "Rejoindre la communauté ArtCraft sur Discord"), - ("Join the community (Discord)...", "Rejoindre la communauté (Discord)..."), - ("Key light (shadow-casting light, direct only)", "Lumière principale (projette des ombres, directe uniquement)"), - ("Keyboard", "Clavier"), - ("Keyboard shortcuts", "Raccourcis clavier"), - ("Light azimuth (degrees)", "Azimut de la lumière (degrés)"), - ("Light elevation (degrees)", "Élévation de la lumière (degrés)"), - ("Light intensity", "Intensité de la lumière"), - ("LMB", "Clic gauche"), - ("Language", "Langue"), - ("Layer mask", "Masque de calque"), - ("Layer memory: {mb} MB", "Mémoire des calques : {mb} Mo"), - ("Layers", "Calques"), - ("Lazy mouse", "Stabilisateur"), - ("Lazy mouse distance", "Distance du stabilisateur"), - ("Leather grain", "Grain de cuir"), - ( - "Lens size: how quickly things blur away from the focus distance", - "Taille de l'objectif : vitesse à laquelle les objets deviennent flous en s'éloignant de la distance de mise au point", - ), - ("Level", "Niveau"), - ("Levels", "Niveaux"), - ("Lifetime (steps)", "Durée de vie (pas)"), - ("Light / direction", "Lumière / direction"), - ("Lighten (Max)", "Éclaircir (Max)"), - ("Lightness", "Clarté"), - ("Linear", "Linéaire"), - ("Linear burn", "Densité linéaire +"), - ("Linear dodge (Add)", "Densité linéaire - (Ajout)"), - ("Linear light", "Lumière linéaire"), - ("List of exports", "Liste des exports"), - ("Load UI Layout", "Charger une disposition"), - ("Loaded UI layout {path}", "Disposition de l'interface chargée : {path}"), - ("Log", "Journal"), - ("Low", "Bas"), - ("Luminosity", "Luminosité"), - ("MMB drag / Alt + MMB", "Glisser (clic milieu) / Alt + clic milieu"), - ("Made by the ArtCraft team and community.", "Créé par l'équipe et la communauté ArtCraft."), - ("Magenta / green", "Magenta / vert"), - ("Main shader", "Shader principal"), - ("Marble veins", "Veines de marbre"), - ("Mask", "Masque"), - ("Mask Editor: Edge wear", "Éditeur de masque : usure des arêtes"), - ("Mask value (gray)", "Valeur du masque (gris)"), - ("Mask with height", "Masquer avec la hauteur"), - ("MatFinish Grind", "MatFinish Meulé"), - ("MatFinish Hammered", "MatFinish Martelé"), - ("MatFinish Raw", "MatFinish Brut"), - ("MatFinish Sanded", "MatFinish Poncé"), - ("Material", "Matériau"), - ("Material ball", "Boule de matériau"), - ("Material finish", "Finition du matériau"), - ("Materials", "Matériaux"), - ("Maximum", "Maximum"), - ("Mesh fill", "Remplissage par maillage"), - ("Mesh map: {map}", "Carte de maillage : {map}"), - ("Mesh maps", "Cartes de maillage"), - ("Mesh maps baked", "Cartes de maillage précalculées"), - ("Meshes", "Maillages"), - ("Metallic", "Métallique"), - ("Midtones", "Tons moyens"), - ("Minimum", "Minimum"), - ("Minimum size (%)", "Taille minimale (%)"), - ("Missing (bake to create)", "Manquante (précalculer pour la créer)"), - ("Mixed AO", "AO mixte"), - ("Mode", "Mode"), - ("More in Assets > Alphas: click one, or drag it here", "Plus dans Ressources > Alphas : cliquez sur l'un d'eux ou faites-le glisser ici"), - ("Mosaic", "Mosaïque"), - ("Move down", "Descendre"), - ("Move up", "Monter"), - ( - "Moves the surface by the height channel on a finer copy of the mesh, at the height to normal strength (viewport only: painting follows the base surface)", - "Déplace la surface selon le canal de hauteur sur une copie plus fine du maillage, à la force de hauteur vers normale (fenêtre d'affichage uniquement : la peinture suit la surface de base)", - ), - ("Multiply", "Produit"), - ("My smart materials", "Mes matériaux intelligents"), - ("Name", "Nom"), - ("New project", "Nouveau projet"), - ("New project...", "Nouveau projet..."), - ("New template", "Nouveau modèle"), - ("No GPU renderer available", "Aucun moteur de rendu GPU disponible"), - ("No font on this system can show this language", "Aucune police de ce système ne peut afficher cette langue"), - ( - "No outputs yet: add one above, then drag input maps onto its channels.", - "Aucune sortie pour l'instant : ajoutez-en une ci-dessus, puis glissez des cartes d'entrée sur ses canaux.", - ), - ("No padding (passthrough)", "Sans marge (transfert direct)"), - ("Noise amount", "Quantité de bruit"), - ("Noise scale", "Échelle du bruit"), - ("None", "Aucun"), - ("Normal", "Normal"), - ("Normal DirectX", "Normale DirectX"), - ("Normal Invert", "Inversion de normale"), - ("Normal OpenGL", "Normale OpenGL"), - ("Normal from height", "Normale depuis la hauteur"), - ("Normal map combine", "Normales : combinaison"), - ("Normal map detail", "Normales : détail"), - ("Color space", "Espace colorimétrique"), - ("Normal map format", "Format de carte de normales"), - ("Normal map inverse detail", "Normales : détail inverse"), - ("Normal: painting uses the flat normal", "Normal : la peinture utilise la normale plate"), - ( - "Not enough GPU memory to show texture set \"{name}\" fully: lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "Mémoire GPU insuffisante pour afficher entièrement l'ensemble de textures \"{name}\" : réduisez la résolution des textures de l'affichage dans les Paramètres. La peinture et l'export ne sont pas affectés.", - ), - ( - "Not enough GPU memory to show {count} texture sets fully ({names}): lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "Mémoire GPU insuffisante pour afficher entièrement {count} ensembles de textures ({names}) : réduisez la résolution des textures de l'affichage dans les Paramètres. La peinture et l'export ne sont pas affectés.", - ), - ("Not exported: no source in this texture set", "Non exporté : aucune source dans cet ensemble de textures"), - ("Not saved: {error}", "Non enregistré : {error}"), - ("Off", "Désactivé"), - ("Offset", "Décalage"), - ("Offset right", "Décalage vers la droite"), - ("Offset up", "Décalage vers le haut"), - ("Offset {axis}", "Décalage {axis}"), - ( - "Offsets the textures by the height channel, at the height to normal strength", - "Décale les textures selon le canal de hauteur, avec l'intensité hauteur vers normale", - ), - ("On", "Activé"), - ("Opacity", "Opacité"), - ("Open sample project...", "Ouvrir un projet d'exemple..."), - ("Open...", "Ouvrir..."), - ("Opened {name}", "{name} ouvert"), - ( - "Optional channels add a clear coat (Coat weight, Coat roughness, Coat normal), sheen (Sheen weight, color, roughness), anisotropy (Anisotropy level, angle), subsurface scattering (Scattering weight) and transmission (Transmission).", - "Les canaux optionnels ajoutent un vernis (Poids du vernis, Rugosité du vernis, Normale du vernis), un lustre (Poids du lustre, couleur, rugosité), une anisotropie (Niveau d'anisotropie, angle), une diffusion sous-surfacique (Poids de diffusion) et une transmission (Transmission).", - ), - ("Orbit", "Orbite"), - ("Orthographic", "Orthographique"), - ("Perspective", "Perspective"), - ("Output directory", "Dossier de sortie"), - ("Output high", "Sortie haute"), - ("Output low", "Sortie basse"), - ("Output template", "Modèle de sortie"), - ("Output templates", "Modèles de sortie"), - ("Overlay", "Incrustation"), - ("Overlay opacity", "Opacité de superposition"), - ("PBR - Metallic Roughness (TextureCraft)", "PBR - Métallique Rugosité (TextureCraft)"), - ("Pick color", "Prélever une couleur"), - ("PNG image", "Image PNG"), - ("Padding", "Marge"), - ("Paint", "Peinture"), - ("Paint chips", "Éclats de peinture"), - ("Paint on the mesh to edit the layer content.", "Peignez sur le maillage pour modifier le contenu du calque."), - ( - "Paint on the mesh to edit this mask. Use the Material tab's mask value for gray.", - "Peignez sur le maillage pour modifier ce masque. Utilisez la valeur de masque de l'onglet Matériau pour le gris.", - ), - ("Paint with the current tool", "Peindre avec l'outil actuel"), - ( - "Painted layer pixels {pixels} MB, composited channels {composites} MB, compositing cache {cache} MB", - "Pixels des calques peints {pixels} Mo, canaux composités {composites} Mo, cache de composition {cache} Mo", - ), - ("Painting", "Peinture"), - ("Pan", "Panoramique"), - ("Parallax occlusion (height channel)", "Occlusion parallaxe (canal de hauteur)"), - ( - "Partial mask values follow the layer's height: high parts show first", - "Les valeurs de masque partielles suivent la hauteur du calque : les parties hautes apparaissent en premier", - ), - ("Particle brush (slides down the surface)", "Pinceau à particules (glisse le long de la surface)"), - ("Particle brush: particles slide down the surface", "Pinceau à particules : les particules glissent le long de la surface"), - ("Particles", "Particules"), - ("Passthrough", "Transfert"), - ("Paste as instance", "Coller comme instance"), - ("Paste effect", "Coller l'effet"), - ("Paste layer(s)", "Coller le(s) calque(s)"), - ("Path", "Tracé"), - ("Path trace on the processor instead of the graphics card (slower)", "Tracé de chemins sur le processeur au lieu de la carte graphique (plus lent)"), - ( - "Path: click adds a point, click the curve inserts one, drag moves it, Enter applies, Esc cancels", - "Tracé : cliquer ajoute un point, cliquer sur la courbe en insère un, glisser le déplace, Enter applique, Esc annule", - ), - ("Pattern scale", "Échelle du motif"), - ("Perlin noise", "Bruit de Perlin"), - ("Pick focus in the viewport", "Choisir la mise au point dans la fenêtre d'affichage"), - ("Pin light", "Lumière ponctuelle"), - ("Place on the surface", "Placer sur la surface"), - ("Place path points on the mesh", "Placez les points du tracé sur le maillage"), - ("Planar projection", "Projection planaire"), - ("Plane", "Plan"), - ("Polygon fill", "Remplissage de polygones"), - ("Pores", "Pores"), - ("Position", "Position"), - ("Position gradient", "Dégradé de position"), - ("Position jitter", "Variation de position"), - ("Posterize", "Postérisation"), - ("Press a key...", "Appuyez sur une touche..."), - ("Procedurals", "Procéduraux"), - ("Project", "Projet"), - ("Project Configuration...", "Configuration du projet..."), - ("Project opened", "Projet ouvert"), - ("Project template", "Modèle de projet"), - ("Projection", "Projection"), - ("Projects and meshes", "Projets et maillages"), - ("Properties", "Propriétés"), - ("Quarter", "Quart"), - ("Quick mask", "Masque rapide"), - ("Quit", "Quitter"), - ("Radius (texels at 2K)", "Rayon (texels en 2K)"), - ("RENDERING", "RENDU"), - ("Range", "Plage"), - ("Rebind any menu item, tool or command", "Réattribuer n'importe quel élément de menu, outil ou commande"), - ("Recent projects", "Projets récents"), - ( - "Records the stack up to this layer. Fill effects in masks (and fill layers) above can read it as a source.", - "Enregistre la pile jusqu'à ce calque. Les effets de remplissage des masques (et les calques de remplissage) situés au-dessus peuvent l'utiliser comme source.", - ), - ("Redo", "Rétablir"), - ("Reimport mesh", "Réimporter le maillage"), - ("Remove", "Supprimer"), - ("Remove channel", "Supprimer le canal"), - ("Remove effect", "Supprimer l'effet"), - ("Remove last", "Supprimer le dernier"), - ("Remove layer", "Supprimer le calque"), - ("Remove layer(s)", "Supprimer le(s) calque(s)"), - ("Remove mask", "Supprimer le masque"), - ("Remove point", "Retirer le point"), - ("Remove resource", "Supprimer la ressource"), - ("Remove the shortcut", "Supprimer le raccourci"), - ("Remove this output", "Supprimer cette sortie"), - ("Remove unused resources...", "Supprimer les ressources inutilisées..."), - ("Rename the selected template", "Renommer le modèle sélectionné"), - ("Render on the CPU", "Rendu sur le CPU"), - ("Rendering", "Rendu"), - ("Rendering (path traced)", "Rendu (tracé de chemins)"), - ("Rendering on CPU: {n} / {max} samples, {s} s", "Rendu sur CPU : {n} / {max} échantillons, {s} s"), - ("Rendering on GPU: {n} / {max} samples, {s} s", "Rendu sur GPU : {n} / {max} échantillons, {s} s"), - ("Rendering, path traced", "Rendu, tracé de chemins"), - ("Replace", "Remplacer"), - ("Replace Color", "Remplacer la couleur"), - ("Replacement color", "Couleur de remplacement"), - ("Report a bug...", "Signaler un bug..."), - ("Rescan the library folder", "Réanalyser le dossier de la bibliothèque"), - ("Reset", "Réinitialiser"), - ("Reset UI", "Réinitialiser l'interface"), - ("Reset all", "Tout réinitialiser"), - ("Reset to defaults", "Rétablir les valeurs par défaut"), - ("Reset to {shortcut}", "Réinitialiser à {shortcut}"), - ("Resizing", "Redimensionnement"), - ("Restore every default shortcut", "Restaurer tous les raccourcis par défaut"), - ("Return to this step", "Revenir à cette étape"), - ("Right-click a layer > Create smart material", "Clic droit sur un calque > Créer un matériau intelligent"), - ("Rotation", "Rotation"), - ("Rotation (degrees)", "Rotation (degrés)"), - ("Roughness", "Rugosité"), - ("Roughness from glossiness", "Rugosité depuis la brillance"), - ("Round", "Rond"), - ("Rounded cube", "Cube arrondi"), - ("Samples", "Échantillons"), - ("Saturation", "Saturation"), - ("Save", "Enregistrer"), - ("Save UI Layout", "Enregistrer la disposition"), - ("Save a copy...", "Enregistrer une copie..."), - ("Save as...", "Enregistrer sous..."), - ("Save current layout...", "Enregistrer la disposition actuelle..."), - ("Save render...", "Enregistrer le rendu..."), - ("Save view as camera", "Enregistrer la vue comme caméra"), - ("Saved UI layout {path}", "Disposition de l'interface enregistrée : {path}"), - ("Saved {path}", "Enregistré : {path}"), - ( - "Saving UI layouts to files is available in the desktop app", - "L'enregistrement des dispositions dans des fichiers est disponible dans l'application de bureau", - ), - ("Scale", "Échelle"), - ("Scale / tiling", "Échelle / répétition"), - ("Scatter color", "Couleur de diffusion"), - ("Scatter radius", "Rayon de diffusion"), - ("Scattering weight", "Poids de diffusion"), - ("Scratches", "Rayures"), - ("Screen", "Superposition"), - ("Screenshot of the viewport", "Capture de la fenêtre d'affichage"), - ("Search", "Rechercher"), - ("Search all assets", "Rechercher dans toutes les ressources"), - ("Search commands or keys", "Rechercher des commandes ou des touches"), - ("Seed", "Graine"), - ("Select a layer", "Sélectionnez un calque"), - ("Select an output template", "Sélectionnez un modèle de sortie"), - ("Select source", "Sélectionner la source"), - ("Select the mask (Alt+click: show it in the viewport)", "Sélectionner le masque (Alt+clic : l'afficher dans la fenêtre d'affichage)"), - ("Select...", "Sélectionner..."), - ("Settings", "Paramètres"), - ("Settings...", "Paramètres..."), - ("Shader Settings", "Paramètres du shader"), - ("Shader instance", "Instance de shader"), - ("Shadows", "Tons foncés"), - ("Sharpen", "Netteté"), - ("Sheen color", "Couleur du lustre"), - ("Sheen color × weight", "Couleur du lustre × poids"), - ("Sheen roughness", "Rugosité du lustre"), - ("Sheen weight", "Poids du lustre"), - ("Shift + wheel", "Shift + molette"), - ("Shortcuts list...", "Liste des raccourcis..."), - ("Show on all parts", "Afficher sur toutes les parties"), - ("Show UV wireframe in the 2D view", "Afficher le filaire UV dans la vue 2D"), - ("Show entire mesh", "Afficher tout le maillage"), - ("Show log...", "Afficher le journal..."), - ("Show or hide the layer", "Afficher ou masquer le calque"), - ("Show or hide the texture set", "Afficher ou masquer l'ensemble de textures"), - ("Show wireframe in the 3D view", "Afficher le filaire dans la vue 3D"), - ("Signed addition (AddSub)", "Addition signée (AddSub)"), - ("Size", "Taille"), - ("Size in screen space", "Taille en espace écran"), - ("Size jitter", "Variation de taille"), - ( - "Size of the textures the viewport shows: lower uses less GPU memory with large texture sets. Painting and export keep full resolution.", - "Taille des textures affichées dans la fenêtre d'affichage : plus basse, elle consomme moins de mémoire GPU avec de grands ensembles de textures. La peinture et l'export gardent la pleine résolution.", - ), - ("Slope Blur", "Flou de pente"), - ("Slope scale", "Échelle de pente"), - ("Smart masks", "Masques intelligents"), - ("Smart material saved to {path}", "Matériau intelligent enregistré dans {path}"), - ("Smart materials", "Matériaux intelligents"), - ("Smudge", "Barbouillage"), - ("Soft light", "Lumière tamisée"), - ("Softness", "Douceur"), - ("Source", "Source"), - ("Source U {u} V {v}", "Source U {u} V {v}"), - ("Spacing", "Espacement"), - ("Specular", "Spéculaire"), - ("Specular level", "Niveau spéculaire"), - ("Sphere", "Sphère"), - ("Spherical projection", "Projection sphérique"), - ("Spray", "Aérosol"), - ("Square", "Carré"), - ("Stamp depth", "Profondeur d'empreinte"), - ("Star", "Étoile"), - ("Starting render...", "Démarrage du rendu..."), - ("Stencil", "Pochoir"), - ("Steps", "Paliers"), - ("Streaks", "Traînées"), - ("Strength", "Force"), - ("Stripes", "Bandes"), - ("Stroke opacity", "Opacité du trait"), - ("Subsampling 2x2", "Sous-échantillonnage 2x2"), - ("Subsampling 4x4", "Sous-échantillonnage 4x4"), - ("Subsampling 8x8", "Sous-échantillonnage 8x8"), - ("Subsurface scattering", "Diffusion sous-surfacique"), - ("Subtract", "Soustraction"), - ("Tangent | Wrap", "Tangente | Enveloppe"), - ("Temporal anti-aliasing (refines the 3D view while it is still)", "Anticrénelage temporel (affine la vue 3D tant qu'elle est immobile)"), - ("Texture Sets", "Ensembles de textures"), - ("Texture Set Settings", "Paramètres de l'ensemble de textures"), - ("Texture resolution", "Résolution des textures"), - ("Texture set channels", "Canaux de l'ensemble de textures"), - ("Texture sets", "Ensembles de textures"), - ("TextureCraft had to close:", "TextureCraft a dû se fermer :"), - ("TextureCraft PBR - Metallic Roughness", "TextureCraft PBR - Métallique Rugosité"), - ("TextureCraft PBR - Specular Glossiness", "TextureCraft PBR - Spéculaire Brillance"), - ("TextureCraft project", "Projet TextureCraft"), - ("TextureCraft project or mesh", "Projet TextureCraft ou maillage"), - ("Textures", "Textures"), - ("Textures embedded; for game engines and most viewers", "Textures intégrées ; pour les moteurs de jeu et la plupart des visionneuses"), - ("Textures packaged; for USD tools and AR Quick Look", "Textures empaquetées ; pour les outils USD et AR Quick Look"), - ("The GPU couldn't render this scene: {error}", "Le GPU n'a pas pu rendre cette scène : {error}"), - ("The bake worker stopped", "Le processus de précalcul s'est arrêté"), - ("The eraser removes paint from the enabled channels.", "La gomme efface la peinture des canaux activés."), - ("The first stroke sets the offset from the source.", "Le premier trait définit le décalage par rapport à la source."), - ( - "The image's alpha cuts the decal's shape; faces turned away and surfaces beyond its depth stay clear.", - "L'alpha de l'image découpe la forme du décalque ; les faces orientées à l'opposé et les surfaces au-delà de sa profondeur restent intactes.", - ), - ("The next click in the 3D view moves the decal there", "Le prochain clic dans la vue 3D y déplace le décalque"), - ("The resize worker stopped", "Le processus de redimensionnement s'est arrêté"), - ("Thickness", "Épaisseur"), - ("Thin areas", "Zones fines"), - ("Threshold", "Seuil"), - ("Tile", "Répéter"), - ("Tiles", "Carreaux"), - ("Tint", "Teinte"), - ("Toggle mask", "Activer/désactiver le masque"), - ("Tolerance", "Tolérance"), - ("Tone mapping", "Mappage des tons"), - ("Tools", "Outils"), - ("Torus", "Tore"), - ("Transmission", "Transmission"), - ("Tri-planar projection", "Projection triplanaire"), - ("Triangle fill", "Remplissage de triangles"), - ("UDIM plane", "Plan UDIM"), - ("UDIM tiles painted by this texture set, each at the set's size", "Tuiles UDIM peintes par cet ensemble de textures, chacune à la taille de l'ensemble"), - ("UI layout", "Disposition de l'interface"), - ("UI layout: {error}", "Disposition de l'interface : {error}"), - ("UI layouts", "Dispositions de l'interface"), - ("UI {ms} ms", "Interface {ms} ms"), - ("USD binary, textures alongside", "USD binaire, textures à côté"), - ("USD text, textures alongside", "USD texte, textures à côté"), - ("USDZ with textures", "USDZ avec textures"), - ("UV checker", "Damier UV"), - ("UV island fill", "Remplissage d'îlots UV"), - ("UV transformations", "Transformations UV"), - ("UV projection", "Projection UV"), - ("UV tiles", "Tuiles UV"), - ("UV tiles (UDIM)", "Tuiles UV (UDIM)"), - ("Undo", "Annuler"), - ("Uniform value", "Valeur uniforme"), - ("Use an equirectangular .hdr or .exr image as the environment", "Utiliser une image équirectangulaire .hdr ou .exr comme environnement"), - ( - "Use the control channel or `texturecraft-cli render` for screenshots", - "Utilisez le canal de contrôle ou `texturecraft-cli render` pour les captures d'écran", - ), - ("Value", "Valeur"), - ("Version {version}", "Version {version}"), - ("Version: {version} ({gpu})", "Version : {version} ({gpu})"), - ("View through this camera", "Voir à travers cette caméra"), - ("Viewer settings", "Paramètres de visualisation"), - ("Viewport", "Affichage"), - ("Viewport and brush (fixed)", "Fenêtre d'affichage et pinceau (fixes)"), - ("Views", "Vues"), - ("Vivid light", "Lumière vive"), - ("Voronoi", "Voronoï"), - ("Warp", "Distorsion"), - ("Warp Directional", "Distorsion directionnelle"), - ("Wavefront OBJ with MTL, textures alongside", "Wavefront OBJ avec MTL, textures à côté"), - ( - "WebGPU isn't available in this browser, so TextureCraft runs on WebGL2: Rendering mode path traces on the CPU (slower) and large texture sets show at reduced resolution. A current Chrome, Edge or Safari has WebGPU.", - "WebGPU n'est pas disponible dans ce navigateur : TextureCraft utilise WebGL2. Le mode Rendu calcule le tracé de chemins sur le CPU (plus lent) et les grands ensembles de textures s'affichent en résolution réduite. Une version récente de Chrome, Edge ou Safari prend en charge WebGPU.", - ), - ("Wheel / Alt + RMB drag", "Molette / Alt + glisser (clic droit)"), - ("White", "Blanc"), - ("Width", "Largeur"), - ("Width (texels at 2K)", "Largeur (texels en 2K)"), - ("Window", "Fenêtre"), - ("Wood grain", "Veinage du bois"), - ("Works in texture space, like the blur: it does not cross UV seams.", "Fonctionne en espace texture, comme le flou : ne traverse pas les coutures UV."), - ("World Space Normal", "Normale en espace monde"), - ("Yellow / blue", "Jaune / bleu"), - ("Zoom", "Zoom"), - ("a missing layer", "un calque manquant"), - ("aniso", "aniso"), - ("aniso angle", "ang aniso"), - ("ao", "ao"), - ("coat", "vernis"), - ("coat nrm", "nrm vern"), - ("coat rough", "rug vern"), - ("color", "couleur"), - ("emiss", "émis"), - ("glTF binary with textures", "glTF binaire avec textures"), - ("gloss", "brill"), - ("height", "hauteur"), - ("metal", "métal"), - ("min", "min"), - ("missing", "manquant"), - ("missing source", "source manquante"), - ("no GPU", "pas de GPU"), - ("none", "aucun"), - ("nrm", "nrm"), - ("off", "désact."), - ("op", "op"), - ("rough", "rug"), - ("scatter", "diffus"), - ("sheen", "lustre"), - ("sheen color", "coul lus"), - ("sheen rough", "rug lus"), - ("spec", "spéc"), - ("specular", "spécul"), - ("transm", "transm"), - ("{action} (undone)", "{action} (annulé)"), - ( - "{file}: add above the selected layer (or drag it into the layer stack or onto the viewport)", - "{file} : ajouter au-dessus du calque sélectionné (ou le glisser dans la pile de calques ou sur la fenêtre d'affichage)", - ), - ("{name} copy", "Copie de {name}"), - ("{n} bits", "{n} bits"), - ( - "{n} control points. Click the mesh (or the 2D view) to add points and drag them to adjust; click the first point to close the path. Enter paints it with the brush (a closed, filled path fills its inside), Esc cancels.", - "{n} points de contrôle. Cliquez sur le maillage (ou la vue 2D) pour ajouter des points et faites-les glisser pour les ajuster ; cliquez sur le premier point pour fermer le tracé. Entrée le peint avec le pinceau (un tracé fermé et rempli remplit son intérieur), Échap annule.", - ), - ("{n} items share a shortcut; the first one listed wins.", "{n} éléments partagent un raccourci ; le premier de la liste l'emporte."), - ("{pattern} (scale {scale}, seed {seed})", "{pattern} (échelle {scale}, graine {seed})"), - ("Template name", "Nom du modèle"), - ("Save current project as template", "Enregistrer le projet actuel comme modèle"), - ("Distribution", "Distribution"), - ("Cosine", "Cosinus"), - ("Uniform", "Uniforme"), - ("Normalization", "Normalisation"), - // Settings › Interface: brightness and accent color. - ("Brightness", "Luminosité"), - ("Dark", "Sombre"), - ("Medium dark", "Moyennement sombre"), - ("Medium light", "Moyennement clair"), - ("Light", "Clair"), - ("Accent color", "Couleur d'accentuation"), - ("Copper", "Cuivre"), - ("Coral", "Corail"), - ("Blue", "Bleu"), - ("Violet", "Violet"), - ("Green", "Vert"), - ("Amber", "Ambre"), - ("Pink", "Rose"), - ("Minimize", "Réduire"), - ("Maximize", "Agrandir"), - ("Restore", "Restaurer"), - ("Title bar", "Barre de titre"), - ("System title bar (applies on restart)", "Barre de titre du système (au prochain démarrage)"), - ( - "Use the operating system's window frame and buttons instead of TextureCraft's own title bar", - "Utiliser le cadre et les boutons de fenêtre du système d'exploitation au lieu de la barre de titre de TextureCraft", - ), - ("Brushes", "Pinceaux"), - ("My brushes", "Mes pinceaux"), - ("Use this brush (keeps its size)", "Utiliser ce pinceau (garde sa taille)"), - ("Brush name", "Nom du pinceau"), - ("Save current brush", "Enregistrer le pinceau actuel"), - ("Start window", "Fenêtre de démarrage"), - ("Show at startup", "Afficher au démarrage"), - ("Continue with the sample project", "Continuer avec le projet d'exemple"), - ("No recent projects yet", "Aucun projet récent pour l'instant"), - ("Text", "Texte"), - ("Font", "Police"), - ("Style", "Style"), - ("Use as brush alpha", "Utiliser comme alpha du pinceau"), - ("Place as decal", "Placer en décalque"), - ("Click: turn this channel on or off. Alt+click: this channel only", "Clic : active ou désactive ce canal. Alt+clic : ce canal uniquement"), - ("Show all", "Tout afficher"), - ("Hide all", "Tout masquer"), - ("Invert show/hide", "Inverser afficher/masquer"), - ("Show or hide texture sets", "Afficher ou masquer les ensembles de textures"), - ("Focus: show only the active texture set", "Focus : n'afficher que l'ensemble de textures actif"), - ("Unsaved changes", "Modifications non enregistrées"), - ("Don't save", "Ne pas enregistrer"), - ("Save the changes to {name} before closing?", "Enregistrer les modifications de {name} avant de fermer ?"), - ("Radius", "Rayon"), - ("Remove skew correction", "Supprimer la correction d'inclinaison"), - ("Twill weave", "Armure sergé"), - ("Save the changes to {name} first?", "Enregistrer d'abord les modifications de {name} ?"), - ( - "Paths stay editable: pick one to move its points or change its brush and material, and the sublayer repaints at once. Add paths with the Path tool.", - "Les tracés restent modifiables : choisissez-en un pour déplacer ses points ou changer sa brosse et sa matière, et la sous-couche se repeint aussitôt. Ajoutez des tracés avec l'outil Tracé.", - ), - ("Import material...", "Importer un matériau..."), - ("MaterialCraft material", "Matériau MaterialCraft"), - ("Cooked at {size} px", "Calculé en {size} px"), - ("Preset", "Préréglage"), - ("Re-cook", "Recalculer"), - ("Open in MaterialCraft", "Ouvrir dans MaterialCraft"), - ( - "Opened in MaterialCraft: use File > Send to TextureCraft there to bring your changes back", - "Ouvert dans MaterialCraft : utilisez-y Fichier > Envoyer vers TextureCraft pour récupérer vos modifications", - ), - ( - "Parameters change in the desktop app, with MaterialCraft installed", - "Les paramètres se modifient dans l'application de bureau, avec MaterialCraft installé", - ), - ("Add High-Poly Meshes", "Ajouter des maillages haute définition"), - ("All", "Tous"), - ("Apply Diffusion", "Appliquer la diffusion"), - ("Attenuation", "Atténuation"), - ("Auto Tonemapping", "Mappage tonal automatique"), - ("Average Normals", "Moyenne des normales"), - ("BBox", "Boîte englobante"), - ("BSphere", "Sphère englobante"), - ("Mesh Map Bakers", "Précalculateurs de cartes de maillage"), - ("Common Settings", "Paramètres communs"), - ("Mesh Map Settings", "Paramètres des cartes de maillage"), - ("Check All", "Tout cocher"), - ("No Parameters", "Aucun paramètre"), - ("Bake Selected Textures ({n})", "Précalculer les textures sélectionnées ({n})"), - ("By Mesh Name", "Par nom de maillage"), - ("Cage", "Cage"), - ("Cage Scene", "Scène de cage"), - ("Cage Type", "Type de cage"), - ("Color Generator", "Générateur de couleurs"), - ("Color Source", "Source de couleur"), - ("Common Parameters", "Paramètres communs"), - ("Custom File", "Fichier personnalisé"), - ("Details", "Détails"), - ("Dilation Width", "Largeur de dilatation"), - ("Distance-Based", "Selon la distance"), - ("Edge Contrast", "Contraste des arêtes"), - ("Edge Distance", "Distance des arêtes"), - ("Edge Protection", "Protection des arêtes"), - ("Enable Seams", "Activer les coutures"), - ("File ID", "ID du fichier"), - ("Full Scene", "Scène entière"), - ("Generate from Mesh", "Générer depuis le maillage"), - ("Generate from Normal Map", "Générer depuis la carte de normales"), - ("Ground Plane", "Plan du sol"), - ("Ground Plane Offset", "Décalage du sol"), - ("High Poly Mesh Suffix", "Suffixe du maillage high poly"), - ("High Poly Scene", "Scène haute définition"), - ("High-Poly Parameters", "Paramètres haute définition"), - ("Hue Shift", "Décalage de teinte"), - ("Ignore Backface", "Ignorer les faces arrière"), - ("Ignore Backface Suffix", "Suffixe des faces arrière ignorées"), - ("Include in Bake", "Inclure dans le précalcul"), - ("Load Cage", "Charger une cage"), - ("Lock Output Size", "Verrouiller les dimensions de sortie"), - ("Low Poly Mesh Suffix", "Suffixe du maillage low poly"), - ("Manual", "Manuel"), - ("Material Color", "Couleur du matériau"), - ("Max Frontal Distance", "Distance frontale max"), - ("Max Occluder Distance", "Distance max des occulteurs"), - ("Max Rear Distance", "Distance arrière max"), - ("Mesh ID", "ID du maillage"), - ("Method", "Méthode"), - ("Min Occluder Distance", "Distance minimale des occluseurs"), - ("Never", "Jamais"), - ("No High-Poly Meshes", "Aucun maillage haute définition"), - ("Normalization Scale", "Échelle de normalisation"), - ("Normalization Type", "Type de normalisation"), - ("Only Same Mesh Name", "Seulement le même nom de maillage"), - ("Output Size", "Taille de sortie"), - ("Match", "Correspondance"), - ("Skew Correction Method", "Méthode de Correction de Déformation"), - ("Mesh Normals Based", "Basée sur les Normales du Maillage"), - ("Face Normals Based", "Basée sur les Normales des Faces"), - ("Reset Painted Cage", "Réinitialiser la Cage Peinte"), - ("Paint Cage", "Peindre la cage"), - ("Paint Skew Correction", "Peindre la correction d'inclinaison"), - ("Per Material", "Par matériau"), - ("Random", "Aléatoire"), - ("Relative to Bounding Box", "Relatif à la boîte englobante"), - ("Relative to Low Mesh", "Relatif au maillage basse définition"), - ("Relative to Min/Max", "Relatif au minimum/maximum"), - ("Relative to Ray Distances", "Relatif aux distances des rayons"), - ("Remove Cage", "Supprimer la cage"), - ("Remove Skew Correction", "Supprimer la correction d'inclinaison"), - ("Restore Defaults", "Rétablir les valeurs par défaut"), - ("Return to Painting Mode", "Revenir au mode peinture"), - ("Sampling Radius", "Rayon d'échantillonnage"), - ("Scaling Divisor", "Diviseur d'échelle"), - ("Seams Intensity", "Intensité des coutures"), - ("Secondary Rays", "Rayons secondaires"), - ("Self Intersection", "Auto-intersection"), - ("Self Occlusion", "Auto-occlusion"), - ("Skew Correction", "Correction d'inclinaison"), - ("Smooth", "Lisse"), - ("Spread Angle", "Angle de dispersion"), - ("Submesh", "Sous-maillage"), - ("Use Low Poly Mesh as High Poly Mesh", "Utiliser le maillage low poly comme maillage high poly"), - ("Value Bounds Max", "Borne maximale"), - ("Value Bounds Min", "Borne minimale"), - ("Vertex Color", "Couleur des sommets"), - ("Select the layer content", "Sélectionner le contenu du calque"), - ("Paint layer", "Calque de peinture"), - ("Fill layer", "Calque de remplissage"), - ("1 effect", "1 effet"), - ("{count} effects", "{count} effets"), - ("Mask effects", "Effets du masque"), - ("Content effects", "Effets du contenu"), - ("Fold or unfold these effects", "Replier ou déplier ces effets"), - ("Remove resolution override", "Supprimer la résolution personnalisée"), - ("Texture set resolution", "Résolution de l'ensemble de textures"), - ("UV tile {tile} resolution", "Résolution de la tuile UV {tile}"), - ("Angle span", "Amplitude d'angle"), - ("Axis position", "Position de l'axe"), - ("Count", "Nombre"), - ("Display", "Affichage"), - ("Hide while painting", "Masquer pendant la peinture"), - ("Manipulator size", "Taille du manipulateur"), - ("Mirror symmetry", "Symétrie miroir"), - ("Radial settings", "Paramètres radiaux"), - ("Radial symmetry", "Symétrie radiale"), - ("Show axis", "Afficher l'axe"), - ("Show axis position manipulator", "Afficher le manipulateur de position de l'axe"), - ("Show cursor", "Afficher le curseur"), - ("Show intersection", "Afficher l'intersection"), - ("Show plane", "Afficher le plan"), - ("Symmetry", "Symétrie"), - ("Symmetry color display", "Couleur d'affichage de la symétrie"), - ("Symmetry settings", "Paramètres de symétrie"), - ("Type", "Type"), - ("Advanced settings", "Paramètres avancés"), - ("Import baked maps", "Importer des cartes précalculées"), - ("Name each file after its texture set, like Body_normal.png", "Nommez chaque fichier d'après son ensemble de textures, par ex. Body_normal.png"), - ("Add...", "Ajouter..."), - ("Baked maps imported: {count}", "Cartes précalculées importées : {count}"), - ("Not imported: {files}", "Non importés : {files}"), - ("Baking Visualization", "Visualisation du baking"), - ("Show for Selected Texture Set Only", "Afficher uniquement pour l'ensemble de textures sélectionné"), - ("High Definition Mesh (HP)", "Maillage haute définition (HP)"), - ("UV Seams", "Coutures UV"), - ("Project Mesh (LP)", "Maillage de projection (LP)"), - ("Edges", "Arêtes"), - ("Cavities", "Cavités"), - ("Edges and cavities", "Arêtes et cavités"), - ("Raw curvature", "Courbure brute"), - ("Detail sizes", "Tailles de détail"), - ( - "Reads the curvature map as baked: changing the mode or a size turns detail sizes on.", - "Lit la carte de courbure telle que calculée : changer le mode ou une taille active les tailles de détail.", - ), - ( - "A click fills what is under it; a dragged rectangle fills what it selects as it grows", - "Un clic remplit ce qui est dessous ; un rectangle tracé remplit ce qu'il sélectionne à mesure qu'il grandit", - ), - ("Contained center: fill polygons whose center is in the rectangle", "Centre contenu : remplir les polygones dont le centre est dans le rectangle"), - ( - "Editing the quick mask: fills paint where painting is allowed. Press U to finish.", - "Modification du masque rapide : les remplissages peignent là où la peinture est autorisée. Appuyez sur U pour terminer.", - ), - ("Fill mode", "Mode de remplissage"), - ("Fill only polygons the camera sees (3D view)", "Remplir uniquement les polygones que voit la caméra (vue 3D)"), - ("Hit-test", "Test de sélection"), - ("How a rectangle selects polygons", "Comment un rectangle sélectionne les polygones"), - ("Intersection: fill polygons the rectangle touches", "Intersection : remplir les polygones que touche le rectangle"), - ("Rectangle fill", "Remplissage rectangulaire"), - ("Select a paint layer or a layer's mask to fill", "Sélectionnez un calque de peinture ou un masque de calque à remplir"), - ("Selection mode", "Mode de sélection"), - ( - "Triangle fills single triangles, Polygon whole quads and n-gons, Mesh the connected geometry, UV island the UV islands", - "Triangle remplit des triangles seuls, Polygone des quads et n-gones entiers, Maillage la géométrie connectée, Îlot UV les îlots UV", - ), - ("Visible polygons only", "Polygones visibles uniquement"), - ( - "\"{layer}\" can't be filled: select a paint layer or a layer's mask", - "« {layer} » ne peut pas être rempli : sélectionnez un calque de peinture ou un masque de calque", - ), - ("The file dialog couldn't be shown: {error}", "Impossible d'afficher la boîte de dialogue de fichiers : {error}"), - ( - "The project changed while the dialog was open, so nothing was done", - "Le projet a changé pendant que la boîte de dialogue était ouverte ; rien n'a été fait", - ), - ("Cores kept for the UI", "Cœurs réservés à l'interface"), - ("Max RAM while saving", "RAM max. à l'enregistrement"), - ( - "Saving uses the other cores and at most this share of the free RAM. At least one core always works.", - "L'enregistrement utilise les autres cœurs et au plus cette part de la RAM libre. Au moins un cœur travaille toujours.", - ), - ("Max project size on open", "Taille max. à l’ouverture"), - ( - "Maximum decompressed project data. Increase this limit to open larger projects.", - "Volume maximal des données décompressées du projet. Augmentez cette limite pour ouvrir des projets plus volumineux.", - ), -]; diff --git a/crates/ui-egui/src/i18n/it.rs b/crates/ui-egui/src/i18n/it.rs deleted file mode 100644 index e067cf67..00000000 --- a/crates/ui-egui/src/i18n/it.rs +++ /dev/null @@ -1,1178 +0,0 @@ -//! Italian UI text: (English key, translation). Keys are the English strings passed to `tr`. - -pub const TABLE: &[(&str, &str)] = &[ - ("Baking {map} ({n}/{total})", "Bake di {map} in corso ({n}/{total})"), - ("Baking {map} ({n}/{total}), texture set {set} of {sets}", "Bake di {map} in corso ({n}/{total}), set di texture {set} di {sets}"), - ("Follow Newest Map", "Segui la mappa più recente"), - ( - "Painting is paused while a bake is shown. Cancel the bake or wait for it to finish.", - "La pittura è in pausa finché viene mostrato un bake. Annulla il bake o attendi che finisca.", - ), - ( - "What the 3D view shows while the bake runs: the newest finished map, one finished map, or the material. Maps not baked yet show a neutral value.", - "Cosa mostra la vista 3D durante il bake: l'ultima mappa completata, una mappa completata a scelta o il materiale. Le mappe non ancora create mostrano un valore neutro.", - ), - ("\"{layer}\" has no paint yet: the filter changes what you paint on it.", "\"{layer}\" non è ancora dipinto: il filtro modifica ciò che vi dipingi."), - ("0 turns autosave off. Copies go to {folder}", "0 disattiva il salvataggio automatico. Le copie vengono salvate in {folder}"), - ("2D view only", "Solo vista 2D"), - ("32 bits (float)", "32 bit (float)"), - ("3D mesh", "Mesh 3D"), - ("3D meshes", "Mesh 3D"), - ( - "3D texture painting: layers, masks, smart materials, mesh map baking and export.", - "Pittura di texture 3D: livelli, maschere, materiali intelligenti, bake delle mappe mesh ed esportazione.", - ), - ("3D view only", "Solo vista 3D"), - ("3D/2D views", "Viste 3D/2D"), - ( - "A folder blends its children (pass-through). Set per-channel opacity in the layer rows.", - "Una cartella fonde i livelli che contiene (pass-through). Imposta l'opacità per canale nelle righe dei livelli.", - ), - ("ACES filmic", "ACES filmico"), - ("Ambient", "Ambiente"), - ("AO intensity", "Intensità AO"), - ("About TextureCraft", "Informazioni su TextureCraft"), - ("About TextureCraft...", "Informazioni su TextureCraft..."), - ( - "Add an anchor point to a layer below to use its stack as a mask.", - "Aggiungi un punto di ancoraggio a un livello sottostante per usarne la pila come maschera.", - ), - ("Add anchor point", "Aggiungi punto di ancoraggio"), - ("Add as decal (view center)", "Aggiungi come decal (centro della vista)"), - ("Add black mask", "Aggiungi maschera nera"), - ("Add channel", "Aggiungi canale"), - ("Add color", "Aggiungi colore"), - ("Add compare mask", "Aggiungi maschera di confronto"), - ("Add effect", "Aggiungi effetto"), - ("Add fill", "Aggiungi riempimento"), - ("Add fill layer", "Aggiungi livello di riempimento"), - ("Add filter", "Aggiungi filtro"), - ("Add folder", "Aggiungi cartella"), - ("Add generator", "Aggiungi generatore"), - ("Add levels", "Aggiungi Livelli"), - ("Add mask", "Aggiungi maschera"), - ("Add mask with color selection", "Aggiungi maschera con selezione colore"), - ("Add output", "Aggiungi output"), - ("Add paint", "Aggiungi pittura"), - ("Add paint layer", "Aggiungi livello di pittura"), - ("Add smart material from the shelf", "Aggiungi un materiale intelligente dalla libreria"), - ("Add to the layer content", "Aggiungi al contenuto del livello"), - ("Add to the mask", "Aggiungi alla maschera"), - ("Add white mask", "Aggiungi maschera bianca"), - ("Adjustments", "Regolazioni"), - ( - "Aligned: the offset set by the first stroke is kept. V + click sets a new source.", - "Allineato: viene mantenuto l'offset impostato dal primo tratto. V + clic imposta una nuova sorgente.", - ), - ("Alignment", "Allineamento"), - ("Alignment and culling", "Allineamento e culling"), - ("All layers", "Tutti i livelli"), - ("Alpha", "Alpha"), - ("Alphas", "Alpha"), - ("Also bound to {item} ({menu})", "Assegnata anche a {item} ({menu})"), - ("Alt + LMB drag", "Alt + trascina (tasto sinistro)"), - ("Always", "Sempre"), - ("Ambient Occlusion", "Occlusione ambientale"), - ("Ambient occlusion", "Occlusione ambientale"), - ("Amount", "Quantità"), - ("Anchor point", "Punto di ancoraggio"), - ("Anchor: {name}", "Ancoraggio: {name}"), - ("Anchor: {name} ({channel})", "Ancoraggio: {name} ({channel})"), - ("Angle", "Angolo"), - ("Angle (degrees)", "Angolo (gradi)"), - ("Angle fade from", "Dissolvenza angolo da"), - ("Angle fade to", "Dissolvenza angolo a"), - ("Angle jitter", "Variazione angolo"), - ("Anisotropy angle", "Angolo anisotropia"), - ("Anisotropy level", "Livello anisotropia"), - ("Antialiasing", "Antialiasing"), - ("Aperture", "Apertura"), - ("Apply", "Applica"), - ("ArtCraft website...", "Sito web di ArtCraft..."), - ("Assets", "Risorse"), - ("Auto", "Auto"), - ("Automatic (from the mesh UVs)", "Automatico (dagli UV della mesh)"), - ("Autosave every", "Salvataggio automatico ogni"), - ( - "Autosaves, smart materials, presets, templates and UI layouts go to the data folder. A new folder applies on restart; files already saved stay where they are.", - "Salvataggi automatici, materiali smart, preset, modelli e layout dell'interfaccia vanno nella cartella dei dati. Una nuova cartella si applica al riavvio; i file già salvati restano dove sono.", - ), - ("Axis", "Asse"), - ("Back to painting", "Torna alla pittura"), - ("Backface culling", "Culling facce posteriori"), - ("Bake an ID map (F8) to pick colors from the mesh.", "Esegui il bake di una mappa ID (F8) per prelevare i colori dalla mesh."), - ("Bake Mesh Maps", "Bake mappe mesh"), - ("Bake mesh maps", "Bake mappe mesh"), - ( - "Bake mesh maps (F8) for curvature, AO and thickness based generators.", - "Esegui il bake delle mappe mesh (F8) per i generatori basati su curvatura, AO e spessore.", - ), - ("Baked Lighting", "Illuminazione precalcolata"), - ("Baking", "Baking"), - ("Base color", "Colore base"), - ( - "Base color is the diffuse color, Specular the F0 color and Glossiness 1 - roughness (add these channels in the texture set settings).", - "Colore base è il colore diffuso, Speculare il colore F0 e Lucentezza 1 - rugosità (aggiungi questi canali nelle impostazioni del set di texture).", - ), - ("Base color, Metallic, Roughness and Specular level.", "Colore base, Metallico, Rugosità e Livello speculare."), - ("Based on each texture set's size", "In base alla dimensione di ciascun set di texture"), - ("Basic settings", "Impostazioni di base"), - ("Bent Normals", "Bent normal"), - ("Bevel", "Smusso"), - ("Black", "Nero"), - ("Blending", "Fusione"), - ("Blending mode of the displayed channel", "Metodo di fusione del canale visualizzato"), - ("Blur", "Sfocatura"), - ("Blur Directional", "Sfocatura direzionale"), - ("Blur and sharpen", "Sfocatura e nitidezza"), - ("Bounces", "Rimbalzi"), - ("Bricks", "Mattoni"), - ("Brush", "Pennello"), - ("Brush size", "Dimensione pennello"), - ("Brush size down / up", "Riduci / aumenta dimensione pennello"), - ("Brushed lines", "Linee spazzolate"), - ("Built-in (read-only): duplicate it to edit", "Integrato (sola lettura): duplicalo per modificarlo"), - ("Built-in templates are read-only: duplicate one to edit it", "I modelli integrati sono di sola lettura: duplicane uno per modificarlo"), - ("Built-in: {mesh}", "Integrata: {mesh}"), - ("Cage: {name}", "Gabbia: {name}"), - ("Camera", "Camera"), - ("Colors", "Colori"), - ("Go to camera 1", "Vai alla camera 1"), - ("Go to camera 2", "Vai alla camera 2"), - ("Go to camera 3", "Vai alla camera 3"), - ("Go to camera 4", "Vai alla camera 4"), - ("Go to camera 5", "Vai alla camera 5"), - ("Go to camera 6", "Vai alla camera 6"), - ("Go to camera 7", "Vai alla camera 7"), - ("Go to camera 8", "Vai alla camera 8"), - ("Go to camera 9", "Vai alla camera 9"), - ("Camera settings", "Impostazioni camera"), - ("Cancel", "Annulla"), - ("Cancel the stroke", "Annulla il tratto"), - ("Cell size (texels at 2K)", "Dimensione celle (texel a 2K)"), - ("Cells", "Celle"), - ("Channel", "Canale"), - ("Channel source: uniform value, procedural, image or anchor", "Sorgente del canale: valore uniforme, procedurale, immagine o ancoraggio"), - ("Channels", "Canali"), - ("Check for Updates...", "Controlla aggiornamenti..."), - ("Checker", "Scacchiera"), - ("Clamp", "Limita"), - ("Clear", "Cancella"), - ("Clear mask", "Cancella maschera"), - ("Clear recent projects", "Cancella progetti recenti"), - ( - "Click a mesh part to show or hide the selected layer on it.", - "Fai clic su una parte della mesh per mostrare o nascondere il livello selezionato su di essa.", - ), - ("Click the mesh to pick its material into the brush", "Fai clic sulla mesh per prelevarne il materiale nel pennello"), - ("Click the mesh to place the decal", "Fai clic sulla mesh per posizionare la decal"), - ("Click, then press the new shortcut (Esc cancels)", "Fai clic, poi premi la nuova scorciatoia (Esc per annullare)"), - ("Clone", "Clona"), - ("Close", "Chiudi"), - ("Closed path", "Tracciato chiuso"), - ("Cloud", "Nuvola"), - ("Clouds", "Nuvole"), - ("Coat normal", "Normale rivestimento"), - ("Coat roughness", "Rugosità rivestimento"), - ("Coat weight", "Peso rivestimento"), - ("Color", "Colore"), - ("Color Balance", "Bilanciamento colore"), - ("Color burn", "Brucia colore"), - ("Color dodge", "Scherma colore"), - ( - "Color of the light that travels under the surface (each channel goes as far as its value)", - "Colore della luce che viaggia sotto la superficie (ogni canale arriva fino al proprio valore)", - ), - ("Color picker", "Contagocce"), - ("Color selection", "Selezione colore"), - ("Color to replace", "Colore da sostituire"), - ( - "Colors near the first shift towards the second, keeping their shading.", - "I colori vicini al primo si spostano verso il secondo, mantenendo l'ombreggiatura.", - ), - ( - "Colors read as gray. Add a levels or blur effect above to shape the result.", - "I colori vengono letti come grigio. Aggiungi sopra un effetto Livelli o Sfocatura per modellare il risultato.", - ), - ("Combine with the layer's height", "Combina con l'altezza del livello"), - ("Compare mask", "Maschera di confronto"), - ("Compositing", "Compositing"), - ("Constant", "Costante"), - ("Constants", "Costanti"), - ("Contrast", "Contrasto"), - ("Contrast/Luminosity", "Contrasto/Luminosità"), - ("Converted maps", "Mappe convertite"), - ("Copy RGB values", "Copia i valori RGB"), - ("Copy effect", "Copia effetto"), - ("Copy from", "Copia da"), - ("Copy layer(s)", "Copia livello/i"), - ("Copy the selected layer alone (its empty parts copy nothing)", "Copia solo il livello selezionato (le sue parti vuote non copiano nulla)"), - ("Copy to all texture sets", "Copia in tutti i set di texture"), - ("Copy what the texture set shows", "Copia ciò che mostra il set di texture"), - ("Couldn't encode the render", "Impossibile codificare il render"), - ("Couldn't export textures: {error}", "Impossibile esportare le texture: {error}"), - ("Couldn't export the mesh: {error}", "Impossibile esportare la mesh: {error}"), - ("Couldn't export the template: {error}", "Impossibile esportare il modello: {error}"), - ("Couldn't import {name}: {error}", "Impossibile importare {name}: {error}"), - ("Couldn't open {name}: {error}", "Impossibile aprire {name}: {error}"), - ("Couldn't read the render back from the GPU", "Impossibile rileggere il render dalla GPU"), - ("Couldn't save the render: {error}", "Impossibile salvare il render: {error}"), - ("Couldn't save {name}: {error}", "Impossibile salvare {name}: {error}"), - ("Count per stamp", "Quantità per impronta"), - ("Crate", "Cassa"), - ("Create", "Crea"), - ("Create smart material", "Crea materiale intelligente"), - ( - "Ctrl+right-drag in a view sets the size and hardness, Ctrl+left-drag the flow and angle.", - "Ctrl+trascina con il tasto destro in una vista per regolare dimensione e durezza, con il sinistro flusso e angolo.", - ), - ("Cube", "Cubo"), - ("Current layer", "Livello corrente"), - ("Curvature", "Curvatura"), - ("Cut effect", "Taglia effetto"), - ("Cut layer(s)", "Taglia livello/i"), - ("Cyan / red", "Ciano / rosso"), - ("Cylinder", "Cilindro"), - ("Cylindrical projection", "Proiezione cilindrica"), - ( - "Dark to light: the content's luminance picks a color along these stops.", - "Da scuro a chiaro: la luminanza del contenuto sceglie un colore lungo questi punti di colore.", - ), - ("Darken (Min)", "Scurisci (Min)"), - ("Data folder", "Cartella dei dati"), - ("Decal", "Decal"), - ("Decal projection", "Proiezione decal"), - ("Default", "Predefinito"), - ("Default camera", "Camera predefinita"), - ("Delete the selected template", "Elimina il modello selezionato"), - ("Delete this camera", "Elimina questa camera"), - ("Deleted template \"{name}\"", "Modello \"{name}\" eliminato"), - ("Denoise", "Riduzione rumore"), - ("Depth", "Profondità"), - ("Depth of field", "Profondità di campo"), - ("Depth of field (viewport and Rendering mode)", "Profondità di campo (viewport e modalità Rendering)"), - ("Depth of the sharp plane along the view (0: the orbit center)", "Profondità del piano a fuoco lungo la vista (0: il centro di orbita)"), - ("Details saved to {file}", "Dettagli salvati in {file}"), - ("Difference", "Differenza"), - ("Dilation + default background color", "Dilatazione + colore di sfondo predefinito"), - ("Dilation + transparent", "Dilatazione + trasparente"), - ("Dilation infinite", "Dilatazione infinita"), - ("DirectX normal map", "Mappa normali DirectX"), - ("Dirt", "Sporco"), - ("Disable", "Disattiva"), - ("Dismiss", "Chiudi"), - ("Displacement (height channel)", "Displacement (canale altezza)"), - ("Display Settings", "Impostazioni di visualizzazione"), - ("Display material", "Mostra materiale"), - ("Display next channel", "Mostra canale successivo"), - ("Display next mesh map", "Mostra mappa mesh successiva"), - ("Display previous channel", "Mostra canale precedente"), - ("Display previous mesh map", "Mostra mappa mesh precedente"), - ("Distance", "Distanza"), - ("Distort", "Distorsione"), - ("Divide", "Dividi"), - ("Document resolution", "Risoluzione documento"), - ("Documentation...", "Documentazione..."), - ("Done on CPU: {n} / {max} samples, {s} s", "Completato su CPU: {n} / {max} campioni, {s} s"), - ("Done on GPU: {n} / {max} samples, {s} s", "Completato su GPU: {n} / {max} campioni, {s} s"), - ("Double-click to rename", "Doppio clic per rinominare"), - ("Download as", "Scarica come"), - ("Downloaded {name}", "{name} scaricato"), - ("Drag onto an output channel", "Trascina su un canale di output"), - ( - "Drags the layer stack's values along the stroke into the selected layer.", - "Trascina i valori della pila dei livelli lungo il tratto nel livello selezionato.", - ), - ( - "Draws {name} of texture set \"{set}\". Edits to the source show in every instance.", - "Disegna {name} del set di texture \"{set}\". Le modifiche alla sorgente appaiono in ogni istanza.", - ), - ( - "Drag the frame to move the decal, a corner to scale it, the round handle to turn it", - "Trascina il riquadro per spostare la decal, un angolo per scalarla, la maniglia rotonda per ruotarla", - ), - ("Drop an image from the Assets panel here to use it as this mesh map", "Rilascia qui un'immagine dal pannello Risorse per usarla come questa mappa mesh"), - ("Dry streaks", "Striature secche"), - ("Duplicate effect", "Duplica effetto"), - ("Duplicate layer(s)", "Duplica livello/i"), - ("Duplicate the selected template", "Duplica il modello selezionato"), - ("Edge Detect", "Rilevamento bordi"), - ("Edit", "Modifica"), - ("Edit keyboard shortcuts...", "Modifica scorciatoie da tastiera..."), - ("Edit quick mask", "Modifica maschera rapida"), - ("Editing quick mask: paint where painting is allowed (U to finish)", "Modifica maschera rapida: dipingi dove è consentito dipingere (U per terminare)"), - ( - "Editing the quick mask: strokes paint where painting is allowed. Press U to finish.", - "Modifica della maschera rapida: i tratti dipingono le aree in cui è consentito dipingere. Premi U per terminare.", - ), - ("Emissive", "Emissivo"), - ("Enable or disable the effect", "Attiva o disattiva l'effetto"), - ("Enable quick mask", "Attiva maschera rapida"), - ("Environment blur", "Sfocatura ambiente"), - ("Environment exposure (EV)", "Esposizione ambiente (EV)"), - ("Environment map", "Mappa ambiente"), - ("Environment opacity", "Opacità ambiente"), - ("Environment rotation", "Rotazione ambiente"), - ("Environment settings", "Impostazioni ambiente"), - ("Environment: {name}", "Ambiente: {name}"), - ("Environments", "Ambienti"), - ("Eraser", "Gomma"), - ("Exclusion", "Esclusione"), - ("Expand or collapse the folder", "Espandi o comprimi la cartella"), - ("Export", "Esporta"), - ("Export Mesh...", "Esporta mesh..."), - ("Export Textures...", "Esporta texture..."), - ("Export mesh", "Esporta mesh"), - ("Export template", "Modello di esportazione"), - ("Export templates", "Modelli di esportazione"), - ("Export textures", "Esporta texture"), - ("Export the selected template (.json)", "Esporta il modello selezionato (.json)"), - ("Exported mesh to {path}", "Mesh esportata in {path}"), - ("Exported template \"{name}\" to {path}", "Modello \"{name}\" esportato in {path}"), - ("Exported {n} textures to {folder}", "{n} texture esportate in {folder}"), - ("F0 from specular level", "F0 da livello speculare"), - ("Fabric weave", "Trama tessuto"), - ("Field of view (deg)", "Campo visivo (gradi)"), - ("File", "File"), - ("File name without extension; variables insert names", "Nome file senza estensione; le variabili inseriscono i nomi"), - ("File type", "Tipo di file"), - ("Fill", "Riempimento"), - ("Fill the closed path (lasso)", "Riempi il tracciato chiuso (lazo)"), - ("Fill the path (close it first)", "Riempi il tracciato (prima chiudilo)"), - ("Filter", "Filtro"), - ("Filter the remaining noise while keeping edges and texture detail", "Filtra il rumore residuo preservando i bordi e i dettagli della texture"), - ("Filters", "Filtri"), - ("Fine noise", "Rumore fine"), - ("Fingerprints", "Impronte digitali"), - ("Enter a finite number", "Inserisci un numero finito"), - ("Double-click or press Enter to edit", "Fai doppio clic o premi Invio per modificare"), - ("Fit the input range to the histogram", "Adatta l'intervallo di input all'istogramma"), - ("Flatten layer", "Appiattisci livello"), - ( - "Flips the image's green channel, for normal maps made with Y pointing down", - "Inverte il canale verde dell'immagine, per mappe normali create con Y rivolto verso il basso", - ), - ("Flow", "Flusso"), - ("Flow and opacity", "Flusso e opacità"), - ("Flow jitter", "Variazione flusso"), - ("Focus distance", "Distanza di messa a fuoco"), - ("Folder", "Cartella"), - ("Folders", "Cartelle"), - ("Follow path", "Segui tracciato"), - ( - "For the whole project: how normal map images set as mesh maps are read (set them again after a change), and the default for export", - "Per l'intero progetto: come vengono lette le immagini di mappe normali usate come mappe mesh (riassegnale dopo una modifica) e il valore predefinito per l'esportazione", - ), - ("Free and open source (MIT OR Apache-2.0), written in Rust.", "Libero e open source (MIT OR Apache-2.0), scritto in Rust."), - ("From template", "Da modello"), - ("From template / project", "Da modello / progetto"), - ("Full", "Piena"), - ("GPU error: {error}", "Errore GPU: {error}"), - ("Geometry mask", "Maschera geometria"), - ( - "GGX specular with height-correlated Smith visibility, Lambert diffuse, split-sum image-based lighting with spherical-harmonics irradiance and horizon fading.", - "Speculare GGX con visibilità Smith correlata all'altezza, diffusa Lambert, illuminazione basata su immagine split-sum con irradianza in armoniche sferiche e attenuazione all'orizzonte.", - ), - ("Gamma", "Gamma"), - ("General export parameters", "Parametri generali di esportazione"), - ("General properties", "Proprietà generali"), - ("Generator", "Generatore"), - ("Geometry and UVs only", "Solo geometria e UV"), - ("Glossiness", "Lucentezza"), - ("Glossiness from roughness", "Lucentezza da rugosità"), - ("Glow", "Bagliore"), - ("Gradient", "Sfumatura"), - ("Gradient Map", "Mappa sfumatura"), - ("Gravity", "Gravità"), - ("Gray", "Grigio"), - ("Gray + A", "Grigio + A"), - ("Gray 50%", "Grigio 50%"), - ("Grayscale", "Scala di grigi"), - ("Group layer(s)", "Raggruppa livello/i"), - ("Grunge", "Grunge"), - ("HDR environments", "Ambienti HDR"), - ("High Pass", "Passa-alto"), - ("HSL Perceptive", "HSL percettivo"), - ("Half", "Metà"), - ("Hammered", "Martellato"), - ("Hard light", "Luce intensa"), - ("Hardness", "Durezza"), - ("Height", "Altezza"), - ("Height offset", "Offset altezza"), - ("Height to normal strength", "Intensità altezza in normale"), - ("Help", "Aiuto"), - ("Hide UI", "Nascondi interfaccia"), - ("High", "Alto"), - ("High poly: {name}", "High poly: {name}"), - ("Highlights", "Luci"), - ("Histogram Range", "Intervallo istogramma"), - ("Histogram Scan", "Scansione istogramma"), - ("Histogram Shift", "Spostamento istogramma"), - ("History", "Cronologia"), - ( - "Hold S: left-drag rotates, right-drag scales, middle-drag moves the stencil.", - "Tieni premuto S: trascina con il tasto sinistro per ruotare, con il destro per scalare e con il centrale per spostare lo stencil.", - ), - ("Hold V and click the mesh to set the clone source", "Tieni premuto V e fai clic sulla mesh per impostare la sorgente di clonazione"), - ( - "Hold V and click the mesh to set the source, then paint elsewhere to copy it.", - "Tieni premuto V e fai clic sulla mesh per impostare la sorgente, poi dipingi altrove per copiarla.", - ), - ( - "How far light travels under the surface, as a fraction of the mesh size (where the Scattering weight channel is painted)", - "Distanza percorsa dalla luce sotto la superficie, come frazione della dimensione della mesh (dove è dipinto il canale Peso scattering)", - ), - ( - "How strongly transmissive surfaces bend light (where the Transmission channel is painted): water 1.33, glass 1.5, diamond 2.42", - "Quanto le superfici trasmissive deviano la luce (dove è dipinto il canale Trasmissione): acqua 1,33, vetro 1,5, diamante 2,42", - ), - ("Hue shift (degrees)", "Spostamento tonalità (gradi)"), - ("ID", "ID"), - ("Image: {name}", "Immagine: {name}"), - ("Images", "Immagini"), - ("Import HDR...", "Importa HDR..."), - ("Import a template (.json)", "Importa un modello (.json)"), - ("Import an image (File > Import resources) to project it onto the mesh.", "Importa un'immagine (File > Importa risorse) per proiettarla sulla mesh."), - ("Import images to use them in fills and masks", "Importa immagini per usarle in riempimenti e maschere"), - ("Import resources...", "Importa risorse..."), - ("Import MaterialX material...", "Importa materiale MaterialX..."), - ("MaterialX materials", "Materiali MaterialX"), - ("Import...", "Importa..."), - ("Imported template \"{name}\"", "Modello \"{name}\" importato"), - ("Imported {name}", "{name} importato"), - ("Index of refraction", "Indice di rifrazione"), - ("Input high", "Input alto"), - ("Input low", "Input basso"), - ("Input maps", "Mappe di input"), - ("Insert a variable", "Inserisci una variabile"), - ("Instance", "Istanza"), - ("Instantiate across texture sets", "Crea istanze nei set di texture"), - ("Intensity (texels at 2K)", "Intensità (texel a 2K)"), - ("Interface", "Interfaccia"), - ("Interface scale", "Scala interfaccia"), - ("Inverse Subtract", "Sottrai inverso"), - ("Inverse divide", "Dividi inverso"), - ("Invert", "Inverti"), - ("Invert mask", "Inverti maschera"), - ("Invert mask background", "Inverti sfondo maschera"), - ("Invert mask value", "Inverti valore maschera"), - ("Invert quick mask", "Inverti maschera rapida"), - ("Jitters", "Variazioni"), - ("Join the ArtCraft community on Discord", "Unisciti alla community di ArtCraft su Discord"), - ("Join the community (Discord)...", "Unisciti alla community (Discord)..."), - ("Key light (shadow-casting light, direct only)", "Luce principale (proietta ombre, solo diretta)"), - ("Keyboard", "Tastiera"), - ("Keyboard shortcuts", "Scorciatoie da tastiera"), - ("Light azimuth (degrees)", "Azimut della luce (gradi)"), - ("Light elevation (degrees)", "Elevazione della luce (gradi)"), - ("Light intensity", "Intensità della luce"), - ("LMB", "Tasto sinistro"), - ("Language", "Lingua"), - ("Layer mask", "Maschera di livello"), - ("Layer memory: {mb} MB", "Memoria livelli: {mb} MB"), - ("Layers", "Livelli"), - ("Lazy mouse", "Lazy mouse"), - ("Lazy mouse distance", "Distanza lazy mouse"), - ("Leather grain", "Grana pelle"), - ( - "Lens size: how quickly things blur away from the focus distance", - "Dimensione dell'obiettivo: rapidità con cui gli oggetti si sfocano allontanandosi dalla distanza di messa a fuoco", - ), - ("Level", "Livello"), - ("Levels", "Livelli"), - ("Lifetime (steps)", "Durata (passi)"), - ("Light / direction", "Luce / direzione"), - ("Lighten (Max)", "Schiarisci (Max)"), - ("Lightness", "Luminosità"), - ("Linear", "Lineare"), - ("Linear burn", "Brucia lineare"), - ("Linear dodge (Add)", "Scherma lineare (Aggiungi)"), - ("Linear light", "Luce lineare"), - ("List of exports", "Elenco esportazioni"), - ("Load UI Layout", "Carica layout interfaccia"), - ("Loaded UI layout {path}", "Layout interfaccia caricato: {path}"), - ("Log", "Log"), - ("Low", "Basso"), - ("Luminosity", "Luminosità"), - ("MMB drag / Alt + MMB", "Trascina (tasto centrale) / Alt + tasto centrale"), - ("Made by the ArtCraft team and community.", "Realizzato dal team e dalla community di ArtCraft."), - ("Magenta / green", "Magenta / verde"), - ("Main shader", "Shader principale"), - ("Marble veins", "Venature marmo"), - ("Mask", "Maschera"), - ("Mask Editor: Edge wear", "Editor maschera: Usura bordi"), - ("Mask value (gray)", "Valore maschera (grigio)"), - ("Mask with height", "Maschera con altezza"), - ("MatFinish Grind", "MatFinish Molato"), - ("MatFinish Hammered", "MatFinish Martellato"), - ("MatFinish Raw", "MatFinish Grezzo"), - ("MatFinish Sanded", "MatFinish Carteggiato"), - ("Material", "Materiale"), - ("Material ball", "Sfera materiale"), - ("Material finish", "Finitura materiale"), - ("Materials", "Materiali"), - ("Maximum", "Massimo"), - ("Mesh fill", "Riempimento mesh"), - ("Mesh map: {map}", "Mappa mesh: {map}"), - ("Mesh maps", "Mappe mesh"), - ("Mesh maps baked", "Bake delle mappe mesh completato"), - ("Meshes", "Mesh"), - ("Metallic", "Metallico"), - ("Midtones", "Mezzitoni"), - ("Minimum", "Minimo"), - ("Minimum size (%)", "Dimensione minima (%)"), - ("Missing (bake to create)", "Mancante (esegui il bake per crearla)"), - ("Mixed AO", "AO miscelata"), - ("Mode", "Modalità"), - ("More in Assets > Alphas: click one, or drag it here", "Altri in Risorse > Alpha: fai clic su uno o trascinalo qui"), - ("Mosaic", "Mosaico"), - ("Move down", "Sposta giù"), - ("Move up", "Sposta su"), - ( - "Moves the surface by the height channel on a finer copy of the mesh, at the height to normal strength (viewport only: painting follows the base surface)", - "Sposta la superficie in base al canale altezza su una copia più fine della mesh, con l'intensità da altezza a normale (solo nel viewport: la pittura segue la superficie di base)", - ), - ("Multiply", "Moltiplica"), - ("My smart materials", "I miei materiali intelligenti"), - ("Name", "Nome"), - ("New project", "Nuovo progetto"), - ("New project...", "Nuovo progetto..."), - ("New template", "Nuovo modello"), - ("No GPU renderer available", "Nessun renderer GPU disponibile"), - ("No font on this system can show this language", "Nessun font di questo sistema può visualizzare questa lingua"), - ( - "No outputs yet: add one above, then drag input maps onto its channels.", - "Ancora nessun output: aggiungine uno sopra, poi trascina le mappe di input sui suoi canali.", - ), - ("No padding (passthrough)", "Nessun padding (passthrough)"), - ("Noise amount", "Quantità rumore"), - ("Noise scale", "Scala rumore"), - ("None", "Nessuno"), - ("Normal", "Normale"), - ("Normal DirectX", "Normale DirectX"), - ("Normal Invert", "Inverti normale"), - ("Normal OpenGL", "Normale OpenGL"), - ("Normal from height", "Normale da altezza"), - ("Normal map combine", "Combina mappa normali"), - ("Normal map detail", "Dettaglio mappa normali"), - ("Color space", "Spazio colore"), - ("Normal map format", "Formato mappa normali"), - ("Normal map inverse detail", "Dettaglio inverso mappa normali"), - ("Normal: painting uses the flat normal", "Normale: la pittura usa la normale piatta"), - ( - "Not enough GPU memory to show texture set \"{name}\" fully: lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "Memoria GPU insufficiente per mostrare per intero il set di texture \"{name}\": riduci nelle Impostazioni la risoluzione texture della viewport. Pittura ed esportazione non sono interessate.", - ), - ( - "Not enough GPU memory to show {count} texture sets fully ({names}): lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "Memoria GPU insufficiente per mostrare per intero {count} set di texture ({names}): riduci nelle Impostazioni la risoluzione texture della viewport. Pittura ed esportazione non sono interessate.", - ), - ("Not exported: no source in this texture set", "Non esportato: nessuna sorgente in questo set di texture"), - ("Not saved: {error}", "Non salvato: {error}"), - ("Off", "Disattivato"), - ("Offset", "Scostamento"), - ("Offset right", "Offset a destra"), - ("Offset up", "Offset in alto"), - ("Offset {axis}", "Scostamento {axis}"), - ( - "Offsets the textures by the height channel, at the height to normal strength", - "Sposta le texture in base al canale altezza, con l'intensità altezza in normale", - ), - ("On", "Attivato"), - ("Opacity", "Opacità"), - ("Open sample project...", "Apri progetto di esempio..."), - ("Open...", "Apri..."), - ("Opened {name}", "{name} aperto"), - ( - "Optional channels add a clear coat (Coat weight, Coat roughness, Coat normal), sheen (Sheen weight, color, roughness), anisotropy (Anisotropy level, angle), subsurface scattering (Scattering weight) and transmission (Transmission).", - "I canali opzionali aggiungono un rivestimento trasparente (Peso rivestimento, Rugosità rivestimento, Normale rivestimento), sheen (Peso sheen, colore, rugosità), anisotropia (Livello anisotropia, angolo), subsurface scattering (Peso scattering) e trasmissione (Trasmissione).", - ), - ("Orbit", "Orbita"), - ("Orthographic", "Ortografica"), - ("Perspective", "Prospettica"), - ("Output directory", "Cartella di output"), - ("Output high", "Output alto"), - ("Output low", "Output basso"), - ("Output template", "Modello di output"), - ("Output templates", "Modelli di output"), - ("Overlay", "Sovrapponi"), - ("Overlay opacity", "Opacità sovrapposizione"), - ("PBR - Metallic Roughness (TextureCraft)", "PBR - Metallico Rugosità (TextureCraft)"), - ("Pick color", "Preleva colore"), - ("PNG image", "Immagine PNG"), - ("Padding", "Padding"), - ("Paint", "Pittura"), - ("Paint chips", "Scaglie di vernice"), - ("Paint on the mesh to edit the layer content.", "Dipingi sulla mesh per modificare il contenuto del livello."), - ( - "Paint on the mesh to edit this mask. Use the Material tab's mask value for gray.", - "Dipingi sulla mesh per modificare questa maschera. Usa il valore maschera della scheda Materiale per il grigio.", - ), - ("Paint with the current tool", "Dipingi con lo strumento corrente"), - ( - "Painted layer pixels {pixels} MB, composited channels {composites} MB, compositing cache {cache} MB", - "Pixel dei livelli dipinti {pixels} MB, canali composti {composites} MB, cache di composizione {cache} MB", - ), - ("Painting", "Pittura"), - ("Pan", "Panoramica"), - ("Parallax occlusion (height channel)", "Occlusione parallasse (canale altezza)"), - ( - "Partial mask values follow the layer's height: high parts show first", - "I valori parziali della maschera seguono l'altezza del livello: le parti alte appaiono per prime", - ), - ("Particle brush (slides down the surface)", "Pennello particellare (scivola giù lungo la superficie)"), - ("Particle brush: particles slide down the surface", "Pennello particellare: le particelle scivolano giù lungo la superficie"), - ("Particles", "Particelle"), - ("Passthrough", "Pass-through"), - ("Paste as instance", "Incolla come istanza"), - ("Paste effect", "Incolla effetto"), - ("Paste layer(s)", "Incolla livello/i"), - ("Path", "Tracciato"), - ("Path trace on the processor instead of the graphics card (slower)", "Esegui il path tracing sul processore anziché sulla scheda grafica (più lento)"), - ( - "Path: click adds a point, click the curve inserts one, drag moves it, Enter applies, Esc cancels", - "Tracciato: clic aggiunge un punto, clic sulla curva ne inserisce uno, trascina lo sposta, Invio applica, Esc annulla", - ), - ("Pattern scale", "Scala motivo"), - ("Perlin noise", "Rumore Perlin"), - ("Pick focus in the viewport", "Seleziona il fuoco nella viewport"), - ("Pin light", "Luce puntiforme"), - ("Place on the surface", "Posiziona sulla superficie"), - ("Place path points on the mesh", "Posiziona i punti del tracciato sulla mesh"), - ("Planar projection", "Proiezione planare"), - ("Plane", "Piano"), - ("Polygon fill", "Riempimento poligono"), - ("Pores", "Pori"), - ("Position", "Posizione"), - ("Position gradient", "Sfumatura posizione"), - ("Position jitter", "Variazione posizione"), - ("Posterize", "Posterizza"), - ("Press a key...", "Premi un tasto..."), - ("Procedurals", "Procedurali"), - ("Project", "Progetto"), - ("Project Configuration...", "Configurazione progetto..."), - ("Project opened", "Progetto aperto"), - ("Project template", "Modello di progetto"), - ("Projection", "Proiezione"), - ("Projects and meshes", "Progetti e mesh"), - ("Properties", "Proprietà"), - ("Quarter", "Un quarto"), - ("Quick mask", "Maschera rapida"), - ("Quit", "Esci"), - ("Radius (texels at 2K)", "Raggio (texel a 2K)"), - ("RENDERING", "RENDERING"), - ("Range", "Intervallo"), - ("Rebind any menu item, tool or command", "Riassegna qualsiasi voce di menu, strumento o comando"), - ("Recent projects", "Progetti recenti"), - ( - "Records the stack up to this layer. Fill effects in masks (and fill layers) above can read it as a source.", - "Registra la pila fino a questo livello. Gli effetti di riempimento nelle maschere (e i livelli di riempimento) soprastanti possono leggerla come sorgente.", - ), - ("Redo", "Ripeti"), - ("Reimport mesh", "Reimporta mesh"), - ("Remove", "Rimuovi"), - ("Remove channel", "Rimuovi canale"), - ("Remove effect", "Rimuovi effetto"), - ("Remove last", "Rimuovi ultimo"), - ("Remove layer", "Rimuovi livello"), - ("Remove layer(s)", "Rimuovi livello/i"), - ("Remove mask", "Rimuovi maschera"), - ("Remove point", "Rimuovi punto"), - ("Remove resource", "Rimuovi risorsa"), - ("Remove the shortcut", "Rimuovi la scorciatoia"), - ("Remove this output", "Rimuovi questo output"), - ("Remove unused resources...", "Rimuovi risorse inutilizzate..."), - ("Rename the selected template", "Rinomina il modello selezionato"), - ("Render on the CPU", "Renderizza sulla CPU"), - ("Rendering", "Rendering"), - ("Rendering (path traced)", "Rendering (path tracing)"), - ("Rendering on CPU: {n} / {max} samples, {s} s", "Rendering su CPU: {n} / {max} campioni, {s} s"), - ("Rendering on GPU: {n} / {max} samples, {s} s", "Rendering su GPU: {n} / {max} campioni, {s} s"), - ("Rendering, path traced", "Rendering, path tracing"), - ("Replace", "Sostituisci"), - ("Replace Color", "Sostituisci colore"), - ("Replacement color", "Colore sostitutivo"), - ("Report a bug...", "Segnala un bug..."), - ("Rescan the library folder", "Ripeti la scansione della cartella della libreria"), - ("Reset", "Reimposta"), - ("Reset UI", "Ripristina interfaccia"), - ("Reset all", "Ripristina tutto"), - ("Reset to defaults", "Ripristina i valori predefiniti"), - ("Reset to {shortcut}", "Ripristina {shortcut}"), - ("Resizing", "Ridimensionamento"), - ("Restore every default shortcut", "Ripristina tutte le scorciatoie predefinite"), - ("Return to this step", "Torna a questo passaggio"), - ("Right-click a layer > Create smart material", "Clic destro su un livello > Crea materiale intelligente"), - ("Rotation", "Rotazione"), - ("Rotation (degrees)", "Rotazione (gradi)"), - ("Roughness", "Rugosità"), - ("Roughness from glossiness", "Rugosità da lucentezza"), - ("Round", "Rotondo"), - ("Rounded cube", "Cubo arrotondato"), - ("Samples", "Campioni"), - ("Saturation", "Saturazione"), - ("Save", "Salva"), - ("Save UI Layout", "Salva layout interfaccia"), - ("Save a copy...", "Salva una copia..."), - ("Save as...", "Salva con nome..."), - ("Save current layout...", "Salva layout corrente..."), - ("Save render...", "Salva render..."), - ("Save view as camera", "Salva vista come camera"), - ("Saved UI layout {path}", "Layout interfaccia salvato: {path}"), - ("Saved {path}", "Salvato: {path}"), - ("Saving UI layouts to files is available in the desktop app", "Il salvataggio dei layout dell'interfaccia su file è disponibile nell'app desktop"), - ("Scale", "Scala"), - ("Scale / tiling", "Scala / ripetizione"), - ("Scatter color", "Colore scattering"), - ("Scatter radius", "Raggio scattering"), - ("Scattering weight", "Peso scattering"), - ("Scratches", "Graffi"), - ("Screen", "Scolora"), - ("Screenshot of the viewport", "Screenshot della viewport"), - ("Search", "Cerca"), - ("Search all assets", "Cerca in tutte le risorse"), - ("Search commands or keys", "Cerca comandi o tasti"), - ("Seed", "Seme"), - ("Select a layer", "Seleziona un livello"), - ("Select an output template", "Seleziona un modello di output"), - ("Select source", "Seleziona sorgente"), - ("Select the mask (Alt+click: show it in the viewport)", "Seleziona la maschera (Alt+clic: mostrala nella viewport)"), - ("Select...", "Seleziona..."), - ("Settings", "Impostazioni"), - ("Settings...", "Impostazioni..."), - ("Shader Settings", "Impostazioni shader"), - ("Shader instance", "Istanza shader"), - ("Shadows", "Ombre"), - ("Sharpen", "Nitidezza"), - ("Sheen color", "Colore sheen"), - ("Sheen color × weight", "Colore sheen × peso"), - ("Sheen roughness", "Rugosità sheen"), - ("Sheen weight", "Peso sheen"), - ("Shift + wheel", "Maiusc + rotella"), - ("Shortcuts list...", "Elenco scorciatoie..."), - ("Show on all parts", "Mostra su tutte le parti"), - ("Show UV wireframe in the 2D view", "Mostra il wireframe UV nella vista 2D"), - ("Show entire mesh", "Mostra intera mesh"), - ("Show log...", "Mostra log..."), - ("Show or hide the layer", "Mostra o nascondi il livello"), - ("Show or hide the texture set", "Mostra o nascondi il set di texture"), - ("Show wireframe in the 3D view", "Mostra il wireframe nella vista 3D"), - ("Signed addition (AddSub)", "Addizione con segno (AddSub)"), - ("Size", "Dimensione"), - ("Size in screen space", "Dimensione nello spazio schermo"), - ("Size jitter", "Variazione dimensione"), - ( - "Size of the textures the viewport shows: lower uses less GPU memory with large texture sets. Painting and export keep full resolution.", - "Dimensione delle texture mostrate nella viewport: valori più bassi usano meno memoria GPU con set di texture grandi. Pittura ed esportazione mantengono la risoluzione piena.", - ), - ("Slope Blur", "Sfocatura pendenza"), - ("Slope scale", "Scala pendenza"), - ("Smart masks", "Maschere intelligenti"), - ("Smart material saved to {path}", "Materiale intelligente salvato in {path}"), - ("Smart materials", "Materiali intelligenti"), - ("Smudge", "Sfumino"), - ("Soft light", "Luce soffusa"), - ("Softness", "Morbidezza"), - ("Source", "Sorgente"), - ("Source U {u} V {v}", "Sorgente U {u} V {v}"), - ("Spacing", "Spaziatura"), - ("Specular", "Speculare"), - ("Specular level", "Livello speculare"), - ("Sphere", "Sfera"), - ("Spherical projection", "Proiezione sferica"), - ("Spray", "Spray"), - ("Square", "Quadrato"), - ("Stamp depth", "Profondità impronta"), - ("Star", "Stella"), - ("Starting render...", "Avvio del render..."), - ("Stencil", "Stencil"), - ("Steps", "Passi"), - ("Streaks", "Striature"), - ("Strength", "Intensità"), - ("Stripes", "Strisce"), - ("Stroke opacity", "Opacità tratto"), - ("Subsampling 2x2", "Sottocampionamento 2x2"), - ("Subsampling 4x4", "Sottocampionamento 4x4"), - ("Subsampling 8x8", "Sottocampionamento 8x8"), - ("Subsurface scattering", "Subsurface scattering"), - ("Subtract", "Sottrai"), - ("Tangent | Wrap", "Tangente | Avvolgi"), - ("Temporal anti-aliasing (refines the 3D view while it is still)", "Anti-aliasing temporale (affina la vista 3D quando è ferma)"), - ("Texture Sets", "Set di texture"), - ("Texture Set Settings", "Impostazioni set di texture"), - ("Texture resolution", "Risoluzione texture"), - ("Texture set channels", "Canali del set di texture"), - ("Texture sets", "Set di texture"), - ("TextureCraft had to close:", "TextureCraft ha dovuto chiudersi:"), - ("TextureCraft PBR - Metallic Roughness", "TextureCraft PBR - Metallico Rugosità"), - ("TextureCraft PBR - Specular Glossiness", "TextureCraft PBR - Speculare Lucentezza"), - ("TextureCraft project", "Progetto TextureCraft"), - ("TextureCraft project or mesh", "Progetto o mesh TextureCraft"), - ("Textures", "Texture"), - ("Textures embedded; for game engines and most viewers", "Texture incorporate; per motori di gioco e la maggior parte dei visualizzatori"), - ("Textures packaged; for USD tools and AR Quick Look", "Texture incluse nel pacchetto; per strumenti USD e AR Quick Look"), - ("The GPU couldn't render this scene: {error}", "La GPU non è riuscita a eseguire il rendering di questa scena: {error}"), - ("The bake worker stopped", "Il processo di bake si è interrotto"), - ("The eraser removes paint from the enabled channels.", "La gomma rimuove la pittura dai canali attivi."), - ("The first stroke sets the offset from the source.", "Il primo tratto imposta l'offset dalla sorgente."), - ( - "The image's alpha cuts the decal's shape; faces turned away and surfaces beyond its depth stay clear.", - "L'alpha dell'immagine ritaglia la forma della decal; le facce rivolte altrove e le superfici oltre la sua profondità restano libere.", - ), - ("The next click in the 3D view moves the decal there", "Il prossimo clic nella vista 3D sposta lì la decal"), - ("The resize worker stopped", "Il processo di ridimensionamento si è interrotto"), - ("Thickness", "Spessore"), - ("Thin areas", "Aree sottili"), - ("Threshold", "Soglia"), - ("Tile", "Ripeti"), - ("Tiles", "Piastrelle"), - ("Tint", "Tinta"), - ("Toggle mask", "Attiva/disattiva maschera"), - ("Tolerance", "Tolleranza"), - ("Tone mapping", "Mappatura dei toni"), - ("Tools", "Strumenti"), - ("Torus", "Toro"), - ("Transmission", "Trasmissione"), - ("Tri-planar projection", "Proiezione triplanare"), - ("Triangle fill", "Riempimento triangolo"), - ("UDIM plane", "Piano UDIM"), - ("UDIM tiles painted by this texture set, each at the set's size", "Tile UDIM dipinti da questo set di texture, ciascuno alla dimensione del set"), - ("UI layout", "Layout interfaccia"), - ("UI layout: {error}", "Layout interfaccia: {error}"), - ("UI layouts", "Layout interfaccia"), - ("UI {ms} ms", "Interfaccia {ms} ms"), - ("USD binary, textures alongside", "USD binario, texture a parte"), - ("USD text, textures alongside", "USD testuale, texture a parte"), - ("USDZ with textures", "USDZ con texture"), - ("UV checker", "Scacchiera UV"), - ("UV island fill", "Riempimento isola UV"), - ("UV transformations", "Trasformazioni UV"), - ("UV projection", "Proiezione UV"), - ("UV tiles", "Tile UV"), - ("UV tiles (UDIM)", "Tile UV (UDIM)"), - ("Undo", "Annulla"), - ("Uniform value", "Valore uniforme"), - ("Use an equirectangular .hdr or .exr image as the environment", "Usa un'immagine equirettangolare .hdr o .exr come ambiente"), - ("Use the control channel or `texturecraft-cli render` for screenshots", "Usa il canale di controllo o `texturecraft-cli render` per gli screenshot"), - ("Value", "Valore"), - ("Version {version}", "Versione {version}"), - ("Version: {version} ({gpu})", "Versione: {version} ({gpu})"), - ("View through this camera", "Guarda attraverso questa camera"), - ("Viewer settings", "Impostazioni visualizzatore"), - ("Viewport", "Viewport"), - ("Viewport and brush (fixed)", "Viewport e pennello (fissi)"), - ("Views", "Viste"), - ("Vivid light", "Luce vivida"), - ("Voronoi", "Voronoi"), - ("Warp", "Deformazione"), - ("Warp Directional", "Deformazione direzionale"), - ("Wavefront OBJ with MTL, textures alongside", "Wavefront OBJ con MTL, texture accanto"), - ( - "WebGPU isn't available in this browser, so TextureCraft runs on WebGL2: Rendering mode path traces on the CPU (slower) and large texture sets show at reduced resolution. A current Chrome, Edge or Safari has WebGPU.", - "WebGPU non è disponibile in questo browser, quindi TextureCraft usa WebGL2: la modalità Rendering esegue il path tracing sulla CPU (più lento) e i set di texture grandi vengono mostrati a risoluzione ridotta. Le versioni recenti di Chrome, Edge e Safari supportano WebGPU.", - ), - ("Wheel / Alt + RMB drag", "Rotella / Alt + trascina (tasto destro)"), - ("White", "Bianco"), - ("Width", "Larghezza"), - ("Width (texels at 2K)", "Larghezza (texel a 2K)"), - ("Window", "Finestra"), - ("Wood grain", "Venatura legno"), - ("Works in texture space, like the blur: it does not cross UV seams.", "Opera nello spazio texture, come la sfocatura: non attraversa le cuciture UV."), - ("World Space Normal", "Normale spazio mondo"), - ("Yellow / blue", "Giallo / blu"), - ("Zoom", "Zoom"), - ("a missing layer", "un livello mancante"), - ("aniso", "aniso"), - ("aniso angle", "ang aniso"), - ("ao", "ao"), - ("coat", "riv"), - ("coat nrm", "riv nrm"), - ("coat rough", "riv rug"), - ("color", "colore"), - ("emiss", "emiss"), - ("glTF binary with textures", "glTF binario con texture"), - ("gloss", "lucent"), - ("height", "altezza"), - ("metal", "metal"), - ("min", "min"), - ("missing", "mancante"), - ("missing source", "sorgente mancante"), - ("no GPU", "nessuna GPU"), - ("none", "nessuna"), - ("nrm", "nrm"), - ("off", "disattivo"), - ("op", "op"), - ("rough", "rug"), - ("scatter", "scatter"), - ("sheen", "sheen"), - ("sheen color", "col sheen"), - ("sheen rough", "rug sheen"), - ("spec", "spec"), - ("specular", "speculare"), - ("transm", "trasm"), - ("{action} (undone)", "{action} (annullato)"), - ( - "{file}: add above the selected layer (or drag it into the layer stack or onto the viewport)", - "{file}: aggiungi sopra il livello selezionato (o trascinalo nella pila dei livelli o nella viewport)", - ), - ("{name} copy", "{name} copia"), - ("{n} bits", "{n} bit"), - ( - "{n} control points. Click the mesh (or the 2D view) to add points and drag them to adjust; click the first point to close the path. Enter paints it with the brush (a closed, filled path fills its inside), Esc cancels.", - "{n} punti di controllo. Fai clic sulla mesh (o sulla vista 2D) per aggiungere punti e trascinali per regolarli; fai clic sul primo punto per chiudere il tracciato. Invio lo dipinge con il pennello (un tracciato chiuso e riempito riempie il suo interno), Esc annulla.", - ), - ("{n} items share a shortcut; the first one listed wins.", "{n} elementi condividono una scorciatoia; ha la precedenza il primo dell'elenco."), - ("{pattern} (scale {scale}, seed {seed})", "{pattern} (scala {scale}, seme {seed})"), - ("Template name", "Nome del modello"), - ("Save current project as template", "Salva il progetto corrente come modello"), - ("Distribution", "Distribuzione"), - ("Cosine", "Coseno"), - ("Uniform", "Uniforme"), - ("Normalization", "Normalizzazione"), - // Settings › Interface: brightness and accent color. - ("Brightness", "Luminosità"), - ("Dark", "Scuro"), - ("Medium dark", "Medio scuro"), - ("Medium light", "Medio chiaro"), - ("Light", "Chiaro"), - ("Accent color", "Colore di accento"), - ("Copper", "Rame"), - ("Coral", "Corallo"), - ("Blue", "Blu"), - ("Violet", "Viola"), - ("Green", "Verde"), - ("Amber", "Ambra"), - ("Pink", "Rosa"), - ("Minimize", "Riduci a icona"), - ("Maximize", "Ingrandisci"), - ("Restore", "Ripristina"), - ("Title bar", "Barra del titolo"), - ("System title bar (applies on restart)", "Barra del titolo di sistema (si applica al riavvio)"), - ( - "Use the operating system's window frame and buttons instead of TextureCraft's own title bar", - "Usa la cornice e i pulsanti della finestra del sistema operativo invece della barra del titolo di TextureCraft", - ), - ("Brushes", "Pennelli"), - ("My brushes", "I miei pennelli"), - ("Use this brush (keeps its size)", "Usa questo pennello (mantiene la dimensione)"), - ("Brush name", "Nome del pennello"), - ("Save current brush", "Salva il pennello attuale"), - ("Start window", "Finestra iniziale"), - ("Show at startup", "Mostra all'avvio"), - ("Continue with the sample project", "Continua con il progetto di esempio"), - ("No recent projects yet", "Ancora nessun progetto recente"), - ("Text", "Testo"), - ("Font", "Carattere"), - ("Style", "Stile"), - ("Use as brush alpha", "Usa come alpha del pennello"), - ("Place as decal", "Posiziona come decal"), - ("Click: turn this channel on or off. Alt+click: this channel only", "Clic: attiva o disattiva questo canale. Alt+clic: solo questo canale"), - ("Show all", "Mostra tutto"), - ("Hide all", "Nascondi tutto"), - ("Invert show/hide", "Inverti mostra/nascondi"), - ("Show or hide texture sets", "Mostra o nascondi i set di texture"), - ("Focus: show only the active texture set", "Focus: mostra solo il set di texture attivo"), - ("Unsaved changes", "Modifiche non salvate"), - ("Don't save", "Non salvare"), - ("Save the changes to {name} before closing?", "Salvare le modifiche a {name} prima di chiudere?"), - ("Radius", "Raggio"), - ("Remove skew correction", "Rimuovi la correzione dell'inclinazione"), - ("Twill weave", "Tessuto a saia"), - ("Save the changes to {name} first?", "Salvare prima le modifiche a {name}?"), - ( - "Paths stay editable: pick one to move its points or change its brush and material, and the sublayer repaints at once. Add paths with the Path tool.", - "I tracciati restano modificabili: scegline uno per spostarne i punti o cambiarne pennello e materiale, e il sottolivello si ridipinge subito. Aggiungi tracciati con lo strumento Tracciato.", - ), - ("Import material...", "Importa materiale..."), - ("MaterialCraft material", "Materiale MaterialCraft"), - ("Cooked at {size} px", "Calcolato a {size} px"), - ("Preset", "Preset"), - ("Re-cook", "Ricalcola"), - ("Open in MaterialCraft", "Apri in MaterialCraft"), - ( - "Opened in MaterialCraft: use File > Send to TextureCraft there to bring your changes back", - "Aperto in MaterialCraft: usa lì File > Invia a TextureCraft per riportare le modifiche", - ), - ("Parameters change in the desktop app, with MaterialCraft installed", "I parametri si modificano nell'app desktop, con MaterialCraft installato"), - ("Add High-Poly Meshes", "Aggiungi mesh ad alta risoluzione"), - ("All", "Tutti"), - ("Apply Diffusion", "Applica diffusione"), - ("Attenuation", "Attenuazione"), - ("Auto Tonemapping", "Mappatura tonale automatica"), - ("Average Normals", "Normali medie"), - ("BBox", "Riquadro di delimitazione"), - ("BSphere", "Sfera di delimitazione"), - ("Mesh Map Bakers", "Baker delle mappe mesh"), - ("Common Settings", "Impostazioni comuni"), - ("Mesh Map Settings", "Impostazioni mappe mesh"), - ("Check All", "Seleziona tutto"), - ("No Parameters", "Nessun parametro"), - ("Bake Selected Textures ({n})", "Bake texture selezionate ({n})"), - ("By Mesh Name", "Per nome della mesh"), - ("Cage", "Gabbia"), - ("Cage Scene", "Scena della gabbia"), - ("Cage Type", "Tipo di gabbia"), - ("Color Generator", "Generatore di colori"), - ("Color Source", "Origine del colore"), - ("Common Parameters", "Parametri comuni"), - ("Custom File", "File personalizzato"), - ("Details", "Dettagli"), - ("Dilation Width", "Ampiezza dilatazione"), - ("Distance-Based", "Basata sulla distanza"), - ("Edge Contrast", "Contrasto dei bordi"), - ("Edge Distance", "Distanza dei bordi"), - ("Edge Protection", "Protezione dei bordi"), - ("Enable Seams", "Abilita cuciture"), - ("File ID", "ID del file"), - ("Full Scene", "Intera scena"), - ("Generate from Mesh", "Genera dalla mesh"), - ("Generate from Normal Map", "Genera dalla mappa delle normali"), - ("Ground Plane", "Piano del terreno"), - ("Ground Plane Offset", "Scostamento del terreno"), - ("High Poly Mesh Suffix", "Suffisso mesh high poly"), - ("High Poly Scene", "Scena ad alta risoluzione"), - ("High-Poly Parameters", "Parametri ad alta risoluzione"), - ("Hue Shift", "Variazione di tonalità"), - ("Ignore Backface", "Ignora facce posteriori"), - ("Ignore Backface Suffix", "Suffisso per ignorare le facce posteriori"), - ("Include in Bake", "Includi nel bake"), - ("Load Cage", "Carica gabbia"), - ("Lock Output Size", "Blocca dimensioni di output"), - ("Low Poly Mesh Suffix", "Suffisso mesh low poly"), - ("Manual", "Manuale"), - ("Material Color", "Colore del materiale"), - ("Max Frontal Distance", "Distanza frontale max"), - ("Max Occluder Distance", "Distanza max occlusori"), - ("Max Rear Distance", "Distanza posteriore max"), - ("Mesh ID", "ID della mesh"), - ("Method", "Metodo"), - ("Min Occluder Distance", "Distanza minima dell'occlusore"), - ("Never", "Mai"), - ("No High-Poly Meshes", "Nessuna mesh ad alta risoluzione"), - ("Normalization Scale", "Scala di normalizzazione"), - ("Normalization Type", "Tipo di normalizzazione"), - ("Only Same Mesh Name", "Solo stesso nome mesh"), - ("Output Size", "Dimensione output"), - ("Match", "Corrispondenza"), - ("Skew Correction Method", "Metodo di Correzione della Distorsione"), - ("Mesh Normals Based", "Basato sulle Normali della Mesh"), - ("Face Normals Based", "Basato sulle Normali delle Facce"), - ("Reset Painted Cage", "Ripristina Gabbia Dipinta"), - ("Paint Cage", "Dipingi gabbia"), - ("Paint Skew Correction", "Dipingi correzione dell'inclinazione"), - ("Per Material", "Per materiale"), - ("Random", "Casuale"), - ("Relative to Bounding Box", "Relativo al riquadro di delimitazione"), - ("Relative to Low Mesh", "Relativo alla mesh a bassa risoluzione"), - ("Relative to Min/Max", "Relativo a minimo/massimo"), - ("Relative to Ray Distances", "Relativo alle distanze dei raggi"), - ("Remove Cage", "Rimuovi gabbia"), - ("Remove Skew Correction", "Rimuovi la correzione dell'inclinazione"), - ("Restore Defaults", "Ripristina valori predefiniti"), - ("Return to Painting Mode", "Torna alla modalità pittura"), - ("Sampling Radius", "Raggio di campionamento"), - ("Scaling Divisor", "Divisore di scala"), - ("Seams Intensity", "Intensità delle cuciture"), - ("Secondary Rays", "Raggi secondari"), - ("Self Intersection", "Autointersezione"), - ("Self Occlusion", "Auto-occlusione"), - ("Skew Correction", "Correzione dell'inclinazione"), - ("Smooth", "Uniforme"), - ("Spread Angle", "Angolo di diffusione"), - ("Submesh", "Sottomesh"), - ("Use Low Poly Mesh as High Poly Mesh", "Usa la mesh low poly come mesh high poly"), - ("Value Bounds Max", "Limite massimo"), - ("Value Bounds Min", "Limite minimo"), - ("Vertex Color", "Colore dei vertici"), - ("Select the layer content", "Seleziona il contenuto del livello"), - ("Paint layer", "Livello di pittura"), - ("Fill layer", "Livello di riempimento"), - ("1 effect", "1 effetto"), - ("{count} effects", "{count} effetti"), - ("Mask effects", "Effetti della maschera"), - ("Content effects", "Effetti del contenuto"), - ("Fold or unfold these effects", "Comprimi o espandi questi effetti"), - ("Remove resolution override", "Rimuovi risoluzione personalizzata"), - ("Texture set resolution", "Risoluzione del set di texture"), - ("UV tile {tile} resolution", "Risoluzione del tile UV {tile}"), - ("Angle span", "Ampiezza angolo"), - ("Axis position", "Posizione asse"), - ("Count", "Numero"), - ("Display", "Visualizzazione"), - ("Hide while painting", "Nascondi durante la pittura"), - ("Manipulator size", "Dimensione manipolatore"), - ("Mirror symmetry", "Simmetria speculare"), - ("Radial settings", "Impostazioni radiali"), - ("Radial symmetry", "Simmetria radiale"), - ("Show axis", "Mostra asse"), - ("Show axis position manipulator", "Mostra manipolatore posizione asse"), - ("Show cursor", "Mostra cursore"), - ("Show intersection", "Mostra intersezione"), - ("Show plane", "Mostra piano"), - ("Symmetry", "Simmetria"), - ("Symmetry color display", "Colore di visualizzazione simmetria"), - ("Symmetry settings", "Impostazioni simmetria"), - ("Type", "Tipo"), - ("Advanced settings", "Impostazioni avanzate"), - ("Import baked maps", "Importa mappe bake"), - ("Name each file after its texture set, like Body_normal.png", "Dai a ogni file il nome del suo set di texture, ad es. Body_normal.png"), - ("Add...", "Aggiungi..."), - ("Baked maps imported: {count}", "Mappe bake importate: {count}"), - ("Not imported: {files}", "Non importati: {files}"), - ("Baking Visualization", "Visualizzazione del baking"), - ("Show for Selected Texture Set Only", "Mostra solo per il set di texture selezionato"), - ("High Definition Mesh (HP)", "Mesh ad alta risoluzione (HP)"), - ("UV Seams", "Cuciture UV"), - ("Project Mesh (LP)", "Mesh di proiezione (LP)"), - ("Edges", "Bordi"), - ("Cavities", "Cavità"), - ("Edges and cavities", "Bordi e cavità"), - ("Raw curvature", "Curvatura grezza"), - ("Detail sizes", "Dimensioni del dettaglio"), - ( - "Reads the curvature map as baked: changing the mode or a size turns detail sizes on.", - "Legge la mappa di curvatura così come è stata calcolata: cambiare la modalità o una dimensione attiva le dimensioni del dettaglio.", - ), - ( - "A click fills what is under it; a dragged rectangle fills what it selects as it grows", - "Un clic riempie ciò che c'è sotto; un rettangolo trascinato riempie ciò che seleziona mentre si allarga", - ), - ("Contained center: fill polygons whose center is in the rectangle", "Centro contenuto: riempi i poligoni il cui centro è nel rettangolo"), - ( - "Editing the quick mask: fills paint where painting is allowed. Press U to finish.", - "Modifica della maschera rapida: i riempimenti dipingono le aree in cui è consentito dipingere. Premi U per terminare.", - ), - ("Fill mode", "Modalità di riempimento"), - ("Fill only polygons the camera sees (3D view)", "Riempi solo i poligoni visti dalla camera (vista 3D)"), - ("Hit-test", "Test di selezione"), - ("How a rectangle selects polygons", "Come un rettangolo seleziona i poligoni"), - ("Intersection: fill polygons the rectangle touches", "Intersezione: riempi i poligoni toccati dal rettangolo"), - ("Rectangle fill", "Riempimento rettangolare"), - ("Select a paint layer or a layer's mask to fill", "Seleziona un livello di pittura o una maschera di livello da riempire"), - ("Selection mode", "Modalità di selezione"), - ( - "Triangle fills single triangles, Polygon whole quads and n-gons, Mesh the connected geometry, UV island the UV islands", - "Triangolo riempie singoli triangoli, Poligono quad e n-goni interi, Mesh la geometria connessa, Isola UV le isole UV", - ), - ("Visible polygons only", "Solo poligoni visibili"), - ( - "\"{layer}\" can't be filled: select a paint layer or a layer's mask", - "\"{layer}\" non può essere riempito: seleziona un livello di pittura o una maschera di livello", - ), - ("The file dialog couldn't be shown: {error}", "Impossibile mostrare la finestra di dialogo dei file: {error}"), - ( - "The project changed while the dialog was open, so nothing was done", - "Il progetto è cambiato mentre la finestra di dialogo era aperta, quindi non è stato fatto nulla", - ), - ("Cores kept for the UI", "Core riservati all'interfaccia"), - ("Max RAM while saving", "RAM max durante il salvataggio"), - ( - "Saving uses the other cores and at most this share of the free RAM. At least one core always works.", - "Il salvataggio usa gli altri core e al massimo questa quota della RAM libera. Almeno un core lavora sempre.", - ), - ("Max project size on open", "Dimensione massima all’apertura"), - ( - "Maximum decompressed project data. Increase this limit to open larger projects.", - "Quantità massima di dati decompressi del progetto. Aumenta questo limite per aprire progetti più grandi.", - ), -]; diff --git a/crates/ui-egui/src/i18n/ja.rs b/crates/ui-egui/src/i18n/ja.rs deleted file mode 100644 index 0e60e132..00000000 --- a/crates/ui-egui/src/i18n/ja.rs +++ /dev/null @@ -1,1163 +0,0 @@ -//! Japanese UI text: (English key, translation). Keys are the English strings passed to `tr`. - -pub const TABLE: &[(&str, &str)] = &[ - ("Baking {map} ({n}/{total})", "{map} をベイク中 ({n}/{total})"), - ("Baking {map} ({n}/{total}), texture set {set} of {sets}", "{map} をベイク中 ({n}/{total})、テクスチャセット {set}/{sets}"), - ("Follow Newest Map", "最新のマップを追う"), - ( - "Painting is paused while a bake is shown. Cancel the bake or wait for it to finish.", - "ベイクの表示中はペイントを一時停止しています。ベイクをキャンセルするか、終わるまでお待ちください。", - ), - ( - "What the 3D view shows while the bake runs: the newest finished map, one finished map, or the material. Maps not baked yet show a neutral value.", - "ベイク中に3Dビューが表示するもの:最後に完成したマップ、完成済みの好きなマップ、またはマテリアル。まだベイクされていないマップは中立値で表示されます。", - ), - ( - "\"{layer}\" has no paint yet: the filter changes what you paint on it.", - "「{layer}」にはまだペイントがありません:フィルターはこのレイヤーにペイントした内容を変化させます。", - ), - ("0 turns autosave off. Copies go to {folder}", "0で自動保存をオフにします。コピーの保存先: {folder}"), - ("2D view only", "2Dビューのみ"), - ("32 bits (float)", "32ビット (浮動小数点)"), - ("3D mesh", "3Dメッシュ"), - ("3D meshes", "3Dメッシュ"), - ( - "3D texture painting: layers, masks, smart materials, mesh map baking and export.", - "3Dテクスチャペイント: レイヤー、マスク、スマートマテリアル、メッシュマップのベイク、エクスポート。", - ), - ("3D view only", "3Dビューのみ"), - ("3D/2D views", "3D/2Dビュー"), - ( - "A folder blends its children (pass-through). Set per-channel opacity in the layer rows.", - "フォルダーは子レイヤーをそのまま合成します (通過)。チャンネルごとの不透明度はレイヤー行で設定します。", - ), - ("ACES filmic", "ACES フィルミック"), - ("Ambient", "アンビエント"), - ("AO intensity", "AO強度"), - ("About TextureCraft", "TextureCraftについて"), - ("About TextureCraft...", "TextureCraftについて..."), - ( - "Add an anchor point to a layer below to use its stack as a mask.", - "下のレイヤーにアンカーポイントを追加すると、そのスタックをマスクとして使用できます。", - ), - ("Add anchor point", "アンカーポイントを追加"), - ("Add as decal (view center)", "デカールとして追加 (ビュー中央)"), - ("Add black mask", "黒マスクを追加"), - ("Add channel", "チャンネルを追加"), - ("Add color", "カラーを追加"), - ("Add compare mask", "比較マスクを追加"), - ("Add effect", "エフェクトを追加"), - ("Add fill", "塗りつぶしを追加"), - ("Add fill layer", "塗りつぶしレイヤーを追加"), - ("Add filter", "フィルターを追加"), - ("Add folder", "フォルダーを追加"), - ("Add generator", "ジェネレーターを追加"), - ("Add levels", "レベル補正を追加"), - ("Add mask", "マスクを追加"), - ("Add mask with color selection", "カラー選択でマスクを追加"), - ("Add output", "出力を追加"), - ("Add paint", "ペイントを追加"), - ("Add paint layer", "ペイントレイヤーを追加"), - ("Add smart material from the shelf", "シェルフからスマートマテリアルを追加"), - ("Add to the layer content", "レイヤーのコンテンツに追加"), - ("Add to the mask", "マスクに追加"), - ("Add white mask", "白マスクを追加"), - ("Adjustments", "色調補正"), - ( - "Aligned: the offset set by the first stroke is kept. V + click sets a new source.", - "整列: 最初のストロークで決まったオフセットを維持します。V + クリックで新しいソースを設定します。", - ), - ("Alignment", "アライメント"), - ("Alignment and culling", "アライメントとカリング"), - ("All layers", "すべてのレイヤー"), - ("Alpha", "アルファ"), - ("Alphas", "アルファ"), - ("Also bound to {item} ({menu})", "{item} ({menu}) にも割り当て済み"), - ("Alt + LMB drag", "Alt + 左ドラッグ"), - ("Always", "常に"), - ("Ambient Occlusion", "アンビエントオクルージョン"), - ("Ambient occlusion", "アンビエントオクルージョン"), - ("Amount", "量"), - ("Anchor point", "アンカーポイント"), - ("Anchor: {name}", "アンカー: {name}"), - ("Anchor: {name} ({channel})", "アンカー: {name} ({channel})"), - ("Angle", "角度"), - ("Angle (degrees)", "角度 (度)"), - ("Angle fade from", "角度フェード開始"), - ("Angle fade to", "角度フェード終了"), - ("Angle jitter", "角度ジッター"), - ("Anisotropy angle", "異方性角度"), - ("Anisotropy level", "異方性レベル"), - ("Antialiasing", "アンチエイリアス"), - ("Aperture", "絞り"), - ("Apply", "適用"), - ("ArtCraft website...", "ArtCraft ウェブサイト..."), - ("Assets", "アセット"), - ("Auto", "自動"), - ("Automatic (from the mesh UVs)", "自動 (メッシュのUVから)"), - ("Autosave every", "自動保存の間隔"), - ( - "Autosaves, smart materials, presets, templates and UI layouts go to the data folder. A new folder applies on restart; files already saved stay where they are.", - "自動保存、スマートマテリアル、プリセット、テンプレート、UI レイアウトはデータフォルダーに保存されます。新しいフォルダーは再起動後に適用され、保存済みのファイルはそのまま残ります。", - ), - ("Axis", "軸"), - ("Back to painting", "ペイントに戻る"), - ("Backface culling", "背面カリング"), - ("Bake an ID map (F8) to pick colors from the mesh.", "メッシュから色を拾うには ID マップをベイクしてください (F8)。"), - ("Bake Mesh Maps", "メッシュマップのベイク"), - ("Bake mesh maps", "メッシュマップをベイク"), - ( - "Bake mesh maps (F8) for curvature, AO and thickness based generators.", - "曲率、AO、厚みに基づくジェネレーターには、メッシュマップのベイク (F8) が必要です。", - ), - ("Baked Lighting", "ライティングのベイク"), - ("Baking", "ベイク"), - ("Base color", "ベースカラー"), - ( - "Base color is the diffuse color, Specular the F0 color and Glossiness 1 - roughness (add these channels in the texture set settings).", - "ベースカラーはディフューズカラー、スペキュラーはF0カラー、グロッシネスは 1 - ラフネスです (これらのチャンネルはテクスチャセット設定で追加します)。", - ), - ("Base color, Metallic, Roughness and Specular level.", "ベースカラー、メタリック、ラフネス、スペキュラーレベル。"), - ("Based on each texture set's size", "各テクスチャセットのサイズに基づく"), - ("Basic settings", "基本設定"), - ("Bent Normals", "ベントノーマル"), - ("Bevel", "ベベル"), - ("Black", "黒"), - ("Blending", "ブレンド"), - ("Blending mode of the displayed channel", "表示中のチャンネルのブレンドモード"), - ("Blur", "ぼかし"), - ("Blur Directional", "方向ぼかし"), - ("Blur and sharpen", "ぼかしとシャープ"), - ("Bounces", "バウンス数"), - ("Bricks", "レンガ"), - ("Brush", "ブラシ"), - ("Brush size", "ブラシサイズ"), - ("Brush size down / up", "ブラシサイズ 縮小 / 拡大"), - ("Brushed lines", "ヘアライン"), - ("Built-in (read-only): duplicate it to edit", "組み込み (読み取り専用): 複製して編集"), - ("Built-in templates are read-only: duplicate one to edit it", "組み込みテンプレートは読み取り専用です: 複製して編集"), - ("Built-in: {mesh}", "組み込み: {mesh}"), - ("Cage: {name}", "ケージ: {name}"), - ("Camera", "カメラ"), - ("Colors", "カラー"), - ("Go to camera 1", "カメラ 1 に移動"), - ("Go to camera 2", "カメラ 2 に移動"), - ("Go to camera 3", "カメラ 3 に移動"), - ("Go to camera 4", "カメラ 4 に移動"), - ("Go to camera 5", "カメラ 5 に移動"), - ("Go to camera 6", "カメラ 6 に移動"), - ("Go to camera 7", "カメラ 7 に移動"), - ("Go to camera 8", "カメラ 8 に移動"), - ("Go to camera 9", "カメラ 9 に移動"), - ("Camera settings", "カメラ設定"), - ("Cancel", "キャンセル"), - ("Cancel the stroke", "ストロークをキャンセル"), - ("Cell size (texels at 2K)", "セルサイズ (2K時のテクセル)"), - ("Cells", "セル"), - ("Channel", "チャンネル"), - ("Channel source: uniform value, procedural, image or anchor", "チャンネルのソース: 均一値、プロシージャル、画像、アンカー"), - ("Channels", "チャンネル"), - ("Check for Updates...", "アップデートを確認..."), - ("Checker", "チェッカー"), - ("Clamp", "クランプ"), - ("Clear", "クリア"), - ("Clear mask", "マスクをクリア"), - ("Clear recent projects", "最近使ったプロジェクトをクリア"), - ( - "Click a mesh part to show or hide the selected layer on it.", - "メッシュのパーツをクリックすると、選択したレイヤーをそのパーツで表示または非表示にします。", - ), - ("Click the mesh to pick its material into the brush", "メッシュをクリックしてマテリアルをブラシに取得"), - ("Click the mesh to place the decal", "メッシュをクリックしてデカールを配置"), - ("Click, then press the new shortcut (Esc cancels)", "クリックして新しいショートカットを押す (Escでキャンセル)"), - ("Clone", "クローン"), - ("Close", "閉じる"), - ("Closed path", "閉じたパス"), - ("Cloud", "雲"), - ("Clouds", "雲"), - ("Coat normal", "コートノーマル"), - ("Coat roughness", "コートラフネス"), - ("Coat weight", "コートウェイト"), - ("Color", "カラー"), - ("Color Balance", "カラーバランス"), - ("Color burn", "焼き込みカラー"), - ("Color dodge", "覆い焼きカラー"), - ( - "Color of the light that travels under the surface (each channel goes as far as its value)", - "表面下を伝わる光の色 (各チャンネルは値に応じた距離まで届く)", - ), - ("Color picker", "カラーピッカー"), - ("Color selection", "カラー選択"), - ("Color to replace", "置き換える色"), - ("Colors near the first shift towards the second, keeping their shading.", "最初の色に近い色が、陰影を保ったまま2番目の色へ移ります。"), - ( - "Colors read as gray. Add a levels or blur effect above to shape the result.", - "カラーはグレーとして読み取られます。結果を調整するには、上にレベル補正またはぼかしエフェクトを追加します。", - ), - ("Combine with the layer's height", "レイヤーのハイトと合成"), - ("Compare mask", "比較マスク"), - ("Compositing", "合成中"), - ("Constant", "定数"), - ("Constants", "定数"), - ("Contrast", "コントラスト"), - ("Contrast/Luminosity", "コントラスト/輝度"), - ("Converted maps", "変換マップ"), - ("Copy RGB values", "RGB 値をコピー"), - ("Copy effect", "エフェクトをコピー"), - ("Copy from", "コピー元"), - ("Copy layer(s)", "レイヤーをコピー"), - ("Copy the selected layer alone (its empty parts copy nothing)", "選択中のレイヤーのみをコピー (空の部分は何もコピーしない)"), - ("Copy to all texture sets", "すべてのテクスチャセットにコピー"), - ("Copy what the texture set shows", "テクスチャセットの表示内容をコピー"), - ("Couldn't encode the render", "レンダリング結果をエンコードできませんでした"), - ("Couldn't export textures: {error}", "テクスチャをエクスポートできませんでした: {error}"), - ("Couldn't export the mesh: {error}", "メッシュをエクスポートできませんでした: {error}"), - ("Couldn't export the template: {error}", "テンプレートをエクスポートできませんでした: {error}"), - ("Couldn't import {name}: {error}", "{name} をインポートできませんでした: {error}"), - ("Couldn't open {name}: {error}", "{name} を開けませんでした: {error}"), - ("Couldn't read the render back from the GPU", "GPUからレンダリング結果を読み戻せませんでした"), - ("Couldn't save the render: {error}", "レンダリング結果を保存できませんでした: {error}"), - ("Couldn't save {name}: {error}", "{name} を保存できませんでした: {error}"), - ("Count per stamp", "スタンプあたりの数"), - ("Crate", "木箱"), - ("Create", "作成"), - ("Create smart material", "スマートマテリアルを作成"), - ( - "Ctrl+right-drag in a view sets the size and hardness, Ctrl+left-drag the flow and angle.", - "ビューでCtrl+右ドラッグでサイズと硬さ、Ctrl+左ドラッグでフローと角度を設定します。", - ), - ("Cube", "立方体"), - ("Current layer", "現在のレイヤー"), - ("Curvature", "曲率"), - ("Cut effect", "エフェクトを切り取り"), - ("Cut layer(s)", "レイヤーを切り取り"), - ("Cyan / red", "シアン / レッド"), - ("Cylinder", "円柱"), - ("Cylindrical projection", "円柱投影"), - ("Dark to light: the content's luminance picks a color along these stops.", "暗→明: コンテンツの輝度に応じて、これらのストップに沿った色が選ばれます。"), - ("Darken (Min)", "比較(暗) (Min)"), - ("Data folder", "データフォルダー"), - ("Decal", "デカール"), - ("Decal projection", "デカール投影"), - ("Default", "デフォルト"), - ("Default camera", "デフォルトカメラ"), - ("Delete the selected template", "選択中のテンプレートを削除"), - ("Delete this camera", "このカメラを削除"), - ("Deleted template \"{name}\"", "テンプレート「{name}」を削除しました"), - ("Denoise", "ノイズ除去"), - ("Depth", "奥行き"), - ("Depth of field", "被写界深度"), - ("Depth of field (viewport and Rendering mode)", "被写界深度 (ビューポートとレンダリングモード)"), - ("Depth of the sharp plane along the view (0: the orbit center)", "ピントが合う面の視線方向の深度 (0: オービット中心)"), - ("Details saved to {file}", "詳細の保存先: {file}"), - ("Difference", "差の絶対値"), - ("Dilation + default background color", "ダイレーション + デフォルト背景色"), - ("Dilation + transparent", "ダイレーション + 透明"), - ("Dilation infinite", "ダイレーション (無限)"), - ("DirectX normal map", "DirectX ノーマルマップ"), - ("Dirt", "汚れ"), - ("Disable", "無効"), - ("Dismiss", "閉じる"), - ("Displacement (height channel)", "ディスプレイスメント(ハイトチャンネル)"), - ("Display Settings", "表示設定"), - ("Display material", "マテリアルを表示"), - ("Display next channel", "次のチャンネルを表示"), - ("Display next mesh map", "次のメッシュマップを表示"), - ("Display previous channel", "前のチャンネルを表示"), - ("Display previous mesh map", "前のメッシュマップを表示"), - ("Distance", "距離"), - ("Distort", "変形"), - ("Divide", "除算"), - ("Document resolution", "ドキュメント解像度"), - ("Documentation...", "ドキュメント..."), - ("Done on CPU: {n} / {max} samples, {s} s", "CPUで完了: {n} / {max} サンプル、{s} 秒"), - ("Done on GPU: {n} / {max} samples, {s} s", "GPUで完了: {n} / {max} サンプル、{s} 秒"), - ("Double-click to rename", "ダブルクリックで名前を変更"), - ("Download as", "ダウンロード形式"), - ("Downloaded {name}", "{name} をダウンロードしました"), - ("Drag onto an output channel", "出力チャンネルにドラッグ"), - ("Drag the frame to move the decal, a corner to scale it, the round handle to turn it", "枠をドラッグでデカールを移動、角で拡大縮小、丸いハンドルで回転"), - ("Drags the layer stack's values along the stroke into the selected layer.", "レイヤースタックの値をストロークに沿って選択中のレイヤーへ引き伸ばします。"), - ( - "Draws {name} of texture set \"{set}\". Edits to the source show in every instance.", - "テクスチャセット「{set}」の {name} を描画します。ソースへの編集はすべてのインスタンスに反映されます。", - ), - ("Drop an image from the Assets panel here to use it as this mesh map", "アセットパネルから画像をここにドロップすると、このメッシュマップとして使用します"), - ("Dry streaks", "かすれ"), - ("Duplicate effect", "エフェクトを複製"), - ("Duplicate layer(s)", "レイヤーを複製"), - ("Duplicate the selected template", "選択中のテンプレートを複製"), - ("Edge Detect", "エッジ検出"), - ("Edit", "編集"), - ("Edit keyboard shortcuts...", "キーボードショートカットを編集..."), - ("Edit quick mask", "クイックマスクを編集"), - ("Editing quick mask: paint where painting is allowed (U to finish)", "クイックマスク編集中: ペイントを許可する範囲を塗る (Uで終了)"), - ( - "Editing the quick mask: strokes paint where painting is allowed. Press U to finish.", - "クイックマスク編集中: ストロークでペイントを許可する範囲を塗ります。Uキーで終了します。", - ), - ("Emissive", "エミッシブ"), - ("Enable or disable the effect", "エフェクトの有効/無効を切り替え"), - ("Enable quick mask", "クイックマスクを有効化"), - ("Environment blur", "環境のぼかし"), - ("Environment exposure (EV)", "環境の露出 (EV)"), - ("Environment map", "環境マップ"), - ("Environment opacity", "環境の不透明度"), - ("Environment rotation", "環境の回転"), - ("Environment settings", "環境の設定"), - ("Environment: {name}", "環境: {name}"), - ("Environments", "環境"), - ("Eraser", "消しゴム"), - ("Exclusion", "除外"), - ("Expand or collapse the folder", "フォルダーを展開/折りたたみ"), - ("Export", "エクスポート"), - ("Export Mesh...", "メッシュをエクスポート..."), - ("Export Textures...", "テクスチャをエクスポート..."), - ("Export mesh", "メッシュのエクスポート"), - ("Export template", "出力テンプレート"), - ("Export templates", "出力テンプレート"), - ("Export textures", "テクスチャのエクスポート"), - ("Export the selected template (.json)", "選択中のテンプレートをエクスポート (.json)"), - ("Exported mesh to {path}", "メッシュを {path} にエクスポートしました"), - ("Exported template \"{name}\" to {path}", "テンプレート「{name}」を {path} にエクスポートしました"), - ("Exported {n} textures to {folder}", "{n} 個のテクスチャを {folder} にエクスポートしました"), - ("F0 from specular level", "スペキュラーレベルからF0"), - ("Fabric weave", "布の織り目"), - ("Field of view (deg)", "視野角 (度)"), - ("File", "ファイル"), - ("File name without extension; variables insert names", "拡張子なしのファイル名。変数で名前を挿入"), - ("File type", "ファイル形式"), - ("Fill", "塗りつぶし"), - ("Fill the closed path (lasso)", "閉じたパスを塗りつぶし (なげなわ)"), - ("Fill the path (close it first)", "パスを塗りつぶし (先にパスを閉じる)"), - ("Filter", "フィルター"), - ("Filter the remaining noise while keeping edges and texture detail", "エッジとテクスチャのディテールを保ちながら残りのノイズを除去"), - ("Filters", "フィルター"), - ("Fine noise", "細かいノイズ"), - ("Fingerprints", "指紋"), - ("Enter a finite number", "有限の数値を入力してください"), - ("Double-click or press Enter to edit", "ダブルクリックまたは Enter キーで編集"), - ("Fit the input range to the histogram", "入力範囲をヒストグラムに合わせる"), - ("Flatten layer", "レイヤーを統合"), - ("Flips the image's green channel, for normal maps made with Y pointing down", "画像の緑チャンネルを反転します (Y が下向きで作られたノーマルマップ用)"), - ("Flow", "フロー"), - ("Flow and opacity", "フローと不透明度"), - ("Flow jitter", "フロージッター"), - ("Focus distance", "フォーカス距離"), - ("Folder", "フォルダー"), - ("Folders", "フォルダー"), - ("Follow path", "パスに沿う"), - ( - "For the whole project: how normal map images set as mesh maps are read (set them again after a change), and the default for export", - "プロジェクト全体: メッシュマップとして設定したノーマルマップ画像の読み取り方 (変更後は設定し直してください) と、書き出しの既定値", - ), - ("Free and open source (MIT OR Apache-2.0), written in Rust.", "無料のオープンソース (MIT OR Apache-2.0)、Rustで開発。"), - ("From template", "テンプレートから"), - ("From template / project", "テンプレート / プロジェクトから"), - ("Full", "フル"), - ("GPU error: {error}", "GPU エラー: {error}"), - ("Geometry mask", "ジオメトリマスク"), - ( - "GGX specular with height-correlated Smith visibility, Lambert diffuse, split-sum image-based lighting with spherical-harmonics irradiance and horizon fading.", - "GGXスペキュラー (高さ相関Smithビジビリティ)、Lambertディフューズ、球面調和関数による放射照度とホライズンフェードを用いたスプリットサムのイメージベースドライティング。", - ), - ("Gamma", "ガンマ"), - ("General export parameters", "一般エクスポートパラメーター"), - ("General properties", "一般プロパティ"), - ("Generator", "ジェネレーター"), - ("Geometry and UVs only", "ジオメトリとUVのみ"), - ("Glossiness", "グロッシネス"), - ("Glossiness from roughness", "ラフネスからグロッシネス"), - ("Glow", "グロー"), - ("Gradient", "グラデーション"), - ("Gradient Map", "グラデーションマップ"), - ("Gravity", "重力"), - ("Gray", "グレー"), - ("Gray + A", "グレー + A"), - ("Gray 50%", "グレー 50%"), - ("Grayscale", "グレースケール"), - ("Group layer(s)", "レイヤーをグループ化"), - ("Grunge", "グランジ"), - ("HDR environments", "HDR環境"), - ("High Pass", "ハイパス"), - ("HSL Perceptive", "HSL (知覚)"), - ("Half", "1/2"), - ("Hammered", "槌目"), - ("Hard light", "ハードライト"), - ("Hardness", "硬さ"), - ("Height", "ハイト"), - ("Height offset", "ハイトオフセット"), - ("Height to normal strength", "ハイト→ノーマル強度"), - ("Help", "ヘルプ"), - ("Hide UI", "UIを非表示"), - ("High", "高"), - ("High poly: {name}", "ハイポリ: {name}"), - ("Highlights", "ハイライト"), - ("Histogram Range", "ヒストグラム範囲"), - ("Histogram Scan", "ヒストグラムスキャン"), - ("Histogram Shift", "ヒストグラムシフト"), - ("History", "履歴"), - ( - "Hold S: left-drag rotates, right-drag scales, middle-drag moves the stencil.", - "Sを押したまま: 左ドラッグで回転、右ドラッグで拡大縮小、中ドラッグでステンシルを移動。", - ), - ("Hold V and click the mesh to set the clone source", "Vを押しながらメッシュをクリックしてクローンソースを設定"), - ( - "Hold V and click the mesh to set the source, then paint elsewhere to copy it.", - "Vを押しながらメッシュをクリックしてソースを設定し、別の場所をペイントしてコピーします。", - ), - ( - "How far light travels under the surface, as a fraction of the mesh size (where the Scattering weight channel is painted)", - "表面下を光が伝わる距離。メッシュサイズに対する割合 (スキャタリングウェイトチャンネルをペイントした箇所)", - ), - ( - "How strongly transmissive surfaces bend light (where the Transmission channel is painted): water 1.33, glass 1.5, diamond 2.42", - "透過する表面が光を屈折させる強さ (トランスミッションチャンネルをペイントした箇所): 水 1.33、ガラス 1.5、ダイヤモンド 2.42", - ), - ("Hue shift (degrees)", "色相シフト (度)"), - ("ID", "ID"), - ("Image: {name}", "画像: {name}"), - ("Images", "画像"), - ("Import HDR...", "HDRをインポート..."), - ("Import a template (.json)", "テンプレートをインポート (.json)"), - ( - "Import an image (File > Import resources) to project it onto the mesh.", - "画像をインポートすると (ファイル > リソースをインポート)、メッシュに投影できます。", - ), - ("Import images to use them in fills and masks", "画像をインポートして塗りつぶしやマスクで使用"), - ("Import resources...", "リソースをインポート..."), - ("Import MaterialX material...", "MaterialX マテリアルをインポート..."), - ("MaterialX materials", "MaterialX マテリアル"), - ("Import...", "インポート..."), - ("Imported template \"{name}\"", "テンプレート「{name}」をインポートしました"), - ("Imported {name}", "{name} をインポートしました"), - ("Index of refraction", "屈折率"), - ("Input high", "入力の上限"), - ("Input low", "入力の下限"), - ("Input maps", "入力マップ"), - ("Insert a variable", "変数を挿入"), - ("Instance", "インスタンス"), - ("Instantiate across texture sets", "テクスチャセット間でインスタンス化"), - ("Intensity (texels at 2K)", "強度 (2K時のテクセル)"), - ("Interface", "インターフェイス"), - ("Interface scale", "インターフェイスのスケール"), - ("Inverse Subtract", "逆減算"), - ("Inverse divide", "逆除算"), - ("Invert", "反転"), - ("Invert mask", "マスクを反転"), - ("Invert mask background", "マスクの背景を反転"), - ("Invert mask value", "マスク値を反転"), - ("Invert quick mask", "クイックマスクを反転"), - ("Jitters", "ジッター"), - ("Join the ArtCraft community on Discord", "DiscordでArtCraftコミュニティに参加"), - ("Join the community (Discord)...", "コミュニティに参加 (Discord)..."), - ("Key light (shadow-casting light, direct only)", "キーライト (影を落とすライト、直接光のみ)"), - ("Keyboard", "キーボード"), - ("Keyboard shortcuts", "キーボードショートカット"), - ("Light azimuth (degrees)", "ライトの方位角 (度)"), - ("Light elevation (degrees)", "ライトの仰角 (度)"), - ("Light intensity", "ライトの強度"), - ("LMB", "左ドラッグ"), - ("Language", "言語"), - ("Layer mask", "レイヤーマスク"), - ("Layer memory: {mb} MB", "レイヤーメモリ: {mb} MB"), - ("Layers", "レイヤー"), - ("Lazy mouse", "レイジーマウス"), - ("Lazy mouse distance", "レイジーマウスの距離"), - ("Leather grain", "革のシボ"), - ("Lens size: how quickly things blur away from the focus distance", "レンズサイズ: フォーカス距離から離れるにつれてぼける速さ"), - ("Level", "レベル"), - ("Levels", "レベル補正"), - ("Lifetime (steps)", "寿命 (ステップ)"), - ("Light / direction", "ライト / 方向"), - ("Lighten (Max)", "比較(明) (Max)"), - ("Lightness", "明度"), - ("Linear", "リニア"), - ("Linear burn", "焼き込み(リニア)"), - ("Linear dodge (Add)", "覆い焼き(リニア) - 加算"), - ("Linear light", "リニアライト"), - ("List of exports", "エクスポート一覧"), - ("Load UI Layout", "UIレイアウトを読み込み"), - ("Loaded UI layout {path}", "UIレイアウト {path} を読み込みました"), - ("Log", "ログ"), - ("Low", "低"), - ("Luminosity", "輝度"), - ("MMB drag / Alt + MMB", "中ドラッグ / Alt + 中ドラッグ"), - ("Made by the ArtCraft team and community.", "ArtCraftチームとコミュニティによって制作。"), - ("Magenta / green", "マゼンタ / グリーン"), - ("Main shader", "メインシェーダー"), - ("Marble veins", "大理石の筋"), - ("Mask", "マスク"), - ("Mask Editor: Edge wear", "マスクエディター: エッジの摩耗"), - ("Mask value (gray)", "マスク値 (グレー)"), - ("Mask with height", "ハイトでマスク"), - ("MatFinish Grind", "MatFinish 研削"), - ("MatFinish Hammered", "MatFinish 槌目"), - ("MatFinish Raw", "MatFinish 未加工"), - ("MatFinish Sanded", "MatFinish サンディング"), - ("Material", "マテリアル"), - ("Material ball", "マテリアルボール"), - ("Material finish", "マテリアル仕上げ"), - ("Materials", "マテリアル"), - ("Maximum", "最大"), - ("Mesh fill", "メッシュ塗りつぶし"), - ("Mesh map: {map}", "メッシュマップ: {map}"), - ("Mesh maps", "メッシュマップ"), - ("Mesh maps baked", "メッシュマップをベイクしました"), - ("Meshes", "メッシュ"), - ("Metallic", "メタリック"), - ("Midtones", "中間調"), - ("Minimum", "最小"), - ("Minimum size (%)", "最小サイズ (%)"), - ("Missing (bake to create)", "なし (ベイクで作成)"), - ("Mixed AO", "ミックスAO"), - ("Mode", "モード"), - ("More in Assets > Alphas: click one, or drag it here", "アセット > アルファ にさらにあります: クリックするか、ここにドラッグ"), - ("Mosaic", "モザイク"), - ("Move down", "下へ移動"), - ("Move up", "上へ移動"), - ( - "Moves the surface by the height channel on a finer copy of the mesh, at the height to normal strength (viewport only: painting follows the base surface)", - "メッシュの細分化コピー上で、ハイトからノーマルへの強度でハイトチャンネルに沿って表面を動かします(ビューポートのみ:ペイントは元の表面に従います)", - ), - ("Multiply", "乗算"), - ("My smart materials", "マイ スマートマテリアル"), - ("Name", "名前"), - ("New project", "新規プロジェクト"), - ("New project...", "新規プロジェクト..."), - ("New template", "新規テンプレート"), - ("No GPU renderer available", "使用可能なGPUレンダラーがありません"), - ("No font on this system can show this language", "このシステムにはこの言語を表示できるフォントがありません"), - ( - "No outputs yet: add one above, then drag input maps onto its channels.", - "出力がまだありません: 上で追加し、入力マップをそのチャンネルにドラッグします。", - ), - ("No padding (passthrough)", "パディングなし (パススルー)"), - ("Noise amount", "ノイズ量"), - ("Noise scale", "ノイズスケール"), - ("None", "なし"), - ("Normal", "ノーマル"), - ("Normal DirectX", "ノーマル DirectX"), - ("Normal Invert", "ノーマル反転"), - ("Normal OpenGL", "ノーマル OpenGL"), - ("Normal from height", "ハイトからノーマル"), - ("Normal map combine", "ノーマルマップ合成"), - ("Normal map detail", "ノーマルマップ ディテール"), - ("Color space", "カラースペース"), - ("Normal map format", "ノーマルマップ形式"), - ("Normal map inverse detail", "ノーマルマップ 逆ディテール"), - ("Normal: painting uses the flat normal", "ノーマル: ペイントにはフラットな法線を使用"), - ( - "Not enough GPU memory to show texture set \"{name}\" fully: lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "GPU メモリが不足しているため、テクスチャセット「{name}」を完全には表示できません:設定でビューポートのテクスチャ解像度を下げてください。ペイントと書き出しには影響しません。", - ), - ( - "Not enough GPU memory to show {count} texture sets fully ({names}): lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "GPU メモリが不足しているため、{count} 個のテクスチャセット({names})を完全には表示できません:設定でビューポートのテクスチャ解像度を下げてください。ペイントと書き出しには影響しません。", - ), - ("Not exported: no source in this texture set", "エクスポートされません: このテクスチャセットにソースがありません"), - ("Not saved: {error}", "保存されていません: {error}"), - ("Off", "オフ"), - ("Offset", "オフセット"), - ("Offset right", "右オフセット"), - ("Offset up", "上オフセット"), - ("Offset {axis}", "オフセット {axis}"), - ( - "Offsets the textures by the height channel, at the height to normal strength", - "ハイトチャンネルに応じてテクスチャをオフセットします (強度はハイト→ノーマル強度)", - ), - ("On", "オン"), - ("Opacity", "不透明度"), - ("Open sample project...", "サンプルプロジェクトを開く..."), - ("Open...", "開く..."), - ("Opened {name}", "{name} を開きました"), - ( - "Optional channels add a clear coat (Coat weight, Coat roughness, Coat normal), sheen (Sheen weight, color, roughness), anisotropy (Anisotropy level, angle), subsurface scattering (Scattering weight) and transmission (Transmission).", - "オプションのチャンネルで、クリアコート (コートウェイト、コートラフネス、コートノーマル)、シーン (シーンウェイト、カラー、ラフネス)、異方性 (異方性レベル、角度)、サブサーフェススキャタリング (スキャタリングウェイト)、トランスミッション (トランスミッション) を追加できます。", - ), - ("Orbit", "オービット"), - ("Orthographic", "平行投影"), - ("Perspective", "透視投影"), - ("Output directory", "出力先フォルダー"), - ("Output high", "出力の上限"), - ("Output low", "出力の下限"), - ("Output template", "出力テンプレート"), - ("Output templates", "出力テンプレート"), - ("Overlay", "オーバーレイ"), - ("Overlay opacity", "オーバーレイの不透明度"), - ("PBR - Metallic Roughness (TextureCraft)", "PBR - メタリック/ラフネス (TextureCraft)"), - ("Pick color", "色を拾う"), - ("PNG image", "PNG画像"), - ("Padding", "パディング"), - ("Paint", "ペイント"), - ("Paint chips", "塗装の剥がれ"), - ("Paint on the mesh to edit the layer content.", "メッシュにペイントしてレイヤーのコンテンツを編集します。"), - ( - "Paint on the mesh to edit this mask. Use the Material tab's mask value for gray.", - "メッシュにペイントしてこのマスクを編集します。グレーには「マテリアル」タブのマスク値を使用します。", - ), - ("Paint with the current tool", "現在のツールでペイント"), - ( - "Painted layer pixels {pixels} MB, composited channels {composites} MB, compositing cache {cache} MB", - "ペイントしたレイヤーのピクセル {pixels} MB、合成済みチャンネル {composites} MB、合成キャッシュ {cache} MB", - ), - ("Painting", "ペイント"), - ("Pan", "パン"), - ("Parallax occlusion (height channel)", "視差オクルージョン (ハイトチャンネル)"), - ("Partial mask values follow the layer's height: high parts show first", "中間のマスク値はレイヤーのハイトに従い、高い部分から表示されます"), - ("Particle brush (slides down the surface)", "パーティクルブラシ (表面を滑り落ちる)"), - ("Particle brush: particles slide down the surface", "パーティクルブラシ: パーティクルが表面を滑り落ちます"), - ("Particles", "パーティクル"), - ("Passthrough", "通過"), - ("Paste as instance", "インスタンスとして貼り付け"), - ("Paste effect", "エフェクトを貼り付け"), - ("Paste layer(s)", "レイヤーを貼り付け"), - ("Path", "パス"), - ("Path trace on the processor instead of the graphics card (slower)", "グラフィックカードではなくプロセッサーでパストレース (低速)"), - ( - "Path: click adds a point, click the curve inserts one, drag moves it, Enter applies, Esc cancels", - "パス: クリックでポイントを追加、カーブをクリックで挿入、ドラッグで移動、Enterで適用、Escでキャンセル", - ), - ("Pattern scale", "パターンのスケール"), - ("Perlin noise", "パーリンノイズ"), - ("Pick focus in the viewport", "ビューポートでフォーカスを指定"), - ("Pin light", "ピンライト"), - ("Place on the surface", "表面に配置"), - ("Place path points on the mesh", "メッシュ上にパスのポイントを配置"), - ("Planar projection", "平面投影"), - ("Plane", "平面"), - ("Polygon fill", "ポリゴン塗りつぶし"), - ("Pores", "毛穴"), - ("Position", "位置"), - ("Position gradient", "位置グラデーション"), - ("Position jitter", "位置ジッター"), - ("Posterize", "ポスタリゼーション"), - ("Press a key...", "キーを押してください..."), - ("Procedurals", "プロシージャル"), - ("Project", "プロジェクト"), - ("Project Configuration...", "プロジェクト構成..."), - ("Project opened", "プロジェクトを開きました"), - ("Project template", "プロジェクトテンプレート"), - ("Projection", "投影"), - ("Projects and meshes", "プロジェクトとメッシュ"), - ("Properties", "プロパティ"), - ("Quarter", "1/4"), - ("Quick mask", "クイックマスク"), - ("Quit", "終了"), - ("Radius (texels at 2K)", "半径 (2K時のテクセル)"), - ("RENDERING", "レンダリング"), - ("Range", "範囲"), - ("Rebind any menu item, tool or command", "メニュー項目、ツール、コマンドのショートカットを再割り当て"), - ("Recent projects", "最近使ったプロジェクト"), - ( - "Records the stack up to this layer. Fill effects in masks (and fill layers) above can read it as a source.", - "このレイヤーまでのスタックを記録します。上にあるマスク内の塗りつぶしエフェクト (および塗りつぶしレイヤー) は、これをソースとして読み取れます。", - ), - ("Redo", "やり直し"), - ("Reimport mesh", "メッシュを再インポート"), - ("Remove", "削除"), - ("Remove channel", "チャンネルを削除"), - ("Remove effect", "エフェクトを削除"), - ("Remove last", "最後を削除"), - ("Remove layer", "レイヤーを削除"), - ("Remove layer(s)", "レイヤーを削除"), - ("Remove mask", "マスクを削除"), - ("Remove point", "ポイントを削除"), - ("Remove resource", "リソースを削除"), - ("Remove the shortcut", "ショートカットを削除"), - ("Remove this output", "この出力を削除"), - ("Remove unused resources...", "未使用のリソースを削除..."), - ("Rename the selected template", "選択中のテンプレートの名前を変更"), - ("Render on the CPU", "CPUでレンダリング"), - ("Rendering", "レンダリング"), - ("Rendering (path traced)", "レンダリング (パストレース)"), - ("Rendering on CPU: {n} / {max} samples, {s} s", "CPUでレンダリング中: {n} / {max} サンプル、{s} 秒"), - ("Rendering on GPU: {n} / {max} samples, {s} s", "GPUでレンダリング中: {n} / {max} サンプル、{s} 秒"), - ("Rendering, path traced", "パストレースによるレンダリング"), - ("Replace", "置換"), - ("Replace Color", "色の置き換え"), - ("Replacement color", "置き換え後の色"), - ("Report a bug...", "バグを報告..."), - ("Rescan the library folder", "ライブラリフォルダーを再スキャン"), - ("Reset", "リセット"), - ("Reset UI", "UIをリセット"), - ("Reset all", "すべてリセット"), - ("Reset to defaults", "デフォルトに戻す"), - ("Reset to {shortcut}", "{shortcut} にリセット"), - ("Resizing", "サイズ変更中"), - ("Restore every default shortcut", "すべてのショートカットをデフォルトに戻す"), - ("Return to this step", "このステップに戻る"), - ("Right-click a layer > Create smart material", "レイヤーを右クリック > スマートマテリアルを作成"), - ("Rotation", "回転"), - ("Rotation (degrees)", "回転 (度)"), - ("Roughness", "ラフネス"), - ("Roughness from glossiness", "グロッシネスからラフネス"), - ("Round", "円形"), - ("Rounded cube", "角丸立方体"), - ("Samples", "サンプル数"), - ("Saturation", "彩度"), - ("Save", "保存"), - ("Save UI Layout", "UIレイアウトを保存"), - ("Save a copy...", "コピーを保存..."), - ("Save as...", "名前を付けて保存..."), - ("Save current layout...", "現在のレイアウトを保存..."), - ("Save render...", "レンダリング結果を保存..."), - ("Save view as camera", "ビューをカメラとして保存"), - ("Saved UI layout {path}", "UIレイアウト {path} を保存しました"), - ("Saved {path}", "{path} を保存しました"), - ("Saving UI layouts to files is available in the desktop app", "UIレイアウトのファイル保存はデスクトップアプリで利用できます"), - ("Scale", "スケール"), - ("Scale / tiling", "スケール / タイリング"), - ("Scatter color", "スキャタリングカラー"), - ("Scatter radius", "スキャタリング半径"), - ("Scattering weight", "スキャタリングウェイト"), - ("Scratches", "引っかき傷"), - ("Screen", "スクリーン"), - ("Screenshot of the viewport", "ビューポートのスクリーンショット"), - ("Search", "検索"), - ("Search all assets", "すべてのアセットを検索"), - ("Search commands or keys", "コマンドまたはキーを検索"), - ("Seed", "シード"), - ("Select a layer", "レイヤーを選択"), - ("Select an output template", "出力テンプレートを選択"), - ("Select source", "ソースを選択"), - ("Select the mask (Alt+click: show it in the viewport)", "マスクを選択 (Alt+クリック: ビューポートに表示)"), - ("Select...", "選択..."), - ("Settings", "設定"), - ("Settings...", "設定..."), - ("Shader Settings", "シェーダー設定"), - ("Shader instance", "シェーダーインスタンス"), - ("Shadows", "シャドウ"), - ("Sharpen", "シャープ"), - ("Sheen color", "シーンカラー"), - ("Sheen color × weight", "シーンカラー × ウェイト"), - ("Sheen roughness", "シーンラフネス"), - ("Sheen weight", "シーンウェイト"), - ("Shift + wheel", "Shift + ホイール"), - ("Shortcuts list...", "ショートカット一覧..."), - ("Show on all parts", "すべてのパーツに表示"), - ("Show UV wireframe in the 2D view", "2DビューにUVワイヤーフレームを表示"), - ("Show entire mesh", "メッシュ全体を表示"), - ("Show log...", "ログを表示..."), - ("Show or hide the layer", "レイヤーの表示/非表示"), - ("Show or hide the texture set", "テクスチャセットの表示/非表示"), - ("Show wireframe in the 3D view", "3Dビューにワイヤーフレームを表示"), - ("Signed addition (AddSub)", "符号付き加算 (AddSub)"), - ("Size", "サイズ"), - ("Size in screen space", "スクリーン空間でのサイズ"), - ("Size jitter", "サイズジッター"), - ( - "Size of the textures the viewport shows: lower uses less GPU memory with large texture sets. Painting and export keep full resolution.", - "ビューポートに表示するテクスチャのサイズ。低くすると大きなテクスチャセットでも GPU メモリの使用量が減ります。ペイントと書き出しはフル解像度のままです。", - ), - ("Slope Blur", "スロープぼかし"), - ("Slope scale", "スロープスケール"), - ("Smart masks", "スマートマスク"), - ("Smart material saved to {path}", "スマートマテリアルを {path} に保存しました"), - ("Smart materials", "スマートマテリアル"), - ("Smudge", "スマッジ"), - ("Soft light", "ソフトライト"), - ("Softness", "柔らかさ"), - ("Source", "ソース"), - ("Source U {u} V {v}", "ソース U {u} V {v}"), - ("Spacing", "間隔"), - ("Specular", "スペキュラー"), - ("Specular level", "スペキュラーレベル"), - ("Sphere", "球"), - ("Spherical projection", "球面投影"), - ("Spray", "スプレー"), - ("Square", "正方形"), - ("Stamp depth", "スタンプの深度"), - ("Star", "星"), - ("Starting render...", "レンダリングを開始しています..."), - ("Stencil", "ステンシル"), - ("Steps", "ステップ数"), - ("Streaks", "筋"), - ("Strength", "強度"), - ("Stripes", "ストライプ"), - ("Stroke opacity", "ストロークの不透明度"), - ("Subsampling 2x2", "サブサンプリング 2x2"), - ("Subsampling 4x4", "サブサンプリング 4x4"), - ("Subsampling 8x8", "サブサンプリング 8x8"), - ("Subsurface scattering", "サブサーフェススキャタリング"), - ("Subtract", "減算"), - ("Tangent | Wrap", "タンジェント | ラップ"), - ("Temporal anti-aliasing (refines the 3D view while it is still)", "テンポラルアンチエイリアス (静止中に3Dビューを精細化)"), - ("Texture Sets", "テクスチャセット"), - ("Texture Set Settings", "テクスチャセット設定"), - ("Texture resolution", "テクスチャ解像度"), - ("Texture set channels", "テクスチャセットのチャンネル"), - ("Texture sets", "テクスチャセット"), - ("TextureCraft had to close:", "TextureCraft を終了する必要がありました:"), - ("TextureCraft PBR - Metallic Roughness", "TextureCraft PBR - メタリック/ラフネス"), - ("TextureCraft PBR - Specular Glossiness", "TextureCraft PBR - スペキュラー/グロッシネス"), - ("TextureCraft project", "TextureCraftプロジェクト"), - ("TextureCraft project or mesh", "TextureCraftプロジェクトまたはメッシュ"), - ("Textures", "テクスチャ"), - ("Textures embedded; for game engines and most viewers", "テクスチャ埋め込み。ゲームエンジンや多くのビューアー向け"), - ("Textures packaged; for USD tools and AR Quick Look", "テクスチャをパッケージ化。USDツールやAR Quick Look向け"), - ("The GPU couldn't render this scene: {error}", "GPUでこのシーンをレンダリングできませんでした: {error}"), - ("The bake worker stopped", "ベイク処理が停止しました"), - ("The eraser removes paint from the enabled channels.", "消しゴムは有効なチャンネルからペイントを消去します。"), - ("The first stroke sets the offset from the source.", "最初のストロークでソースからのオフセットが決まります。"), - ( - "The image's alpha cuts the decal's shape; faces turned away and surfaces beyond its depth stay clear.", - "画像のアルファでデカールの形状を切り抜きます。裏向きの面と奥行きを超えた面には投影されません。", - ), - ("The next click in the 3D view moves the decal there", "3Dビューで次にクリックした位置にデカールを移動"), - ("The resize worker stopped", "サイズ変更の処理が停止しました"), - ("Thickness", "厚み"), - ("Thin areas", "薄い領域"), - ("Threshold", "しきい値"), - ("Tile", "タイル"), - ("Tiles", "タイル"), - ("Tint", "色合い"), - ("Toggle mask", "マスクの切り替え"), - ("Tolerance", "許容値"), - ("Tone mapping", "トーンマッピング"), - ("Tools", "ツール"), - ("Torus", "トーラス"), - ("Transmission", "トランスミッション"), - ("Tri-planar projection", "トライプラナー投影"), - ("Triangle fill", "三角形塗りつぶし"), - ("UDIM plane", "UDIM平面"), - ("UDIM tiles painted by this texture set, each at the set's size", "このテクスチャセットがペイントするUDIMタイル (各タイルはセットのサイズ)"), - ("UI layout", "UIレイアウト"), - ("UI layout: {error}", "UIレイアウト: {error}"), - ("UI layouts", "UIレイアウト"), - ("UI {ms} ms", "UI {ms} ms"), - ("USD binary, textures alongside", "USDバイナリ、テクスチャは別ファイル"), - ("USD text, textures alongside", "USDテキスト、テクスチャは別ファイル"), - ("USDZ with textures", "USDZ (テクスチャ付き)"), - ("UV checker", "UVチェッカー"), - ("UV island fill", "UVアイランド塗りつぶし"), - ("UV transformations", "UV変換"), - ("UV projection", "UV投影"), - ("UV tiles", "UVタイル"), - ("UV tiles (UDIM)", "UVタイル (UDIM)"), - ("Undo", "元に戻す"), - ("Uniform value", "均一値"), - ("Use an equirectangular .hdr or .exr image as the environment", "正距円筒図法の .hdr または .exr 画像を環境として使用"), - ( - "Use the control channel or `texturecraft-cli render` for screenshots", - "スクリーンショットにはコントロールチャンネルまたは `texturecraft-cli render` を使用", - ), - ("Value", "値"), - ("Version {version}", "バージョン {version}"), - ("Version: {version} ({gpu})", "バージョン: {version} ({gpu})"), - ("View through this camera", "このカメラから見る"), - ("Viewer settings", "ビューアー設定"), - ("Viewport", "ビューポート"), - ("Viewport and brush (fixed)", "ビューポートとブラシ (固定)"), - ("Views", "ビュー"), - ("Vivid light", "ビビッドライト"), - ("Voronoi", "ボロノイ"), - ("Warp", "ワープ"), - ("Warp Directional", "方向ワープ"), - ("Wavefront OBJ with MTL, textures alongside", "Wavefront OBJ(MTL付き)、テクスチャは別ファイル"), - ( - "WebGPU isn't available in this browser, so TextureCraft runs on WebGL2: Rendering mode path traces on the CPU (slower) and large texture sets show at reduced resolution. A current Chrome, Edge or Safari has WebGPU.", - "このブラウザーでは WebGPU を利用できないため、TextureCraft は WebGL2 で動作しています。レンダリングモードのパストレーシングは CPU で行われ (低速)、大きなテクスチャセットは解像度を下げて表示されます。最新の Chrome、Edge、Safari は WebGPU に対応しています。", - ), - ("Wheel / Alt + RMB drag", "ホイール / Alt + 右ドラッグ"), - ("White", "白"), - ("Width", "幅"), - ("Width (texels at 2K)", "幅 (2K時のテクセル)"), - ("Window", "ウィンドウ"), - ("Wood grain", "木目"), - ("Works in texture space, like the blur: it does not cross UV seams.", "ぼかしと同様にテクスチャ空間で処理するため、UVシームをまたぎません。"), - ("World Space Normal", "ワールド空間ノーマル"), - ("Yellow / blue", "イエロー / ブルー"), - ("Zoom", "ズーム"), - ("a missing layer", "見つからないレイヤー"), - ("aniso", "異方性"), - ("aniso angle", "異方角"), - ("ao", "AO"), - ("coat", "コート"), - ("coat nrm", "コート法線"), - ("coat rough", "コートラフ"), - ("color", "カラー"), - ("emiss", "エミッシブ"), - ("glTF binary with textures", "glTFバイナリ (テクスチャ付き)"), - ("gloss", "グロス"), - ("height", "ハイト"), - ("metal", "メタル"), - ("min", "分"), - ("missing", "不明"), - ("missing source", "ソース不明"), - ("no GPU", "GPUなし"), - ("none", "なし"), - ("nrm", "法線"), - ("off", "オフ"), - ("op", "不透明"), - ("rough", "ラフ"), - ("scatter", "散乱"), - ("sheen", "シーン"), - ("sheen color", "シーン色"), - ("sheen rough", "シーンラフ"), - ("spec", "スペLv"), - ("specular", "スペキュラ"), - ("transm", "透過"), - ("{action} (undone)", "{action} (取り消し済み)"), - ( - "{file}: add above the selected layer (or drag it into the layer stack or onto the viewport)", - "{file}: 選択中のレイヤーの上に追加 (レイヤースタックやビューポートへのドラッグも可)", - ), - ("{name} copy", "{name} のコピー"), - ("{n} bits", "{n} ビット"), - ( - "{n} control points. Click the mesh (or the 2D view) to add points and drag them to adjust; click the first point to close the path. Enter paints it with the brush (a closed, filled path fills its inside), Esc cancels.", - "コントロールポイント {n} 個。メッシュ (または 2D ビュー) をクリックしてポイントを追加し、ドラッグして調整します。最初のポイントをクリックするとパスが閉じます。Enter でブラシを使ってペイントし (閉じて塗りつぶすパスは内側を塗りつぶします)、Esc でキャンセルします。", - ), - ("{n} items share a shortcut; the first one listed wins.", "{n} 個の項目が同じショートカットを共有しています。一覧の最初の項目が優先されます。"), - ("{pattern} (scale {scale}, seed {seed})", "{pattern} (スケール {scale}、シード {seed})"), - ("Template name", "テンプレート名"), - ("Save current project as template", "現在のプロジェクトをテンプレートとして保存"), - ("Distribution", "分布"), - ("Cosine", "コサイン"), - ("Uniform", "均一"), - ("Normalization", "正規化"), - // Settings › Interface: brightness and accent color. - ("Brightness", "明るさ"), - ("Dark", "ダーク"), - ("Medium dark", "ミディアムダーク"), - ("Medium light", "ミディアムライト"), - ("Light", "ライト"), - ("Accent color", "アクセントカラー"), - ("Copper", "カッパー"), - ("Coral", "コーラル"), - ("Blue", "ブルー"), - ("Violet", "バイオレット"), - ("Green", "グリーン"), - ("Amber", "アンバー"), - ("Pink", "ピンク"), - ("Minimize", "最小化"), - ("Maximize", "最大化"), - ("Restore", "元のサイズに戻す"), - ("Title bar", "タイトルバー"), - ("System title bar (applies on restart)", "システムのタイトルバー (再起動後に適用)"), - ( - "Use the operating system's window frame and buttons instead of TextureCraft's own title bar", - "TextureCraft 独自のタイトルバーの代わりに、OS のウィンドウ枠とボタンを使います", - ), - ("Brushes", "ブラシ一覧"), - ("My brushes", "マイブラシ"), - ("Use this brush (keeps its size)", "このブラシを使用(サイズはそのまま)"), - ("Brush name", "ブラシ名"), - ("Save current brush", "現在のブラシを保存"), - ("Start window", "スタートウィンドウ"), - ("Show at startup", "起動時に表示"), - ("Continue with the sample project", "サンプルプロジェクトで続ける"), - ("No recent projects yet", "最近のプロジェクトはまだありません"), - ("Text", "テキスト"), - ("Font", "フォント"), - ("Style", "スタイル"), - ("Use as brush alpha", "ブラシのアルファとして使用"), - ("Place as decal", "デカールとして配置"), - ("Click: turn this channel on or off. Alt+click: this channel only", "クリック: このチャンネルのオン/オフ。Alt+クリック: このチャンネルのみ"), - ("Show all", "すべて表示"), - ("Hide all", "すべて非表示"), - ("Invert show/hide", "表示/非表示を反転"), - ("Show or hide texture sets", "テクスチャセットの表示/非表示"), - ("Focus: show only the active texture set", "フォーカス: アクティブなテクスチャセットのみ表示"), - ("Unsaved changes", "未保存の変更"), - ("Don't save", "保存しない"), - ("Save the changes to {name} before closing?", "閉じる前に {name} の変更を保存しますか?"), - ("Radius", "半径"), - ("Remove skew correction", "スキュー補正を削除"), - ("Twill weave", "綾織り"), - ("Save the changes to {name} first?", "先に {name} の変更を保存しますか?"), - ( - "Paths stay editable: pick one to move its points or change its brush and material, and the sublayer repaints at once. Add paths with the Path tool.", - "パスは編集可能なままです。パスを選んで点を移動したりブラシやマテリアルを変えたりすると、サブレイヤーがすぐに描き直されます。パスはパスツールで追加します。", - ), - ("Import material...", "マテリアルを読み込む..."), - ("MaterialCraft material", "MaterialCraft マテリアル"), - ("Cooked at {size} px", "{size} px で計算済み"), - ("Preset", "プリセット"), - ("Re-cook", "再計算"), - ("Open in MaterialCraft", "MaterialCraft で開く"), - ( - "Opened in MaterialCraft: use File > Send to TextureCraft there to bring your changes back", - "MaterialCraft で開きました。変更を戻すには、そちらで「ファイル > TextureCraft に送る」を使います", - ), - ("Parameters change in the desktop app, with MaterialCraft installed", "パラメーターは MaterialCraft をインストールしたデスクトップ版で変更できます"), - ("Add High-Poly Meshes", "ハイポリメッシュを追加"), - ("All", "すべて"), - ("Apply Diffusion", "拡散を適用"), - ("Attenuation", "減衰"), - ("Auto Tonemapping", "自動トーンマッピング"), - ("Average Normals", "法線を平均化"), - ("BBox", "バウンディングボックス"), - ("BSphere", "バウンディングスフィア"), - ("Mesh Map Bakers", "メッシュマップベイカー"), - ("Common Settings", "共通設定"), - ("Mesh Map Settings", "メッシュマップ設定"), - ("Check All", "すべてチェック"), - ("No Parameters", "パラメーターなし"), - ("Bake Selected Textures ({n})", "選択したテクスチャをベイク ({n})"), - ("By Mesh Name", "メッシュ名で"), - ("Cage", "ケージ"), - ("Cage Scene", "ケージシーン"), - ("Cage Type", "ケージの種類"), - ("Color Generator", "カラー生成"), - ("Color Source", "カラーソース"), - ("Common Parameters", "共通パラメーター"), - ("Custom File", "カスタムファイル"), - ("Details", "ディテール"), - ("Dilation Width", "ダイレーション幅"), - ("Distance-Based", "距離ベース"), - ("Edge Contrast", "エッジコントラスト"), - ("Edge Distance", "エッジ距離"), - ("Edge Protection", "エッジ保護"), - ("Enable Seams", "シームを有効化"), - ("File ID", "ファイルID"), - ("Full Scene", "シーン全体"), - ("Generate from Mesh", "メッシュから生成"), - ("Generate from Normal Map", "法線マップから生成"), - ("Ground Plane", "グラウンドプレーン"), - ("Ground Plane Offset", "グラウンドプレーンのオフセット"), - ("High Poly Mesh Suffix", "ハイポリメッシュの接尾辞"), - ("High Poly Scene", "ハイポリシーン"), - ("High-Poly Parameters", "ハイポリパラメーター"), - ("Hue Shift", "色相シフト"), - ("Ignore Backface", "裏面を無視"), - ("Ignore Backface Suffix", "裏面を無視するサフィックス"), - ("Include in Bake", "ベイク対象に含める"), - ("Load Cage", "ケージを読み込む"), - ("Lock Output Size", "出力サイズをロック"), - ("Low Poly Mesh Suffix", "ローポリメッシュの接尾辞"), - ("Manual", "手動"), - ("Material Color", "マテリアルカラー"), - ("Max Frontal Distance", "前方最大距離"), - ("Max Occluder Distance", "遮蔽物の最大距離"), - ("Max Rear Distance", "後方最大距離"), - ("Mesh ID", "メッシュID"), - ("Method", "方式"), - ("Min Occluder Distance", "最小遮蔽距離"), - ("Never", "しない"), - ("No High-Poly Meshes", "ハイポリメッシュなし"), - ("Normalization Scale", "正規化スケール"), - ("Normalization Type", "正規化の種類"), - ("Only Same Mesh Name", "同じメッシュ名のみ"), - ("Output Size", "出力サイズ"), - ("Match", "マッチング"), - ("Skew Correction Method", "スキュー補正方法"), - ("Mesh Normals Based", "メッシュ法線ベース"), - ("Face Normals Based", "面法線ベース"), - ("Reset Painted Cage", "ペイントしたケージをリセット"), - ("Paint Cage", "ケージをペイント"), - ("Paint Skew Correction", "スキュー補正をペイント"), - ("Per Material", "マテリアルごと"), - ("Random", "ランダム"), - ("Relative to Bounding Box", "バウンディングボックスに相対"), - ("Relative to Low Mesh", "ローポリメッシュに相対"), - ("Relative to Min/Max", "最小値・最大値に相対"), - ("Relative to Ray Distances", "レイ距離に相対"), - ("Remove Cage", "ケージを削除"), - ("Remove Skew Correction", "スキュー補正を削除"), - ("Restore Defaults", "既定値に戻す"), - ("Return to Painting Mode", "ペイントモードに戻る"), - ("Sampling Radius", "サンプリング半径"), - ("Scaling Divisor", "スケーリング除数"), - ("Seams Intensity", "シームの強度"), - ("Secondary Rays", "二次レイ"), - ("Self Intersection", "自己交差"), - ("Self Occlusion", "自己遮蔽"), - ("Skew Correction", "スキュー補正"), - ("Smooth", "スムーズ"), - ("Spread Angle", "拡散角度"), - ("Submesh", "サブメッシュ"), - ("Use Low Poly Mesh as High Poly Mesh", "ローポリメッシュをハイポリメッシュとして使用"), - ("Value Bounds Max", "値の上限"), - ("Value Bounds Min", "値の下限"), - ("Vertex Color", "頂点カラー"), - ("Select the layer content", "レイヤーの内容を選択"), - ("Paint layer", "ペイントレイヤー"), - ("Fill layer", "塗りつぶしレイヤー"), - ("1 effect", "エフェクト 1 件"), - ("{count} effects", "エフェクト {count} 件"), - ("Mask effects", "マスクのエフェクト"), - ("Content effects", "コンテンツのエフェクト"), - ("Fold or unfold these effects", "これらのエフェクトを折りたたむ/展開する"), - ("Remove resolution override", "解像度の上書きを解除"), - ("Texture set resolution", "テクスチャセットの解像度"), - ("UV tile {tile} resolution", "UVタイル {tile} の解像度"), - ("Angle span", "角度範囲"), - ("Axis position", "軸の位置"), - ("Count", "数"), - ("Display", "表示"), - ("Hide while painting", "ペイント中は隠す"), - ("Manipulator size", "マニピュレーターのサイズ"), - ("Mirror symmetry", "ミラー対称"), - ("Radial settings", "放射の設定"), - ("Radial symmetry", "放射対称"), - ("Show axis", "軸を表示"), - ("Show axis position manipulator", "軸位置マニピュレーターを表示"), - ("Show cursor", "カーソルを表示"), - ("Show intersection", "交差部を表示"), - ("Show plane", "平面を表示"), - ("Symmetry", "対称"), - ("Symmetry color display", "対称の表示色"), - ("Symmetry settings", "対称の設定"), - ("Type", "種類"), - ("Advanced settings", "詳細設定"), - ("Import baked maps", "ベイク済みマップを読み込む"), - ("Name each file after its texture set, like Body_normal.png", "各ファイル名をテクスチャセット名で始めてください(例: Body_normal.png)"), - ("Add...", "追加..."), - ("Baked maps imported: {count}", "読み込んだベイク済みマップ: {count}"), - ("Not imported: {files}", "読み込まれなかったファイル: {files}"), - ("Baking Visualization", "ベイクの可視化"), - ("Show for Selected Texture Set Only", "選択したテクスチャセットのみ表示"), - ("High Definition Mesh (HP)", "ハイポリメッシュ (HP)"), - ("UV Seams", "UVシーム"), - ("Project Mesh (LP)", "投影メッシュ (LP)"), - ("Edges", "エッジ"), - ("Cavities", "くぼみ"), - ("Edges and cavities", "エッジとくぼみ"), - ("Raw curvature", "生の曲率"), - ("Detail sizes", "ディテールサイズ"), - ( - "Reads the curvature map as baked: changing the mode or a size turns detail sizes on.", - "曲率マップをベイクされたまま読み取ります。モードやサイズを変更するとディテールサイズが有効になります。", - ), - ( - "A click fills what is under it; a dragged rectangle fills what it selects as it grows", - "クリックでその下を塗りつぶし、ドラッグした矩形は広げるにつれて選択した範囲を塗りつぶします", - ), - ("Contained center: fill polygons whose center is in the rectangle", "中心を含む: 中心が矩形内にあるポリゴンを塗りつぶします"), - ( - "Editing the quick mask: fills paint where painting is allowed. Press U to finish.", - "クイックマスク編集中: 塗りつぶしでペイントを許可する範囲を塗ります。Uキーで終了します。", - ), - ("Fill mode", "塗りつぶしモード"), - ("Fill only polygons the camera sees (3D view)", "カメラから見えるポリゴンだけを塗りつぶします (3Dビュー)"), - ("Hit-test", "ヒットテスト"), - ("How a rectangle selects polygons", "矩形がポリゴンを選択する方法"), - ("Intersection: fill polygons the rectangle touches", "交差: 矩形が触れるポリゴンを塗りつぶします"), - ("Rectangle fill", "矩形塗りつぶし"), - ("Select a paint layer or a layer's mask to fill", "塗りつぶすペイントレイヤーまたはレイヤーマスクを選択してください"), - ("Selection mode", "選択モード"), - ( - "Triangle fills single triangles, Polygon whole quads and n-gons, Mesh the connected geometry, UV island the UV islands", - "三角形は個々の三角形、ポリゴンは四角形やNゴン全体、メッシュはつながったジオメトリ、UVアイランドはUVアイランドを塗りつぶします", - ), - ("Visible polygons only", "表示されているポリゴンのみ"), - ( - "\"{layer}\" can't be filled: select a paint layer or a layer's mask", - "「{layer}」は塗りつぶせません: ペイントレイヤーまたはレイヤーマスクを選択してください", - ), - ("The file dialog couldn't be shown: {error}", "ファイルダイアログを表示できませんでした: {error}"), - ("The project changed while the dialog was open, so nothing was done", "ダイアログを開いている間にプロジェクトが変更されたため、何も実行されませんでした"), - ("Cores kept for the UI", "UI用に確保するコア数"), - ("Max RAM while saving", "保存時のRAM上限"), - ( - "Saving uses the other cores and at most this share of the free RAM. At least one core always works.", - "保存は残りのコアと、空きRAMのこの割合までを使います。少なくとも1コアは常に動作します。", - ), - ("Max project size on open", "開くプロジェクトの最大サイズ"), - ( - "Maximum decompressed project data. Increase this limit to open larger projects.", - "展開後のプロジェクトデータの上限です。大きなプロジェクトを開くには、この上限を引き上げてください。", - ), -]; diff --git a/crates/ui-egui/src/i18n/ko.rs b/crates/ui-egui/src/i18n/ko.rs deleted file mode 100644 index 7f80b6be..00000000 --- a/crates/ui-egui/src/i18n/ko.rs +++ /dev/null @@ -1,1148 +0,0 @@ -//! Korean UI text: (English key, translation). Keys are the English strings passed to `tr`. - -pub const TABLE: &[(&str, &str)] = &[ - ("Baking {map} ({n}/{total})", "{map} 베이크 중 ({n}/{total})"), - ("Baking {map} ({n}/{total}), texture set {set} of {sets}", "{map} 베이크 중 ({n}/{total}), 텍스처 세트 {set}/{sets}"), - ("Follow Newest Map", "최신 맵 따라가기"), - ( - "Painting is paused while a bake is shown. Cancel the bake or wait for it to finish.", - "베이크를 표시하는 동안에는 페인팅이 일시 중지됩니다. 베이크를 취소하거나 끝날 때까지 기다리세요.", - ), - ( - "What the 3D view shows while the bake runs: the newest finished map, one finished map, or the material. Maps not baked yet show a neutral value.", - "베이크하는 동안 3D 뷰가 보여 주는 것: 가장 최근에 완료된 맵, 완료된 맵 중 선택한 하나, 또는 머티리얼. 아직 베이크되지 않은 맵은 중립 값으로 표시됩니다.", - ), - ( - "\"{layer}\" has no paint yet: the filter changes what you paint on it.", - "\"{layer}\"에 아직 페인트가 없습니다: 필터는 이 레이어에 칠하는 내용을 바꿉니다.", - ), - ("0 turns autosave off. Copies go to {folder}", "0으로 설정하면 자동 저장이 꺼집니다. 사본 저장 위치: {folder}"), - ("2D view only", "2D 뷰만"), - ("32 bits (float)", "32비트 (float)"), - ("3D mesh", "3D 메시"), - ("3D meshes", "3D 메시"), - ( - "3D texture painting: layers, masks, smart materials, mesh map baking and export.", - "3D 텍스처 페인팅: 레이어, 마스크, 스마트 머티리얼, 메시 맵 베이크 및 내보내기.", - ), - ("3D view only", "3D 뷰만"), - ("3D/2D views", "3D/2D 뷰"), - ( - "A folder blends its children (pass-through). Set per-channel opacity in the layer rows.", - "폴더는 하위 항목을 블렌딩합니다(통과). 채널별 불투명도는 레이어 행에서 설정합니다.", - ), - ("ACES filmic", "ACES 필믹"), - ("Ambient", "앰비언트"), - ("AO intensity", "AO 강도"), - ("About TextureCraft", "TextureCraft 정보"), - ("About TextureCraft...", "TextureCraft 정보..."), - ("Add an anchor point to a layer below to use its stack as a mask.", "아래 레이어에 앵커 포인트를 추가하면 해당 스택을 마스크로 사용할 수 있습니다."), - ("Add anchor point", "앵커 포인트 추가"), - ("Add as decal (view center)", "데칼로 추가 (뷰 중앙)"), - ("Add black mask", "검은색 마스크 추가"), - ("Add channel", "채널 추가"), - ("Add color", "색상 추가"), - ("Add compare mask", "비교 마스크 추가"), - ("Add effect", "이펙트 추가"), - ("Add fill", "채우기 추가"), - ("Add fill layer", "채우기 레이어 추가"), - ("Add filter", "필터 추가"), - ("Add folder", "폴더 추가"), - ("Add generator", "제너레이터 추가"), - ("Add levels", "레벨 추가"), - ("Add mask", "마스크 추가"), - ("Add mask with color selection", "색상 선택으로 마스크 추가"), - ("Add output", "출력 추가"), - ("Add paint", "페인트 추가"), - ("Add paint layer", "페인트 레이어 추가"), - ("Add smart material from the shelf", "셸프에서 스마트 머티리얼 추가"), - ("Add to the layer content", "레이어 콘텐츠에 추가"), - ("Add to the mask", "마스크에 추가"), - ("Add white mask", "흰색 마스크 추가"), - ("Adjustments", "조정"), - ( - "Aligned: the offset set by the first stroke is kept. V + click sets a new source.", - "정렬됨: 첫 번째 스트로크로 설정된 오프셋이 유지됩니다. V + 클릭으로 새 소스를 설정합니다.", - ), - ("Alignment", "정렬"), - ("Alignment and culling", "정렬 및 컬링"), - ("All layers", "모든 레이어"), - ("Alpha", "알파"), - ("Alphas", "알파"), - ("Also bound to {item} ({menu})", "{item}({menu})에도 지정됨"), - ("Alt + LMB drag", "Alt + 왼쪽 드래그"), - ("Always", "항상"), - ("Ambient Occlusion", "앰비언트 오클루전"), - ("Ambient occlusion", "앰비언트 오클루전"), - ("Amount", "양"), - ("Anchor point", "앵커 포인트"), - ("Anchor: {name}", "앵커: {name}"), - ("Anchor: {name} ({channel})", "앵커: {name} ({channel})"), - ("Angle", "각도"), - ("Angle (degrees)", "각도 (도)"), - ("Angle fade from", "각도 페이드 시작"), - ("Angle fade to", "각도 페이드 끝"), - ("Angle jitter", "각도 지터"), - ("Anisotropy angle", "이방성 각도"), - ("Anisotropy level", "이방성 레벨"), - ("Antialiasing", "안티앨리어싱"), - ("Aperture", "조리개"), - ("Apply", "적용"), - ("ArtCraft website...", "ArtCraft 웹사이트..."), - ("Assets", "에셋"), - ("Auto", "자동"), - ("Automatic (from the mesh UVs)", "자동 (메시 UV 기준)"), - ("Autosave every", "자동 저장 간격"), - ( - "Autosaves, smart materials, presets, templates and UI layouts go to the data folder. A new folder applies on restart; files already saved stay where they are.", - "자동 저장, 스마트 머티리얼, 프리셋, 템플릿과 UI 레이아웃은 데이터 폴더에 저장됩니다. 새 폴더는 다시 시작하면 적용되며, 이미 저장된 파일은 그대로 남습니다.", - ), - ("Axis", "축"), - ("Back to painting", "페인팅으로 돌아가기"), - ("Backface culling", "후면 컬링"), - ("Bake an ID map (F8) to pick colors from the mesh.", "메시에서 색을 고르려면 ID 맵을 베이크하세요 (F8)."), - ("Bake Mesh Maps", "메시 맵 베이크"), - ("Bake mesh maps", "메시 맵 베이크"), - ("Bake mesh maps (F8) for curvature, AO and thickness based generators.", "곡률, AO, 두께 기반 제너레이터를 사용하려면 메시 맵을 베이크하세요 (F8)."), - ("Baked Lighting", "베이크된 조명"), - ("Baking", "베이킹"), - ("Base color", "베이스 컬러"), - ( - "Base color is the diffuse color, Specular the F0 color and Glossiness 1 - roughness (add these channels in the texture set settings).", - "베이스 컬러는 디퓨즈 색상, 스페큘러는 F0 색상, 글로시니스는 1 - 러프니스입니다 (이 채널들은 텍스처 세트 설정에서 추가).", - ), - ("Base color, Metallic, Roughness and Specular level.", "베이스 컬러, 메탈릭, 러프니스, 스페큘러 레벨."), - ("Based on each texture set's size", "각 텍스처 세트 크기 기준"), - ("Basic settings", "기본 설정"), - ("Bent Normals", "벤트 노멀"), - ("Bevel", "베벨"), - ("Black", "검은색"), - ("Blending", "블렌딩"), - ("Blending mode of the displayed channel", "표시된 채널의 블렌딩 모드"), - ("Blur", "블러"), - ("Blur Directional", "방향성 블러"), - ("Blur and sharpen", "블러 및 선명하게"), - ("Bounces", "바운스"), - ("Bricks", "벽돌"), - ("Brush", "브러시"), - ("Brush size", "브러시 크기"), - ("Brush size down / up", "브러시 크기 축소 / 확대"), - ("Brushed lines", "브러시드 라인"), - ("Built-in (read-only): duplicate it to edit", "기본 제공 (읽기 전용): 편집하려면 복제하세요"), - ("Built-in templates are read-only: duplicate one to edit it", "기본 제공 템플릿은 읽기 전용입니다. 편집하려면 복제하세요"), - ("Built-in: {mesh}", "기본 제공: {mesh}"), - ("Cage: {name}", "케이지: {name}"), - ("Camera", "카메라"), - ("Colors", "색상"), - ("Go to camera 1", "카메라 1 보기"), - ("Go to camera 2", "카메라 2 보기"), - ("Go to camera 3", "카메라 3 보기"), - ("Go to camera 4", "카메라 4 보기"), - ("Go to camera 5", "카메라 5 보기"), - ("Go to camera 6", "카메라 6 보기"), - ("Go to camera 7", "카메라 7 보기"), - ("Go to camera 8", "카메라 8 보기"), - ("Go to camera 9", "카메라 9 보기"), - ("Camera settings", "카메라 설정"), - ("Cancel", "취소"), - ("Cancel the stroke", "스트로크 취소"), - ("Cell size (texels at 2K)", "셀 크기 (2K 기준 텍셀)"), - ("Cells", "셀"), - ("Channel", "채널"), - ("Channel source: uniform value, procedural, image or anchor", "채널 소스: 균일 값, 프로시저럴, 이미지 또는 앵커"), - ("Channels", "채널"), - ("Check for Updates...", "업데이트 확인..."), - ("Checker", "체커"), - ("Clamp", "클램프"), - ("Clear", "지우기"), - ("Clear mask", "마스크 지우기"), - ("Clear recent projects", "최근 프로젝트 지우기"), - ("Click a mesh part to show or hide the selected layer on it.", "메시 파트를 클릭하면 선택한 레이어를 해당 파트에서 표시하거나 숨깁니다."), - ("Click the mesh to pick its material into the brush", "메시를 클릭하여 해당 머티리얼을 브러시로 가져옵니다"), - ("Click the mesh to place the decal", "메시를 클릭하여 데칼 배치"), - ("Click, then press the new shortcut (Esc cancels)", "클릭한 후 새 단축키를 누르세요 (Esc로 취소)"), - ("Clone", "복제"), - ("Close", "닫기"), - ("Closed path", "닫힌 패스"), - ("Cloud", "구름"), - ("Clouds", "구름"), - ("Coat normal", "코트 노멀"), - ("Coat roughness", "코트 러프니스"), - ("Coat weight", "코트 가중치"), - ("Color", "색상"), - ("Color Balance", "색상 균형"), - ("Color burn", "색상 번"), - ("Color dodge", "색상 닷지"), - ( - "Color of the light that travels under the surface (each channel goes as far as its value)", - "표면 아래로 이동하는 빛의 색상입니다 (각 채널은 값만큼 멀리 이동)", - ), - ("Color picker", "색상 피커"), - ("Color selection", "색상 선택"), - ("Color to replace", "바꿀 색상"), - ("Colors near the first shift towards the second, keeping their shading.", "첫 번째 색상에 가까운 색상이 음영을 유지한 채 두 번째 색상으로 바뀝니다."), - ( - "Colors read as gray. Add a levels or blur effect above to shape the result.", - "색상은 회색으로 읽힙니다. 결과를 조정하려면 위에 레벨 또는 블러 이펙트를 추가하세요.", - ), - ("Combine with the layer's height", "레이어 높이와 결합"), - ("Compare mask", "비교 마스크"), - ("Compositing", "합성 중"), - ("Constant", "상수"), - ("Constants", "상수"), - ("Contrast", "대비"), - ("Contrast/Luminosity", "대비/광도"), - ("Converted maps", "변환된 맵"), - ("Copy RGB values", "RGB 값 복사"), - ("Copy effect", "이펙트 복사"), - ("Copy from", "복사 원본"), - ("Copy layer(s)", "레이어 복사"), - ("Copy the selected layer alone (its empty parts copy nothing)", "선택한 레이어만 복사합니다 (빈 부분은 복사되지 않음)"), - ("Copy to all texture sets", "모든 텍스처 세트에 복사"), - ("Copy what the texture set shows", "텍스처 세트에 표시되는 내용을 복사합니다"), - ("Couldn't encode the render", "렌더를 인코딩할 수 없습니다"), - ("Couldn't export textures: {error}", "텍스처를 내보낼 수 없습니다: {error}"), - ("Couldn't export the mesh: {error}", "메시를 내보낼 수 없습니다: {error}"), - ("Couldn't export the template: {error}", "템플릿을 내보낼 수 없습니다: {error}"), - ("Couldn't import {name}: {error}", "가져올 수 없습니다 ({name}): {error}"), - ("Couldn't open {name}: {error}", "열 수 없습니다 ({name}): {error}"), - ("Couldn't read the render back from the GPU", "GPU에서 렌더를 읽어올 수 없습니다"), - ("Couldn't save the render: {error}", "렌더를 저장할 수 없습니다: {error}"), - ("Couldn't save {name}: {error}", "저장할 수 없습니다 ({name}): {error}"), - ("Count per stamp", "스탬프당 개수"), - ("Crate", "상자"), - ("Create", "만들기"), - ("Create smart material", "스마트 머티리얼 만들기"), - ( - "Ctrl+right-drag in a view sets the size and hardness, Ctrl+left-drag the flow and angle.", - "뷰에서 Ctrl+오른쪽 드래그로 크기와 경도를, Ctrl+왼쪽 드래그로 흐름과 각도를 설정합니다.", - ), - ("Cube", "큐브"), - ("Current layer", "현재 레이어"), - ("Curvature", "곡률"), - ("Cut effect", "이펙트 잘라내기"), - ("Cut layer(s)", "레이어 잘라내기"), - ("Cyan / red", "녹청 / 빨강"), - ("Cylinder", "실린더"), - ("Cylindrical projection", "원통형 투영"), - ( - "Dark to light: the content's luminance picks a color along these stops.", - "어두운 색에서 밝은 색 순: 콘텐츠의 휘도에 따라 이 정지점을 따라 색상이 선택됩니다.", - ), - ("Darken (Min)", "어둡게 하기 (최소)"), - ("Data folder", "데이터 폴더"), - ("Decal", "데칼"), - ("Decal projection", "데칼 투영"), - ("Default", "기본값"), - ("Default camera", "기본 카메라"), - ("Delete the selected template", "선택한 템플릿을 삭제합니다"), - ("Delete this camera", "이 카메라를 삭제합니다"), - ("Deleted template \"{name}\"", "템플릿 \"{name}\" 삭제됨"), - ("Denoise", "노이즈 제거"), - ("Depth", "깊이"), - ("Depth of field", "피사계 심도"), - ("Depth of field (viewport and Rendering mode)", "피사계 심도 (뷰포트 및 렌더링 모드)"), - ("Depth of the sharp plane along the view (0: the orbit center)", "뷰 방향으로 초점 평면의 깊이 (0: 궤도 중심)"), - ("Details saved to {file}", "자세한 내용 저장 위치: {file}"), - ("Difference", "차이"), - ("Dilation + default background color", "확장 + 기본 배경색"), - ("Dilation + transparent", "확장 + 투명"), - ("Dilation infinite", "무한 확장"), - ("DirectX normal map", "DirectX 노멀 맵"), - ("Dirt", "먼지"), - ("Disable", "비활성화"), - ("Dismiss", "닫기"), - ("Displacement (height channel)", "디스플레이스먼트 (높이 채널)"), - ("Display Settings", "디스플레이 설정"), - ("Display material", "머티리얼 표시"), - ("Display next channel", "다음 채널 표시"), - ("Display next mesh map", "다음 메시 맵 표시"), - ("Display previous channel", "이전 채널 표시"), - ("Display previous mesh map", "이전 메시 맵 표시"), - ("Distance", "거리"), - ("Distort", "왜곡"), - ("Divide", "나누기"), - ("Document resolution", "문서 해상도"), - ("Documentation...", "문서..."), - ("Done on CPU: {n} / {max} samples, {s} s", "CPU에서 완료: 샘플 {n} / {max}, {s}초"), - ("Done on GPU: {n} / {max} samples, {s} s", "GPU에서 완료: 샘플 {n} / {max}, {s}초"), - ("Double-click to rename", "더블클릭하여 이름 변경"), - ("Download as", "다운로드 형식"), - ("Downloaded {name}", "다운로드됨: {name}"), - ("Drag onto an output channel", "출력 채널로 드래그하세요"), - ( - "Drag the frame to move the decal, a corner to scale it, the round handle to turn it", - "프레임을 드래그하여 데칼 이동, 모서리로 크기 조절, 둥근 핸들로 회전", - ), - ("Drags the layer stack's values along the stroke into the selected layer.", "스트로크를 따라 레이어 스택의 값을 선택한 레이어로 끌어옵니다."), - ( - "Draws {name} of texture set \"{set}\". Edits to the source show in every instance.", - "텍스처 세트 \"{set}\"의 {name}을(를) 그립니다. 원본을 편집하면 모든 인스턴스에 반영됩니다.", - ), - ("Drop an image from the Assets panel here to use it as this mesh map", "에셋 패널의 이미지를 여기에 놓으면 이 메시 맵으로 사용합니다"), - ("Dry streaks", "마른 붓자국"), - ("Duplicate effect", "이펙트 복제"), - ("Duplicate layer(s)", "레이어 복제"), - ("Duplicate the selected template", "선택한 템플릿을 복제합니다"), - ("Edge Detect", "가장자리 검출"), - ("Edit", "편집"), - ("Edit keyboard shortcuts...", "키보드 단축키 편집..."), - ("Edit quick mask", "퀵 마스크 편집"), - ("Editing quick mask: paint where painting is allowed (U to finish)", "퀵 마스크 편집 중: 페인팅을 허용할 영역을 칠하세요 (U로 완료)"), - ( - "Editing the quick mask: strokes paint where painting is allowed. Press U to finish.", - "퀵 마스크 편집 중: 스트로크로 페인팅을 허용할 영역을 칠합니다. U를 눌러 완료하세요.", - ), - ("Emissive", "이미시브"), - ("Enable or disable the effect", "이펙트를 켜거나 끕니다"), - ("Enable quick mask", "퀵 마스크 사용"), - ("Environment blur", "환경 블러"), - ("Environment exposure (EV)", "환경 노출 (EV)"), - ("Environment map", "환경 맵"), - ("Environment opacity", "환경 불투명도"), - ("Environment rotation", "환경 회전"), - ("Environment settings", "환경 설정"), - ("Environment: {name}", "환경: {name}"), - ("Environments", "환경"), - ("Eraser", "지우개"), - ("Exclusion", "제외"), - ("Expand or collapse the folder", "폴더를 펼치거나 접습니다"), - ("Export", "내보내기"), - ("Export Mesh...", "메시 내보내기..."), - ("Export Textures...", "텍스처 내보내기..."), - ("Export mesh", "메시 내보내기"), - ("Export template", "출력 템플릿"), - ("Export templates", "출력 템플릿"), - ("Export textures", "텍스처 내보내기"), - ("Export the selected template (.json)", "선택한 템플릿을 내보냅니다 (.json)"), - ("Exported mesh to {path}", "메시를 내보냈습니다: {path}"), - ("Exported template \"{name}\" to {path}", "템플릿 \"{name}\"을(를) 내보냈습니다: {path}"), - ("Exported {n} textures to {folder}", "텍스처 {n}개를 내보냈습니다: {folder}"), - ("F0 from specular level", "스페큘러 레벨에서 F0"), - ("Fabric weave", "직물 짜임"), - ("Field of view (deg)", "시야각 (도)"), - ("File", "파일"), - ("File name without extension; variables insert names", "확장자 없는 파일 이름입니다. 변수를 사용하면 이름이 삽입됩니다"), - ("File type", "파일 형식"), - ("Fill", "채우기"), - ("Fill the closed path (lasso)", "닫힌 패스를 채웁니다 (올가미)"), - ("Fill the path (close it first)", "패스를 채웁니다 (먼저 패스를 닫으세요)"), - ("Filter", "필터"), - ("Filter the remaining noise while keeping edges and texture detail", "가장자리와 텍스처 디테일을 유지하면서 남은 노이즈를 걸러냅니다"), - ("Filters", "필터"), - ("Fine noise", "미세 노이즈"), - ("Fingerprints", "지문"), - ("Enter a finite number", "유한한 숫자를 입력하세요"), - ("Double-click or press Enter to edit", "두 번 클릭하거나 Enter 키를 눌러 편집"), - ("Fit the input range to the histogram", "입력 범위를 히스토그램에 맞추기"), - ("Flatten layer", "레이어 병합"), - ("Flips the image's green channel, for normal maps made with Y pointing down", "이미지의 녹색 채널을 뒤집습니다 (Y가 아래를 향하도록 만든 노멀 맵용)"), - ("Flow", "흐름"), - ("Flow and opacity", "흐름 및 불투명도"), - ("Flow jitter", "흐름 지터"), - ("Focus distance", "초점 거리"), - ("Folder", "폴더"), - ("Folders", "폴더"), - ("Follow path", "패스 따라가기"), - ( - "For the whole project: how normal map images set as mesh maps are read (set them again after a change), and the default for export", - "프로젝트 전체: 메시 맵으로 지정한 노멀 맵 이미지를 읽는 방식(변경 후 다시 지정하세요)과 내보내기 기본값", - ), - ("Free and open source (MIT OR Apache-2.0), written in Rust.", "Rust로 작성된 무료 오픈 소스 소프트웨어입니다 (MIT OR Apache-2.0)."), - ("From template", "템플릿 기준"), - ("From template / project", "템플릿 / 프로젝트 기준"), - ("Full", "전체"), - ("GPU error: {error}", "GPU 오류: {error}"), - ("Geometry mask", "지오메트리 마스크"), - ( - "GGX specular with height-correlated Smith visibility, Lambert diffuse, split-sum image-based lighting with spherical-harmonics irradiance and horizon fading.", - "높이 상관 Smith 가시성을 사용하는 GGX 스페큘러, Lambert 디퓨즈, 구면 조화 함수 조도와 수평선 페이딩을 적용한 분할 합 이미지 기반 라이팅.", - ), - ("Gamma", "감마"), - ("General export parameters", "일반 내보내기 매개변수"), - ("General properties", "일반 속성"), - ("Generator", "제너레이터"), - ("Geometry and UVs only", "지오메트리와 UV만"), - ("Glossiness", "글로시니스"), - ("Glossiness from roughness", "러프니스에서 글로시니스"), - ("Glow", "글로우"), - ("Gradient", "그레이디언트"), - ("Gradient Map", "그레이디언트 맵"), - ("Gravity", "중력"), - ("Gray", "회색"), - ("Gray + A", "회색 + A"), - ("Gray 50%", "회색 50%"), - ("Grayscale", "회색조"), - ("Group layer(s)", "레이어 그룹화"), - ("Grunge", "그런지"), - ("HDR environments", "HDR 환경"), - ("High Pass", "하이 패스"), - ("HSL Perceptive", "HSL 지각"), - ("Half", "1/2"), - ("Hammered", "망치 자국"), - ("Hard light", "하드 라이트"), - ("Hardness", "경도"), - ("Height", "높이"), - ("Height offset", "높이 오프셋"), - ("Height to normal strength", "높이-노멀 변환 강도"), - ("Help", "도움말"), - ("Hide UI", "UI 숨기기"), - ("High", "높음"), - ("High poly: {name}", "하이 폴리: {name}"), - ("Highlights", "밝은 영역"), - ("Histogram Range", "히스토그램 범위"), - ("Histogram Scan", "히스토그램 스캔"), - ("Histogram Shift", "히스토그램 이동"), - ("History", "히스토리"), - ( - "Hold S: left-drag rotates, right-drag scales, middle-drag moves the stencil.", - "S 누른 채: 왼쪽 드래그로 회전, 오른쪽 드래그로 크기 조절, 가운데 드래그로 스텐실을 이동합니다.", - ), - ("Hold V and click the mesh to set the clone source", "V를 누른 채 메시를 클릭하여 복제 소스를 설정합니다"), - ( - "Hold V and click the mesh to set the source, then paint elsewhere to copy it.", - "V를 누른 채 메시를 클릭하여 소스를 설정한 다음, 다른 곳을 칠하면 복사됩니다.", - ), - ( - "How far light travels under the surface, as a fraction of the mesh size (where the Scattering weight channel is painted)", - "빛이 표면 아래로 이동하는 거리로, 메시 크기에 대한 비율입니다 (산란 가중치 채널이 칠해진 곳)", - ), - ( - "How strongly transmissive surfaces bend light (where the Transmission channel is painted): water 1.33, glass 1.5, diamond 2.42", - "투과 표면이 빛을 굴절시키는 정도입니다 (투과 채널이 칠해진 곳): 물 1.33, 유리 1.5, 다이아몬드 2.42", - ), - ("Hue shift (degrees)", "색조 이동 (도)"), - ("ID", "ID"), - ("Image: {name}", "이미지: {name}"), - ("Images", "이미지"), - ("Import HDR...", "HDR 가져오기..."), - ("Import a template (.json)", "템플릿을 가져옵니다 (.json)"), - ("Import an image (File > Import resources) to project it onto the mesh.", "메시에 투영할 이미지를 가져오세요 (파일 > 리소스 가져오기)."), - ("Import images to use them in fills and masks", "채우기와 마스크에 사용할 이미지를 가져옵니다"), - ("Import resources...", "리소스 가져오기..."), - ("Import MaterialX material...", "MaterialX 머티리얼 가져오기..."), - ("MaterialX materials", "MaterialX 머티리얼"), - ("Import...", "가져오기..."), - ("Imported template \"{name}\"", "템플릿 \"{name}\" 가져옴"), - ("Imported {name}", "가져옴: {name}"), - ("Index of refraction", "굴절률"), - ("Input high", "입력 상한"), - ("Input low", "입력 하한"), - ("Input maps", "입력 맵"), - ("Insert a variable", "변수 삽입"), - ("Instance", "인스턴스"), - ("Instantiate across texture sets", "모든 텍스처 세트에 인스턴스화"), - ("Intensity (texels at 2K)", "강도 (2K 기준 텍셀)"), - ("Interface", "인터페이스"), - ("Interface scale", "인터페이스 배율"), - ("Inverse Subtract", "역 빼기"), - ("Inverse divide", "역 나누기"), - ("Invert", "반전"), - ("Invert mask", "마스크 반전"), - ("Invert mask background", "마스크 배경 반전"), - ("Invert mask value", "마스크 값 반전"), - ("Invert quick mask", "퀵 마스크 반전"), - ("Jitters", "지터"), - ("Join the ArtCraft community on Discord", "Discord에서 ArtCraft 커뮤니티에 참여하세요"), - ("Join the community (Discord)...", "커뮤니티 참여 (Discord)..."), - ("Key light (shadow-casting light, direct only)", "키 라이트 (그림자를 드리우는 조명, 직접광만)"), - ("Keyboard", "키보드"), - ("Keyboard shortcuts", "키보드 단축키"), - ("Light azimuth (degrees)", "조명 방위각 (도)"), - ("Light elevation (degrees)", "조명 고도 (도)"), - ("Light intensity", "조명 강도"), - ("LMB", "왼쪽 버튼"), - ("Language", "언어"), - ("Layer mask", "레이어 마스크"), - ("Layer memory: {mb} MB", "레이어 메모리: {mb} MB"), - ("Layers", "레이어"), - ("Lazy mouse", "레이지 마우스"), - ("Lazy mouse distance", "레이지 마우스 거리"), - ("Leather grain", "가죽 결"), - ("Lens size: how quickly things blur away from the focus distance", "렌즈 크기: 초점 거리에서 멀어질수록 얼마나 빠르게 흐려지는지 결정합니다"), - ("Level", "레벨"), - ("Levels", "레벨"), - ("Lifetime (steps)", "수명 (단계)"), - ("Light / direction", "조명 / 방향"), - ("Lighten (Max)", "밝게 하기 (최대)"), - ("Lightness", "명도"), - ("Linear", "선형"), - ("Linear burn", "선형 번"), - ("Linear dodge (Add)", "선형 닷지 (추가)"), - ("Linear light", "선형 라이트"), - ("List of exports", "내보내기 목록"), - ("Load UI Layout", "UI 레이아웃 불러오기"), - ("Loaded UI layout {path}", "UI 레이아웃 불러옴: {path}"), - ("Log", "로그"), - ("Low", "낮음"), - ("Luminosity", "광도"), - ("MMB drag / Alt + MMB", "가운데 드래그 / Alt + 가운데 버튼"), - ("Made by the ArtCraft team and community.", "ArtCraft 팀과 커뮤니티가 만들었습니다."), - ("Magenta / green", "마젠타 / 녹색"), - ("Main shader", "메인 셰이더"), - ("Marble veins", "대리석 무늬"), - ("Mask", "마스크"), - ("Mask Editor: Edge wear", "마스크 에디터: 모서리 마모"), - ("Mask value (gray)", "마스크 값 (회색)"), - ("Mask with height", "높이로 마스크"), - ("MatFinish Grind", "마감 - 연마"), - ("MatFinish Hammered", "마감 - 망치 자국"), - ("MatFinish Raw", "마감 - 원재료"), - ("MatFinish Sanded", "마감 - 샌딩"), - ("Material", "머티리얼"), - ("Material ball", "머티리얼 볼"), - ("Material finish", "머티리얼 마감"), - ("Materials", "머티리얼"), - ("Maximum", "최대"), - ("Mesh fill", "메시 채우기"), - ("Mesh map: {map}", "메시 맵: {map}"), - ("Mesh maps", "메시 맵"), - ("Mesh maps baked", "메시 맵 베이크 완료"), - ("Meshes", "메시"), - ("Metallic", "메탈릭"), - ("Midtones", "중간 영역"), - ("Minimum", "최소"), - ("Minimum size (%)", "최소 크기 (%)"), - ("Missing (bake to create)", "없음 (베이크하여 생성)"), - ("Mixed AO", "혼합 AO"), - ("Mode", "모드"), - ("More in Assets > Alphas: click one, or drag it here", "에셋 > 알파에서 더 보기: 클릭하거나 여기로 드래그하세요"), - ("Mosaic", "모자이크"), - ("Move down", "아래로 이동"), - ("Move up", "위로 이동"), - ( - "Moves the surface by the height channel on a finer copy of the mesh, at the height to normal strength (viewport only: painting follows the base surface)", - "더 세밀한 메시 사본에서 높이를 노멀로 변환하는 강도로 높이 채널에 따라 표면을 이동합니다 (뷰포트 전용: 페인팅은 기본 표면을 따릅니다)", - ), - ("Multiply", "곱하기"), - ("My smart materials", "내 스마트 머티리얼"), - ("Name", "이름"), - ("New project", "새 프로젝트"), - ("New project...", "새 프로젝트..."), - ("New template", "새 템플릿"), - ("No GPU renderer available", "사용 가능한 GPU 렌더러가 없습니다"), - ("No font on this system can show this language", "이 시스템에는 이 언어를 표시할 수 있는 글꼴이 없습니다"), - ( - "No outputs yet: add one above, then drag input maps onto its channels.", - "아직 출력이 없습니다. 위에서 출력을 추가한 다음 입력 맵을 해당 채널로 드래그하세요.", - ), - ("No padding (passthrough)", "패딩 없음 (통과)"), - ("Noise amount", "노이즈 양"), - ("Noise scale", "노이즈 스케일"), - ("None", "없음"), - ("Normal", "노멀"), - ("Normal DirectX", "노멀 DirectX"), - ("Normal Invert", "노멀 반전"), - ("Normal OpenGL", "노멀 OpenGL"), - ("Normal from height", "높이에서 노멀"), - ("Normal map combine", "노멀 맵 결합"), - ("Normal map detail", "노멀 맵 디테일"), - ("Color space", "색 공간"), - ("Normal map format", "노멀 맵 형식"), - ("Normal map inverse detail", "노멀 맵 역 디테일"), - ("Normal: painting uses the flat normal", "노멀: 평면 노멀로 페인팅합니다"), - ( - "Not enough GPU memory to show texture set \"{name}\" fully: lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "GPU 메모리가 부족하여 텍스처 세트 \"{name}\"을(를) 모두 표시할 수 없습니다: 설정에서 뷰포트의 텍스처 해상도를 낮추세요. 페인팅과 내보내기에는 영향이 없습니다.", - ), - ( - "Not enough GPU memory to show {count} texture sets fully ({names}): lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "GPU 메모리가 부족하여 텍스처 세트 {count}개({names})를 모두 표시할 수 없습니다: 설정에서 뷰포트의 텍스처 해상도를 낮추세요. 페인팅과 내보내기에는 영향이 없습니다.", - ), - ("Not exported: no source in this texture set", "내보내지 않음: 이 텍스처 세트에 소스가 없습니다"), - ("Not saved: {error}", "저장되지 않음: {error}"), - ("Off", "끄기"), - ("Offset", "오프셋"), - ("Offset right", "오른쪽 오프셋"), - ("Offset up", "위쪽 오프셋"), - ("Offset {axis}", "오프셋 {axis}"), - ("Offsets the textures by the height channel, at the height to normal strength", "높이-노멀 변환 강도로 높이 채널에 따라 텍스처를 오프셋합니다"), - ("On", "켜기"), - ("Opacity", "불투명도"), - ("Open sample project...", "샘플 프로젝트 열기..."), - ("Open...", "열기..."), - ("Opened {name}", "열림: {name}"), - ( - "Optional channels add a clear coat (Coat weight, Coat roughness, Coat normal), sheen (Sheen weight, color, roughness), anisotropy (Anisotropy level, angle), subsurface scattering (Scattering weight) and transmission (Transmission).", - "선택 채널로 클리어 코트(코트 가중치, 코트 러프니스, 코트 노멀), 쉰(쉰 가중치, 색상, 러프니스), 이방성(이방성 레벨, 각도), 서브서피스 스캐터링(산란 가중치), 투과(투과)를 추가할 수 있습니다.", - ), - ("Orbit", "궤도 회전"), - ("Orthographic", "직교"), - ("Perspective", "원근"), - ("Output directory", "출력 디렉터리"), - ("Output high", "출력 상한"), - ("Output low", "출력 하한"), - ("Output template", "출력 템플릿"), - ("Output templates", "출력 템플릿"), - ("Overlay", "오버레이"), - ("Overlay opacity", "오버레이 불투명도"), - ("PBR - Metallic Roughness (TextureCraft)", "PBR - 메탈릭 러프니스 (TextureCraft)"), - ("Pick color", "색 고르기"), - ("PNG image", "PNG 이미지"), - ("Padding", "패딩"), - ("Paint", "페인트"), - ("Paint chips", "페인트 벗겨짐"), - ("Paint on the mesh to edit the layer content.", "메시에 칠하여 레이어 콘텐츠를 편집합니다."), - ( - "Paint on the mesh to edit this mask. Use the Material tab's mask value for gray.", - "메시에 칠하여 이 마스크를 편집합니다. 회색은 머티리얼 탭의 마스크 값을 사용하세요.", - ), - ("Paint with the current tool", "현재 도구로 페인팅"), - ( - "Painted layer pixels {pixels} MB, composited channels {composites} MB, compositing cache {cache} MB", - "페인트한 레이어 픽셀 {pixels} MB, 합성된 채널 {composites} MB, 합성 캐시 {cache} MB", - ), - ("Painting", "페인팅"), - ("Pan", "이동"), - ("Parallax occlusion (height channel)", "시차 오클루전 (높이 채널)"), - ("Partial mask values follow the layer's height: high parts show first", "부분 마스크 값이 레이어 높이를 따릅니다. 높은 부분이 먼저 나타납니다"), - ("Particle brush (slides down the surface)", "파티클 브러시 (표면을 따라 흘러내림)"), - ("Particle brush: particles slide down the surface", "파티클 브러시: 파티클이 표면을 따라 흘러내립니다"), - ("Particles", "파티클"), - ("Passthrough", "통과"), - ("Paste as instance", "인스턴스로 붙여넣기"), - ("Paste effect", "이펙트 붙여넣기"), - ("Paste layer(s)", "레이어 붙여넣기"), - ("Path", "패스"), - ("Path trace on the processor instead of the graphics card (slower)", "그래픽 카드 대신 프로세서에서 패스 트레이싱합니다 (더 느림)"), - ( - "Path: click adds a point, click the curve inserts one, drag moves it, Enter applies, Esc cancels", - "패스: 클릭으로 점 추가, 곡선 클릭으로 점 삽입, 드래그로 이동, Enter로 적용, Esc로 취소", - ), - ("Pattern scale", "패턴 스케일"), - ("Perlin noise", "펄린 노이즈"), - ("Pick focus in the viewport", "뷰포트에서 초점 선택"), - ("Pin light", "핀 라이트"), - ("Place on the surface", "표면에 배치"), - ("Place path points on the mesh", "메시에 패스 점을 배치하세요"), - ("Planar projection", "평면 투영"), - ("Plane", "평면"), - ("Polygon fill", "폴리곤 채우기"), - ("Pores", "모공"), - ("Position", "위치"), - ("Position gradient", "위치 그레이디언트"), - ("Position jitter", "위치 지터"), - ("Posterize", "포스터화"), - ("Press a key...", "키를 누르세요..."), - ("Procedurals", "프로시저럴"), - ("Project", "프로젝트"), - ("Project Configuration...", "프로젝트 구성..."), - ("Project opened", "프로젝트를 열었습니다"), - ("Project template", "프로젝트 템플릿"), - ("Projection", "투영"), - ("Projects and meshes", "프로젝트 및 메시"), - ("Properties", "속성"), - ("Quarter", "1/4"), - ("Quick mask", "퀵 마스크"), - ("Quit", "종료"), - ("Radius (texels at 2K)", "반경 (2K 기준 텍셀)"), - ("RENDERING", "렌더링"), - ("Range", "범위"), - ("Rebind any menu item, tool or command", "메뉴 항목, 도구 또는 명령의 단축키를 다시 지정합니다"), - ("Recent projects", "최근 프로젝트"), - ( - "Records the stack up to this layer. Fill effects in masks (and fill layers) above can read it as a source.", - "이 레이어까지의 스택을 기록합니다. 위쪽 마스크의 채우기 이펙트(및 채우기 레이어)에서 이를 소스로 읽을 수 있습니다.", - ), - ("Redo", "다시 실행"), - ("Reimport mesh", "메시 다시 가져오기"), - ("Remove", "제거"), - ("Remove channel", "채널 제거"), - ("Remove effect", "이펙트 제거"), - ("Remove last", "마지막 항목 제거"), - ("Remove layer", "레이어 제거"), - ("Remove layer(s)", "레이어 제거"), - ("Remove mask", "마스크 제거"), - ("Remove point", "점 제거"), - ("Remove resource", "리소스 제거"), - ("Remove the shortcut", "단축키를 제거합니다"), - ("Remove this output", "이 출력을 제거합니다"), - ("Remove unused resources...", "사용하지 않는 리소스 제거..."), - ("Rename the selected template", "선택한 템플릿의 이름을 변경합니다"), - ("Render on the CPU", "CPU에서 렌더링"), - ("Rendering", "렌더링"), - ("Rendering (path traced)", "렌더링 (패스 트레이싱)"), - ("Rendering on CPU: {n} / {max} samples, {s} s", "CPU에서 렌더링 중: 샘플 {n} / {max}, {s}초"), - ("Rendering on GPU: {n} / {max} samples, {s} s", "GPU에서 렌더링 중: 샘플 {n} / {max}, {s}초"), - ("Rendering, path traced", "렌더링, 패스 트레이싱"), - ("Replace", "대체"), - ("Replace Color", "색상 바꾸기"), - ("Replacement color", "대체 색상"), - ("Report a bug...", "버그 신고..."), - ("Rescan the library folder", "라이브러리 폴더를 다시 검색합니다"), - ("Reset", "초기화"), - ("Reset UI", "UI 초기화"), - ("Reset all", "모두 초기화"), - ("Reset to defaults", "기본값으로 초기화"), - ("Reset to {shortcut}", "{shortcut}(으)로 초기화"), - ("Resizing", "크기 조정 중"), - ("Restore every default shortcut", "모든 기본 단축키를 복원합니다"), - ("Return to this step", "이 단계로 돌아가기"), - ("Right-click a layer > Create smart material", "레이어 마우스 오른쪽 클릭 > 스마트 머티리얼 만들기"), - ("Rotation", "회전"), - ("Rotation (degrees)", "회전 (도)"), - ("Roughness", "러프니스"), - ("Roughness from glossiness", "글로시니스에서 러프니스"), - ("Round", "원형"), - ("Rounded cube", "둥근 큐브"), - ("Samples", "샘플"), - ("Saturation", "채도"), - ("Save", "저장"), - ("Save UI Layout", "UI 레이아웃 저장"), - ("Save a copy...", "사본 저장..."), - ("Save as...", "다른 이름으로 저장..."), - ("Save current layout...", "현재 레이아웃 저장..."), - ("Save render...", "렌더 저장..."), - ("Save view as camera", "뷰를 카메라로 저장"), - ("Saved UI layout {path}", "UI 레이아웃 저장됨: {path}"), - ("Saved {path}", "저장됨: {path}"), - ("Saving UI layouts to files is available in the desktop app", "UI 레이아웃을 파일로 저장하는 기능은 데스크톱 앱에서 사용할 수 있습니다"), - ("Scale", "스케일"), - ("Scale / tiling", "스케일 / 타일링"), - ("Scatter color", "산란 색상"), - ("Scatter radius", "산란 반경"), - ("Scattering weight", "산란 가중치"), - ("Scratches", "스크래치"), - ("Screen", "스크린"), - ("Screenshot of the viewport", "뷰포트 스크린샷"), - ("Search", "검색"), - ("Search all assets", "모든 에셋 검색"), - ("Search commands or keys", "명령 또는 키 검색"), - ("Seed", "시드"), - ("Select a layer", "레이어를 선택하세요"), - ("Select an output template", "출력 템플릿을 선택하세요"), - ("Select source", "소스 선택"), - ("Select the mask (Alt+click: show it in the viewport)", "마스크를 선택합니다 (Alt+클릭: 뷰포트에 표시)"), - ("Select...", "선택..."), - ("Settings", "설정"), - ("Settings...", "설정..."), - ("Shader Settings", "셰이더 설정"), - ("Shader instance", "셰이더 인스턴스"), - ("Shadows", "어두운 영역"), - ("Sharpen", "선명하게"), - ("Sheen color", "쉰 색상"), - ("Sheen color × weight", "쉰 색상 × 가중치"), - ("Sheen roughness", "쉰 러프니스"), - ("Sheen weight", "쉰 가중치"), - ("Shift + wheel", "Shift + 휠"), - ("Shortcuts list...", "단축키 목록..."), - ("Show on all parts", "모든 파트에 표시"), - ("Show UV wireframe in the 2D view", "2D 뷰에 UV 와이어프레임 표시"), - ("Show entire mesh", "전체 메시 표시"), - ("Show log...", "로그 표시..."), - ("Show or hide the layer", "레이어를 표시하거나 숨깁니다"), - ("Show or hide the texture set", "텍스처 세트를 표시하거나 숨깁니다"), - ("Show wireframe in the 3D view", "3D 뷰에 와이어프레임 표시"), - ("Signed addition (AddSub)", "부호 있는 더하기 (AddSub)"), - ("Size", "크기"), - ("Size in screen space", "화면 공간 기준 크기"), - ("Size jitter", "크기 지터"), - ( - "Size of the textures the viewport shows: lower uses less GPU memory with large texture sets. Painting and export keep full resolution.", - "뷰포트에 표시할 텍스처 크기입니다. 낮을수록 큰 텍스처 세트에서 GPU 메모리를 덜 사용합니다. 페인팅과 내보내기는 전체 해상도를 유지합니다.", - ), - ("Slope Blur", "슬로프 블러"), - ("Slope scale", "슬로프 스케일"), - ("Smart masks", "스마트 마스크"), - ("Smart material saved to {path}", "스마트 머티리얼 저장됨: {path}"), - ("Smart materials", "스마트 머티리얼"), - ("Smudge", "스머지"), - ("Soft light", "소프트 라이트"), - ("Softness", "부드러움"), - ("Source", "소스"), - ("Source U {u} V {v}", "소스 U {u} V {v}"), - ("Spacing", "간격"), - ("Specular", "스페큘러"), - ("Specular level", "스페큘러 레벨"), - ("Sphere", "구"), - ("Spherical projection", "구형 투영"), - ("Spray", "스프레이"), - ("Square", "사각형"), - ("Stamp depth", "스탬프 깊이"), - ("Star", "별"), - ("Starting render...", "렌더 시작 중..."), - ("Stencil", "스텐실"), - ("Steps", "단계"), - ("Streaks", "줄 얼룩"), - ("Strength", "강도"), - ("Stripes", "줄무늬"), - ("Stroke opacity", "스트로크 불투명도"), - ("Subsampling 2x2", "서브샘플링 2x2"), - ("Subsampling 4x4", "서브샘플링 4x4"), - ("Subsampling 8x8", "서브샘플링 8x8"), - ("Subsurface scattering", "서브서피스 스캐터링"), - ("Subtract", "빼기"), - ("Tangent | Wrap", "탄젠트 | 랩"), - ("Temporal anti-aliasing (refines the 3D view while it is still)", "시간적 안티앨리어싱 (3D 뷰가 정지해 있을 때 품질을 높임)"), - ("Texture Sets", "텍스처 세트"), - ("Texture Set Settings", "텍스처 세트 설정"), - ("Texture resolution", "텍스처 해상도"), - ("Texture set channels", "텍스처 세트 채널"), - ("Texture sets", "텍스처 세트"), - ("TextureCraft had to close:", "TextureCraft를 종료해야 했습니다:"), - ("TextureCraft PBR - Metallic Roughness", "TextureCraft PBR - 메탈릭 러프니스"), - ("TextureCraft PBR - Specular Glossiness", "TextureCraft PBR - 스페큘러 글로시니스"), - ("TextureCraft project", "TextureCraft 프로젝트"), - ("TextureCraft project or mesh", "TextureCraft 프로젝트 또는 메시"), - ("Textures", "텍스처"), - ("Textures embedded; for game engines and most viewers", "텍스처 포함, 게임 엔진 및 대부분의 뷰어용"), - ("Textures packaged; for USD tools and AR Quick Look", "텍스처 패키징, USD 도구 및 AR Quick Look용"), - ("The GPU couldn't render this scene: {error}", "GPU가 이 장면을 렌더링할 수 없습니다: {error}"), - ("The bake worker stopped", "베이크 작업자가 중지되었습니다"), - ("The eraser removes paint from the enabled channels.", "지우개는 활성화된 채널에서 페인트를 지웁니다."), - ("The first stroke sets the offset from the source.", "첫 번째 스트로크가 소스로부터의 오프셋을 설정합니다."), - ( - "The image's alpha cuts the decal's shape; faces turned away and surfaces beyond its depth stay clear.", - "이미지의 알파가 데칼의 모양을 잘라냅니다. 반대쪽을 향한 면과 깊이를 벗어난 표면에는 적용되지 않습니다.", - ), - ("The next click in the 3D view moves the decal there", "3D 뷰에서 다음에 클릭한 위치로 데칼이 이동합니다"), - ("The resize worker stopped", "크기 조정 작업이 중지되었습니다"), - ("Thickness", "두께"), - ("Thin areas", "얇은 영역"), - ("Threshold", "한계값"), - ("Tile", "타일"), - ("Tiles", "타일"), - ("Tint", "틴트"), - ("Toggle mask", "마스크 켜기/끄기"), - ("Tolerance", "허용 범위"), - ("Tone mapping", "톤 매핑"), - ("Tools", "도구"), - ("Torus", "토러스"), - ("Transmission", "투과"), - ("Tri-planar projection", "트라이플래너 투영"), - ("Triangle fill", "삼각형 채우기"), - ("UDIM plane", "UDIM 평면"), - ("UDIM tiles painted by this texture set, each at the set's size", "이 텍스처 세트가 칠하는 UDIM 타일이며, 각 타일은 세트 크기를 따릅니다"), - ("UI layout", "UI 레이아웃"), - ("UI layout: {error}", "UI 레이아웃: {error}"), - ("UI layouts", "UI 레이아웃"), - ("UI {ms} ms", "UI {ms} ms"), - ("USD binary, textures alongside", "USD 바이너리, 텍스처 별도"), - ("USD text, textures alongside", "USD 텍스트, 텍스처 별도"), - ("USDZ with textures", "텍스처 포함 USDZ"), - ("UV checker", "UV 체커"), - ("UV island fill", "UV 아일랜드 채우기"), - ("UV transformations", "UV 변환"), - ("UV projection", "UV 투영"), - ("UV tiles", "UV 타일"), - ("UV tiles (UDIM)", "UV 타일 (UDIM)"), - ("Undo", "실행 취소"), - ("Uniform value", "균일 값"), - ("Use an equirectangular .hdr or .exr image as the environment", "등장방형 .hdr 또는 .exr 이미지를 환경으로 사용합니다"), - ("Use the control channel or `texturecraft-cli render` for screenshots", "스크린샷은 제어 채널 또는 `texturecraft-cli render`를 사용하세요"), - ("Value", "값"), - ("Version {version}", "버전 {version}"), - ("Version: {version} ({gpu})", "버전: {version} ({gpu})"), - ("View through this camera", "이 카메라로 보기"), - ("Viewer settings", "뷰어 설정"), - ("Viewport", "뷰포트"), - ("Viewport and brush (fixed)", "뷰포트 및 브러시 (고정)"), - ("Views", "뷰"), - ("Vivid light", "선명한 라이트"), - ("Voronoi", "보로노이"), - ("Warp", "워프"), - ("Warp Directional", "방향성 워프"), - ("Wavefront OBJ with MTL, textures alongside", "Wavefront OBJ(MTL 포함), 텍스처는 옆에"), - ( - "WebGPU isn't available in this browser, so TextureCraft runs on WebGL2: Rendering mode path traces on the CPU (slower) and large texture sets show at reduced resolution. A current Chrome, Edge or Safari has WebGPU.", - "이 브라우저에서는 WebGPU를 사용할 수 없어 TextureCraft가 WebGL2로 실행됩니다. 렌더링 모드의 패스 트레이싱은 CPU에서 수행되며(더 느림), 큰 텍스처 세트는 낮은 해상도로 표시됩니다. 최신 Chrome, Edge, Safari는 WebGPU를 지원합니다.", - ), - ("Wheel / Alt + RMB drag", "휠 / Alt + 오른쪽 드래그"), - ("White", "흰색"), - ("Width", "너비"), - ("Width (texels at 2K)", "폭 (2K 기준 텍셀)"), - ("Window", "창"), - ("Wood grain", "나뭇결"), - ("Works in texture space, like the blur: it does not cross UV seams.", "블러와 마찬가지로 텍스처 공간에서 작동하므로 UV 경계를 넘지 않습니다."), - ("World Space Normal", "월드 공간 노멀"), - ("Yellow / blue", "노랑 / 파랑"), - ("Zoom", "확대/축소"), - ("a missing layer", "누락된 레이어"), - ("aniso", "이방성"), - ("aniso angle", "이방 각도"), - ("ao", "AO"), - ("coat", "코트"), - ("coat nrm", "코트 노멀"), - ("coat rough", "코트 러프"), - ("color", "컬러"), - ("emiss", "이미시브"), - ("glTF binary with textures", "텍스처 포함 glTF 바이너리"), - ("gloss", "글로시"), - ("height", "높이"), - ("metal", "메탈"), - ("min", "분"), - ("missing", "누락됨"), - ("missing source", "소스 누락"), - ("no GPU", "GPU 없음"), - ("none", "없음"), - ("nrm", "노멀"), - ("off", "끔"), - ("op", "불투명"), - ("rough", "러프"), - ("scatter", "산란"), - ("sheen", "쉰"), - ("sheen color", "쉰 컬러"), - ("sheen rough", "쉰 러프"), - ("spec", "스펙"), - ("specular", "스페큘러"), - ("transm", "투과"), - ("{action} (undone)", "{action} (실행 취소됨)"), - ( - "{file}: add above the selected layer (or drag it into the layer stack or onto the viewport)", - "{file}: 선택한 레이어 위에 추가합니다 (또는 레이어 스택이나 뷰포트로 드래그)", - ), - ("{name} copy", "{name} 사본"), - ("{n} bits", "{n}비트"), - ( - "{n} control points. Click the mesh (or the 2D view) to add points and drag them to adjust; click the first point to close the path. Enter paints it with the brush (a closed, filled path fills its inside), Esc cancels.", - "컨트롤 포인트 {n}개. 메시(또는 2D 뷰)를 클릭해 포인트를 추가하고 드래그해 조정합니다. 첫 포인트를 클릭하면 패스가 닫힙니다. Enter는 브러시로 패스를 페인트하고(닫히고 채워진 패스는 내부를 채움), Esc는 취소합니다.", - ), - ("{n} items share a shortcut; the first one listed wins.", "항목 {n}개가 같은 단축키를 사용합니다. 목록의 첫 번째 항목이 우선합니다."), - ("{pattern} (scale {scale}, seed {seed})", "{pattern} (스케일 {scale}, 시드 {seed})"), - ("Template name", "템플릿 이름"), - ("Save current project as template", "현재 프로젝트를 템플릿으로 저장"), - ("Distribution", "분포"), - ("Cosine", "코사인"), - ("Uniform", "균일"), - ("Normalization", "정규화"), - // Settings › Interface: brightness and accent color. - ("Brightness", "밝기"), - ("Dark", "어둡게"), - ("Medium dark", "약간 어둡게"), - ("Medium light", "약간 밝게"), - ("Light", "밝게"), - ("Accent color", "강조 색상"), - ("Copper", "구리"), - ("Coral", "코랄"), - ("Blue", "파랑"), - ("Violet", "보라"), - ("Green", "초록"), - ("Amber", "호박색"), - ("Pink", "분홍"), - ("Minimize", "최소화"), - ("Maximize", "최대화"), - ("Restore", "이전 크기로 복원"), - ("Title bar", "제목 표시줄"), - ("System title bar (applies on restart)", "시스템 제목 표시줄 (다시 시작하면 적용)"), - ( - "Use the operating system's window frame and buttons instead of TextureCraft's own title bar", - "TextureCraft 자체 제목 표시줄 대신 운영 체제의 창 테두리와 버튼을 사용합니다", - ), - ("Brushes", "브러시 목록"), - ("My brushes", "내 브러시"), - ("Use this brush (keeps its size)", "이 브러시 사용 (크기 유지)"), - ("Brush name", "브러시 이름"), - ("Save current brush", "현재 브러시 저장"), - ("Start window", "시작 창"), - ("Show at startup", "시작 시 표시"), - ("Continue with the sample project", "샘플 프로젝트로 계속"), - ("No recent projects yet", "아직 최근 프로젝트가 없습니다"), - ("Text", "텍스트"), - ("Font", "글꼴"), - ("Style", "스타일"), - ("Use as brush alpha", "브러시 알파로 사용"), - ("Place as decal", "데칼로 배치"), - ("Click: turn this channel on or off. Alt+click: this channel only", "클릭: 이 채널 켜기/끄기. Alt+클릭: 이 채널만"), - ("Show all", "모두 표시"), - ("Hide all", "모두 숨기기"), - ("Invert show/hide", "표시/숨기기 반전"), - ("Show or hide texture sets", "텍스처 세트 표시 또는 숨기기"), - ("Focus: show only the active texture set", "포커스: 활성 텍스처 세트만 표시"), - ("Unsaved changes", "저장되지 않은 변경 사항"), - ("Don't save", "저장 안 함"), - ("Save the changes to {name} before closing?", "닫기 전에 {name}의 변경 사항을 저장할까요?"), - ("Radius", "반경"), - ("Remove skew correction", "스큐 보정 제거"), - ("Twill weave", "능직"), - ("Save the changes to {name} first?", "먼저 {name}의 변경 사항을 저장할까요?"), - ( - "Paths stay editable: pick one to move its points or change its brush and material, and the sublayer repaints at once. Add paths with the Path tool.", - "패스는 계속 편집할 수 있습니다. 패스를 골라 점을 옮기거나 브러시와 재질을 바꾸면 하위 레이어가 바로 다시 칠해집니다. 패스는 패스 도구로 추가합니다.", - ), - ("Import material...", "머티리얼 가져오기..."), - ("MaterialCraft material", "MaterialCraft 머티리얼"), - ("Cooked at {size} px", "{size} px로 계산됨"), - ("Preset", "프리셋"), - ("Re-cook", "다시 계산"), - ("Open in MaterialCraft", "MaterialCraft에서 열기"), - ( - "Opened in MaterialCraft: use File > Send to TextureCraft there to bring your changes back", - "MaterialCraft에서 열었습니다. 변경 내용을 가져오려면 그곳에서 파일 > TextureCraft로 보내기를 사용하세요", - ), - ("Parameters change in the desktop app, with MaterialCraft installed", "매개변수는 MaterialCraft가 설치된 데스크톱 앱에서 바꿀 수 있습니다"), - ("Add High-Poly Meshes", "하이 폴리 메시 추가"), - ("All", "전체"), - ("Apply Diffusion", "확산 적용"), - ("Attenuation", "감쇠"), - ("Auto Tonemapping", "자동 톤 매핑"), - ("Average Normals", "노멀 평균화"), - ("BBox", "경계 상자"), - ("BSphere", "경계 구"), - ("Mesh Map Bakers", "메시 맵 베이커"), - ("Common Settings", "공통 설정"), - ("Mesh Map Settings", "메시 맵 설정"), - ("Check All", "모두 선택"), - ("No Parameters", "매개변수 없음"), - ("Bake Selected Textures ({n})", "선택한 텍스처 베이크 ({n})"), - ("By Mesh Name", "메시 이름으로"), - ("Cage", "케이지"), - ("Cage Scene", "케이지 장면"), - ("Cage Type", "케이지 유형"), - ("Color Generator", "색상 생성기"), - ("Color Source", "색상 소스"), - ("Common Parameters", "공통 매개변수"), - ("Custom File", "사용자 지정 파일"), - ("Details", "세부 사항"), - ("Dilation Width", "확장 폭"), - ("Distance-Based", "거리 기반"), - ("Edge Contrast", "가장자리 대비"), - ("Edge Distance", "가장자리 거리"), - ("Edge Protection", "가장자리 보호"), - ("Enable Seams", "이음새 활성화"), - ("File ID", "파일 ID"), - ("Full Scene", "전체 장면"), - ("Generate from Mesh", "메시에서 생성"), - ("Generate from Normal Map", "노멀 맵에서 생성"), - ("Ground Plane", "바닥 평면"), - ("Ground Plane Offset", "바닥 평면 오프셋"), - ("High Poly Mesh Suffix", "하이 폴리 메시 접미사"), - ("High Poly Scene", "하이 폴리 장면"), - ("High-Poly Parameters", "하이 폴리 매개변수"), - ("Hue Shift", "색조 이동"), - ("Ignore Backface", "뒷면 무시"), - ("Ignore Backface Suffix", "뒷면 무시 접미사"), - ("Include in Bake", "베이크에 포함"), - ("Load Cage", "케이지 불러오기"), - ("Lock Output Size", "출력 크기 잠금"), - ("Low Poly Mesh Suffix", "로우 폴리 메시 접미사"), - ("Manual", "수동"), - ("Material Color", "재질 색상"), - ("Max Frontal Distance", "최대 전방 거리"), - ("Max Occluder Distance", "최대 차폐물 거리"), - ("Max Rear Distance", "최대 후방 거리"), - ("Mesh ID", "메시 ID"), - ("Method", "방식"), - ("Min Occluder Distance", "최소 차폐 거리"), - ("Never", "안 함"), - ("No High-Poly Meshes", "하이 폴리 메시 없음"), - ("Normalization Scale", "정규화 범위"), - ("Normalization Type", "정규화 유형"), - ("Only Same Mesh Name", "같은 메시 이름만"), - ("Output Size", "출력 크기"), - ("Match", "일치"), - ("Skew Correction Method", "왜곡 보정 방법"), - ("Mesh Normals Based", "메시 법선 기반"), - ("Face Normals Based", "면 법선 기반"), - ("Reset Painted Cage", "페인트한 케이지 초기화"), - ("Paint Cage", "케이지 페인트"), - ("Paint Skew Correction", "기울기 보정 페인트"), - ("Per Material", "재질별"), - ("Random", "무작위"), - ("Relative to Bounding Box", "경계 상자 기준"), - ("Relative to Low Mesh", "로우 폴리 메시 기준"), - ("Relative to Min/Max", "최소/최대 기준"), - ("Relative to Ray Distances", "광선 거리 기준"), - ("Remove Cage", "케이지 제거"), - ("Remove Skew Correction", "스큐 보정 제거"), - ("Restore Defaults", "기본값 복원"), - ("Return to Painting Mode", "페인팅 모드로 돌아가기"), - ("Sampling Radius", "샘플링 반경"), - ("Scaling Divisor", "배율 나눗수"), - ("Seams Intensity", "이음새 강도"), - ("Secondary Rays", "보조 광선"), - ("Self Intersection", "자체 교차"), - ("Self Occlusion", "자기 차폐"), - ("Skew Correction", "스큐 보정"), - ("Smooth", "부드러움"), - ("Spread Angle", "확산 각도"), - ("Submesh", "하위 메시"), - ("Use Low Poly Mesh as High Poly Mesh", "로우 폴리 메시를 하이 폴리 메시로 사용"), - ("Value Bounds Max", "값 상한"), - ("Value Bounds Min", "값 하한"), - ("Vertex Color", "정점 색상"), - ("Select the layer content", "레이어 내용 선택"), - ("Paint layer", "페인트 레이어"), - ("Fill layer", "채우기 레이어"), - ("1 effect", "이펙트 1개"), - ("{count} effects", "이펙트 {count}개"), - ("Mask effects", "마스크 이펙트"), - ("Content effects", "콘텐츠 이펙트"), - ("Fold or unfold these effects", "이 이펙트 접기/펼치기"), - ("Remove resolution override", "해상도 재정의 제거"), - ("Texture set resolution", "텍스처 세트 해상도"), - ("UV tile {tile} resolution", "UV 타일 {tile} 해상도"), - ("Angle span", "각도 범위"), - ("Axis position", "축 위치"), - ("Count", "개수"), - ("Display", "표시"), - ("Hide while painting", "페인팅 중 숨기기"), - ("Manipulator size", "조작기 크기"), - ("Mirror symmetry", "미러 대칭"), - ("Radial settings", "방사형 설정"), - ("Radial symmetry", "방사형 대칭"), - ("Show axis", "축 표시"), - ("Show axis position manipulator", "축 위치 조작기 표시"), - ("Show cursor", "커서 표시"), - ("Show intersection", "교차선 표시"), - ("Show plane", "평면 표시"), - ("Symmetry", "대칭"), - ("Symmetry color display", "대칭 표시 색상"), - ("Symmetry settings", "대칭 설정"), - ("Type", "유형"), - ("Advanced settings", "고급 설정"), - ("Import baked maps", "베이크된 맵 가져오기"), - ("Name each file after its texture set, like Body_normal.png", "각 파일 이름을 텍스처 세트 이름으로 시작하세요(예: Body_normal.png)"), - ("Add...", "추가..."), - ("Baked maps imported: {count}", "가져온 베이크된 맵: {count}"), - ("Not imported: {files}", "가져오지 않음: {files}"), - ("Baking Visualization", "베이크 시각화"), - ("Show for Selected Texture Set Only", "선택한 텍스처 세트만 표시"), - ("High Definition Mesh (HP)", "하이 폴리 메시 (HP)"), - ("UV Seams", "UV 심"), - ("Project Mesh (LP)", "투영 메시 (LP)"), - ("Edges", "가장자리"), - ("Cavities", "오목한 부분"), - ("Edges and cavities", "가장자리와 오목한 부분"), - ("Raw curvature", "원시 곡률"), - ("Detail sizes", "디테일 크기"), - ( - "Reads the curvature map as baked: changing the mode or a size turns detail sizes on.", - "곡률 맵을 베이크된 그대로 읽습니다. 모드나 크기를 바꾸면 디테일 크기가 켜집니다.", - ), - ( - "A click fills what is under it; a dragged rectangle fills what it selects as it grows", - "클릭하면 아래에 있는 것을 채우고, 드래그한 사각형은 커지면서 선택한 것을 채웁니다", - ), - ("Contained center: fill polygons whose center is in the rectangle", "중심 포함: 중심이 사각형 안에 있는 폴리곤을 채웁니다"), - ( - "Editing the quick mask: fills paint where painting is allowed. Press U to finish.", - "퀵 마스크 편집 중: 채우기로 페인팅을 허용할 영역을 칠합니다. U를 눌러 완료하세요.", - ), - ("Fill mode", "채우기 모드"), - ("Fill only polygons the camera sees (3D view)", "카메라에 보이는 폴리곤만 채웁니다 (3D 뷰)"), - ("Hit-test", "히트 테스트"), - ("How a rectangle selects polygons", "사각형이 폴리곤을 선택하는 방식"), - ("Intersection: fill polygons the rectangle touches", "교차: 사각형에 닿는 폴리곤을 채웁니다"), - ("Rectangle fill", "사각형 채우기"), - ("Select a paint layer or a layer's mask to fill", "채울 페인트 레이어나 레이어 마스크를 선택하세요"), - ("Selection mode", "선택 모드"), - ( - "Triangle fills single triangles, Polygon whole quads and n-gons, Mesh the connected geometry, UV island the UV islands", - "삼각형은 개별 삼각형, 폴리곤은 사각형과 N각형 전체, 메시는 연결된 지오메트리, UV 아일랜드는 UV 아일랜드를 채웁니다", - ), - ("Visible polygons only", "보이는 폴리곤만"), - ("\"{layer}\" can't be filled: select a paint layer or a layer's mask", "\"{layer}\"은(는) 채울 수 없습니다: 페인트 레이어나 레이어 마스크를 선택하세요"), - ("The file dialog couldn't be shown: {error}", "파일 대화 상자를 표시할 수 없습니다: {error}"), - ("The project changed while the dialog was open, so nothing was done", "대화 상자가 열려 있는 동안 프로젝트가 변경되어 아무 작업도 수행하지 않았습니다"), - ("Cores kept for the UI", "UI용으로 남겨 둘 코어"), - ("Max RAM while saving", "저장 시 최대 RAM"), - ( - "Saving uses the other cores and at most this share of the free RAM. At least one core always works.", - "저장은 나머지 코어와 여유 RAM의 이 비율까지만 사용합니다. 최소 한 개의 코어는 항상 작동합니다.", - ), - ("Max project size on open", "열기 시 최대 프로젝트 크기"), - ( - "Maximum decompressed project data. Increase this limit to open larger projects.", - "압축 해제된 프로젝트 데이터의 최대 크기입니다. 더 큰 프로젝트를 열려면 이 한도를 높이세요.", - ), -]; diff --git a/crates/ui-egui/src/i18n/pt_br.rs b/crates/ui-egui/src/i18n/pt_br.rs deleted file mode 100644 index e5b023af..00000000 --- a/crates/ui-egui/src/i18n/pt_br.rs +++ /dev/null @@ -1,1166 +0,0 @@ -//! Brazilian Portuguese UI text: (English key, translation). Keys are the English strings passed to `tr`. - -pub const TABLE: &[(&str, &str)] = &[ - ("Baking {map} ({n}/{total})", "Fazendo o bake de {map} ({n}/{total})"), - ("Baking {map} ({n}/{total}), texture set {set} of {sets}", "Fazendo o bake de {map} ({n}/{total}), conjunto de texturas {set} de {sets}"), - ("Follow Newest Map", "Seguir o mapa mais recente"), - ( - "Painting is paused while a bake is shown. Cancel the bake or wait for it to finish.", - "A pintura fica em pausa enquanto um bake é exibido. Cancele o bake ou espere ele terminar.", - ), - ( - "What the 3D view shows while the bake runs: the newest finished map, one finished map, or the material. Maps not baked yet show a neutral value.", - "O que a vista 3D mostra durante o bake: o último mapa concluído, um mapa concluído à escolha ou o material. Mapas ainda não gerados mostram um valor neutro.", - ), - ("\"{layer}\" has no paint yet: the filter changes what you paint on it.", "\"{layer}\" ainda não tem pintura: o filtro altera o que você pintar nela."), - ("0 turns autosave off. Copies go to {folder}", "0 desativa o salvamento automático. As cópias vão para {folder}"), - ("2D view only", "Apenas vista 2D"), - ("32 bits (float)", "32 bits (float)"), - ("3D mesh", "Malha 3D"), - ("3D meshes", "Malhas 3D"), - ( - "3D texture painting: layers, masks, smart materials, mesh map baking and export.", - "Pintura de texturas 3D: camadas, máscaras, materiais inteligentes, bake de mapas de malha e exportação.", - ), - ("3D view only", "Apenas vista 3D"), - ("3D/2D views", "Vistas 3D/2D"), - ( - "A folder blends its children (pass-through). Set per-channel opacity in the layer rows.", - "Uma pasta mescla seus filhos (passagem). Defina a opacidade por canal nas linhas das camadas.", - ), - ("ACES filmic", "ACES fílmico"), - ("Ambient", "Ambiente"), - ("AO intensity", "Intensidade de AO"), - ("About TextureCraft", "Sobre o TextureCraft"), - ("About TextureCraft...", "Sobre o TextureCraft..."), - ( - "Add an anchor point to a layer below to use its stack as a mask.", - "Adicione um ponto de ancoragem a uma camada abaixo para usar sua pilha como máscara.", - ), - ("Add anchor point", "Adicionar ponto de ancoragem"), - ("Add as decal (view center)", "Adicionar como decalque (centro da vista)"), - ("Add black mask", "Adicionar máscara preta"), - ("Add channel", "Adicionar canal"), - ("Add color", "Adicionar cor"), - ("Add compare mask", "Adicionar máscara de comparação"), - ("Add effect", "Adicionar efeito"), - ("Add fill", "Adicionar preenchimento"), - ("Add fill layer", "Adicionar camada de preenchimento"), - ("Add filter", "Adicionar filtro"), - ("Add folder", "Adicionar pasta"), - ("Add generator", "Adicionar gerador"), - ("Add levels", "Adicionar níveis"), - ("Add mask", "Adicionar máscara"), - ("Add mask with color selection", "Adicionar máscara com seleção de cor"), - ("Add output", "Adicionar saída"), - ("Add paint", "Adicionar pintura"), - ("Add paint layer", "Adicionar camada de pintura"), - ("Add smart material from the shelf", "Adicionar material inteligente da prateleira"), - ("Add to the layer content", "Adicionar ao conteúdo da camada"), - ("Add to the mask", "Adicionar à máscara"), - ("Add white mask", "Adicionar máscara branca"), - ("Adjustments", "Ajustes"), - ( - "Aligned: the offset set by the first stroke is kept. V + click sets a new source.", - "Alinhado: o deslocamento definido pelo primeiro traço é mantido. V + clique define uma nova origem.", - ), - ("Alignment", "Alinhamento"), - ("Alignment and culling", "Alinhamento e descarte"), - ("All layers", "Todas as camadas"), - ("Alpha", "Alpha"), - ("Alphas", "Alphas"), - ("Also bound to {item} ({menu})", "Também atribuído a {item} ({menu})"), - ("Alt + LMB drag", "Alt + arrastar com botão esquerdo"), - ("Always", "Sempre"), - ("Ambient Occlusion", "Oclusão de ambiente"), - ("Ambient occlusion", "Oclusão de ambiente"), - ("Amount", "Quantidade"), - ("Anchor point", "Ponto de ancoragem"), - ("Anchor: {name}", "Âncora: {name}"), - ("Anchor: {name} ({channel})", "Âncora: {name} ({channel})"), - ("Angle", "Ângulo"), - ("Angle (degrees)", "Ângulo (graus)"), - ("Angle fade from", "Atenuação de ângulo a partir de"), - ("Angle fade to", "Atenuação de ângulo até"), - ("Angle jitter", "Variação de ângulo"), - ("Anisotropy angle", "Ângulo de anisotropia"), - ("Anisotropy level", "Nível de anisotropia"), - ("Antialiasing", "Antisserrilhamento"), - ("Aperture", "Abertura"), - ("Apply", "Aplicar"), - ("ArtCraft website...", "Site da ArtCraft..."), - ("Assets", "Recursos"), - ("Auto", "Auto"), - ("Automatic (from the mesh UVs)", "Automático (das UVs da malha)"), - ("Autosave every", "Salvar automaticamente a cada"), - ( - "Autosaves, smart materials, presets, templates and UI layouts go to the data folder. A new folder applies on restart; files already saved stay where they are.", - "Salvamentos automáticos, materiais inteligentes, predefinições, modelos e layouts da interface vão para a pasta de dados. Uma nova pasta vale após reiniciar; os arquivos já salvos ficam onde estão.", - ), - ("Axis", "Eixo"), - ("Back to painting", "Voltar à pintura"), - ("Backface culling", "Descarte de faces traseiras"), - ("Bake an ID map (F8) to pick colors from the mesh.", "Faça o bake de um mapa de ID (F8) para coletar cores da malha."), - ("Bake Mesh Maps", "Bake de mapas de malha"), - ("Bake mesh maps", "Fazer bake dos mapas de malha"), - ( - "Bake mesh maps (F8) for curvature, AO and thickness based generators.", - "Faça o bake dos mapas de malha (F8) para geradores baseados em curvatura, AO e espessura.", - ), - ("Baked Lighting", "Iluminação pré-calculada"), - ("Baking", "Bake"), - ("Base color", "Cor base"), - ( - "Base color is the diffuse color, Specular the F0 color and Glossiness 1 - roughness (add these channels in the texture set settings).", - "Cor base é a cor difusa, Especular é a cor F0 e Brilho é 1 - rugosidade (adicione esses canais nas configurações do conjunto de texturas).", - ), - ("Base color, Metallic, Roughness and Specular level.", "Cor base, Metálico, Rugosidade e Nível especular."), - ("Based on each texture set's size", "Com base no tamanho de cada conjunto de texturas"), - ("Basic settings", "Configurações básicas"), - ("Bent Normals", "Normais curvadas"), - ("Bevel", "Chanfro"), - ("Black", "Preto"), - ("Blending", "Mesclagem"), - ("Blending mode of the displayed channel", "Modo de mesclagem do canal exibido"), - ("Blur", "Desfoque"), - ("Blur Directional", "Desfoque direcional"), - ("Blur and sharpen", "Desfoque e nitidez"), - ("Bounces", "Rebatimentos"), - ("Bricks", "Tijolos"), - ("Brush", "Pincel"), - ("Brush size", "Tamanho do pincel"), - ("Brush size down / up", "Diminuir / aumentar o pincel"), - ("Brushed lines", "Linhas escovadas"), - ("Built-in (read-only): duplicate it to edit", "Embutido (somente leitura): duplique-o para editar"), - ("Built-in templates are read-only: duplicate one to edit it", "Os modelos embutidos são somente leitura: duplique um para editá-lo"), - ("Built-in: {mesh}", "Embutida: {mesh}"), - ("Cage: {name}", "Cage: {name}"), - ("Camera", "Câmera"), - ("Colors", "Cores"), - ("Go to camera 1", "Ir para a câmera 1"), - ("Go to camera 2", "Ir para a câmera 2"), - ("Go to camera 3", "Ir para a câmera 3"), - ("Go to camera 4", "Ir para a câmera 4"), - ("Go to camera 5", "Ir para a câmera 5"), - ("Go to camera 6", "Ir para a câmera 6"), - ("Go to camera 7", "Ir para a câmera 7"), - ("Go to camera 8", "Ir para a câmera 8"), - ("Go to camera 9", "Ir para a câmera 9"), - ("Camera settings", "Configurações da câmera"), - ("Cancel", "Cancelar"), - ("Cancel the stroke", "Cancelar o traço"), - ("Cell size (texels at 2K)", "Tamanho da célula (texels em 2K)"), - ("Cells", "Células"), - ("Channel", "Canal"), - ("Channel source: uniform value, procedural, image or anchor", "Origem do canal: valor uniforme, procedural, imagem ou âncora"), - ("Channels", "Canais"), - ("Check for Updates...", "Verificar atualizações..."), - ("Checker", "Xadrez"), - ("Clamp", "Limitar"), - ("Clear", "Limpar"), - ("Clear mask", "Limpar máscara"), - ("Clear recent projects", "Limpar projetos recentes"), - ("Click a mesh part to show or hide the selected layer on it.", "Clique em uma parte da malha para mostrar ou ocultar nela a camada selecionada."), - ("Click the mesh to pick its material into the brush", "Clique na malha para capturar o material dela no pincel"), - ("Click the mesh to place the decal", "Clique na malha para posicionar o decalque"), - ("Click, then press the new shortcut (Esc cancels)", "Clique e pressione o novo atalho (Esc cancela)"), - ("Clone", "Clonar"), - ("Close", "Fechar"), - ("Closed path", "Caminho fechado"), - ("Cloud", "Nuvem"), - ("Clouds", "Nuvens"), - ("Coat normal", "Normal do verniz"), - ("Coat roughness", "Rugosidade do verniz"), - ("Coat weight", "Peso do verniz"), - ("Color", "Cor"), - ("Color Balance", "Equilíbrio de cores"), - ("Color burn", "Superexposição de cor"), - ("Color dodge", "Subexposição de cor"), - ( - "Color of the light that travels under the surface (each channel goes as far as its value)", - "Cor da luz que viaja sob a superfície (cada canal vai tão longe quanto seu valor)", - ), - ("Color picker", "Conta-gotas"), - ("Color selection", "Seleção de cor"), - ("Color to replace", "Cor a substituir"), - ("Colors near the first shift towards the second, keeping their shading.", "As cores próximas da primeira passam para a segunda, mantendo o sombreamento."), - ( - "Colors read as gray. Add a levels or blur effect above to shape the result.", - "As cores são lidas como cinza. Adicione um efeito de níveis ou desfoque acima para ajustar o resultado.", - ), - ("Combine with the layer's height", "Combinar com a altura da camada"), - ("Compare mask", "Máscara de comparação"), - ("Compositing", "Composição"), - ("Constant", "Constante"), - ("Constants", "Constantes"), - ("Contrast", "Contraste"), - ("Contrast/Luminosity", "Contraste/Luminosidade"), - ("Converted maps", "Mapas convertidos"), - ("Copy RGB values", "Copiar os valores RGB"), - ("Copy effect", "Copiar efeito"), - ("Copy from", "Copiar de"), - ("Copy layer(s)", "Copiar camada(s)"), - ("Copy the selected layer alone (its empty parts copy nothing)", "Copiar apenas a camada selecionada (suas partes vazias não copiam nada)"), - ("Copy to all texture sets", "Copiar para todos os conjuntos de texturas"), - ("Copy what the texture set shows", "Copiar o que o conjunto de texturas exibe"), - ("Couldn't encode the render", "Não foi possível codificar a renderização"), - ("Couldn't export textures: {error}", "Não foi possível exportar as texturas: {error}"), - ("Couldn't export the mesh: {error}", "Não foi possível exportar a malha: {error}"), - ("Couldn't export the template: {error}", "Não foi possível exportar o modelo: {error}"), - ("Couldn't import {name}: {error}", "Não foi possível importar {name}: {error}"), - ("Couldn't open {name}: {error}", "Não foi possível abrir {name}: {error}"), - ("Couldn't read the render back from the GPU", "Não foi possível ler a renderização de volta da GPU"), - ("Couldn't save the render: {error}", "Não foi possível salvar a renderização: {error}"), - ("Couldn't save {name}: {error}", "Não foi possível salvar {name}: {error}"), - ("Count per stamp", "Quantidade por carimbo"), - ("Crate", "Caixote"), - ("Create", "Criar"), - ("Create smart material", "Criar material inteligente"), - ( - "Ctrl+right-drag in a view sets the size and hardness, Ctrl+left-drag the flow and angle.", - "Ctrl+arrastar com botão direito em uma vista ajusta o tamanho e a dureza; Ctrl+arrastar com botão esquerdo, o fluxo e o ângulo.", - ), - ("Cube", "Cubo"), - ("Current layer", "Camada atual"), - ("Curvature", "Curvatura"), - ("Cut effect", "Recortar efeito"), - ("Cut layer(s)", "Recortar camada(s)"), - ("Cyan / red", "Ciano / vermelho"), - ("Cylinder", "Cilindro"), - ("Cylindrical projection", "Projeção cilíndrica"), - ( - "Dark to light: the content's luminance picks a color along these stops.", - "Do escuro ao claro: a luminância do conteúdo escolhe uma cor ao longo destas paradas.", - ), - ("Darken (Min)", "Escurecer (Mín)"), - ("Data folder", "Pasta de dados"), - ("Decal", "Decalque"), - ("Decal projection", "Projeção de decalque"), - ("Default", "Padrão"), - ("Default camera", "Câmera padrão"), - ("Delete the selected template", "Excluir o modelo selecionado"), - ("Delete this camera", "Excluir esta câmera"), - ("Deleted template \"{name}\"", "Modelo \"{name}\" excluído"), - ("Denoise", "Remover ruído"), - ("Depth", "Profundidade"), - ("Depth of field", "Profundidade de campo"), - ("Depth of field (viewport and Rendering mode)", "Profundidade de campo (viewport e modo Renderização)"), - ("Depth of the sharp plane along the view (0: the orbit center)", "Profundidade do plano nítido ao longo da vista (0: o centro de órbita)"), - ("Details saved to {file}", "Detalhes salvos em {file}"), - ("Difference", "Diferença"), - ("Dilation + default background color", "Dilatação + cor de fundo padrão"), - ("Dilation + transparent", "Dilatação + transparente"), - ("Dilation infinite", "Dilatação infinita"), - ("DirectX normal map", "Mapa normal DirectX"), - ("Dirt", "Sujeira"), - ("Disable", "Desativado"), - ("Dismiss", "Fechar"), - ("Displacement (height channel)", "Deslocamento (canal de altura)"), - ("Display Settings", "Configurações de exibição"), - ("Display material", "Exibir material"), - ("Display next channel", "Exibir próximo canal"), - ("Display next mesh map", "Exibir próximo mapa de malha"), - ("Display previous channel", "Exibir canal anterior"), - ("Display previous mesh map", "Exibir mapa de malha anterior"), - ("Distance", "Distância"), - ("Distort", "Distorcer"), - ("Divide", "Divisão"), - ("Document resolution", "Resolução do documento"), - ("Documentation...", "Documentação..."), - ("Done on CPU: {n} / {max} samples, {s} s", "Concluído na CPU: {n} / {max} amostras, {s} s"), - ("Done on GPU: {n} / {max} samples, {s} s", "Concluído na GPU: {n} / {max} amostras, {s} s"), - ("Double-click to rename", "Clique duas vezes para renomear"), - ("Download as", "Baixar como"), - ("Downloaded {name}", "{name} baixado"), - ("Drag onto an output channel", "Arraste para um canal de saída"), - ( - "Drags the layer stack's values along the stroke into the selected layer.", - "Arrasta os valores da pilha de camadas ao longo do traço para a camada selecionada.", - ), - ( - "Draws {name} of texture set \"{set}\". Edits to the source show in every instance.", - "Desenha {name} do conjunto de texturas \"{set}\". As edições na origem aparecem em todas as instâncias.", - ), - ( - "Drag the frame to move the decal, a corner to scale it, the round handle to turn it", - "Arraste o quadro para mover o decalque, um canto para redimensioná-lo e a alça redonda para girá-lo", - ), - ("Drop an image from the Assets panel here to use it as this mesh map", "Solte aqui uma imagem do painel Recursos para usá-la como este mapa de malha"), - ("Dry streaks", "Estrias secas"), - ("Duplicate effect", "Duplicar efeito"), - ("Duplicate layer(s)", "Duplicar camada(s)"), - ("Duplicate the selected template", "Duplicar o modelo selecionado"), - ("Edge Detect", "Detecção de bordas"), - ("Edit", "Editar"), - ("Edit keyboard shortcuts...", "Editar atalhos de teclado..."), - ("Edit quick mask", "Editar máscara rápida"), - ("Editing quick mask: paint where painting is allowed (U to finish)", "Editando a máscara rápida: pinte onde a pintura é permitida (U para concluir)"), - ( - "Editing the quick mask: strokes paint where painting is allowed. Press U to finish.", - "Editando a máscara rápida: os traços pintam onde a pintura é permitida. Pressione U para concluir.", - ), - ("Emissive", "Emissivo"), - ("Enable or disable the effect", "Ativar ou desativar o efeito"), - ("Enable quick mask", "Ativar máscara rápida"), - ("Environment blur", "Desfoque do ambiente"), - ("Environment exposure (EV)", "Exposição do ambiente (EV)"), - ("Environment map", "Mapa de ambiente"), - ("Environment opacity", "Opacidade do ambiente"), - ("Environment rotation", "Rotação do ambiente"), - ("Environment settings", "Configurações do ambiente"), - ("Environment: {name}", "Ambiente: {name}"), - ("Environments", "Ambientes"), - ("Eraser", "Borracha"), - ("Exclusion", "Exclusão"), - ("Expand or collapse the folder", "Expandir ou recolher a pasta"), - ("Export", "Exportar"), - ("Export Mesh...", "Exportar malha..."), - ("Export Textures...", "Exportar texturas..."), - ("Export mesh", "Exportar malha"), - ("Export template", "Exportar modelo"), - ("Export templates", "Modelos de exportação"), - ("Export textures", "Exportar texturas"), - ("Export the selected template (.json)", "Exportar o modelo selecionado (.json)"), - ("Exported mesh to {path}", "Malha exportada para {path}"), - ("Exported template \"{name}\" to {path}", "Modelo \"{name}\" exportado para {path}"), - ("Exported {n} textures to {folder}", "{n} texturas exportadas para {folder}"), - ("F0 from specular level", "F0 a partir do nível especular"), - ("Fabric weave", "Trama de tecido"), - ("Field of view (deg)", "Campo de visão (graus)"), - ("File", "Arquivo"), - ("File name without extension; variables insert names", "Nome do arquivo sem extensão; variáveis inserem nomes"), - ("File type", "Tipo de arquivo"), - ("Fill", "Preenchimento"), - ("Fill the closed path (lasso)", "Preencher o caminho fechado (laço)"), - ("Fill the path (close it first)", "Preencher o caminho (feche-o primeiro)"), - ("Filter", "Filtro"), - ("Filter the remaining noise while keeping edges and texture detail", "Filtrar o ruído restante preservando bordas e detalhes de textura"), - ("Filters", "Filtros"), - ("Fine noise", "Ruído fino"), - ("Fingerprints", "Impressões digitais"), - ("Enter a finite number", "Insira um número finito"), - ("Double-click or press Enter to edit", "Clique duas vezes ou pressione Enter para editar"), - ("Fit the input range to the histogram", "Ajustar o intervalo de entrada ao histograma"), - ("Flatten layer", "Achatar camada"), - ( - "Flips the image's green channel, for normal maps made with Y pointing down", - "Inverte o canal verde da imagem, para mapas normais feitos com Y apontando para baixo", - ), - ("Flow", "Fluxo"), - ("Flow and opacity", "Fluxo e opacidade"), - ("Flow jitter", "Variação de fluxo"), - ("Focus distance", "Distância de foco"), - ("Folder", "Pasta"), - ("Folders", "Pastas"), - ("Follow path", "Seguir caminho"), - ( - "For the whole project: how normal map images set as mesh maps are read (set them again after a change), and the default for export", - "Para todo o projeto: como as imagens de mapa normal usadas como mapas de malha são lidas (atribua-as de novo após uma mudança), e o padrão para exportação", - ), - ("Free and open source (MIT OR Apache-2.0), written in Rust.", "Livre e de código aberto (MIT OR Apache-2.0), escrito em Rust."), - ("From template", "Do modelo"), - ("From template / project", "Do modelo / projeto"), - ("Full", "Completa"), - ("GPU error: {error}", "Erro de GPU: {error}"), - ("Geometry mask", "Máscara de geometria"), - ( - "GGX specular with height-correlated Smith visibility, Lambert diffuse, split-sum image-based lighting with spherical-harmonics irradiance and horizon fading.", - "Especular GGX com visibilidade Smith correlacionada à altura, difuso Lambert, iluminação baseada em imagem com soma dividida, irradiância por harmônicos esféricos e atenuação no horizonte.", - ), - ("Gamma", "Gama"), - ("General export parameters", "Parâmetros gerais de exportação"), - ("General properties", "Propriedades gerais"), - ("Generator", "Gerador"), - ("Geometry and UVs only", "Apenas geometria e UVs"), - ("Glossiness", "Brilho"), - ("Glossiness from roughness", "Brilho a partir da rugosidade"), - ("Glow", "Brilho"), - ("Gradient", "Gradiente"), - ("Gradient Map", "Mapa de gradiente"), - ("Gravity", "Gravidade"), - ("Gray", "Cinza"), - ("Gray + A", "Cinza + A"), - ("Gray 50%", "Cinza 50%"), - ("Grayscale", "Escala de cinza"), - ("Group layer(s)", "Agrupar camada(s)"), - ("Grunge", "Grunge"), - ("HDR environments", "Ambientes HDR"), - ("High Pass", "Passa-alta"), - ("HSL Perceptive", "HSL perceptivo"), - ("Half", "Metade"), - ("Hammered", "Martelado"), - ("Hard light", "Luz direta"), - ("Hardness", "Dureza"), - ("Height", "Altura"), - ("Height offset", "Deslocamento de altura"), - ("Height to normal strength", "Intensidade de altura para normal"), - ("Help", "Ajuda"), - ("Hide UI", "Ocultar interface"), - ("High", "Alto"), - ("High poly: {name}", "High poly: {name}"), - ("Highlights", "Realces"), - ("Histogram Range", "Intervalo do histograma"), - ("Histogram Scan", "Varredura do histograma"), - ("Histogram Shift", "Deslocamento do histograma"), - ("History", "Histórico"), - ( - "Hold S: left-drag rotates, right-drag scales, middle-drag moves the stencil.", - "Segure S: arrastar com botão esquerdo gira, com botão direito redimensiona e com botão do meio move o estêncil.", - ), - ("Hold V and click the mesh to set the clone source", "Segure V e clique na malha para definir a origem da clonagem"), - ( - "Hold V and click the mesh to set the source, then paint elsewhere to copy it.", - "Segure V e clique na malha para definir a origem, depois pinte em outro lugar para copiá-la.", - ), - ( - "How far light travels under the surface, as a fraction of the mesh size (where the Scattering weight channel is painted)", - "Até onde a luz viaja sob a superfície, como fração do tamanho da malha (onde o canal Peso de dispersão está pintado)", - ), - ( - "How strongly transmissive surfaces bend light (where the Transmission channel is painted): water 1.33, glass 1.5, diamond 2.42", - "Quanto as superfícies transmissivas desviam a luz (onde o canal Transmissão está pintado): água 1.33, vidro 1.5, diamante 2.42", - ), - ("Hue shift (degrees)", "Deslocamento de matiz (graus)"), - ("ID", "ID"), - ("Image: {name}", "Imagem: {name}"), - ("Images", "Imagens"), - ("Import HDR...", "Importar HDR..."), - ("Import a template (.json)", "Importar um modelo (.json)"), - ("Import an image (File > Import resources) to project it onto the mesh.", "Importe uma imagem (Arquivo > Importar recursos) para projetá-la na malha."), - ("Import images to use them in fills and masks", "Importe imagens para usá-las em preenchimentos e máscaras"), - ("Import resources...", "Importar recursos..."), - ("Import MaterialX material...", "Importar material MaterialX..."), - ("MaterialX materials", "Materiais MaterialX"), - ("Import...", "Importar..."), - ("Imported template \"{name}\"", "Modelo \"{name}\" importado"), - ("Imported {name}", "{name} importado"), - ("Index of refraction", "Índice de refração"), - ("Input high", "Entrada alta"), - ("Input low", "Entrada baixa"), - ("Input maps", "Mapas de entrada"), - ("Insert a variable", "Inserir uma variável"), - ("Instance", "Instância"), - ("Instantiate across texture sets", "Instanciar entre conjuntos de texturas"), - ("Intensity (texels at 2K)", "Intensidade (texels em 2K)"), - ("Interface", "Interface"), - ("Interface scale", "Escala da interface"), - ("Inverse Subtract", "Subtração inversa"), - ("Inverse divide", "Divisão inversa"), - ("Invert", "Inverter"), - ("Invert mask", "Inverter máscara"), - ("Invert mask background", "Inverter fundo da máscara"), - ("Invert mask value", "Inverter valor da máscara"), - ("Invert quick mask", "Inverter máscara rápida"), - ("Jitters", "Variações"), - ("Join the ArtCraft community on Discord", "Participe da comunidade ArtCraft no Discord"), - ("Join the community (Discord)...", "Participar da comunidade (Discord)..."), - ("Key light (shadow-casting light, direct only)", "Luz principal (projeta sombras, apenas direta)"), - ("Keyboard", "Teclado"), - ("Keyboard shortcuts", "Atalhos de teclado"), - ("Light azimuth (degrees)", "Azimute da luz (graus)"), - ("Light elevation (degrees)", "Elevação da luz (graus)"), - ("Light intensity", "Intensidade da luz"), - ("LMB", "Botão esquerdo"), - ("Language", "Idioma"), - ("Layer mask", "Máscara de camada"), - ("Layer memory: {mb} MB", "Memória das camadas: {mb} MB"), - ("Layers", "Camadas"), - ("Lazy mouse", "Lazy mouse"), - ("Lazy mouse distance", "Distância do lazy mouse"), - ("Leather grain", "Grão de couro"), - ("Lens size: how quickly things blur away from the focus distance", "Tamanho da lente: quão rápido os objetos desfocam fora da distância de foco"), - ("Level", "Nível"), - ("Levels", "Níveis"), - ("Lifetime (steps)", "Duração (passos)"), - ("Light / direction", "Luz / direção"), - ("Lighten (Max)", "Clarear (Máx)"), - ("Lightness", "Claridade"), - ("Linear", "Linear"), - ("Linear burn", "Superexposição linear"), - ("Linear dodge (Add)", "Subexposição linear (Adição)"), - ("Linear light", "Luz linear"), - ("List of exports", "Lista de exportações"), - ("Load UI Layout", "Carregar layout da interface"), - ("Loaded UI layout {path}", "Layout da interface carregado de {path}"), - ("Log", "Log"), - ("Low", "Baixo"), - ("Luminosity", "Luminosidade"), - ("MMB drag / Alt + MMB", "Arrastar com botão do meio / Alt + botão do meio"), - ("Made by the ArtCraft team and community.", "Feito pela equipe e pela comunidade ArtCraft."), - ("Magenta / green", "Magenta / verde"), - ("Main shader", "Shader principal"), - ("Marble veins", "Veios de mármore"), - ("Mask", "Máscara"), - ("Mask Editor: Edge wear", "Editor de máscara: Desgaste de bordas"), - ("Mask value (gray)", "Valor da máscara (cinza)"), - ("Mask with height", "Mascarar com altura"), - ("MatFinish Grind", "MatFinish Esmerilhado"), - ("MatFinish Hammered", "MatFinish Martelado"), - ("MatFinish Raw", "MatFinish Bruto"), - ("MatFinish Sanded", "MatFinish Lixado"), - ("Material", "Material"), - ("Material ball", "Esfera de material"), - ("Material finish", "Acabamento de material"), - ("Materials", "Materiais"), - ("Maximum", "Máximo"), - ("Mesh fill", "Preenchimento de malha"), - ("Mesh map: {map}", "Mapa de malha: {map}"), - ("Mesh maps", "Mapas de malha"), - ("Mesh maps baked", "Bake dos mapas de malha concluído"), - ("Meshes", "Malhas"), - ("Metallic", "Metálico"), - ("Midtones", "Tons médios"), - ("Minimum", "Mínimo"), - ("Minimum size (%)", "Tamanho mínimo (%)"), - ("Missing (bake to create)", "Ausente (faça o bake para criar)"), - ("Mixed AO", "AO combinada"), - ("Mode", "Modo"), - ("More in Assets > Alphas: click one, or drag it here", "Mais em Recursos > Alphas: clique em um ou arraste-o para cá"), - ("Mosaic", "Mosaico"), - ("Move down", "Mover para baixo"), - ("Move up", "Mover para cima"), - ( - "Moves the surface by the height channel on a finer copy of the mesh, at the height to normal strength (viewport only: painting follows the base surface)", - "Desloca a superfície pelo canal de altura em uma cópia mais fina da malha, com a intensidade de altura para normal (apenas na viewport: a pintura segue a superfície base)", - ), - ("Multiply", "Multiplicação"), - ("My smart materials", "Meus materiais inteligentes"), - ("Name", "Nome"), - ("New project", "Novo projeto"), - ("New project...", "Novo projeto..."), - ("New template", "Novo modelo"), - ("No GPU renderer available", "Nenhum renderizador de GPU disponível"), - ("No font on this system can show this language", "Nenhuma fonte deste sistema consegue exibir este idioma"), - ( - "No outputs yet: add one above, then drag input maps onto its channels.", - "Nenhuma saída ainda: adicione uma acima e arraste mapas de entrada para os canais dela.", - ), - ("No padding (passthrough)", "Sem margem (passagem direta)"), - ("Noise amount", "Quantidade de ruído"), - ("Noise scale", "Escala do ruído"), - ("None", "Nenhum"), - ("Normal", "Normal"), - ("Normal DirectX", "Normal DirectX"), - ("Normal Invert", "Inverter normal"), - ("Normal OpenGL", "Normal OpenGL"), - ("Normal from height", "Normal a partir da altura"), - ("Normal map combine", "Combinação de mapa normal"), - ("Normal map detail", "Detalhe de mapa normal"), - ("Color space", "Espaço de cor"), - ("Normal map format", "Formato do mapa normal"), - ("Normal map inverse detail", "Detalhe inverso de mapa normal"), - ("Normal: painting uses the flat normal", "Normal: a pintura usa a normal plana"), - ( - "Not enough GPU memory to show texture set \"{name}\" fully: lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "Memória de GPU insuficiente para mostrar o conjunto de texturas \"{name}\" por completo: reduza nas Configurações a resolução das texturas da viewport. A pintura e a exportação não são afetadas.", - ), - ( - "Not enough GPU memory to show {count} texture sets fully ({names}): lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "Memória de GPU insuficiente para mostrar por completo {count} conjuntos de texturas ({names}): reduza nas Configurações a resolução das texturas da viewport. A pintura e a exportação não são afetadas.", - ), - ("Not exported: no source in this texture set", "Não exportado: sem origem neste conjunto de texturas"), - ("Not saved: {error}", "Não salvo: {error}"), - ("Off", "Desligado"), - ("Offset", "Deslocamento"), - ("Offset right", "Deslocamento à direita"), - ("Offset up", "Deslocamento para cima"), - ("Offset {axis}", "Deslocamento {axis}"), - ( - "Offsets the textures by the height channel, at the height to normal strength", - "Desloca as texturas pelo canal de altura, com a intensidade de altura para normal", - ), - ("On", "Ligado"), - ("Opacity", "Opacidade"), - ("Open sample project...", "Abrir projeto de exemplo..."), - ("Open...", "Abrir..."), - ("Opened {name}", "{name} aberto"), - ( - "Optional channels add a clear coat (Coat weight, Coat roughness, Coat normal), sheen (Sheen weight, color, roughness), anisotropy (Anisotropy level, angle), subsurface scattering (Scattering weight) and transmission (Transmission).", - "Canais opcionais adicionam verniz (Peso do verniz, Rugosidade do verniz, Normal do verniz), lustro (Peso do lustro, cor, rugosidade), anisotropia (Nível de anisotropia, ângulo), dispersão subsuperficial (Peso de dispersão) e transmissão (Transmissão).", - ), - ("Orbit", "Orbitar"), - ("Orthographic", "Ortográfica"), - ("Perspective", "Perspectiva"), - ("Output directory", "Pasta de saída"), - ("Output high", "Saída alta"), - ("Output low", "Saída baixa"), - ("Output template", "Modelo de saída"), - ("Output templates", "Modelos de saída"), - ("Overlay", "Sobrepor"), - ("Overlay opacity", "Opacidade da sobreposição"), - ("PBR - Metallic Roughness (TextureCraft)", "PBR - Metálico Rugosidade (TextureCraft)"), - ("Pick color", "Coletar cor"), - ("PNG image", "Imagem PNG"), - ("Padding", "Margem"), - ("Paint", "Pintura"), - ("Paint chips", "Lascas de tinta"), - ("Paint on the mesh to edit the layer content.", "Pinte na malha para editar o conteúdo da camada."), - ( - "Paint on the mesh to edit this mask. Use the Material tab's mask value for gray.", - "Pinte na malha para editar esta máscara. Use o valor de máscara da aba Material para cinza.", - ), - ("Paint with the current tool", "Pintar com a ferramenta atual"), - ( - "Painted layer pixels {pixels} MB, composited channels {composites} MB, compositing cache {cache} MB", - "Pixels das camadas pintadas {pixels} MB, canais compostos {composites} MB, cache de composição {cache} MB", - ), - ("Painting", "Pintura"), - ("Pan", "Deslocar"), - ("Parallax occlusion (height channel)", "Oclusão de paralaxe (canal de altura)"), - ( - "Partial mask values follow the layer's height: high parts show first", - "Valores parciais de máscara seguem a altura da camada: as partes altas aparecem primeiro", - ), - ("Particle brush (slides down the surface)", "Pincel de partículas (desliza pela superfície)"), - ("Particle brush: particles slide down the surface", "Pincel de partículas: as partículas deslizam pela superfície"), - ("Particles", "Partículas"), - ("Passthrough", "Passagem"), - ("Paste as instance", "Colar como instância"), - ("Paste effect", "Colar efeito"), - ("Paste layer(s)", "Colar camada(s)"), - ("Path", "Caminho"), - ("Path trace on the processor instead of the graphics card (slower)", "Fazer path tracing no processador em vez da placa de vídeo (mais lento)"), - ( - "Path: click adds a point, click the curve inserts one, drag moves it, Enter applies, Esc cancels", - "Caminho: clicar adiciona um ponto, clicar na curva insere um, arrastar o move, Enter aplica, Esc cancela", - ), - ("Pattern scale", "Escala do padrão"), - ("Perlin noise", "Ruído Perlin"), - ("Pick focus in the viewport", "Escolher o foco na viewport"), - ("Pin light", "Luz pontual"), - ("Place on the surface", "Posicionar na superfície"), - ("Place path points on the mesh", "Posicione os pontos do caminho na malha"), - ("Planar projection", "Projeção planar"), - ("Plane", "Plano"), - ("Polygon fill", "Preenchimento de polígonos"), - ("Pores", "Poros"), - ("Position", "Posição"), - ("Position gradient", "Gradiente de posição"), - ("Position jitter", "Variação de posição"), - ("Posterize", "Posterizar"), - ("Press a key...", "Pressione uma tecla..."), - ("Procedurals", "Procedurais"), - ("Project", "Projeto"), - ("Project Configuration...", "Configuração do projeto..."), - ("Project opened", "Projeto aberto"), - ("Project template", "Modelo de projeto"), - ("Projection", "Projeção"), - ("Projects and meshes", "Projetos e malhas"), - ("Properties", "Propriedades"), - ("Quarter", "Um quarto"), - ("Quick mask", "Máscara rápida"), - ("Quit", "Sair"), - ("Radius (texels at 2K)", "Raio (texels em 2K)"), - ("RENDERING", "RENDERIZAÇÃO"), - ("Range", "Intervalo"), - ("Rebind any menu item, tool or command", "Reatribuir qualquer item de menu, ferramenta ou comando"), - ("Recent projects", "Projetos recentes"), - ( - "Records the stack up to this layer. Fill effects in masks (and fill layers) above can read it as a source.", - "Registra a pilha até esta camada. Efeitos de preenchimento em máscaras (e camadas de preenchimento) acima podem lê-la como origem.", - ), - ("Redo", "Refazer"), - ("Reimport mesh", "Reimportar malha"), - ("Remove", "Remover"), - ("Remove channel", "Remover canal"), - ("Remove effect", "Remover efeito"), - ("Remove last", "Remover último"), - ("Remove layer", "Remover camada"), - ("Remove layer(s)", "Remover camada(s)"), - ("Remove mask", "Remover máscara"), - ("Remove point", "Remover ponto"), - ("Remove resource", "Remover recurso"), - ("Remove the shortcut", "Remover o atalho"), - ("Remove this output", "Remover esta saída"), - ("Remove unused resources...", "Remover recursos não usados..."), - ("Rename the selected template", "Renomear o modelo selecionado"), - ("Render on the CPU", "Renderizar na CPU"), - ("Rendering", "Renderização"), - ("Rendering (path traced)", "Renderização (path tracing)"), - ("Rendering on CPU: {n} / {max} samples, {s} s", "Renderizando na CPU: {n} / {max} amostras, {s} s"), - ("Rendering on GPU: {n} / {max} samples, {s} s", "Renderizando na GPU: {n} / {max} amostras, {s} s"), - ("Rendering, path traced", "Renderização com path tracing"), - ("Replace", "Substituir"), - ("Replace Color", "Substituir cor"), - ("Replacement color", "Cor de substituição"), - ("Report a bug...", "Relatar um bug..."), - ("Rescan the library folder", "Reexaminar a pasta da biblioteca"), - ("Reset", "Redefinir"), - ("Reset UI", "Redefinir interface"), - ("Reset all", "Redefinir tudo"), - ("Reset to defaults", "Redefinir para o padrão"), - ("Reset to {shortcut}", "Redefinir para {shortcut}"), - ("Resizing", "Redimensionando"), - ("Restore every default shortcut", "Restaurar todos os atalhos padrão"), - ("Return to this step", "Voltar a esta etapa"), - ("Right-click a layer > Create smart material", "Clique com o botão direito em uma camada > Criar material inteligente"), - ("Rotation", "Rotação"), - ("Rotation (degrees)", "Rotação (graus)"), - ("Roughness", "Rugosidade"), - ("Roughness from glossiness", "Rugosidade a partir do brilho"), - ("Round", "Redondo"), - ("Rounded cube", "Cubo arredondado"), - ("Samples", "Amostras"), - ("Saturation", "Saturação"), - ("Save", "Salvar"), - ("Save UI Layout", "Salvar layout da interface"), - ("Save a copy...", "Salvar uma cópia..."), - ("Save as...", "Salvar como..."), - ("Save current layout...", "Salvar layout atual..."), - ("Save render...", "Salvar renderização..."), - ("Save view as camera", "Salvar vista como câmera"), - ("Saved UI layout {path}", "Layout da interface salvo em {path}"), - ("Saved {path}", "{path} salvo"), - ("Saving UI layouts to files is available in the desktop app", "Salvar layouts da interface em arquivos está disponível no aplicativo para desktop"), - ("Scale", "Escala"), - ("Scale / tiling", "Escala / repetição"), - ("Scatter color", "Cor de dispersão"), - ("Scatter radius", "Raio de dispersão"), - ("Scattering weight", "Peso de dispersão"), - ("Scratches", "Arranhões"), - ("Screen", "Tela"), - ("Screenshot of the viewport", "Captura de tela da viewport"), - ("Search", "Pesquisar"), - ("Search all assets", "Pesquisar em todos os recursos"), - ("Search commands or keys", "Pesquisar comandos ou teclas"), - ("Seed", "Semente"), - ("Select a layer", "Selecione uma camada"), - ("Select an output template", "Selecione um modelo de saída"), - ("Select source", "Selecionar origem"), - ("Select the mask (Alt+click: show it in the viewport)", "Selecionar a máscara (Alt+clique: exibi-la na viewport)"), - ("Select...", "Selecionar..."), - ("Settings", "Configurações"), - ("Settings...", "Configurações..."), - ("Shader Settings", "Configurações do shader"), - ("Shader instance", "Instância do shader"), - ("Shadows", "Sombras"), - ("Sharpen", "Nitidez"), - ("Sheen color", "Cor do lustro"), - ("Sheen color × weight", "Cor do lustro × peso"), - ("Sheen roughness", "Rugosidade do lustro"), - ("Sheen weight", "Peso do lustro"), - ("Shift + wheel", "Shift + roda do mouse"), - ("Shortcuts list...", "Lista de atalhos..."), - ("Show on all parts", "Mostrar em todas as partes"), - ("Show UV wireframe in the 2D view", "Exibir wireframe das UVs na vista 2D"), - ("Show entire mesh", "Exibir malha inteira"), - ("Show log...", "Exibir log..."), - ("Show or hide the layer", "Exibir ou ocultar a camada"), - ("Show or hide the texture set", "Exibir ou ocultar o conjunto de texturas"), - ("Show wireframe in the 3D view", "Exibir wireframe na vista 3D"), - ("Signed addition (AddSub)", "Adição com sinal (AddSub)"), - ("Size", "Tamanho"), - ("Size in screen space", "Tamanho no espaço da tela"), - ("Size jitter", "Variação de tamanho"), - ( - "Size of the textures the viewport shows: lower uses less GPU memory with large texture sets. Painting and export keep full resolution.", - "Tamanho das texturas exibidas na viewport: valores menores usam menos memória de GPU com conjuntos de texturas grandes. A pintura e a exportação mantêm a resolução completa.", - ), - ("Slope Blur", "Desfoque de inclinação"), - ("Slope scale", "Escala da inclinação"), - ("Smart masks", "Máscaras inteligentes"), - ("Smart material saved to {path}", "Material inteligente salvo em {path}"), - ("Smart materials", "Materiais inteligentes"), - ("Smudge", "Borrar"), - ("Soft light", "Luz suave"), - ("Softness", "Suavidade"), - ("Source", "Origem"), - ("Source U {u} V {v}", "Origem U {u} V {v}"), - ("Spacing", "Espaçamento"), - ("Specular", "Especular"), - ("Specular level", "Nível especular"), - ("Sphere", "Esfera"), - ("Spherical projection", "Projeção esférica"), - ("Spray", "Spray"), - ("Square", "Quadrado"), - ("Stamp depth", "Profundidade do carimbo"), - ("Star", "Estrela"), - ("Starting render...", "Iniciando renderização..."), - ("Stencil", "Estêncil"), - ("Steps", "Passos"), - ("Streaks", "Estrias"), - ("Strength", "Intensidade"), - ("Stripes", "Listras"), - ("Stroke opacity", "Opacidade do traço"), - ("Subsampling 2x2", "Subamostragem 2x2"), - ("Subsampling 4x4", "Subamostragem 4x4"), - ("Subsampling 8x8", "Subamostragem 8x8"), - ("Subsurface scattering", "Dispersão subsuperficial"), - ("Subtract", "Subtração"), - ("Tangent | Wrap", "Tangente | Envolver"), - ("Temporal anti-aliasing (refines the 3D view while it is still)", "Antisserrilhamento temporal (refina a vista 3D enquanto está parada)"), - ("Texture Sets", "Conjuntos de texturas"), - ("Texture Set Settings", "Configurações do conjunto de texturas"), - ("Texture resolution", "Resolução das texturas"), - ("Texture set channels", "Canais do conjunto de texturas"), - ("Texture sets", "Conjuntos de texturas"), - ("TextureCraft had to close:", "O TextureCraft precisou ser fechado:"), - ("TextureCraft PBR - Metallic Roughness", "TextureCraft PBR - Metálico Rugosidade"), - ("TextureCraft PBR - Specular Glossiness", "TextureCraft PBR - Especular Brilho"), - ("TextureCraft project", "Projeto TextureCraft"), - ("TextureCraft project or mesh", "Projeto TextureCraft ou malha"), - ("Textures", "Texturas"), - ("Textures embedded; for game engines and most viewers", "Texturas incorporadas; para engines de jogos e a maioria dos visualizadores"), - ("Textures packaged; for USD tools and AR Quick Look", "Texturas empacotadas; para ferramentas USD e AR Quick Look"), - ("The GPU couldn't render this scene: {error}", "A GPU não conseguiu renderizar esta cena: {error}"), - ("The bake worker stopped", "O processo de bake parou"), - ("The eraser removes paint from the enabled channels.", "A borracha remove a pintura dos canais ativados."), - ("The first stroke sets the offset from the source.", "O primeiro traço define o deslocamento em relação à origem."), - ( - "The image's alpha cuts the decal's shape; faces turned away and surfaces beyond its depth stay clear.", - "O alpha da imagem recorta a forma do decalque; faces voltadas para trás e superfícies além da sua profundidade ficam intactas.", - ), - ("The next click in the 3D view moves the decal there", "O próximo clique na vista 3D move o decalque para lá"), - ("The resize worker stopped", "O processo de redimensionamento parou"), - ("Thickness", "Espessura"), - ("Thin areas", "Áreas finas"), - ("Threshold", "Limiar"), - ("Tile", "Repetir"), - ("Tiles", "Ladrilhos"), - ("Tint", "Tonalizar"), - ("Toggle mask", "Alternar máscara"), - ("Tolerance", "Tolerância"), - ("Tone mapping", "Mapeamento de tons"), - ("Tools", "Ferramentas"), - ("Torus", "Toro"), - ("Transmission", "Transmissão"), - ("Tri-planar projection", "Projeção triplanar"), - ("Triangle fill", "Preenchimento de triângulos"), - ("UDIM plane", "Plano UDIM"), - ("UDIM tiles painted by this texture set, each at the set's size", "Tiles UDIM pintados por este conjunto de texturas, cada um no tamanho do conjunto"), - ("UI layout", "Layout da interface"), - ("UI layout: {error}", "Layout da interface: {error}"), - ("UI layouts", "Layouts da interface"), - ("UI {ms} ms", "Interface {ms} ms"), - ("USD binary, textures alongside", "USD binário, texturas ao lado"), - ("USD text, textures alongside", "USD em texto, texturas ao lado"), - ("USDZ with textures", "USDZ com texturas"), - ("UV checker", "Xadrez UV"), - ("UV island fill", "Preenchimento de ilhas UV"), - ("UV transformations", "Transformações UV"), - ("UV projection", "Projeção UV"), - ("UV tiles", "Tiles UV"), - ("UV tiles (UDIM)", "Tiles UV (UDIM)"), - ("Undo", "Desfazer"), - ("Uniform value", "Valor uniforme"), - ("Use an equirectangular .hdr or .exr image as the environment", "Usar uma imagem equirretangular .hdr ou .exr como ambiente"), - ("Use the control channel or `texturecraft-cli render` for screenshots", "Use o canal de controle ou `texturecraft-cli render` para capturas de tela"), - ("Value", "Valor"), - ("Version {version}", "Versão {version}"), - ("Version: {version} ({gpu})", "Versão: {version} ({gpu})"), - ("View through this camera", "Ver por esta câmera"), - ("Viewer settings", "Configurações do visualizador"), - ("Viewport", "Viewport"), - ("Viewport and brush (fixed)", "Viewport e pincel (fixos)"), - ("Views", "Vistas"), - ("Vivid light", "Luz brilhante"), - ("Voronoi", "Voronoi"), - ("Warp", "Deformar"), - ("Warp Directional", "Deformar direcional"), - ("Wavefront OBJ with MTL, textures alongside", "Wavefront OBJ com MTL, texturas ao lado"), - ( - "WebGPU isn't available in this browser, so TextureCraft runs on WebGL2: Rendering mode path traces on the CPU (slower) and large texture sets show at reduced resolution. A current Chrome, Edge or Safari has WebGPU.", - "O WebGPU não está disponível neste navegador, então o TextureCraft usa WebGL2: o modo de renderização faz path tracing na CPU (mais lento) e conjuntos de texturas grandes aparecem em resolução reduzida. As versões atuais do Chrome, Edge e Safari têm WebGPU.", - ), - ("Wheel / Alt + RMB drag", "Roda do mouse / Alt + arrastar com botão direito"), - ("White", "Branco"), - ("Width", "Largura"), - ("Width (texels at 2K)", "Largura (texels em 2K)"), - ("Window", "Janela"), - ("Wood grain", "Veio de madeira"), - ("Works in texture space, like the blur: it does not cross UV seams.", "Funciona no espaço de textura, como o desfoque: não atravessa costuras de UV."), - ("World Space Normal", "Normal no espaço do mundo"), - ("Yellow / blue", "Amarelo / azul"), - ("Zoom", "Zoom"), - ("a missing layer", "uma camada ausente"), - ("aniso", "aniso"), - ("aniso angle", "âng aniso"), - ("ao", "ao"), - ("coat", "verniz"), - ("coat nrm", "vern nrm"), - ("coat rough", "vern rug"), - ("color", "cor"), - ("emiss", "emiss"), - ("glTF binary with textures", "glTF binário com texturas"), - ("gloss", "brilho"), - ("height", "altura"), - ("metal", "metal"), - ("min", "min"), - ("missing", "ausente"), - ("missing source", "origem ausente"), - ("no GPU", "sem GPU"), - ("none", "nenhum"), - ("nrm", "nrm"), - ("off", "desligado"), - ("op", "opac"), - ("rough", "rugos"), - ("scatter", "disp"), - ("sheen", "lustro"), - ("sheen color", "cor lust"), - ("sheen rough", "rug lust"), - ("spec", "espec"), - ("specular", "especular"), - ("transm", "transm"), - ("{action} (undone)", "{action} (desfeito)"), - ( - "{file}: add above the selected layer (or drag it into the layer stack or onto the viewport)", - "{file}: adicionar acima da camada selecionada (ou arraste-o para a pilha de camadas ou para a viewport)", - ), - ("{name} copy", "Cópia de {name}"), - ("{n} bits", "{n} bits"), - ( - "{n} control points. Click the mesh (or the 2D view) to add points and drag them to adjust; click the first point to close the path. Enter paints it with the brush (a closed, filled path fills its inside), Esc cancels.", - "{n} pontos de controle. Clique na malha (ou na vista 2D) para adicionar pontos e arraste-os para ajustar; clique no primeiro ponto para fechar o caminho. Enter pinta o caminho com o pincel (um caminho fechado e preenchido preenche o interior), Esc cancela.", - ), - ("{n} items share a shortcut; the first one listed wins.", "{n} itens compartilham um atalho; o primeiro listado prevalece."), - ("{pattern} (scale {scale}, seed {seed})", "{pattern} (escala {scale}, semente {seed})"), - ("Template name", "Nome do modelo"), - ("Save current project as template", "Salvar o projeto atual como modelo"), - ("Distribution", "Distribuição"), - ("Cosine", "Cosseno"), - ("Uniform", "Uniforme"), - ("Normalization", "Normalização"), - // Settings › Interface: brightness and accent color. - ("Brightness", "Brilho"), - ("Dark", "Escuro"), - ("Medium dark", "Médio escuro"), - ("Medium light", "Médio claro"), - ("Light", "Claro"), - ("Accent color", "Cor de destaque"), - ("Copper", "Cobre"), - ("Coral", "Coral"), - ("Blue", "Azul"), - ("Violet", "Violeta"), - ("Green", "Verde"), - ("Amber", "Âmbar"), - ("Pink", "Rosa"), - ("Minimize", "Minimizar"), - ("Maximize", "Maximizar"), - ("Restore", "Restaurar"), - ("Title bar", "Barra de título"), - ("System title bar (applies on restart)", "Barra de título do sistema (aplicada ao reiniciar)"), - ( - "Use the operating system's window frame and buttons instead of TextureCraft's own title bar", - "Usar a moldura e os botões de janela do sistema operacional em vez da barra de título própria do TextureCraft", - ), - ("Brushes", "Pincéis"), - ("My brushes", "Meus pincéis"), - ("Use this brush (keeps its size)", "Usar este pincel (mantém o tamanho)"), - ("Brush name", "Nome do pincel"), - ("Save current brush", "Salvar o pincel atual"), - ("Start window", "Janela inicial"), - ("Show at startup", "Mostrar ao iniciar"), - ("Continue with the sample project", "Continuar com o projeto de exemplo"), - ("No recent projects yet", "Nenhum projeto recente ainda"), - ("Text", "Texto"), - ("Font", "Fonte"), - ("Style", "Estilo"), - ("Use as brush alpha", "Usar como alpha do pincel"), - ("Place as decal", "Colocar como decalque"), - ("Click: turn this channel on or off. Alt+click: this channel only", "Clique: liga ou desliga este canal. Alt+clique: só este canal"), - ("Show all", "Mostrar tudo"), - ("Hide all", "Ocultar tudo"), - ("Invert show/hide", "Inverter mostrar/ocultar"), - ("Show or hide texture sets", "Mostrar ou ocultar conjuntos de texturas"), - ("Focus: show only the active texture set", "Foco: mostrar só o conjunto de texturas ativo"), - ("Unsaved changes", "Alterações não salvas"), - ("Don't save", "Não salvar"), - ("Save the changes to {name} before closing?", "Salvar as alterações em {name} antes de fechar?"), - ("Radius", "Raio"), - ("Remove skew correction", "Remover a correção de inclinação"), - ("Twill weave", "Tecido sarja"), - ("Save the changes to {name} first?", "Salvar primeiro as alterações em {name}?"), - ( - "Paths stay editable: pick one to move its points or change its brush and material, and the sublayer repaints at once. Add paths with the Path tool.", - "Os caminhos continuam editáveis: escolha um para mover seus pontos ou mudar seu pincel e material, e a subcamada é repintada na hora. Adicione caminhos com a ferramenta Caminho.", - ), - ("Import material...", "Importar material..."), - ("MaterialCraft material", "Material do MaterialCraft"), - ("Cooked at {size} px", "Calculado em {size} px"), - ("Preset", "Predefinição"), - ("Re-cook", "Recalcular"), - ("Open in MaterialCraft", "Abrir no MaterialCraft"), - ( - "Opened in MaterialCraft: use File > Send to TextureCraft there to bring your changes back", - "Aberto no MaterialCraft: use lá Arquivo > Enviar para o TextureCraft para trazer suas alterações", - ), - ("Parameters change in the desktop app, with MaterialCraft installed", "Os parâmetros mudam no app para desktop, com o MaterialCraft instalado"), - ("Add High-Poly Meshes", "Adicionar malhas de alta resolução"), - ("All", "Todos"), - ("Apply Diffusion", "Aplicar difusão"), - ("Attenuation", "Atenuação"), - ("Auto Tonemapping", "Mapeamento tonal automático"), - ("Average Normals", "Normais médias"), - ("BBox", "Caixa delimitadora"), - ("BSphere", "Esfera delimitadora"), - ("Mesh Map Bakers", "Bakers de mapas de malha"), - ("Common Settings", "Configurações comuns"), - ("Mesh Map Settings", "Configurações de mapas de malha"), - ("Check All", "Marcar todos"), - ("No Parameters", "Sem parâmetros"), - ("Bake Selected Textures ({n})", "Fazer bake das texturas selecionadas ({n})"), - ("By Mesh Name", "Por nome da malha"), - ("Cage", "Gaiola"), - ("Cage Scene", "Cena da gaiola"), - ("Cage Type", "Tipo de gaiola"), - ("Color Generator", "Gerador de cores"), - ("Color Source", "Origem da cor"), - ("Common Parameters", "Parâmetros comuns"), - ("Custom File", "Arquivo personalizado"), - ("Details", "Detalhes"), - ("Dilation Width", "Largura da dilatação"), - ("Distance-Based", "Baseada em distância"), - ("Edge Contrast", "Contraste das arestas"), - ("Edge Distance", "Distância das arestas"), - ("Edge Protection", "Proteção das arestas"), - ("Enable Seams", "Ativar costuras"), - ("File ID", "ID do arquivo"), - ("Full Scene", "Cena inteira"), - ("Generate from Mesh", "Gerar a partir da malha"), - ("Generate from Normal Map", "Gerar a partir do mapa de normais"), - ("Ground Plane", "Plano do solo"), - ("Ground Plane Offset", "Deslocamento do solo"), - ("High Poly Mesh Suffix", "Sufixo da malha high poly"), - ("High Poly Scene", "Cena de alta resolução"), - ("High-Poly Parameters", "Parâmetros de alta resolução"), - ("Hue Shift", "Deslocamento de matiz"), - ("Ignore Backface", "Ignorar faces traseiras"), - ("Ignore Backface Suffix", "Sufixo para ignorar faces traseiras"), - ("Include in Bake", "Incluir no bake"), - ("Load Cage", "Carregar gaiola"), - ("Lock Output Size", "Bloquear tamanho de saída"), - ("Low Poly Mesh Suffix", "Sufixo da malha low poly"), - ("Manual", "Manual"), - ("Material Color", "Cor do material"), - ("Max Frontal Distance", "Distância frontal máxima"), - ("Max Occluder Distance", "Distância máxima do oclusor"), - ("Max Rear Distance", "Distância traseira máxima"), - ("Mesh ID", "ID da malha"), - ("Method", "Método"), - ("Min Occluder Distance", "Distância mínima do oclusor"), - ("Never", "Nunca"), - ("No High-Poly Meshes", "Nenhuma malha de alta resolução"), - ("Normalization Scale", "Escala de normalização"), - ("Normalization Type", "Tipo de normalização"), - ("Only Same Mesh Name", "Somente o mesmo nome de malha"), - ("Output Size", "Tamanho de saída"), - ("Match", "Correspondência"), - ("Skew Correction Method", "Método de Correção de Distorção"), - ("Mesh Normals Based", "Baseado nas Normais da Malha"), - ("Face Normals Based", "Baseado nas Normais das Faces"), - ("Reset Painted Cage", "Redefinir Gaiola Pintada"), - ("Paint Cage", "Pintar gaiola"), - ("Paint Skew Correction", "Pintar correção de inclinação"), - ("Per Material", "Por material"), - ("Random", "Aleatório"), - ("Relative to Bounding Box", "Relativo à caixa delimitadora"), - ("Relative to Low Mesh", "Relativo à malha de baixa resolução"), - ("Relative to Min/Max", "Relativo ao mínimo/máximo"), - ("Relative to Ray Distances", "Relativo às distâncias dos raios"), - ("Remove Cage", "Remover gaiola"), - ("Remove Skew Correction", "Remover a correção de inclinação"), - ("Restore Defaults", "Restaurar padrões"), - ("Return to Painting Mode", "Voltar ao modo de pintura"), - ("Sampling Radius", "Raio de amostragem"), - ("Scaling Divisor", "Divisor de escala"), - ("Seams Intensity", "Intensidade das costuras"), - ("Secondary Rays", "Raios secundários"), - ("Self Intersection", "Autointerseção"), - ("Self Occlusion", "Autooclusão"), - ("Skew Correction", "Correção de inclinação"), - ("Smooth", "Suave"), - ("Spread Angle", "Ângulo de dispersão"), - ("Submesh", "Submalha"), - ("Use Low Poly Mesh as High Poly Mesh", "Usar a malha low poly como malha high poly"), - ("Value Bounds Max", "Limite máximo"), - ("Value Bounds Min", "Limite mínimo"), - ("Vertex Color", "Cor do vértice"), - ("Select the layer content", "Selecionar o conteúdo da camada"), - ("Paint layer", "Camada de pintura"), - ("Fill layer", "Camada de preenchimento"), - ("1 effect", "1 efeito"), - ("{count} effects", "{count} efeitos"), - ("Mask effects", "Efeitos da máscara"), - ("Content effects", "Efeitos do conteúdo"), - ("Fold or unfold these effects", "Recolher ou expandir estes efeitos"), - ("Remove resolution override", "Remover resolução personalizada"), - ("Texture set resolution", "Resolução do conjunto de texturas"), - ("UV tile {tile} resolution", "Resolução do tile UV {tile}"), - ("Angle span", "Amplitude do ângulo"), - ("Axis position", "Posição do eixo"), - ("Count", "Quantidade"), - ("Display", "Exibição"), - ("Hide while painting", "Ocultar ao pintar"), - ("Manipulator size", "Tamanho do manipulador"), - ("Mirror symmetry", "Simetria espelhada"), - ("Radial settings", "Configurações radiais"), - ("Radial symmetry", "Simetria radial"), - ("Show axis", "Mostrar eixo"), - ("Show axis position manipulator", "Mostrar manipulador da posição do eixo"), - ("Show cursor", "Mostrar cursor"), - ("Show intersection", "Mostrar interseção"), - ("Show plane", "Mostrar plano"), - ("Symmetry", "Simetria"), - ("Symmetry color display", "Cor de exibição da simetria"), - ("Symmetry settings", "Configurações de simetria"), - ("Type", "Tipo"), - ("Advanced settings", "Configurações avançadas"), - ("Import baked maps", "Importar mapas com bake"), - ("Name each file after its texture set, like Body_normal.png", "Nomeie cada arquivo com o nome do seu conjunto de texturas, como Body_normal.png"), - ("Add...", "Adicionar..."), - ("Baked maps imported: {count}", "Mapas com bake importados: {count}"), - ("Not imported: {files}", "Não importados: {files}"), - ("Baking Visualization", "Visualização do bake"), - ("Show for Selected Texture Set Only", "Mostrar apenas para o conjunto de texturas selecionado"), - ("High Definition Mesh (HP)", "Malha de alta resolução (HP)"), - ("UV Seams", "Costuras UV"), - ("Project Mesh (LP)", "Malha de projeção (LP)"), - ("Edges", "Bordas"), - ("Cavities", "Cavidades"), - ("Edges and cavities", "Bordas e cavidades"), - ("Raw curvature", "Curvatura bruta"), - ("Detail sizes", "Tamanhos de detalhe"), - ( - "Reads the curvature map as baked: changing the mode or a size turns detail sizes on.", - "Lê o mapa de curvatura como foi assado: mudar o modo ou um tamanho ativa os tamanhos de detalhe.", - ), - ( - "A click fills what is under it; a dragged rectangle fills what it selects as it grows", - "Um clique preenche o que está embaixo; um retângulo arrastado preenche o que seleciona enquanto cresce", - ), - ("Contained center: fill polygons whose center is in the rectangle", "Centro contido: preencher os polígonos cujo centro está no retângulo"), - ( - "Editing the quick mask: fills paint where painting is allowed. Press U to finish.", - "Editando a máscara rápida: os preenchimentos pintam onde a pintura é permitida. Pressione U para concluir.", - ), - ("Fill mode", "Modo de preenchimento"), - ("Fill only polygons the camera sees (3D view)", "Preencher apenas os polígonos que a câmera vê (vista 3D)"), - ("Hit-test", "Teste de seleção"), - ("How a rectangle selects polygons", "Como um retângulo seleciona polígonos"), - ("Intersection: fill polygons the rectangle touches", "Interseção: preencher os polígonos que o retângulo toca"), - ("Rectangle fill", "Preenchimento retangular"), - ("Select a paint layer or a layer's mask to fill", "Selecione uma camada de pintura ou uma máscara de camada para preencher"), - ("Selection mode", "Modo de seleção"), - ( - "Triangle fills single triangles, Polygon whole quads and n-gons, Mesh the connected geometry, UV island the UV islands", - "Triângulo preenche triângulos isolados, Polígono quads e n-gons inteiros, Malha a geometria conectada, Ilha UV as ilhas UV", - ), - ("Visible polygons only", "Apenas polígonos visíveis"), - ( - "\"{layer}\" can't be filled: select a paint layer or a layer's mask", - "\"{layer}\" não pode ser preenchida: selecione uma camada de pintura ou uma máscara de camada", - ), - ("The file dialog couldn't be shown: {error}", "Não foi possível mostrar a caixa de diálogo de arquivos: {error}"), - ("The project changed while the dialog was open, so nothing was done", "O projeto mudou enquanto a caixa de diálogo estava aberta, então nada foi feito"), - ("Cores kept for the UI", "Núcleos reservados para a interface"), - ("Max RAM while saving", "RAM máx. ao salvar"), - ( - "Saving uses the other cores and at most this share of the free RAM. At least one core always works.", - "Salvar usa os outros núcleos e no máximo esta parte da RAM livre. Pelo menos um núcleo sempre trabalha.", - ), - ("Max project size on open", "Tamanho máximo ao abrir"), - ( - "Maximum decompressed project data. Increase this limit to open larger projects.", - "Limite de dados descompactados do projeto. Aumente este limite para abrir projetos maiores.", - ), -]; diff --git a/crates/ui-egui/src/i18n/zh_hans.rs b/crates/ui-egui/src/i18n/zh_hans.rs deleted file mode 100644 index ef4209e4..00000000 --- a/crates/ui-egui/src/i18n/zh_hans.rs +++ /dev/null @@ -1,1091 +0,0 @@ -//! Simplified Chinese UI text: (English key, translation). Keys are the English strings passed to `tr`. - -pub const TABLE: &[(&str, &str)] = &[ - ("Baking {map} ({n}/{total})", "正在烘焙{map} ({n}/{total})"), - ("Baking {map} ({n}/{total}), texture set {set} of {sets}", "正在烘焙{map} ({n}/{total}),纹理集 {set}/{sets}"), - ("Follow Newest Map", "跟随最新贴图"), - ("Painting is paused while a bake is shown. Cancel the bake or wait for it to finish.", "显示烘焙时已暂停绘制。请取消烘焙,或等待其完成。"), - ( - "What the 3D view shows while the bake runs: the newest finished map, one finished map, or the material. Maps not baked yet show a neutral value.", - "烘焙过程中 3D 视图显示的内容:最新完成的贴图、任意已完成的贴图,或材质。尚未烘焙的贴图显示中性值。", - ), - ("\"{layer}\" has no paint yet: the filter changes what you paint on it.", "“{layer}”尚未绘制:滤镜会改变你在其上绘制的内容。"), - ("0 turns autosave off. Copies go to {folder}", "设为 0 可关闭自动保存。副本保存到 {folder}"), - ("2D view only", "仅 2D 视图"), - ("32 bits (float)", "32 位(浮点)"), - ("3D mesh", "3D 网格"), - ("3D meshes", "3D 网格"), - ("3D texture painting: layers, masks, smart materials, mesh map baking and export.", "3D 纹理绘制:图层、遮罩、智能材质、网格贴图烘焙与导出。"), - ("3D view only", "仅 3D 视图"), - ("3D/2D views", "3D/2D 视图"), - ( - "A folder blends its children (pass-through). Set per-channel opacity in the layer rows.", - "文件夹会混合其子图层(穿透)。请在图层行中设置各通道的不透明度。", - ), - ("ACES filmic", "ACES 电影"), - ("Ambient", "环境光"), - ("AO intensity", "AO 强度"), - ("About TextureCraft", "关于 TextureCraft"), - ("About TextureCraft...", "关于 TextureCraft..."), - ("Add an anchor point to a layer below to use its stack as a mask.", "在下方图层上添加锚点,以将其堆栈用作遮罩。"), - ("Add anchor point", "添加锚点"), - ("Add as decal (view center)", "添加为贴花(视图中心)"), - ("Add black mask", "添加黑色遮罩"), - ("Add channel", "添加通道"), - ("Add color", "添加颜色"), - ("Add compare mask", "添加比较遮罩"), - ("Add effect", "添加效果"), - ("Add fill", "添加填充"), - ("Add fill layer", "添加填充图层"), - ("Add filter", "添加滤镜"), - ("Add folder", "添加文件夹"), - ("Add generator", "添加生成器"), - ("Add levels", "添加色阶"), - ("Add mask", "添加遮罩"), - ("Add mask with color selection", "添加颜色选择遮罩"), - ("Add output", "添加输出"), - ("Add paint", "添加绘画"), - ("Add paint layer", "添加绘画图层"), - ("Add smart material from the shelf", "从资产架添加智能材质"), - ("Add to the layer content", "添加到图层内容"), - ("Add to the mask", "添加到遮罩"), - ("Add white mask", "添加白色遮罩"), - ("Adjustments", "调整"), - ("Aligned: the offset set by the first stroke is kept. V + click sets a new source.", "对齐:保留第一笔设定的偏移。按住 V 并单击可设置新的源。"), - ("Alignment", "对齐"), - ("Alignment and culling", "对齐与剔除"), - ("All layers", "所有图层"), - ("Alpha", "Alpha"), - ("Alphas", "Alpha"), - ("Also bound to {item} ({menu})", "同时绑定到 {item}({menu})"), - ("Alt + LMB drag", "Alt + 左键拖动"), - ("Always", "始终"), - ("Ambient Occlusion", "环境光遮蔽"), - ("Ambient occlusion", "环境光遮蔽"), - ("Amount", "数量"), - ("Anchor point", "锚点"), - ("Anchor: {name}", "锚点:{name}"), - ("Anchor: {name} ({channel})", "锚点:{name}({channel})"), - ("Angle", "角度"), - ("Angle (degrees)", "角度(度)"), - ("Angle fade from", "角度衰减起点"), - ("Angle fade to", "角度衰减终点"), - ("Angle jitter", "角度抖动"), - ("Anisotropy angle", "各向异性角度"), - ("Anisotropy level", "各向异性强度"), - ("Antialiasing", "抗锯齿"), - ("Aperture", "光圈"), - ("Apply", "应用"), - ("ArtCraft website...", "ArtCraft 网站..."), - ("Assets", "资产"), - ("Auto", "自动"), - ("Automatic (from the mesh UVs)", "自动(基于网格 UV)"), - ("Autosave every", "自动保存间隔"), - ( - "Autosaves, smart materials, presets, templates and UI layouts go to the data folder. A new folder applies on restart; files already saved stay where they are.", - "自动保存、智能材质、预设、模板和界面布局都保存在数据文件夹中。新文件夹在重启后生效;已保存的文件保留在原处。", - ), - ("Axis", "轴"), - ("Back to painting", "返回绘画"), - ("Backface culling", "背面剔除"), - ("Bake an ID map (F8) to pick colors from the mesh.", "烘焙 ID 贴图(F8)以从网格上拾取颜色。"), - ("Bake Mesh Maps", "烘焙网格贴图"), - ("Bake mesh maps", "烘焙网格贴图"), - ("Bake mesh maps (F8) for curvature, AO and thickness based generators.", "烘焙网格贴图(F8)以用于基于曲率、AO 和厚度的生成器。"), - ("Baked Lighting", "烘焙光照"), - ("Baking", "烘焙"), - ("Base color", "基础色"), - ( - "Base color is the diffuse color, Specular the F0 color and Glossiness 1 - roughness (add these channels in the texture set settings).", - "基础色为漫反射颜色,高光为 F0 颜色,光泽度为 1 - 粗糙度(请在纹理集设置中添加这些通道)。", - ), - ("Base color, Metallic, Roughness and Specular level.", "基础色、金属度、粗糙度和高光强度。"), - ("Based on each texture set's size", "基于各纹理集的尺寸"), - ("Basic settings", "基本设置"), - ("Bent Normals", "弯曲法线"), - ("Bevel", "斜角"), - ("Black", "黑色"), - ("Blending", "混合"), - ("Blending mode of the displayed channel", "所显示通道的混合模式"), - ("Blur", "模糊"), - ("Blur Directional", "方向模糊"), - ("Blur and sharpen", "模糊与锐化"), - ("Bounces", "反弹次数"), - ("Bricks", "砖块"), - ("Brush", "笔刷"), - ("Brush size", "笔刷大小"), - ("Brush size down / up", "减小 / 增大笔刷大小"), - ("Brushed lines", "拉丝"), - ("Built-in (read-only): duplicate it to edit", "内置(只读):创建副本后即可编辑"), - ("Built-in templates are read-only: duplicate one to edit it", "内置模板为只读:创建副本后即可编辑"), - ("Built-in: {mesh}", "内置:{mesh}"), - ("Cage: {name}", "笼体:{name}"), - ("Camera", "相机"), - ("Colors", "颜色"), - ("Go to camera 1", "转到相机 1"), - ("Go to camera 2", "转到相机 2"), - ("Go to camera 3", "转到相机 3"), - ("Go to camera 4", "转到相机 4"), - ("Go to camera 5", "转到相机 5"), - ("Go to camera 6", "转到相机 6"), - ("Go to camera 7", "转到相机 7"), - ("Go to camera 8", "转到相机 8"), - ("Go to camera 9", "转到相机 9"), - ("Camera settings", "相机设置"), - ("Cancel", "取消"), - ("Cancel the stroke", "取消笔画"), - ("Cell size (texels at 2K)", "单元大小(2K 下的纹素数)"), - ("Cells", "细胞"), - ("Channel", "通道"), - ("Channel source: uniform value, procedural, image or anchor", "通道来源:统一值、程序纹理、图像或锚点"), - ("Channels", "通道"), - ("Check for Updates...", "检查更新..."), - ("Checker", "棋盘格"), - ("Clamp", "钳制"), - ("Clear", "清除"), - ("Clear mask", "清除遮罩"), - ("Clear recent projects", "清除最近的项目"), - ("Click a mesh part to show or hide the selected layer on it.", "单击网格部件,可在其上显示或隐藏所选图层。"), - ("Click the mesh to pick its material into the brush", "单击网格,将其材质吸取到笔刷中"), - ("Click the mesh to place the decal", "单击网格以放置贴花"), - ("Click, then press the new shortcut (Esc cancels)", "单击后按下新的快捷键(Esc 取消)"), - ("Clone", "仿制"), - ("Close", "关闭"), - ("Closed path", "闭合路径"), - ("Cloud", "云"), - ("Clouds", "云雾"), - ("Coat normal", "清漆法线"), - ("Coat roughness", "清漆粗糙度"), - ("Coat weight", "清漆权重"), - ("Color", "颜色"), - ("Color Balance", "色彩平衡"), - ("Color burn", "颜色加深"), - ("Color dodge", "颜色减淡"), - ("Color of the light that travels under the surface (each channel goes as far as its value)", "在表面下传播的光的颜色(各通道的传播距离取决于其值)"), - ("Color picker", "拾色器"), - ("Color selection", "颜色选择"), - ("Color to replace", "要替换的颜色"), - ("Colors near the first shift towards the second, keeping their shading.", "接近第一种颜色的颜色会在保留明暗的同时转向第二种颜色。"), - ("Colors read as gray. Add a levels or blur effect above to shape the result.", "颜色按灰度读取。可在上方添加色阶或模糊效果来调整结果。"), - ("Combine with the layer's height", "与图层高度合并"), - ("Compare mask", "比较遮罩"), - ("Compositing", "合成"), - ("Constant", "常量"), - ("Constants", "常量"), - ("Contrast", "对比度"), - ("Contrast/Luminosity", "对比度/亮度"), - ("Converted maps", "转换贴图"), - ("Copy RGB values", "复制 RGB 值"), - ("Copy effect", "复制效果"), - ("Copy from", "复制自"), - ("Copy layer(s)", "复制图层"), - ("Copy the selected layer alone (its empty parts copy nothing)", "仅复制所选图层(其空白部分不复制任何内容)"), - ("Copy to all texture sets", "复制到所有纹理集"), - ("Copy what the texture set shows", "复制纹理集显示的内容"), - ("Couldn't encode the render", "无法编码渲染结果"), - ("Couldn't export textures: {error}", "无法导出纹理:{error}"), - ("Couldn't export the mesh: {error}", "无法导出网格:{error}"), - ("Couldn't export the template: {error}", "无法导出模板:{error}"), - ("Couldn't import {name}: {error}", "无法导入 {name}:{error}"), - ("Couldn't open {name}: {error}", "无法打开 {name}:{error}"), - ("Couldn't read the render back from the GPU", "无法从 GPU 读回渲染结果"), - ("Couldn't save the render: {error}", "无法保存渲染结果:{error}"), - ("Couldn't save {name}: {error}", "无法保存 {name}:{error}"), - ("Count per stamp", "每个笔印的数量"), - ("Crate", "箱子"), - ("Create", "创建"), - ("Create smart material", "创建智能材质"), - ( - "Ctrl+right-drag in a view sets the size and hardness, Ctrl+left-drag the flow and angle.", - "在视图中按住 Ctrl 右键拖动可调整大小和硬度,Ctrl 左键拖动可调整流量和角度。", - ), - ("Cube", "立方体"), - ("Current layer", "当前图层"), - ("Curvature", "曲率"), - ("Cut effect", "剪切效果"), - ("Cut layer(s)", "剪切图层"), - ("Cyan / red", "青色 / 红色"), - ("Cylinder", "圆柱体"), - ("Cylindrical projection", "圆柱投影"), - ("Dark to light: the content's luminance picks a color along these stops.", "从暗到亮:内容的亮度沿这些色标选取颜色。"), - ("Darken (Min)", "变暗(最小值)"), - ("Data folder", "数据文件夹"), - ("Decal", "贴花"), - ("Decal projection", "贴花投影"), - ("Default", "默认"), - ("Default camera", "默认相机"), - ("Delete the selected template", "删除所选模板"), - ("Delete this camera", "删除此相机"), - ("Deleted template \"{name}\"", "已删除模板“{name}”"), - ("Denoise", "降噪"), - ("Depth", "深度"), - ("Depth of field", "景深"), - ("Depth of field (viewport and Rendering mode)", "景深(视口和渲染模式)"), - ("Depth of the sharp plane along the view (0: the orbit center)", "清晰平面沿视线方向的深度(0:轨道中心)"), - ("Details saved to {file}", "详细信息已保存到 {file}"), - ("Difference", "差值"), - ("Dilation + default background color", "扩张 + 默认背景色"), - ("Dilation + transparent", "扩张 + 透明"), - ("Dilation infinite", "无限扩张"), - ("DirectX normal map", "DirectX 法线贴图"), - ("Dirt", "污垢"), - ("Disable", "禁用"), - ("Dismiss", "关闭"), - ("Displacement (height channel)", "置换(高度通道)"), - ("Display Settings", "显示设置"), - ("Display material", "显示材质"), - ("Display next channel", "显示下一个通道"), - ("Display next mesh map", "显示下一个网格贴图"), - ("Display previous channel", "显示上一个通道"), - ("Display previous mesh map", "显示上一个网格贴图"), - ("Distance", "距离"), - ("Distort", "扭曲"), - ("Divide", "划分"), - ("Document resolution", "文档分辨率"), - ("Documentation...", "文档..."), - ("Done on CPU: {n} / {max} samples, {s} s", "已在 CPU 上完成:{n} / {max} 采样,{s} 秒"), - ("Done on GPU: {n} / {max} samples, {s} s", "已在 GPU 上完成:{n} / {max} 采样,{s} 秒"), - ("Double-click to rename", "双击以重命名"), - ("Download as", "下载为"), - ("Downloaded {name}", "已下载 {name}"), - ("Drag onto an output channel", "拖到输出通道上"), - ("Drag the frame to move the decal, a corner to scale it, the round handle to turn it", "拖动边框移动贴花,拖动角缩放,拖动圆形手柄旋转"), - ("Drags the layer stack's values along the stroke into the selected layer.", "沿笔画将图层堆栈的值拖入所选图层。"), - ("Draws {name} of texture set \"{set}\". Edits to the source show in every instance.", "绘制纹理集“{set}”的 {name}。对源的编辑会显示在每个实例中。"), - ("Drop an image from the Assets panel here to use it as this mesh map", "将资产面板中的图像拖放到此处,用作此网格贴图"), - ("Dry streaks", "干笔条纹"), - ("Duplicate effect", "创建效果副本"), - ("Duplicate layer(s)", "创建图层副本"), - ("Duplicate the selected template", "创建所选模板的副本"), - ("Edge Detect", "边缘检测"), - ("Edit", "编辑"), - ("Edit keyboard shortcuts...", "编辑键盘快捷键..."), - ("Edit quick mask", "编辑快速遮罩"), - ("Editing quick mask: paint where painting is allowed (U to finish)", "正在编辑快速遮罩:在允许绘画的区域绘制(按 U 完成)"), - ("Editing the quick mask: strokes paint where painting is allowed. Press U to finish.", "正在编辑快速遮罩:笔画绘制在允许绘画的区域。按 U 完成。"), - ("Emissive", "自发光"), - ("Enable or disable the effect", "启用或禁用效果"), - ("Enable quick mask", "启用快速遮罩"), - ("Environment blur", "环境模糊"), - ("Environment exposure (EV)", "环境曝光(EV)"), - ("Environment map", "环境贴图"), - ("Environment opacity", "环境不透明度"), - ("Environment rotation", "环境旋转"), - ("Environment settings", "环境设置"), - ("Environment: {name}", "环境:{name}"), - ("Environments", "环境"), - ("Eraser", "橡皮擦"), - ("Exclusion", "排除"), - ("Expand or collapse the folder", "展开或折叠文件夹"), - ("Export", "导出"), - ("Export Mesh...", "导出网格..."), - ("Export Textures...", "导出纹理..."), - ("Export mesh", "导出网格"), - ("Export template", "输出模板"), - ("Export templates", "输出模板"), - ("Export textures", "导出纹理"), - ("Export the selected template (.json)", "导出所选模板(.json)"), - ("Exported mesh to {path}", "已将网格导出到 {path}"), - ("Exported template \"{name}\" to {path}", "已将模板“{name}”导出到 {path}"), - ("Exported {n} textures to {folder}", "已将 {n} 个纹理导出到 {folder}"), - ("F0 from specular level", "由高光强度生成 F0"), - ("Fabric weave", "织物编织"), - ("Field of view (deg)", "视野(度)"), - ("File", "文件"), - ("File name without extension; variables insert names", "不含扩展名的文件名;变量会插入对应名称"), - ("File type", "文件类型"), - ("Fill", "填充"), - ("Fill the closed path (lasso)", "填充闭合路径(套索)"), - ("Fill the path (close it first)", "填充路径(请先闭合)"), - ("Filter", "滤镜"), - ("Filter the remaining noise while keeping edges and texture detail", "在保留边缘和纹理细节的同时过滤剩余噪点"), - ("Filters", "滤镜"), - ("Fine noise", "细噪波"), - ("Fingerprints", "指纹"), - ("Enter a finite number", "请输入有限数值"), - ("Double-click or press Enter to edit", "双击或按 Enter 键编辑"), - ("Fit the input range to the histogram", "使输入范围适合直方图"), - ("Flatten layer", "合并图层"), - ("Flips the image's green channel, for normal maps made with Y pointing down", "翻转图像的绿色通道,用于 Y 轴朝下制作的法线贴图"), - ("Flow", "流量"), - ("Flow and opacity", "流量与不透明度"), - ("Flow jitter", "流量抖动"), - ("Focus distance", "对焦距离"), - ("Folder", "文件夹"), - ("Folders", "文件夹"), - ("Follow path", "跟随路径"), - ( - "For the whole project: how normal map images set as mesh maps are read (set them again after a change), and the default for export", - "整个项目:设为网格贴图的法线贴图图像的读取方式(更改后请重新设置),以及导出的默认值", - ), - ("Free and open source (MIT OR Apache-2.0), written in Rust.", "免费开源(MIT OR Apache-2.0),使用 Rust 编写。"), - ("From template", "基于模板"), - ("From template / project", "基于模板 / 项目"), - ("Full", "完整"), - ("GPU error: {error}", "GPU 错误:{error}"), - ("Geometry mask", "几何遮罩"), - ( - "GGX specular with height-correlated Smith visibility, Lambert diffuse, split-sum image-based lighting with spherical-harmonics irradiance and horizon fading.", - "GGX 高光与高度相关的 Smith 可见性项、Lambert 漫反射、拆分求和的基于图像的光照,以及球谐辐照度与地平线衰减。", - ), - ("Gamma", "伽马"), - ("General export parameters", "常规导出参数"), - ("General properties", "常规属性"), - ("Generator", "生成器"), - ("Geometry and UVs only", "仅几何体和 UV"), - ("Glossiness", "光泽度"), - ("Glossiness from roughness", "由粗糙度生成光泽度"), - ("Glow", "辉光"), - ("Gradient", "渐变"), - ("Gradient Map", "渐变映射"), - ("Gravity", "重力"), - ("Gray", "灰度"), - ("Gray + A", "灰度 + A"), - ("Gray 50%", "50% 灰"), - ("Grayscale", "灰度"), - ("Group layer(s)", "将图层编组"), - ("Grunge", "污渍"), - ("HDR environments", "HDR 环境"), - ("High Pass", "高反差保留"), - ("HSL Perceptive", "HSL 感知"), - ("Half", "1/2"), - ("Hammered", "锤纹"), - ("Hard light", "强光"), - ("Hardness", "硬度"), - ("Height", "高度"), - ("Height offset", "高度偏移"), - ("Height to normal strength", "高度转法线强度"), - ("Help", "帮助"), - ("Hide UI", "隐藏界面"), - ("High", "高"), - ("High poly: {name}", "高模:{name}"), - ("Highlights", "高光"), - ("Histogram Range", "直方图范围"), - ("Histogram Scan", "直方图扫描"), - ("Histogram Shift", "直方图偏移"), - ("History", "历史记录"), - ("Hold S: left-drag rotates, right-drag scales, middle-drag moves the stencil.", "按住 S:左键拖动旋转,右键拖动缩放,中键拖动移动模板。"), - ("Hold V and click the mesh to set the clone source", "按住 V 并单击网格以设置仿制源"), - ("Hold V and click the mesh to set the source, then paint elsewhere to copy it.", "按住 V 并单击网格以设置源,然后在其他位置绘画进行复制。"), - ( - "How far light travels under the surface, as a fraction of the mesh size (where the Scattering weight channel is painted)", - "光在表面下传播的距离,以网格尺寸的比例表示(在绘制了散射权重通道的区域)", - ), - ( - "How strongly transmissive surfaces bend light (where the Transmission channel is painted): water 1.33, glass 1.5, diamond 2.42", - "透射表面使光弯曲的程度(在绘制了透射通道的区域):水 1.33,玻璃 1.5,钻石 2.42", - ), - ("Hue shift (degrees)", "色相偏移(度)"), - ("ID", "ID"), - ("Image: {name}", "图像:{name}"), - ("Images", "图像"), - ("Import HDR...", "导入 HDR..."), - ("Import a template (.json)", "导入模板(.json)"), - ("Import an image (File > Import resources) to project it onto the mesh.", "导入图像(文件 > 导入资源)以将其投影到网格上。"), - ("Import images to use them in fills and masks", "导入图像以在填充和遮罩中使用"), - ("Import resources...", "导入资源..."), - ("Import MaterialX material...", "导入 MaterialX 材质..."), - ("MaterialX materials", "MaterialX 材质"), - ("Import...", "导入..."), - ("Imported template \"{name}\"", "已导入模板“{name}”"), - ("Imported {name}", "已导入 {name}"), - ("Index of refraction", "折射率"), - ("Input high", "输入高"), - ("Input low", "输入低"), - ("Input maps", "输入贴图"), - ("Insert a variable", "插入变量"), - ("Instance", "实例"), - ("Instantiate across texture sets", "跨纹理集实例化"), - ("Intensity (texels at 2K)", "强度(2K 下的纹素数)"), - ("Interface", "界面"), - ("Interface scale", "界面缩放"), - ("Inverse Subtract", "反向减去"), - ("Inverse divide", "反向划分"), - ("Invert", "反相"), - ("Invert mask", "反相遮罩"), - ("Invert mask background", "反相遮罩背景"), - ("Invert mask value", "反相遮罩值"), - ("Invert quick mask", "反相快速遮罩"), - ("Jitters", "抖动"), - ("Join the ArtCraft community on Discord", "加入 Discord 上的 ArtCraft 社区"), - ("Join the community (Discord)...", "加入社区(Discord)..."), - ("Key light (shadow-casting light, direct only)", "主光源(投射阴影,仅直接光照)"), - ("Keyboard", "键盘"), - ("Keyboard shortcuts", "键盘快捷键"), - ("Light azimuth (degrees)", "光源方位角(度)"), - ("Light elevation (degrees)", "光源仰角(度)"), - ("Light intensity", "光照强度"), - ("LMB", "左键"), - ("Language", "语言"), - ("Layer mask", "图层遮罩"), - ("Layer memory: {mb} MB", "图层内存:{mb} MB"), - ("Layers", "图层"), - ("Lazy mouse", "平滑跟随"), - ("Lazy mouse distance", "平滑跟随距离"), - ("Leather grain", "皮革纹理"), - ("Lens size: how quickly things blur away from the focus distance", "镜头大小:远离对焦距离时物体变模糊的速度"), - ("Level", "级别"), - ("Levels", "色阶"), - ("Lifetime (steps)", "寿命(步数)"), - ("Light / direction", "光照 / 方向"), - ("Lighten (Max)", "变亮(最大值)"), - ("Lightness", "明度"), - ("Linear", "线性"), - ("Linear burn", "线性加深"), - ("Linear dodge (Add)", "线性减淡(添加)"), - ("Linear light", "线性光"), - ("List of exports", "导出列表"), - ("Load UI Layout", "加载界面布局"), - ("Loaded UI layout {path}", "已加载界面布局 {path}"), - ("Log", "日志"), - ("Low", "低"), - ("Luminosity", "亮度"), - ("MMB drag / Alt + MMB", "中键拖动 / Alt + 中键"), - ("Made by the ArtCraft team and community.", "由 ArtCraft 团队和社区打造。"), - ("Magenta / green", "洋红 / 绿色"), - ("Main shader", "主着色器"), - ("Marble veins", "大理石纹"), - ("Mask", "遮罩"), - ("Mask Editor: Edge wear", "遮罩编辑器:边缘磨损"), - ("Mask value (gray)", "遮罩值(灰度)"), - ("Mask with height", "用高度遮罩"), - ("MatFinish Grind", "表面处理:研磨"), - ("MatFinish Hammered", "表面处理:锤纹"), - ("MatFinish Raw", "表面处理:原始"), - ("MatFinish Sanded", "表面处理:砂磨"), - ("Material", "材质"), - ("Material ball", "材质球"), - ("Material finish", "材质表面处理"), - ("Materials", "材质"), - ("Maximum", "最大值"), - ("Mesh fill", "网格填充"), - ("Mesh map: {map}", "网格贴图:{map}"), - ("Mesh maps", "网格贴图"), - ("Mesh maps baked", "网格贴图已烘焙"), - ("Meshes", "网格"), - ("Metallic", "金属度"), - ("Midtones", "中间调"), - ("Minimum", "最小值"), - ("Minimum size (%)", "最小尺寸(%)"), - ("Missing (bake to create)", "缺失(烘焙以创建)"), - ("Mixed AO", "混合 AO"), - ("Mode", "模式"), - ("More in Assets > Alphas: click one, or drag it here", "“资产 > Alpha”中有更多:单击选择一个,或将其拖到此处"), - ("Mosaic", "马赛克"), - ("Move down", "下移"), - ("Move up", "上移"), - ( - "Moves the surface by the height channel on a finer copy of the mesh, at the height to normal strength (viewport only: painting follows the base surface)", - "在更精细的网格副本上按高度通道移动表面,强度与高度转法线相同(仅视口:绘制仍沿原始表面)", - ), - ("Multiply", "正片叠底"), - ("My smart materials", "我的智能材质"), - ("Name", "名称"), - ("New project", "新建项目"), - ("New project...", "新建项目..."), - ("New template", "新建模板"), - ("No GPU renderer available", "没有可用的 GPU 渲染器"), - ("No font on this system can show this language", "此系统上没有可显示该语言的字体"), - ("No outputs yet: add one above, then drag input maps onto its channels.", "尚无输出:请在上方添加一个,然后将输入贴图拖到其通道上。"), - ("No padding (passthrough)", "无扩边(直通)"), - ("Noise amount", "噪波量"), - ("Noise scale", "噪波缩放"), - ("None", "无"), - ("Normal", "法线"), - ("Normal DirectX", "法线 DirectX"), - ("Normal Invert", "法线反转"), - ("Normal OpenGL", "法线 OpenGL"), - ("Normal from height", "由高度生成法线"), - ("Normal map combine", "法线贴图合并"), - ("Normal map detail", "法线贴图细节"), - ("Color space", "色彩空间"), - ("Normal map format", "法线贴图格式"), - ("Normal map inverse detail", "法线贴图反向细节"), - ("Normal: painting uses the flat normal", "法线:绘画使用平坦法线"), - ( - "Not enough GPU memory to show texture set \"{name}\" fully: lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "GPU 内存不足,无法完整显示纹理集“{name}”:请在设置中降低视口的纹理分辨率。绘制和导出不受影响。", - ), - ( - "Not enough GPU memory to show {count} texture sets fully ({names}): lower the viewport Texture resolution in Settings. Painting and export are not affected.", - "GPU 内存不足,无法完整显示 {count} 个纹理集({names}):请在设置中降低视口的纹理分辨率。绘制和导出不受影响。", - ), - ("Not exported: no source in this texture set", "未导出:此纹理集中没有来源"), - ("Not saved: {error}", "未保存:{error}"), - ("Off", "关"), - ("Offset", "偏移"), - ("Offset right", "向右偏移"), - ("Offset up", "向上偏移"), - ("Offset {axis}", "偏移 {axis}"), - ("Offsets the textures by the height channel, at the height to normal strength", "按高度通道偏移纹理,偏移量取决于高度转法线强度"), - ("On", "开"), - ("Opacity", "不透明度"), - ("Open sample project...", "打开示例项目..."), - ("Open...", "打开..."), - ("Opened {name}", "已打开 {name}"), - ( - "Optional channels add a clear coat (Coat weight, Coat roughness, Coat normal), sheen (Sheen weight, color, roughness), anisotropy (Anisotropy level, angle), subsurface scattering (Scattering weight) and transmission (Transmission).", - "可选通道可添加清漆(清漆权重、清漆粗糙度、清漆法线)、绒光(绒光权重、颜色、粗糙度)、各向异性(各向异性强度、角度)、次表面散射(散射权重)和透射(透射)。", - ), - ("Orbit", "环绕"), - ("Orthographic", "正交"), - ("Perspective", "透视"), - ("Output directory", "输出目录"), - ("Output high", "输出高"), - ("Output low", "输出低"), - ("Output template", "输出模板"), - ("Output templates", "输出模板"), - ("Overlay", "叠加"), - ("Overlay opacity", "叠加层不透明度"), - ("PBR - Metallic Roughness (TextureCraft)", "PBR - 金属度/粗糙度(TextureCraft)"), - ("Pick color", "拾取颜色"), - ("PNG image", "PNG 图像"), - ("Padding", "扩边"), - ("Paint", "绘画"), - ("Paint chips", "掉漆"), - ("Paint on the mesh to edit the layer content.", "在网格上绘画以编辑图层内容。"), - ("Paint on the mesh to edit this mask. Use the Material tab's mask value for gray.", "在网格上绘画以编辑此遮罩。灰度请使用“材质”选项卡中的遮罩值。"), - ("Paint with the current tool", "使用当前工具绘画"), - ( - "Painted layer pixels {pixels} MB, composited channels {composites} MB, compositing cache {cache} MB", - "已绘制图层像素 {pixels} MB,合成通道 {composites} MB,合成缓存 {cache} MB", - ), - ("Painting", "绘画"), - ("Pan", "平移"), - ("Parallax occlusion (height channel)", "视差遮蔽(高度通道)"), - ("Partial mask values follow the layer's height: high parts show first", "部分遮罩值跟随图层高度:较高部分先显示"), - ("Particle brush (slides down the surface)", "粒子笔刷(沿表面向下滑动)"), - ("Particle brush: particles slide down the surface", "粒子笔刷:粒子沿表面向下滑动"), - ("Particles", "粒子"), - ("Passthrough", "穿透"), - ("Paste as instance", "粘贴为实例"), - ("Paste effect", "粘贴效果"), - ("Paste layer(s)", "粘贴图层"), - ("Path", "路径"), - ("Path trace on the processor instead of the graphics card (slower)", "在处理器而非显卡上进行路径追踪(较慢)"), - ( - "Path: click adds a point, click the curve inserts one, drag moves it, Enter applies, Esc cancels", - "路径:单击添加点,单击曲线插入点,拖动移动点,Enter 应用,Esc 取消", - ), - ("Pattern scale", "图案缩放"), - ("Perlin noise", "柏林噪波"), - ("Pick focus in the viewport", "在视口中拾取焦点"), - ("Pin light", "点光"), - ("Place on the surface", "放置在表面上"), - ("Place path points on the mesh", "在网格上放置路径点"), - ("Planar projection", "平面投影"), - ("Plane", "平面"), - ("Polygon fill", "多边形填充"), - ("Pores", "毛孔"), - ("Position", "位置"), - ("Position gradient", "位置渐变"), - ("Position jitter", "位置抖动"), - ("Posterize", "色调分离"), - ("Press a key...", "请按下一个键..."), - ("Procedurals", "程序纹理"), - ("Project", "项目"), - ("Project Configuration...", "项目配置..."), - ("Project opened", "项目已打开"), - ("Project template", "项目模板"), - ("Projection", "投影"), - ("Projects and meshes", "项目和网格"), - ("Properties", "属性"), - ("Quarter", "1/4"), - ("Quick mask", "快速遮罩"), - ("Quit", "退出"), - ("Radius (texels at 2K)", "半径(2K 下的纹素数)"), - ("RENDERING", "渲染"), - ("Range", "范围"), - ("Rebind any menu item, tool or command", "重新绑定任意菜单项、工具或命令"), - ("Recent projects", "最近的项目"), - ( - "Records the stack up to this layer. Fill effects in masks (and fill layers) above can read it as a source.", - "记录截至此图层的堆栈。上方遮罩(及填充图层)中的填充效果可将其作为来源读取。", - ), - ("Redo", "重做"), - ("Reimport mesh", "重新导入网格"), - ("Remove", "移除"), - ("Remove channel", "移除通道"), - ("Remove effect", "移除效果"), - ("Remove last", "移除最后一个"), - ("Remove layer", "移除图层"), - ("Remove layer(s)", "移除图层"), - ("Remove mask", "移除遮罩"), - ("Remove point", "移除点"), - ("Remove resource", "移除资源"), - ("Remove the shortcut", "移除快捷键"), - ("Remove this output", "移除此输出"), - ("Remove unused resources...", "移除未使用的资源..."), - ("Rename the selected template", "重命名所选模板"), - ("Render on the CPU", "在 CPU 上渲染"), - ("Rendering", "渲染"), - ("Rendering (path traced)", "渲染(路径追踪)"), - ("Rendering on CPU: {n} / {max} samples, {s} s", "正在 CPU 上渲染:{n} / {max} 采样,{s} 秒"), - ("Rendering on GPU: {n} / {max} samples, {s} s", "正在 GPU 上渲染:{n} / {max} 采样,{s} 秒"), - ("Rendering, path traced", "渲染,路径追踪"), - ("Replace", "替换"), - ("Replace Color", "替换颜色"), - ("Replacement color", "替换后的颜色"), - ("Report a bug...", "报告错误..."), - ("Rescan the library folder", "重新扫描库文件夹"), - ("Reset", "重置"), - ("Reset UI", "重置界面"), - ("Reset all", "全部重置"), - ("Reset to defaults", "恢复默认值"), - ("Reset to {shortcut}", "重置为 {shortcut}"), - ("Resizing", "正在调整大小"), - ("Restore every default shortcut", "恢复所有默认快捷键"), - ("Return to this step", "返回到此步骤"), - ("Right-click a layer > Create smart material", "右键单击图层 > 创建智能材质"), - ("Rotation", "旋转"), - ("Rotation (degrees)", "旋转(度)"), - ("Roughness", "粗糙度"), - ("Roughness from glossiness", "由光泽度生成粗糙度"), - ("Round", "圆形"), - ("Rounded cube", "圆角立方体"), - ("Samples", "采样"), - ("Saturation", "饱和度"), - ("Save", "保存"), - ("Save UI Layout", "保存界面布局"), - ("Save a copy...", "保存副本..."), - ("Save as...", "另存为..."), - ("Save current layout...", "保存当前布局..."), - ("Save render...", "保存渲染结果..."), - ("Save view as camera", "将视图保存为相机"), - ("Saved UI layout {path}", "已保存界面布局 {path}"), - ("Saved {path}", "已保存 {path}"), - ("Saving UI layouts to files is available in the desktop app", "将界面布局保存到文件的功能仅在桌面版中可用"), - ("Scale", "缩放"), - ("Scale / tiling", "缩放 / 平铺"), - ("Scatter color", "散射颜色"), - ("Scatter radius", "散射半径"), - ("Scattering weight", "散射权重"), - ("Scratches", "划痕"), - ("Screen", "滤色"), - ("Screenshot of the viewport", "视口截图"), - ("Search", "搜索"), - ("Search all assets", "搜索所有资产"), - ("Search commands or keys", "搜索命令或按键"), - ("Seed", "随机种子"), - ("Select a layer", "选择图层"), - ("Select an output template", "选择输出模板"), - ("Select source", "选择来源"), - ("Select the mask (Alt+click: show it in the viewport)", "选择遮罩(Alt+单击:在视口中显示)"), - ("Select...", "选择..."), - ("Settings", "设置"), - ("Settings...", "设置..."), - ("Shader Settings", "着色器设置"), - ("Shader instance", "着色器实例"), - ("Shadows", "阴影"), - ("Sharpen", "锐化"), - ("Sheen color", "绒光颜色"), - ("Sheen color × weight", "绒光颜色 × 权重"), - ("Sheen roughness", "绒光粗糙度"), - ("Sheen weight", "绒光权重"), - ("Shift + wheel", "Shift + 滚轮"), - ("Shortcuts list...", "快捷键列表..."), - ("Show on all parts", "在所有部件上显示"), - ("Show UV wireframe in the 2D view", "在 2D 视图中显示 UV 线框"), - ("Show entire mesh", "显示整个网格"), - ("Show log...", "显示日志..."), - ("Show or hide the layer", "显示或隐藏图层"), - ("Show or hide the texture set", "显示或隐藏纹理集"), - ("Show wireframe in the 3D view", "在 3D 视图中显示线框"), - ("Signed addition (AddSub)", "有符号相加(AddSub)"), - ("Size", "大小"), - ("Size in screen space", "屏幕空间大小"), - ("Size jitter", "大小抖动"), - ( - "Size of the textures the viewport shows: lower uses less GPU memory with large texture sets. Painting and export keep full resolution.", - "视口显示的纹理尺寸:较低的设置在大型纹理集上占用更少的 GPU 显存。绘画和导出仍使用完整分辨率。", - ), - ("Slope Blur", "坡度模糊"), - ("Slope scale", "坡度缩放"), - ("Smart masks", "智能遮罩"), - ("Smart material saved to {path}", "智能材质已保存到 {path}"), - ("Smart materials", "智能材质"), - ("Smudge", "涂抹"), - ("Soft light", "柔光"), - ("Softness", "柔和度"), - ("Source", "来源"), - ("Source U {u} V {v}", "源 U {u} V {v}"), - ("Spacing", "间距"), - ("Specular", "高光"), - ("Specular level", "高光强度"), - ("Sphere", "球体"), - ("Spherical projection", "球面投影"), - ("Spray", "喷溅"), - ("Square", "方形"), - ("Stamp depth", "笔印深度"), - ("Star", "星形"), - ("Starting render...", "正在开始渲染..."), - ("Stencil", "模板"), - ("Steps", "步数"), - ("Streaks", "条纹"), - ("Strength", "强度"), - ("Stripes", "条带"), - ("Stroke opacity", "笔画不透明度"), - ("Subsampling 2x2", "2x2 子采样"), - ("Subsampling 4x4", "4x4 子采样"), - ("Subsampling 8x8", "8x8 子采样"), - ("Subsurface scattering", "次表面散射"), - ("Subtract", "减去"), - ("Tangent | Wrap", "切线 | 包裹"), - ("Temporal anti-aliasing (refines the 3D view while it is still)", "时间抗锯齿(在 3D 视图静止时逐步细化)"), - ("Texture Sets", "纹理集"), - ("Texture Set Settings", "纹理集设置"), - ("Texture resolution", "纹理分辨率"), - ("Texture set channels", "纹理集通道"), - ("Texture sets", "纹理集"), - ("TextureCraft had to close:", "TextureCraft 不得不关闭:"), - ("TextureCraft PBR - Metallic Roughness", "TextureCraft PBR - 金属度/粗糙度"), - ("TextureCraft PBR - Specular Glossiness", "TextureCraft PBR - 高光/光泽度"), - ("TextureCraft project", "TextureCraft 项目"), - ("TextureCraft project or mesh", "TextureCraft 项目或网格"), - ("Textures", "纹理"), - ("Textures embedded; for game engines and most viewers", "嵌入纹理;适用于游戏引擎和大多数查看器"), - ("Textures packaged; for USD tools and AR Quick Look", "打包纹理;适用于 USD 工具和 AR Quick Look"), - ("The GPU couldn't render this scene: {error}", "GPU 无法渲染此场景:{error}"), - ("The bake worker stopped", "烘焙进程已停止"), - ("The eraser removes paint from the enabled channels.", "橡皮擦会从已启用的通道中移除颜料。"), - ("The first stroke sets the offset from the source.", "第一笔会设定与源的偏移。"), - ( - "The image's alpha cuts the decal's shape; faces turned away and surfaces beyond its depth stay clear.", - "图像的 Alpha 决定贴花的形状;背向的面和超出其深度的表面不受影响。", - ), - ("The next click in the 3D view moves the decal there", "在 3D 视图中下一次单击会将贴花移到该处"), - ("The resize worker stopped", "调整大小的进程已停止"), - ("Thickness", "厚度"), - ("Thin areas", "薄区域"), - ("Threshold", "阈值"), - ("Tile", "平铺"), - ("Tiles", "瓷砖"), - ("Tint", "着色"), - ("Toggle mask", "切换遮罩"), - ("Tolerance", "容差"), - ("Tone mapping", "色调映射"), - ("Tools", "工具"), - ("Torus", "圆环"), - ("Transmission", "透射"), - ("Tri-planar projection", "三平面投影"), - ("Triangle fill", "三角形填充"), - ("UDIM plane", "UDIM 平面"), - ("UDIM tiles painted by this texture set, each at the set's size", "此纹理集绘制的 UDIM 图块,每个都使用纹理集的尺寸"), - ("UI layout", "界面布局"), - ("UI layout: {error}", "界面布局:{error}"), - ("UI layouts", "界面布局"), - ("UI {ms} ms", "界面 {ms} ms"), - ("USD binary, textures alongside", "USD 二进制,纹理单独存放"), - ("USD text, textures alongside", "USD 文本,纹理单独存放"), - ("USDZ with textures", "带纹理的 USDZ"), - ("UV checker", "UV 棋盘格"), - ("UV island fill", "UV 岛填充"), - ("UV transformations", "UV 变换"), - ("UV projection", "UV 投影"), - ("UV tiles", "UV 图块"), - ("UV tiles (UDIM)", "UV 图块(UDIM)"), - ("Undo", "撤销"), - ("Uniform value", "统一值"), - ("Use an equirectangular .hdr or .exr image as the environment", "使用等距柱状投影的 .hdr 或 .exr 图像作为环境"), - ("Use the control channel or `texturecraft-cli render` for screenshots", "截图请使用控制通道或 `texturecraft-cli render`"), - ("Value", "值"), - ("Version {version}", "版本 {version}"), - ("Version: {version} ({gpu})", "版本:{version}({gpu})"), - ("View through this camera", "通过此相机查看"), - ("Viewer settings", "查看器设置"), - ("Viewport", "视口"), - ("Viewport and brush (fixed)", "视口与笔刷(固定)"), - ("Views", "视图"), - ("Vivid light", "亮光"), - ("Voronoi", "沃罗诺伊"), - ("Warp", "变形"), - ("Warp Directional", "方向变形"), - ("Wavefront OBJ with MTL, textures alongside", "Wavefront OBJ(含 MTL),纹理单独存放"), - ( - "WebGPU isn't available in this browser, so TextureCraft runs on WebGL2: Rendering mode path traces on the CPU (slower) and large texture sets show at reduced resolution. A current Chrome, Edge or Safari has WebGPU.", - "此浏览器不支持 WebGPU,因此 TextureCraft 使用 WebGL2 运行:渲染模式在 CPU 上进行路径追踪(较慢),大型纹理集以降低的分辨率显示。最新版 Chrome、Edge 和 Safari 支持 WebGPU。", - ), - ("Wheel / Alt + RMB drag", "滚轮 / Alt + 右键拖动"), - ("White", "白色"), - ("Width", "宽度"), - ("Width (texels at 2K)", "宽度(2K 下的纹素数)"), - ("Window", "窗口"), - ("Wood grain", "木纹"), - ("Works in texture space, like the blur: it does not cross UV seams.", "在纹理空间中工作,与模糊相同:不会跨越 UV 接缝。"), - ("World Space Normal", "世界空间法线"), - ("Yellow / blue", "黄色 / 蓝色"), - ("Zoom", "缩放"), - ("a missing layer", "缺失的图层"), - ("aniso", "各向"), - ("aniso angle", "各向角"), - ("ao", "AO"), - ("coat", "清漆"), - ("coat nrm", "清漆法"), - ("coat rough", "清漆糙"), - ("color", "颜色"), - ("emiss", "发光"), - ("glTF binary with textures", "带纹理的 glTF 二进制"), - ("gloss", "光泽"), - ("height", "高度"), - ("metal", "金属"), - ("min", "分钟"), - ("missing", "缺失"), - ("missing source", "缺少来源"), - ("no GPU", "无 GPU"), - ("none", "无"), - ("nrm", "法线"), - ("off", "关"), - ("op", "不透明"), - ("rough", "粗糙"), - ("scatter", "散射"), - ("sheen", "绒光"), - ("sheen color", "绒光色"), - ("sheen rough", "绒光糙"), - ("spec", "高光强"), - ("specular", "高光"), - ("transm", "透射"), - ("{action} (undone)", "{action}(已撤销)"), - ("{file}: add above the selected layer (or drag it into the layer stack or onto the viewport)", "{file}:添加到所选图层上方(或将其拖入图层堆栈或视口)"), - ("{name} copy", "{name} 副本"), - ("{n} bits", "{n} 位"), - ( - "{n} control points. Click the mesh (or the 2D view) to add points and drag them to adjust; click the first point to close the path. Enter paints it with the brush (a closed, filled path fills its inside), Esc cancels.", - "{n} 个控制点。单击网格(或 2D 视图)添加控制点,拖动可调整;单击第一个点可闭合路径。按 Enter 用笔刷绘制路径(闭合且填充的路径会填充内部),按 Esc 取消。", - ), - ("{n} items share a shortcut; the first one listed wins.", "{n} 个项目共用一个快捷键;列表中第一个生效。"), - ("{pattern} (scale {scale}, seed {seed})", "{pattern}(缩放 {scale},种子 {seed})"), - ("Template name", "模板名称"), - ("Save current project as template", "将当前项目保存为模板"), - ("Distribution", "分布"), - ("Cosine", "余弦"), - ("Uniform", "均匀"), - ("Normalization", "归一化"), - // Settings › Interface: brightness and accent color. - ("Brightness", "亮度"), - ("Dark", "深色"), - ("Medium dark", "中等深色"), - ("Medium light", "中等浅色"), - ("Light", "浅色"), - ("Accent color", "强调色"), - ("Copper", "铜色"), - ("Coral", "珊瑚色"), - ("Blue", "蓝色"), - ("Violet", "紫罗兰色"), - ("Green", "绿色"), - ("Amber", "琥珀色"), - ("Pink", "粉色"), - ("Minimize", "最小化"), - ("Maximize", "最大化"), - ("Restore", "还原"), - ("Title bar", "标题栏"), - ("System title bar (applies on restart)", "系统标题栏(重启后生效)"), - ( - "Use the operating system's window frame and buttons instead of TextureCraft's own title bar", - "使用操作系统的窗口边框和按钮,而不是 TextureCraft 自己的标题栏", - ), - ("Brushes", "笔刷库"), - ("My brushes", "我的笔刷"), - ("Use this brush (keeps its size)", "使用此笔刷(保留大小)"), - ("Brush name", "笔刷名称"), - ("Save current brush", "保存当前笔刷"), - ("Start window", "启动窗口"), - ("Show at startup", "启动时显示"), - ("Continue with the sample project", "继续使用示例项目"), - ("No recent projects yet", "暂无最近的项目"), - ("Text", "文字"), - ("Font", "字体"), - ("Style", "样式"), - ("Use as brush alpha", "用作笔刷 Alpha"), - ("Place as decal", "作为贴花放置"), - ("Click: turn this channel on or off. Alt+click: this channel only", "单击:打开或关闭此通道。Alt+单击:仅此通道"), - ("Show all", "全部显示"), - ("Hide all", "全部隐藏"), - ("Invert show/hide", "反转显示/隐藏"), - ("Show or hide texture sets", "显示或隐藏纹理集"), - ("Focus: show only the active texture set", "聚焦:仅显示当前纹理集"), - ("Unsaved changes", "未保存的更改"), - ("Don't save", "不保存"), - ("Save the changes to {name} before closing?", "关闭前是否保存对 {name} 的更改?"), - ("Radius", "半径"), - ("Remove skew correction", "移除倾斜校正"), - ("Twill weave", "斜纹织物"), - ("Save the changes to {name} first?", "是否先保存对 {name} 的更改?"), - ( - "Paths stay editable: pick one to move its points or change its brush and material, and the sublayer repaints at once. Add paths with the Path tool.", - "路径始终可编辑:选择一条路径来移动其控制点或更改其笔刷和材质,子图层会立即重绘。使用路径工具添加路径。", - ), - ("Import material...", "导入材质..."), - ("MaterialCraft material", "MaterialCraft 材质"), - ("Cooked at {size} px", "已按 {size} px 计算"), - ("Preset", "预设"), - ("Re-cook", "重新计算"), - ("Open in MaterialCraft", "在 MaterialCraft 中打开"), - ( - "Opened in MaterialCraft: use File > Send to TextureCraft there to bring your changes back", - "已在 MaterialCraft 中打开:在其中使用“文件 > 发送到 TextureCraft”即可带回更改", - ), - ("Parameters change in the desktop app, with MaterialCraft installed", "参数可在安装了 MaterialCraft 的桌面版中修改"), - ("Add High-Poly Meshes", "添加高模网格"), - ("All", "全部"), - ("Apply Diffusion", "应用扩散"), - ("Attenuation", "衰减"), - ("Auto Tonemapping", "自动色调映射"), - ("Average Normals", "平均法线"), - ("BBox", "包围盒"), - ("BSphere", "包围球"), - ("Mesh Map Bakers", "网格贴图烘焙器"), - ("Common Settings", "通用设置"), - ("Mesh Map Settings", "网格贴图设置"), - ("Check All", "全选"), - ("No Parameters", "无参数"), - ("Bake Selected Textures ({n})", "烘焙所选纹理({n})"), - ("By Mesh Name", "按网格名称"), - ("Cage", "笼形"), - ("Cage Scene", "笼形场景"), - ("Cage Type", "笼形类型"), - ("Color Generator", "颜色生成器"), - ("Color Source", "颜色来源"), - ("Common Parameters", "通用参数"), - ("Custom File", "自定义文件"), - ("Details", "细节"), - ("Dilation Width", "扩张宽度"), - ("Distance-Based", "基于距离"), - ("Edge Contrast", "边缘对比度"), - ("Edge Distance", "边缘距离"), - ("Edge Protection", "边缘保护"), - ("Enable Seams", "启用接缝"), - ("File ID", "文件 ID"), - ("Full Scene", "整个场景"), - ("Generate from Mesh", "从网格生成"), - ("Generate from Normal Map", "从法线贴图生成"), - ("Ground Plane", "地平面"), - ("Ground Plane Offset", "地平面偏移"), - ("High Poly Mesh Suffix", "高模网格后缀"), - ("High Poly Scene", "高模场景"), - ("High-Poly Parameters", "高模参数"), - ("Hue Shift", "色相偏移"), - ("Ignore Backface", "忽略背面"), - ("Ignore Backface Suffix", "忽略背面后缀"), - ("Include in Bake", "包含在烘焙中"), - ("Load Cage", "加载笼形"), - ("Lock Output Size", "锁定输出尺寸"), - ("Low Poly Mesh Suffix", "低模网格后缀"), - ("Manual", "手动"), - ("Material Color", "材质颜色"), - ("Max Frontal Distance", "最大前向距离"), - ("Max Occluder Distance", "最大遮挡物距离"), - ("Max Rear Distance", "最大后向距离"), - ("Mesh ID", "网格 ID"), - ("Method", "方法"), - ("Min Occluder Distance", "最小遮挡距离"), - ("Never", "从不"), - ("No High-Poly Meshes", "无高模网格"), - ("Normalization Scale", "归一化范围"), - ("Normalization Type", "归一化类型"), - ("Only Same Mesh Name", "仅相同网格名称"), - ("Output Size", "输出尺寸"), - ("Match", "匹配"), - ("Skew Correction Method", "偏斜校正方法"), - ("Mesh Normals Based", "基于网格法线"), - ("Face Normals Based", "基于面法线"), - ("Reset Painted Cage", "重置绘制的笼形"), - ("Paint Cage", "绘制笼形"), - ("Paint Skew Correction", "绘制倾斜校正"), - ("Per Material", "按材质"), - ("Random", "随机"), - ("Relative to Bounding Box", "相对于包围盒"), - ("Relative to Low Mesh", "相对于低模网格"), - ("Relative to Min/Max", "相对于最小值/最大值"), - ("Relative to Ray Distances", "相对于射线距离"), - ("Remove Cage", "移除笼形"), - ("Remove Skew Correction", "移除倾斜校正"), - ("Restore Defaults", "恢复默认值"), - ("Return to Painting Mode", "返回绘画模式"), - ("Sampling Radius", "采样半径"), - ("Scaling Divisor", "缩放除数"), - ("Seams Intensity", "接缝强度"), - ("Secondary Rays", "二次光线"), - ("Self Intersection", "自相交"), - ("Self Occlusion", "自遮蔽"), - ("Skew Correction", "倾斜校正"), - ("Smooth", "平滑"), - ("Spread Angle", "扩散角度"), - ("Submesh", "子网格"), - ("Use Low Poly Mesh as High Poly Mesh", "将低模用作高模"), - ("Value Bounds Max", "值上限"), - ("Value Bounds Min", "值下限"), - ("Vertex Color", "顶点颜色"), - ("Select the layer content", "选择图层内容"), - ("Paint layer", "绘画图层"), - ("Fill layer", "填充图层"), - ("1 effect", "1 个效果"), - ("{count} effects", "{count} 个效果"), - ("Mask effects", "遮罩效果"), - ("Content effects", "内容效果"), - ("Fold or unfold these effects", "折叠或展开这些效果"), - ("Remove resolution override", "移除分辨率覆盖"), - ("Texture set resolution", "纹理集分辨率"), - ("UV tile {tile} resolution", "UV 图块 {tile} 的分辨率"), - ("Angle span", "角度范围"), - ("Axis position", "轴位置"), - ("Count", "数量"), - ("Display", "显示"), - ("Hide while painting", "绘制时隐藏"), - ("Manipulator size", "操纵器大小"), - ("Mirror symmetry", "镜像对称"), - ("Radial settings", "径向设置"), - ("Radial symmetry", "径向对称"), - ("Show axis", "显示轴"), - ("Show axis position manipulator", "显示轴位置操纵器"), - ("Show cursor", "显示光标"), - ("Show intersection", "显示交线"), - ("Show plane", "显示平面"), - ("Symmetry", "对称"), - ("Symmetry color display", "对称显示颜色"), - ("Symmetry settings", "对称设置"), - ("Type", "类型"), - ("Advanced settings", "高级设置"), - ("Import baked maps", "导入已烘焙贴图"), - ("Name each file after its texture set, like Body_normal.png", "以纹理集名称为每个文件命名,例如 Body_normal.png"), - ("Add...", "添加..."), - ("Baked maps imported: {count}", "已导入的烘焙贴图:{count}"), - ("Not imported: {files}", "未导入:{files}"), - ("Baking Visualization", "烘焙可视化"), - ("Show for Selected Texture Set Only", "仅显示所选纹理集"), - ("High Definition Mesh (HP)", "高模网格 (HP)"), - ("UV Seams", "UV 接缝"), - ("Project Mesh (LP)", "投射网格 (LP)"), - ("Edges", "边缘"), - ("Cavities", "凹陷"), - ("Edges and cavities", "边缘和凹陷"), - ("Raw curvature", "原始曲率"), - ("Detail sizes", "细节尺寸"), - ("Reads the curvature map as baked: changing the mode or a size turns detail sizes on.", "按烘焙原样读取曲率贴图:更改模式或尺寸会启用细节尺寸。"), - ("A click fills what is under it; a dragged rectangle fills what it selects as it grows", "单击填充其下方的内容;拖出的矩形在扩大时填充其选中的内容"), - ("Contained center: fill polygons whose center is in the rectangle", "包含中心:填充中心位于矩形内的多边形"), - ("Editing the quick mask: fills paint where painting is allowed. Press U to finish.", "正在编辑快速遮罩:填充绘制在允许绘画的区域。按 U 完成。"), - ("Fill mode", "填充模式"), - ("Fill only polygons the camera sees (3D view)", "仅填充相机可见的多边形(3D 视图)"), - ("Hit-test", "命中测试"), - ("How a rectangle selects polygons", "矩形选择多边形的方式"), - ("Intersection: fill polygons the rectangle touches", "相交:填充矩形触及的多边形"), - ("Rectangle fill", "矩形填充"), - ("Select a paint layer or a layer's mask to fill", "选择要填充的绘画图层或图层遮罩"), - ("Selection mode", "选择模式"), - ( - "Triangle fills single triangles, Polygon whole quads and n-gons, Mesh the connected geometry, UV island the UV islands", - "三角形填充单个三角形,多边形填充整个四边形和 n 边形,网格填充相连的几何体,UV 岛填充 UV 岛", - ), - ("Visible polygons only", "仅可见多边形"), - ("\"{layer}\" can't be filled: select a paint layer or a layer's mask", "“{layer}”无法填充:请选择绘画图层或图层遮罩"), - ("The file dialog couldn't be shown: {error}", "无法显示文件对话框:{error}"), - ("The project changed while the dialog was open, so nothing was done", "对话框打开期间项目已更改,因此未执行任何操作"), - ("Cores kept for the UI", "为界面保留的核心数"), - ("Max RAM while saving", "保存时的最大内存"), - ( - "Saving uses the other cores and at most this share of the free RAM. At least one core always works.", - "保存使用其余核心,并最多占用这一比例的可用内存。至少始终有一个核心工作。", - ), - ("Max project size on open", "打开项目的大小上限"), - ("Maximum decompressed project data. Increase this limit to open larger projects.", "解压后项目数据的大小上限。提高此限制以打开更大的项目。"), -]; diff --git a/crates/ui-egui/src/windows.rs b/crates/ui-egui/src/windows.rs index c8448913..8d573899 100644 --- a/crates/ui-egui/src/windows.rs +++ b/crates/ui-egui/src/windows.rs @@ -611,7 +611,7 @@ fn settings(app: &mut TextureCraftApp, ctx: &egui::Context) { ui.label(tr("Language")); let current = crate::i18n::current(); egui::ComboBox::from_id_salt("language").width(180.0).height(320.0).selected_text(current.name).show_ui(ui, |ui| { - for (l, ok) in LANGUAGES.iter().zip(drawable) { + for (l, ok) in LANGUAGES.iter().zip(drawable).filter(|(l, _)| crate::i18n::available(l.code)) { let item = egui::Button::selectable(l.code == current.code, if ok { l.name } else { l.english }); if ui.add_enabled(ok, item).on_disabled_hover_text(tr("No font on this system can show this language")).clicked() { p.language = l.code.to_owned(); @@ -1303,6 +1303,8 @@ mod tests { fn harness() -> Harness<'static, TextureCraftApp> { let session = texturecraft_engine::sample_session(256, 64).unwrap(); let mut h = Harness::builder().with_size(vec2(1600.0, 960.0)).build_eframe(|cc| TextureCraftApp::new(cc, session)); + // These dialog tests query English labels, independently of the system locale. + h.state_mut().ui.prefs.language = "en".into(); h.run_steps(2); h } diff --git a/crates/ui-egui/tests/i18n_build.rs b/crates/ui-egui/tests/i18n_build.rs new file mode 100644 index 00000000..d0ff1953 --- /dev/null +++ b/crates/ui-egui/tests/i18n_build.rs @@ -0,0 +1,78 @@ +//! Optional catalog embedding must work without network or application dependencies. +#[path = "../i18n_build.rs"] +#[allow(dead_code)] // The production build entry point is not invoked by these pure-input tests. +mod i18n_build; + +use std::path::PathBuf; +use std::sync::atomic::{AtomicUsize, Ordering}; + +struct Fixture(PathBuf); +impl Fixture { + fn new() -> Self { + static NEXT: AtomicUsize = AtomicUsize::new(0); + let path = std::env::temp_dir().join(format!("texturecraft-i18n-{}-{}", std::process::id(), NEXT.fetch_add(1, Ordering::Relaxed))); + std::fs::create_dir_all(path.join("locales/es")).unwrap(); + Self(path) + } +} +impl Drop for Fixture { + fn drop(&mut self) { + let _ = std::fs::remove_dir_all(&self.0); + } +} + +#[test] +fn no_input_is_english_but_required_input_errors() { + assert!(!i18n_build::generate(None, false).unwrap().contains("include_str!")); + assert!(i18n_build::generate(None, true).is_err()); +} + +#[test] +fn invalid_and_relative_checkouts_are_rejected() { + let fixture = Fixture::new(); + assert!(i18n_build::generate(Some(&fixture.0.join("missing")), false).is_err()); + assert!(i18n_build::generate(Some(std::path::Path::new("relative")), false).is_err()); +} + +#[test] +fn shared_only_locale_is_not_offered_and_required_needs_app_catalog() { + let fixture = Fixture::new(); + std::fs::write(fixture.0.join("locales/es/common.tsv"), "\tSave\tGuardar\n").unwrap(); + assert!(!i18n_build::generate(Some(&fixture.0), false).unwrap().contains("include_str!")); + assert!(i18n_build::generate(Some(&fixture.0), true).is_err()); +} + +#[test] +fn app_catalog_is_embedded_with_optional_shared_catalog() { + let fixture = Fixture::new(); + let app = fixture.0.join("locales/es/texturecraft.tsv"); + std::fs::write(&app, "\tLayers\tCapas\n").unwrap(); + let source = i18n_build::generate(Some(&fixture.0), true).unwrap(); + assert!(source.contains("texturecraft.tsv")); + assert!(source.contains("(\"es\", \"\",")); + let common = fixture.0.join("locales/es/common.tsv"); + std::fs::write(&common, "\tSave\tGuardar\n").unwrap(); + assert!(i18n_build::generate(Some(&fixture.0), true).unwrap().contains("common.tsv")); +} + +#[test] +fn unreadable_catalog_fails_before_generating_rust_source() { + let fixture = Fixture::new(); + std::fs::write(fixture.0.join("locales/es/texturecraft.tsv"), [0xff, 0xfe]).unwrap(); + assert!(i18n_build::generate(Some(&fixture.0), true).is_err()); +} + +#[test] +fn generated_paths_compile_and_embed_the_catalog_contents() { + let fixture = Fixture::new(); + std::fs::write(fixture.0.join("locales/es/texturecraft.tsv"), "\tLayers\tCapas\n").unwrap(); + let generated = i18n_build::generate(Some(&fixture.0), true).unwrap(); + let program = format!( + "extern crate self as craft_i18n;\npub type Embedded = [(&'static str, &'static str, &'static str)];\n{generated}\nfn main() {{ assert_eq!(CRAFT_I18N[0].2, \"\\tLayers\\tCapas\\n\"); }}" + ); + let source = fixture.0.join("check.rs"); + let binary = fixture.0.join(format!("check{}", std::env::consts::EXE_SUFFIX)); + std::fs::write(&source, program).unwrap(); + assert!(std::process::Command::new("rustc").arg(&source).arg("-o").arg(&binary).status().unwrap().success()); + assert!(std::process::Command::new(binary).status().unwrap().success()); +} diff --git a/crates/ui-egui/tests/ui_snapshots.rs b/crates/ui-egui/tests/ui_snapshots.rs index 4ca66c96..fbcecb49 100644 --- a/crates/ui-egui/tests/ui_snapshots.rs +++ b/crates/ui-egui/tests/ui_snapshots.rs @@ -497,3 +497,21 @@ fn rail_window_snapshots() { texturecraft_ui_egui::menus::invoke(harness.state_mut(), &context, "ui.view.history"); save(&mut harness, &output_dir, "rail-history-short"); } + +/// Visual check of the migrated catalogs and the live language selector. +#[test] +#[ignore] +fn i18n_snapshots() { + let Some(output_dir) = std::env::var_os("TC_UI_SNAPSHOTS").map(PathBuf::from) else { return }; + std::fs::create_dir_all(&output_dir).unwrap(); + for code in ["en", "es", "ar"] { + assert!(texturecraft_ui_egui::i18n::available(code), "build with migrated catalogs for {code}"); + let session = texturecraft_engine::sample_session(128, 32).unwrap(); + let mut harness = + Harness::builder().with_size(egui::vec2(1600.0, 960.0)).with_pixels_per_point(1.0).wgpu().build_eframe(|cc| TextureCraftApp::new(cc, session)); + harness.state_mut().ui.prefs.language = code.into(); + harness.state_mut().ui.windows.settings = true; + save(&mut harness, &output_dir, &format!("i18n-{code}")); + } + texturecraft_ui_egui::i18n::set_language("en"); +} diff --git a/docs/internationalization.md b/docs/internationalization.md new file mode 100644 index 00000000..c75b7e44 --- /dev/null +++ b/docs/internationalization.md @@ -0,0 +1,29 @@ +# Interface translations + +TextureCraft uses the `craft-i18n` runtime from craft-libs and optional catalogs from +[craft-i18n](https://github.com/storytold/craft-i18n). + +Set `CRAFT_I18N_DIR` to the absolute path of a craft-i18n checkout before building. +The build embeds `locales//common.tsv` and `texturecraft.tsv`. Without catalog input, +the application uses English. `CRAFT_I18N_REQUIRED=1` makes missing/invalid input a build error. +The same catalogs are embedded for native and WebAssembly builds; no runtime files are needed. + +Feature changes add English strings through `tr`, `n_` or `trf`. Translations belong in +craft-i18n PRs. A missing translation displays English and does not block a feature or release. +Run `cargo test -p texturecraft-ui-egui translation_coverage_report -- --nocapture` with +catalog input to inspect untranslated and unused/shared keys. Shared catalogs contain other +apps' strings, so unused shared keys are informational, not candidates for automatic deletion. + +The initial migration is tracked in storytold/texturecraft#419. Catalog changes must merge +before the application cutover, and translations landing meanwhile need a final sync. +Saved `pt-BR` and `zh-Hans` preferences retain their original spelling and meaning. + +## CI and release catalog revision + +`craft-i18n.rev` pins the catalog commit. The shared craft-common-actions gate and release +workflows read this file, check out storytold/craft-i18n and set CRAFT_I18N_DIR together with +CRAFT_I18N_REQUIRED=1. No application workflow changes are needed. + +The catalog commit must be available in storytold/craft-i18n before merging the app cutover. +After a squash or rebase merge of the companion catalog PR, update the pin to the resulting +upstream commit and rerun validation before merging TextureCraft. diff --git a/docs/localization-parity.md b/docs/localization-parity.md index e664b605..fb6a8a49 100644 --- a/docs/localization-parity.md +++ b/docs/localization-parity.md @@ -2,20 +2,23 @@ TextureCraft's interface text goes through one lookup, `tr("English text")` in `crates/ui-egui/src/i18n.rs`: the English string is the key, so English needs no table and a -missing translation falls back to English. Each language is a static `(English, translation)` -table in `crates/ui-egui/src/i18n/.rs`, indexed into a hash map the first time the -language is used. Text with values uses `trf("Saved {path}", &[("path", &p)])`; static labels -that are translated where they are shown are marked with `n_("…")`. +missing translation falls back to English. Translations are embedded from the optional shared +craft-i18n catalogs; see [integration and contribution instructions](internationalization.md). +Text with values uses `trf("Saved {path}", &[("path", &p)])`; static labels translated where +they are shown are marked with `n_("…")`. Pick the language in **Edit ▸ Settings ▸ Language** (it switches live). The first run follows the operating system's language (the browser's in the web build). ## Status +The table records coverage before the initial catalog migration. Actual coverage depends on +the craft-i18n catalogs embedded in a build. Without catalogs, only English is offered. + UI strings: every `tr`/`trf`/`n_` literal in `crates/ui-egui/src` plus the menu catalog, panel names, shortcut editor rows and the engine's channel, blend mode, mesh map, tool, procedural, generator, filter and brush alpha names (**KEYS** strings, counted by the -`every_key_is_translated_in_every_language` test, which fails when one is missing). +`translation_coverage_report` test, which reports missing and unused keys without failing). | Language | Code | UI strings | Dialogs, tooltips, help | Script support | Native review | Status | To `full` | |---|---|---|---|---|---|---|---| From 9e96367d0c0519ce9f5c796815303c44aad46501 Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Wed, 11 Nov 2026 16:52:41 +0100 Subject: [PATCH 10/39] Release: TextureCraft v0.6.0 (#420) --- Cargo.lock | 30 +++++++++++++++--------------- Cargo.toml | 2 +- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 94579b6f..19c65129 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4259,7 +4259,7 @@ dependencies = [ [[package]] name = "texturecraft" -version = "0.3.1" +version = "0.6.0" dependencies = [ "craft-menu", "craft-update", @@ -4280,7 +4280,7 @@ dependencies = [ [[package]] name = "texturecraft-automation" -version = "0.3.1" +version = "0.6.0" dependencies = [ "base64 0.22.1", "cap-std", @@ -4301,7 +4301,7 @@ dependencies = [ [[package]] name = "texturecraft-bake" -version = "0.3.1" +version = "0.6.0" dependencies = [ "bytemuck", "rayon", @@ -4313,7 +4313,7 @@ dependencies = [ [[package]] name = "texturecraft-cli" -version = "0.3.1" +version = "0.6.0" dependencies = [ "image", "serde_json", @@ -4325,7 +4325,7 @@ dependencies = [ [[package]] name = "texturecraft-compose" -version = "0.3.1" +version = "0.6.0" dependencies = [ "half", "rayon", @@ -4336,7 +4336,7 @@ dependencies = [ [[package]] name = "texturecraft-core" -version = "0.3.1" +version = "0.6.0" dependencies = [ "serde", "serde_json", @@ -4345,7 +4345,7 @@ dependencies = [ [[package]] name = "texturecraft-engine" -version = "0.3.1" +version = "0.6.0" dependencies = [ "epaint_default_fonts", "image", @@ -4365,7 +4365,7 @@ dependencies = [ [[package]] name = "texturecraft-formats" -version = "0.3.1" +version = "0.6.0" dependencies = [ "base64 0.22.1", "exr", @@ -4390,7 +4390,7 @@ dependencies = [ [[package]] name = "texturecraft-geom" -version = "0.3.1" +version = "0.6.0" dependencies = [ "glam 0.30.10", "mikktspace", @@ -4401,7 +4401,7 @@ dependencies = [ [[package]] name = "texturecraft-paint" -version = "0.3.1" +version = "0.6.0" dependencies = [ "epaint_default_fonts", "harfrust", @@ -4416,7 +4416,7 @@ dependencies = [ [[package]] name = "texturecraft-render" -version = "0.3.1" +version = "0.6.0" dependencies = [ "bytemuck", "half", @@ -4435,11 +4435,11 @@ dependencies = [ [[package]] name = "texturecraft-texel" -version = "0.3.1" +version = "0.6.0" [[package]] name = "texturecraft-ui-egui" -version = "0.3.1" +version = "0.6.0" dependencies = [ "base64 0.22.1", "craft-dialogs", @@ -4473,7 +4473,7 @@ dependencies = [ [[package]] name = "texturecraft-web" -version = "0.3.1" +version = "0.6.0" dependencies = [ "eframe", "js-sys", @@ -5865,7 +5865,7 @@ checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7" [[package]] name = "xtask" -version = "0.3.1" +version = "0.6.0" dependencies = [ "serde_json", ] diff --git a/Cargo.toml b/Cargo.toml index 29de448b..b67d119b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,7 +5,7 @@ exclude = ["vendor"] default-members = ["crates/core", "crates/texel", "crates/geom", "crates/compose", "crates/bake", "crates/formats", "crates/paint", "crates/engine", "crates/render", "crates/automation", "crates/ui-egui", "apps/texturecraft", "apps/texturecraft-cli", "xtask"] [workspace.package] -version = "0.3.1" +version = "0.6.0" edition = "2024" license = "MIT OR Apache-2.0" rust-version = "1.95" From 23ac2b54530c3548a84beb500c1959f22b7bfe09 Mon Sep 17 00:00:00 2001 From: dotCooCoo Date: Wed, 11 Nov 2026 09:05:36 -0800 Subject: [PATCH 11/39] Updates: take craft-update from craft-libs main at 6e03f65bf Moves the craft-libs pins from 1b34eba41 to 6e03f65bf, which adds the craft-update fixes from craft-libs #763 and #803. --- Cargo.lock | 39 ++++++++++++++++++++------------------- Cargo.toml | 14 +++++++------- 2 files changed, 27 insertions(+), 26 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 19c65129..89ec9f96 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -578,7 +578,7 @@ dependencies = [ "maybe-owned", "rustix 1.1.5", "rustix-linux-procfs", - "windows-sys 0.61.2", + "windows-sys 0.60.2", "winx", ] @@ -758,7 +758,7 @@ dependencies = [ [[package]] name = "craft-dialogs" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" dependencies = [ "block2 0.6.2", "objc2 0.6.5", @@ -771,12 +771,12 @@ dependencies = [ [[package]] name = "craft-fonts-build" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" [[package]] name = "craft-i18n" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" dependencies = [ "fixed_decimal", "icu_decimal", @@ -799,7 +799,7 @@ dependencies = [ [[package]] name = "craft-keymap" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" dependencies = [ "egui", "serde", @@ -809,7 +809,7 @@ dependencies = [ [[package]] name = "craft-menu" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" dependencies = [ "craft-keymap", "craft-quit", @@ -822,7 +822,7 @@ dependencies = [ [[package]] name = "craft-quit" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" dependencies = [ "dispatch2", "egui", @@ -833,7 +833,7 @@ dependencies = [ [[package]] name = "craft-ui" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" dependencies = [ "craft-fonts-build", "craft-i18n", @@ -854,7 +854,7 @@ dependencies = [ [[package]] name = "craft-update" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" dependencies = [ "chrono", "dunce", @@ -864,6 +864,7 @@ dependencies = [ "image", "log", "plist", + "rustix 1.1.5", "semver", "serde", "serde_json", @@ -880,7 +881,7 @@ dependencies = [ [[package]] name = "craft-window" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" dependencies = [ "egui", "objc2 0.6.5", @@ -1319,7 +1320,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" dependencies = [ "libc", - "windows-sys 0.61.2", + "windows-sys 0.60.2", ] [[package]] @@ -2542,7 +2543,7 @@ dependencies = [ "objc2-foundation 0.3.2", "png", "thiserror 2.0.21", - "windows-sys 0.61.2", + "windows-sys 0.60.2", ] [[package]] @@ -3066,7 +3067,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967" dependencies = [ "libc", - "windows-sys 0.61.2", + "windows-sys 0.60.2", ] [[package]] @@ -3710,7 +3711,7 @@ dependencies = [ "errno", "libc", "linux-raw-sys 0.12.1", - "windows-sys 0.61.2", + "windows-sys 0.60.2", ] [[package]] @@ -3777,7 +3778,7 @@ dependencies = [ "security-framework", "security-framework-sys", "webpki-root-certs", - "windows-sys 0.61.2", + "windows-sys 0.60.2", ] [[package]] @@ -4130,7 +4131,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4" dependencies = [ "libc", - "windows-sys 0.61.2", + "windows-sys 0.60.2", ] [[package]] @@ -4245,7 +4246,7 @@ dependencies = [ "getrandom 0.4.3", "once_cell", "rustix 1.1.5", - "windows-sys 0.61.2", + "windows-sys 0.60.2", ] [[package]] @@ -4765,7 +4766,7 @@ checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e" dependencies = [ "memoffset", "tempfile", - "windows-sys 0.61.2", + "windows-sys 0.60.2", ] [[package]] @@ -5360,7 +5361,7 @@ version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" dependencies = [ - "windows-sys 0.61.2", + "windows-sys 0.60.2", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index b67d119b..a466d14b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -65,19 +65,19 @@ getrandom = "0.3" rustix = { version = "1", default-features = false, features = ["std", "fs", "process"] } # Shared Craft egui components (widget palette, icon buttons, panel docking): storytold/craft-libs, # MIT OR Apache-2.0, pinned to one rev. -craft-ui = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", features = ["serde"] } +craft-ui = { git = "https://github.com/storytold/craft-libs", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b", features = ["serde"] } # Who draws the window frame, and the app-drawn strip as the title bar (crates/ui-egui/src/titlebar.rs). -craft-window = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", features = ["egui"] } +craft-window = { git = "https://github.com/storytold/craft-libs", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b", features = ["egui"] } # Release checks, the update prompt and the update helper (crates/ui-egui/src/updates_ui.rs). -craft-update = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", features = ["egui"] } +craft-update = { git = "https://github.com/storytold/craft-libs", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b", features = ["egui"] } # File dialogs that never block the frame (crates/ui-egui/src/file_dialogs.rs). -craft-dialogs = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d" } +craft-dialogs = { git = "https://github.com/storytold/craft-libs", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b" } # Shortcut chords, lookup and dispatch (crates/ui-egui/src/keymap.rs). -craft-keymap = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", features = ["egui"] } +craft-keymap = { git = "https://github.com/storytold/craft-libs", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b", features = ["egui"] } # Quitting the macOS way instead of closing the window (crates/ui-egui/src/windows.rs). -craft-quit = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", features = ["egui"] } +craft-quit = { git = "https://github.com/storytold/craft-libs", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b", features = ["egui"] } # The macOS app menu whose Quit asks about unsaved changes (apps/texturecraft/src/main.rs). -craft-menu = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d" } +craft-menu = { git = "https://github.com/storytold/craft-libs", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b" } # egui 0.37 and winit: the suite's forks (storytold/egui, storytold/winit), as craft-libs pins them. [patch.crates-io] From 5b997827bf4f3c0bb4cbf700af1c758a9fdc92c2 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Wed, 11 Nov 2026 12:45:10 -0500 Subject: [PATCH 12/39] Updates: take craft-update from craft-libs main at 6e03f65bf --- Cargo.lock | 19 ++++++++++--------- Cargo.toml | 14 +++++++------- 2 files changed, 17 insertions(+), 16 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 19c65129..2c1dc8de 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -758,7 +758,7 @@ dependencies = [ [[package]] name = "craft-dialogs" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" dependencies = [ "block2 0.6.2", "objc2 0.6.5", @@ -771,12 +771,12 @@ dependencies = [ [[package]] name = "craft-fonts-build" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" [[package]] name = "craft-i18n" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" dependencies = [ "fixed_decimal", "icu_decimal", @@ -799,7 +799,7 @@ dependencies = [ [[package]] name = "craft-keymap" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" dependencies = [ "egui", "serde", @@ -809,7 +809,7 @@ dependencies = [ [[package]] name = "craft-menu" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" dependencies = [ "craft-keymap", "craft-quit", @@ -822,7 +822,7 @@ dependencies = [ [[package]] name = "craft-quit" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" dependencies = [ "dispatch2", "egui", @@ -833,7 +833,7 @@ dependencies = [ [[package]] name = "craft-ui" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" dependencies = [ "craft-fonts-build", "craft-i18n", @@ -854,7 +854,7 @@ dependencies = [ [[package]] name = "craft-update" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" dependencies = [ "chrono", "dunce", @@ -864,6 +864,7 @@ dependencies = [ "image", "log", "plist", + "rustix 1.1.5", "semver", "serde", "serde_json", @@ -880,7 +881,7 @@ dependencies = [ [[package]] name = "craft-window" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=1b34eba41e62138fc2438d2734523b302840b45d#1b34eba41e62138fc2438d2734523b302840b45d" +source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" dependencies = [ "egui", "objc2 0.6.5", diff --git a/Cargo.toml b/Cargo.toml index b67d119b..a466d14b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -65,19 +65,19 @@ getrandom = "0.3" rustix = { version = "1", default-features = false, features = ["std", "fs", "process"] } # Shared Craft egui components (widget palette, icon buttons, panel docking): storytold/craft-libs, # MIT OR Apache-2.0, pinned to one rev. -craft-ui = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", features = ["serde"] } +craft-ui = { git = "https://github.com/storytold/craft-libs", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b", features = ["serde"] } # Who draws the window frame, and the app-drawn strip as the title bar (crates/ui-egui/src/titlebar.rs). -craft-window = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", features = ["egui"] } +craft-window = { git = "https://github.com/storytold/craft-libs", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b", features = ["egui"] } # Release checks, the update prompt and the update helper (crates/ui-egui/src/updates_ui.rs). -craft-update = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", features = ["egui"] } +craft-update = { git = "https://github.com/storytold/craft-libs", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b", features = ["egui"] } # File dialogs that never block the frame (crates/ui-egui/src/file_dialogs.rs). -craft-dialogs = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d" } +craft-dialogs = { git = "https://github.com/storytold/craft-libs", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b" } # Shortcut chords, lookup and dispatch (crates/ui-egui/src/keymap.rs). -craft-keymap = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", features = ["egui"] } +craft-keymap = { git = "https://github.com/storytold/craft-libs", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b", features = ["egui"] } # Quitting the macOS way instead of closing the window (crates/ui-egui/src/windows.rs). -craft-quit = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d", features = ["egui"] } +craft-quit = { git = "https://github.com/storytold/craft-libs", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b", features = ["egui"] } # The macOS app menu whose Quit asks about unsaved changes (apps/texturecraft/src/main.rs). -craft-menu = { git = "https://github.com/storytold/craft-libs", rev = "1b34eba41e62138fc2438d2734523b302840b45d" } +craft-menu = { git = "https://github.com/storytold/craft-libs", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b" } # egui 0.37 and winit: the suite's forks (storytold/egui, storytold/winit), as craft-libs pins them. [patch.crates-io] From 1ad56c90848e601878994efa0c0bd4cdbeae4550 Mon Sep 17 00:00:00 2001 From: Morion Date: Wed, 11 Nov 2026 13:36:13 -0500 Subject: [PATCH 13/39] Document optional catalog embedding and cached language lookup --- crates/ui-egui/i18n_build.rs | 4 ++++ crates/ui-egui/src/i18n.rs | 1 + 2 files changed, 5 insertions(+) diff --git a/crates/ui-egui/i18n_build.rs b/crates/ui-egui/i18n_build.rs index bc5c3820..422edc07 100644 --- a/crates/ui-egui/i18n_build.rs +++ b/crates/ui-egui/i18n_build.rs @@ -2,6 +2,8 @@ use std::fmt::Write as _; use std::path::Path; +/// Generate Rust includes for the optional catalog checkout; required input must contain app catalogs. +/// Paths are escaped as Rust strings so Windows separators and spaces remain valid. pub fn generate(dir: Option<&Path>, required: bool) -> Result { let mut source = String::from("pub static CRAFT_I18N: &craft_i18n::Embedded = &[\n"); let Some(dir) = dir else { @@ -53,6 +55,8 @@ pub fn generate(dir: Option<&Path>, required: bool) -> Result { Ok(source) } +/// Write the embedding for both desktop and wasm, reporting optional failures as warnings. +/// Required input errors stop Cargo instead of silently shipping an English-only release. pub fn embed() { println!("cargo::rerun-if-env-changed=CRAFT_I18N_DIR"); println!("cargo::rerun-if-env-changed=CRAFT_I18N_REQUIRED"); diff --git a/crates/ui-egui/src/i18n.rs b/crates/ui-egui/src/i18n.rs index a9431af1..90a1db04 100644 --- a/crates/ui-egui/src/i18n.rs +++ b/crates/ui-egui/src/i18n.rs @@ -18,6 +18,7 @@ static I18N: LazyLock = LazyLock::new(|| { static SHARED_LANGUAGES: OnceLock<[craft_i18n::Lang; COUNT]> = OnceLock::new(); +/// Resolve the fixed picker codes once; hot text lookups only load the cached language handle. fn shared_languages() -> &'static [craft_i18n::Lang; COUNT] { SHARED_LANGUAGES.get_or_init(|| LANGUAGES.each_ref().map(|l| I18N.from_code(l.code).unwrap_or(craft_i18n::Lang::EN))) } From 8818f8eef1efcacc2b9f5325fd6f2552a394d5ad Mon Sep 17 00:00:00 2001 From: Morion Date: Wed, 11 Nov 2026 14:40:46 -0500 Subject: [PATCH 14/39] Validate embedded translation catalogs during the build --- crates/ui-egui/Cargo.toml | 1 + crates/ui-egui/i18n_build.rs | 20 +++++++++++++++----- crates/ui-egui/tests/i18n_build.rs | 22 ++++++++++++++++++++++ 3 files changed, 38 insertions(+), 5 deletions(-) diff --git a/crates/ui-egui/Cargo.toml b/crates/ui-egui/Cargo.toml index 63b79f77..c6e42c38 100644 --- a/crates/ui-egui/Cargo.toml +++ b/crates/ui-egui/Cargo.toml @@ -40,6 +40,7 @@ craft-dialogs = { workspace = true } # build.rs: the interface faces lose their Private Use Area, where the icon font draws (the # versions craft-libs' craft-fonts-build subsets with). [build-dependencies] +craft-i18n = { workspace = true } skera = "0.8" skrifa = { version = "0.48", default-features = false, features = ["std"] } diff --git a/crates/ui-egui/i18n_build.rs b/crates/ui-egui/i18n_build.rs index 422edc07..6d0cd6e4 100644 --- a/crates/ui-egui/i18n_build.rs +++ b/crates/ui-egui/i18n_build.rs @@ -28,6 +28,7 @@ pub fn generate(dir: Option<&Path>, required: bool) -> Result { } paths.sort(); let mut count = 0; + let mut catalogs = Vec::new(); for path in paths { // Watch directories too: adding/removing an app catalog must rebuild the embedding. println!("cargo::rerun-if-changed={}", path.display()); @@ -37,20 +38,29 @@ pub fn generate(dir: Option<&Path>, required: bool) -> Result { } let locale = path.file_name().and_then(|n| n.to_str()).ok_or("non-UTF-8 locale")?; let common = path.join("common.tsv"); - let embed = |file: &Path| -> Result { - std::fs::read_to_string(file).map_err(|e| format!("{}: {e}", file.display()))?; + let embed = |file: &Path| -> Result<(String, &'static str), String> { + let text = std::fs::read_to_string(file).map_err(|e| format!("{}: {e}", file.display()))?; let name = file.to_str().ok_or("non-UTF-8 catalog path")?; println!("cargo::rerun-if-changed={name}"); - Ok(format!("include_str!({name:?})")) + // The shared runtime requires static inputs; this short-lived build process owns them. + Ok((format!("include_str!({name:?})"), Box::leak(text.into_boxed_str()))) }; - let shared = if common.is_file() { embed(&common)? } else { "\"\"".into() }; - let app = embed(&app)?; + let (shared, shared_text) = if common.is_file() { embed(&common)? } else { ("\"\"".into(), "") }; + let (app, app_text) = embed(&app)?; + let code: &'static str = Box::leak(locale.to_owned().into_boxed_str()); + catalogs.push((code, shared_text, app_text)); let _ = writeln!(source, " ({locale:?}, {shared}, {app}),"); count += 1; } if required && count == 0 { return Err("no TextureCraft translation catalogs found".into()); } + // Reject the same rows the runtime would skip, before required builds can ship English fallbacks. + let (runtime, mut problems) = craft_i18n::I18n::new(Box::leak(catalogs.into_boxed_slice()), &[]); + problems.extend(runtime.check_all()); + if !problems.is_empty() { + return Err(format!("invalid translation catalogs in {}: {}", locales.display(), problems.join("; "))); + } source.push_str("];\n"); Ok(source) } diff --git a/crates/ui-egui/tests/i18n_build.rs b/crates/ui-egui/tests/i18n_build.rs index d0ff1953..c972cfc7 100644 --- a/crates/ui-egui/tests/i18n_build.rs +++ b/crates/ui-egui/tests/i18n_build.rs @@ -76,3 +76,25 @@ fn generated_paths_compile_and_embed_the_catalog_contents() { assert!(std::process::Command::new("rustc").arg(&source).arg("-o").arg(&binary).status().unwrap().success()); assert!(std::process::Command::new(binary).status().unwrap().success()); } + +#[test] +fn malformed_utf8_catalogs_and_invalid_rows_fail_during_generation() { + for file in ["texturecraft.tsv", "common.tsv"] { + for invalid in [ + "not a TSV row\n", + "\tLayers\t\n", + "\tSave {name}\tGuardar\n", + "\tOpen…\tAbrir\n", + "\tSave\tGuardar\n\tSave\tSalvar\n", + "@plural\t{n} layer|{n} layers\t{n} capa\n", + "@unknown\tSave\tGuardar\n", + ] { + let fixture = Fixture::new(); + std::fs::write(fixture.0.join("locales/es/texturecraft.tsv"), "\tLayers\tCapas\n").unwrap(); + std::fs::write(fixture.0.join("locales/es").join(file), invalid).unwrap(); + for required in [false, true] { + assert!(i18n_build::generate(Some(&fixture.0), required).is_err(), "accepted {file}: {invalid:?}"); + } + } + } +} From 7db38721e0a592e30da40c109167b62f466decda Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Wed, 11 Nov 2026 23:04:44 +0100 Subject: [PATCH 15/39] CI: nightly release dry run (#431) release.yml also runs nightly on main with craft-common-actions' dry-run: every release build except macOS, with nothing signed, pushed or drafted. Breakage that only the release build hits (riscv64, Flatpak, FreeBSD, packaging) then shows up the next morning instead of on release day, as it did on 11 Nov 2026. --- .github/workflows/release.yml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 69e0384b..23727788 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -1,6 +1,10 @@ name: Release on: + # A nightly dry run on main: every release build except macOS, nothing signed or released + # (craft-common-actions release.yml `dry-run`). Finds release-only breakage before release day. + schedule: + - cron: "44 2 * * *" push: branches: [release] workflow_dispatch: @@ -23,6 +27,7 @@ jobs: # Intentionally tracked at @main (not SHA-pinned) so org-wide CI improvements, security fixes, and build optimizations propagate without PR churn across all craftapp repos. uses: storytold/craft-common-actions/.github/workflows/release.yml@main with: + dry-run: ${{ github.event_name == 'schedule' }} app-name: texturecraft app-title: "TextureCraft" craft-fonts-ref: aced4137c022f1f587624d48e81ec77e1914a9cc From 55015a76313c9ec30dfd5a853b5a8d40f5ad38fe Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Wed, 11 Nov 2026 18:38:56 -0500 Subject: [PATCH 16/39] Fix Flatpak updates and bump to 0.6.1 (#426) * fix(flatpak): allow release checks and self-update helpers * test: keep Flatpak permission parsing within strict Clippy rules * chore: bump version to 0.6.1 for the Flatpak update fix * fix(flatpak): honor the launcher version choices --- Cargo.lock | 30 +++++++++---------- Cargo.toml | 2 +- crates/ui-egui/tests/flatpak_updates.rs | 27 +++++++++++++++++ .../ai.storyteller.TextureCraft.bundle.yml | 9 ++++-- .../flatpak/ai.storyteller.TextureCraft.yml | 9 ++++-- 5 files changed, 55 insertions(+), 22 deletions(-) create mode 100644 crates/ui-egui/tests/flatpak_updates.rs diff --git a/Cargo.lock b/Cargo.lock index 89ec9f96..4831abd2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4260,7 +4260,7 @@ dependencies = [ [[package]] name = "texturecraft" -version = "0.6.0" +version = "0.6.1" dependencies = [ "craft-menu", "craft-update", @@ -4281,7 +4281,7 @@ dependencies = [ [[package]] name = "texturecraft-automation" -version = "0.6.0" +version = "0.6.1" dependencies = [ "base64 0.22.1", "cap-std", @@ -4302,7 +4302,7 @@ dependencies = [ [[package]] name = "texturecraft-bake" -version = "0.6.0" +version = "0.6.1" dependencies = [ "bytemuck", "rayon", @@ -4314,7 +4314,7 @@ dependencies = [ [[package]] name = "texturecraft-cli" -version = "0.6.0" +version = "0.6.1" dependencies = [ "image", "serde_json", @@ -4326,7 +4326,7 @@ dependencies = [ [[package]] name = "texturecraft-compose" -version = "0.6.0" +version = "0.6.1" dependencies = [ "half", "rayon", @@ -4337,7 +4337,7 @@ dependencies = [ [[package]] name = "texturecraft-core" -version = "0.6.0" +version = "0.6.1" dependencies = [ "serde", "serde_json", @@ -4346,7 +4346,7 @@ dependencies = [ [[package]] name = "texturecraft-engine" -version = "0.6.0" +version = "0.6.1" dependencies = [ "epaint_default_fonts", "image", @@ -4366,7 +4366,7 @@ dependencies = [ [[package]] name = "texturecraft-formats" -version = "0.6.0" +version = "0.6.1" dependencies = [ "base64 0.22.1", "exr", @@ -4391,7 +4391,7 @@ dependencies = [ [[package]] name = "texturecraft-geom" -version = "0.6.0" +version = "0.6.1" dependencies = [ "glam 0.30.10", "mikktspace", @@ -4402,7 +4402,7 @@ dependencies = [ [[package]] name = "texturecraft-paint" -version = "0.6.0" +version = "0.6.1" dependencies = [ "epaint_default_fonts", "harfrust", @@ -4417,7 +4417,7 @@ dependencies = [ [[package]] name = "texturecraft-render" -version = "0.6.0" +version = "0.6.1" dependencies = [ "bytemuck", "half", @@ -4436,11 +4436,11 @@ dependencies = [ [[package]] name = "texturecraft-texel" -version = "0.6.0" +version = "0.6.1" [[package]] name = "texturecraft-ui-egui" -version = "0.6.0" +version = "0.6.1" dependencies = [ "base64 0.22.1", "craft-dialogs", @@ -4474,7 +4474,7 @@ dependencies = [ [[package]] name = "texturecraft-web" -version = "0.6.0" +version = "0.6.1" dependencies = [ "eframe", "js-sys", @@ -5866,7 +5866,7 @@ checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7" [[package]] name = "xtask" -version = "0.6.0" +version = "0.6.1" dependencies = [ "serde_json", ] diff --git a/Cargo.toml b/Cargo.toml index a466d14b..76f84caa 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,7 +5,7 @@ exclude = ["vendor"] default-members = ["crates/core", "crates/texel", "crates/geom", "crates/compose", "crates/bake", "crates/formats", "crates/paint", "crates/engine", "crates/render", "crates/automation", "crates/ui-egui", "apps/texturecraft", "apps/texturecraft-cli", "xtask"] [workspace.package] -version = "0.6.0" +version = "0.6.1" edition = "2024" license = "MIT OR Apache-2.0" rust-version = "1.95" diff --git a/crates/ui-egui/tests/flatpak_updates.rs b/crates/ui-egui/tests/flatpak_updates.rs new file mode 100644 index 00000000..d7c447db --- /dev/null +++ b/crates/ui-egui/tests/flatpak_updates.rs @@ -0,0 +1,27 @@ +//! Release and source Flatpaks must allow release checks and host update helpers. +fn finish_args(manifest: &str) -> Vec<&str> { + manifest + .split("finish-args:") + .nth(1) + .unwrap_or_default() + .lines() + .take_while(|line| line.is_empty() || line.starts_with(' ') || line.starts_with('#')) + .filter_map(|line| line.trim().strip_prefix("- ")) + .map(|arg| arg.trim_matches(['\'', '"'])) + .collect() +} + +#[test] +fn flatpak_update_permissions() { + let manifests = [ + include_str!("../../../packaging/linux/flatpak/ai.storyteller.TextureCraft.bundle.yml"), + include_str!("../../../packaging/linux/flatpak/ai.storyteller.TextureCraft.yml"), + ]; + let args = manifests.map(finish_args); + assert_eq!(args[0], args[1], "source and release permissions must agree"); + for permissions in args { + for required in ["--share=network", "--talk-name=org.freedesktop.Flatpak", "--filesystem=xdg-data/ArtCraft/versions:ro"] { + assert!(permissions.contains(&required), "missing update permission: {required}"); + } + } +} diff --git a/packaging/linux/flatpak/ai.storyteller.TextureCraft.bundle.yml b/packaging/linux/flatpak/ai.storyteller.TextureCraft.bundle.yml index 259e2396..56d29581 100644 --- a/packaging/linux/flatpak/ai.storyteller.TextureCraft.bundle.yml +++ b/packaging/linux/flatpak/ai.storyteller.TextureCraft.bundle.yml @@ -17,6 +17,12 @@ runtime-version: '26.08' sdk: org.freedesktop.Sdk command: texturecraft finish-args: + # Honor the launcher's pinned and nightly version choices before offering updates. + - --filesystem=xdg-data/ArtCraft/versions:ro + # Release checks and downloads use HTTPS. + - --share=network + # The shared updater inspects and updates this installation via flatpak-spawn --host. + - --talk-name=org.freedesktop.Flatpak # Display: Wayland first; X11 only when no Wayland compositor is running. - --socket=wayland - --socket=fallback-x11 @@ -30,9 +36,6 @@ finish-args: # line, Open Recent, "Save" next to the original) work in the usual places. - --filesystem=xdg-pictures - --filesystem=xdg-documents - # Deliberately not granted: network (the optional --control server listens on 127.0.0.1 in - # the sandbox; `flatpak override --user --share=network ai.storyteller.texturecraft` exposes it to - # host agents) and home/host filesystem access. modules: - name: texturecraft buildsystem: simple diff --git a/packaging/linux/flatpak/ai.storyteller.TextureCraft.yml b/packaging/linux/flatpak/ai.storyteller.TextureCraft.yml index 3b680178..8529d8bc 100644 --- a/packaging/linux/flatpak/ai.storyteller.TextureCraft.yml +++ b/packaging/linux/flatpak/ai.storyteller.TextureCraft.yml @@ -18,6 +18,12 @@ sdk-extensions: - org.freedesktop.Sdk.Extension.rust-stable command: texturecraft finish-args: + # Honor the launcher's pinned and nightly version choices before offering updates. + - --filesystem=xdg-data/ArtCraft/versions:ro + # Release checks and downloads use HTTPS. + - --share=network + # The shared updater inspects and updates this installation via flatpak-spawn --host. + - --talk-name=org.freedesktop.Flatpak # Display: Wayland first; X11 only when no Wayland compositor is running. - --socket=wayland - --socket=fallback-x11 @@ -31,9 +37,6 @@ finish-args: # line, Open Recent, "Save" next to the original) work in the usual places. - --filesystem=xdg-pictures - --filesystem=xdg-documents - # Deliberately not granted: network (the optional --control server listens on 127.0.0.1 in - # the sandbox; `flatpak override --user --share=network ai.storyteller.texturecraft` exposes it to - # host agents) and home/host filesystem access. build-options: append-path: /usr/lib/sdk/rust-stable/bin modules: From e03e6fae6a677a505caf6ac9c971a61e62f177d9 Mon Sep 17 00:00:00 2001 From: test-bit-sys Date: Thu, 12 Nov 2026 17:56:19 +0100 Subject: [PATCH 17/39] fix(engine): reject unparseable colour parameters with an error (#369) (#390) * fix(engine): reject unparseable colour parameters with an error (#369) When a colour parameter cannot be parsed, fail with an error describing the expected color format instead of silently falling back to defaults. Update color_param to return an explicit error and propagate across commands that accept color values. * fix(engine): validate f32 overflow, pre-parse state mutations, and keep UV pairs strict (#369) --- crates/engine/src/commands.rs | 66 +++++++++++++++++++++++++++++++-- crates/engine/src/filter_lib.rs | 7 ++-- crates/engine/src/layer_cmds.rs | 16 +++++--- crates/engine/src/mask_cmds.rs | 6 +-- crates/engine/src/text_cmds.rs | 2 +- crates/engine/src/tool_cmds.rs | 20 +++++----- crates/engine/src/view_cmds.rs | 3 +- crates/engine/tests/session.rs | 49 ++++++++++++++++++++++++ 8 files changed, 141 insertions(+), 28 deletions(-) diff --git a/crates/engine/src/commands.rs b/crates/engine/src/commands.rs index d754fc70..a03a58a9 100644 --- a/crates/engine/src/commands.rs +++ b/crates/engine/src/commands.rs @@ -195,16 +195,26 @@ pub(crate) fn blend_param(cmd: &str, p: &Value, key: &str) -> Result Option<[f32; 3]> { - color_of(p.get(key)?) +pub(crate) fn color_param(cmd: &str, p: &Value, key: &str) -> Result> { + match p.get(key) { + None | Some(Value::Null) => Ok(None), + Some(v) => color_of(v).map(Some).ok_or_else(|| bad(cmd, format!("`{key}` must be a color ([r, g, b] linear or \"#rrggbb\")"))), + } } /// A color value (see [`color_param`]). pub(crate) fn color_of(v: &Value) -> Option<[f32; 3]> { match v { Value::Array(a) if a.len() >= 3 => { - let v: Vec = a.iter().take(3).map(|x| x.as_f64().unwrap_or(0.0) as f32).collect(); - if v.iter().all(|x| x.is_finite()) { Some([v[0], v[1], v[2]]) } else { None } + let mut out = [0.0f32; 3]; + for (i, x) in a.iter().take(3).enumerate() { + let f = x.as_f64()? as f32; + if !f.is_finite() { + return None; + } + out[i] = f; + } + Some(out) } Value::Number(n) => n.as_f64().map(|v| [v as f32; 3]).filter(|v| v[0].is_finite()), Value::String(s) => { @@ -218,3 +228,51 @@ pub(crate) fn color_of(v: &Value) -> Option<[f32; 3]> { _ => None, } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn color_param_accepts_valid_forms() { + let p = json!({ + "hex": "#336699", + "hex_plain": "336699", + "rgb": [0.2, 0.4, 0.6], + "grey": 0.5, + }); + assert!(color_param("cmd", &p, "hex").unwrap().is_some()); + assert!(color_param("cmd", &p, "hex_plain").unwrap().is_some()); + assert_eq!(color_param("cmd", &p, "rgb").unwrap(), Some([0.2, 0.4, 0.6])); + assert_eq!(color_param("cmd", &p, "grey").unwrap(), Some([0.5, 0.5, 0.5])); + assert_eq!(color_param("cmd", &p, "missing").unwrap(), None); + assert_eq!(color_param("cmd", &json!({"c": null}), "c").unwrap(), None); + } + + #[test] + fn color_param_rejects_invalid_forms() { + let bad_cases = [ + ("#fff", "`color` must be a color ([r, g, b] linear or \"#rrggbb\")"), + ("red", "`color` must be a color ([r, g, b] linear or \"#rrggbb\")"), + ("#12345", "`color` must be a color ([r, g, b] linear or \"#rrggbb\")"), + ("#gggggg", "`color` must be a color ([r, g, b] linear or \"#rrggbb\")"), + ]; + for (input, expected_err) in bad_cases { + let p = json!({ "color": input }); + let err = color_param("test.cmd", &p, "color").unwrap_err(); + assert_eq!(err.to_string(), format!("`test.cmd`: {expected_err}")); + } + + let bad_array = json!({ "color": ["a", "b", "c"] }); + assert!(color_param("test.cmd", &bad_array, "color").is_err()); + + let short_array = json!({ "color": [0.5, 0.5] }); + assert!(color_param("test.cmd", &short_array, "color").is_err()); + + let overflow_array = json!({ "color": [1e40, 0.0, 0.0] }); + assert!(color_param("test.cmd", &overflow_array, "color").is_err()); + + let overflow_scalar = json!({ "color": 1e40 }); + assert!(color_param("test.cmd", &overflow_scalar, "color").is_err()); + } +} diff --git a/crates/engine/src/filter_lib.rs b/crates/engine/src/filter_lib.rs index 7856f565..1e7c2b69 100644 --- a/crates/engine/src/filter_lib.rs +++ b/crates/engine/src/filter_lib.rs @@ -253,8 +253,8 @@ pub(crate) fn apply(p: &Value, f: &mut Filter, cmd: &str) -> Result<()> { } Filter::ColorBalance { shadows, midtones, highlights } => { for (key, slot) in [("shadows", shadows), ("midtones", midtones), ("highlights", highlights)] { - if p.get(key).is_some() { - let v = color_param(p, key).ok_or_else(|| bad(cmd, format!("`{key}` must be [r, g, b] offsets in -1..1")))?; + if let Some(val) = p.get(key).filter(|v| !v.is_null()) { + let v = color_of(val).ok_or_else(|| bad(cmd, format!("`{key}` must be [r, g, b] offsets in -1..1")))?; *slot = v.map(|x| x.clamp(-1.0, 1.0)); } } @@ -305,8 +305,7 @@ pub(crate) fn apply(p: &Value, f: &mut Filter, cmd: &str) -> Result<()> { } Filter::ReplaceColor { from, to, tolerance, softness } => { for (key, slot) in [("from", from), ("to", to)] { - if p.get(key).is_some() { - let v = color_param(p, key).ok_or_else(|| bad(cmd, format!("`{key}` must be a color ([r, g, b] linear or \"#rrggbb\")")))?; + if let Some(v) = color_param(cmd, p, key)? { *slot = v.map(|x| x.clamp(0.0, 1.0)); } } diff --git a/crates/engine/src/layer_cmds.rs b/crates/engine/src/layer_cmds.rs index 36cd090c..5d5fc104 100644 --- a/crates/engine/src/layer_cmds.rs +++ b/crates/engine/src/layer_cmds.rs @@ -71,9 +71,9 @@ fn add_paint(s: &mut Session, p: &Value) -> Result { } /// A uniform fill from the `color`, `roughness`, `metallic`, `height` and `opacity` params. -pub(crate) fn fill_from(p: &Value) -> Fill { +pub(crate) fn fill_from(cmd: &str, p: &Value) -> Result { let mut fill = Fill::default(); - if let Some(c) = color_param(p, "color") { + if let Some(c) = color_param(cmd, 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)] { @@ -81,13 +81,13 @@ pub(crate) fn fill_from(p: &Value) -> Fill { fill.sources.insert(ch, Source::Uniform([v; 3])); } } - fill + Ok(fill) } fn add_fill(s: &mut Session, p: &Value) -> Result { 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 fill = fill_from("layer.add.fill", 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))) @@ -316,6 +316,10 @@ fn fill_set(s: &mut Session, p: &Value) -> Result { let solo = boolp(p, "solo") == Some(true); let enabled = if solo { Some(true) } else { boolp(p, "enabled") }; let normal_format = normal_format_param("layer.fill.set", p)?; + let low = color_param("layer.fill.set", p, "low")?.unwrap_or([0.0; 3]); + let high = color_param("layer.fill.set", p, "high")?.unwrap_or([1.0; 3]); + let color = color_param("layer.fill.set", p, "color")?; + let value = color_param("layer.fill.set", p, "value")?; 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); @@ -332,8 +336,8 @@ fn fill_set(s: &mut Session, p: &Value) -> Result { 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::Procedural { pattern: pr, low, high }) + } else if let Some(c) = color.or(value) { Some(Source::Uniform(c)) } else if let Some(name) = strp(p, "image") { Some(Source::Image { name: name.to_string(), normal_format: normal_format.unwrap_or_default() }) diff --git a/crates/engine/src/mask_cmds.rs b/crates/engine/src/mask_cmds.rs index 4c286955..b61e745d 100644 --- a/crates/engine/src/mask_cmds.rs +++ b/crates/engine/src/mask_cmds.rs @@ -141,7 +141,7 @@ fn add_mask(s: &mut Session, p: &Value, bg: MaskBackground) -> Result { } fn add_color_mask(s: &mut Session, p: &Value) -> Result { - let color = color_param(p, "color").unwrap_or([1.0, 0.0, 0.0]); + let color = color_param("mask.add.colorSelection", p, "color")?.unwrap_or([1.0, 0.0, 0.0]); let tolerance = f32p(p, "tolerance").unwrap_or(0.1).clamp(0.0, 1.0); with_mask(s, p, "mask.add.colorSelection", "Add mask with color selection", |s, id| { let eid = s.doc.project.alloc_id(); @@ -285,7 +285,7 @@ fn add_fill(s: &mut Session, p: &Value) -> Result { let blend = blend_param("effect.add.fill", p, "blend")?.unwrap_or(BlendMode::Normal); let id = layer_param(s, "effect.add.fill", p)?; if content_target(p, "effect.add.fill")? { - let mut fill = crate::layer_cmds::fill_from(p); + let mut fill = crate::layer_cmds::fill_from("effect.add.fill", p)?; if fill.sources.is_empty() { fill.sources = s.doc.project.layer(id)?.channels.keys().map(|c| (*c, Source::uniform_of(*c))).collect(); } @@ -337,7 +337,7 @@ fn generator_from(command: &str, params: &Value, generator: &mut Generator) -> R if let Some(invert) = boolp(params, "invert") { generator.invert = invert; } - if let Some(direction) = color_param(params, "direction") { + if let Some(direction) = color_param(command, params, "direction")? { generator.direction = direction; } diff --git a/crates/engine/src/text_cmds.rs b/crates/engine/src/text_cmds.rs index 7f39bd2a..5964813f 100644 --- a/crates/engine/src/text_cmds.rs +++ b/crates/engine/src/text_cmds.rs @@ -100,7 +100,7 @@ fn add_text(s: &mut Session, p: &Value) -> Result { let (font, index) = font_bytes(strp(p, "font"), strp(p, "style"))?; let size = f32p(p, "size").unwrap_or(256.0).clamp(8.0, 1024.0); let img = render_text(&font, index, text, size).map_err(|e| bad(cmd, e))?; - let rgb = color_param(p, "color").unwrap_or([1.0; 3]).map(|c| (texturecraft_texel::linear_to_srgb(c.clamp(0.0, 1.0)) * 255.0).round() as u8); + let rgb = color_param(cmd, p, "color")?.unwrap_or([1.0; 3]).map(|c| (texturecraft_texel::linear_to_srgb(c.clamp(0.0, 1.0)) * 255.0).round() as u8); let png = texturecraft_formats::coverage_png(img.width, img.height, &img.coverage, rgb).map_err(|e| bad(cmd, e.to_string()))?; // The resource is named after the text (its first line, shortened) unless a name is given. let label: String = strp(p, "name").unwrap_or_else(|| text.lines().next().unwrap_or_default()).chars().take(32).collect(); diff --git a/crates/engine/src/tool_cmds.rs b/crates/engine/src/tool_cmds.rs index 6a390866..4c6c4e29 100644 --- a/crates/engine/src/tool_cmds.rs +++ b/crates/engine/src/tool_cmds.rs @@ -6,7 +6,7 @@ use texturecraft_core::Channel; use texturecraft_geom::glam::Vec2; use texturecraft_paint::{Alignment, BrushAlpha, MAX_RADIAL_COPIES, alphas}; -use crate::commands::{CommandSpec, always, bad, boolp, channel_param, color_param, f32p, strp, vec3}; +use crate::commands::{CommandSpec, always, bad, boolp, channel_param, color_of, color_param, f32p, strp, vec3}; use crate::fill_hit_test::FillHitTest; use crate::fill_mode::FillMode; use crate::session::{CloneFrom, CloneSource, StackTarget, Tool}; @@ -285,11 +285,14 @@ pub(crate) fn brush_json(session: &Session) -> Value { } fn material(s: &mut Session, p: &Value) -> Result { + let channel = channel_param("tool.material", p, "channel")?; + let color = color_param("tool.material", p, "color")?; + let value = color_param("tool.material", p, "value")?; if let Some(v) = f32p(p, "maskValue") { s.tool.mask_value = v.clamp(0.0, 1.0); } - if let Some(c) = channel_param("tool.material", p, "channel")? { - if let Some(v) = color_param(p, "color").or_else(|| color_param(p, "value")) { + if let Some(c) = channel { + if let Some(v) = color.or(value) { let v = if c == Channel::Height { v.map(|x| x.clamp(-1.0, 1.0)) } else { v.map(|x| x.clamp(0.0, 1.0)) }; s.tool.values.insert(c, v); s.tool.enabled.insert(c); @@ -356,7 +359,7 @@ fn stencil(s: &mut Session, p: &Value) -> Result { s.tool.stencil = Some(st); } let st = s.tool.stencil.as_mut().ok_or_else(|| bad("tool.stencil", "no stencil: give `image`"))?; - if let Some(c) = color_param(p, "center").map(|c| [c[0], c[1]]).or_else(|| pair(p, "center")) { + if let Some(c) = pair(p, "center").or_else(|| p.get("center").and_then(color_of).map(|c| [c[0], c[1]])) { st.center = c.map(|v| v.clamp(-4.0, 4.0)); } if let Some(v) = f32p(p, "scale") { @@ -378,11 +381,10 @@ fn stencil(s: &mut Session, p: &Value) -> Result { /// A `[a, b]` param of two finite numbers. fn pair(p: &Value, key: &str) -> Option<[f32; 2]> { let a = p.get(key)?.as_array()?; - let v: Vec = a.iter().filter_map(Value::as_f64).map(|x| x as f32).filter(|x| x.is_finite()).collect(); - match v.as_slice() { - [x, y] => Some([*x, *y]), - _ => None, - } + let [x, y] = a.as_slice() else { return None }; + let x = x.as_f64()? as f32; + let y = y.as_f64()? as f32; + (x.is_finite() && y.is_finite()).then_some([x, y]) } fn clone_source(s: &mut Session, p: &Value) -> Result { diff --git a/crates/engine/src/view_cmds.rs b/crates/engine/src/view_cmds.rs index 9fb03ecf..db03435c 100644 --- a/crates/engine/src/view_cmds.rs +++ b/crates/engine/src/view_cmds.rs @@ -211,6 +211,7 @@ fn display(s: &mut Session, p: &Value) -> Result { if let Some(e) = env.as_deref().filter(|e| !e.starts_with(texturecraft_core::project::ENV_RESOURCE_PREFIX) && !ENVIRONMENTS.contains(e)) { return Err(bad("display.set", format!("unknown environment `{e}`: one of {}, or resource:", ENVIRONMENTS.join(", ")))); } + let scatter_color = color_param("display.set", p, "scatterColor")?; let d = &mut s.doc.project.display; if let Some(e) = env { d.environment = e; @@ -236,7 +237,7 @@ fn display(s: &mut Session, p: &Value) -> Result { if let Some(t) = tm { d.tone_mapping = t; } - if let Some(c) = color_param(p, "scatterColor") { + if let Some(c) = scatter_color { d.scatter_color = c.map(|v| v.clamp(0.0, 1.0)); } if let Some(b) = boolp(p, "shadows") { diff --git a/crates/engine/tests/session.rs b/crates/engine/tests/session.rs index 22a17cd5..ddc25049 100644 --- a/crates/engine/tests/session.rs +++ b/crates/engine/tests/session.rs @@ -524,3 +524,52 @@ fn curvature_generators_take_a_mode_and_detail_sizes() { assert!(dirt.is_err(), "only curvature generators have a mode"); assert_eq!(execute(&mut state, "project.inspect", &Value::Null).unwrap().to_string(), inspect, "failed commands leave the project unchanged"); } + +#[test] +fn unparseable_color_param_returns_error() { + let mut s = session(); + let err = execute(&mut s, "layer.add.fill", &json!({"color": "#fff"})).unwrap_err(); + assert_eq!(err.to_string(), "`layer.add.fill`: `color` must be a color ([r, g, b] linear or \"#rrggbb\")"); + + let err = execute(&mut s, "layer.fill.set", &json!({"channel": "baseColor", "color": "#123"})).unwrap_err(); + assert_eq!(err.to_string(), "`layer.fill.set`: `color` must be a color ([r, g, b] linear or \"#rrggbb\")"); + + let err = execute(&mut s, "tool.material", &json!({"channel": "baseColor", "color": "invalid"})).unwrap_err(); + assert_eq!(err.to_string(), "`tool.material`: `color` must be a color ([r, g, b] linear or \"#rrggbb\")"); + + let err = execute(&mut s, "mask.add.colorSelection", &json!({"color": "#xyz"})).unwrap_err(); + assert_eq!(err.to_string(), "`mask.add.colorSelection`: `color` must be a color ([r, g, b] linear or \"#rrggbb\")"); + + let err = execute(&mut s, "display.set", &json!({"scatterColor": "#12345"})).unwrap_err(); + assert_eq!(err.to_string(), "`display.set`: `scatterColor` must be a color ([r, g, b] linear or \"#rrggbb\")"); + + let rev_before = s.revision; + let exposure_before = s.doc.project.display.env_exposure; + let err = execute(&mut s, "display.set", &json!({"exposure": 2.0, "scatterColor": "invalid"})).unwrap_err(); + assert_eq!(err.to_string(), "`display.set`: `scatterColor` must be a color ([r, g, b] linear or \"#rrggbb\")"); + assert_eq!(s.doc.project.display.env_exposure, exposure_before); + assert_eq!(s.revision, rev_before); + + let mask_before = s.tool.mask_value; + let err = execute(&mut s, "tool.material", &json!({"maskValue": 0.25, "channel": "baseColor", "color": "invalid"})).unwrap_err(); + assert_eq!(err.to_string(), "`tool.material`: `color` must be a color ([r, g, b] linear or \"#rrggbb\")"); + assert_eq!(s.tool.mask_value, mask_before); + assert_eq!(s.revision, rev_before); + + let err = execute(&mut s, "tool.material", &json!({"color": "invalid"})).unwrap_err(); + assert_eq!(err.to_string(), "`tool.material`: `color` must be a color ([r, g, b] linear or \"#rrggbb\")"); + assert_eq!(s.revision, rev_before); + + let err = execute(&mut s, "layer.add.fill", &json!({"color": [1e40, 0.0, 0.0]})).unwrap_err(); + assert_eq!(err.to_string(), "`layer.add.fill`: `color` must be a color ([r, g, b] linear or \"#rrggbb\")"); + assert_eq!(s.revision, rev_before); + + let err = execute(&mut s, "layer.fill.set", &json!({"channel": "baseColor", "procedural": "noise", "color": "red"})).unwrap_err(); + assert_eq!(err.to_string(), "`layer.fill.set`: `color` must be a color ([r, g, b] linear or \"#rrggbb\")"); + assert_eq!(s.revision, rev_before); + + assert!(execute(&mut s, "tool.cloneSource", &json!({"uv": [0.2, 0.8, 0.4]})).is_err()); + execute(&mut s, "tool.polygonFill", &Value::Null).unwrap(); + let err = execute(&mut s, "tool.click", &json!({"uv": [0.2, 0.8, 0.4]})).unwrap_err(); + assert_eq!(err.to_string(), "`tool.click`: a 2D view point needs `uv` as [u, v]"); +} From a969983a5259cf2a032e7c5e2614da048b1445db Mon Sep 17 00:00:00 2001 From: test-bit-sys Date: Thu, 12 Nov 2026 17:56:34 +0100 Subject: [PATCH 18/39] fix(engine): resolve resource stem and list available names in layer.add.image (#337) (#391) * fix(engine): resolve resource stem and list available names in layer.add.image (#337) Accept an unambiguous file stem in layer.add.image alongside the full resource name with extension. When the requested resource is not found, list the available resources or guide the user to resource.import. * fix(engine): filter image lookup stems and hints to decoded images (#337) --- crates/engine/src/resource_cmds.rs | 34 ++++++++++++++--- crates/engine/tests/session.rs | 61 ++++++++++++++++++++++++++++++ 2 files changed, 90 insertions(+), 5 deletions(-) diff --git a/crates/engine/src/resource_cmds.rs b/crates/engine/src/resource_cmds.rs index 86e7c9b8..54876d19 100644 --- a/crates/engine/src/resource_cmds.rs +++ b/crates/engine/src/resource_cmds.rs @@ -21,7 +21,7 @@ pub fn specs() -> Vec { "Add fill layer from image", [], None, - "{name, channel?: baseColor, projection?: uv|triplanar|planar, scale?}", + "{name (exact resource name with extension or unique stem), channel?: baseColor, projection?: uv|triplanar|planar, scale?}", always, add_image_fill ), @@ -179,11 +179,35 @@ fn remove_unused(s: &mut Session, _: &Value) -> Result { Ok(json!({ "removed": unused })) } -fn add_image_fill(s: &mut Session, p: &Value) -> Result { - let name = strp(p, "name").ok_or_else(|| bad("layer.add.image", "`name` is required"))?.to_string(); - if !s.doc.resources.contains_key(&name) { - return Err(bad("layer.add.image", format!("no resource `{name}`"))); +#[cfg(not(target_arch = "wasm32"))] +const IMPORT_HINT: &str = "resource.import"; +#[cfg(target_arch = "wasm32")] +const IMPORT_HINT: &str = "File > Import resources"; + +/// Resolve an image resource by exact name or unique file stem. +fn resolve_resource_name(s: &Session, name: &str) -> Result { + if s.images.contains_key(name) { + return Ok(name.to_string()); } + let matches: Vec<&String> = s.images.keys().filter(|k| std::path::Path::new(k).file_stem().and_then(|stem| stem.to_str()) == Some(name)).collect(); + match matches.as_slice() { + [single] => Ok((*single).clone()), + [] => { + let available: Vec<&str> = s.images.keys().map(String::as_str).collect(); + let hint = + if available.is_empty() { format!(" (no resources imported: use {IMPORT_HINT})") } else { format!(" (available: {})", available.join(", ")) }; + Err(bad("layer.add.image", format!("no resource `{name}`{hint}"))) + } + multiple => { + let matches_str = multiple.iter().map(|m| format!("`{m}`")).collect::>().join(", "); + Err(bad("layer.add.image", format!("ambiguous resource `{name}` matches {matches_str}: give the full name with extension"))) + } + } +} + +fn add_image_fill(s: &mut Session, p: &Value) -> Result { + let raw_name = strp(p, "name").ok_or_else(|| bad("layer.add.image", "`name` is required"))?; + let name = resolve_resource_name(s, raw_name)?; let ch = channel_param("layer.add.image", p, "channel")?.unwrap_or(Channel::BaseColor); let projection = crate::layer_cmds::projection_from(p, "layer.add.image", None)?; let ts = s.ts(); diff --git a/crates/engine/tests/session.rs b/crates/engine/tests/session.rs index ddc25049..34f5c4c2 100644 --- a/crates/engine/tests/session.rs +++ b/crates/engine/tests/session.rs @@ -308,6 +308,67 @@ fn image_resources_fill_layers_and_round_trip() { assert!(s.import_resource_bytes("bad.png", vec![1, 2, 3]).is_err()); } +#[test] +fn image_resource_lookup_accepts_extension_and_stem() { + let mut s = session(); + + // No resources imported yet + let err = execute(&mut s, "layer.add.image", &json!({"name": "missing"})).unwrap_err(); + assert!(err.to_string().contains("no resource `missing` (no resources imported: use resource.import)")); + + let mut png = Vec::new(); + let img = image::RgbaImage::from_fn(4, 4, |_, _| image::Rgba([0, 255, 0, 255])); + img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap(); + s.import_resource_bytes("tile.png", png.clone()).unwrap(); + + // Lookup by stem + let r = execute(&mut s, "layer.add.image", &json!({"name": "tile"})).unwrap(); + assert!(r["layer"].as_u64().is_some()); + + // Lookup by full name + let r2 = execute(&mut s, "layer.add.image", &json!({"name": "tile.png"})).unwrap(); + assert!(r2["layer"].as_u64().is_some()); + + // Missing resource lists available + let err = execute(&mut s, "layer.add.image", &json!({"name": "wood"})).unwrap_err(); + assert!(err.to_string().contains("no resource `wood` (available: tile.png)")); + + // Ambiguous stem resolution + s.import_resource_bytes("tile.jpg", png).unwrap(); + let err = execute(&mut s, "layer.add.image", &json!({"name": "tile"})).unwrap_err(); + assert!(err.to_string().contains("ambiguous resource `tile`")); +} + +#[test] +fn image_resource_lookup_ignores_linked_packages() { + use std::sync::Arc; + use texturecraft_engine::core::{LayerId, LayerKind, Source}; + + let mut s = session(); + s.doc.resources.insert("wood.mcraft".into(), Arc::new(b"package bytes".to_vec())); + s.sync_images(); + assert!(!s.images.contains_key("wood.mcraft")); + + let err = execute(&mut s, "layer.add.image", &json!({"name": "wood"})).unwrap_err(); + assert!(err.to_string().contains("no resources imported"), "{err}"); + + let err = execute(&mut s, "layer.add.image", &json!({"name": "wood.mcraft"})).unwrap_err(); + assert!(err.to_string().contains("no resource `wood.mcraft` (no resources imported"), "{err}"); + + let mut png = Vec::new(); + let img = image::RgbaImage::from_fn(4, 4, |_, _| image::Rgba([0, 255, 0, 255])); + img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap(); + s.import_resource_bytes("wood.png", png).unwrap(); + + let err = execute(&mut s, "layer.add.image", &json!({"name": "missing"})).unwrap_err(); + assert!(err.to_string().contains("no resource `missing` (available: wood.png)"), "{err}"); + + let res = execute(&mut s, "layer.add.image", &json!({"name": "wood"})).unwrap(); + let id = LayerId(res["layer"].as_u64().unwrap()); + let LayerKind::Fill(fill) = &s.doc.project.layer(id).unwrap().kind else { panic!("expected fill layer") }; + assert_eq!(fill.sources.get(&Channel::BaseColor), Some(&Source::image("wood.png"))); +} + #[test] fn brush_presets_apply_save_and_load() { let mut s = session(); From 6270aeca05d92527c6e09461efc9b0a35d415137 Mon Sep 17 00:00:00 2001 From: test-bit-sys Date: Thu, 12 Nov 2026 17:56:41 +0100 Subject: [PATCH 19/39] fix(engine): reset paint target to content when undoing mask (#307) (#398) * fix(engine): reset paint target to content when undoing mask (#307) * fix(engine): resolve mask_owner in after_history and clear below cache in test (#307) --- crates/engine/src/session.rs | 4 +++ crates/engine/tests/it/tools.rs | 51 +++++++++++++++++++++++++++++++++ 2 files changed, 55 insertions(+) diff --git a/crates/engine/src/session.rs b/crates/engine/src/session.rs index 41bfacbb..9d58670b 100644 --- a/crates/engine/src/session.rs +++ b/crates/engine/src/session.rs @@ -740,6 +740,10 @@ impl Session { let content = p.effect(e).and_then(|(owner, _)| p.layers.get(&owner)).is_some_and(|l| l.content_effects.iter().any(|x| x.id == e)); self.target = if content { StackTarget::Content } else { StackTarget::Mask }; } + let has_mask = self.selected_layer().and_then(|lid| self.doc.project.layer(self.doc.project.mask_owner(lid)).ok()).is_some_and(|l| l.mask.is_some()); + if self.target == StackTarget::Mask && !has_mask { + self.target = StackTarget::Content; + } } // ----------------------------------------------------------------------------------------- diff --git a/crates/engine/tests/it/tools.rs b/crates/engine/tests/it/tools.rs index afadf0b3..def69c97 100644 --- a/crates/engine/tests/it/tools.rs +++ b/crates/engine/tests/it/tools.rs @@ -244,3 +244,54 @@ fn swap_mask_value_inverts_only_while_a_mask_is_the_target() { assert_eq!(session.tool.mask_value, 0.0, "a mask effect paints the mask too"); } + +#[test] +fn stroke_after_undoing_mask_is_paint_stroke() { + let mut s = Session::new_project("t", primitives::sphere(1.0, 48, 24), "builtin:random", None, 256).unwrap(); + s.viewport = Vec2::new(400.0, 400.0); + execute(&mut s, "layer.add.fill", &json!({"color": [0.2, 0.5, 0.3], "roughness": 0.7})).unwrap(); + execute(&mut s, "layer.add.paint", &Value::Null).unwrap(); + s.update(); + execute(&mut s, "tool.brush", &json!({"size": 20, "hardness": 50, "opacity": 0.8})).unwrap(); + execute(&mut s, "tool.paint", &Value::Null).unwrap(); + execute(&mut s, "tool.material", &json!({"channel": "baseColor", "color": [0.9, 0.3, 0.9]})).unwrap(); + + execute(&mut s, "tool.stroke", &json!({"points": [[130, 130], [170, 150]]})).unwrap(); + s.update(); + execute(&mut s, "mask.add.white", &Value::Null).unwrap(); + s.update(); + execute(&mut s, "edit.undo", &Value::Null).unwrap(); + s.update(); + execute(&mut s, "tool.stroke", &json!({"points": [[167, 183], [207, 203]]})).unwrap(); + s.update(); + + let undone = execute(&mut s, "edit.undo", &Value::Null).unwrap(); + assert_eq!(undone["undone"], "Paint stroke", "the stroke after undoing the mask was recorded as {}", undone["undone"]); + execute(&mut s, "edit.redo", &Value::Null).unwrap(); + s.update(); + + let settled = s.caches[0].composite.clone(); + s.caches[0].below.clear(); + s.caches[0].invalidate_all(); + s.update(); + assert_eq!(settled, s.caches[0].composite, "the composite after the stroke matches a full recomposite"); +} + +#[test] +fn undoing_after_painting_on_instance_source_mask_keeps_mask_target() { + let mut s = Session::new_project("t", primitives::sphere(1.0, 48, 24), "builtin:random", None, 256).unwrap(); + s.viewport = Vec2::new(400.0, 400.0); + execute(&mut s, "layer.add.paint", &Value::Null).unwrap(); + execute(&mut s, "mask.add.white", &Value::Null).unwrap(); + execute(&mut s, "layer.instance", &Value::Null).unwrap(); + s.update(); + s.target = StackTarget::Mask; + execute(&mut s, "tool.brush", &json!({"size": 20, "hardness": 50, "opacity": 0.8})).unwrap(); + execute(&mut s, "tool.stroke", &json!({"points": [[170, 180], [210, 200]]})).unwrap(); + execute(&mut s, "edit.undo", &Value::Null).unwrap(); + assert_eq!(s.target, StackTarget::Mask); + + execute(&mut s, "tool.stroke", &json!({"points": [[180, 180], [210, 200]]})).unwrap(); + let undone = execute(&mut s, "edit.undo", &Value::Null).unwrap(); + assert_eq!(undone["undone"], "Mask stroke"); +} From feb2a83b851e1095038ae530b1b706966ad2d5b6 Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Thu, 12 Nov 2026 21:59:43 +0100 Subject: [PATCH 20/39] test(cli): resolve binary paths after nextest archive relocation (#454) --- apps/texturecraft-cli/tests/cli.rs | 26 ++++++++++++++++++++++++-- 1 file changed, 24 insertions(+), 2 deletions(-) diff --git a/apps/texturecraft-cli/tests/cli.rs b/apps/texturecraft-cli/tests/cli.rs index 686bee97..4cb6a5aa 100644 --- a/apps/texturecraft-cli/tests/cli.rs +++ b/apps/texturecraft-cli/tests/cli.rs @@ -1,12 +1,34 @@ //! Drives the `texturecraft-cli` binary. +use std::ffi::OsString; use std::path::{Path, PathBuf}; use std::process::{Command, Output}; use serde_json::Value; +// Nextest 0.9.130+ remaps this variable when an archive is extracted on another +// runner. Cargo's compile-time path still supports ordinary `cargo test`. +fn cli_binary() -> OsString { + cli_binary_path(std::env::var_os("CARGO_BIN_EXE_texturecraft-cli")) +} + +fn cli_binary_path(runner_path: Option) -> OsString { + runner_path.unwrap_or_else(|| env!("CARGO_BIN_EXE_texturecraft-cli").into()) +} + +#[test] +fn cli_binary_prefers_relocated_runner_path() { + let relocated = OsString::from("relocated archive/texturecraft-cli"); + assert_eq!(cli_binary_path(Some(relocated.clone())), relocated); +} + +#[test] +fn cli_binary_defaults_to_cargo_path() { + assert_eq!(cli_binary_path(None), OsString::from(env!("CARGO_BIN_EXE_texturecraft-cli"))); +} + fn cli(args: &[&str]) -> Output { - Command::new(env!("CARGO_BIN_EXE_texturecraft-cli")).args(args).output().unwrap() + Command::new(cli_binary()).args(args).output().unwrap() } fn ok(args: &[&str]) -> String { @@ -101,7 +123,7 @@ fn info_on_a_mesh_reports_uvs() { fn serve_takes_the_automation_root_spelling_too() { use std::io::Write as _; let d = tmp("automation-root"); - let mut child = Command::new(env!("CARGO_BIN_EXE_texturecraft-cli")) + let mut child = Command::new(cli_binary()) .args(["serve", "--automation-write-root", p(&d)]) .stdin(std::process::Stdio::piped()) .stdout(std::process::Stdio::piped()) From a03f14ea88c7538e884d226ce3ca195712837e8b Mon Sep 17 00:00:00 2001 From: Chris Hassebrook Date: Thu, 12 Nov 2026 16:21:42 -0500 Subject: [PATCH 21/39] Updating CI with local profile for faster runs (#453) * Run CI on stable Rust and check layering earlier * Add a faster profile for optimized verification --- .github/workflows/ci.yml | 1 - Cargo.toml | 7 +++++++ docs/testing-ci.md | 25 +++++++++++++++++++++++++ xtask/src/main.rs | 5 +++-- 4 files changed, 35 insertions(+), 3 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 7bef15d1..1145b532 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -24,7 +24,6 @@ jobs: # Same craft-fonts commit as release.yml. craft-fonts-ref: aced4137c022f1f587624d48e81ec77e1914a9cc os: '["ubuntu-24.04","windows-latest"]' - toolchain: "1.96.0" # xtask ci runs cargo test (including doctests), not cargo nextest. tools: "" packages: >- diff --git a/Cargo.toml b/Cargo.toml index 692bd9f4..cb9745b5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -117,6 +117,13 @@ opt-level = 1 lto = "thin" codegen-units = 1 +# Fast optimized verification: each test executable otherwise repeats cross-crate LTO. +# `false` keeps thin LTO within each crate; release packaging keeps the profile above. +[profile.verify] +inherits = "release" +lto = false +codegen-units = 16 + [profile.wasm-release] inherits = "release" opt-level = "s" diff --git a/docs/testing-ci.md b/docs/testing-ci.md index 7db9ae07..4fb8d5fd 100644 --- a/docs/testing-ci.md +++ b/docs/testing-ci.md @@ -12,6 +12,31 @@ Run a feature module with a test-name filter, for example: cargo test -p texturecraft-engine --test it bake:: ``` +For faster optimized local verification, run the same workspace tests and doctests +with the `verify` profile: + +```sh +cargo test --workspace --profile verify +``` + +`verify` inherits the release profile's optimization level and runtime checks, but +uses 16 codegen units and `lto = false`. Cargo retains thin LTO within each crate +without repeating cross-crate LTO for every test executable. The existing test +selection and ignore attributes still apply. Keep the target directory between +runs so Cargo can reuse unchanged build artifacts. + +To compile the normal application binaries alongside the test binaries before +running them: + +```sh +cargo build --workspace --bins --tests --profile verify +cargo test --workspace --profile verify +``` + +This profile is for local verification. Use `--release` for release validation and +performance measurements; its compiler settings remain unchanged. The regular +debug test profile and CI gates also remain unchanged. + The standalone engine `session` target and UI `ui_snapshots` target remain available for the commands in `AGENTS.md`. Existing ignore attributes are unchanged. Tests in the shared executable can run concurrently across modules; diff --git a/xtask/src/main.rs b/xtask/src/main.rs index ccbdc2c7..2ff6178a 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -15,7 +15,7 @@ usage: cargo xtask commands: layers enforce the crate dependency layering (xtask/src/layers.rs) wasm cargo check --target wasm32-unknown-unknown for the wasm crates and the web app - ci fmt --check, clippy -D warnings, test, layers, wasm (stops at the first failure) + ci fmt --check, layers, clippy -D warnings, test, wasm (stops at the first failure) version [set X.Y.Z[-pre]] print the workspace version, or set it (Cargo.toml + Cargo.lock) ico ... @@ -154,11 +154,12 @@ fn cmd_ci() -> Result<(), String> { } }; type Step = (&'static str, Box Result<(), String>>); + // Reject invalid dependency layering before spending time compiling and running the workspace. let steps: Vec = vec![ ("fmt", Box::new(cargo_step(&["fmt", "--all", "--", "--check"]))), + ("layers", Box::new(cmd_layers)), ("clippy", Box::new(cargo_step(&["clippy", "--workspace", "--all-targets", "--", "-D", "warnings"]))), ("test", Box::new(cargo_step(&["test", "--workspace"]))), - ("layers", Box::new(cmd_layers)), ("wasm", Box::new(cmd_wasm)), ]; for (i, (name, step)) in steps.iter().enumerate() { From aa99a798a7e64c9b00cb2e13b434c75ee38ddea1 Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Fri, 13 Nov 2026 00:15:49 +0100 Subject: [PATCH 22/39] test(formats): split malformed scene fixtures for parallel CI (#455) --- crates/formats/src/mesh_import/scene_tests.rs | 43 ++++++++++++++++++- 1 file changed, 41 insertions(+), 2 deletions(-) diff --git a/crates/formats/src/mesh_import/scene_tests.rs b/crates/formats/src/mesh_import/scene_tests.rs index 5c5f4b5a..09515423 100644 --- a/crates/formats/src/mesh_import/scene_tests.rs +++ b/crates/formats/src/mesh_import/scene_tests.rs @@ -589,19 +589,55 @@ fn fbx_old_versions_and_garbage_are_errors() { assert!(import_mesh_bytes("h.fbx", &huge).is_err()); } +// Keep these fixtures independently schedulable: one serial test took 24 minutes in +// instrumented coverage. Splitting cases keeps every mutation and assertion intact. #[test] -fn malformed_fbx_and_dae_never_panic() { +fn malformed_fbx_and_dae_never_panic_binary_7400() { hammer("x.fbx", &binary_fbx(&scene(false), 7400, false)); +} + +#[test] +fn malformed_fbx_and_dae_never_panic_binary_7500() { hammer("x.fbx", &binary_fbx(&scene(true), 7500, true)); +} + +#[test] +fn malformed_fbx_and_dae_never_panic_ascii() { hammer("x.fbx", ascii_fbx(&scene(false)).as_bytes()); +} + +#[test] +fn malformed_fbx_and_dae_never_panic_collada() { hammer("x.dae", DAE.as_bytes()); +} + +#[test] +fn malformed_fbx_and_dae_never_panic_random_binary() { + random_scene_corruptions(0); +} + +#[test] +fn malformed_fbx_and_dae_never_panic_random_ascii() { + random_scene_corruptions(1); +} + +#[test] +fn malformed_fbx_and_dae_never_panic_random_collada() { + random_scene_corruptions(2); +} + +fn random_scene_corruptions(selected_fixture: usize) { // Random multi-byte corruptions (a fixed LCG keeps failures reproducible). let mut seed = 0x2545_f491_4f6c_dd1du64; let mut next = move || { seed = seed.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407); (seed >> 33) as usize }; - for good in [binary_fbx(&scene(false), 7500, true), ascii_fbx(&scene(true)).into_bytes(), DAE.as_bytes().to_vec()] { + // Replay earlier mutations without parsing them so each fixture receives exactly + // its original LCG stream, not a fresh seed. Fixture sizes and all 1,500 cases + // per fixture stay unchanged; generating these bytes is cheap next to parsing. + let fixtures = [binary_fbx(&scene(false), 7500, true), ascii_fbx(&scene(true)).into_bytes(), DAE.as_bytes().to_vec()]; + for (fixture, good) in fixtures.into_iter().enumerate().take(selected_fixture + 1) { let name = if good.starts_with(b" Date: Fri, 13 Nov 2026 02:28:43 -0500 Subject: [PATCH 23/39] fix(compose): retain curvature cache layout variants (#459) --- crates/compose/src/curvature_sizes.rs | 50 +++++++++++++++++++++------ 1 file changed, 40 insertions(+), 10 deletions(-) diff --git a/crates/compose/src/curvature_sizes.rs b/crates/compose/src/curvature_sizes.rs index d04e7f62..ab01f627 100644 --- a/crates/compose/src/curvature_sizes.rs +++ b/crates/compose/src/curvature_sizes.rs @@ -125,8 +125,9 @@ fn store(curvature: &Arc>, key: CacheKey, scales: &BlockScales, sizes: sizes }; - // One layout per curvature map, with the most recently used map at the end - cache.retain(|(source, ..)| source.strong_count() > 0 && !std::ptr::eq(source.as_ptr(), Arc::as_ptr(curvature))); + // Keep distinct layouts: thumbnails and the viewport alternate on the same bake. + // Replacing only this variant prevents them from repeatedly rebuilding each other. + cache.retain(|entry| entry.0.strong_count() > 0 && !is_entry_for(entry, curvature, key, scales)); let sizes = Arc::new(sizes); cache.push((Arc::downgrade(curvature), key, scales.clone(), sizes.clone())); trim_cache(&mut cache, CACHE_BYTES); @@ -338,6 +339,7 @@ mod tests { #[test] fn unused_maps_are_evicted_even_while_undo_keeps_the_sources_alive() { + let _guard = CACHE_TESTS.lock().unwrap_or_else(|poisoned| poisoned.into_inner()); let sources: Vec<_> = (0..=CACHE_MAPS).map(|_| Arc::new(vec![0.5; 16])).collect(); let scales = BlockScales::default(); let key = ((4, 4), (4, 4), (4, 4)); @@ -408,18 +410,46 @@ mod tests { } } + // Cache lifecycle tests must not evict each other's entries in parallel. + static CACHE_TESTS: Mutex<()> = Mutex::new(()); + #[test] - fn a_new_layout_replaces_the_sizes_of_the_old_one() { + fn alternating_layouts_reuse_their_cached_sizes() { + let _guard = CACHE_TESTS.lock().unwrap_or_else(|poisoned| poisoned.into_inner()); let curvature = Arc::new(vec![0.5; 16]); let scales = BlockScales::default(); - let entries_for_curvature = || { - let cache = CACHE.lock().unwrap_or_else(|poisoned| poisoned.into_inner()); - cache.iter().filter(|(source, ..)| std::ptr::eq(source.as_ptr(), Arc::as_ptr(&curvature))).count() - }; + let viewport_key = ((4, 4), (4, 4), (4, 4)); + let thumbnail_key = ((4, 4), (4, 4), (2, 2)); + let viewport = store(&curvature, viewport_key, &scales, CurvatureSizes { levels: Vec::new() }); + let thumbnail = store(&curvature, thumbnail_key, &scales, CurvatureSizes { levels: Vec::new() }); - store(&curvature, ((4, 4), (4, 4), (4, 4)), &scales, CurvatureSizes { levels: Vec::new() }); - store(&curvature, ((4, 4), (2, 2), (8, 8)), &scales, CurvatureSizes { levels: Vec::new() }); - assert_eq!(entries_for_curvature(), 1, "only the latest layout of a curvature map stays cached"); + assert!(Arc::ptr_eq(&cached(&curvature, viewport_key, &scales).unwrap(), &viewport), "a thumbnail must not evict the viewport layout"); + assert!(Arc::ptr_eq(&cached(&curvature, thumbnail_key, &scales).unwrap(), &thumbnail), "both layouts stay reusable"); + let mut set = texturecraft_core::TextureSet::new("Tiles", 0, 4); + set.uv_tiles = vec![1001, 1002]; + set.tile_resolutions.insert(1002, 2); + let scaled = set.block_scales(); + assert_ne!(scaled, scales); + assert!(cached(&curvature, viewport_key, &scaled).is_none(), "different tile scales cannot read the unscaled result"); + let scaled_sizes = store(&curvature, viewport_key, &scaled, CurvatureSizes { levels: Vec::new() }); + assert!(Arc::ptr_eq(&cached(&curvature, viewport_key, &scaled).unwrap(), &scaled_sizes)); + assert!(Arc::ptr_eq(&cached(&curvature, viewport_key, &scales).unwrap(), &viewport), "scale variants also coexist"); + let replacement = store(&curvature, viewport_key, &scales, CurvatureSizes { levels: Vec::new() }); + assert!(Arc::ptr_eq(&cached(&curvature, viewport_key, &scales).unwrap(), &replacement)); + assert!(Arc::ptr_eq(&cached(&curvature, thumbnail_key, &scales).unwrap(), &thumbnail), "updating one layout keeps the other"); + } + + #[test] + fn layout_variants_obey_the_entry_limit() { + let _guard = CACHE_TESTS.lock().unwrap_or_else(|poisoned| poisoned.into_inner()); + let curvature = Arc::new(vec![0.5; 16]); + let scales = BlockScales::default(); + let key = |size| ((4, 4), (4, 4), (size, size)); + for size in 1..=CACHE_MAPS as u32 + 1 { + store(&curvature, key(size), &scales, CurvatureSizes { levels: Vec::new() }); + } + assert!(cached(&curvature, key(1), &scales).is_none(), "layout variants cannot grow without bound"); + assert!(cached(&curvature, key(CACHE_MAPS as u32 + 1), &scales).is_some(), "the newest layout stays cached"); } #[test] From 73c9f8f70546064d119a6be0c973fa319d2e05ac Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Fri, 13 Nov 2026 11:13:08 +0100 Subject: [PATCH 24/39] Bound FBX instance control-point work (#466) Co-authored-by: FredApps --- crates/formats/src/mesh_import/fbx.rs | 30 +++++++++++++++++++++++++-- 1 file changed, 28 insertions(+), 2 deletions(-) diff --git a/crates/formats/src/mesh_import/fbx.rs b/crates/formats/src/mesh_import/fbx.rs index 5e975ba2..22599844 100644 --- a/crates/formats/src/mesh_import/fbx.rs +++ b/crates/formats/src/mesh_import/fbx.rs @@ -32,6 +32,8 @@ const MIN_VERSION: i64 = 6000; const MAX_DEPTH: usize = 64; /// Memory budget for parsed nodes and properties (arrays are held as f64). const MAX_DECODED_BYTES: usize = 1 << 31; +/// Maximum control points transformed across all mesh instances in one import. +const MAX_INSTANCE_POINTS: usize = 200_000_000; /// Approximate memory charged per node and per scalar property. const NODE_COST: usize = 96; const PROP_COST: usize = 32; @@ -550,6 +552,7 @@ fn read_inner(bytes: &[u8], files: &mut Files) -> Result { let base_colors = base_colors(&materials, &textures, &videos, &connections, files); let global = global_transform(root("GlobalSettings").or_else(|| objects.child("GlobalSettings"))); let mut sink = PolygonSink::default(); + let mut remaining_points = MAX_INSTANCE_POINTS; let no_slots = Vec::new(); for (geom, model) in instances { let Some(g) = geometries.get(&geom) else { continue }; @@ -564,7 +567,7 @@ fn read_inner(bytes: &[u8], files: &mut Files) -> Result { } }; let names = model.as_ref().and_then(|m| slots.get(m)).unwrap_or(&no_slots); - add_geometry(&mut sink, g, global * m, names)?; + add_geometry(&mut sink, g, global * m, names, &mut remaining_points)?; } let mut raw = sink.finish(); raw.base_colors = base_colors; @@ -783,9 +786,12 @@ impl Layer<'_> { } } -fn add_geometry(sink: &mut PolygonSink, geometry: &Node, transform: Mat4, slots: &[String]) -> Result<()> { +fn add_geometry(sink: &mut PolygonSink, geometry: &Node, transform: Mat4, slots: &[String], remaining_points: &mut usize) -> Result<()> { let vertices = geometry.child("Vertices").map(Node::arr).unwrap_or_default(); check_vertices(vertices.len() / 3)?; + *remaining_points = remaining_points + .checked_sub(vertices.len() / 3) + .ok_or_else(|| FormatError::TooLarge(format!("FBX instances exceed the {MAX_INSTANCE_POINTS} control-point work limit")))?; let points: Vec = vertices.as_chunks::<3>().0.iter().map(|c| transform.transform_point3(Vec3::new(c[0] as f32, c[1] as f32, c[2] as f32))).collect(); let polygon_indices = geometry.child("PolygonVertexIndex").map(Node::arr).unwrap_or_default(); let normals = Layer::read(geometry, "LayerElementNormal", "Normals", "NormalsIndex"); @@ -839,3 +845,23 @@ fn add_geometry(sink: &mut PolygonSink, geometry: &Node, transform: Mat4, slots: Ok(()) } + +#[cfg(test)] +mod instance_budget_tests { + use super::*; + + #[test] + fn instance_points_are_charged_before_transforming_each_copy() { + let geometry = Node { + name: "Geometry".into(), + props: vec![], + children: vec![Node { name: "Vertices".into(), props: vec![Prop::Arr(vec![0.0; 9])], children: vec![] }], + }; + let mut sink = PolygonSink::default(); + let mut remaining = 5; + add_geometry(&mut sink, &geometry, Mat4::IDENTITY, &[], &mut remaining).unwrap(); + assert_eq!(remaining, 2); + assert!(matches!(add_geometry(&mut sink, &geometry, Mat4::IDENTITY, &[], &mut remaining), Err(FormatError::TooLarge(_)))); + assert_eq!(remaining, 2); + } +} From 277bbf3cf1057b856a151741b048bc26389f584e Mon Sep 17 00:00:00 2001 From: Morion Tutoriales <100455929+MorionTutoriales@users.noreply.github.com> Date: Fri, 13 Nov 2026 05:20:01 -0500 Subject: [PATCH 25/39] Import glTF scenes that have no nodes array (#438) (#457) * Import glTF scenes that have no nodes array (#438) The gltf crate requires scene.nodes, but the glTF 2.0 schema lists no required properties for a scene. Blender writes such scenes for scenes with no exported objects, so a file whose default scene was fine failed with 'missing field nodes'. Treat a missing array as empty before the document is built. * Test GLB import with an empty scene --------- Co-authored-by: FredApps --- crates/formats/src/mesh_import/gltf.rs | 28 ++++++++++++++++- crates/formats/src/mesh_import/tests.rs | 42 +++++++++++++++++++++++++ 2 files changed, 69 insertions(+), 1 deletion(-) diff --git a/crates/formats/src/mesh_import/gltf.rs b/crates/formats/src/mesh_import/gltf.rs index 21658033..136e3e0c 100644 --- a/crates/formats/src/mesh_import/gltf.rs +++ b/crates/formats/src/mesh_import/gltf.rs @@ -20,8 +20,34 @@ pub(crate) fn read(bytes: &[u8]) -> Result { crate::guard(KIND, || read_inner(bytes)) } +/// Loads and validates the document like `gltf::Gltf::from_slice`, except that a scene without a +/// `nodes` array is an empty scene. The `gltf` crate declares the field as required, but the +/// glTF 2.0 schema lists no required properties for a scene, and exporters write such scenes +/// for scenes that contain no objects. +fn parse(bytes: &[u8]) -> Result<(gltf::Document, Option>)> { + let (json, blob) = if bytes.starts_with(b"glTF") { + let mut glb = gltf::Glb::from_slice(bytes).map_err(|e| malformed(KIND, e))?; + let blob = glb.bin.take().map(std::borrow::Cow::into_owned); + (glb.json.into_owned(), blob) + } else { + (bytes.to_vec(), None) + }; + let mut value: serde_json::Value = serde_json::from_slice(&json).map_err(|e| malformed(KIND, e))?; + if let Some(scenes) = value.get_mut("scenes").and_then(serde_json::Value::as_array_mut) { + for scene in scenes { + if let Some(scene) = scene.as_object_mut() { + scene.entry("nodes").or_insert_with(|| serde_json::Value::Array(Vec::new())); + } + } + } + let json = serde_json::to_vec(&value).map_err(|e| malformed(KIND, e))?; + let root = gltf::json::Root::from_slice(&json).map_err(|e| malformed(KIND, e))?; + let document = gltf::Document::from_json(root).map_err(|e| malformed(KIND, e))?; + Ok((document, blob)) +} + fn read_inner(bytes: &[u8]) -> Result { - let gltf::Gltf { document, blob } = gltf::Gltf::from_slice(bytes).map_err(|e| malformed(KIND, e))?; + let (document, blob) = parse(bytes)?; check_buffer_uris(&document)?; let buffers = gltf::import_buffers(&document, None, blob).map_err(|e| match e { gltf::Error::ExternalReferenceInSliceImport => FormatError::Unsupported( diff --git a/crates/formats/src/mesh_import/tests.rs b/crates/formats/src/mesh_import/tests.rs index e55f8eae..a78e5742 100644 --- a/crates/formats/src/mesh_import/tests.rs +++ b/crates/formats/src/mesh_import/tests.rs @@ -118,6 +118,48 @@ fn glb_two_materials_mirrored_node() { m.validate().unwrap(); } +/// A scene without a `nodes` array is legal glTF (Blender writes one for a scene with no exported +/// objects); it must not stop the default scene from importing. +#[test] +fn gltf_scene_without_nodes_imports_the_default_scene() { + let mut json: serde_json::Value = serde_json::from_slice(&embedded_gltf()).unwrap(); + json["scenes"] = serde_json::json!([{ "name": "EmptyReviewScene" }, { "nodes": [0] }]); + json["scene"] = 1.into(); + let im = import_mesh_bytes("scene.gltf", &serde_json::to_vec(&json).unwrap()).unwrap(); + assert_eq!(im.report.triangles, 2); + // Only an empty scene: nothing to import, but a clear error rather than a parse failure. + json["scenes"] = serde_json::json!([{ "name": "EmptyReviewScene" }]); + json["scene"] = 0.into(); + let err = import_mesh_bytes("scene.gltf", &serde_json::to_vec(&json).unwrap()).unwrap_err(); + assert!(!err.to_string().contains("missing field"), "{err}"); +} + +#[test] +fn glb_scene_without_nodes_keeps_binary_mesh_in_default_scene() { + let original = glb(true, true); + let jlen = u32::from_le_bytes(original[12..16].try_into().unwrap()) as usize; + let mut json: serde_json::Value = serde_json::from_slice(&original[20..20 + jlen]).unwrap(); + json["scenes"] = serde_json::json!([{ "name": "EmptyReviewScene" }, { "nodes": [0] }]); + json["scene"] = 1.into(); + let mut js = serde_json::to_vec(&json).unwrap(); + while !js.len().is_multiple_of(4) { + js.push(b' '); + } + let bin_chunk = &original[20 + jlen..]; + let mut glb = Vec::new(); + glb.extend(b"glTF"); + glb.extend(2u32.to_le_bytes()); + glb.extend(((20 + js.len() + bin_chunk.len()) as u32).to_le_bytes()); + glb.extend((js.len() as u32).to_le_bytes()); + glb.extend(b"JSON"); + glb.extend(js); + glb.extend(bin_chunk); + let im = import_mesh_bytes("scene.glb", &glb).unwrap(); + assert_eq!(im.report.triangles, 2); + assert_eq!(im.mesh.materials, ["Red", "Material_1"]); + assert_outward(&im.mesh); +} + #[test] fn gltf_embedded_buffers_and_missing_attributes() { let im = import_mesh_bytes("scene.gltf", &embedded_gltf()).unwrap(); From 9f4ef44bd883d17c6f205f75c0d8c7050b6d6429 Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Fri, 13 Nov 2026 11:41:00 +0100 Subject: [PATCH 26/39] Decode half-float Alembic properties (#467) Co-authored-by: FredApps --- crates/formats/src/mesh_import/abc/mod.rs | 3 +- crates/formats/src/mesh_import/abc/tests.rs | 32 +++++++++++++++++++++ 2 files changed, 34 insertions(+), 1 deletion(-) diff --git a/crates/formats/src/mesh_import/abc/mod.rs b/crates/formats/src/mesh_import/abc/mod.rs index fd9a7f46..5a19982c 100644 --- a/crates/formats/src/mesh_import/abc/mod.rs +++ b/crates/formats/src/mesh_import/abc/mod.rs @@ -217,7 +217,7 @@ impl<'a> Ogawa<'a> { let value_bytes = match property.pod { 0..=2 => 1, - 3 | 4 => 2, + 3 | 4 | 9 => 2, 5 | 6 | 10 => 4, 7 | 8 | 11 => 8, other => return Err(FormatError::Unsupported(format!("Alembic property \"{}\" of data type {other}", property.name))), @@ -233,6 +233,7 @@ impl<'a> Ogawa<'a> { 6 => raw.as_chunks::<4>().0.iter().map(|c| i32::from_le_bytes(*c) as f64).collect(), 7 => raw.as_chunks::<8>().0.iter().map(|c| u64::from_le_bytes(*c) as f64).collect(), 8 => raw.as_chunks::<8>().0.iter().map(|c| i64::from_le_bytes(*c) as f64).collect(), + 9 => raw.as_chunks::<2>().0.iter().map(|c| half::f16::from_bits(u16::from_le_bytes(*c)).to_f64()).collect(), 10 => raw.as_chunks::<4>().0.iter().map(|c| f32::from_le_bytes(*c) as f64).collect(), _ => raw.as_chunks::<8>().0.iter().map(|c| f64::from_le_bytes(*c)).collect(), }) diff --git a/crates/formats/src/mesh_import/abc/tests.rs b/crates/formats/src/mesh_import/abc/tests.rs index dfba3ba9..fecb0623 100644 --- a/crates/formats/src/mesh_import/abc/tests.rs +++ b/crates/formats/src/mesh_import/abc/tests.rs @@ -243,6 +243,38 @@ fn strip_alone_keeps_uvs_flipped_to_v_down() { } } +#[test] +fn half_float_uvs_import_without_losing_values() { + let mut a = Abc { w: Writer::new() }; + let pp = a.array("P", "", F32, 3, &f32s(&[0.0, 0.0, 0.0, 0.5, 1.0, 0.0, 1.0, 0.0, 0.0])); + let fi = a.array(".faceIndices", "", I32, 1, &i32s(&[0, 1, 2])); + let fc = a.array(".faceCounts", "", I32, 1, &i32s(&[3])); + let uv_bytes: Vec = [0u16, 0, 0x3800, 0x3c00, 0x3c00, 0].iter().flat_map(|x| x.to_le_bytes()).collect(); + let uv = a.array("uv", "", 9, 2, &uv_bytes); + let geom = a.compound(".geom", "schema=AbcGeom_PolyMesh_v1", vec![pp, fi, fc, uv]); + let mesh = a.object(vec![geom], &[]); + let top = a.object(vec![], &[("m", "", mesh)]); + let imported = crate::import_mesh_bytes("m.abc", &a.archive(top, &["schema=AbcGeom_PolyMesh_v1"])).unwrap(); + assert!(!imported.report.uvs_generated); + for (p, uv) in imported.mesh.positions.iter().zip(&imported.mesh.uvs) { + assert_eq!(*uv, texturecraft_geom::glam::Vec2::new(p.x, 1.0 - p.y)); + } +} + +#[test] +fn half_float_values_preserve_special_values() { + let mut a = Abc { w: Writer::new() }; + let raw: Vec = [0xc000u16, 0x0001, 0x7c00, 0x7e00].iter().flat_map(|x| x.to_le_bytes()).collect(); + let p = a.array("values", "", 9, 1, &raw); + let property = Prop { name: p.name.into(), meta: p.meta, kind: PropKind::Array, pod: 9, extent: 1, group: p.group }; + let mut ogawa = Ogawa { b: &a.w.b, budget: MAX_DECODED_BYTES, indexed_meta: Vec::new() }; + let values = ogawa.values(&property).unwrap(); + assert_eq!(values[0], -2.0); + assert_eq!(values[1], 2f64.powi(-24)); + assert_eq!(values[2], f64::INFINITY); + assert!(values[3].is_nan()); +} + #[test] fn hdf5_and_garbage_are_clear_errors() { let e = read(b"\x89HDF\r\n\x1a\n rest of an hdf5 file").err().unwrap().to_string(); From fe6ede90be015606d7d7c35664486ad5c446a6e6 Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Fri, 13 Nov 2026 11:59:42 +0100 Subject: [PATCH 27/39] Ignore repeated FBX geometry connections (#468) Co-authored-by: FredApps --- crates/formats/src/mesh_import/fbx.rs | 3 +++ crates/formats/src/mesh_import/scene_tests.rs | 18 ++++++++++++++++++ 2 files changed, 21 insertions(+) diff --git a/crates/formats/src/mesh_import/fbx.rs b/crates/formats/src/mesh_import/fbx.rs index 22599844..86eaa52e 100644 --- a/crates/formats/src/mesh_import/fbx.rs +++ b/crates/formats/src/mesh_import/fbx.rs @@ -544,6 +544,9 @@ fn read_inner(bytes: &[u8], files: &mut Files) -> Result { attribute_of.insert(parent, *a); } } + // Repeated connections describe the same instance; keep distinct model placements in order. + let mut seen_instances = HashSet::new(); + instances.retain(|instance| seen_instances.insert(instance.clone())); let placed: HashSet<&String> = instances.iter().map(|(g, _)| g).collect(); let mut unplaced: Vec = geometries.keys().filter(|g| !placed.contains(g)).cloned().collect(); unplaced.sort_unstable(); diff --git a/crates/formats/src/mesh_import/scene_tests.rs b/crates/formats/src/mesh_import/scene_tests.rs index 09515423..a5a86c4f 100644 --- a/crates/formats/src/mesh_import/scene_tests.rs +++ b/crates/formats/src/mesh_import/scene_tests.rs @@ -415,6 +415,24 @@ fn fbx_ascii_and_z_up() { check_fbx_scene(&import_mesh_bytes("z.fbx", &binary_fbx(&scene(true), 7700, true)).unwrap().mesh, true); } +#[test] +fn fbx_duplicate_geometry_connections_do_not_duplicate_instances() { + let mut nodes = scene(false); + let connections = nodes.iter_mut().find(|node| node.name == "Connections").unwrap(); + for _ in 0..50 { + connections.children.push(n("C", vec![P::S("OO"), P::L(10), P::L(21)], vec![])); + } + let imported = import_mesh_bytes("scene.fbx", ascii_fbx(&nodes).as_bytes()).unwrap(); + assert_eq!(imported.report.triangles, 3); + + let objects = nodes.iter_mut().find(|node| node.name == "Objects").unwrap(); + objects.children.push(n("Model", vec![P::L(22), P::S("Other\u{0}\u{1}Model"), P::S("Mesh")], vec![])); + let connections = nodes.iter_mut().find(|node| node.name == "Connections").unwrap(); + connections.children.push(n("C", vec![P::S("OO"), P::L(10), P::L(22)], vec![])); + let imported = import_mesh_bytes("scene.fbx", ascii_fbx(&nodes).as_bytes()).unwrap(); + assert_eq!(imported.report.triangles, 6, "a different model must remain a distinct instance"); +} + /// The scene of [`scene`] (Y up) as FBX 6.1 writes it: geometry inside the Model, objects named /// `Class::Name`, `Properties60`, `Connect` records, GlobalSettings inside Objects. const FBX61: &str = r#"; FBX 6.1.0 project file From 8e83ac66f10c5efca9d986b77f6254d4a2c00c7d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Max=20Mittelst=C3=A4dt?= <62167861+TheGalitube@users.noreply.github.com> Date: Fri, 13 Nov 2026 12:09:02 +0100 Subject: [PATCH 28/39] Cap FBX cameras during import (#450) Fixes #445 Co-authored-by: GPT-6-Luna Co-authored-by: FredApps --- crates/formats/src/mesh_import/fbx.rs | 3 +++ crates/formats/src/mesh_import/scene_tests.rs | 12 ++++++++++++ 2 files changed, 15 insertions(+) diff --git a/crates/formats/src/mesh_import/fbx.rs b/crates/formats/src/mesh_import/fbx.rs index 86eaa52e..0d61ce67 100644 --- a/crates/formats/src/mesh_import/fbx.rs +++ b/crates/formats/src/mesh_import/fbx.rs @@ -576,6 +576,9 @@ fn read_inner(bytes: &[u8], files: &mut Files) -> Result { raw.base_colors = base_colors; // In file order; FBX 6's built-in "Producer" views are not the scene's cameras. for o in objects.children.iter().filter(|o| o.name == "Model" && o.class() == "Camera" && !o.object_name().starts_with("Producer ")) { + if raw.cameras.len() >= super::MAX_CAMERAS { + break; + } let Some(id) = o.id_at(0) else { continue }; if let Ok(m) = world(&models, &parents, &id) { raw.cameras.push(camera(o, attribute_of.get(&id).copied().unwrap_or(o), global * m)); diff --git a/crates/formats/src/mesh_import/scene_tests.rs b/crates/formats/src/mesh_import/scene_tests.rs index a5a86c4f..00a97922 100644 --- a/crates/formats/src/mesh_import/scene_tests.rs +++ b/crates/formats/src/mesh_import/scene_tests.rs @@ -299,6 +299,18 @@ fn fbx_binary_32_and_64_bit_compressed_or_not() { } /// [`scene`] with a diffuse color on Red and an embedded diffuse texture on Blue. +#[test] +fn fbx_camera_models_are_capped_during_import() { + let mut nodes = scene(false); + let objects = nodes.iter_mut().find(|node| node.name == "Objects").unwrap(); + for id in 100..199 { + objects.children.push(n("Model", vec![P::L(id), P::S("Camera\\u{0}\\u{1}Model"), P::S("Camera")], vec![])); + } + + let raw = fbx::read(&binary_fbx(&nodes, 7500, true)).unwrap(); + assert_eq!(raw.cameras.len(), MAX_CAMERAS); +} + fn textured_scene(png: &[u8]) -> Vec { let mut nodes = scene(false); let objects = nodes.iter_mut().find(|n| n.name == "Objects").unwrap(); From afc1ee169b7f40c49a670448157d8d1f21f4ba28 Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Fri, 13 Nov 2026 12:52:34 +0100 Subject: [PATCH 29/39] Preserve invalid ASCII FBX array values (#469) Co-authored-by: FredApps --- crates/formats/src/mesh_import/fbx.rs | 87 ++++++++++++++++++++++++++- 1 file changed, 85 insertions(+), 2 deletions(-) diff --git a/crates/formats/src/mesh_import/fbx.rs b/crates/formats/src/mesh_import/fbx.rs index 0d61ce67..08087283 100644 --- a/crates/formats/src/mesh_import/fbx.rs +++ b/crates/formats/src/mesh_import/fbx.rs @@ -130,14 +130,15 @@ impl Node { if let Some(a) = self.child("a") { return a.arr(); } - Cow::Owned(self.props.iter().filter_map(Prop::num).collect()) + Cow::Owned(self.props.iter().map(|p| p.num().unwrap_or(f64::NAN)).collect()) } /// The numbers of entry `name` in Properties70 (`P: name, type, subtype, flags, values`) or /// Properties60 (`Property: name, type, flags, values`). fn property(&self, name: &str) -> Option> { let list = self.child("Properties70").or_else(|| self.child("Properties60"))?; - list.children.iter().find(|p| p.str_at(0) == name).map(|p| p.props.iter().filter_map(Prop::num).collect()) + let first_value = if list.name == "Properties70" { 4 } else { 3 }; + list.children.iter().find(|p| p.str_at(0) == name).map(|p| p.props.iter().skip(first_value).map(|v| v.num().unwrap_or(f64::NAN)).collect()) } fn vec3(&self, name: &str, default: Vec3) -> Vec3 { @@ -803,6 +804,14 @@ fn add_geometry(sink: &mut PolygonSink, geometry: &Node, transform: Mat4, slots: let normals = Layer::read(geometry, "LayerElementNormal", "Normals", "NormalsIndex"); let uvs = Layer::read(geometry, "LayerElementUV", "UV", "UVIndex"); let materials = Layer::read(geometry, "LayerElementMaterial", "Materials", ""); + if vertices.iter().chain(polygon_indices.iter()).any(|v| !v.is_finite()) + || [&normals, &uvs, &materials] + .into_iter() + .flatten() + .any(|layer| layer.data.iter().any(|v| !v.is_finite()) || layer.index.as_ref().is_some_and(|index| index.iter().any(|v| !v.is_finite()))) + { + return Err(malformed(KIND, "mesh array contains a non-numeric or non-finite value")); + } let normal_transform = Mat3::from_mat4(transform).inverse().transpose(); let flip = transform.determinant() < 0.0; let (mut corners, mut polygon_index, mut bad_normals, mut bad_uvs) = (Vec::new(), 0usize, 0usize, 0usize); @@ -856,6 +865,80 @@ fn add_geometry(sink: &mut PolygonSink, geometry: &Node, transform: Mat4, slots: mod instance_budget_tests { use super::*; + #[test] + fn ascii_array_keeps_invalid_values_in_place() { + let (nodes, _) = parse_ascii( + br#"FBXHeaderExtension: { FBXVersion: 7400 } +Vertices: 1, 1.#INF, 3, "x", 5 +"#, + ) + .unwrap(); + let values = nodes[1].arr(); + assert_eq!(values.len(), 5); + assert!(values[1].is_nan() && values[3].is_nan()); + assert_eq!((values[0], values[2], values[4]), (1.0, 3.0, 5.0)); + } + + #[test] + fn ascii_bad_vertex_is_rejected() { + let (nodes, _) = parse_ascii( + br#"FBXHeaderExtension: { FBXVersion: 7400 } +Geometry: { Vertices: 0, 0, 0, 1, -1.#IND, 0, 0, 1, 0 +PolygonVertexIndex: 0, 1, -3 } +"#, + ) + .unwrap(); + let mut remaining = usize::MAX; + let result = add_geometry(&mut PolygonSink::default(), &nodes[1], Mat4::IDENTITY, &[], &mut remaining); + assert!(result.is_err()); + } + + #[test] + fn ascii_bad_index_and_uv_are_rejected() { + for payload in [ + "PolygonVertexIndex: 0, oops, -3", + "PolygonVertexIndex: 0, 1, -3\nLayerElementUV: 0 { MappingInformationType: \"ByPolygonVertex\"\nReferenceInformationType: \"Direct\"\nUV: 0, 0, oops, 1, 1, 0 }", + ] { + let source = format!("FBXHeaderExtension: {{ FBXVersion: 7400 }}\nGeometry: {{ Vertices: 0, 0, 0, 1, 0, 0, 0, 1, 0\n{payload} }}"); + let (nodes, _) = parse_ascii(source.as_bytes()).unwrap(); + let mut remaining = usize::MAX; + assert!(add_geometry(&mut PolygonSink::default(), &nodes[1], Mat4::IDENTITY, &[], &mut remaining).is_err()); + } + } + + #[test] + fn ascii_transform_metadata_does_not_shift_values() { + let (nodes, _) = parse_ascii( + br#"FBXHeaderExtension: { FBXVersion: 7400 } +Model: { Properties70: { P: "Lcl Translation", "Lcl Translation", "", "A", 1, 2, 3 } } +"#, + ) + .unwrap(); + assert_eq!(nodes[1].property("Lcl Translation"), Some(vec![1.0, 2.0, 3.0])); + let (nodes, _) = parse_ascii( + br#"FBXHeaderExtension: { FBXVersion: 7400 } +Model: { Properties60: { Property: "Lcl Translation", "Lcl Translation", "A", 1, 2, 3 } } +"#, + ) + .unwrap(); + assert_eq!(nodes[1].property("Lcl Translation"), Some(vec![1.0, 2.0, 3.0])); + } + + #[test] + fn malformed_transform_value_keeps_its_position_in_both_property_formats() { + for (list, entry) in [ + ("Properties70", "P: \"Lcl Translation\", \"Lcl Translation\", \"\", \"A\", 1, oops, 3"), + ("Properties60", "Property: \"Lcl Translation\", \"Lcl Translation\", \"A\", 1, oops, 3"), + ] { + let source = format!("FBXHeaderExtension: {{ FBXVersion: 7400 }}\nModel: {{ {list}: {{ {entry} }} }}"); + let (nodes, _) = parse_ascii(source.as_bytes()).unwrap(); + let values = nodes[1].property("Lcl Translation").unwrap(); + assert_eq!(values.len(), 3); + assert_eq!((values[0], values[2]), (1.0, 3.0)); + assert!(values[1].is_nan()); + } + } + #[test] fn instance_points_are_charged_before_transforming_each_copy() { let geometry = Node { From 386630ee85cb22679295b24013575d1aecb39ad2 Mon Sep 17 00:00:00 2001 From: Prajwal Raj Date: Fri, 13 Nov 2026 17:28:42 +0530 Subject: [PATCH 30/39] Stop reading Alembic indexed metadata after 255 entries (#464) * fix(formats): stop reading Alembic indexed metadata after 255 entries (#447) Objects and properties refer to indexed metadata with one byte, and 0xff already means the metadata is stored inline, so only entries 0 to 254 can ever be used. The reader kept every entry, so a block of zero bytes cost a whole String in memory for each byte of file. It now stops once 255 entries are held. * test(formats): verify indexed metadata during archive import (#447) --- crates/formats/src/mesh_import/abc/mod.rs | 23 +++++++++++++----- crates/formats/src/mesh_import/abc/tests.rs | 26 +++++++++++++++++++++ 2 files changed, 43 insertions(+), 6 deletions(-) diff --git a/crates/formats/src/mesh_import/abc/mod.rs b/crates/formats/src/mesh_import/abc/mod.rs index 5a19982c..b0a0ef22 100644 --- a/crates/formats/src/mesh_import/abc/mod.rs +++ b/crates/formats/src/mesh_import/abc/mod.rs @@ -281,19 +281,30 @@ fn read_inner(bytes: &[u8]) -> Result { if root.len() < 6 || !(0..6).all(|i| is_data(i) != (i == 2)) { return Err(malformed(KIND, "the archive group does not have the Alembic layout")); } - // Indexed metadata: a u8 length before each string. let block = o.data(root[5])?; - let mut c = Cursor { b: block, pos: 0 }; - while c.pos < block.len() { - let n = c.u8()? as usize; - o.indexed_meta.push(c.string(n)?); - } + read_indexed_meta(block, &mut o.indexed_meta)?; let mut sink = PolygonSink::default(); let mut walk = Walk { o, sink: &mut sink, visits: 0 }; walk.object(root[2], Mat4::IDENTITY, "", 0)?; Ok(sink.finish()) } +/// The most indexed metadata entries that can ever be used: objects and properties refer to one +/// with a single byte, and 0xff already means "stored inline", so only 0 to 254 are reachable. +const MAX_INDEXED_META: usize = 255; + +/// Indexed metadata: a u8 length before each string. `out` starts with the empty entry 0. Reading +/// stops once `out` holds [`MAX_INDEXED_META`] entries, because no later entry can be referred to +/// and an empty one costs a whole `String` in memory for one byte of file. +fn read_indexed_meta(block: &[u8], out: &mut Vec) -> Result<()> { + let mut c = Cursor { b: block, pos: 0 }; + while c.pos < block.len() && out.len() < MAX_INDEXED_META { + let n = c.u8()? as usize; + out.push(c.string(n)?); + } + Ok(()) +} + struct Walk<'a, 'b> { o: Ogawa<'a>, sink: &'b mut PolygonSink, diff --git a/crates/formats/src/mesh_import/abc/tests.rs b/crates/formats/src/mesh_import/abc/tests.rs index fecb0623..92f18620 100644 --- a/crates/formats/src/mesh_import/abc/tests.rs +++ b/crates/formats/src/mesh_import/abc/tests.rs @@ -323,3 +323,29 @@ fn self_referencing_groups_are_bounded() { let bytes = a.archive(at, &[]); assert!(read(&bytes).is_err()); } + +#[test] +fn indexed_metadata_stops_at_the_entries_a_byte_can_index() { + // One real entry followed by a million empty ones: a byte each in the file, a `String` each + // in memory, and no index past 254 can be used anyway. + let mut block = vec![3, b'a', b'b', b'c']; + block.extend(std::iter::repeat_n(0u8, 1_000_000)); + let mut kept = vec![String::new()]; + read_indexed_meta(&block, &mut kept).unwrap(); + assert_eq!(kept.len(), MAX_INDEXED_META); + assert_eq!(kept.get(1).map(String::as_str), Some("abc")); + + // The mesh schema comes from metadata index 1 even when the table has unreachable entries. + let mut a = Abc { w: Writer::new() }; + let pp = a.array("P", "", F32, 3, &f32s(&[0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0])); + let fi = a.array(".faceIndices", "", I32, 1, &i32s(&[0, 1, 2])); + let fc = a.array(".faceCounts", "", I32, 1, &i32s(&[3])); + let geom = a.compound(".geom", "schema=AbcGeom_PolyMesh_v1", vec![pp, fi, fc]); + let mesh = a.object(vec![geom], &[]); + let top = a.object(vec![], &[("tri", "", mesh)]); + let mut metas = vec!["schema=AbcGeom_PolyMesh_v1"]; + metas.extend(std::iter::repeat_n("", 5_000)); + let raw = read(&a.archive(top, &metas)).unwrap(); + assert_eq!(raw.positions, [Vec3::X, Vec3::Y, Vec3::ZERO]); + assert_eq!(raw.groups, vec![(DEFAULT_MATERIAL.into(), "tri".into(), vec![0, 1, 2])]); +} From a616e5ed06d6235e9a9030e20ce65aa1a91f221e Mon Sep 17 00:00:00 2001 From: Morion Date: Fri, 13 Nov 2026 08:53:59 -0500 Subject: [PATCH 31/39] experiment: scope invalidation of newly added material resources --- crates/engine/examples/material_probe.rs | 55 ++++++++++++++++++++++++ crates/engine/src/session.rs | 25 +++++++++-- 2 files changed, 77 insertions(+), 3 deletions(-) create mode 100644 crates/engine/examples/material_probe.rs diff --git a/crates/engine/examples/material_probe.rs b/crates/engine/examples/material_probe.rs new file mode 100644 index 00000000..0179b8d2 --- /dev/null +++ b/crates/engine/examples/material_probe.rs @@ -0,0 +1,55 @@ +use serde_json::json; +use std::{ + hash::{DefaultHasher, Hash, Hasher}, + time::Instant, +}; +use texturecraft_engine::{ + Session, + compose::{DisplayKind, tile_bytes}, + core::LayerId, + execute, file_cmds, + geom::primitives, +}; +fn drain(s: &mut Session, label: &str) { + let dirty: Vec<_> = s.caches.iter().map(|c| c.dirty.len()).collect(); + let t = Instant::now(); + let mut peak = 0f64; + let mut slices = 0; + while s.pending_tiles() > 0 { + let a = Instant::now(); + s.update_for(30., || t.elapsed().as_secs_f64() * 1000.); + peak = peak.max(a.elapsed().as_secs_f64() * 1000.); + slices += 1; + } + println!("{} dirty={:?} compose_ms={:.1} max_slice_ms={:.1} slices={}", label, dirty, t.elapsed().as_secs_f64() * 1000., peak, slices); +} +fn main() -> Result<(), Box> { + let args: Vec<_> = std::env::args().collect(); + let mut donor = Session::new_project("probe", primitives::plane(2., 1), "builtin:plane", None, 128)?; + donor.import_resource_bytes("unique-material-probe.png", std::fs::read(&args[2])?)?; + let layer = execute(&mut donor, "layer.add.image", &json!({"name":"unique-material-probe.png"}))?; + let bytes = donor.smart_material_bytes(LayerId(layer["layer"].as_u64().unwrap()), "Image material")?; + let t = Instant::now(); + let mut s = file_cmds::open_path(&args[1])?; + println!("load_ms={:.1}", t.elapsed().as_secs_f64() * 1000.); + drain(&mut s, "open"); + execute(&mut s, "layer.select", &json!({"layer":10}))?; + execute(&mut s, "material.apply", &json!({"material":"gold_polished"}))?; + drain(&mut s, "simple"); + let t = Instant::now(); + s.add_smart_material_bytes(&bytes)?; + println!("apply_ms={:.1}", t.elapsed().as_secs_f64() * 1000.); + drain(&mut s, "smart"); + let mut hash = DefaultHasher::new(); + for (i, c) in s.caches.iter().enumerate() { + let empty = Default::default(); + let baked = s.doc.baked.get(&i).unwrap_or(&empty); + for (x, y) in texturecraft_engine::compose::all_tiles(c.size.0, c.size.1) { + for k in DisplayKind::ALL { + tile_bytes(&c.composite, baked, k, x, y).hash(&mut hash); + } + } + } + println!("display_hash={:x}", hash.finish()); + Ok(()) +} diff --git a/crates/engine/src/session.rs b/crates/engine/src/session.rs index 9d58670b..695bfab4 100644 --- a/crates/engine/src/session.rs +++ b/crates/engine/src/session.rs @@ -576,15 +576,34 @@ impl Session { pub(crate) fn invalidate_changed(&mut self, other: &Document) { self.follow_uv_layouts(&other.project); self.sync_caches(); - let resources = |d: &Document| d.resources.iter().map(|(n, b)| (n.clone(), Arc::as_ptr(b))).collect::>(); - let all = resources(other) != resources(&self.doc); + // Retain broad invalidation on removal or replacement. A newly added resource + // can also satisfy an existing, previously unresolved image reference. + let all = other.resources.iter().any(|(name, old)| !self.doc.resources.get(name).is_some_and(|new| Arc::ptr_eq(old, new))); + let added: BTreeSet<_> = self.doc.resources.keys().filter(|name| !other.resources.contains_key(*name)).collect(); + let uses_added = |ts: usize| { + use texturecraft_core::{EffectKind, Fill, Source}; + let uses_source = |src: &Source| matches!(src, Source::Image { name, .. } if added.contains(name)); + let uses_fill = |f: &Fill| f.sources.values().any(uses_source) || f.link.as_ref().is_some_and(|l| added.contains(&l.package)); + let project = &self.doc.project; + !added.is_empty() + && project.texture_sets.get(ts).is_some_and(|set| { + project.render_tree(&set.stack).iter().filter_map(|id| project.layers.get(id)).any(|layer| { + matches!(&layer.kind, LayerKind::Fill(f) if uses_fill(f)) + || layer.mask.iter().flat_map(|m| &m.effects).chain(&layer.content_effects).any(|e| match &e.kind { + EffectKind::Fill { source, .. } => uses_source(source), + EffectKind::Material(f) => uses_fill(f), + _ => false, + }) + }) + }) + }; let (empty, images) = (BakedMaps::default(), Default::default()); let key = |d: &Document, ts: usize| { let stack = d.project.texture_sets.get(ts).map(|s| s.stack.as_slice()).unwrap_or_default(); StackKey::new(&d.project, &d.pixels, d.baked.get(&ts).unwrap_or(&empty), &images, ts, stack) }; for ts in 0..self.caches.len() { - if (all || key(other, ts) != key(&self.doc, ts)) + if (all || key(other, ts) != key(&self.doc, ts) || uses_added(ts)) && let Some(c) = self.caches.get_mut(ts) { c.invalidate_all(); From d5675e090b176aad1347767c5c52a31fd2e54016 Mon Sep 17 00:00:00 2001 From: Morion Date: Fri, 13 Nov 2026 09:38:39 -0500 Subject: [PATCH 32/39] Keep cached layer composites across unrelated image imports --- crates/compose/src/below.rs | 41 +++++++++++++++--- crates/compose/tests/cache_and_instances.rs | 48 +++++++++++++++++++++ 2 files changed, 84 insertions(+), 5 deletions(-) diff --git a/crates/compose/src/below.rs b/crates/compose/src/below.rs index cf675d4f..ec597eb4 100644 --- a/crates/compose/src/below.rs +++ b/crates/compose/src/below.rs @@ -10,11 +10,11 @@ use std::collections::{BTreeSet, HashMap, VecDeque}; use std::sync::Arc; use texturecraft_core::project::MAX_DEPTH; -use texturecraft_core::{BakedMap, Channel, Layer, LayerId, LayerKind, Project, TextureSet}; +use texturecraft_core::{BakedMap, Channel, EffectKind, Layer, LayerId, LayerKind, Project, Source, TextureSet}; use texturecraft_texel::TileImage; use crate::eval::{Inputs, PaintTarget}; -use crate::store::{BakedMaps, ImageStore, PixelStore}; +use crate::store::{BakedMaps, ImageRes, ImageStore, PixelStore}; /// Default byte budget of a [`BelowCache`], per nesting level it holds (see /// [`BelowCache::limit`]). @@ -78,7 +78,7 @@ pub struct StackKey { layers: Vec, pixels: Vec<(LayerId, Option, Shared)>, baked: (u32, Vec<(BakedMap, usize)>), - images: Vec<(String, usize)>, + images: Vec<(String, ImageIdentity)>, } impl StackKey { @@ -111,8 +111,29 @@ impl StackKey { layer.chain(pixels.masks.get(id).map(|img| (*id, None, Shared(img.clone())))) }) .collect(); - let mut images: Vec<(String, usize)> = images.iter().map(|(n, i)| (n.clone(), Arc::as_ptr(i) as usize)).collect(); - images.sort(); + let mut names = BTreeSet::new(); + if !images.is_empty() { + let mut record = |source: &Source| { + if let Source::Image { name, .. } = source + && let Some((name, _)) = images.get_key_value(name) + { + names.insert(name); + } + }; + for layer in tree.iter().filter_map(|id| project.layers.get(id)) { + if let LayerKind::Fill(fill) = &layer.kind { + fill.sources.values().for_each(&mut record); + } + for effect in layer.mask.iter().flat_map(|m| &m.effects).chain(&layer.content_effects) { + match &effect.kind { + EffectKind::Fill { source, .. } => record(source), + EffectKind::Material(fill) => fill.sources.values().for_each(&mut record), + _ => {} + } + } + } + } + let images = names.into_iter().map(|name| (name.clone(), ImageIdentity(Arc::downgrade(&images[name])))).collect(); Some(StackKey { set, roots, @@ -124,6 +145,16 @@ impl StackKey { } } +// Keep the allocation identity stable even when an image is removed between composites. +#[derive(Debug)] +struct ImageIdentity(std::sync::Weak); + +impl PartialEq for ImageIdentity { + fn eq(&self, other: &Self) -> bool { + self.0.ptr_eq(&other.0) + } +} + /// An image compared by tile identity: holding the clone keeps its tiles alive, and a tile /// rewritten since is a different allocation (copy-on-write), so pointer equality means the /// same pixels without reading them. diff --git a/crates/compose/tests/cache_and_instances.rs b/crates/compose/tests/cache_and_instances.rs index d7df0258..02009a06 100644 --- a/crates/compose/tests/cache_and_instances.rs +++ b/crates/compose/tests/cache_and_instances.rs @@ -573,3 +573,51 @@ fn gathering_filters_composite_identically_in_any_grouping_and_cached() { assert!(!check_cached(&f, 0, hot).is_empty()); } } + +#[test] +fn image_dependency_probe() { + use std::sync::Arc; + use std::time::Instant; + use texturecraft_compose::{ImageRes, ImageStore}; + + let mut f = fixture(); + let hot = heavy_stack(&mut f); + let bottom = f.project.texture_sets[0].stack[0]; + let LayerKind::Fill(fill) = &mut f.project.layer_mut(bottom).unwrap().kind else { panic!("expected fill") }; + fill.sources.insert(Channel::Roughness, Source::Image { name: "used".into(), normal_format: Default::default() }); + let image = |value| Arc::new(ImageRes { width: 1, height: 1, rgba: vec![[value; 4]], srgb: false }); + let mut images = ImageStore::default(); + let baked = Default::default(); + let tiles = all_tiles(RES, RES); + let mut cache = BelowCache::default(); + cache.set_hot(Some(hot)); + let mut out = Composite::new(&f.project.texture_sets[0].channel_list(), RES); + for stage in ["cold", "resolve", "unused1", "unused2", "unused3", "replace", "remove"] { + match stage { + "resolve" => { + images.insert("used".into(), image(1.0)); + } + "replace" => { + images.insert("used".into(), image(0.4)); + } + "remove" => { + images.remove("used"); + } + "cold" => {} + _ => { + images.insert(stage.into(), image(0.5)); + } + } + f.pixels.layer_mut(hot, Channel::BaseColor, (RES, RES)).set(5, 5, &[stage.len() as u16, 0, 0, u16::MAX]); + let inp = inputs(&f, 0, &images, &baked); + let start = Instant::now(); + composite_tiles_cached(&inp, &mut out, &tiles[..1], Some(&mut cache)); + let retained = cache.len() - 1; + composite_tiles_cached(&inp, &mut out, &tiles[1..], Some(&mut cache)); + println!("{stage}: {:?}, retained other tiles {retained}", start.elapsed()); + assert_eq!(retained, if stage.starts_with("unused") { tiles.len() - 1 } else { 0 }, "{stage}"); + let mut expected = Composite::new(&f.project.texture_sets[0].channel_list(), RES); + composite_tiles(&inp, &mut expected, &tiles); + assert!(out == expected, "{stage}"); + } +} From 1a742d3fa4105c3da1f956811b671cbc1fc23e48 Mon Sep 17 00:00:00 2001 From: Morion Date: Fri, 13 Nov 2026 12:38:58 -0500 Subject: [PATCH 33/39] Frame-sliced recomposites filter a run of tiles once (#475) A stack with a neighbourhood filter (blur, high pass, bevel, glow...) made a recomposite spread over frames many times slower than the same recomposite in one call: every chunk filtered its own surroundings again, and on a machine with many threads the filter's per-texel parallel steps cost more to hand out than to run on a region of a few tiles. - Neighbourhood filters split their per-texel work into tasks of at least 16384 texels. Each texel is computed on its own, so results do not change. - Session::update_for tells the compositor which dirty tiles follow the chunk in its block (up to 64). The compositor filters the chunk and those tiles at once and keeps the fields for the composites that follow, compared by everything the stack reads, and drops them at the end of the pass, after an edit, and under a live stroke. Results are identical to the one-call composite: tests cover cold, warm and partly evicted hot-layer caches, an edit mid-pass and a live stroke. perf::bench_sliced_filters_4k times both paths. --- crates/compose/src/below.rs | 47 ++++++- crates/compose/src/eval.rs | 113 +++++++++++++---- crates/compose/src/lib.rs | 4 +- crates/compose/tests/cache_and_instances.rs | 133 ++++++++++++++++++++ crates/engine/src/session.rs | 15 +++ crates/engine/tests/it/perf.rs | 38 ++++++ 6 files changed, 324 insertions(+), 26 deletions(-) diff --git a/crates/compose/src/below.rs b/crates/compose/src/below.rs index cf675d4f..25d086e9 100644 --- a/crates/compose/src/below.rs +++ b/crates/compose/src/below.rs @@ -13,7 +13,7 @@ use texturecraft_core::project::MAX_DEPTH; use texturecraft_core::{BakedMap, Channel, Layer, LayerId, LayerKind, Project, TextureSet}; use texturecraft_texel::TileImage; -use crate::eval::{Inputs, PaintTarget}; +use crate::eval::{Fields, Inputs, PaintTarget}; use crate::store::{BakedMaps, ImageStore, PixelStore}; /// Default byte budget of a [`BelowCache`], per nesting level it holds (see @@ -40,11 +40,47 @@ pub struct BelowCache { /// Tiles of the whole pass a caller splits into several composites (0: each composite is a /// pass). A pass larger than the cache records only what fits. pub pass: usize, + /// Tiles the caller composites next in this pass, after those of the coming composite (empty: none, or a pass that is one + /// composite). A stack with neighbourhood filters then filters the coming tiles and these at once and keeps the result for + /// the composites that follow, instead of filtering each small chunk's surroundings again. + pub ahead: Vec<(u32, u32)>, + pub(crate) held: Option, +} + +/// Neighbourhood-filter fields kept between the composites of one pass. +pub(crate) struct HeldFields { + /// Everything the fields read. + pub key: Arc, + /// The working size they were built at. + pub size: (u32, u32), + /// The tiles every layer's fields hold. + pub stack_tiles: BTreeSet<(u32, u32)>, + /// The tiles the hot layer's fields hold (the same tiles when the stack was not split). + pub hot_tiles: BTreeSet<(u32, u32)>, + pub fields: Arc, +} + +impl std::fmt::Debug for HeldFields { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("HeldFields").field("stack_tiles", &self.stack_tiles.len()).field("hot_tiles", &self.hot_tiles.len()).finish_non_exhaustive() + } } impl Default for BelowCache { fn default() -> Self { - BelowCache { hot: None, key: None, tiles: HashMap::new(), order: VecDeque::new(), clock: 0, bytes: 0, budget: BELOW_BUDGET, levels: 1, pass: 0 } + BelowCache { + hot: None, + key: None, + tiles: HashMap::new(), + order: VecDeque::new(), + clock: 0, + bytes: 0, + budget: BELOW_BUDGET, + levels: 1, + pass: 0, + ahead: Vec::new(), + held: None, + } } } @@ -184,12 +220,19 @@ impl BelowCache { self.order.clear(); self.bytes = 0; self.key = None; + // Held fields tell the hot layer's tiles from the others' + self.held = None; } pub fn bytes(&self) -> usize { self.bytes } + /// Whether neighbourhood-filter fields are kept for the composites that follow (see [`BelowCache::ahead`]). + pub fn holds_fields(&self) -> bool { + self.held.is_some() + } + /// The byte limit: the budget for the top level and as much again for a hot layer nested in /// folders (each tile then holds the stack at two or more levels). pub fn limit(&self) -> usize { diff --git a/crates/compose/src/eval.rs b/crates/compose/src/eval.rs index fe0bdb23..0815124d 100644 --- a/crates/compose/src/eval.rs +++ b/crates/compose/src/eval.rs @@ -18,7 +18,7 @@ use texturecraft_geom::glam::{Vec2, Vec3}; use texturecraft_geom::{Mesh, NO_TRI, UvGBuffer}; use texturecraft_texel::{DilationMap, TILE, TILE_AREA, TileImage, from_u16, noise, to_u16, to_u16_signed}; -use crate::below::{Band, BelowCache, Level}; +use crate::below::{Band, BelowCache, HeldFields, Level, StackKey}; use crate::curvature_sizes::CurvatureSizes; use crate::pattern::{Coords, decal_uv, image_samples, procedural, world_noise}; use crate::store::{BakedMaps, ImageStore, PixelStore, decode}; @@ -434,15 +434,27 @@ fn gather(op: Op, orig: &[f32], cover: &[f32], comps: usize, (x0, y0, w, h): (u3 /// the region it is computed in, so tiles composited in any grouping agree exactly. const FIX: f64 = (1u64 << 24) as f64; +/// Texels one parallel task of a neighbourhood filter handles at least. Compositing in frame slices filters regions of a few tiles: split per texel, +/// handing that little work to every thread costs far more than the work itself. Each texel is computed on its own, so the split does not change results. +const MIN_PARALLEL_TEXELS: usize = 1 << 14; + +/// How many lines of `length` texels make a parallel task of at least [`MIN_PARALLEL_TEXELS`]. +fn lines_per_task(length: usize) -> usize { + (MIN_PARALLEL_TEXELS / length.max(1)).max(1) +} + /// Three running-sum box blurs (≈ Gaussian) of a `width × height` image along its rows, then its columns, each in parallel. pub(crate) fn blur(data: &mut [f32], width: usize, height: usize, radius: usize) { let to_fixed = |value: &f32| if value.is_finite() { (f64::from(value.clamp(-1e6, 1e6)) * FIX).round() as i64 } else { 0 }; - let mut fixed: Vec = data.par_iter().map(to_fixed).collect(); + let mut fixed: Vec = data.par_iter().with_min_len(MIN_PARALLEL_TEXELS).map(to_fixed).collect(); blur_rows(&mut fixed, width, radius); let mut columns = transpose(&fixed, width, height); blur_rows(&mut columns, height, radius); - data.par_iter_mut().zip(transpose(&columns, height, width)).for_each(|(target, blurred)| *target = (blurred as f64 / FIX) as f32); + data.par_iter_mut() + .with_min_len(MIN_PARALLEL_TEXELS) + .zip(transpose(&columns, height, width)) + .for_each(|(target, blurred)| *target = (blurred as f64 / FIX) as f32); } /// The box blurs `blur` runs along each axis @@ -453,7 +465,7 @@ fn blur_rows(data: &mut [i64], w: usize, r: usize) { if w == 0 { return; } - data.par_chunks_mut(w).for_each(|row| { + data.par_chunks_mut(w).with_min_len(lines_per_task(w)).for_each(|row| { let mut tmp = vec![0i64; row.len()]; for _ in 0..BLUR_BOX_PASSES { box_line(row, &mut tmp, r); @@ -481,7 +493,7 @@ fn box_line(src: &[i64], dst: &mut [i64], r: usize) { fn transpose(src: &[i64], w: usize, h: usize) -> Vec { let mut out = vec![0i64; src.len()]; if h > 0 { - out.par_chunks_mut(h).enumerate().for_each(|(x, col)| { + out.par_chunks_mut(h).with_min_len(lines_per_task(h)).enumerate().for_each(|(x, col)| { for (y, d) in col.iter_mut().enumerate() { *d = src.get(y * w + x).copied().unwrap_or(0); } @@ -698,9 +710,10 @@ fn filter_region( blur(&mut weights, width, height, blur_radius); let mut data = orig.clone(); for component in 0..comps { - let mut sums: Vec = orig.par_chunks(comps).map(|pixel| pixel.get(component).copied().unwrap_or(0.0)).collect(); + let mut sums: Vec = + orig.par_chunks(comps).with_min_len(MIN_PARALLEL_TEXELS).map(|pixel| pixel.get(component).copied().unwrap_or(0.0)).collect(); blur(&mut sums, width, height, blur_radius); - data.par_chunks_mut(comps).zip(sums.par_iter()).zip(weights.par_iter()).for_each(|((pixel, sum), weight)| { + data.par_chunks_mut(comps).with_min_len(MIN_PARALLEL_TEXELS).zip(sums.par_iter()).zip(weights.par_iter()).for_each(|((pixel, sum), weight)| { // Content is premultiplied, so the mid value is too (coverage itself is kept) let cov = if comps == 4 { pixel.get(3).copied().unwrap_or(0.0) } else { 1.0 }; if *weight > 1e-6 @@ -749,7 +762,7 @@ fn filter_region( /// Clamp filtered masks to 0..1, and turn filtered content back into straight values. fn unpremultiply(data: &mut [f32], comps: usize) { - data.par_chunks_mut(comps).for_each(|px| match px { + data.par_chunks_mut(comps).with_min_len(MIN_PARALLEL_TEXELS).for_each(|px| match px { [v] => *v = v.clamp(0.0, 1.0), [r, g, b, cov] => { *cov = cov.clamp(0.0, 1.0); @@ -1661,7 +1674,7 @@ pub fn composite_tiles(inp: &Inputs, out: &mut Composite, tiles: &[(u32, u32)]) } /// Tiles per side of the blocks a composite works through (bounds neighbourhood-filter memory). -const BLOCK: u32 = 16; +pub const BLOCK: u32 = 16; /// [`composite_tiles`], serving everything but the hot layer from `below` where it can (and /// filling it). Results are identical to [`composite_tiles`]. @@ -1681,14 +1694,50 @@ pub fn composite_tiles_cached(inp: &Inputs, out: &mut Composite, tiles: &[(u32, for t in tiles { blocks.entry((t.1 / BLOCK, t.0 / BLOCK)).or_default().push(*t); } - for block in blocks.values() { + let channels = set.channel_list(); + let hot = split.as_deref().and_then(<[Level]>::last); + // Fields are only kept without a live stroke (its preview is not part of what a stack key compares) + let holds = below.is_some() && inp.preview.is_none() && has_neighbourhood(inp, &set.stack); + let key = if holds { StackKey::new(inp.project, inp.pixels, inp.baked, inp.images, inp.ts, &set.stack).map(Arc::new) } else { None }; + let size = (inp.gbuf.width, inp.gbuf.height); + for (at, block) in &blocks { + let lacks = |tile: &(u32, u32)| below.as_deref().zip(split.as_deref()).is_none_or(|(cache, _)| cache.tile(*tile).is_none()); + let fresh: Vec<(u32, u32)> = block.iter().copied().filter(lacks).collect(); + let held = below.as_deref().and_then(|cache| cache.held.as_ref()).filter(|held| { + key.as_ref().is_some_and(|key| **key == *held.key) + && held.size == size + && fresh.iter().all(|tile| held.stack_tiles.contains(tile)) + && block.iter().all(|tile| held.hot_tiles.contains(tile)) + }); + let ahead: Vec<(u32, u32)> = match (&key, below.as_deref()) { + (Some(_), Some(cache)) if held.is_none() => { + cache.ahead.iter().copied().filter(|tile| (tile.1 / BLOCK, tile.0 / BLOCK) == *at && !block.contains(tile)).collect() + } + _ => Vec::new(), + }; + let fields: Arc = match (held, &key) { + (Some(held), _) => held.fields.clone(), + (None, Some(key)) if !ahead.is_empty() => { + // These tiles and the ones that follow them, filtered at once and kept + let wide: Vec<(u32, u32)> = block.iter().chain(&ahead).copied().collect(); + let wide_fresh: Vec<(u32, u32)> = wide.iter().copied().filter(lacks).collect(); + let fields = Arc::new(block_fields(inp, &channels, &set.stack, hot, &wide_fresh, &wide)); + let hot_tiles: std::collections::BTreeSet<(u32, u32)> = wide.iter().copied().collect(); + let stack_tiles = if hot.is_some() && wide_fresh.len() < wide.len() { wide_fresh.into_iter().collect() } else { hot_tiles.clone() }; + if let Some(cache) = below.as_deref_mut() { + cache.held = Some(HeldFields { key: key.clone(), size, stack_tiles, hot_tiles, fields: fields.clone() }); + } + fields + } + _ => Arc::new(block_fields(inp, &channels, &set.stack, hot, &fresh, block)), + }; let quota = match below.as_deref() { Some(_) if fits => usize::MAX, Some(b) => b.limit().saturating_sub(b.bytes()) / tile_bytes, None => 0, }; let cached = below.as_deref().zip(split.as_deref()); - let records = composite_block(inp, &set.stack, out, block, cached, quota); + let records = composite_block(inp, &set.stack, out, block, cached, quota, &fields); if let Some(b) = below.as_deref_mut() { for t in block { b.touch(*t); @@ -1698,6 +1747,34 @@ pub fn composite_tiles_cached(inp: &Inputs, out: &mut Composite, tiles: &[(u32, } } } + // Nothing follows in this pass: its fields are not kept past it + if let Some(cache) = below.filter(|cache| cache.ahead.is_empty()) { + cache.held = None; + } +} + +/// Whether a layer drawn by `stack` has a neighbourhood filter in its mask or content effects. +fn has_neighbourhood(inp: &Inputs, stack: &[LayerId]) -> bool { + let working_width = inp.gbuf.width; + let mut order = Vec::new(); + draw_order(inp.project, stack, 0, &mut order); + order.into_iter().any(|id| { + let masked = layer_mask(inp.project, id).is_some_and(|mask| mask.enabled && neighbourhood(&mask.effects, working_width).is_some()); + masked || inp.project.content_layer(id).is_some_and(|layer| !layer.is_group() && neighbourhood(&layer.content_effects, working_width).is_some()) + }) +} + +/// The neighbourhood fields compositing `tiles` reads: those of every layer of `stack` over the tiles the cache lacks (`fresh`), +/// and off the path to the `hot` layer only there; the hot layer's over all of `tiles`. +fn block_fields(inp: &Inputs, channels: &[Channel], stack: &[LayerId], hot: Option<&Level>, fresh: &[(u32, u32)], tiles: &[(u32, u32)]) -> Fields { + match hot { + Some(hot) if fresh.len() < tiles.len() => { + let mut fields = fields_of(inp, channels, stack, fresh); + fields.extend(fields_of(inp, channels, &[hot.at], tiles)); + fields + } + _ => fields_of(inp, channels, stack, tiles), + } } /// Rows of a tile composited as one parallel task. @@ -1719,6 +1796,7 @@ fn composite_block( tiles: &[(u32, u32)], below: Option<(&BelowCache, &[Level])>, quota: usize, + fields: &Fields, ) -> Vec<((u32, u32), Vec)> { let channels: Vec = inp.project.texture_set(inp.ts).map(|s| s.channel_list()).unwrap_or_default(); let (w, h) = (out.resolution, out.height); @@ -1726,15 +1804,6 @@ fn composite_block( let cached = |t: (u32, u32)| below.and_then(|(b, _)| b.tile(t)); let fresh: Vec<(u32, u32)> = tiles.iter().copied().filter(|t| cached(*t).is_none()).collect(); let recorded: std::collections::BTreeSet<(u32, u32)> = if split.is_some() { fresh.iter().copied().take(quota).collect() } else { Default::default() }; - // Off the path, layers are only evaluated on tiles the cache lacks. - let fields = match split.and_then(<[Level]>::last) { - Some(hot) if fresh.len() < tiles.len() => { - let mut fields = fields_of(inp, &channels, stack, &fresh); - fields.extend(fields_of(inp, &channels, &[hot.at], tiles)); - fields - } - _ => fields_of(inp, &channels, stack, tiles), - }; let lanes: Vec = channels.iter().map(|c| Lane { ch: c.index(), n: c.components(), signed: c.kind() == ChannelKind::Signed }).collect(); let stride: usize = lanes.iter().map(|l| l.n).sum(); let nlev = split.map_or(0, <[Level]>::len); @@ -1747,8 +1816,8 @@ fn composite_block( .map(|&((tx, ty), band)| { let warm = cached((tx, ty)).and_then(|b| b.get(band as usize)); let record = warm.is_none() && recorded.contains(&(tx, ty)); - let levels = split.map(|l| plan_levels(inp, l, &channels, tx, ty, &fields, warm.is_some())); - let nodes = if levels.is_none() { plan(inp, stack, &channels, tx, ty, 0, Some(&fields)) } else { Vec::new() }; + let levels = split.map(|l| plan_levels(inp, l, &channels, tx, ty, fields, warm.is_some())); + let nodes = if levels.is_none() { plan(inp, stack, &channels, tx, ty, 0, Some(fields)) } else { Vec::new() }; let rows = (BAND * TILE) as usize; let mut accs = vec![defaults; nlev]; let mut masks = vec![0.0f32; nlev]; diff --git a/crates/compose/src/lib.rs b/crates/compose/src/lib.rs index 46c3c6b5..2499c073 100644 --- a/crates/compose/src/lib.rs +++ b/crates/compose/src/lib.rs @@ -20,8 +20,8 @@ pub mod thumb; pub use below::{BelowCache, StackKey}; pub use display::{DisplayKind, tile_bytes}; pub use eval::{ - Composite, Inputs, PaintTarget, Stencil, StrokePreview, all_tiles, composite_tiles, composite_tiles_cached, covered_tiles, effect_histogram, flatten_layer, - mask_at, mask_image, pad_tiles, + BLOCK, Composite, Inputs, PaintTarget, Stencil, StrokePreview, all_tiles, composite_tiles, composite_tiles_cached, covered_tiles, effect_histogram, + flatten_layer, mask_at, mask_image, pad_tiles, }; pub use store::{BakedMaps, ImageRes, ImageStore, PixelStore}; pub use thumb::{THUMB_TEXELS, ThumbImage, ThumbTarget}; diff --git a/crates/compose/tests/cache_and_instances.rs b/crates/compose/tests/cache_and_instances.rs index d7df0258..bd8efe80 100644 --- a/crates/compose/tests/cache_and_instances.rs +++ b/crates/compose/tests/cache_and_instances.rs @@ -573,3 +573,136 @@ fn gathering_filters_composite_identically_in_any_grouping_and_cached() { assert!(!check_cached(&f, 0, hot).is_empty()); } } + +/// Composite every tile in chunks of `chunk`, telling the cache the `ahead` tiles that follow each chunk, as a pass spread over frames does. +fn run_sliced(f: &Fixture, cache: &mut BelowCache, chunk: usize, ahead: usize) -> Composite { + let all = all_tiles(RES, RES); + let (images, baked) = (Default::default(), Default::default()); + let mut out = Composite::new(&f.project.texture_sets[0].channel_list(), RES); + for (index, tiles) in all.chunks(chunk).enumerate() { + let done = (index * chunk + tiles.len()).min(all.len()); + cache.ahead = all.iter().skip(done).take(ahead).copied().collect(); + composite_tiles_cached(&inputs(f, 0, &images, &baked), &mut out, tiles, Some(&mut *cache)); + assert_eq!(cache.holds_fields(), !cache.ahead.is_empty(), "fields are kept exactly while tiles follow (chunk {chunk}, ahead {ahead})"); + } + out +} + +#[test] +fn filter_fields_kept_across_the_chunks_of_a_pass_composite_exactly() { + let mut f = fixture(); + let top = heavy_stack(&mut f); + let blurred_fill = f.project.texture_sets[0].stack[1]; + let want = reference(&f, 0); + for hot in [None, Some(top), Some(blurred_fill)] { + // Short and long runs of kept tiles: chunks inside a run reuse it, chunks past its end filter again + for (chunk, ahead) in [(1, 1), (1, 5), (3, 4), (5, 16), (2, 0)] { + let mut cache = BelowCache::default(); + cache.set_hot(hot); + assert!(run_sliced(&f, &mut cache, chunk, ahead) == want, "a cold sliced pass differs (hot {hot:?}, chunk {chunk}, ahead {ahead})"); + // The hot-layer cache is warm now: only the hot layer's fields are needed + assert!(run_sliced(&f, &mut cache, chunk, ahead) == want, "a warm sliced pass differs (hot {hot:?}, chunk {chunk}, ahead {ahead})"); + } + } + + // A cache too small for the set drops tiles while a run of kept fields is in use: those tiles need every layer's fields again + let mut full = BelowCache::default(); + full.set_hot(Some(top)); + run(&f, 0, &all_tiles(RES, RES), Some(&mut full)); + let tile_bytes = full.tile_bytes().unwrap(); + for tiles_held in [2, 5, 9] { + for (chunk, ahead) in [(1, 5), (3, 4), (2, 16)] { + let mut cache = BelowCache::default(); + cache.budget = tiles_held * tile_bytes; + cache.set_hot(Some(top)); + for pass in 0..3 { + assert!(run_sliced(&f, &mut cache, chunk, ahead) == want, "pass {pass} differs with {tiles_held} cached tiles (chunk {chunk}, ahead {ahead})"); + } + } + } +} + +#[test] +fn kept_filter_fields_are_not_used_after_an_edit_or_under_a_live_stroke() { + let mut f = fixture(); + let top = heavy_stack(&mut f); + let all = all_tiles(RES, RES); + let (first, rest) = all.split_at(3); + let mut cache = BelowCache::default(); + cache.set_hot(Some(top)); + + // Fields are kept for the tiles after the first chunk… + cache.ahead = rest.to_vec(); + let mut out = run(&f, 0, first, Some(&mut cache)); + assert!(cache.holds_fields()); + + // …then the blurred mask of the hot layer changes before they are composited + let mask = f.project.layer_mut(top).unwrap().mask.as_mut().unwrap(); + mask.effects[1].kind = EffectKind::Filter(Filter::Blur { radius: 6.0 }); + let (images, baked) = (Default::default(), Default::default()); + cache.ahead = Vec::new(); + composite_tiles_cached(&inputs(&f, 0, &images, &baked), &mut out, &all, Some(&mut cache)); + assert!(out == reference(&f, 0), "fields kept from before an edit were used after it"); + assert!(!cache.holds_fields()); + + // A live stroke is not part of what kept fields are compared by: it composites without them + let preview = stroke(top); + cache.ahead = rest.to_vec(); + let mut live = run_with(&f, 0, first, Some(&mut cache), Some(&preview)); + assert!(!cache.holds_fields()); + let mut inp = inputs(&f, 0, &images, &baked); + inp.preview = Some(&preview); + composite_tiles_cached(&inp, &mut live, rest, Some(&mut cache)); + assert!(live == run_with(&f, 0, &all, None, Some(&preview)), "a live stroke over a sliced pass differs"); +} + +/// Kept fields hold a layer off the hot path only over the tiles the cache lacked when they were built. A tile the cache drops +/// while they are in use needs that layer's fields again. +#[test] +fn tiles_the_cache_drops_during_a_kept_run_are_filtered_again() { + const SIZE: u32 = 512; + let mesh = primitives::sphere(1.0, 32, 16); + let gbuf = UvGBuffer::new(&mesh, 0, SIZE, SIZE); + let mut project = Project::new("t", "builtin:sphere"); + project.texture_sets.push(TextureSet::new("A", 0, SIZE)); + let mut f = Fixture { project, mesh, gbuf, pixels: PixelStore::default() }; + add(&mut f, 0, fill(&[(Channel::BaseColor, procedural(ProceduralKind::Clouds, 0.1, 0.9))]), None); + // A pattern with detail on every tile, so a tile composited without its blur shows + let mut blurred = Mask::new(MaskBackground::Black); + blurred.effects.push(effect(&mut f, EffectKind::Fill { source: procedural(ProceduralKind::Checker, 0.0, 1.0), projection: Projection::default() })); + blurred.effects.push(effect(&mut f, EffectKind::Filter(Filter::Blur { radius: 40.0 }))); + add(&mut f, 0, fill(&[(Channel::Roughness, procedural(ProceduralKind::Grunge, 0.0, 1.0))]), Some(blurred)); + // A paint layer on top leaves the blurred layer in sight + let hot = add(&mut f, 0, LayerKind::Paint, None); + paint_rect_at(&mut f, hot, SIZE, (10, 10), (40, 40), 0.2); + + let mut all = all_tiles(SIZE, SIZE); + all.sort_by_key(|&(x, y)| (y, x)); + let channels = f.project.texture_sets[0].channel_list(); + let (images, baked) = (Default::default(), Default::default()); + let mut want = Composite::new(&channels, SIZE); + composite_tiles(&inputs(&f, 0, &images, &baked), &mut want, &all); + + // The cache holds the two bottom rows of tiles, and no more than that + let rows = (SIZE / TILE) as usize; + let (above, bottom) = all.split_at(all.len() - 2 * rows); + let mut cache = BelowCache::default(); + cache.set_hot(Some(hot)); + let mut out = Composite::new(&channels, SIZE); + composite_tiles_cached(&inputs(&f, 0, &images, &baked), &mut out, bottom, Some(&mut cache)); + assert_eq!(cache.len(), bottom.len()); + cache.budget = cache.bytes(); + + // One tile at a time with every later tile ahead: the first composite keeps fields for the whole set, the blurred layer's + // only over the rows above. Recording those rows then drops the bottom ones from the cache before their turn + let mut out = Composite::new(&channels, SIZE); + for (index, tile) in all.iter().enumerate() { + cache.ahead = all.iter().skip(index + 1).copied().collect(); + composite_tiles_cached(&inputs(&f, 0, &images, &baked), &mut out, &[*tile], Some(&mut cache)); + if index == 0 { + assert!(cache.holds_fields()); + } + } + assert!(above.len() > bottom.len()); + assert!(out == want, "a tile dropped from the cache was composited with fields that lack the layers off the hot path"); +} diff --git a/crates/engine/src/session.rs b/crates/engine/src/session.rs index 9d58670b..ca7f6521 100644 --- a/crates/engine/src/session.rs +++ b/crates/engine/src/session.rs @@ -817,6 +817,8 @@ impl Session { images: &self.images, bounds: self.mesh.bounds(), }; + // A pass spread over frames tells the compositor what comes next, so neighbourhood filters run once over a run of tiles + cache.below.ahead = if budget_ms.is_finite() { tiles_ahead(&cache.dirty, &tiles) } else { Vec::new() }; texturecraft_compose::composite_tiles_cached(&inputs, &mut cache.composite, &tiles, Some(&mut cache.below)); // The composited tiles and the neighbours their padding reached change. let padded = pad_tiles(&mut cache.composite, &cache.dilation, &tiles); @@ -977,6 +979,19 @@ fn next_chunk(dirty: &mut BTreeSet<(u32, u32)>, n: usize) -> Vec<(u32, u32)> { } /// Valid texture set resolutions: powers of two from 128 to 8192. +/// Dirty tiles a neighbourhood filter runs over ahead of the chunk being composited (see [`tiles_ahead`]). +const FILTER_AHEAD: usize = 64; + +/// The dirty tiles composited after `chunk` in its 16 × 16 tile blocks, in the order [`next_chunk`] takes them, at most [`FILTER_AHEAD`]. +fn tiles_ahead(dirty: &BTreeSet<(u32, u32)>, chunk: &[(u32, u32)]) -> Vec<(u32, u32)> { + let block = |&(x, y): &(u32, u32)| (y / texturecraft_compose::BLOCK, x / texturecraft_compose::BLOCK); + let blocks: BTreeSet<(u32, u32)> = chunk.iter().map(block).collect(); + let mut ahead: Vec<(u32, u32)> = dirty.iter().copied().filter(|tile| blocks.contains(&block(tile))).collect(); + ahead.sort_by_key(|tile| (block(tile), tile.1, tile.0)); + ahead.truncate(FILTER_AHEAD); + ahead +} + pub fn check_resolution(r: u32) -> Result { if (128..=8192).contains(&r) && r.is_power_of_two() { Ok(r) diff --git a/crates/engine/tests/it/perf.rs b/crates/engine/tests/it/perf.rs index e4691b6a..4b97420d 100644 --- a/crates/engine/tests/it/perf.rs +++ b/crates/engine/tests/it/perf.rs @@ -397,3 +397,41 @@ fn bench_layer_thumbs_4k() { } eprintln!(" every target once: {:.1} ms ({} pictures)", total.as_secs_f64() * 1e3, targets.len()); } + +/// A full recomposite in one call against the same one spread over frames, as the UI runs it, with and without a blurred mask +/// in the stack: neighbourhood filters are what a frame slice pays for apart from its own tiles. +#[test] +#[ignore] +fn bench_sliced_filters_4k() { + for blur in [false, true] { + let mut s = Session::new_project("sliced", primitives::sphere(1.0, 64, 32), "builtin:sphere", None, 4096).unwrap(); + s.viewport = Vec2::new(800.0, 800.0); + let run = |s: &mut Session, id: &str, p: Value| execute(s, id, &p).unwrap(); + run(&mut s, "layer.add.fill", json!({"color": [0.6, 0.5, 0.4], "roughness": 0.6})); + run(&mut s, "layer.add.fill", json!({"color": [0.1, 0.3, 0.6]})); + run(&mut s, "mask.add.black", Value::Null); + run(&mut s, "effect.add.generator", json!({"generator": "position", "level": 0.5})); + if blur { + run(&mut s, "effect.add.filter", json!({"filter": "blur", "radius": 8})); + } + s.update(); + + s.caches[0].invalidate_all(); + let t = Instant::now(); + s.update(); + let direct = t.elapsed(); + + s.caches[0].invalidate_all(); + let clock = Instant::now(); + let ms = || clock.elapsed().as_secs_f64() * 1000.0; + let (mut frames, mut worst) = (0, Duration::ZERO); + while s.pending_tiles() > 0 { + let t = Instant::now(); + s.update_for(30.0, ms); + worst = worst.max(t.elapsed()); + frames += 1; + } + let label = if blur { "blurred mask" } else { "no filter" }; + println!("[sliced 4096², {label}] one call {direct:.2?}; in 30 ms slices {frames} frames, worst {worst:.2?}, total {:.2?}", clock.elapsed()); + } +} From 74d213272d08b67fc0abaa4e6d9db3e30734f4f3 Mon Sep 17 00:00:00 2001 From: Morion Date: Fri, 13 Nov 2026 14:20:27 -0500 Subject: [PATCH 34/39] Release kept filter fields when a stroke begins during a sliced pass (#475) Fields kept for the coming composites stayed allocated for as long as a stroke lasted while tiles still followed, because the end-of-pass cleanup only runs when none do. A stroke already kept them from being used; now it also drops them. The test keeps fields first, then starts the stroke. --- crates/compose/src/eval.rs | 6 +++++ crates/compose/tests/cache_and_instances.rs | 25 +++++++++++++++++++++ 2 files changed, 31 insertions(+) diff --git a/crates/compose/src/eval.rs b/crates/compose/src/eval.rs index 0815124d..16bf2bd3 100644 --- a/crates/compose/src/eval.rs +++ b/crates/compose/src/eval.rs @@ -1700,6 +1700,12 @@ pub fn composite_tiles_cached(inp: &Inputs, out: &mut Composite, tiles: &[(u32, let holds = below.is_some() && inp.preview.is_none() && has_neighbourhood(inp, &set.stack); let key = if holds { StackKey::new(inp.project, inp.pixels, inp.baked, inp.images, inp.ts, &set.stack).map(Arc::new) } else { None }; let size = (inp.gbuf.width, inp.gbuf.height); + // Fields kept before a stroke began are not used under it, nor held while it lasts + if key.is_none() + && let Some(cache) = below.as_deref_mut() + { + cache.held = None; + } for (at, block) in &blocks { let lacks = |tile: &(u32, u32)| below.as_deref().zip(split.as_deref()).is_none_or(|(cache, _)| cache.tile(*tile).is_none()); let fresh: Vec<(u32, u32)> = block.iter().copied().filter(lacks).collect(); diff --git a/crates/compose/tests/cache_and_instances.rs b/crates/compose/tests/cache_and_instances.rs index bd8efe80..b5dd0602 100644 --- a/crates/compose/tests/cache_and_instances.rs +++ b/crates/compose/tests/cache_and_instances.rs @@ -706,3 +706,28 @@ fn tiles_the_cache_drops_during_a_kept_run_are_filtered_again() { assert!(above.len() > bottom.len()); assert!(out == want, "a tile dropped from the cache was composited with fields that lack the layers off the hot path"); } + +/// A stroke that starts while fields are kept must not leave them allocated for as long as it lasts, even though tiles still follow. +#[test] +fn a_live_stroke_releases_the_fields_kept_before_it_started() { + let mut f = fixture(); + let top = heavy_stack(&mut f); + let all = all_tiles(RES, RES); + let (first, rest) = all.split_at(3); + let mut cache = BelowCache::default(); + cache.set_hot(Some(top)); + + cache.ahead = rest.to_vec(); + run(&f, 0, first, Some(&mut cache)); + assert!(cache.holds_fields()); + + // The stroke begins with tiles still following: the pass is not over, so nothing else would clear them + let preview = stroke(top); + let mut live = run_with(&f, 0, first, Some(&mut cache), Some(&preview)); + assert!(!cache.holds_fields(), "fields kept before the stroke stay allocated while it lasts"); + let (images, baked) = (Default::default(), Default::default()); + let mut inp = inputs(&f, 0, &images, &baked); + inp.preview = Some(&preview); + composite_tiles_cached(&inp, &mut live, rest, Some(&mut cache)); + assert!(live == run_with(&f, 0, &all, None, Some(&preview)), "a stroke that starts during a sliced pass differs"); +} From b89badcd6f883751f79960f93c554fb77f063885 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sat, 14 Nov 2026 15:42:13 -0500 Subject: [PATCH 35/39] Budget the total payload of one .mcmat (#499) * formats: budget the total payload of one .mcmat * formats: format the .mcmat map-limit test --- crates/formats/src/mcmat.rs | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/crates/formats/src/mcmat.rs b/crates/formats/src/mcmat.rs index 55b6f6ee..441bae10 100644 --- a/crates/formats/src/mcmat.rs +++ b/crates/formats/src/mcmat.rs @@ -20,6 +20,10 @@ const FORMAT: &str = "craft-material"; const VERSION: u32 = 1; /// Largest entry read (maps are at most 8192² × 16 bits, compressed). const MAX_ENTRY: u64 = 512 << 20; +/// Most map entries one manifest may name (a material has at most nine usages). +const MAX_MAPS: usize = 64; +/// Largest total payload read from one `.mcmat`: maps and source together (audit: TextureCraft #4). +const MAX_TOTAL: u64 = 1 << 30; const KIND: &str = "MaterialCraft material"; #[derive(Clone, Debug, PartialEq, Deserialize)] @@ -69,6 +73,7 @@ fn malformed(msg: impl Into) -> FormatError { /// Read `.mcmat` bytes. pub fn read_mcmat(bytes: &[u8]) -> Result { let mut z = zip::ZipArchive::new(Cursor::new(bytes)).map_err(|e| malformed(e.to_string()))?; + let mut total = 0u64; let mut read = |name: &str| -> Result> { let mut out = Vec::new(); let f = z.by_name(name).map_err(|_| malformed(format!("{name} is missing")))?; @@ -76,6 +81,10 @@ pub fn read_mcmat(bytes: &[u8]) -> Result { if out.len() as u64 > MAX_ENTRY { return Err(FormatError::TooLarge(name.to_string())); } + total = total.saturating_add(out.len() as u64); + if total > MAX_TOTAL { + return Err(FormatError::TooLarge(format!("{KIND} payload (over {MAX_TOTAL} bytes)"))); + } Ok(out) }; let manifest: Manifest = serde_json::from_slice(&read("material.json")?).map_err(|e| malformed(format!("material.json: {e}")))?; @@ -85,6 +94,9 @@ pub fn read_mcmat(bytes: &[u8]) -> Result { if manifest.version > VERSION { return Err(FormatError::Unsupported(format!("{KIND} version {} (this version reads up to {VERSION})", manifest.version))); } + if manifest.maps.len() > MAX_MAPS { + return Err(malformed(format!("{} maps, over the {MAX_MAPS} map limit", manifest.maps.len()))); + } let maps = manifest.maps.iter().map(|m| Ok((m.usage.clone(), read(&m.file)?))).collect::>>()?; let source = read(&manifest.source)?; Ok(PortableMaterial { manifest, maps, source }) @@ -167,6 +179,22 @@ mod tests { assert!(read_mcmat(b"junk").is_err()); } + #[test] + fn an_unbounded_map_list_is_refused() { + let maps: Vec<_> = (0..=MAX_MAPS).map(|_| serde_json::json!({"usage": "baseColor", "file": "maps/baseColor.png"})).collect(); + let manifest = + serde_json::json!({"format": FORMAT, "version": VERSION, "name": "n", "graph": "g", "size": [4, 4], "maps": maps, "source": "source.mcraft"}); + let mut z = zip::ZipWriter::new(Cursor::new(Vec::new())); + let o = zip::write::SimpleFileOptions::default(); + z.start_file("material.json", o).unwrap(); + z.write_all(manifest.to_string().as_bytes()).unwrap(); + z.start_file("maps/baseColor.png", o).unwrap(); + z.write_all(&mesh_map_png(4, 3, &[0.5; 48]).unwrap()).unwrap(); + z.start_file("source.mcraft", o).unwrap(); + z.write_all(b"pkg").unwrap(); + assert!(read_mcmat(&z.finish().unwrap().into_inner()).is_err()); + } + #[test] fn mesh_maps_encode_as_16_bit() { let png = mesh_map_png(2, 1, &[0.0, 0.25, 0.5, 1.0]).unwrap(); From 73083d418a2b680867d823e6542bdefb20f92d1e Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sat, 14 Nov 2026 17:02:27 -0500 Subject: [PATCH 36/39] formats: cap default resource image decode at 64 M texels (#506) Imported images still used the 16384-pixel edge limit with no texel ceiling, so a small 16k square PNG expanded to multi-gigabyte RGBA f32 buffers. Default resource decoding now refuses more than 8192 square texels from the header, and the engine import path uses the same budget. --- crates/engine/src/resource_cmds.rs | 2 +- crates/formats/src/image_res.rs | 15 +++++++++++++-- crates/formats/src/lib.rs | 4 ++++ 3 files changed, 18 insertions(+), 3 deletions(-) diff --git a/crates/engine/src/resource_cmds.rs b/crates/engine/src/resource_cmds.rs index 54876d19..67665c4e 100644 --- a/crates/engine/src/resource_cmds.rs +++ b/crates/engine/src/resource_cmds.rs @@ -38,7 +38,7 @@ pub(crate) fn decoded(d: texturecraft_formats::DecodedImage) -> Arc { impl Session { /// Add an image resource from bytes (one undo step); returns its unique, sanitized name pub fn import_resource_bytes(&mut self, file_name: &str, bytes: Vec) -> Result { - self.edit("Import resource", |s| s.add_image_resource(file_name, bytes, u64::MAX)) + self.edit("Import resource", |s| s.add_image_resource(file_name, bytes, texturecraft_formats::MAX_RESOURCE_TEXELS)) } /// Add an image within a decoded texel budget, inside the caller's edit diff --git a/crates/formats/src/image_res.rs b/crates/formats/src/image_res.rs index 85590d9d..bcff2435 100644 --- a/crates/formats/src/image_res.rs +++ b/crates/formats/src/image_res.rs @@ -1,6 +1,6 @@ //! Decoding imported image resources (fills, alphas, stencils). -use crate::{FormatError, MAX_IMAGE_SIZE, Result}; +use crate::{FormatError, MAX_IMAGE_SIZE, MAX_RESOURCE_TEXELS, Result}; /// A decoded image: RGBA as 0..1 floats in the file's own encoding (8/16-bit files stay /// sRGB-encoded; `srgb` says so), row-major, top row first. @@ -15,7 +15,7 @@ pub struct DecodedImage { /// Decode PNG, JPEG, TGA, TIFF, BMP, WEBP, EXR or HDR bytes. pub fn decode_image(bytes: &[u8]) -> Result { - decode_image_within(bytes, u64::MAX) + decode_image_within(bytes, MAX_RESOURCE_TEXELS) } /// [`decode_image`] for an image of at most `max_texels` (width × height), checked from the @@ -100,4 +100,15 @@ mod tests { assert!(matches!(decode_image_within(&png, 63), Err(FormatError::TooLarge(_)))); assert!(decode_image(&png).is_ok()); } + + #[test] + fn the_default_decoder_refuses_more_than_the_resource_texel_budget_from_the_header() { + // An 18-byte TGA header: 16384² is inside the edge limit but far over 64 M texels. + let mut header = [0u8; 18]; + header[2] = 2; + header[12..14].copy_from_slice(&16_384u16.to_le_bytes()); + header[14..16].copy_from_slice(&16_384u16.to_le_bytes()); + header[16] = 24; + assert!(matches!(decode_image(&header), Err(FormatError::TooLarge(_)))); + } } diff --git a/crates/formats/src/lib.rs b/crates/formats/src/lib.rs index 6e57432e..d8550531 100644 --- a/crates/formats/src/lib.rs +++ b/crates/formats/src/lib.rs @@ -95,6 +95,10 @@ pub(crate) fn guard(kind: &'static str, f: impl FnOnce() -> Result) -> Res /// Largest image edge accepted or produced anywhere in this crate. pub const MAX_IMAGE_SIZE: u32 = 16_384; +/// Most texels an imported image resource may decode to by default (8192 × 8192). +/// Larger images are refused from their header before any pixels are decoded. +pub const MAX_RESOURCE_TEXELS: u64 = 1 << 26; + /// Read a whole file, refusing files over `cap` bytes. #[cfg(not(target_arch = "wasm32"))] pub(crate) fn read_capped(path: &std::path::Path, cap: u64) -> Result> { From 0fa3a392fd61b3e02a86e8136bfbaa178be76100 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sat, 14 Nov 2026 17:23:06 -0500 Subject: [PATCH 37/39] formats: create atomic-write temps exclusively so a planted symlink is never followed (#502) --- crates/formats/src/lib.rs | 48 +++++++++++++++++++++++--- crates/formats/src/project_file/mod.rs | 6 ++-- 2 files changed, 45 insertions(+), 9 deletions(-) diff --git a/crates/formats/src/lib.rs b/crates/formats/src/lib.rs index d8550531..3708d737 100644 --- a/crates/formats/src/lib.rs +++ b/crates/formats/src/lib.rs @@ -112,15 +112,53 @@ pub(crate) fn read_capped(path: &std::path::Path, cap: u64) -> Result> { Ok(std::fs::read(path)?) } -/// Write `bytes` to `path` atomically: `.tmp` first, then rename over the target. +/// Create a new temporary file beside `path`, refusing to reuse an existing (possibly symlinked) name. +#[cfg(not(target_arch = "wasm32"))] +pub(crate) fn create_temp(path: &std::path::Path) -> Result<(std::path::PathBuf, std::fs::File)> { + let parent = path.parent().unwrap_or_else(|| std::path::Path::new(".")); + let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("out"); + for attempt in 0..100u32 { + let tmp = parent.join(format!(".{name}.{}.{attempt}.tmp", std::process::id())); + match std::fs::OpenOptions::new().write(true).create_new(true).open(&tmp) { + Ok(file) => return Ok((tmp, file)), + Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue, + Err(e) => return Err(e.into()), + } + } + Err(FormatError::Io(std::io::Error::new(std::io::ErrorKind::AlreadyExists, "could not create a temporary file"))) +} + +/// Write `bytes` to `path` atomically: a new temporary file first, then rename over the target. #[cfg(not(target_arch = "wasm32"))] pub fn write_atomic(path: &std::path::Path, bytes: &[u8]) -> Result<()> { - let mut tmp = path.as_os_str().to_owned(); - tmp.push(".tmp"); - let tmp = std::path::PathBuf::from(tmp); - let res = std::fs::write(&tmp, bytes).and_then(|_| std::fs::rename(&tmp, path)); + use std::io::Write; + let (tmp, mut file) = create_temp(path)?; + let res = file.write_all(bytes).and_then(|_| file.sync_all()); + drop(file); + let res = res.and_then(|_| std::fs::rename(&tmp, path)); if res.is_err() { let _ = std::fs::remove_file(&tmp); } Ok(res?) } + +#[cfg(all(test, unix))] +mod atomic_tests { + use super::write_atomic; + + #[test] + fn write_atomic_does_not_follow_a_planted_temp_symlink() -> std::io::Result<()> { + let dir = std::env::temp_dir().join(format!("tc-atomic-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(&dir)?; + let target = dir.join("out.png"); + let victim = dir.join("victim.txt"); + std::fs::write(&victim, b"safe")?; + std::os::unix::fs::symlink(&victim, dir.join("out.png.tmp"))?; + write_atomic(&target, b"new").map_err(std::io::Error::other)?; + assert_eq!(std::fs::read(&victim)?, b"safe"); + assert_eq!(std::fs::read(&target)?, b"new"); + let _ = std::fs::remove_dir_all(&dir); + Ok(()) + } +} diff --git a/crates/formats/src/project_file/mod.rs b/crates/formats/src/project_file/mod.rs index 8390220a..e982d761 100644 --- a/crates/formats/src/project_file/mod.rs +++ b/crates/formats/src/project_file/mod.rs @@ -101,11 +101,9 @@ pub fn save_project_bytes(pf: &ProjectFile) -> Result> { /// Save atomically: `.tmp` first, then rename over `path`. #[cfg(not(target_arch = "wasm32"))] pub fn save_project(path: &std::path::Path, pf: &ProjectFile) -> Result<()> { - let mut tmp = path.as_os_str().to_owned(); - tmp.push(".tmp"); - let tmp = std::path::PathBuf::from(tmp); + let (tmp, file) = crate::create_temp(path)?; let res = (|| -> Result<()> { - let mut file = std::io::BufWriter::new(std::fs::File::create(&tmp)?); + let mut file = std::io::BufWriter::new(file); write_project(&mut file, pf)?; file.into_inner().map_err(|e| e.into_error())?.sync_all()?; std::fs::rename(&tmp, path)?; From 9ed81da8cbcfff0bf11d362f0e83fa4baa9d1300 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sat, 14 Nov 2026 17:28:04 -0500 Subject: [PATCH 38/39] formats: account for the USDC path table's real allocation (#507) The PATHS table charged 64 bytes per entry but allocates Option (about 80), letting a small declared count exceed the decoded-byte budget, and had no entry ceiling. Charge the real element size and cap the table at four million paths. --- crates/formats/src/mesh_import/usd/usdc.rs | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/crates/formats/src/mesh_import/usd/usdc.rs b/crates/formats/src/mesh_import/usd/usdc.rs index 221c7b4a..0a07b637 100644 --- a/crates/formats/src/mesh_import/usd/usdc.rs +++ b/crates/formats/src/mesh_import/usd/usdc.rs @@ -15,6 +15,9 @@ const MIN_VERSION: (u8, u8, u8) = (0, 4, 0); const MAX_SECTIONS: usize = 64; /// Items in one table or array. const MAX_ITEMS: usize = 1 << 28; +/// Entries in the PATHS table. The declared count is tiny in the file but each entry is a +/// materialised path, so it needs its own ceiling as well as the decoded-byte budget. +const MAX_PATHS: usize = 4_000_000; /// Spec types. const SPEC_ATTRIBUTE: i64 = 1; @@ -248,7 +251,11 @@ impl<'a> Crate<'a> { let index = s.ints(n, 4, budget)?; let elements = s.ints(n, 4, budget)?; let jumps = s.ints(n, 4, budget)?; - budget.take(total.saturating_mul(64))?; + if total > MAX_PATHS { + return Err(FormatError::TooLarge(format!("the USD path table has {total} entries (limit {MAX_PATHS})"))); + } + // Charge what the vector really allocates, not a guessed 64 bytes per entry. + budget.take(total.saturating_mul(std::mem::size_of::>()))?; self.paths = vec![None; total]; let mut work: Vec<(usize, Option)> = vec![(0, None)]; let mut steps = 0usize; From 5e4f511f178d6691d052123321e194113c1bcae0 Mon Sep 17 00:00:00 2001 From: chasse20 Date: Sat, 14 Nov 2026 21:18:26 -0500 Subject: [PATCH 39/39] Added CODE_STYLE (not referenced by AGENTS) as helper for maintaining better code quality --- CODE_STYLE.md | 77 ++++++++++++++++++++++++++++ docs/helpful-pr-review-guidelines.md | 36 +------------ 2 files changed, 79 insertions(+), 34 deletions(-) create mode 100644 CODE_STYLE.md diff --git a/CODE_STYLE.md b/CODE_STYLE.md new file mode 100644 index 00000000..86dcc057 --- /dev/null +++ b/CODE_STYLE.md @@ -0,0 +1,77 @@ +# Code style + +Style conventions for MaterialCraft's Rust code. +Read alongside [AGENTS.md](AGENTS.md) for repository requirements. + +## Naming and Rust conventions + +- Use descriptive names that explain purpose; include units where useful. Avoid misleading names + and abbreviations whose meaning is unclear in context. +- Follow Rust naming conventions: `snake_case` for functions, variables, fields, and modules; + `UpperCamelCase` for types and traits; `SCREAMING_SNAKE_CASE` for constants and statics. +- Conventional Rust names are not cryptic abbreviations. Keep names such as `fmt`, `iter`, `len`, + `args`, `err`, `id`, and `ui` when their meaning is clear. Do not expand them just to make them + longer. +- Keep standard file and directory names such as `lib.rs`, `main.rs`, `mod.rs`, `src`, `tests`, + `examples`, and `benches`. Rust keywords such as `mut`, `ref`, `impl`, and `mod` are language + syntax, not naming problems. +- Short names are appropriate in a clear local context: `i` for an index, `x` and `y` for + coordinates, `w` and `h` for image dimensions, and conventional generic parameters such as `T`. + Use more descriptive names when scope or ambiguity makes those hard to follow. + +## Magic numbers + +- Give non-obvious limits, thresholds, sizes, and tuning values descriptive named constants + instead of leaving unexplained numeric literals in the code. +- Name constants for their purpose, with units where useful, rather than for their literal value. + Keep them in the narrowest useful scope. +- Reuse an existing constant when it represents the same concept. Equal numeric values alone do + not mean two concepts should share a constant. +- Explain the origin or rationale of non-obvious coefficients and tolerances in a short comment. + Use standard library constants for standard mathematical values. +- Keep literals inline when their role is clear, such as zero initialization, incrementing by one, + or dividing by two to find a midpoint. Do not introduce names such as `ZERO` or `TWO` that add + no meaning. +- Apply this guidance to tests too; clear fixture values and expected results can remain literal. + +## Formatting and spacing + +- Let `cargo fmt` and the repository's [rustfmt.toml](rustfmt.toml) handle mechanical formatting. + Do not introduce a competing indentation or line-wrapping convention. +- Use one blank line between distinct logical steps: input preparation, validation, computation, + mutation, and result construction. +- Keep closely related statements together. Do not add a blank line after every declaration or + fragment a single operation with extra spacing. +- Put a blank line after a multiline early-exit guard, including `if` and `let ... else`, before + the next statement. +- Put a blank line before a comment introducing a new step, with no blank line between the + comment and the code it explains. +- Keep documentation and attributes attached to their declarations. +- Separate function definitions with one blank line. Avoid extra empty lines just inside braces + or between every field, argument, or statement. +- In tests, separate preparation, action, and verification with blank lines when those phases + are distinct; keep related assertions together. + +## Source organization + +- Give each struct or enum its own source file, with its implementation beside it. Use the full + type name in `snake_case`, such as `mesh_curvature_settings.rs` for `MeshCurvatureSettings`. +- Preserve conventional crate roots and module entry points such as `lib.rs`, `main.rs`, and + `mod.rs`. Follow the command and node module placement required by `AGENTS.md`. +- Prefer singular folder names for new domain modules, such as `map`, `setting`, or `tracing`. + Keep standard Rust directories and repository-mandated paths unchanged. +- Group related types into focused modules rather than collecting unrelated types in one large file. +- Apply these preferences to new types and source organization changes within scope. Do not + reorganize unrelated existing code to enforce them. + +## Comments + +- Explain intent or a non-obvious constraint rather than narrating the code. +- Use short `//` comments. Avoid block comments and wrapped prose in ordinary implementation + comments; adjacent comment lines should each express a concise point. +- Do not add trailing punctuation to ordinary code comments. +- Preserve explanations of guards and invariants. Remove stale or redundant comments without + losing necessary rationale. +- API documentation, required license headers, and examples may use conventional multiline + formatting and punctuation. +- Apply the same comment guidance to production code and tests. diff --git a/docs/helpful-pr-review-guidelines.md b/docs/helpful-pr-review-guidelines.md index 098b6ae1..fbe4f69d 100644 --- a/docs/helpful-pr-review-guidelines.md +++ b/docs/helpful-pr-review-guidelines.md @@ -8,7 +8,7 @@ Use these preferences when reviewing and improving a PR. Follow repository requi - Review-only requests call for findings; requests to fix or improve also authorize focused local edits - A review may conclude that no changes are needed. If the PR meets the applicable standards and no actionable issues are found, leave it unchanged. Do not invent findings, add unnecessary tests, or make edits merely to produce a diff. Report what was checked and any remaining validation limits - Apply all review standards across the entire affected method, including existing code and relevant tests -- Complete naming, spacing, and comment cleanup throughout it +- Read and apply [CODE_STYLE.md](../CODE_STYLE.md) throughout that scope - Make additional correctness or performance changes when supported by evidence and appropriate validation - Separate substantial changes that address an independent problem, explaining why - Apply the same scope to standalone functions and inspect relevant callers when verifying behavior @@ -27,6 +27,7 @@ Use these preferences when reviewing and improving a PR. Follow repository requi ## Optimization and simplicity - Prefer the smallest complete solution that is efficient and easy to understand +- Keep control flow direct and share repeated logic when it makes the code simpler - Look for repeated calculations, expensive iterations, unnecessary allocations, and redundant data access - For loops, batches, and streaming operations, trace allocations and buffer lifetimes across multiple iterations, including outputs retained from earlier iterations. Identify work that belongs once per operation rather than once per item, using the full selection when making retention decisions - Consider caching, batching, and parallelism when measurements justify their complexity and memory cost @@ -35,39 +36,6 @@ Use these preferences when reviewing and improving a PR. Follow repository requi - Check what the compiler already optimizes before replacing clear arithmetic with micro-optimizations - Avoid speculative optimization, unnecessary dependencies, and abstractions that add more code than clarity -## Clarity, naming, and spacing - -- Clean up the functions or methods being changed and their relevant tests within the scope above -- Use descriptive names that explain purpose; include units where useful -- Avoid cryptic abbreviations, misleading names, and unexplained production constants -- Keep control flow direct and share repeated logic when it makes the code simpler -- Use a single blank line to separate logical steps, such as input preparation, validation, computation, mutation, and result construction, when those steps are distinct -- Keep closely related statements together; avoid spacing that fragments a single operation or inserts a blank line after every declaration -- Put a blank line after a multiline early-exit guard, including `if` and `let ... else`, before the next statement -- Keep comments attached to the code they explain; put a blank line before a comment introducing a new step, with no blank line between the comment and that step -- Keep documentation and attributes attached to their declarations -- Separate function definitions with one blank line; avoid extra empty lines immediately inside braces or between every field, argument, or statement -- Group tests into preparation, action, and verification with blank lines where those phases are distinct; keep related assertions together -- Apply this spacing consistently throughout affected functions, methods, and tests, and follow the repository's formatter for mechanical formatting - -## Source organization - -- Keep each class, enum, or struct in its own source file, with its implementation beside it -- Spell out the full type name in the filename; use the language's filename convention, such as `mesh_curvature_settings.rs` for `MeshCurvatureSettings` in Rust -- Use singular folder names, such as `map`, `setting`, or `tracing` -- Group related types into focused modules and share helpers where useful without collecting unrelated types into one large file -- Apply these preferences to new types and source organization changes within scope; follow mandatory repository layout rules and leave unrelated existing structure alone - -## Comments - -- Use short, single-line comments; adjacent comment lines should each express a concise point -- Avoid block comments and wrapped prose in ordinary implementation comments -- Explain intent or a non-obvious constraint rather than narrating the code -- No trailing punctuation on ordinary code comments -- Preserve explanations of guards and invariants; remove stale or redundant comments without losing necessary rationale -- API documentation, required license headers, and examples may use their conventional multiline formatting and punctuation -- Apply these standards to both production code and tests - ## Validation and reporting - Run relevant tests and required repository checks with the project's expected toolchain