diff --git a/crates/automation/src/headless.rs b/crates/automation/src/headless.rs index 87d58648..0af8274d 100644 --- a/crates/automation/src/headless.rs +++ b/crates/automation/src/headless.rs @@ -72,7 +72,7 @@ fn join(dir: &str, name: &str) -> String { impl Headless { pub fn new(session: Session, fs: Filesystem) -> Headless { // Bakes run here (CLI, MCP) cast their rays on the GPU when there is one. - texturecraft_engine::bake_cmds::install_gpu_tracer(std::sync::Arc::new(texturecraft_render::gpu_bake::GpuBaker::new())); + texturecraft_engine::bake::install_gpu_tracer(std::sync::Arc::new(texturecraft_render::gpu_bake::GpuBaker::new())); Headless { session, fs, gpu: None } } diff --git a/crates/automation/src/render.rs b/crates/automation/src/render.rs index 4621d6a0..c61fce50 100644 --- a/crates/automation/src/render.rs +++ b/crates/automation/src/render.rs @@ -72,7 +72,7 @@ impl Gpu { // The aux texture behind the mesh-map and mask views (rebuilt every render). let res = texturecraft_render::aux_size(cache.size); let aux = match s.view { - ViewMode::MeshMap(m) => Some(texturecraft_render::mesh_maps::mesh_map_rgba(s.doc.baked.get(&ts), m, res)), + ViewMode::MeshMap(m) => Some(texturecraft_render::mesh_maps::mesh_map_rgba(s.doc.baked.get(&ts), m, res, cache.size, &comp.block_scales)), ViewMode::Mask(id) if s.doc.project.locate(id).is_some_and(|(t, _, _)| t == ts) => s.mask_view_rgba(id, res), _ => None, }; diff --git a/crates/bake/src/lib.rs b/crates/bake/src/lib.rs index 0b315cdb..67c349a4 100644 --- a/crates/bake/src/lib.rs +++ b/crates/bake/src/lib.rs @@ -143,14 +143,20 @@ fn alloc(count: usize, value: T) -> Result, BakeError> { } pub fn bake(request: &BakeRequest, progress: &Progress) -> Result { - bake_in_strips(request, progress, STRIP_TEXELS, &CpuTracer) + bake_in_strips(request, progress, STRIP_TEXELS, &CpuTracer, &[]) } /// Retry on the CPU if the supplied tracer fails pub fn bake_on(request: &BakeRequest, progress: &Progress, tracer: &dyn Tracer) -> Result { - match bake_in_strips(request, progress, STRIP_TEXELS, tracer) { + bake_tiles(request, progress, &[], Some(tracer)) +} + +/// Excluded atlas blocks produce no samples; their geometry still participates in ray tracing +pub fn bake_tiles(request: &BakeRequest, progress: &Progress, excluded_tiles: &[(u32, u32)], tracer: Option<&dyn Tracer>) -> Result { + let tracer = tracer.unwrap_or(&CpuTracer); + match bake_in_strips(request, progress, STRIP_TEXELS, tracer, excluded_tiles) { Err(BakeError::Tracer(error)) => { - let mut output = bake(request, progress)?; + let mut output = bake_in_strips(request, progress, STRIP_TEXELS, &CpuTracer, excluded_tiles)?; output.tracer = format!("CPU ({} unavailable: {error})", tracer.name()); Ok(output) } @@ -160,8 +166,18 @@ pub fn bake_on(request: &BakeRequest, progress: &Progress, tracer: &dyn Tracer) type OutRow<'a> = Vec<&'a mut [f32]>; -fn bake_in_strips(request: &BakeRequest, progress: &Progress, strip_texels: usize, tracer: &dyn Tracer) -> Result { +fn bake_in_strips( + request: &BakeRequest, + progress: &Progress, + strip_texels: usize, + tracer: &dyn Tracer, + excluded_tiles: &[(u32, u32)], +) -> Result { validate(request)?; + if excluded_tiles.iter().any(|(column, row)| *column >= request.tiles.0 || *row >= request.tiles.1) { + return Err(BakeError::Invalid("excluded UV tile lies outside the bake atlas".into())); + } + let settings = request.settings; let (tile_width, tile_height) = settings.common.output_size(); let tile_size = (tile_width as usize, tile_height as usize); @@ -196,7 +212,17 @@ fn bake_in_strips(request: &BakeRequest, progress: &Progress, strip_texels: usiz let (sample_start_y, strip_sample_height) = (strip_start * samples_per_axis, rows * samples_per_axis); strip_mesh.uvs = request.mesh.uvs.iter().map(|uv| Vec2::new(uv.x, (uv.y * sample_height as f32 - sample_start_y as f32) / strip_sample_height as f32)).collect(); - let gbuffer = UvGBuffer::new(&strip_mesh, request.material, sample_width as u32, strip_sample_height as u32); + let mut gbuffer = UvGBuffer::new(&strip_mesh, request.material, sample_width as u32, strip_sample_height as u32); + for &(column, row) in excluded_tiles { + let start_x = column as usize * tile_size.0 * samples_per_axis; + let start_y = row as usize * tile_size.1 * samples_per_axis; + let end_y = (start_y + tile_size.1 * samples_per_axis).min(sample_start_y + strip_sample_height); + for sample_y in start_y.max(sample_start_y)..end_y { + let first = (sample_y - sample_start_y) * sample_width + start_x; + gbuffer.tri.get_mut(first..first + tile_size.0 * samples_per_axis).ok_or_else(strip_error)?.fill(NO_TRI); + } + } + let coverage_rows = covered.get_mut(strip_start * width..(strip_start + rows) * width).ok_or_else(strip_error)?; coverage_rows.par_chunks_mut(width).enumerate().for_each(|(row_index, row)| { for (x, covered_pixel) in row.iter_mut().enumerate() { diff --git a/crates/bake/src/test/tile_selection.rs b/crates/bake/src/test/tile_selection.rs new file mode 100644 index 00000000..18f13968 --- /dev/null +++ b/crates/bake/src/test/tile_selection.rs @@ -0,0 +1,54 @@ +use super::{Broken, settings}; +use crate::tracing::CpuTracer; +use crate::{BakeRequest, Progress, bake, bake_in_strips, bake_tiles}; +use texturecraft_core::{BakeAntialiasing, BakedMap, TileGrid}; +use texturecraft_geom::glam::Vec2; +use texturecraft_geom::{Bvh, primitives}; + +#[test] +fn excluded_tiles_match_across_strips_antialiasing_and_cpu_fallback() { + let mut mesh = primitives::udim_plane(); + let grid = TileGrid::of(&[1001, 1002]).unwrap(); + mesh.map_material_uvs(0, |uv| Vec2::from(grid.to_atlas(uv.to_array()))); + let bvh = Bvh::new(&mesh); + let mut settings = settings(32, &[BakedMap::Position, BakedMap::AmbientOcclusion]); + settings.maps.ao.parameters.rays.rays = 4; + settings.common.antialiasing = BakeAntialiasing::Subsampling2x2; + settings.common.dilation = 4; + settings.common.apply_diffusion = true; + let request = BakeRequest { + mesh: &mesh, + bvh: &bvh, + material: 0, + low_base_color: &[], + settings: &settings, + high: None, + cage: None, + skew: None, + cage_paint: None, + tiles: (2, 1), + }; + let full = bake(&request, &Progress::new()).unwrap(); + for excluded in [[(0, 0)], [(1, 0)]] { + let partial = bake_tiles(&request, &Progress::new(), &excluded, None).unwrap(); + let strips = bake_in_strips(&request, &Progress::new(), 512, &CpuTracer, &excluded).unwrap(); + let fallback = bake_tiles(&request, &Progress::new(), &excluded, Some(&Broken)).unwrap(); + assert_eq!(strips.maps, partial.maps); + assert_eq!(fallback.maps, partial.maps); + assert!(fallback.tracer.contains("Broken unavailable")); + + for map in [BakedMap::Position, BakedMap::AmbientOcclusion] { + let components = map.components(); + for (index, pixel) in partial.maps[&map].chunks_exact(components).enumerate() { + if index % 64 / 32 == excluded[0].0 as usize { + assert_eq!(pixel, &map.neutral()[..components]); + } else { + assert_eq!(pixel, &full.maps[&map][index * components..(index + 1) * components]); + } + } + } + } + + assert!(bake_tiles(&request, &Progress::new(), &[(2, 0)], None).is_err()); + assert!(bake_tiles(&request, &Progress::new(), &[(0, u32::MAX)], None).is_err()); +} diff --git a/crates/bake/src/tests.rs b/crates/bake/src/tests.rs index 00b46b7b..bb75353e 100644 --- a/crates/bake/src/tests.rs +++ b/crates/bake/src/tests.rs @@ -17,6 +17,9 @@ use super::*; #[path = "test/setting.rs"] mod setting; +#[path = "test/tile_selection.rs"] +mod tile_selection; + fn settings(resolution: u32, maps: &[BakedMap]) -> BakeSettings { with_rays( { @@ -307,7 +310,7 @@ fn strips_match_a_single_pass() { tiles: (1, 1), }; let whole = bake(&req, &Progress::new()).unwrap(); - let strips = bake_in_strips(&req, &Progress::new(), 128 * 2, &CpuTracer).unwrap(); + let strips = bake_in_strips(&req, &Progress::new(), 128 * 2, &CpuTracer, &[]).unwrap(); for (map, a) in &whole.maps { let b = &strips.maps[map]; let off = a.iter().zip(b).filter(|(a, b)| (*a - *b).abs() > 1e-3).count(); diff --git a/crates/compose/src/baked_maps.rs b/crates/compose/src/baked_maps.rs new file mode 100644 index 00000000..1ce05bf7 --- /dev/null +++ b/crates/compose/src/baked_maps.rs @@ -0,0 +1,53 @@ +use std::collections::BTreeMap; + +use texturecraft_core::{BakedMap, BlockScales}; + +/// Dense mesh maps with `components()` floats per texel in row-major order +/// Each UV tile fills its block independently of the working resolution +/// The width is `resolution`; height follows the output size and UV tile grid +#[derive(Clone, Debug, Default, PartialEq)] +pub struct BakedMaps { + /// Width in texels + pub resolution: u32, + pub maps: BTreeMap>>, +} + +impl BakedMaps { + /// Sample a working atlas texel without resampling the stored bake + pub fn sample_working(&self, map: BakedMap, x: u32, y: u32, size: (u32, u32), scales: &BlockScales) -> Option<[f32; 3]> { + let uv = [(x as f32 + 0.5) / size.0.max(1) as f32, (y as f32 + 0.5) / size.1.max(1) as f32]; + self.sample_uv(map, scales.bake_uv(uv, size)?) + } + + /// Nearest sample in the uniform bake atlas + pub fn sample_uv(&self, map: BakedMap, uv: [f32; 2]) -> Option<[f32; 3]> { + if uv.iter().any(|value| !value.is_finite()) { + return None; + } + + let size = (self.resolution, self.height(map)); + self.sample(map, (uv[0] * size.0 as f32) as u32, (uv[1] * size.1 as f32) as u32, size) + } + + /// Height in texels of map `m`, from its length + pub fn height(&self, m: BakedMap) -> u32 { + self.maps.get(&m).map_or(0, |d| (d.len() / (self.resolution.max(1) as usize * m.components())) as u32) + } + + /// Sample the corresponding texel of an image with the supplied output size + pub fn sample(&self, map: BakedMap, x: u32, y: u32, output_size: (u32, u32)) -> Option<[f32; 3]> { + let data = self.maps.get(&map)?; + let width = u64::from(self.resolution.max(1)); + let height = u64::from(self.height(map).max(1)); + let sample_x = (u64::from(x) * width / u64::from(output_size.0.max(1))).min(width - 1); + let sample_y = (u64::from(y) * height / u64::from(output_size.1.max(1))).min(height - 1); + let component_count = map.components(); + let offset = ((sample_y * width + sample_x) as usize).checked_mul(component_count)?; + let texel = data.get(offset..offset.checked_add(component_count)?)?; + Some(if component_count == 3 { [texel[0], texel[1], texel[2]] } else { [texel[0]; 3] }) + } + + pub fn scalar(&self, m: BakedMap, x: u32, y: u32, size: (u32, u32)) -> Option { + self.sample(m, x, y, size).map(|v| v[0]) + } +} diff --git a/crates/compose/src/display.rs b/crates/compose/src/display.rs index f78e9470..ba4b675e 100644 --- a/crates/compose/src/display.rs +++ b/crates/compose/src/display.rs @@ -159,7 +159,7 @@ pub fn tile_bytes(comp: &Composite, baked: &BakedMaps, kind: DisplayKind, tx: u3 if gloss { (get(Channel::Glossiness), default16(Channel::Glossiness)) } else { (get(Channel::Roughness), default16(Channel::Roughness)) }; for i in 0..TILE_AREA { let (x, y) = (tx * TILE + (i as u32 % TILE), ty * TILE + (i as u32 / TILE)); - let baked_ao = baked.scalar(BakedMap::AmbientOcclusion, x, y, (res, comp.height)).unwrap_or(1.0); + let baked_ao = baked.sample_working(BakedMap::AmbientOcclusion, x, y, (res, comp.height), &comp.block_scales).map_or(1.0, |value| value[0]); let ch_ao = ao.and_then(|a| a.get(i)).map(|v| *v as f32 / 65535.0).unwrap_or(1.0); let px = &mut out[i * 4..i * 4 + 4]; px[0] = ((baked_ao * ch_ao).clamp(0.0, 1.0) * 255.0 + 0.5) as u8; @@ -175,7 +175,7 @@ pub fn tile_bytes(comp: &Composite, baked: &BakedMaps, kind: DisplayKind, tx: u3 let px = &mut out[i * 4..i * 4 + 4]; // The baked normal is the base the painted normal details sit on (as in export). let (x, y) = (tx * TILE + (i as u32 % TILE), ty * TILE + (i as u32 / TILE)); - let base = baked.sample(BakedMap::Normal, x, y, (res, comp.height)); + let base = baked.sample_working(BakedMap::Normal, x, y, (res, comp.height), &comp.block_scales); match (n, base) { (Some(t), None) => { for (k, d) in px.iter_mut().take(3).enumerate() { diff --git a/crates/compose/src/eval.rs b/crates/compose/src/eval.rs index ec75cd97..c5eb4978 100644 --- a/crates/compose/src/eval.rs +++ b/crates/compose/src/eval.rs @@ -93,6 +93,7 @@ pub struct Inputs<'a> { pub gbuf: &'a UvGBuffer, pub pixels: &'a PixelStore, pub baked: &'a BakedMaps, + pub block_scales: BlockScales, pub preview: Option<&'a StrokePreview>, /// Imported image resources (fill sources). pub images: &'a ImageStore, @@ -1043,7 +1044,11 @@ impl<'a, 'b> Texel<'a, 'b> { } fn baked(&self, m: BakedMap) -> Option { - self.inp.baked.scalar(m, self.x, self.y, (self.res, self.inp.gbuf.height)) + self.baked_color(m).map(|value| value[0]) + } + + fn baked_color(&self, map: BakedMap) -> Option<[f32; 3]> { + self.inp.baked.sample_working(map, self.x, self.y, (self.res, self.inp.gbuf.height), &self.inp.block_scales) } /// Where projection `proj` samples this texel: the texel's coordinates, or for a decal its @@ -1179,7 +1184,7 @@ impl<'a, 'b> Texel<'a, 'b> { v += (val - v) * o; } EffectKind::ColorSelection { colors, tolerance } => { - let id = self.inp.baked.sample(BakedMap::Id, self.x, self.y, (self.res, self.inp.gbuf.height)); + let id = self.baked_color(BakedMap::Id); let hit = id.is_some_and(|c| colors.iter().any(|k| (k[0] - c[0]).abs().max((k[1] - c[1]).abs()).max((k[2] - c[2]).abs()) <= *tolerance)); let val = if hit { 1.0 } else { 0.0 }; v += (blend1(e.blend, v, val) - v) * o; @@ -1981,7 +1986,7 @@ pub fn effect_histogram(inp: &Inputs, effect: LayerId, channel: Channel, bins: u false } }; - let cut_inp = Inputs { project: &cut, preview: None, ..*inp }; + let cut_inp = Inputs { project: &cut, preview: None, block_scales: inp.block_scales.clone(), ..*inp }; let channels = cut.texture_set(inp.ts).map(|t| t.channel_list()).unwrap_or_default(); let tiles = histogram_tiles(inp.gbuf.width, inp.gbuf.height); // A field covers the bounding box of the tiles it is built for, which for a scattered sample @@ -2058,7 +2063,7 @@ pub fn flatten_layer(inp: &Inputs, id: LayerId, tiles: &[(u32, u32)]) -> Option< if let Some(l) = solo.layers.get_mut(&id) { l.visible = true; } - let solo_inp = Inputs { project: &solo, preview: None, ..*inp }; + let solo_inp = Inputs { project: &solo, preview: None, block_scales: inp.block_scales.clone(), ..*inp }; let fields = neighbourhood_fields(&solo_inp, &channels, tiles); let out: Vec> = tiles .par_iter() @@ -2135,6 +2140,7 @@ mod tests { gbuf: &f.gbuf, pixels: &f.pixels, baked: &f.baked, + block_scales: f.project.texture_sets[0].block_scales(), preview, images: &images, bounds: f.mesh.bounds(), @@ -2252,6 +2258,7 @@ mod tests { gbuf: &fixture.gbuf, pixels: &fixture.pixels, baked: &fixture.baked, + block_scales: fixture.project.texture_sets[0].block_scales(), preview: None, images: &images, bounds: fixture.mesh.bounds(), @@ -2606,6 +2613,7 @@ soft {soft:?}" gbuf: &f.gbuf, pixels: &f.pixels, baked: &f.baked, + block_scales: f.project.texture_sets[0].block_scales(), preview: None, images: &images, bounds: f.mesh.bounds(), @@ -2667,6 +2675,7 @@ soft {soft:?}" gbuf: &f.gbuf, pixels: &f.pixels, baked: &f.baked, + block_scales: f.project.texture_sets[0].block_scales(), preview: None, images: &images, bounds: f.mesh.bounds(), diff --git a/crates/compose/src/lib.rs b/crates/compose/src/lib.rs index ee940e06..01365a27 100644 --- a/crates/compose/src/lib.rs +++ b/crates/compose/src/lib.rs @@ -7,6 +7,7 @@ #![forbid(unsafe_code)] #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] +mod baked_maps; pub mod below; pub mod display; pub mod eval; diff --git a/crates/compose/src/store.rs b/crates/compose/src/store.rs index cf640e0a..1370c0c0 100644 --- a/crates/compose/src/store.rs +++ b/crates/compose/src/store.rs @@ -1,9 +1,9 @@ //! Pixel data owned by a document: painted layer channels, painted mask effects and baked mesh //! maps. Everything is copy-on-write, so cloning the store for undo is cheap. -use std::collections::{BTreeMap, HashMap}; +use std::collections::HashMap; -use texturecraft_core::{BakedMap, Channel, ChannelKind, LayerId}; +use texturecraft_core::{Channel, ChannelKind, LayerId}; use texturecraft_texel::{TileImage, from_u16, from_u16_signed}; /// Painted data of one paint layer channel: premultiplied value(s) plus coverage, u16 per @@ -56,38 +56,7 @@ pub fn decode(kind: ChannelKind, v: u16) -> f32 { if kind == ChannelKind::Signed { from_u16_signed(v) } else { from_u16(v) } } -/// Baked mesh maps of one texture set (dense, row-major, `components()` floats per texel). The -/// width is `resolution`; height follows the output size and UV tile grid -#[derive(Clone, Debug, Default, PartialEq)] -pub struct BakedMaps { - /// Width in texels. - pub resolution: u32, - pub maps: BTreeMap>>, -} - -impl BakedMaps { - /// Height in texels of map `m` (from its length). - pub fn height(&self, m: BakedMap) -> u32 { - self.maps.get(&m).map_or(0, |d| (d.len() / (self.resolution.max(1) as usize * m.components())) as u32) - } - - /// Sample the corresponding texel of an image with the supplied output size - pub fn sample(&self, map: BakedMap, x: u32, y: u32, output_size: (u32, u32)) -> Option<[f32; 3]> { - let data = self.maps.get(&map)?; - let width = u64::from(self.resolution.max(1)); - let height = u64::from(self.height(map).max(1)); - let sample_x = (u64::from(x) * width / u64::from(output_size.0.max(1))).min(width - 1); - let sample_y = (u64::from(y) * height / u64::from(output_size.1.max(1))).min(height - 1); - let component_count = map.components(); - let offset = ((sample_y * width + sample_x) as usize).checked_mul(component_count)?; - let texel = data.get(offset..offset.checked_add(component_count)?)?; - Some(if component_count == 3 { [texel[0], texel[1], texel[2]] } else { [texel[0]; 3] }) - } - - pub fn scalar(&self, m: BakedMap, x: u32, y: u32, size: (u32, u32)) -> Option { - self.sample(m, x, y, size).map(|v| v[0]) - } -} +pub use crate::baked_maps::BakedMaps; /// A decoded image resource sampled by fills (values in the file's encoding; see `srgb`). #[derive(Clone, Debug, PartialEq)] diff --git a/crates/compose/tests/cache_and_instances.rs b/crates/compose/tests/cache_and_instances.rs index 020a9de0..d7df0258 100644 --- a/crates/compose/tests/cache_and_instances.rs +++ b/crates/compose/tests/cache_and_instances.rs @@ -90,7 +90,18 @@ fn heavy_stack(f: &mut Fixture) -> LayerId { } fn inputs<'a>(f: &'a Fixture, ts: usize, images: &'a texturecraft_compose::ImageStore, baked: &'a texturecraft_compose::BakedMaps) -> Inputs<'a> { - Inputs { project: &f.project, ts, mesh: &f.mesh, gbuf: &f.gbuf, pixels: &f.pixels, baked, preview: None, images, bounds: f.mesh.bounds() } + Inputs { + project: &f.project, + ts, + mesh: &f.mesh, + gbuf: &f.gbuf, + pixels: &f.pixels, + baked, + block_scales: f.project.texture_sets[ts].block_scales(), + preview: None, + images, + bounds: f.mesh.bounds(), + } } fn run(f: &Fixture, ts: usize, tiles: &[(u32, u32)], below: Option<&mut BelowCache>) -> Composite { diff --git a/crates/core/src/block_scales.rs b/crates/core/src/block_scales.rs new file mode 100644 index 00000000..65b2403e --- /dev/null +++ b/crates/core/src/block_scales.rs @@ -0,0 +1,43 @@ +/// Per-block UV tile scale for working-to-bake coordinates, filter radii, and height slopes +/// Empty when every tile fills its block; see [`crate::TextureSet::tile_scale`] +#[derive(Clone, Debug, Default, PartialEq)] +pub struct BlockScales { + pub(crate) block: u32, + pub(crate) cols: u32, + pub(crate) scales: Vec, +} + +impl BlockScales { + /// Working atlas UV → uniform bake atlas UV, excluding unused portions of tile blocks + pub fn bake_uv(&self, uv: [f32; 2], working_size: (u32, u32)) -> Option<[f32; 2]> { + if working_size.0 == 0 || working_size.1 == 0 || uv.iter().any(|value| !value.is_finite() || !(0.0..1.0).contains(value)) { + return None; + } + + if self.scales.is_empty() { + return Some(uv); + } + + let block = self.block.max(1) as f32; + let position = [uv[0] * working_size.0 as f32 / block, uv[1] * working_size.1 as f32 / block]; + let origin = position.map(f32::floor); + let scale = self.at((origin[0] * block) as u32, (origin[1] * block) as u32); + let local = [(position[0] - origin[0]) / scale, (position[1] - origin[1]) / scale]; + if local.iter().any(|value| !value.is_finite() || !(0.0..1.0).contains(value)) { + return None; + } + + Some([(origin[0] + local[0]) * block / working_size.0.max(1) as f32, (origin[1] + local[1]) * block / working_size.1.max(1) as f32]) + } + + /// The scale at atlas texel (x, y) + pub fn at(&self, x: u32, y: u32) -> f32 { + let (bx, by) = (x / self.block.max(1), y / self.block.max(1)); + if bx >= self.cols { + return 1.0; + } + + let index = (by as usize).checked_mul(self.cols as usize).and_then(|index| index.checked_add(bx as usize)); + index.and_then(|index| self.scales.get(index)).copied().unwrap_or(1.0) + } +} diff --git a/crates/core/src/lib.rs b/crates/core/src/lib.rs index ddaa6045..72adf044 100644 --- a/crates/core/src/lib.rs +++ b/crates/core/src/lib.rs @@ -9,6 +9,7 @@ pub mod bake; pub mod blend; +mod block_scales; pub mod channel; pub mod layer; pub mod project; diff --git a/crates/core/src/project.rs b/crates/core/src/project.rs index 26d4f6e6..36b5f856 100644 --- a/crates/core/src/project.rs +++ b/crates/core/src/project.rs @@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize}; use crate::{BakeSettings, BakedMap, Channel, ChannelFormat, CoreError, Effect, Layer, LayerId, LayerKind, Result}; -pub const FORMAT_VERSION: u32 = 1; +pub const FORMAT_VERSION: u32 = 2; /// Maximum group nesting (also bounds recursion over hostile project files) pub const MAX_DEPTH: usize = 16; @@ -63,6 +63,9 @@ pub struct TextureSet { /// [`TileGrid`], [`TextureSet::block_resolution`] texels square. #[serde(default, skip_serializing_if = "Vec::is_empty")] pub uv_tiles: Vec, + /// UV tiles excluded from baking; missing entries stay included + #[serde(default, skip_serializing_if = "BTreeSet::is_empty")] + pub bake_excluded_tiles: BTreeSet, /// Per-tile resolutions overriding `resolution` (UDIM → texels per side). A tile smaller /// than the atlas block fills the block's top-left corner (see [`TextureSet::to_atlas`]). #[serde(default, skip_serializing_if = "BTreeMap::is_empty")] @@ -132,26 +135,7 @@ impl TileGrid { } } -/// The fraction of its atlas block the UV tile of each block fills ([`TextureSet::tile_scale`]): -/// such a tile has fewer texels per UV unit, so filter radii and height slopes shrink with it. -/// Empty (every scale 1) unless a tile is smaller than its block. -#[derive(Clone, Debug, Default, PartialEq)] -pub struct BlockScales { - block: u32, - cols: u32, - scales: Vec, -} - -impl BlockScales { - /// The scale at atlas texel (x, y). - pub fn at(&self, x: u32, y: u32) -> f32 { - let (bx, by) = (x / self.block.max(1), y / self.block.max(1)); - if bx >= self.cols { - return 1.0; - } - self.scales.get(by as usize * self.cols as usize + bx as usize).copied().unwrap_or(1.0) - } -} +pub use crate::block_scales::BlockScales; fn one() -> f32 { 1.0 @@ -176,6 +160,7 @@ impl TextureSet { baked: BTreeSet::new(), visible: true, uv_tiles: Vec::new(), + bake_excluded_tiles: BTreeSet::new(), tile_resolutions: BTreeMap::new(), } } @@ -185,6 +170,10 @@ impl TextureSet { TileGrid::of(&self.uv_tiles) } + pub fn has_enabled_bake_tiles(&self) -> bool { + self.uv_tiles.is_empty() || self.uv_tiles.iter().any(|tile| !self.bake_excluded_tiles.contains(tile)) + } + /// Height strength for slopes measured over the whole texture width (the viewport shader, /// the path tracer): a UV tile atlas is one tile per column wide. pub fn atlas_height_strength(&self) -> f32 { diff --git a/crates/engine/src/bake/bake_task.rs b/crates/engine/src/bake/bake_task.rs index 831a7abc..8c942176 100644 --- a/crates/engine/src/bake/bake_task.rs +++ b/crates/engine/src/bake/bake_task.rs @@ -1,7 +1,8 @@ use super::MergedHigh; use crate::{EngineError, Result}; use std::sync::Arc; -use texturecraft_bake::{BakeOutput, BakePaintMap, BakeRequest, HighPoly, Progress, bake, bake_on, tracing::Tracer}; +use texturecraft_bake::{BakeOutput, BakePaintMap, BakeRequest, HighPoly, Progress, bake_tiles, tracing::Tracer}; +use texturecraft_compose::BakedMaps; use texturecraft_core::BakeSettings; use texturecraft_geom::{Bvh, Mesh}; @@ -20,6 +21,9 @@ pub struct BakeTask { pub cage_paint: Option>, /// UV tile grid (columns, rows) of the set; (1, 1) without UV tiles. pub tiles: (u32, u32), + /// Snapshot of tile selection and pixels to retain while the worker runs + pub excluded_tiles: Vec<(u32, u32)>, + pub previous_maps: BakedMaps, /// The GPU ray tracer, if installed and not turned off (`bake.run {cpu: true}`). pub tracer: Option>, } @@ -40,10 +44,9 @@ impl BakeTask { cage_paint: self.cage_paint.as_deref(), tiles: self.tiles, }; - match &self.tracer { - Some(tracer) => bake_on(&request, progress, tracer.as_ref()), - None => bake(&request, progress), - } - .map_err(|e| EngineError::Other(format!("bake failed: {e}"))) + let mut output = bake_tiles(&request, progress, &self.excluded_tiles, self.tracer.as_deref()) + .map_err(|error| EngineError::Other(format!("bake failed: {error}")))?; + super::preserve_tiles::restore(&mut output, &self.previous_maps, &self.excluded_tiles, self.tiles)?; + Ok(output) } } diff --git a/crates/engine/src/bake/layout.rs b/crates/engine/src/bake/layout.rs new file mode 100644 index 00000000..70e4b539 --- /dev/null +++ b/crates/engine/src/bake/layout.rs @@ -0,0 +1,46 @@ +use std::sync::Arc; + +use rayon::prelude::*; +use texturecraft_bake::BakePaintMap; +use texturecraft_core::TextureSet; +use texturecraft_geom::glam::Vec2; + +use crate::{EngineError, Result}; + +/// Correction paint stays in working coordinates; the worker reads a uniform bake atlas +pub(super) fn paint_for_bake(painted: &Arc, set: &TextureSet) -> Result> { + let Some(grid) = set.tile_grid().filter(|_| !set.tile_resolutions.is_empty()) else { + return Ok(painted.clone()); + }; + + painted.validate().map_err(|error| EngineError::Other(error.to_string()))?; + let (width, height) = (painted.width, painted.height); + let mut values = vec![0.0; painted.values.len()]; + values.par_chunks_mut(width as usize).enumerate().for_each(|(y, row)| { + for (x, value) in row.iter_mut().enumerate() { + let uv = grid.from_atlas([(x as f32 + 0.5) / width as f32, (y as f32 + 0.5) / height as f32]); + *value = painted.sample(Vec2::from_array(set.to_atlas(&grid, uv, uv))); + } + }); + Ok(Arc::new(BakePaintMap { width, height, values })) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn correction_paint_follows_the_same_surface_in_bake_coordinates() { + let mut set = TextureSet::new("Tiles", 0, 256); + set.uv_tiles = vec![1001, 1002]; + set.tile_resolutions.insert(1002, 128); + let mut paint = BakePaintMap::constant(0.0).resized(128, 64).unwrap(); + paint.paint(&[Vec2::new(0.625, 0.25)], 0.05, 1.0, 1.0, 1.0).unwrap(); + let paint = Arc::new(paint); + let baked = paint_for_bake(&paint, &set).unwrap(); + assert!(paint.sample(Vec2::new(0.625, 0.25)) > 0.99); + assert!(baked.sample(Vec2::new(0.75, 0.5)) > 0.99); + assert_eq!(baked.sample(Vec2::new(0.25, 0.5)), 0.0); + assert_eq!(paint.sample(Vec2::new(0.75, 0.5)), 0.0); + } +} diff --git a/crates/engine/src/bake_cmds.rs b/crates/engine/src/bake/mesh_map_command.rs similarity index 90% rename from crates/engine/src/bake_cmds.rs rename to crates/engine/src/bake/mesh_map_command.rs index d56a2bc0..e5982f18 100644 --- a/crates/engine/src/bake_cmds.rs +++ b/crates/engine/src/bake/mesh_map_command.rs @@ -2,6 +2,8 @@ //! high-definition mesh list, the cage, and running a bake. Bakes cast their rays on the GPU //! tracer the app installs ([`install_gpu_tracer`]) and on the CPU otherwise. +use super::model_patch; + use std::collections::BTreeMap; use std::sync::{Arc, OnceLock}; use texturecraft_core::BakePaintTarget; @@ -17,7 +19,7 @@ use texturecraft_core::{ use crate::commands::{CommandSpec, always, bad, boolp, f32p, strp, u64p}; use crate::{EngineError, Result, Session, cmd}; -pub fn specs() -> Vec { +pub(super) fn specs() -> Vec { vec![ cmd!( "bake.run", @@ -33,7 +35,7 @@ pub fn specs() -> Vec { "Bake settings", [], None, - "{ts?: index|[indices]|\"all\"|\"selected\" (default: the active set), model?: complete nested BakeSettings (named enum values), preserveEnabled?: keep each texture set enabled flag when replacing the model, resolution?, antialiasing?: 1|2|4|8, dilation?, ao?: {rays?, maxDistance?, spread?: degrees (180 = hemisphere), distribution?: cosine|uniform, ignoreBackface?: never|always|byMeshName, selfOcclusion?: always|sameMeshName}, thickness?: {rays?, maxDistance?, spread?, distribution?}, bentNormal?: {rays?, maxDistance?, spread?, distribution?}, rays?, maxDistance? (all three ray maps), curvatureMethod?: normalMap|mesh, positionMode?: boundingBox|boundingSphere|none, maps?: [ids], enabled?, useLowAsHigh?, maxFrontal?, maxRear?, averageNormals?, lowSuffix?, highSuffix?}", + "{ts?: index|[indices]|\"all\"|\"selected\" (default: the active set), model?: complete nested BakeSettings (named enum values), preserveEnabled?: keep each texture set enabled flag when replacing the model, patch?: nested BakeSettings fields to update after model (omitted fields stay unchanged, null clears optional fields), resolution?, antialiasing?: 1|2|4|8, dilation?, ao?: {rays?, maxDistance?, spread?: degrees (180 = hemisphere), distribution?: cosine|uniform, ignoreBackface?: never|always|byMeshName, selfOcclusion?: always|sameMeshName}, thickness?: {rays?, maxDistance?, spread?, distribution?}, bentNormal?: {rays?, maxDistance?, spread?, distribution?}, rays?, maxDistance? (all three ray maps), curvatureMethod?: normalMap|mesh, positionMode?: boundingBox|boundingSphere|none, maps?: [ids], enabled?, useLowAsHigh?, maxFrontal?, maxRear?, averageNormals?, lowSuffix?, highSuffix?}", always, settings ), @@ -90,6 +92,10 @@ fn parse_mesh(file_name: &str, bytes: Vec) -> Result { impl Session { pub fn bake_task(&self, ts: usize) -> Result { let set = self.doc.project.texture_set(ts)?; + if !set.has_enabled_bake_tiles() { + return Err(EngineError::Other(format!("texture set {} has no UV tiles selected for baking", set.name))); + } + let needs_low_color = set.bake.maps.opacity.is_enabled || (set.bake.maps.id.is_enabled && set.bake.maps.id.parameters.source == texturecraft_core::IdColorSource::MaterialColor); let low_base_color = if needs_low_color && (set.bake.high_poly.use_low_as_high || self.bake_meshes.high.is_empty()) { @@ -112,14 +118,25 @@ impl Session { } else { None }; - let skew = high.as_ref().and(self.doc.bake_paint.get(&(ts, BakePaintTarget::Skew)).cloned()); - let cage_paint = high.as_ref().and(self.doc.bake_paint.get(&(ts, BakePaintTarget::Cage)).cloned()); - let tiles = set.tile_grid().map_or((1, 1), |g| (g.cols, g.rows)); + let painted = |target| high.as_ref().and(self.doc.bake_paint.get(&(ts, target))).map(|map| super::layout::paint_for_bake(map, set)).transpose(); + let skew = painted(BakePaintTarget::Skew)?; + let cage_paint = painted(BakePaintTarget::Cage)?; + let grid = set.tile_grid(); + let tiles = grid.map_or((1, 1), |grid| (grid.cols, grid.rows)); + let excluded_tiles: Vec<_> = set.uv_tiles.iter().filter(|tile| set.bake_excluded_tiles.contains(tile)).filter_map(|tile| grid?.block(*tile)).collect(); + let previous_maps = if excluded_tiles.is_empty() { Default::default() } else { self.doc.baked.get(&ts).cloned().unwrap_or_default() }; let tracer = GPU_TRACER.get().cloned(); Ok(BakeTask { low_base_color, ts, - mesh: self.mesh.clone(), + mesh: match grid.filter(|_| !set.tile_resolutions.is_empty()) { + Some(grid) => { + let mut mesh = (*self.source).clone(); + mesh.map_material_uvs(set.material, |uv| texturecraft_geom::glam::Vec2::from_array(grid.to_atlas(uv.to_array()))); + Arc::new(mesh) + } + None => self.mesh.clone(), + }, bvh: self.bvh.clone(), material: set.material, settings: set.bake.clone(), @@ -128,6 +145,8 @@ impl Session { skew, cage_paint, tiles, + excluded_tiles, + previous_maps, tracer, }) } @@ -364,7 +383,7 @@ pub fn settings_params(settings: &BakeSettings) -> Value { /// Apply only the bake parameters supplied by the caller fn apply_settings(settings: &mut BakeSettings, params: &Value, command: &str) -> Result<()> { - // Keep the current command limits until the reference controls are integrated + // Preserve the legacy flat-parameter limits for existing callers const MAX_DILATION_PIXELS: u32 = 256; const MAX_SUFFIX_CHARS: usize = 64; @@ -378,6 +397,14 @@ fn apply_settings(settings: &mut BakeSettings, params: &Value, command: &str) -> } } + if let Some(patch) = params.get("patch") { + let mut model = json!(settings); + model_patch::apply_patch(&mut model, patch, command)?; + let updated: BakeSettings = serde_json::from_value(model).map_err(|error| bad(command, error.to_string()))?; + validate_model_settings(&updated, command)?; + *settings = updated; + } + if let Some(resolution) = u64p(params, "resolution") { settings.common.resolution = u32::try_from(resolution) .ok() @@ -604,8 +631,15 @@ fn settings(session: &mut Session, params: &Value) -> Result { } fn bake_run(session: &mut Session, params: &Value) -> Result { - let next = updated_settings(session, params, "bake.run")?; + let next: Vec<_> = updated_settings(session, params, "bake.run")? + .into_iter() + .filter(|(index, _)| session.doc.project.texture_sets.get(*index).is_some_and(|texture_set| texture_set.has_enabled_bake_tiles())) + .collect(); let sets: Vec = next.iter().map(|(index, _)| *index).collect(); + if sets.is_empty() { + return Ok(json!({"baked": [], "tracer": []})); + } + let cpu = boolp(params, "cpu") == Some(true); let tracers = session.edit("Bake mesh maps", |session| { let mut tracers = Vec::with_capacity(next.len()); diff --git a/crates/engine/src/bake/mod.rs b/crates/engine/src/bake/mod.rs index 075943b3..213e1ff6 100644 --- a/crates/engine/src/bake/mod.rs +++ b/crates/engine/src/bake/mod.rs @@ -1,11 +1,31 @@ +//! Baking tasks, commands, settings helpers, and the mesh-map baking API + mod bake_mesh; mod bake_meshes; mod bake_task; +mod layout; mod merged_high; +mod mesh_map_command; +mod model_patch; +mod paint_command; +mod preserve_tiles; +mod tile_command; pub use bake_mesh::BakeMesh; pub use bake_meshes::BakeMeshes; pub use bake_task::BakeTask; pub use merged_high::MergedHigh; +pub use mesh_map_command::{install_gpu_tracer, meshes_json, settings_params}; +pub use model_patch::settings_patch; +pub use texturecraft_bake::*; + +use crate::CommandSpec; type MaterialColors = std::sync::Arc>>>; + +pub(crate) fn specs() -> Vec { + let mut commands = mesh_map_command::specs(); + commands.extend(paint_command::specs()); + commands.extend(tile_command::specs()); + commands +} diff --git a/crates/engine/src/bake/model_patch.rs b/crates/engine/src/bake/model_patch.rs new file mode 100644 index 00000000..871d7dc8 --- /dev/null +++ b/crates/engine/src/bake/model_patch.rs @@ -0,0 +1,40 @@ +use serde_json::{Value, json}; +use texturecraft_core::BakeSettings; + +use crate::Result; +use crate::commands::bad; + +/// Only the changed fields, using the persisted model's names and enum values +pub fn settings_patch(before: &BakeSettings, after: &BakeSettings) -> Value { + changed_fields(&json!(before), &json!(after)).unwrap_or_else(|| json!({})) +} + +fn changed_fields(before: &Value, after: &Value) -> Option { + if before == after { + return None; + } + + if let (Some(before), Some(after)) = (before.as_object(), after.as_object()) { + let fields = after + .iter() + .filter_map(|(name, value)| changed_fields(before.get(name).unwrap_or(&Value::Null), value).map(|change| (name.clone(), change))) + .collect(); + Some(Value::Object(fields)) + } else { + Some(after.clone()) + } +} + +/// Merge known fields only; null is a value, so optional settings can be cleared +pub(super) fn apply_patch(model: &mut Value, patch: &Value, command: &str) -> Result<()> { + let fields = patch.as_object().ok_or_else(|| bad(command, "bake settings patch must be an object"))?; + for (name, value) in fields { + let target = model.get_mut(name).ok_or_else(|| bad(command, format!("unknown bake setting `{name}`")))?; + if target.is_object() { + apply_patch(target, value, command)?; + } else { + *target = value.clone(); + } + } + Ok(()) +} diff --git a/crates/engine/src/bake_paint_cmds.rs b/crates/engine/src/bake/paint_command.rs similarity index 97% rename from crates/engine/src/bake_paint_cmds.rs rename to crates/engine/src/bake/paint_command.rs index 80cf4852..1bbe2580 100644 --- a/crates/engine/src/bake_paint_cmds.rs +++ b/crates/engine/src/bake/paint_command.rs @@ -6,7 +6,7 @@ use texturecraft_bake::BakePaintMap; use texturecraft_core::BakePaintTarget; use texturecraft_geom::glam::Vec2; -pub fn specs() -> Vec { +pub(super) fn specs() -> Vec { vec![ cmd!("bake.skew.set", "Set Skew Correction", [], None, "{ts?, value?: 0..1 | path: grayscale image}", always, |session, parameters| set( session, @@ -65,7 +65,7 @@ fn set(session: &mut Session, parameters: &Value, target: BakePaintTarget) -> Re session.doc.bake_paint.insert((texture_set, target), Arc::new(map)); Ok(()) })?; - Ok(crate::bake_cmds::meshes_json(session)) + Ok(super::meshes_json(session)) } fn clear(session: &mut Session, parameters: &Value, target: BakePaintTarget) -> Result { @@ -76,7 +76,7 @@ fn clear(session: &mut Session, parameters: &Value, target: BakePaintTarget) -> Ok(()) })?; } - Ok(crate::bake_cmds::meshes_json(session)) + Ok(super::meshes_json(session)) } fn paint(session: &mut Session, parameters: &Value, target: BakePaintTarget) -> Result { @@ -123,7 +123,7 @@ fn paint(session: &mut Session, parameters: &Value, target: BakePaintTarget) -> } Arc::make_mut(map).paint(&points, radius, value, hardness, strength).map_err(|error| bad("bake.paint", error.to_string())) })?; - Ok(crate::bake_cmds::meshes_json(session)) + Ok(super::meshes_json(session)) } #[cfg(not(target_arch = "wasm32"))] diff --git a/crates/engine/src/bake/preserve_tiles.rs b/crates/engine/src/bake/preserve_tiles.rs new file mode 100644 index 00000000..27c74ae8 --- /dev/null +++ b/crates/engine/src/bake/preserve_tiles.rs @@ -0,0 +1,54 @@ +use texturecraft_bake::BakeOutput; +use texturecraft_compose::BakedMaps; + +use crate::{EngineError, Result}; + +/// Retain excluded tiles from the worker's snapshot, resampling when output size changes +pub(super) fn restore(output: &mut BakeOutput, previous: &BakedMaps, excluded_tiles: &[(u32, u32)], grid: (u32, u32)) -> Result<()> { + if excluded_tiles.is_empty() { + return Ok(()); + } + + let size = (output.resolution, output.height); + let tile_width = size.0 / grid.0.max(1); + let tile_height = size.1 / grid.1.max(1); + for (map, pixels) in &mut output.maps { + let components = map.components(); + for &(column, row) in excluded_tiles { + for y in row * tile_height..(row + 1) * tile_height { + let first = (y as usize * size.0 as usize + column as usize * tile_width as usize) * components; + let last = first + tile_width as usize * components; + let row_pixels = pixels.get_mut(first..last).ok_or_else(|| EngineError::Other("excluded UV tile lies outside the baked pixels".into()))?; + for (offset, pixel) in row_pixels.chunks_exact_mut(components).enumerate() { + let value = previous.sample(*map, column * tile_width + offset as u32, y, size).unwrap_or_else(|| map.neutral()); + for (component, value) in pixel.iter_mut().zip(value) { + *component = value; + } + } + } + } + } + + // Keep unchecked map outputs too when a partial bake changes the atlas dimensions + for map in previous.maps.keys() { + if output.maps.contains_key(map) || (previous.resolution == size.0 && previous.height(*map) == size.1) { + continue; + } + + let components = map.components(); + let count = (size.0 as usize) + .checked_mul(size.1 as usize) + .and_then(|count| count.checked_mul(components)) + .ok_or_else(|| EngineError::Other("resized bake map exceeds the addressable size".into()))?; + let mut pixels = Vec::new(); + pixels.try_reserve_exact(count).map_err(|error| EngineError::Other(format!("cannot retain mesh map {}: {error}", map.id())))?; + for y in 0..size.1 { + for x in 0..size.0 { + let value = previous.sample(*map, x, y, size).unwrap_or_else(|| map.neutral()); + pixels.extend(value.into_iter().take(components)); + } + } + output.maps.insert(*map, pixels); + } + Ok(()) +} diff --git a/crates/engine/src/bake/tile_command.rs b/crates/engine/src/bake/tile_command.rs new file mode 100644 index 00000000..766a4b84 --- /dev/null +++ b/crates/engine/src/bake/tile_command.rs @@ -0,0 +1,42 @@ +use serde_json::{Value, json}; + +use crate::commands::{CommandSpec, always, bad, boolp, u64p}; +use crate::set_cmds::ts_param; +use crate::{Result, Session, cmd}; + +pub(super) fn specs() -> Vec { + vec![cmd!( + "bake.tile.set", + "Include UV tile in bake", + [], + None, + "{ts?, tile: UDIM number, enabled: bool} → {ts, tile, enabled}; excluded tiles keep existing baked pixels", + always, + set_enabled + )] +} + +fn set_enabled(session: &mut Session, params: &Value) -> Result { + const COMMAND: &str = "bake.tile.set"; + let texture_set = ts_param(session, params, COMMAND)?; + let tile = u64p(params, "tile").and_then(|tile| u32::try_from(tile).ok()).ok_or_else(|| bad(COMMAND, "`tile` must be a UDIM number"))?; + let enabled = boolp(params, "enabled").ok_or_else(|| bad(COMMAND, "`enabled` must be true or false"))?; + let settings = session.doc.project.texture_set(texture_set)?; + if !settings.uv_tiles.contains(&tile) { + return Err(bad(COMMAND, format!("texture set {} has no UV tile {tile}", settings.name))); + } + + let was_enabled = !settings.bake_excluded_tiles.contains(&tile); + if enabled != was_enabled { + session.edit("Include UV tile in bake", |session| { + let settings = session.doc.project.texture_set_mut(texture_set)?; + if enabled { + settings.bake_excluded_tiles.remove(&tile); + } else { + settings.bake_excluded_tiles.insert(tile); + } + Ok(()) + })?; + } + Ok(json!({"ts": texture_set, "tile": tile, "enabled": enabled})) +} diff --git a/crates/engine/src/commands.rs b/crates/engine/src/commands.rs index 94bb350c..9f0d126b 100644 --- a/crates/engine/src/commands.rs +++ b/crates/engine/src/commands.rs @@ -68,8 +68,7 @@ pub fn command_specs() -> &'static [CommandSpec] { v.extend(crate::uv_tile_cmds::specs()); v.extend(crate::template_cmds::specs()); v.extend(crate::project_cmds::specs()); - v.extend(crate::bake_cmds::specs()); - v.extend(crate::bake_paint_cmds::specs()); + v.extend(crate::bake::specs()); v.extend(crate::materialx_cmds::specs()); v.extend(crate::file_cmds::specs()); v.extend(crate::preset_cmds::specs()); diff --git a/crates/engine/src/inspect.rs b/crates/engine/src/inspect.rs index 228d37e1..347b7390 100644 --- a/crates/engine/src/inspect.rs +++ b/crates/engine/src/inspect.rs @@ -129,26 +129,34 @@ pub fn texture_sets(s: &Session) -> Value { json!((0..s.set_count()).map(|i| texture_set(s, i)).collect::>()) } -/// One texture set; UV-tiled sets list their tiles and where each sits in the texel atlas. -pub fn texture_set(s: &Session, i: usize) -> Value { - let Some(t) = s.doc.project.texture_sets.get(i) else { return Value::Null }; - let grid = t.tile_grid(); - let tiles: Vec = - t.uv_tiles.iter().filter_map(|u| grid?.block(*u).map(|(x, y)| json!({ "udim": u, "block": [x, y], "resolution": t.tile_resolution(*u) }))).collect(); +/// One texture set, including UV tile layout and bake selection +pub fn texture_set(session: &Session, index: usize) -> Value { + let Some(texture_set) = session.doc.project.texture_sets.get(index) else { return Value::Null }; + + let grid = texture_set.tile_grid(); + let tiles: Vec = texture_set + .uv_tiles + .iter() + .filter_map(|tile| { + grid?.block(*tile).map(|(x, y)| { + json!({"udim": tile, "block": [x, y], "resolution": texture_set.tile_resolution(*tile), "bakeEnabled": !texture_set.bake_excluded_tiles.contains(tile)}) + }) + }) + .collect(); json!({ - "index": i, - "name": t.name, - "resolution": t.resolution, - "size": t.size(), - "blockResolution": t.block_resolution(), - "uvTiles": t.uv_tiles, + "index": index, + "name": texture_set.name, + "resolution": texture_set.resolution, + "size": texture_set.size(), + "blockResolution": texture_set.block_resolution(), + "uvTiles": texture_set.uv_tiles, "tiles": tiles, - "channels": t.channels.iter().map(|(c, f)| json!({ "channel": c.id(), "format": f.label() })).collect::>(), - "layers": s.doc.project.walk(i).len(), - "parts": crate::set_cmds::parts(s, i), - "baked": crate::project_cmds::baked_json(s.doc.baked.get(&i)), - "visible": t.visible, - "active": i == s.ts(), + "channels": texture_set.channels.iter().map(|(channel, format)| json!({ "channel": channel.id(), "format": format.label() })).collect::>(), + "layers": session.doc.project.walk(index).len(), + "parts": crate::set_cmds::parts(session, index), + "baked": crate::project_cmds::baked_json(session.doc.baked.get(&index)), + "visible": texture_set.visible, + "active": index == session.ts(), }) } @@ -161,7 +169,7 @@ pub fn session(s: &Session) -> Value { "path": s.path, "modified": s.modified, "textureSets": texture_sets(s), - "bakeMeshes": crate::bake_cmds::meshes_json(s), + "bakeMeshes": crate::bake::meshes_json(s), "activeTextureSet": ts, "selectedLayer": s.selected_layer().map(|l| l.0), "target": match s.target { StackTarget::Content => json!("content"), StackTarget::Mask => json!("mask"), StackTarget::Effect(e) => json!(e.0) }, diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index 201d0eb1..2f5887a6 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -8,10 +8,7 @@ #![forbid(unsafe_code)] #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] -pub mod bake_cmds; -#[path = "bake/mod.rs"] -mod bake_data; -mod bake_paint_cmds; +pub mod bake; pub mod brush_preset_cmds; pub mod camera_cmds; pub mod commands; @@ -51,14 +48,13 @@ pub mod tool_cmds; pub mod uv_tile_cmds; pub mod view_cmds; -pub use bake_data::{BakeMesh, BakeMeshes, BakeTask}; +pub use bake::{BakeMesh, BakeMeshes, BakeTask}; pub use commands::{CommandSpec, command_specs, execute, find}; pub use path_tool::PathState; pub use project_cmds::sample_session; pub use session::{CloneFrom, CloneSource, Document, FillMode, Session, SetCache, StackTarget, StencilState, Tool, ToolState, ViewMode}; pub use set_cmds::{ResizeOutput, ResizeTask}; -pub use texturecraft_bake as bake; pub use texturecraft_compose as compose; pub use texturecraft_core as core; pub use texturecraft_formats as formats; diff --git a/crates/engine/src/meshmap_cmds.rs b/crates/engine/src/meshmap_cmds.rs index 2220df34..0fbe1f5b 100644 --- a/crates/engine/src/meshmap_cmds.rs +++ b/crates/engine/src/meshmap_cmds.rs @@ -59,7 +59,7 @@ fn set(s: &mut Session, p: &Value) -> Result { None => resample(map.components(), (res, height), directx, |u, v| img.sample(u, v)), // An atlas texel reads the image of the tile its mesh UV falls in. Some((grid, imgs)) => resample(map.components(), (res, height), directx, |u, v| { - let uv = set.from_atlas(grid, [u, v]); + let uv = grid.from_atlas([u, v]); udim_at(uv).and_then(|t| imgs.get(&t)).map_or([0.0; 4], |img| img.sample(uv[0] - uv[0].floor(), uv[1] - uv[1].floor())) }), }; diff --git a/crates/engine/src/preview.rs b/crates/engine/src/preview.rs index 8882b6d8..5b72cea4 100644 --- a/crates/engine/src/preview.rs +++ b/crates/engine/src/preview.rs @@ -172,6 +172,7 @@ pub fn filter(id: &str, size: usize) -> Option>> { gbuf: &gbuf, pixels: &pixels, baked: &baked, + block_scales: p.texture_set(0).map(|set| set.block_scales()).unwrap_or_default(), preview: None, images: &images, bounds: mesh.bounds(), diff --git a/crates/engine/src/session.rs b/crates/engine/src/session.rs index aeaa5550..36263560 100644 --- a/crates/engine/src/session.rs +++ b/crates/engine/src/session.rs @@ -728,6 +728,7 @@ impl Session { gbuf: &cache.gbuf, pixels: &self.doc.pixels, baked: self.doc.baked.get(&ts).unwrap_or(&empty), + block_scales: cache.composite.block_scales.clone(), preview, images: &self.images, bounds: self.mesh.bounds(), @@ -816,6 +817,7 @@ impl Session { gbuf: &cache.gbuf, pixels: &self.doc.pixels, baked: self.doc.baked.get(&ts).unwrap_or(&empty), + block_scales: cache.composite.block_scales.clone(), preview: None, images: &self.images, bounds: self.mesh.bounds(), diff --git a/crates/engine/src/uv_tile_cmds.rs b/crates/engine/src/uv_tile_cmds.rs index d4659943..cd8c3a76 100644 --- a/crates/engine/src/uv_tile_cmds.rs +++ b/crates/engine/src/uv_tile_cmds.rs @@ -39,61 +39,69 @@ pub fn specs() -> Vec { ] } -fn tile_resolution(s: &mut Session, p: &Value) -> Result { - const CMD: &str = "textureSet.tile.resolution"; - let ts = ts_param(s, p, CMD)?; - let tile = u64p(p, "tile").and_then(|t| u32::try_from(t).ok()).ok_or_else(|| bad(CMD, "`tile` (a UDIM number) is required"))?; - let r = u64p(p, "resolution").ok_or_else(|| bad(CMD, "`resolution` is required"))?; - let r = check_resolution(u32::try_from(r).unwrap_or(0))?; - let set = s.doc.project.texture_set(ts)?; - if !set.uv_tiles.contains(&tile) { - return Err(bad(CMD, format!("texture set \"{}\" has no UV tile {tile} (tiles: {:?})", set.name, set.uv_tiles))); +fn tile_resolution(session: &mut Session, params: &Value) -> Result { + const COMMAND: &str = "textureSet.tile.resolution"; + let texture_set_index = ts_param(session, params, COMMAND)?; + let tile = u64p(params, "tile").and_then(|tile| u32::try_from(tile).ok()).ok_or_else(|| bad(COMMAND, "`tile` (a UDIM number) is required"))?; + let resolution = u64p(params, "resolution").ok_or_else(|| bad(COMMAND, "`resolution` is required"))?; + let resolution = check_resolution(u32::try_from(resolution).unwrap_or(0))?; + let texture_set = session.doc.project.texture_set(texture_set_index)?; + if !texture_set.uv_tiles.contains(&tile) { + return Err(bad(COMMAND, format!("texture set \"{}\" has no UV tile {tile} (tiles: {:?})", texture_set.name, texture_set.uv_tiles))); } - if set.tile_resolution(tile) == r { - return Ok(json!({ "ts": ts, "tile": tile, "resolution": r, "size": set.size() })); + + let removes_override = resolution == texture_set.resolution && texture_set.tile_resolutions.contains_key(&tile); + if texture_set.tile_resolution(tile) == resolution && !removes_override { + return Ok(json!({ "ts": texture_set_index, "tile": tile, "resolution": resolution, "size": texture_set.size() })); } - s.cancel_stroke(); - let size = s.edit("UV tile resolution", |s| { - let set = s.doc.project.texture_set_mut(ts)?; - let old = set.clone(); - if r == set.resolution { - set.tile_resolutions.remove(&tile); + + session.cancel_stroke(); + let size = session.edit("UV tile resolution", |session| { + let texture_set = session.doc.project.texture_set_mut(texture_set_index)?; + let previous = texture_set.clone(); + if resolution == texture_set.resolution { + texture_set.tile_resolutions.remove(&tile); } else { - set.tile_resolutions.insert(tile, r); + texture_set.tile_resolutions.insert(tile, resolution); + } + check_size(texture_set)?; + let size = texture_set.size(); + if previous.tile_resolution(tile) != resolution { + relayout(&mut session.doc, texture_set_index, &previous, &mut session.log)?; } - check_size(set)?; - let size = set.size(); - relayout(&mut s.doc, ts, &old, &mut s.log)?; Ok(size) })?; - Ok(json!({ "ts": ts, "tile": tile, "resolution": r, "size": size })) + Ok(json!({ "ts": texture_set_index, "tile": tile, "resolution": resolution, "size": size })) } -fn uv_tiles(s: &mut Session, p: &Value) -> Result { - const CMD: &str = "textureSet.uvTiles"; - let ts = ts_param(s, p, CMD)?; - let enabled = boolp(p, "enabled").ok_or_else(|| bad(CMD, "`enabled` (true or false) is required"))?; - let set = s.doc.project.texture_set(ts)?; +fn uv_tiles(session: &mut Session, params: &Value) -> Result { + const COMMAND: &str = "textureSet.uvTiles"; + let texture_set_index = ts_param(session, params, COMMAND)?; + let enabled = boolp(params, "enabled").ok_or_else(|| bad(COMMAND, "`enabled` (true or false) is required"))?; + let texture_set = session.doc.project.texture_set(texture_set_index)?; let tiles = if enabled { - detect_uv_tiles(&s.source, set.material, Some(true), &mut Vec::new()).map_err(|e| bad(CMD, format!("texture set \"{}\": {e}", set.name)))? + detect_uv_tiles(&session.source, texture_set.material, Some(true), &mut Vec::new()) + .map_err(|error| bad(COMMAND, format!("texture set \"{}\": {error}", texture_set.name)))? } else { Vec::new() }; - if tiles == set.uv_tiles { - return Ok(json!({ "ts": ts, "uvTiles": tiles, "dropped": [] })); + if tiles == texture_set.uv_tiles { + return Ok(json!({ "ts": texture_set_index, "uvTiles": tiles, "dropped": [] })); } - // Leaving UV tile mode keeps tile 1001 (UV 0..1), the area a classic set paints. - let dropped: Vec = set.uv_tiles.iter().copied().filter(|t| !enabled && *t != 1001).collect(); - s.cancel_stroke(); - s.edit(if enabled { "Use UV tiles" } else { "Stop using UV tiles" }, |s| { - let set = s.doc.project.texture_set_mut(ts)?; - let old = set.clone(); - set.tile_resolutions.retain(|u, _| tiles.contains(u)); - set.uv_tiles = tiles.clone(); - check_size(set)?; - relayout(&mut s.doc, ts, &old, &mut s.log) + + // Leaving UV tile mode keeps tile 1001, the area a classic set paints + let dropped: Vec = texture_set.uv_tiles.iter().copied().filter(|tile| !enabled && *tile != 1001).collect(); + session.cancel_stroke(); + session.edit(if enabled { "Use UV tiles" } else { "Stop using UV tiles" }, |session| { + let texture_set = session.doc.project.texture_set_mut(texture_set_index)?; + let previous = texture_set.clone(); + texture_set.tile_resolutions.retain(|tile, _| tiles.contains(tile)); + texture_set.bake_excluded_tiles.retain(|tile| tiles.contains(tile)); + texture_set.uv_tiles = tiles.clone(); + check_size(texture_set)?; + relayout(&mut session.doc, texture_set_index, &previous, &mut session.log) })?; - Ok(json!({ "ts": ts, "uvTiles": tiles, "dropped": dropped })) + Ok(json!({ "ts": texture_set_index, "uvTiles": tiles, "dropped": dropped })) } /// Mesh UV → normalized atlas position of UV tile layout `set` (None where the layout holds @@ -119,23 +127,30 @@ fn from_layout(set: &TextureSet, a: [f32; 2]) -> Option<[f32; 2]> { (set.uv_tiles.contains(&udim) && local.0 <= scale && local.1 <= scale).then(|| set.from_atlas(&g, a)) } -/// Resample texture set `ts`'s painted images and baked maps from layout `old` into the set's -/// current layout (inside [`Session::edit`] after changing the set). Notes go to `log`. +/// Move painted images into the working layout and baked maps only when the tile grid changes pub(crate) fn relayout(doc: &mut Document, ts: usize, old: &TextureSet, log: &mut Vec) -> Result<()> { let new = doc.project.texture_set(ts)?.clone(); - let map = |a: [f32; 2]| from_layout(&new, a).and_then(|m| to_layout(old, m)); - let ((ow, oh), (nw, nh)) = (old.size(), new.size()); - let texel = |x: f32, y: f32| map([x / nw as f32, y / nh as f32]).map(|o| (o[0] * ow as f32, o[1] * oh as f32)); - let all = TileImage::new(nw, nh, 1); + let map = |uv: [f32; 2]| from_layout(&new, uv).and_then(|mesh_uv| to_layout(old, mesh_uv)); + let (old_size, new_size) = (old.size(), new.size()); + let texel = |x: f32, y: f32| map([x / new_size.0 as f32, y / new_size.1 as f32]).map(|uv| (uv[0] * old_size.0 as f32, uv[1] * old_size.1 as f32)); + let all = TileImage::new(new_size.0, new_size.1, 1); let tiles: Vec<(u32, u32)> = (0..all.tiles_y()).flat_map(|ty| (0..all.tiles_x()).map(move |tx| (tx, ty))).collect(); - // Blocks and tiles are multiples of 64 texels (resolutions are powers of two ≥ 128), so the - // map is affine (or None) over each destination tile. - crate::layer_ops::map_set_images(doc, ts, |img, empty| remap_image(img, (nw, nh), empty, &texel, &tiles, true)); + + // Atlas blocks align with the 64-texel storage tiles, making each mapping affine + crate::layer_ops::map_set_images(doc, ts, |image, empty| remap_image(image, new_size, empty, &texel, &tiles, true)); remap_bake_paint(doc, ts, old, &new, &map)?; - if let Some(baked) = doc.baked.get(&ts) { - match remap_baked(baked, old, &new, &map) { - Some(b) => { - doc.baked.insert(ts, b); + + if old.uv_tiles != new.uv_tiles + && let Some(baked) = doc.baked.get(&ts) + { + let mut old_bake = old.clone(); + let mut new_bake = new.clone(); + old_bake.tile_resolutions.clear(); + new_bake.tile_resolutions.clear(); + let bake_map = |uv| from_layout(&new_bake, uv).and_then(|mesh_uv| to_layout(&old_bake, mesh_uv)); + match remap_baked(baked, &old_bake, &new_bake, &bake_map) { + Some(baked) => { + doc.baked.insert(ts, baked); } None => { doc.baked.remove(&ts); @@ -326,6 +341,28 @@ mod tests { assert!(execute(&mut s, "textureSet.tile.resolution", &json!({"tile": 1001, "resolution": 100})).is_err()); } + #[test] + fn removing_a_tile_override_at_the_sets_current_resolution_restores_inheritance() { + let mut session = udim_session(); + execute(&mut session, "textureSet.tile.resolution", &json!({"tile": 1002, "resolution": 128})).unwrap(); + execute(&mut session, "textureSet.resolution", &json!({"resolution": 128})).unwrap(); + let before = session.doc.project.clone(); + let history_steps = session.history_labels().len(); + + execute(&mut session, "textureSet.tile.resolution", &json!({"tile": 1002, "resolution": 128})).unwrap(); + + assert!(session.doc.project.texture_sets[0].tile_resolutions.is_empty()); + assert_eq!(session.history_labels().len(), history_steps + 1); + let reopened = Session::from_project_bytes(&session.to_project_bytes().unwrap()).unwrap(); + assert!(reopened.doc.project.texture_sets[0].tile_resolutions.is_empty()); + session.undo().unwrap(); + assert_eq!(session.doc.project, before); + session.redo().unwrap(); + execute(&mut session, "textureSet.resolution", &json!({"resolution": 256})).unwrap(); + assert_eq!(session.doc.project.texture_sets[0].tile_resolution(1002), 256); + assert_eq!(session.doc.project.texture_sets[0].bake, before.texture_sets[0].bake); + } + #[test] fn export_writes_each_tile_at_its_own_size() { let mut s = udim_session(); diff --git a/crates/engine/tests/bake_resolution.rs b/crates/engine/tests/bake_resolution.rs new file mode 100644 index 00000000..620de675 --- /dev/null +++ b/crates/engine/tests/bake_resolution.rs @@ -0,0 +1,130 @@ +use std::sync::Arc; + +use serde_json::json; +use texturecraft_engine::bake::Progress; +use texturecraft_engine::core::BakedMap; +use texturecraft_engine::geom::{NO_TRI, UvGBuffer, primitives}; +use texturecraft_engine::{Session, execute}; + +fn session() -> Session { + let mut session = Session::new_project("Bake detail", primitives::udim_plane(), "builtin:udim_plane", None, 256).unwrap(); + execute(&mut session, "bake.settings", &json!({"resolution": 128, "maps": ["position"], "dilation": 0, "patch": {"common": {"apply_diffusion": false}}})) + .unwrap(); + session +} + +#[test] +fn working_tile_resolution_preserves_bake_samples_and_pixels() { + let mut session = session(); + let original = session.bake_task(0).unwrap().run(&Progress::new()).unwrap(); + execute(&mut session, "textureSet.tile.resolution", &json!({"tile": 1002, "resolution": 128})).unwrap(); + let task = session.bake_task(0).unwrap(); + let output = task.run(&Progress::new()).unwrap(); + assert_eq!((output.resolution, output.height), (256, 128)); + + let gbuffer = UvGBuffer::new(&task.mesh, task.material, output.resolution, output.height); + let mut samples = [0usize; 2]; + for (index, triangle) in gbuffer.tri.iter().enumerate() { + if *triangle != NO_TRI { + samples[(index % 256) / 128] += 1; + } + } + assert_eq!(samples, [128 * 128; 2], "each tile receives the full Bake Output Size"); + assert_eq!(output.maps, original.maps); +} + +#[test] +fn changing_working_resolution_never_resamples_stored_bakes() { + let mut session = session(); + let output = session.bake_task(0).unwrap().run(&Progress::new()).unwrap(); + session.apply_bake(0, output).unwrap(); + let original = session.doc.baked[&0].clone(); + for resolution in [128, 512, 256] { + execute(&mut session, "textureSet.tile.resolution", &json!({"tile": 1002, "resolution": resolution})).unwrap(); + let current = &session.doc.baked[&0]; + assert!(Arc::ptr_eq(¤t.maps[&BakedMap::Position], &original.maps[&BakedMap::Position]), "working resize must retain the bake buffer"); + assert_eq!(current, &original); + let reopened = Session::from_project_bytes(&session.to_project_bytes().unwrap()).unwrap(); + assert_eq!(reopened.doc.baked[&0], original); + } + session.undo().unwrap(); + assert_eq!(session.doc.baked[&0], original); + session.redo().unwrap(); + assert_eq!(session.doc.baked[&0], original); + + for resolution in [512, 128] { + execute(&mut session, "textureSet.resolution", &json!({"resolution": resolution})).unwrap(); + assert!(Arc::ptr_eq(&session.doc.baked[&0].maps[&BakedMap::Position], &original.maps[&BakedMap::Position])); + } +} + +#[test] +fn rectangular_bakes_and_excluded_vertical_tiles_ignore_working_resolution() { + let mut mesh = primitives::udim_plane(); + let second_plane = mesh.uvs.len() / 2; + for uv in mesh.uvs.iter_mut().skip(second_plane) { + uv.x -= 1.0; + uv.y -= 1.0; + } + let mut session = Session::new_project("Vertical bake", mesh, "builtin:udim_plane", None, 256).unwrap(); + execute( + &mut session, + "bake.settings", + &json!({"resolution": 64, "maps": ["position"], "dilation": 0, "patch": {"common": {"resolution_height": "R128", "apply_diffusion": false}}}), + ) + .unwrap(); + let original = session.bake_task(0).unwrap().run(&Progress::new()).unwrap(); + assert_eq!((original.resolution, original.height), (64, 256)); + let pixels = original.maps.clone(); + session.apply_bake(0, original).unwrap(); + execute(&mut session, "textureSet.tile.resolution", &json!({"tile": 1011, "resolution": 128})).unwrap(); + execute(&mut session, "bake.tile.set", &json!({"tile": 1011, "enabled": false})).unwrap(); + let output = session.bake_task(0).unwrap().run(&Progress::new()).unwrap(); + assert_eq!(output.maps, pixels, "rebaked and excluded tiles both keep their full rectangular detail"); +} + +#[test] +fn imported_mesh_maps_display_and_export_the_entire_overridden_tile() { + use texturecraft_engine::compose::{DisplayKind, tile_bytes}; + use texturecraft_engine::formats::export::{Dest, ExportOptions, ExportPreset, FileFormat, MapSpec, SourceRef}; + + let mut session = session(); + execute(&mut session, "textureSet.tile.resolution", &json!({"tile": 1002, "resolution": 128})).unwrap(); + let image = image::GrayImage::from_fn(128, 128, |x, y| image::Luma([(x + y) as u8])); + let mut bytes = Vec::new(); + image.write_to(&mut std::io::Cursor::new(&mut bytes), image::ImageFormat::Png).unwrap(); + for tile in [1001, 1002] { + session.import_resource_bytes(&format!("ao.{tile}.png"), bytes.clone()).unwrap(); + } + execute(&mut session, "textureSet.meshMap.set", &json!({"map": "ambientOcclusion", "image": "ao.1001.png"})).unwrap(); + while session.update() {} + + let baked = &session.doc.baked[&0]; + let map = BakedMap::AmbientOcclusion; + assert!((baked.scalar(map, 248, 120, (256, 128)).unwrap() - 240.0 / 255.0).abs() < 0.001); + let composite = &session.caches[0].composite; + let display = tile_bytes(composite, baked, DisplayKind::Orm, 5, 1); + assert_eq!(display[((56 * 64 + 56) * 4) as usize], 240, "the viewport samples the far corner of the smaller working tile"); + + let options = ExportOptions::new(ExportPreset { + name: "Bake detail".into(), + maps: vec![MapSpec { + file: "ao.$udim".into(), + format: FileFormat::Png, + bit_depth: 8, + channels: vec![(Dest::L, SourceRef::Baked { map, component: 0 })], + }], + }); + let files = session.export_files(&[0], &options).unwrap(); + let file = files.iter().find(|file| file.name == "ao.1002.png").unwrap(); + let exported = image::load_from_memory(&file.bytes).unwrap().to_luma8(); + assert_eq!(exported.dimensions(), (128, 128)); + assert_eq!(exported.get_pixel(120, 120)[0], 240); + assert_eq!(exported.get_pixel(10, 10)[0], 20); + + let layer = session.doc.project.texture_sets[0].stack[0]; + execute(&mut session, "mask.add.black", &json!({"layer": layer.0})).unwrap(); + execute(&mut session, "effect.add.generator", &json!({"layer": layer.0, "generator": "ambientOcclusion"})).unwrap(); + let mask = session.mask_at(layer, &[(376, 120), (266, 10)]).unwrap(); + assert_eq!(mask, vec![1.0, 0.0], "generators sample the whole bake through the working layout"); +} diff --git a/crates/engine/tests/bake_settings.rs b/crates/engine/tests/bake_settings.rs new file mode 100644 index 00000000..b22c53d9 --- /dev/null +++ b/crates/engine/tests/bake_settings.rs @@ -0,0 +1,112 @@ +use serde_json::json; +use texturecraft_engine::core::{BakeResolution, BakeSettings}; +use texturecraft_engine::geom::primitives; +use texturecraft_engine::{Session, execute}; + +fn session() -> Session { + let mut session = Session::new_project("Bake settings", primitives::material_ball(), "builtin:material_ball", None, 128).unwrap(); + let second = &mut session.doc.project.texture_sets[1].bake; + second.common.is_enabled = false; + second.common.resolution = BakeResolution::R128; + second.common.resolution_height = Some(BakeResolution::R256); + second.maps.ao.is_enabled = false; + second.maps.ao.parameters.rays.min_distance = 0.25; + second.maps.ao.parameters.rays.rays = 16; + second.maps.height.parameters.scaling_divisor = 2.0; + session +} + +#[test] +fn nested_settings_patch_preserves_other_fields_and_is_one_undo_step() { + let mut session = session(); + let before = session.doc.project.clone(); + let history_steps = session.history_labels().len(); + let patch = json!({"maps": {"ao": {"parameters": {"rays": {"rays": 128}}}}}); + + let result = execute(&mut session, "bake.settings", &json!({"ts": "all", "patch": patch})).unwrap(); + + let mut expected = before.clone(); + for texture_set in &mut expected.texture_sets { + texture_set.bake.maps.ao.parameters.rays.rays = 128; + } + assert_eq!(session.doc.project, expected); + assert_eq!(result.as_array().unwrap().len(), 2); + assert_eq!(result[1]["model"], json!(expected.texture_sets[1].bake)); + assert_eq!(session.history_labels().len(), history_steps + 1); + let reopened = Session::from_project_bytes(&session.to_project_bytes().unwrap()).unwrap(); + assert_eq!(reopened.doc.project.texture_sets, expected.texture_sets); + + session.undo().unwrap(); + assert_eq!(session.doc.project, before); + session.redo().unwrap(); + assert_eq!(session.doc.project, expected); +} + +#[test] +fn settings_patch_validates_every_target_before_changing_any() { + let mut session = session(); + let before = session.doc.project.clone(); + let history = session.history_labels(); + + // This maximum is valid for the active set but below the second set's minimum + let patch = json!({"maps": {"ao": {"parameters": {"rays": {"max_distance": 0.1}}}}}); + let error = execute(&mut session, "bake.settings", &json!({"ts": "all", "patch": patch})).unwrap_err(); + assert!(error.to_string().contains("minimum occluder distance"), "{error}"); + assert_eq!(session.doc.project, before); + assert_eq!(session.history_labels(), history); +} + +#[test] +fn settings_patch_rejects_unknown_fields_and_invalid_shapes() { + let mut session = session(); + let before = session.doc.project.clone(); + let history = session.history_labels(); + + for patch in [ + json!(null), + json!([]), + json!({"unknown": 1}), + json!({"common": null}), + json!({"common": {"resolution": "invalid"}}), + json!({"common": {"antialiasing": true}}), + json!({"maps": {"ao": {"parameters": {"rays": {"rays": 257}}}}}), + json!({"maps": {"ao": {"parameters": {"rays": {"rayz": 128}}}}}), + ] { + assert!(execute(&mut session, "bake.settings", &json!({"ts": "all", "patch": patch})).is_err(), "{patch}"); + assert_eq!(session.doc.project, before); + assert_eq!(session.history_labels(), history); + } +} + +#[test] +fn settings_patch_can_clear_optional_height_and_keeps_target_selection() { + let mut session = session(); + let first = session.doc.project.texture_sets[0].bake.clone(); + let mut second = session.doc.project.texture_sets[1].bake.clone(); + let patch = json!({"common": {"resolution_height": null}}); + + execute(&mut session, "bake.settings", &json!({"ts": [1], "patch": patch})).unwrap(); + + second.common.resolution_height = None; + assert_eq!(session.doc.project.texture_sets[0].bake, first); + assert_eq!(session.doc.project.texture_sets[1].bake, second); + + let history_steps = session.history_labels().len(); + execute(&mut session, "bake.settings", &json!({"ts": "all", "patch": {}})).unwrap(); + execute(&mut session, "bake.settings", &json!({"ts": 1, "patch": patch})).unwrap(); + assert_eq!(session.history_labels().len(), history_steps); +} + +#[test] +fn settings_patch_can_reset_one_section_without_replacing_other_settings() { + let mut session = session(); + let mut expected = session.doc.project.clone(); + let defaults = BakeSettings::default().maps.ao.parameters; + for texture_set in &mut expected.texture_sets { + texture_set.bake.maps.ao.parameters = defaults; + } + + execute(&mut session, "bake.settings", &json!({"ts": "all", "patch": {"maps": {"ao": {"parameters": defaults}}}})).unwrap(); + + assert_eq!(session.doc.project, expected); +} diff --git a/crates/engine/tests/bake_tiles.rs b/crates/engine/tests/bake_tiles.rs new file mode 100644 index 00000000..3f000321 --- /dev/null +++ b/crates/engine/tests/bake_tiles.rs @@ -0,0 +1,172 @@ +use std::sync::Arc; + +use serde_json::{Value, json}; +use texturecraft_engine::bake::Progress; +use texturecraft_engine::compose::BakedMaps; +use texturecraft_engine::core::BakedMap; +use texturecraft_engine::geom::primitives; +use texturecraft_engine::{Session, execute}; + +fn session() -> Session { + let mut session = Session::new_project("Tile baking", primitives::udim_plane(), "builtin:udim_plane", None, 128).unwrap(); + execute(&mut session, "bake.settings", &json!({"resolution": 32, "maps": ["ambientOcclusion"], "rays": 2})).unwrap(); + session +} + +#[test] +fn tile_selection_is_inspectable_saved_and_undoable() { + let mut session = session(); + let before = session.doc.project.clone(); + let result = execute(&mut session, "bake.tile.set", &json!({"tile": 1002, "enabled": false})).unwrap(); + assert_eq!(result, json!({"ts": 0, "tile": 1002, "enabled": false})); + let selected = session.doc.project.clone(); + let inspected = execute(&mut session, "textureSet.inspect", &Value::Null).unwrap(); + assert_eq!(inspected["tiles"][0]["bakeEnabled"], true); + assert_eq!(inspected["tiles"][1]["bakeEnabled"], false); + let reopened = Session::from_project_bytes(&session.to_project_bytes().unwrap()).unwrap(); + assert_eq!(reopened.doc.project, selected); + + let history = session.history_labels(); + execute(&mut session, "bake.tile.set", &json!({"tile": 1002, "enabled": false})).unwrap(); + assert_eq!(session.history_labels(), history); + session.undo().unwrap(); + assert_eq!(session.doc.project, before); + session.redo().unwrap(); + assert_eq!(session.doc.project, selected); + + for params in [json!({}), json!({"tile": 1003, "enabled": false}), json!({"tile": u64::MAX, "enabled": false}), json!({"tile": 1001, "enabled": 1})] { + assert!(execute(&mut session, "bake.tile.set", ¶ms).is_err()); + assert_eq!(session.doc.project, selected); + assert_eq!(session.history_labels(), history); + } +} + +#[test] +fn partial_bake_preserves_unchecked_tiles_and_uses_the_workers_selection() { + let mut session = session(); + session.doc.baked.insert(0, BakedMaps { resolution: 64, maps: [(BakedMap::AmbientOcclusion, Arc::new(vec![0.25; 64 * 32]))].into() }); + execute(&mut session, "bake.tile.set", &json!({"tile": 1002, "enabled": false})).unwrap(); + let mut task = session.bake_task(0).unwrap(); + task.tracer = None; + + // Editing the checkboxes while a bake runs affects the next bake + execute(&mut session, "bake.tile.set", &json!({"tile": 1002, "enabled": true})).unwrap(); + execute(&mut session, "bake.tile.set", &json!({"tile": 1001, "enabled": false})).unwrap(); + let before = session.doc.baked.clone(); + let output = task.run(&Progress::new()).unwrap(); + session.apply_bake(0, output).unwrap(); + + let pixels = &session.doc.baked[&0].maps[&BakedMap::AmbientOcclusion]; + for row in pixels.chunks_exact(64) { + assert!(row[..32].iter().all(|value| *value > 0.99)); + assert!(row[32..].iter().all(|value| *value == 0.25)); + } + session.undo().unwrap(); + assert_eq!(session.doc.baked, before); +} + +#[test] +fn partial_bake_resizes_retained_tiles_and_unchecked_map_outputs() { + let mut session = session(); + session.doc.baked.insert( + 0, + BakedMaps { + resolution: 64, + maps: [(BakedMap::AmbientOcclusion, Arc::new(vec![0.25; 64 * 32])), (BakedMap::Normal, Arc::new(vec![0.4; 64 * 32 * 3]))].into(), + }, + ); + execute(&mut session, "bake.tile.set", &json!({"tile": 1002, "enabled": false})).unwrap(); + let result = execute(&mut session, "bake.run", &json!({"resolution": 64, "cpu": true})).unwrap(); + assert_eq!(result["baked"], json!([0])); + + let baked = &session.doc.baked[&0]; + assert_eq!((baked.resolution, baked.height(BakedMap::AmbientOcclusion)), (128, 64)); + for row in baked.maps[&BakedMap::AmbientOcclusion].chunks_exact(128) { + assert!(row[..64].iter().all(|value| *value > 0.99)); + assert!(row[64..].iter().all(|value| *value == 0.25)); + } + assert_eq!(baked.maps[&BakedMap::Normal].len(), 128 * 64 * 3); + assert!(baked.maps[&BakedMap::Normal].iter().all(|value| *value == 0.4)); + let reopened = Session::from_project_bytes(&session.to_project_bytes().unwrap()).unwrap(); + assert_eq!(reopened.doc.baked, session.doc.baked); +} + +#[test] +fn tile_selection_preserves_the_correct_udim_row() { + let mut mesh = primitives::udim_plane(); + let second_plane = mesh.uvs.len() / 2; + for uv in mesh.uvs.iter_mut().skip(second_plane) { + uv.x -= 1.0; + uv.y -= 1.0; + } + let mut session = Session::new_project("Vertical UV tiles", mesh, "builtin:udim_plane", None, 128).unwrap(); + assert_eq!(session.doc.project.texture_sets[0].uv_tiles, [1001, 1011]); + session.doc.baked.insert(0, BakedMaps { resolution: 32, maps: [(BakedMap::AmbientOcclusion, Arc::new(vec![0.25; 32 * 64]))].into() }); + execute(&mut session, "bake.tile.set", &json!({"tile": 1011, "enabled": false})).unwrap(); + execute(&mut session, "bake.run", &json!({"resolution": 32, "maps": ["ambientOcclusion"], "rays": 2, "cpu": true})).unwrap(); + + let pixels = &session.doc.baked[&0].maps[&BakedMap::AmbientOcclusion]; + assert!(pixels[..32 * 32].iter().all(|value| *value == 0.25)); + assert!(pixels[32 * 32..].iter().all(|value| *value > 0.99)); +} + +#[test] +fn excluded_tiles_without_previous_pixels_use_neutral_values() { + let mut session = session(); + execute(&mut session, "bake.tile.set", &json!({"tile": 1001, "enabled": false})).unwrap(); + execute(&mut session, "bake.run", &json!({"maps": ["normal", "ambientOcclusion"], "cpu": true})).unwrap(); + let baked = &session.doc.baked[&0]; + for map in [BakedMap::Normal, BakedMap::AmbientOcclusion] { + for row in baked.maps[&map].chunks_exact(64 * map.components()) { + for pixel in row[..32 * map.components()].chunks_exact(map.components()) { + assert_eq!(pixel, &map.neutral()[..map.components()]); + } + } + } +} + +#[test] +fn no_selected_tiles_is_a_noop_and_old_projects_include_every_tile() { + let mut session = session(); + let serialized = serde_json::to_value(&session.doc.project).unwrap(); + assert!(serialized["texture_sets"][0].get("bake_excluded_tiles").is_none()); + let legacy: texturecraft_engine::core::Project = serde_json::from_value(serialized).unwrap(); + assert!(legacy.texture_sets[0].has_enabled_bake_tiles()); + + for tile in [1001, 1002] { + execute(&mut session, "bake.tile.set", &json!({"tile": tile, "enabled": false})).unwrap(); + } + let before = session.doc.project.clone(); + let history = session.history_labels(); + let result = execute(&mut session, "bake.run", &json!({"ts": "selected", "cpu": true})).unwrap(); + assert_eq!(result["baked"], json!([])); + assert_eq!(session.doc.project, before); + assert!(session.doc.baked.is_empty()); + assert_eq!(session.history_labels(), history); + assert!(session.bake_task(0).is_err()); + + execute(&mut session, "textureSet.uvTiles", &json!({"enabled": false})).unwrap(); + assert!(session.doc.project.texture_sets[0].bake_excluded_tiles.is_empty()); + session.undo().unwrap(); + assert_eq!(session.doc.project, before); +} + +#[test] +#[ignore] +fn partial_bake_timing() { + let mut session = session(); + execute(&mut session, "bake.run", &json!({"resolution": 256, "rays": 64, "cpu": true})).unwrap(); + for enabled in [true, false] { + execute(&mut session, "bake.tile.set", &json!({"tile": 1002, "enabled": enabled})).unwrap(); + let mut task = session.bake_task(0).unwrap(); + task.tracer = None; + let mut times = Vec::new(); + for _ in 0..5 { + let started = std::time::Instant::now(); + task.run(&Progress::new()).unwrap(); + times.push(started.elapsed()); + } + times.sort(); + eprintln!("{} of 2 UV tiles, 256 square, AO 64 rays, CPU: median {:?}, runs {:?}", if enabled { 2 } else { 1 }, times[2], times); + } +} diff --git a/crates/engine/tests/udim.rs b/crates/engine/tests/udim.rs index bcfab00b..aff12622 100644 --- a/crates/engine/tests/udim.rs +++ b/crates/engine/tests/udim.rs @@ -48,20 +48,24 @@ fn paint_red_at(s: &mut Session, p: Vec3) { #[test] fn uv_tiles_are_detected_and_inspected() { - let mut s = session(); - let set = execute(&mut s, "textureSet.inspect", &Value::Null).unwrap(); + let mut session = session(); + let set = execute(&mut session, "textureSet.inspect", &Value::Null).unwrap(); assert_eq!(set["uvTiles"], json!([1001, 1002])); assert_eq!(set["size"], json!([2 * RES, RES])); - assert_eq!(set["tiles"], json!([{ "udim": 1001, "block": [0, 0], "resolution": RES }, { "udim": 1002, "block": [1, 0], "resolution": RES }])); - assert_eq!(s.caches[0].size, (2 * RES, RES)); - // Explicit modes: classic on the UDIM plane, one tile on a 0..1 mesh. - execute(&mut s, "project.new", &json!({"mesh": "udim_plane", "resolution": RES, "uvTiles": false})).unwrap(); - assert!(s.doc.project.texture_sets[0].uv_tiles.is_empty()); - execute(&mut s, "project.new", &json!({"mesh": "plane", "resolution": RES})).unwrap(); - assert!(s.doc.project.texture_sets[0].uv_tiles.is_empty(), "UVs in 0..1 stay classic"); - execute(&mut s, "project.new", &json!({"mesh": "plane", "resolution": RES, "uvTiles": true})).unwrap(); - assert_eq!(s.doc.project.texture_sets[0].uv_tiles, vec![1001]); - assert_eq!(s.caches[0].size, (RES, RES)); + assert_eq!( + set["tiles"], + json!([{ "udim": 1001, "block": [0, 0], "resolution": RES, "bakeEnabled": true }, { "udim": 1002, "block": [1, 0], "resolution": RES, "bakeEnabled": true }]) + ); + assert_eq!(session.caches[0].size, (2 * RES, RES)); + + // Explicit modes: classic on the UDIM plane, one tile on a 0..1 mesh + execute(&mut session, "project.new", &json!({"mesh": "udim_plane", "resolution": RES, "uvTiles": false})).unwrap(); + assert!(session.doc.project.texture_sets[0].uv_tiles.is_empty()); + execute(&mut session, "project.new", &json!({"mesh": "plane", "resolution": RES})).unwrap(); + assert!(session.doc.project.texture_sets[0].uv_tiles.is_empty(), "UVs in 0..1 stay classic"); + execute(&mut session, "project.new", &json!({"mesh": "plane", "resolution": RES, "uvTiles": true})).unwrap(); + assert_eq!(session.doc.project.texture_sets[0].uv_tiles, vec![1001]); + assert_eq!(session.caches[0].size, (RES, RES)); } #[test] diff --git a/crates/formats/README.md b/crates/formats/README.md index 7b28004e..a52e80a5 100644 --- a/crates/formats/README.md +++ b/crates/formats/README.md @@ -145,6 +145,11 @@ pub fn load_project(path: &Path) -> Result; // native allocated 64×64 tile `tx`, `ty` (u32 LE) and the raw `u16` LE components (sparse, lossless). Baked maps: the same header with 0 tiles, then `width × height × components` f32 LE. +Project format version 2 stores baked maps in uniform UV tile blocks, independent of working +tile-resolution overrides. Older projects load their stored bake pixels as-is, without converting +the old layout; their appearance may change until rebaked. Painted layers and cage/skew correction +maps retain their working atlas layout. + Loading runs `Project::validate`, refuses a newer `format_version` (`FormatError::NewerVersion`), checks every tile against its texture set's resolution and component count, rejects repeated or out-of-range tiles and trailing data, drops pixels of layers that are in no stack, and caps the diff --git a/crates/formats/src/export/mod.rs b/crates/formats/src/export/mod.rs index f8fc1b97..24fc9833 100644 --- a/crates/formats/src/export/mod.rs +++ b/crates/formats/src/export/mod.rs @@ -596,7 +596,9 @@ impl Sampler<'_> { fn baked(&self, m: BakedMap, at: At) -> [f32; 3] { match at { - At::Texel(x, y) if self.set.baked.contains(&m) => self.baked.sample(m, x, y, (self.res, self.comp.height)).unwrap_or(m.neutral()), + At::Texel(x, y) if self.set.baked.contains(&m) => { + self.baked.sample_working(m, x, y, (self.res, self.comp.height), &self.scales).unwrap_or(m.neutral()) + } _ => m.neutral(), } } diff --git a/crates/formats/src/project_file/mod.rs b/crates/formats/src/project_file/mod.rs index 045dd0da..115ed5e0 100644 --- a/crates/formats/src/project_file/mod.rs +++ b/crates/formats/src/project_file/mod.rs @@ -455,6 +455,8 @@ fn load(reader: R) -> Result { // Ignore other entries from newer minor revisions } + pf.project.format_version = FORMAT_VERSION; + if recovered { pf.warnings.push( "Warning: Some project settings or mesh maps could not be imported. TextureCraft recovered what it could, using defaults where needed.".into(), diff --git a/crates/formats/src/project_file/tests.rs b/crates/formats/src/project_file/tests.rs index 0a3c5067..7f756554 100644 --- a/crates/formats/src/project_file/tests.rs +++ b/crates/formats/src/project_file/tests.rs @@ -82,6 +82,26 @@ fn round_trip_is_identical_and_deterministic() { assert_same(&builtin, &load_project_bytes(&save_project_bytes(&builtin).unwrap()).unwrap()); } +#[test] +fn legacy_bakes_load_as_is_without_layout_conversion() { + let mut sample = sample(); + sample.pf.project.format_version = 1; + sample.pf.pixels.layers.clear(); + let set = &mut sample.pf.project.texture_sets[0]; + set.resolution = 256; + set.uv_tiles = vec![1001, 1002]; + set.tile_resolutions.insert(1002, 128); + let pixels: Vec = (0..16).flat_map(|y| (0..32).map(move |x| (y * 32 + x) as f32)).collect(); + sample.pf.baked.insert(0, BakedMaps { resolution: 32, maps: [(BakedMap::AmbientOcclusion, Arc::new(pixels))].into() }); + + let loaded = load_project_bytes(&save_project_bytes(&sample.pf).unwrap()).unwrap(); + assert_eq!(loaded.project.format_version, FORMAT_VERSION); + assert_eq!(loaded.baked, sample.pf.baked, "old bake pixels are accepted without preserving their former layout"); + assert_eq!(loaded.bake_paint, sample.pf.bake_paint, "correction paint remains in the working layout"); + let reopened = load_project_bytes(&save_project_bytes(&loaded).unwrap()).unwrap(); + assert_same(&loaded, &reopened); +} + #[cfg(not(target_arch = "wasm32"))] #[test] fn save_and_load_through_files() { diff --git a/crates/render/src/mesh_maps.rs b/crates/render/src/mesh_maps.rs index bf811478..4bfb13dc 100644 --- a/crates/render/src/mesh_maps.rs +++ b/crates/render/src/mesh_maps.rs @@ -1,27 +1,46 @@ //! Debug textures for the mesh-map view. use texturecraft_compose::BakedMaps; -use texturecraft_core::BakedMap; -use texturecraft_texel::linear_to_srgb; +use texturecraft_core::{BakedMap, BlockScales}; /// RGBA8 of baked map `m` resampled to `size × size` stretched over the map (mid gray where not /// baked). Scalar maps are shown as grayscale; ID maps as their colors. Values are display /// (sRGB) encoded. -pub fn mesh_map_rgba(baked: Option<&BakedMaps>, m: BakedMap, size: u32) -> Vec { +pub fn mesh_map_rgba(baked: Option<&BakedMaps>, m: BakedMap, size: u32, working_size: (u32, u32), scales: &BlockScales) -> Vec { let size = size.max(1); let mut out = vec![128u8; (size * size * 4) as usize]; let Some(b) = baked.filter(|b| b.maps.contains_key(&m)) else { return out }; + for y in 0..size { for x in 0..size { - let v = b.sample(m, x, y, (size, size)).unwrap_or([0.5; 3]); + let uv = [(x as f32 + 0.5) / size as f32, (y as f32 + 0.5) / size as f32]; + let v = scales.bake_uv(uv, working_size).and_then(|uv| b.sample_uv(m, uv)).unwrap_or([0.5; 3]); let i = ((y * size + x) * 4) as usize; for k in 0..3 { - // Data maps are shown as stored, i.e. treated as display values. + // Data maps are shown as stored out[i + k] = (v[k].clamp(0.0, 1.0) * 255.0 + 0.5) as u8; } out[i + 3] = 255; } } - let _ = linear_to_srgb; out } + +#[cfg(test)] +mod tests { + use super::*; + use std::sync::Arc; + use texturecraft_core::TextureSet; + + #[test] + fn mesh_map_preview_places_bake_detail_in_the_working_tile() { + let mut set = TextureSet::new("Tiles", 0, 256); + set.uv_tiles = vec![1001, 1002]; + set.tile_resolutions.insert(1002, 128); + let pixels = (0..128).flat_map(|y| (0..256).map(move |x| ((x % 128) + y) as f32 / 255.0)).collect(); + let baked = BakedMaps { resolution: 256, maps: [(BakedMap::AmbientOcclusion, Arc::new(pixels))].into() }; + let preview = mesh_map_rgba(Some(&baked), BakedMap::AmbientOcclusion, 512, set.size(), &set.block_scales()); + assert_eq!(preview[(240 * 512 + 376) * 4], 240); + assert_eq!(preview[(400 * 512 + 500) * 4], 128, "unused working block area stays neutral"); + } +} diff --git a/crates/ui-egui/src/bake_mode.rs b/crates/ui-egui/src/bake_mode.rs deleted file mode 100644 index a5ee88f4..00000000 --- a/crates/ui-egui/src/bake_mode.rs +++ /dev/null @@ -1,112 +0,0 @@ -//! Bake Mode presentation; persisted settings live in core and edits use engine commands - -mod bake_paint_brush; -mod breadcrumb; -mod common_settings; -pub use bake_paint_brush::BakePaintBrush; -mod controls; -mod map_settings; -mod mesh_map_bakers; - -use egui::{Ui, vec2}; -use serde_json::json; -use texturecraft_engine::core::{BakeSettings, BakedMap}; - -use crate::TextureCraftApp; -use crate::i18n::{tr, trf}; -use crate::state::Mode; -use crate::widgets::primary_button; - -pub fn texture_sets(app: &mut TextureCraftApp, ui: &mut Ui) { - egui::ScrollArea::vertical().id_salt("bake_texture_sets").auto_shrink([false; 2]).show(ui, |ui| { - for set_index in 0..app.session.set_count() { - let Some(texture_set) = app.session.doc.project.texture_sets.get(set_index) else { continue }; - - let name = texture_set.name.clone(); - let (width, height) = texture_set.bake.common.output_size(); - let mut is_enabled = texture_set.bake.common.is_enabled; - ui.push_id(set_index, |ui| { - ui.horizontal(|ui| { - if ui.checkbox(&mut is_enabled, "").on_hover_text(tr("Include in Bake")).changed() { - app.run("bake.settings", json!({ "ts": set_index, "enabled": is_enabled })); - } - if ui.selectable_label(set_index == app.session.ts(), format!("{name} ({width} × {height})")).clicked() { - app.run("textureSet.select", json!({ "ts": set_index })); - } - }); - }); - } - }); -} - -/// The Mesh Map Bakers panel: which maps bake and which one Mesh Map Settings shows -pub fn mesh_map_bakers_panel(app: &mut TextureCraftApp, ui: &mut Ui) { - edit_settings(app, ui, "mesh_map_bakers", mesh_map_bakers::show); -} - -/// The Mesh Map Settings panel: the breadcrumb, then the selected map's parameters -pub fn mesh_map_settings_panel(app: &mut TextureCraftApp, ui: &mut Ui) { - let Some(texture_set) = app.session.doc.project.texture_sets.get(app.session.ts()) else { return }; - - let selected = selected_map(app.ui.selected_baked_map, &texture_set.bake); - breadcrumb::show(app, ui, selected); - ui.separator(); - edit_settings(app, ui, "mesh_map_settings", |_, ui, settings| ui.push_id(selected, |ui| map_settings::show(ui, selected, &mut settings.maps)).inner); -} - -/// The Common Settings panel: output, high poly, cage and skew settings -pub fn common_settings_panel(app: &mut TextureCraftApp, ui: &mut Ui) { - edit_settings(app, ui, "bake_common_settings", common_settings::show); -} - -/// The map whose settings show: the chosen one, else the first enabled map, else Normal -fn selected_map(selection: Option, settings: &BakeSettings) -> BakedMap { - selection.or_else(|| settings.maps.enabled().next()).unwrap_or(BakedMap::Normal) -} - -/// Draw `contents` over a copy of the active set's bake settings and run `bake.settings` on change -fn edit_settings(app: &mut TextureCraftApp, ui: &mut Ui, scroll_id: &str, contents: impl FnOnce(&mut TextureCraftApp, &mut Ui, &mut BakeSettings)) { - let set_index = app.session.ts(); - let Some(before) = app.session.doc.project.texture_sets.get(set_index).map(|texture_set| texture_set.bake.clone()) else { return }; - - let mut settings = before.clone(); - egui::ScrollArea::vertical().id_salt(scroll_id).auto_shrink([false; 2]).show(ui, |ui| contents(app, ui, &mut settings)); - if settings != before { - app.run("bake.settings", json!({ "ts": set_index, "model": settings })); - } -} - -pub(crate) fn bake_bar(app: &mut TextureCraftApp, ctx: &egui::Context, viewport: egui::Rect) { - egui::Area::new(egui::Id::unique("bake_bar")).constrain_to(viewport).anchor(egui::Align2::CENTER_BOTTOM, vec2(0.0, -16.0)).default_width(0.0).show( - ctx, - |ui| { - ui.horizontal(|ui| { - if let Some(progress) = app.bake_progress() { - ui.add(egui::ProgressBar::new(progress).desired_width(220.0).show_percentage()); - if ui.button(tr("Cancel")).clicked() { - app.cancel_bake(); - } - } else { - let texture_sets: Vec = app - .session - .doc - .project - .texture_sets - .iter() - .enumerate() - .filter(|(_, texture_set)| texture_set.bake.common.is_enabled) - .map(|(index, _)| index) - .collect(); - let label = trf("Bake Selected Textures ({n})", &[("n", &texture_sets.len())]); - if ui.add_enabled(!texture_sets.is_empty(), primary_button(ui, &label)).clicked() { - app.start_bake(texture_sets); - } - } - - if ui.button(tr("Return to Painting Mode")).clicked() { - app.ui.mode = Mode::Painting; - } - }); - }, - ); -} diff --git a/crates/ui-egui/src/bake_mode/common_settings.rs b/crates/ui-egui/src/bake_mode/common_settings.rs index fe4819a0..02d712a0 100644 --- a/crates/ui-egui/src/bake_mode/common_settings.rs +++ b/crates/ui-egui/src/bake_mode/common_settings.rs @@ -4,13 +4,14 @@ use crate::i18n::tr; use crate::widgets::icon_button; use egui::Ui; use egui_phosphor::regular as icon; -use serde_json::json; +use serde_json::{Map, Value, json}; use texturecraft_engine::core::{ BakeAntialiasing, BakePaintTarget, BakeResolution, BakeSettings, CageType, CommonBakeSettings, MeshMatchMode, SkewCorrectionMethod, }; /// The output and high-poly sections, then cage (needs a high poly) and skew (needs a distance cage) -pub(super) fn show(app: &mut TextureCraftApp, ui: &mut Ui, settings: &mut BakeSettings) { +pub(super) fn show(app: &mut TextureCraftApp, ui: &mut Ui, settings: &mut BakeSettings) -> Option { + let mut reset = Map::new(); ui.push_id("common", |ui| { // Restore Defaults keeps whether the texture set is included in the bake let is_enabled = settings.common.is_enabled; @@ -31,6 +32,11 @@ pub(super) fn show(app: &mut TextureCraftApp, ui: &mut Ui, settings: &mut BakeSe ui.checkbox(&mut settings.common.apply_diffusion, tr("Apply Diffusion")); }) { settings.common = CommonBakeSettings { is_enabled, ..CommonBakeSettings::default() }; + let mut defaults = json!(settings.common); + if let Some(fields) = defaults.as_object_mut() { + fields.remove("is_enabled"); + } + reset.insert("common".into(), defaults); } }); @@ -53,6 +59,7 @@ pub(super) fn show(app: &mut TextureCraftApp, ui: &mut Ui, settings: &mut BakeSe } }) { settings.high_poly = Default::default(); + reset.insert("high_poly".into(), json!(settings.high_poly)); } }); @@ -78,6 +85,7 @@ pub(super) fn show(app: &mut TextureCraftApp, ui: &mut Ui, settings: &mut BakeSe } }) { settings.cage = Default::default(); + reset.insert("cage".into(), json!(settings.cage)); } }); @@ -100,10 +108,13 @@ pub(super) fn show(app: &mut TextureCraftApp, ui: &mut Ui, settings: &mut BakeSe number(ui, tr("Edge Contrast"), &mut settings.skew.edge_contrast, 0.0..=1.0, 2); }) { settings.skew = Default::default(); + reset.insert("skew".into(), json!(settings.skew)); } }); } } + + (!reset.is_empty()).then_some(Value::Object(reset)) } fn output_size(ui: &mut Ui, settings: &mut CommonBakeSettings) { diff --git a/crates/ui-egui/src/bake_mode/map_settings.rs b/crates/ui-egui/src/bake_mode/map_settings.rs index 0b5ac9e0..5168d341 100644 --- a/crates/ui-egui/src/bake_mode/map_settings.rs +++ b/crates/ui-egui/src/bake_mode/map_settings.rs @@ -1,6 +1,8 @@ use super::controls::{choice, hint, integer, number}; use crate::i18n::tr; use egui::Ui; +use serde::Serialize; +use serde_json::{Value, json}; use texturecraft_engine::core::{ AmbientOcclusionAttenuation, AmbientOcclusionSettings, BackfaceMode, BakedMap, BentNormalSettings, CurvatureMethod, CurvatureSettings, HeightNormalization, HeightSettings, IdColorGenerator, IdColorSource, IdSettings, MeshMapSettings, PositionAxis, PositionMode, PositionNormalizationScale, PositionSettings, @@ -8,28 +10,33 @@ use texturecraft_engine::core::{ }; /// Draw `map`'s parameters with Restore Defaults; maps without parameters say so -pub(super) fn show(ui: &mut Ui, map: BakedMap, settings: &mut MeshMapSettings) { +pub(super) fn show(ui: &mut Ui, map: BakedMap, settings: &mut MeshMapSettings) -> Option { match map { - BakedMap::Normal | BakedMap::WorldNormal | BakedMap::Opacity => hint(ui, tr("No Parameters")), - BakedMap::Id => parameters(ui, &mut settings.id.parameters, id), - BakedMap::AmbientOcclusion => parameters(ui, &mut settings.ao.parameters, ambient_occlusion), - BakedMap::Curvature => parameters(ui, &mut settings.curvature.parameters, curvature), - BakedMap::Position => parameters(ui, &mut settings.position.parameters, position), - BakedMap::Thickness => parameters(ui, &mut settings.thickness.parameters, thickness), - BakedMap::Height => parameters(ui, &mut settings.height.parameters, height), - BakedMap::BentNormal => parameters(ui, &mut settings.bent_normal.parameters, bent_normal), + BakedMap::Normal | BakedMap::WorldNormal | BakedMap::Opacity => { + hint(ui, tr("No Parameters")); + None + } + BakedMap::Id => parameters(ui, "id", &mut settings.id.parameters, id), + BakedMap::AmbientOcclusion => parameters(ui, "ao", &mut settings.ao.parameters, ambient_occlusion), + BakedMap::Curvature => parameters(ui, "curvature", &mut settings.curvature.parameters, curvature), + BakedMap::Position => parameters(ui, "position", &mut settings.position.parameters, position), + BakedMap::Thickness => parameters(ui, "thickness", &mut settings.thickness.parameters, thickness), + BakedMap::Height => parameters(ui, "height", &mut settings.height.parameters, height), + BakedMap::BentNormal => parameters(ui, "bent_normal", &mut settings.bent_normal.parameters, bent_normal), } } /// A map's controls, then a right-aligned Restore Defaults that resets only its parameters -fn parameters(ui: &mut Ui, parameters: &mut T, controls: impl FnOnce(&mut Ui, &mut T)) { +fn parameters(ui: &mut Ui, map_key: &str, parameters: &mut T, controls: impl FnOnce(&mut Ui, &mut T)) -> Option { controls(ui, parameters); ui.add_space(6.0); let restore = ui.with_layout(egui::Layout::right_to_left(egui::Align::Min), |ui| ui.button(tr("Restore Defaults"))).inner; if restore.clicked() { *parameters = T::default(); + return Some(json!({"maps": {map_key: {"parameters": parameters}}})); } + None } fn id(ui: &mut Ui, settings: &mut IdSettings) { diff --git a/crates/ui-egui/src/bake_mode/mod.rs b/crates/ui-egui/src/bake_mode/mod.rs new file mode 100644 index 00000000..3a308a4a --- /dev/null +++ b/crates/ui-egui/src/bake_mode/mod.rs @@ -0,0 +1,216 @@ +//! Bake Mode presentation; persisted settings live in core and edits use engine commands + +mod bake_paint_brush; +mod breadcrumb; +mod common_settings; +pub use bake_paint_brush::BakePaintBrush; +mod controls; +mod map_settings; +mod mesh_map_bakers; + +use egui::{Ui, vec2}; +use egui_phosphor::regular as icon; +use serde_json::{Value, json}; +use texturecraft_engine::bake::settings_patch; +use texturecraft_engine::core::{BakeSettings, BakedMap}; + +use crate::TextureCraftApp; +use crate::i18n::{tr, trf}; +use crate::state::Mode; +use crate::widgets::{icon_button, primary_button}; + +pub fn texture_sets(app: &mut TextureCraftApp, ui: &mut Ui) { + egui::ScrollArea::vertical().id_salt("bake_texture_sets").auto_shrink([false; 2]).show(ui, |ui| { + for set_index in 0..app.session.set_count() { + let Some(texture_set) = app.session.doc.project.texture_sets.get(set_index) else { continue }; + + let name = texture_set.name.clone(); + let resolution = texture_set.resolution; + let mut is_enabled = texture_set.bake.common.is_enabled; + let visible = texture_set.visible; + let tiles: Vec<_> = texture_set + .uv_tiles + .iter() + .map(|tile| (*tile, texture_set.tile_resolutions.get(tile).copied(), !texture_set.bake_excluded_tiles.contains(tile))) + .collect(); + + ui.push_id(set_index, |ui| { + ui.horizontal(|ui| { + let button_size = ui.spacing().interact_size.y; + if icon_button(ui, if visible { icon::EYE } else { icon::EYE_SLASH }, tr("Show or hide the texture set"), false, button_size).clicked() { + app.run("textureSet.visible", json!({ "ts": set_index })); + } + if ui.checkbox(&mut is_enabled, "").on_hover_text(tr("Include in Bake")).changed() { + app.run("bake.settings", json!({ "ts": set_index, "enabled": is_enabled })); + } + ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { + if let Some(selected) = resolution_menu(ui, tr("Texture set resolution"), format!("{resolution} × {resolution}"), resolution, None) + && selected != resolution + { + app.start_resize(set_index, selected); + } + ui.with_layout(egui::Layout::left_to_right(egui::Align::Center), |ui| { + if ui.add(egui::Button::selectable(set_index == app.session.ts(), &name).truncate()).on_hover_text(&name).clicked() { + app.run("textureSet.select", json!({ "ts": set_index })); + } + }); + }); + }); + + if !tiles.is_empty() { + egui::CollapsingHeader::new(format!("{} ({})", tr("UV tiles (UDIM)"), tiles.len())).default_open(true).show(ui, |ui| { + for (tile, override_resolution, enabled) in &tiles { + let mut enabled = *enabled; + ui.push_id(tile, |ui| { + ui.horizontal(|ui| { + if ui.checkbox(&mut enabled, tile.to_string()).on_hover_text(tr("Include in Bake")).changed() { + app.run("bake.tile.set", json!({"ts": set_index, "tile": tile, "enabled": enabled})); + } + ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { + let text = override_resolution.map(|value| format!("{value} × {value}*")).unwrap_or_default(); + let label = trf("UV tile {tile} resolution", &[("tile", &tile.to_string())]); + if let Some(selected) = resolution_menu( + ui, + &label, + text, + override_resolution.unwrap_or(resolution), + override_resolution.map(|_| resolution), + ) { + app.run("textureSet.tile.resolution", json!({"ts": set_index, "tile": tile, "resolution": selected})); + } + }); + }) + }); + } + }); + } + }); + } + }); +} + +fn resolution_menu(ui: &mut Ui, label: &str, text: String, resolution: u32, inherited_resolution: Option) -> Option { + let effective_size = format!("{resolution} × {resolution}"); + let measured = if text.is_empty() { &effective_size } else { &text }; + let font = egui::TextStyle::Button.resolve(ui.style()); + let text_width = ui.painter().layout_no_wrap(measured.clone(), font.clone(), ui.visuals().text_color()).size().x; + let width = text_width + ui.spacing().button_padding.x * 2.0; + let response = ui.add_sized([width, ui.spacing().interact_size.y], egui::Button::new("").frame(false)); + let popup_id = response.id.with("resolution_menu"); + let open = egui::Popup::is_id_open(ui.ctx(), popup_id) || response.clicked(); + let shown = if text.is_empty() && (response.hovered() || open) { effective_size } else { text }; + ui.painter().text(response.rect.center(), egui::Align2::CENTER_CENTER, &shown, font, ui.style().interact(&response).text_color()); + + let mut selected = None; + egui::Popup::menu(&response).id(popup_id).show(|ui| { + if let Some(inherited) = inherited_resolution { + if ui.button(tr("Remove resolution override")).clicked() { + selected = Some(inherited); + ui.close(); + } + ui.separator(); + } + for candidate in [128, 256, 512, 1024, 2048, 4096, 8192] { + if ui.selectable_label(candidate == resolution, format!("{candidate} × {candidate}")).clicked() { + selected = Some(candidate); + } + } + }); + response.widget_info(|| { + let mut info = egui::WidgetInfo::labeled(egui::Role::ComboBox, ui.is_enabled(), label); + info.current_text_value = Some(shown.clone()); + info + }); + response.on_hover_text(label); + selected +} + +/// The Mesh Map Bakers panel: which maps bake and which one Mesh Map Settings shows +pub fn mesh_map_bakers_panel(app: &mut TextureCraftApp, ui: &mut Ui) { + let texture_set = json!(app.session.ts()); + edit_settings(app, ui, "mesh_map_bakers", texture_set, |app, ui, settings| { + mesh_map_bakers::show(app, ui, settings); + None + }); +} + +/// The Mesh Map Settings panel: the breadcrumb, then the selected map's parameters +pub fn mesh_map_settings_panel(app: &mut TextureCraftApp, ui: &mut Ui) { + let Some(texture_set) = app.session.doc.project.texture_sets.get(app.session.ts()) else { return }; + + let selected = selected_map(app.ui.selected_baked_map, &texture_set.bake); + breadcrumb::show(app, ui, selected); + ui.separator(); + edit_settings(app, ui, "mesh_map_settings", json!("all"), |_, ui, settings| { + ui.push_id(selected, |ui| map_settings::show(ui, selected, &mut settings.maps)).inner + }); +} + +/// The Common Settings panel: output, high poly, cage and skew settings +pub fn common_settings_panel(app: &mut TextureCraftApp, ui: &mut Ui) { + edit_settings(app, ui, "bake_common_settings", json!("all"), common_settings::show); +} + +/// The map whose settings show: the chosen one, else the first enabled map, else Normal +fn selected_map(selection: Option, settings: &BakeSettings) -> BakedMap { + selection.or_else(|| settings.maps.enabled().next()).unwrap_or(BakedMap::Normal) +} + +/// Send changed fields and explicitly reset sections through the same undoable command +fn edit_settings( + app: &mut TextureCraftApp, + ui: &mut Ui, + scroll_id: &str, + texture_sets: Value, + contents: impl FnOnce(&mut TextureCraftApp, &mut Ui, &mut BakeSettings) -> Option, +) { + let set_index = app.session.ts(); + let Some(before) = app.session.doc.project.texture_sets.get(set_index).map(|texture_set| texture_set.bake.clone()) else { return }; + + let mut settings = before.clone(); + let reset = egui::ScrollArea::vertical().id_salt(scroll_id).auto_shrink([false; 2]).show(ui, |ui| contents(app, ui, &mut settings)).inner; + if settings == before && reset.is_none() { + return; + } + + let mut patch = settings_patch(&before, &settings); + if let (Some(fields), Some(Value::Object(reset))) = (patch.as_object_mut(), reset) { + fields.extend(reset); + } + app.run("bake.settings", json!({ "ts": texture_sets, "patch": patch })); +} + +pub(crate) fn bake_bar(app: &mut TextureCraftApp, ctx: &egui::Context, viewport: egui::Rect) { + egui::Area::new(egui::Id::unique("bake_bar")).constrain_to(viewport).anchor(egui::Align2::CENTER_BOTTOM, vec2(0.0, -16.0)).default_width(0.0).show( + ctx, + |ui| { + ui.horizontal(|ui| { + if let Some(progress) = app.bake_progress() { + ui.add(egui::ProgressBar::new(progress).desired_width(220.0).show_percentage()); + if ui.button(tr("Cancel")).clicked() { + app.cancel_bake(); + } + } else { + let texture_sets: Vec = app + .session + .doc + .project + .texture_sets + .iter() + .enumerate() + .filter(|(_, texture_set)| texture_set.bake.common.is_enabled && texture_set.has_enabled_bake_tiles()) + .map(|(index, _)| index) + .collect(); + let label = trf("Bake Selected Textures ({n})", &[("n", &texture_sets.len())]); + if ui.add_enabled(!texture_sets.is_empty(), primary_button(ui, &label)).clicked() { + app.start_bake(texture_sets); + } + } + + if ui.button(tr("Return to Painting Mode")).clicked() { + app.ui.mode = Mode::Painting; + } + }); + }, + ); +} diff --git a/crates/ui-egui/src/gpu.rs b/crates/ui-egui/src/gpu.rs index 77db5727..c6695b34 100644 --- a/crates/ui-egui/src/gpu.rs +++ b/crates/ui-egui/src/gpu.rs @@ -216,8 +216,14 @@ impl GpuLink { if self.aux.get(&ts) == Some(&key) { continue; } - let res = s.caches.get(ts).map_or(1024, |c| texturecraft_render::aux_size(c.size)); - out.aux.push((ts, res, texturecraft_render::mesh_maps::mesh_map_rgba(s.doc.baked.get(&ts), m, res))); + let Some(cache) = s.caches.get(ts) else { continue }; + + let res = texturecraft_render::aux_size(cache.size); + out.aux.push(( + ts, + res, + texturecraft_render::mesh_maps::mesh_map_rgba(s.doc.baked.get(&ts), m, res, cache.size, &cache.composite.block_scales), + )); self.aux.insert(ts, key); } } diff --git a/crates/ui-egui/src/i18n/ar.rs b/crates/ui-egui/src/i18n/ar.rs index 6146d6d5..0f2e023f 100644 --- a/crates/ui-egui/src/i18n/ar.rs +++ b/crates/ui-egui/src/i18n/ar.rs @@ -1032,4 +1032,7 @@ pub const TABLE: &[(&str, &str)] = &[ ("Value Bounds Max", "الحد الأقصى للقيمة"), ("Value Bounds Min", "الحد الأدنى للقيمة"), ("Vertex Color", "لون الرأس"), + ("Remove resolution override", "إزالة تجاوز الدقة"), + ("Texture set resolution", "دقة مجموعة الخامات"), + ("UV tile {tile} resolution", "دقة بلاطة UV {tile}"), ]; diff --git a/crates/ui-egui/src/i18n/de.rs b/crates/ui-egui/src/i18n/de.rs index 5ceb5dd5..77cf296b 100644 --- a/crates/ui-egui/src/i18n/de.rs +++ b/crates/ui-egui/src/i18n/de.rs @@ -1075,4 +1075,7 @@ pub const TABLE: &[(&str, &str)] = &[ ("Value Bounds Max", "Maximaler Grenzwert"), ("Value Bounds Min", "Minimaler Grenzwert"), ("Vertex Color", "Scheitelpunktfarbe"), + ("Remove resolution override", "Auflösungsüberschreibung entfernen"), + ("Texture set resolution", "Auflösung des Textursets"), + ("UV tile {tile} resolution", "Auflösung der UV-Kachel {tile}"), ]; diff --git a/crates/ui-egui/src/i18n/es.rs b/crates/ui-egui/src/i18n/es.rs index f9f42e49..4153783e 100644 --- a/crates/ui-egui/src/i18n/es.rs +++ b/crates/ui-egui/src/i18n/es.rs @@ -1060,4 +1060,7 @@ pub const TABLE: &[(&str, &str)] = &[ ("Value Bounds Max", "Límite máximo"), ("Value Bounds Min", "Límite mínimo"), ("Vertex Color", "Color de vértice"), + ("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}"), ]; diff --git a/crates/ui-egui/src/i18n/fr.rs b/crates/ui-egui/src/i18n/fr.rs index 57c7194f..0c07e5a4 100644 --- a/crates/ui-egui/src/i18n/fr.rs +++ b/crates/ui-egui/src/i18n/fr.rs @@ -1084,4 +1084,7 @@ pub const TABLE: &[(&str, &str)] = &[ ("Value Bounds Max", "Borne maximale"), ("Value Bounds Min", "Borne minimale"), ("Vertex Color", "Couleur des sommets"), + ("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}"), ]; diff --git a/crates/ui-egui/src/i18n/it.rs b/crates/ui-egui/src/i18n/it.rs index 34abc28a..b4bd33b3 100644 --- a/crates/ui-egui/src/i18n/it.rs +++ b/crates/ui-egui/src/i18n/it.rs @@ -1069,4 +1069,7 @@ pub const TABLE: &[(&str, &str)] = &[ ("Value Bounds Max", "Limite massimo"), ("Value Bounds Min", "Limite minimo"), ("Vertex Color", "Colore dei vertici"), + ("Remove resolution override", "Rimuovi risoluzione personalizzata"), + ("Texture set resolution", "Risoluzione del set di texture"), + ("UV tile {tile} resolution", "Risoluzione del tile UV {tile}"), ]; diff --git a/crates/ui-egui/src/i18n/ja.rs b/crates/ui-egui/src/i18n/ja.rs index 2c91d7ce..f764e268 100644 --- a/crates/ui-egui/src/i18n/ja.rs +++ b/crates/ui-egui/src/i18n/ja.rs @@ -1054,4 +1054,7 @@ pub const TABLE: &[(&str, &str)] = &[ ("Value Bounds Max", "値の上限"), ("Value Bounds Min", "値の下限"), ("Vertex Color", "頂点カラー"), + ("Remove resolution override", "解像度の上書きを解除"), + ("Texture set resolution", "テクスチャセットの解像度"), + ("UV tile {tile} resolution", "UVタイル {tile} の解像度"), ]; diff --git a/crates/ui-egui/src/i18n/ko.rs b/crates/ui-egui/src/i18n/ko.rs index 58a80560..a1c8d363 100644 --- a/crates/ui-egui/src/i18n/ko.rs +++ b/crates/ui-egui/src/i18n/ko.rs @@ -1042,4 +1042,7 @@ pub const TABLE: &[(&str, &str)] = &[ ("Value Bounds Max", "값 상한"), ("Value Bounds Min", "값 하한"), ("Vertex Color", "정점 색상"), + ("Remove resolution override", "해상도 재정의 제거"), + ("Texture set resolution", "텍스처 세트 해상도"), + ("UV tile {tile} resolution", "UV 타일 {tile} 해상도"), ]; diff --git a/crates/ui-egui/src/i18n/pt_br.rs b/crates/ui-egui/src/i18n/pt_br.rs index 47e49c9c..880b62ff 100644 --- a/crates/ui-egui/src/i18n/pt_br.rs +++ b/crates/ui-egui/src/i18n/pt_br.rs @@ -1057,4 +1057,7 @@ pub const TABLE: &[(&str, &str)] = &[ ("Value Bounds Max", "Limite máximo"), ("Value Bounds Min", "Limite mínimo"), ("Vertex Color", "Cor do vértice"), + ("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}"), ]; diff --git a/crates/ui-egui/src/i18n/zh_hans.rs b/crates/ui-egui/src/i18n/zh_hans.rs index 8b66aead..f894f1ad 100644 --- a/crates/ui-egui/src/i18n/zh_hans.rs +++ b/crates/ui-egui/src/i18n/zh_hans.rs @@ -1000,4 +1000,7 @@ pub const TABLE: &[(&str, &str)] = &[ ("Value Bounds Max", "值上限"), ("Value Bounds Min", "值下限"), ("Vertex Color", "顶点颜色"), + ("Remove resolution override", "移除分辨率覆盖"), + ("Texture set resolution", "纹理集分辨率"), + ("UV tile {tile} resolution", "UV 图块 {tile} 的分辨率"), ]; diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 59c6f40c..375ff1ba 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -134,7 +134,7 @@ impl TextureCraftApp { theme::install(&cc.egui_ctx); // Bakes cast their rays on a GPU device of their own (created on the first bake). #[cfg(not(target_arch = "wasm32"))] - texturecraft_engine::bake_cmds::install_gpu_tracer(Arc::new(texturecraft_render::gpu_bake::GpuBaker::new())); + texturecraft_engine::bake::install_gpu_tracer(Arc::new(texturecraft_render::gpu_bake::GpuBaker::new())); let gpu = cc.wgpu_render_state.as_ref().map(|rs| gpu::init(rs, &cc.egui_ctx)); // The first run speaks the OS (or browser) language. let ui = cc.storage.and_then(|s| eframe::get_value::(s, "ui")).unwrap_or_else(|| { diff --git a/crates/ui-egui/tests/bake_mode.rs b/crates/ui-egui/tests/bake_mode.rs index 7802f9d5..88a7c1f2 100644 --- a/crates/ui-egui/tests/bake_mode.rs +++ b/crates/ui-egui/tests/bake_mode.rs @@ -1,7 +1,7 @@ use egui::Role; use egui_kittest::Harness; use egui_kittest::kittest::{NodeT, Queryable}; -use texturecraft_engine::core::{BakeResolution, BakedMap, CageType, CurvatureMethod, HeightNormalization}; +use texturecraft_engine::core::{BakeResolution, BakeSettings, BakedMap, CageType, CurvatureMethod, HeightNormalization}; use texturecraft_ui_egui::TextureCraftApp; use texturecraft_ui_egui::docking::Panel; use texturecraft_ui_egui::state::Mode; @@ -45,6 +45,306 @@ fn click(harness: &mut Harness<'_, TextureCraftApp>, label: &str) { harness.run_steps(3); } +fn number_field<'a>(harness: &'a Harness<'_, TextureCraftApp>, label: &str) -> egui_kittest::Node<'a> { + let label_row = harness.get_by_label(label).rect().center().y; + harness.get_all_by_role(Role::TextInput).find(|node| (node.rect().center().y - label_row).abs() < 4.0).unwrap() +} + +#[test] +fn mesh_map_edits_update_all_sets_without_copying_unedited_fields() { + let mut harness = harness(Some(BakedMap::AmbientOcclusion)); + let session = &mut harness.state_mut().session; + assert_eq!(session.set_count(), 2); + let second = &mut session.doc.project.texture_sets[1].bake; + *second = BakeSettings::default(); + second.common.is_enabled = false; + second.common.resolution = BakeResolution::R128; + second.common.resolution_height = Some(BakeResolution::R256); + second.maps.ao.is_enabled = false; + second.maps.ao.parameters.rays.rays = 16; + second.maps.ao.parameters.ground_plane.offset = 3.0; + second.maps.height.parameters.scaling_divisor = 2.0; + let before = session.doc.project.clone(); + let history_steps = session.history_labels().len(); + + click_checkbox(&mut harness, "Ground Plane"); + + let mut expected = before.clone(); + for texture_set in &mut expected.texture_sets { + texture_set.bake.maps.ao.parameters.ground_plane.enabled = true; + } + let session = &mut harness.state_mut().session; + assert_eq!(session.doc.project, expected); + assert_eq!(session.history_labels().len(), history_steps + 1); + session.undo().unwrap(); + assert_eq!(session.doc.project, before); + session.redo().unwrap(); + assert_eq!(session.doc.project, expected); +} + +#[test] +fn common_settings_edits_update_all_sets_and_keep_their_map_selection() { + let mut harness = harness(Some(BakedMap::AmbientOcclusion)); + let session = &mut harness.state_mut().session; + let second = &mut session.doc.project.texture_sets[1].bake; + *second = BakeSettings::default(); + second.common.is_enabled = false; + second.common.resolution = BakeResolution::R128; + second.maps.select([BakedMap::Height]); + let before = session.doc.project.clone(); + + harness.state_mut().ui.dock.focus(Panel::CommonSettings); + harness.run_steps(3); + click_checkbox(&mut harness, "Apply Diffusion"); + + let mut expected = before.clone(); + for texture_set in &mut expected.texture_sets { + texture_set.bake.common.apply_diffusion = false; + } + assert_eq!(harness.state().session.doc.project, expected); + + harness.get_all_by_value("64").next().unwrap().click(); + harness.run_steps(3); + click(&mut harness, "256"); + for texture_set in &mut expected.texture_sets { + texture_set.bake.common.resolution = BakeResolution::R256; + } + assert_eq!(harness.state().session.doc.project, expected); + + click_checkbox(&mut harness, "Use Low Poly Mesh as High Poly Mesh"); + for texture_set in &mut expected.texture_sets { + texture_set.bake.high_poly.use_low_as_high = true; + } + assert_eq!(harness.state().session.doc.project, expected); +} + +#[test] +fn secondary_rays_edit_from_another_set_updates_all_sets() { + let mut harness = harness(Some(BakedMap::AmbientOcclusion)); + let session = &mut harness.state_mut().session; + session.doc.project.texture_sets[1].bake = BakeSettings::default(); + session.doc.project.texture_sets[1].bake.maps.ao.parameters.rays.rays = 16; + texturecraft_engine::execute(session, "textureSet.select", &serde_json::json!({"ts": 1})).unwrap(); + harness.run_steps(3); + select_map(&mut harness, "Ambient Occlusion"); + let history_steps = harness.state().session.history_labels().len(); + + number_field(&harness, "Secondary Rays").focus(); + harness.run_steps(2); + harness.key_press_modifiers(egui::Modifiers::COMMAND, egui::Key::A); + harness.run_steps(1); + number_field(&harness, "Secondary Rays").type_text("128"); + harness.run_steps(1); + harness.key_press(egui::Key::Enter); + harness.run_steps(3); + + let session = &harness.state().session; + assert_eq!(session.ts(), 1); + for texture_set in &session.doc.project.texture_sets { + assert_eq!(texture_set.bake.maps.ao.parameters.rays.rays, 128); + } + assert_eq!(session.history_labels().len(), history_steps + 1); +} + +#[test] +fn map_selection_stays_per_set() { + let mut harness = harness(Some(BakedMap::AmbientOcclusion)); + let second = harness.state().session.doc.project.texture_sets[1].bake.clone(); + + click_checkbox(&mut harness, "Ambient Occlusion"); + assert!(enabled_maps(&harness).is_empty()); + assert_eq!(harness.state().session.doc.project.texture_sets[1].bake, second); + + click_checkbox(&mut harness, "Check All"); + assert_eq!(enabled_maps(&harness), BakedMap::ALL); + assert_eq!(harness.state().session.doc.project.texture_sets[1].bake, second); +} + +#[test] +fn bake_texture_set_visibility_is_independent_of_bake_selection() { + let mut harness = harness(Some(BakedMap::AmbientOcclusion)); + let before: Vec<_> = harness.state().session.doc.project.texture_sets.iter().map(|texture_set| texture_set.bake.clone()).collect(); + let active_set = harness.state().session.ts(); + + harness.get_all_by_label("Show or hide the texture set").nth(1).unwrap().click(); + harness.run_steps(3); + + let session = &harness.state().session; + assert!(session.doc.project.texture_sets[0].visible); + assert!(!session.doc.project.texture_sets[1].visible); + assert_eq!(session.ts(), active_set); + for (texture_set, settings) in session.doc.project.texture_sets.iter().zip(&before) { + assert_eq!(&texture_set.bake, settings); + } + + harness.get_all_by_label("Show or hide the texture set").nth(1).unwrap().click(); + harness.run_steps(3); + assert!(harness.state().session.doc.project.texture_sets[1].visible); +} + +#[test] +fn texture_set_resolution_controls_are_independent_from_bake_output() { + let mut harness = harness(Some(BakedMap::AmbientOcclusion)); + let before = harness.state().session.doc.project.clone(); + let active_set = harness.state().session.ts(); + harness.get_all_by_value("256 × 256").nth(1).unwrap().click(); + harness.run_steps(3); + click(&mut harness, "128 × 128"); + wait_for_resolution(&mut harness, 1, 128); + + let session = &harness.state().session; + assert_eq!(session.ts(), active_set); + assert_eq!(session.doc.project.texture_sets[0], before.texture_sets[0]); + assert_eq!(session.doc.project.texture_sets[1].bake, before.texture_sets[1].bake); + harness.state_mut().session.undo().unwrap(); + assert_eq!(harness.state().session.doc.project, before); +} + +fn wait_for_resolution(harness: &mut Harness<'_, TextureCraftApp>, texture_set: usize, resolution: u32) { + for _ in 0..100 { + harness.run_steps(1); + if harness.state().session.doc.project.texture_sets[texture_set].resolution == resolution { + return; + } + std::thread::sleep(std::time::Duration::from_millis(5)); + } + panic!("texture set resize did not finish"); +} + +#[test] +fn tile_resolution_overrides_can_be_changed_and_removed_in_bake_mode() { + let session = texturecraft_engine::Session::new_project( + "Tile resolution controls", + texturecraft_engine::geom::primitives::udim_plane(), + "builtin:udim_plane", + None, + 256, + ) + .unwrap(); + let mut harness = Harness::builder().with_size(egui::vec2(1600.0, 1500.0)).build_eframe(|context| TextureCraftApp::new(context, session)); + harness.state_mut().ui.mode = Mode::Baking; + harness.run_steps(4); + let before = harness.state().session.doc.project.clone(); + + assert_eq!(harness.get_all_by_value("256 × 256").count(), 1); + let resolution_position = harness.get_by_label("UV tile 1002 resolution").rect().center(); + harness.hover_at(resolution_position); + harness.run_steps(3); + assert_eq!(harness.get_all_by_value("256 × 256").count(), 2); + harness.hover_at(egui::pos2(900.0, 500.0)); + harness.run_steps(3); + assert_eq!(harness.get_all_by_value("256 × 256").count(), 1); + harness.get_by_label("UV tile 1002 resolution").click(); + harness.run_steps(3); + click(&mut harness, "128 × 128"); + harness.get_by_value("128 × 128*"); + let texture_set = &harness.state().session.doc.project.texture_sets[0]; + assert_eq!(texture_set.resolution, 256); + assert_eq!(texture_set.tile_resolution(1001), 256); + assert_eq!(texture_set.tile_resolution(1002), 128); + assert_eq!(texture_set.bake, before.texture_sets[0].bake); + + harness.get_by_value("128 × 128*").click(); + harness.run_steps(3); + click(&mut harness, "Remove resolution override"); + assert_eq!(harness.state().session.doc.project, before); + assert!(harness.query_by_value("128 × 128*").is_none()); + assert_eq!(harness.get_all_by_value("256 × 256").count(), 1); + harness.state_mut().session.undo().unwrap(); + harness.run_steps(3); + harness.get_by_value("128 × 128*"); + + harness.state_mut().ui.dock.focus(Panel::CommonSettings); + harness.run_steps(3); + harness.get_all_by_value("2048").next().unwrap().click(); + harness.run_steps(3); + click(&mut harness, "64"); + let texture_set = &harness.state().session.doc.project.texture_sets[0]; + assert_eq!(texture_set.resolution, 256); + assert_eq!(texture_set.tile_resolution(1002), 128); + assert_eq!(texture_set.bake.common.resolution, BakeResolution::R64); +} + +#[test] +fn bake_texture_sets_list_uv_tiles_and_their_resolutions() { + let mut session = + texturecraft_engine::Session::new_project("UV tile list", texturecraft_engine::geom::primitives::udim_plane(), "builtin:udim_plane", None, 256) + .unwrap(); + texturecraft_engine::execute(&mut session, "textureSet.tile.resolution", &serde_json::json!({"tile": 1002, "resolution": 128})).unwrap(); + let before = session.doc.project.clone(); + let mut harness = Harness::builder().with_size(egui::vec2(1600.0, 1500.0)).build_eframe(|context| TextureCraftApp::new(context, session)); + harness.state_mut().ui.mode = Mode::Baking; + harness.run_steps(4); + + harness.get_by_label("1001"); + harness.get_by_value("256 × 256"); + harness.get_by_label("1002"); + harness.get_by_value("128 × 128*"); + click_checkbox(&mut harness, "1002"); + assert!(harness.state().session.doc.project.texture_sets[0].bake_excluded_tiles.contains(&1002)); + assert!(!harness.get_by_label("Bake Selected Textures (1)").accesskit_node().is_disabled()); + click_checkbox(&mut harness, "1001"); + assert!(harness.get_by_label("Bake Selected Textures (0)").accesskit_node().is_disabled()); + harness.state_mut().session.undo().unwrap(); + harness.state_mut().session.undo().unwrap(); + harness.run_steps(3); + click(&mut harness, "UV tiles (UDIM) (2)"); + assert!(harness.query_by_label("1001").is_none()); + assert!(harness.query_by_label("1002").is_none()); + assert_eq!(harness.state().session.doc.project, before); +} + +#[test] +fn restoring_map_defaults_updates_other_sets_even_when_active_values_are_default() { + let mut harness = harness(Some(BakedMap::AmbientOcclusion)); + let session = &mut harness.state_mut().session; + let second = &mut session.doc.project.texture_sets[1].bake; + *second = BakeSettings::default(); + second.common.is_enabled = false; + second.maps.ao.is_enabled = false; + second.maps.ao.parameters.rays.rays = 16; + second.maps.ao.parameters.ground_plane.offset = 3.0; + let before = session.doc.project.clone(); + + click(&mut harness, "Restore Defaults"); + + let mut expected = before.clone(); + expected.texture_sets[1].bake.maps.ao.parameters = BakeSettings::default().maps.ao.parameters; + let session = &mut harness.state_mut().session; + assert_eq!(session.doc.project, expected); + session.undo().unwrap(); + assert_eq!(session.doc.project, before); +} + +#[test] +fn restoring_common_defaults_keeps_each_sets_inclusion_and_maps() { + let mut harness = harness(Some(BakedMap::AmbientOcclusion)); + let session = &mut harness.state_mut().session; + session.doc.project.texture_sets[0].bake.common = Default::default(); + let second = &mut session.doc.project.texture_sets[1].bake; + *second = BakeSettings::default(); + second.common.is_enabled = false; + second.common.resolution = BakeResolution::R128; + second.common.resolution_height = Some(BakeResolution::R256); + second.common.apply_diffusion = false; + second.maps.select([BakedMap::Height]); + second.high_poly.low_suffix = "_custom_low".into(); + let before = session.doc.project.clone(); + + harness.state_mut().ui.dock.focus(Panel::CommonSettings); + harness.run_steps(3); + harness.get_all_by_role_and_label(Role::Button, "Restore Defaults").next().unwrap().click(); + harness.run_steps(3); + + let mut expected = before.clone(); + expected.texture_sets[1].bake.common = Default::default(); + expected.texture_sets[1].bake.common.is_enabled = false; + let session = &mut harness.state_mut().session; + assert_eq!(session.doc.project, expected); + session.undo().unwrap(); + assert_eq!(session.doc.project, before); +} + #[test] fn output_axes_unlock_independently_and_relock_to_width() { let mut harness = harness(None); diff --git a/crates/ui-egui/tests/shelf_hover_preview.rs b/crates/ui-egui/tests/shelf_hover_preview.rs index 3c829739..1bb9a4d7 100644 --- a/crates/ui-egui/tests/shelf_hover_preview.rs +++ b/crates/ui-egui/tests/shelf_hover_preview.rs @@ -23,9 +23,13 @@ const WORKER_TIMEOUT: Duration = Duration::from_secs(60); /// The app on the Materials tab, `step_seconds` per frame, and two materials whose names show /// nowhere else. -fn materials_shelf(step_seconds: f32) -> (Harness<'static, TextureCraftApp>, Vec<&'static SmartMaterial>) { +fn materials_shelf(step_seconds: f32, pixels_per_point: f32) -> (Harness<'static, TextureCraftApp>, Vec<&'static SmartMaterial>) { let session = texturecraft_engine::sample_session(256, 64).unwrap(); - let mut h = Harness::builder().with_size(egui::vec2(1600.0, 960.0)).with_step_dt(step_seconds).build_eframe(|cc| TextureCraftApp::new(cc, session)); + let mut h = Harness::builder() + .with_size(egui::vec2(1600.0, 960.0)) + .with_step_dt(step_seconds) + .with_pixels_per_point(pixels_per_point) + .build_eframe(|cc| TextureCraftApp::new(cc, session)); h.state_mut().ui.shelf_tab = MATERIALS_TAB; h.run_steps(4); @@ -55,7 +59,7 @@ fn big_preview_ready(h: &mut Harness<'static, TextureCraftApp>, material: &Smart #[test] fn hovering_a_shelf_tile_shows_its_big_preview() { - let (mut h, materials) = materials_shelf(1.0 / 4.0); + let (mut h, materials) = materials_shelf(1.0 / 4.0, 1.0); let material = materials[0]; let tile = h.get_by_label(material.label).rect(); assert!(largest_drawn_texture(&h, BIG_PREVIEW_SIZE).is_none(), "nothing big before the hover"); @@ -77,7 +81,7 @@ fn hovering_a_shelf_tile_shows_its_big_preview() { #[test] fn the_big_preview_renders_after_a_rest_but_not_during_a_sweep() { - let (mut h, materials) = materials_shelf(STEP_SECONDS); + let (mut h, materials) = materials_shelf(STEP_SECONDS, 1.0); let (first, second) = (materials[0], materials[1]); let (from, to) = (h.get_by_label(first.label).rect().center(), h.get_by_label(second.label).rect().center()); @@ -114,10 +118,10 @@ fn high_dpi_smart_mask_hover_stays_within_the_renderer_limit() { use texturecraft_engine::mask_preview::MAX_PREVIEW_SIZE_PX; use texturecraft_engine::smart_masks::SMART_MASKS; - let (mut harness, _) = materials_shelf(1.0 / 4.0); - harness.ctx.set_pixels_per_point(3.0); + let (mut harness, _) = materials_shelf(1.0 / 4.0, 3.0); harness.state_mut().ui.shelf_tab = 2; harness.run_steps(4); + assert_eq!(harness.ctx.pixels_per_point(), 3.0, "the test uses the native 300% display scale"); harness.get_by_label(SMART_MASKS[0].label).hover(); let expected = Some([MAX_PREVIEW_SIZE_PX; 2]); diff --git a/crates/ui-egui/tests/ui_snapshots.rs b/crates/ui-egui/tests/ui_snapshots.rs index 54e942cc..4b40d7e9 100644 --- a/crates/ui-egui/tests/ui_snapshots.rs +++ b/crates/ui-egui/tests/ui_snapshots.rs @@ -161,6 +161,51 @@ fn window_snapshots() { harness.event(egui::Event::ModifiersChanged(egui::Modifiers::NONE)); } +#[test] +#[ignore] +fn bake_uv_tiles_snapshot() { + let Some(output_dir) = std::env::var_os("TC_UI_SNAPSHOTS").map(PathBuf::from) else { + eprintln!("set TC_UI_SNAPSHOTS= to write the pictures"); + return; + }; + + std::fs::create_dir_all(&output_dir).unwrap(); + let mut session = + texturecraft_engine::Session::new_project("UV tile baking", texturecraft_engine::geom::primitives::udim_plane(), "builtin:udim_plane", None, 256) + .unwrap(); + texturecraft_engine::execute(&mut session, "textureSet.tile.resolution", &serde_json::json!({"tile": 1002, "resolution": 128})).unwrap(); + let mut harness = Harness::builder() + .with_size(egui::vec2(1600.0, 960.0)) + .with_pixels_per_point(1.0) + .wgpu() + .build_eframe(|context| TextureCraftApp::new(context, session)); + harness.state_mut().ui.mode = Mode::Baking; + save(&mut harness, &output_dir, "bake-uv-tiles"); + + harness.get_by_value("128 × 128*").click(); + save(&mut harness, &output_dir, "bake-tile-resolution-menu"); + harness.get_by_label("Remove resolution override").click(); + save(&mut harness, &output_dir, "bake-tile-resolution-inherited"); + assert!(harness.query_by_value("128 × 128*").is_none()); + assert!(harness.state().session.doc.project.texture_sets[0].tile_resolutions.is_empty()); + let inherited_resolution = harness.get_by_label("UV tile 1002 resolution").rect().center(); + harness.hover_at(inherited_resolution); + save(&mut harness, &output_dir, "bake-tile-resolution-hover"); + assert_eq!(harness.get_all_by_value("256 × 256").count(), 2); + harness.hover_at(egui::pos2(900.0, 500.0)); + harness.state_mut().session.undo().unwrap(); + harness.run_steps(3); + + harness.get_by_role_and_label(egui::Role::CheckBox, "1002").click(); + save(&mut harness, &output_dir, "bake-uv-tiles-partial"); + assert!(harness.state().session.doc.project.texture_sets[0].bake_excluded_tiles.contains(&1002)); + + harness.get_by_label("Show or hide the texture set").click(); + save(&mut harness, &output_dir, "bake-uv-tiles-hidden"); + assert!(!harness.state().session.doc.project.texture_sets[0].visible); + assert!(harness.state().session.doc.project.texture_sets[0].bake.common.is_enabled); +} + #[test] #[ignore] fn smart_mask_shelf_snapshot() { diff --git a/docs/control-protocol.md b/docs/control-protocol.md index 74322c74..78707aa1 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -24,6 +24,39 @@ as the history reaches); `edit.history` lists the steps done and the undone ones Any command takes `merge: true` to fold its edit into the previous undo step when that step has the same label: a drag that applies a value on every frame stays one step. +Bake mode applies edits in Common Settings and Mesh Map Settings to every texture set. Each +set keeps its own enabled mesh-map checkboxes and Include in Bake flag. Edits update only the +changed fields; Restore Defaults resets the whole parameter section across all sets. + +`bake.settings {ts: "all", patch: {maps: {ao: {parameters: {rays: {rays: 128}}}}}}` changes +only AO secondary rays. A `patch` uses the nested `BakeSettings` field names and named enum +values returned in the command's `model` result; omitted fields retain each set's values, and +`null` clears optional fields such as `common.resolution_height`. All targeted sets are validated +before the edit is applied as one undo step. `model` still replaces the complete settings; +when combined, `patch` follows `model`, then the flat command parameters apply. Omitting `ts` +still targets the active set for scripts that need individual control. + +The bake texture-set list shows visibility eyes and expandable UV tile rows. Visibility affects +the viewport independently of bake inclusion. Its resolution menus edit the texture-set size +(`textureSet.resolution`) and individual tile overrides (`textureSet.tile.resolution`), independently +of Common Settings' bake Output Size. Overridden tiles display a resolution marked with an asterisk; +inherited tile resolutions appear only on hover or while their menu is open. Remove resolution +override hides the number and restores inheritance from the set, including when their current +sizes happen to match. + +Baked maps use a uniform UV tile atlas: every selected tile receives the full bake Output Size, +including rectangular output sizes. Changing a texture-set or tile working resolution preserves +the stored bake pixels. Materials, mesh-map previews, and exports sample those pixels through +the working tile layout. Older project files load their baked pixels as-is without layout +conversion; rebaking restores correct mapping and detail. + +`bake.tile.set {ts?, tile: 1002, enabled: false}` +excludes one UV tile; `textureSet.inspect` / `session.inspect` expose each tile's `bakeEnabled`. +Tile choices are saved and undoable. Unchecked tiles retain their previous baked pixels, resampled +if output size changes, or neutral values when no previous map exists. A running bake uses the +tile selection captured when its worker started. Sets with no checked tiles are skipped; their +geometry still contributes to occlusion when baking other tiles. + ## Control channel (desktop app) ```sh