GitCorner

Code

ossartcrafttexturecraft🌐
d84914ef1e5a
use std::sync::Arc;

use texturecraft_core::{BakedMap, Effect, EffectKind, Fill, Layer, LayerKind, Mask, MaskBackground, TextureSet};

use super::*;

struct Sample {
    pf: ProjectFile,
    paint: LayerId,
}

fn sample() -> Sample {
    let mut p = Project::new("Demo", "mesh.glb");
    p.texture_sets.push(TextureSet::new("A", 0, 128));
    p.texture_sets.push(TextureSet::new("B", 1, 64));
    let layer = Layer::new(p.alloc_id(), "Paint", LayerKind::Paint, &Channel::DEFAULT_SET);
    let paint = p.insert_layer(0, layer, None, false).unwrap();
    let mut masked = Layer::new(p.alloc_id(), "Masked", LayerKind::Fill(Fill::default()), &Channel::DEFAULT_SET);
    let effect = p.alloc_id();
    masked.mask = Some(Mask { effects: vec![Effect::new(effect, EffectKind::Paint)], ..Mask::new(MaskBackground::Black) });
    p.insert_layer(1, masked, None, false).unwrap();
    let mut pixels = PixelStore::default();
    let img = pixels.layer_mut(paint, Channel::BaseColor, (128, 128));
    img.set(0, 0, &[1, 2, 3, 4]);
    img.set(127, 127, &[65535, 0, 9, 65535]);
    pixels.layer_mut(paint, Channel::Height, (128, 128)).set(70, 3, &[40000, 65535]);
    pixels.mask_mut(effect, (64, 64)).set(10, 60, &[30000, 65535]);
    let ao: Vec<f32> = (0..256).map(|i| i as f32 / 255.0).collect();
    let baked = BakedMaps { resolution: 16, maps: [(BakedMap::AmbientOcclusion, Arc::new(ao)), (BakedMap::Normal, Arc::new(vec![0.5; 16 * 16 * 3]))].into() };
    let pf = ProjectFile {
        project: p,
        pixels,
        baked: [(0, baked)].into(),
        mesh: Some(("glb".into(), vec![1, 2, 3, 4, 5])),
        high_poly: vec![("b_high.obj".into(), vec![7; 9]), ("a_high.ply".into(), vec![6])],
        cage: Some(("cage.obj".into(), vec![5, 5])),
        bake_paint: [((0, texturecraft_core::BakePaintTarget::Skew), BakePaintData { width: 3, height: 2, values: vec![0.0, 0.25, 0.5, 0.75, 1.0, 0.125] })]
            .into(),
        thumbnail: Some(vec![137, 80, 78, 71]),
        resources: [("bricks.png".to_string(), vec![9, 8, 7])].into(),
        warnings: Vec::new(),
    };
    Sample { pf, paint }
}

fn assert_same(a: &ProjectFile, b: &ProjectFile) {
    assert_eq!(a.project, b.project);
    assert_eq!(a.pixels.layers.len(), b.pixels.layers.len());
    for (k, img) in &a.pixels.layers {
        assert_eq!(Some(img), b.pixels.layers.get(k), "{k:?}");
    }
    assert_eq!(a.pixels.masks.len(), b.pixels.masks.len());
    for (k, img) in &a.pixels.masks {
        assert_eq!(Some(img), b.pixels.masks.get(k), "{k:?}");
    }
    assert_eq!(a.baked, b.baked);
    assert_eq!(a.mesh, b.mesh);
    assert_eq!((&a.high_poly, &a.cage), (&b.high_poly, &b.cage), "bake meshes keep their order");
    assert_eq!(a.bake_paint, b.bake_paint);
    assert_eq!(a.thumbnail, b.thumbnail);
    assert_eq!(a.resources, b.resources);
}

fn is_guard_error(e: &FormatError) -> bool {
    e.to_string().contains("parser failed")
}

#[test]
fn round_trip_is_identical_and_deterministic() {
    let s = sample();
    let bytes = save_project_bytes(&s.pf).unwrap();
    let back = load_project_bytes(&bytes).unwrap();
    assert!(back.warnings.is_empty());
    assert_same(&s.pf, &back);
    assert_eq!(back.pixels.layer(s.paint, Channel::BaseColor).unwrap().get(127, 127), [65535, 0, 9, 65535]);
    assert_eq!(save_project_bytes(&back).unwrap(), bytes);
    // Built-in mesh projects carry no mesh entry.
    let mut builtin = s.pf.clone();
    builtin.mesh = None;
    builtin.thumbnail = None;
    builtin.project.mesh = "builtin:sphere".into();
    assert_same(&builtin, &load_project_bytes(&save_project_bytes(&builtin).unwrap()).unwrap());
}

#[test]
fn shared_project_schema_round_trips_the_app_document() {
    let project = sample().pf.project;
    let original = serde_json::to_value(&project).unwrap();
    let document: craft_tcraft::ProjectDocument = serde_json::from_value(original.clone()).unwrap();
    assert_eq!(document.format_version, project.format_version);
    assert_eq!(serde_json::to_value(document).unwrap(), original);
}

#[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<f32> = (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);
}

#[test]
fn a_bent_normal_declared_without_pixels_in_an_older_project_is_dropped_and_reported() {
    let mut sample = sample();
    sample.pf.project.texture_sets[0].baked.insert(BakedMap::BentNormal);
    assert!(!sample.pf.baked[&0].maps.contains_key(&BakedMap::BentNormal));
    sample.pf.project.format_version = TANGENT_BENT_NORMAL_VERSION - 1;
    let older = load_project_bytes(&save_project_bytes(&sample.pf).unwrap()).unwrap();
    assert!(!older.project.texture_sets[0].baked.contains(&BakedMap::BentNormal));
    assert_eq!(older.warnings.len(), 1, "{:?}", older.warnings);
    assert!(older.warnings[0].contains("\"A\""), "{}", older.warnings[0]);
}

#[test]
fn a_bent_normal_with_pixels_but_no_declaration_in_an_older_project_is_dropped_and_reported() {
    let mut sample = sample();
    let bent = Arc::new([0.5, 1.0, 0.5].repeat(16 * 16));
    sample.pf.baked.get_mut(&0).unwrap().maps.insert(BakedMap::BentNormal, bent);
    assert!(!sample.pf.project.texture_sets[0].baked.contains(&BakedMap::BentNormal));
    sample.pf.project.format_version = TANGENT_BENT_NORMAL_VERSION - 1;
    let older = load_project_bytes(&save_project_bytes(&sample.pf).unwrap()).unwrap();
    assert!(!older.baked[&0].maps.contains_key(&BakedMap::BentNormal));
    assert_eq!(older.warnings.len(), 1, "{:?}", older.warnings);
    assert!(older.warnings[0].contains("\"A\""), "{}", older.warnings[0]);
}

#[test]
fn world_space_bent_normals_of_older_projects_are_dropped_for_a_rebake() {
    let mut sample = sample();
    let bent = Arc::new([0.5, 1.0, 0.5].repeat(16 * 16));
    sample.pf.baked.get_mut(&0).unwrap().maps.insert(BakedMap::BentNormal, bent);
    sample.pf.project.texture_sets[0].baked.insert(BakedMap::BentNormal);

    // A current project keeps its tangent-space bent normals
    let current = load_project_bytes(&save_project_bytes(&sample.pf).unwrap()).unwrap();
    assert!(current.warnings.is_empty(), "{:?}", current.warnings);
    assert_same(&sample.pf, &current);

    // One saved before tangent space held world vectors: they go, the other maps stay
    sample.pf.project.format_version = TANGENT_BENT_NORMAL_VERSION - 1;
    let older = load_project_bytes(&save_project_bytes(&sample.pf).unwrap()).unwrap();
    assert_eq!(older.warnings.len(), 1, "{:?}", older.warnings);
    assert!(older.warnings[0].contains("\"A\"") && older.warnings[0].contains("Bent Normals"), "{}", older.warnings[0]);
    let maps = &older.baked[&0].maps;
    assert!(!maps.contains_key(&BakedMap::BentNormal));
    assert!(maps.contains_key(&BakedMap::AmbientOcclusion) && maps.contains_key(&BakedMap::Normal));
    assert!(!older.project.texture_sets[0].baked.contains(&BakedMap::BentNormal));
    assert_eq!(older.project.texture_sets[0].bake, sample.pf.project.texture_sets[0].bake, "the bake settings stay for the re-bake");

    // Saved again, the project is current and opens without the warning
    let reopened = load_project_bytes(&save_project_bytes(&older).unwrap()).unwrap();
    assert!(reopened.warnings.is_empty(), "{:?}", reopened.warnings);
    assert_same(&older, &reopened);
}

#[cfg(not(target_arch = "wasm32"))]
#[test]
fn save_and_load_through_files() {
    let s = sample();
    let dir = std::env::temp_dir().join(format!("tc-formats-project-{}", std::process::id()));
    std::fs::create_dir_all(&dir).unwrap();
    let path = dir.join("demo.tcraft");
    save_project(&path, &s.pf).unwrap();
    save_project(&path, &s.pf).unwrap(); // overwrite in place
    assert!(!dir.join("demo.tcraft.tmp").exists());
    assert_same(&s.pf, &load_project(&path).unwrap());
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn newer_format_is_refused() {
    let mut s = sample();
    s.pf.project.format_version = FORMAT_VERSION + 1;
    let err = load_project_bytes(&save_project_bytes(&s.pf).unwrap()).unwrap_err();
    assert!(matches!(err, FormatError::NewerVersion { found, .. } if found == FORMAT_VERSION + 1), "{err}");
    assert!(err.to_string().contains("newer"));
}

#[test]
fn malformed_project_files_are_errors() {
    let bytes = save_project_bytes(&sample().pf).unwrap();
    for len in 0..bytes.len() {
        let e = load_project_bytes(&bytes[..len]).unwrap_err();
        assert!(!is_guard_error(&e), "prefix {len}: {e}");
    }
    for i in (0..bytes.len()).step_by(3) {
        let mut b = bytes.clone();
        b[i] ^= 0x5A;
        if let Err(e) = load_project_bytes(&b) {
            assert!(!is_guard_error(&e), "flip at {i}: {e}");
        }
    }
    assert!(load_project_bytes(b"PK\x03\x04 definitely not a zip").is_err());
}

/// A project zip with `project.json` from `sample()` plus raw extra entries.
fn zip_with(entries: &[(&str, Vec<u8>)]) -> Vec<u8> {
    let s = sample();
    let mut zip = ZipWriter::new(Cursor::new(Vec::new()));
    zip.start_file("project.json", SimpleFileOptions::default()).unwrap();
    zip.write_all(&serde_json::to_vec(&s.pf.project).unwrap()).unwrap();
    for (name, data) in entries {
        zip.start_file(*name, SimpleFileOptions::default()).unwrap();
        zip.write_all(data).unwrap();
    }
    zip.finish().unwrap().into_inner()
}

fn tile_bin(res: u32, comps: usize, tiles: &[(u32, u32)]) -> Vec<u8> {
    let mut b = header(res, res, comps, tiles.len());
    for (tx, ty) in tiles {
        b.extend(tx.to_le_bytes());
        b.extend(ty.to_le_bytes());
        b.extend(vec![7u8; TILE_AREA * comps * 2]);
    }
    b
}

#[test]
fn tiles_are_validated_against_the_texture_set() {
    let paint = sample().paint;
    let name = format!("pixels/layer_{}_baseColor.bin", paint.0);
    let ok = load_project_bytes(&zip_with(&[(&name, tile_bin(128, 4, &[(1, 1)]))])).unwrap();
    assert_eq!(ok.pixels.layer(paint, Channel::BaseColor).unwrap().get(64, 64), [0x0707; 4]);
    for (what, bin) in [
        ("tile out of range", tile_bin(128, 4, &[(2, 0)])),
        ("repeated tile", tile_bin(128, 4, &[(0, 0), (0, 0)])),
        ("wrong resolution", tile_bin(64, 4, &[(0, 0)])),
        ("wrong components", tile_bin(128, 3, &[(0, 0)])),
        ("truncated", tile_bin(128, 4, &[(0, 0)])[..100].to_vec()),
        ("trailing data", [tile_bin(128, 4, &[]), vec![1]].concat()),
    ] {
        assert!(load_project_bytes(&zip_with(&[(&name, bin)])).is_err(), "{what}");
    }
    let mut newer = tile_bin(128, 4, &[]);
    newer[4] = 9;
    assert!(matches!(load_project_bytes(&zip_with(&[(&name, newer)])), Err(FormatError::NewerVersion { .. })));
    // Pixels of a layer that is in no stack are dropped, not an error.
    let orphan = load_project_bytes(&zip_with(&[("pixels/layer_999_baseColor.bin", tile_bin(128, 4, &[(0, 0)]))])).unwrap();
    assert!(orphan.pixels.layers.is_empty());
    assert!(load_project_bytes(&zip_with(&[("pixels/layer_x_baseColor.bin", vec![])])).is_err());
    assert!(load_project_bytes(&zip_with(&[("baked/0_ambientOcclusion.bin", header(16, 16, 1, 0))])).is_err());
    assert!(load_project_bytes(&zip_with(&[("baked/0_ambientOcclusion.bin", header(100_000, 100_000, 1, 0))])).is_err());
}

#[test]
fn uv_tiled_sets_round_trip_their_atlas_pixels_and_bakes() {
    let mut s = sample();
    s.pf.project.texture_sets[0].uv_tiles = vec![1001, 1002];
    let mut pixels = PixelStore::default();
    pixels.layer_mut(s.paint, Channel::BaseColor, (256, 128)).set(200, 100, &[1, 2, 3, 4]);
    s.pf.pixels = pixels;
    let baked = BakedMaps { resolution: 32, maps: [(BakedMap::AmbientOcclusion, Arc::new(vec![0.25; 32 * 16]))].into() };
    s.pf.baked = [(0, baked)].into();
    let back = load_project_bytes(&save_project_bytes(&s.pf).unwrap()).unwrap();
    assert_same(&s.pf, &back);
    assert_eq!(back.baked[&0].height(BakedMap::AmbientOcclusion), 16);
    assert_eq!(back.pixels.layer(s.paint, Channel::BaseColor).unwrap().get(200, 100), [1, 2, 3, 4]);
    // A square image no longer fits the tiled set.
    let mut square = s.pf.clone();
    square.project.texture_sets[0].uv_tiles.clear();
    assert!(load_project_bytes(&save_project_bytes(&square).unwrap()).is_err());
}

#[test]
fn duplicate_entry_names_are_made_unique_on_save() {
    let mut pf = sample().pf;
    pf.high_poly = vec![("model.obj".into(), vec![1]), ("model.obj".into(), vec![2])];
    pf.resources = [("a b".to_string(), vec![3]), ("a_b".to_string(), vec![4])].into();
    let bytes = save_project_bytes(&pf).expect("save with duplicate entry names");
    let back = load_project_bytes(&bytes).unwrap();
    assert_eq!(back.high_poly.len(), 2);
    let mut hp: Vec<_> = back.high_poly.iter().map(|(_, b)| b.clone()).collect();
    hp.sort();
    assert_eq!(hp, vec![vec![1], vec![2]]);
    assert_eq!(back.resources.len(), 2);
    let mut res: Vec<_> = back.resources.values().cloned().collect();
    res.sort();
    assert_eq!(res, vec![vec![3], vec![4]]);
}

/// Every entry of a zip in file order: (name, method, crc, sizes, the compressed bytes as stored).
/// The zip headers around them (version fields, zip64 size placeholders) are not part of this:
/// copying an entry between zips rewrites them.
#[allow(clippy::type_complexity)]
fn payloads(zip: &[u8]) -> Vec<(String, CompressionMethod, u32, u64, u64, Vec<u8>)> {
    let mut a = ZipArchive::new(Cursor::new(zip)).unwrap();
    (0..a.len())
        .map(|i| {
            let mut f = a.by_index_raw(i).unwrap();
            let mut raw = Vec::new();
            f.read_to_end(&mut raw).unwrap();
            (f.name().unwrap().into_owned(), f.compression(), f.crc32(), f.size(), f.compressed_size(), raw)
        })
        .collect()
}

/// A project with several baked maps and pixel layers, big enough that entries stream in chunks.
fn big_sample() -> ProjectFile {
    let mut s = sample();
    let mut x = 12345u32;
    let mut noise = |n: usize| -> Vec<f32> {
        (0..n)
            .map(|i| {
                x = x.wrapping_mul(1664525).wrapping_add(1013904223);
                (i as f32 * 0.001).sin() * 0.5 + 0.5 + (x >> 24) as f32 * 1e-4
            })
            .collect()
    };
    let r = 300usize;
    let maps = [BakedMap::AmbientOcclusion, BakedMap::Normal, BakedMap::Curvature, BakedMap::Position]
        .into_iter()
        .map(|m| (m, Arc::new(noise(r * r * m.components()))))
        .collect();
    s.pf.baked.insert(1, BakedMaps { resolution: r as u32, maps });
    s.pf.mesh = Some(("obj".into(), noise(5000).iter().map(|v| (v * 200.0) as u8).collect()));
    s.pf
}

fn serial_bytes(pf: &ProjectFile) -> Vec<u8> {
    let mut zip = ZipWriter::new(Cursor::new(Vec::new()));
    entries::write_serial(&mut zip, entries(pf).unwrap()).unwrap();
    zip.finish().unwrap().into_inner()
}

#[cfg(not(target_arch = "wasm32"))]
fn parallel_bytes(pf: &ProjectFile, workers: usize, budget: u64) -> Vec<u8> {
    let mut zip = ZipWriter::new(Cursor::new(Vec::new()));
    entries::parallel::write(&mut zip, entries(pf).unwrap(), workers, budget).unwrap();
    zip.finish().unwrap().into_inner()
}

#[test]
#[cfg(not(target_arch = "wasm32"))]
fn save_plan_follows_the_reserved_cores_and_the_ram_share() {
    // No cap of 8 workers any more, only the entry count and the cores.
    assert_eq!(entries::plan(64, 1, 100, 1000, 50), (63, 500));
    assert_eq!(entries::plan(64, 1, 20, 1000, 50).0, 20);
    // 0 reserved uses every core; more reserved than cores still leaves one worker.
    assert_eq!(entries::plan(16, 0, 100, 1000, 100), (16, 1000));
    assert_eq!(entries::plan(4, 9, 100, 1000, 100).0, 1);
    assert_eq!(entries::plan(1, 0, 100, 1000, 100).0, 1);
    // The share is of the RAM given, clamped to 1..=100 percent, and never overflows.
    assert_eq!(entries::plan(2, 1, 5, 1000, 0).1, 10);
    assert_eq!(entries::plan(2, 1, 5, 1000, 250).1, 1000);
    assert_eq!(entries::plan(2, 1, 5, u64::MAX, 100).1, u64::MAX);
    assert_eq!(entries::plan(2, 1, 5, u64::MAX, 50).1, u64::MAX / 2);
}

#[test]
#[cfg(not(target_arch = "wasm32"))]
fn parallel_save_with_any_reserved_cores_and_ram_share_matches_serial() {
    let pf = big_sample();
    let want = payloads(&serial_bytes(&pf));
    let n = want.len();
    // (cpus, reserved cores, available RAM, percent): none reserved, all reserved, a tiny and a huge share.
    for (cpus, reserved, ram, percent) in [(8, 0, 1u64 << 40, 100u8), (8, 1, 1 << 40, 50), (8, 99, 1 << 40, 50), (16, 0, 1000, 1), (6, 1, u64::MAX, 100)] {
        let (workers, budget) = entries::plan(cpus, reserved, n, ram, percent);
        let got = parallel_bytes(&pf, workers, budget);
        assert!(payloads(&got) == want, "{cpus} cpus, {reserved} reserved, {ram} bytes at {percent}%");
        assert_same(&pf, &load_project_bytes(&got).unwrap());
    }
    // The setting is read by the public save; extreme values still save the same entries.
    for (reserved, percent) in [(0, 100), (1000, 1), (1, 50)] {
        set_save_resources(reserved, percent);
        assert!(payloads(&save_project_bytes(&pf).unwrap()) == want, "{reserved} reserved, {percent}%");
    }
    set_save_resources(DEFAULT_RESERVED_CORES, DEFAULT_RAM_PERCENT);
}

#[test]
#[cfg(not(target_arch = "wasm32"))]
fn parallel_save_writes_the_same_entries_as_serial() {
    let pf = big_sample();
    let serial = serial_bytes(&pf);
    let want = payloads(&serial);
    assert!(want.len() > 10);
    for (workers, budget) in [(0, 1), (2, u64::MAX), (4, u64::MAX), (8, 1), (3, 100_000)] {
        let got = parallel_bytes(&pf, workers, budget);
        assert!(payloads(&got) == want, "{workers} workers, budget {budget}");
        assert_same(&pf, &load_project_bytes(&got).unwrap());
    }
    // The public entry point (threads chosen by the machine) agrees too, and loads back.
    assert!(payloads(&save_project_bytes(&pf).unwrap()) == want);
    assert_same(&pf, &load_project_bytes(&serial).unwrap());
}

/// The files written before entries were compressed in parallel: each entry written in one go.
fn reference_one_shot(pf: &ProjectFile) -> Vec<u8> {
    let deflate = SimpleFileOptions::default().compression_method(CompressionMethod::Deflated).large_file(true);
    let mut zip = ZipWriter::new(Cursor::new(Vec::new()));
    zip.start_file("project.json", deflate).unwrap();
    zip.write_all(&serde_json::to_vec_pretty(&pf.project).unwrap()).unwrap();
    for (ts, maps) in &pf.baked {
        for (m, data) in &maps.maps {
            zip.start_file(format!("baked/{ts}_{}.bin", m.id()), deflate).unwrap();
            zip.write_all(&header(maps.resolution, maps.height(*m), m.components(), 0)).unwrap();
            let bytes: Vec<u8> = data.iter().flat_map(|v| v.to_le_bytes()).collect();
            zip.write_all(&bytes).unwrap();
        }
    }
    zip.finish().unwrap().into_inner()
}

/// Streaming a baked map into the compressor in chunks may place deflate block boundaries a few
/// bytes differently than one big write, so the stored bytes can differ slightly; what the entry
/// holds (name, method, CRC, size) must not, and the compressed size stays within 0.01%.
#[test]
fn baked_entries_hold_what_the_one_shot_writer_wrote() {
    let mut pf = big_sample();
    (pf.mesh, pf.high_poly, pf.cage, pf.bake_paint, pf.thumbnail, pf.resources) = (None, vec![], None, BTreeMap::new(), None, BTreeMap::new());
    pf.pixels = PixelStore::default();
    let (new, old) = (payloads(&save_project_bytes(&pf).unwrap()), payloads(&reference_one_shot(&pf)));
    assert_eq!(new.len(), old.len());
    for (n, o) in new.iter().zip(&old) {
        assert_eq!((&n.0, n.1, n.2, n.3), (&o.0, o.1, o.2, o.3));
        assert!(n.4.abs_diff(o.4) <= 64 + o.4 / 10_000, "{}: {} vs {}", n.0, n.4, o.4);
    }
}

#[test]
fn bake_model_options_survive_the_project_archive() {
    use texturecraft_core::{BackfaceMode, CageType, HeightNormalization};

    let mut project_file = sample().pf;
    let settings = &mut project_file.project.texture_sets[0].bake;
    settings.common.resolution_height = Some(texturecraft_core::BakeResolution::R256);
    settings.cage.kind = CageType::CustomFile;
    settings.maps.ao.parameters.ignore_backface = BackfaceMode::ByMeshName;
    settings.maps.ao.parameters.rays.min_distance = 0.02;
    settings.maps.ao.parameters.ground_plane.enabled = true;
    settings.maps.curvature.parameters.mesh.sampling_radius = 0.002;
    settings.maps.height.parameters.normalization = HeightNormalization::Manual;
    settings.maps.height.parameters.scaling_divisor = 4.0;
    settings.skew.edge_protection = true;
    settings.skew.edge_distance = 0.3;

    let bytes = save_project_bytes(&project_file).unwrap();
    assert_same(&project_file, &load_project_bytes(&bytes).unwrap());
}

fn edit_archive(project_file: &ProjectFile, mut edit: impl FnMut(&mut String, &mut Vec<u8>)) -> Vec<u8> {
    let bytes = save_project_bytes(project_file).unwrap();
    let mut source = ZipArchive::new(Cursor::new(bytes)).unwrap();
    let mut output = ZipWriter::new(Cursor::new(Vec::new()));

    for index in 0..source.len() {
        let mut entry = source.by_index(index).unwrap();
        let mut name = entry.name().unwrap().into_owned();
        let mut data = Vec::new();
        entry.read_to_end(&mut data).unwrap();
        edit(&mut name, &mut data);
        output.start_file(name, SimpleFileOptions::default()).unwrap();
        output.write_all(&data).unwrap();
    }

    output.finish().unwrap().into_inner()
}

fn edit_project_json(project_file: &ProjectFile, mut edit: impl FnMut(&mut serde_json::Value)) -> Vec<u8> {
    edit_archive(project_file, |name, data| {
        if name == "project.json" {
            let mut json = serde_json::from_slice(data).unwrap();
            edit(&mut json);
            *data = serde_json::to_vec(&json).unwrap();
        }
    })
}

#[test]
fn recovery_loads_legacy_bake_settings_and_map_names() {
    let mut expected = sample().pf;
    let maps = expected.baked.get_mut(&0).unwrap();
    maps.maps.insert(BakedMap::WorldNormal, Arc::new(vec![0.5; 16 * 16 * 3]));
    maps.maps.insert(BakedMap::BentNormal, Arc::new(vec![0.5; 16 * 16 * 3]));
    expected.project.texture_sets[0].baked = maps.maps.keys().copied().collect();
    expected.project.texture_sets[1].bake.common.dilation = 12;

    let bytes = edit_archive(&expected, |name, data| {
        if name == "project.json" {
            let mut json: serde_json::Value = serde_json::from_slice(data).unwrap();
            json["texture_sets"][0]["bake"] = serde_json::json!({
                "enabled": true, "resolution": 1024, "antialiasing": 1, "dilation": 16,
                "maps": ["Normal", "WorldNormal", "Id", "AmbientOcclusion", "Curvature", "Position", "Thickness"],
                "ao": {"rays": 64, "max_distance": 0.1}, "use_low_as_high": true
            });
            json["texture_sets"][0]["baked"].as_array_mut().unwrap().extend(serde_json::json!(["ColorMap", "WorldDirection"]).as_array().unwrap().clone());
            *data = serde_json::to_vec(&json).unwrap();
        }

        *name = name
            .replace("_normal.bin", "_normal_base.bin")
            .replace("_worldNormal.bin", "_world_space_normals.bin")
            .replace("_ambientOcclusion.bin", "_ambient_occlusion.bin")
            .replace("_bentNormal.bin", "_bent_normals.bin");
    });

    let recovered = load_project_bytes(&bytes).unwrap();
    assert_eq!(recovered.warnings.len(), 1);
    assert_same(&expected, &recovered);
    let reopened = load_project_bytes(&save_project_bytes(&recovered).unwrap()).unwrap();
    assert_same(&expected, &reopened);
    assert!(reopened.warnings.is_empty());
}

#[test]
fn recovery_keeps_readable_bake_fields_and_project_content() {
    let mut expected = sample().pf;
    let settings = &mut expected.project.texture_sets[0].bake;
    settings.common.dilation = 19;
    settings.maps.height.is_enabled = true;
    settings.maps.ao.parameters.rays.rays = 96;
    settings.maps.ao.parameters.ground_plane.enabled = true;
    settings.high_poly.low_suffix = "_lo".into();
    expected.project.texture_sets[1].bake.common.dilation = 7;

    let bytes = edit_project_json(&expected, |json| {
        let bake = &mut json["texture_sets"][0]["bake"];
        bake["common"]["antialiasing"] = serde_json::json!("unknown");
        bake["common"]["resolution_height"] = serde_json::json!(false);
        bake["maps"]["normal"] = serde_json::json!("Normal");
        bake["maps"]["ao"]["parameters"]["rays"]["max_distance"] = serde_json::json!("bad");
        bake["maps"]["opacity"]["is_enabled"] = serde_json::json!(null);
        bake["cage"] = serde_json::json!([1, 2]);
    });

    assert_same(&expected, &load_project_bytes(&bytes).unwrap());
}

#[test]
fn recovery_defaults_unreadable_bake_blocks() {
    let expected = sample().pf;
    for invalid in [serde_json::Value::Null, serde_json::json!(false), serde_json::json!("old"), serde_json::json!(["Normal"])] {
        let bytes = edit_project_json(&expected, |json| json["texture_sets"][0]["bake"] = invalid.clone());
        assert_same(&expected, &load_project_bytes(&bytes).unwrap());
    }
}

#[test]
#[cfg(not(target_arch = "wasm32"))]
fn a_failing_entry_is_an_error_not_a_hang() {
    let opts = SimpleFileOptions::default().compression_method(CompressionMethod::Deflated);
    for fail_at in [0usize, 3, 9] {
        let list: Vec<Entry<'_>> = (0..10)
            .map(|i| Entry {
                name: format!("e{i}"),
                options: opts,
                weight: 10,
                body: Box::new(move |w| {
                    if i == fail_at {
                        return Err(std::io::Error::other("boom"));
                    }
                    if i == 5 && fail_at == 9 {
                        panic!("worker panic");
                    }
                    w.write_all(&[i as u8; 100])
                }),
            })
            .collect();
        let mut zip = ZipWriter::new(Cursor::new(Vec::new()));
        assert!(entries::parallel::write(&mut zip, list, 4, 25).is_err(), "fail at {fail_at}");
    }
}

#[test]
#[cfg(not(target_arch = "wasm32"))]
fn a_late_failing_entry_after_good_ones_is_its_own_error() {
    // Only the last entry fails and nothing panics, so the error must come from that entry.
    for (workers, budget) in [(4usize, 25u64), (4, u64::MAX), (2, 1)] {
        let (tx, rx) = std::sync::mpsc::channel();
        std::thread::spawn(move || {
            let opts = SimpleFileOptions::default().compression_method(CompressionMethod::Deflated);
            let list: Vec<Entry<'_>> = (0..10)
                .map(|i| Entry {
                    name: format!("e{i}"),
                    options: opts,
                    weight: 10,
                    body: Box::new(move |w| if i == 9 { Err(std::io::Error::other("late boom")) } else { w.write_all(&[i as u8; 100]) }),
                })
                .collect();
            let mut zip = ZipWriter::new(Cursor::new(Vec::new()));
            let res = entries::parallel::write(&mut zip, list, workers, budget);
            let _ = tx.send(res.map_err(|e| matches!(&e, FormatError::Io(io) if io.to_string() == "late boom")));
        });
        let res =
            rx.recv_timeout(std::time::Duration::from_secs(60)).unwrap_or_else(|e| panic!("save did not finish ({e}): {workers} workers, budget {budget}"));
        assert_eq!(res, Err(true), "{workers} workers, budget {budget}");
    }
}

#[cfg(not(target_arch = "wasm32"))]
fn assert_entry_streams_to_destination(method: CompressionMethod, budget: u64) {
    use std::sync::atomic::{AtomicBool, Ordering};

    let path = std::env::temp_dir().join(format!("texturecraft-entry-streaming-{}-{method:?}.zip", std::process::id()));
    let destination = std::fs::File::create(&path).unwrap();
    let observed_destination = destination.try_clone().unwrap();
    let reached_destination = AtomicBool::new(false);
    let mut random = 12345u32;
    let payload: Vec<u8> = (0..131_072)
        .map(|_| {
            random ^= random << 13;
            random ^= random >> 17;
            random ^= random << 5;
            random as u8
        })
        .collect();
    let compressed = SimpleFileOptions::default().compression_method(CompressionMethod::Deflated);
    let mut list: Vec<Entry<'_>> = (0..2)
        .map(|index| Entry { name: format!("before{index}"), options: compressed, weight: 128, body: Box::new(|writer| writer.write_all(&[7; 128])) })
        .collect();
    list.push(Entry {
        name: "target".into(),
        options: SimpleFileOptions::default().compression_method(method),
        weight: payload.len() as u64,
        body: Box::new(|writer| {
            let before_bytes = observed_destination.metadata()?.len();
            writer.write_all(&payload)?;
            writer.flush()?;
            reached_destination.store(observed_destination.metadata()?.len() > before_bytes, Ordering::Relaxed);
            Ok(())
        }),
    });
    list.push(Entry { name: "after".into(), options: compressed, weight: 128, body: Box::new(|writer| writer.write_all(&[9; 128])) });
    let mut writer = ZipWriter::new(destination);

    let result = entries::parallel::write(&mut writer, list, 4, budget);
    drop(writer.finish().unwrap());
    drop(observed_destination);
    let bytes = std::fs::read(&path).unwrap();
    std::fs::remove_file(&path).unwrap();

    result.unwrap();
    assert!(reached_destination.load(Ordering::Relaxed), "{method:?} was buffered instead of streamed");
    let mut archive = ZipArchive::new(Cursor::new(bytes)).unwrap();
    let names: Vec<_> = (0..archive.len()).map(|index| archive.by_index(index).unwrap().name().unwrap().into_owned()).collect();
    assert_eq!(names, ["before0", "before1", "target", "after"]);
    let mut actual = Vec::new();
    archive.by_name("target").unwrap().read_to_end(&mut actual).unwrap();
    assert_eq!(actual, payload);
    let mut after = Vec::new();
    archive.by_name("after").unwrap().read_to_end(&mut after).unwrap();
    assert_eq!(after, [9; 128]);
}

#[test]
#[cfg(not(target_arch = "wasm32"))]
fn stored_entries_reach_the_destination_during_their_body() {
    assert_entry_streams_to_destination(CompressionMethod::Stored, 1 << 20);
}

#[test]
#[cfg(not(target_arch = "wasm32"))]
fn over_budget_entries_reach_the_destination_during_their_body() {
    assert_entry_streams_to_destination(CompressionMethod::Deflated, 4096);
}

#[test]
fn recovery_skips_unsupported_baked_map_entries() {
    let expected = sample().pf;
    let bytes = edit_archive(&expected, |name, _| {
        if name == "thumbnail.png" {
            *name = "baked/0_color_map.bin".into();
        }
    });
    let mut expected = expected;
    expected.thumbnail = None;
    let recovered = load_project_bytes(&bytes).unwrap();
    assert_same(&expected, &recovered);
    assert_eq!(recovered.warnings.len(), 1);
}

#[test]
fn recovery_does_not_hide_invalid_project_structure_or_newer_versions() {
    let project_file = sample().pf;
    for (field, value) in [("resolution", serde_json::json!("bad")), ("stack", serde_json::json!([999])), ("channels", serde_json::json!(null))] {
        let bytes = edit_project_json(&project_file, |json| {
            json["texture_sets"][0]["bake"] = serde_json::json!("old");
            json["texture_sets"][0][field] = value.clone();
        });
        assert!(load_project_bytes(&bytes).is_err(), "{field}");
    }

    let bytes = edit_project_json(&project_file, |json| {
        json["format_version"] = serde_json::json!(FORMAT_VERSION + 1);
        json["texture_sets"][0]["bake"] = serde_json::json!("old");
    });
    assert!(matches!(load_project_bytes(&bytes), Err(FormatError::NewerVersion { .. })));
}

#[test]
fn recovery_still_rejects_corrupt_pixels() {
    let project_file = sample().pf;
    let bytes = edit_archive(&project_file, |name, data| {
        if name == "project.json" {
            let mut json: serde_json::Value = serde_json::from_slice(data).unwrap();
            json["texture_sets"][0]["bake"]["maps"] = serde_json::json!(["Normal"]);
            *data = serde_json::to_vec(&json).unwrap();
        } else if name.starts_with("pixels/") {
            data.truncate(10);
        }
    });

    let error = load_project_bytes(&bytes).unwrap_err();
    assert!(error.to_string().contains("pixels/"), "{error}");
}

#[test]
fn recovery_does_not_accept_unrelated_json_errors() {
    let bytes = edit_archive(&sample().pf, |name, data| {
        if name == "project.json" {
            data.splice(1..1, br#""name":"duplicate", "#.iter().copied());
        }
    });

    let error = load_project_bytes(&bytes).unwrap_err();
    assert!(error.to_string().contains("duplicate field"), "{error}");
}

#[test]
fn project_open_limit_counts_every_loaded_entry_kind() {
    let paint = sample().paint;
    let baked = [header(16, 16, 1, 0), vec![0; 16 * 16 * 4]].concat();
    let entries = [
        ("resources/test.bin".to_string(), vec![1; 1024]),
        ("mesh.obj".to_string(), vec![2; 1024]),
        ("highpoly/test.obj".to_string(), vec![3; 1024]),
        ("cage/test.obj".to_string(), vec![4; 1024]),
        ("thumbnail.png".to_string(), vec![5; 1024]),
        (format!("pixels/layer_{}_baseColor.bin", paint.0), tile_bin(128, 4, &[(0, 0)])),
        (format!("pixels/mask_{}.bin", paint.0), tile_bin(128, 2, &[(0, 0)])),
        ("baked/0_ambientOcclusion.bin".to_string(), baked.clone()),
        ("bake_paint/0_skew.bin".to_string(), baked),
    ];

    for (name, data) in entries {
        let bytes = zip_with(&[(&name, data)]);
        let mut archive = ZipArchive::new(Cursor::new(&bytes)).unwrap();
        let total_bytes: u64 = (0..archive.len()).map(|index| archive.by_index(index).unwrap().size()).sum();

        let accepted = load_with_budget(Cursor::new(&bytes), LoadBudget::new(total_bytes)).unwrap();
        let error = load_with_budget(Cursor::new(&bytes), LoadBudget::new(total_bytes - 1)).unwrap_err();
        let raised_limit = load_with_budget(Cursor::new(&bytes), LoadBudget::new(total_bytes + 1)).unwrap();

        assert!(matches!(error, FormatError::TooLarge(_)), "{name}: {error}");
        assert!(error.to_string().contains(&format!("{} bytes", total_bytes - 1)), "{name}: {error}");
        assert_same(&accepted, &raised_limit);
    }
}

#[test]
fn project_open_limit_is_shared_across_the_whole_archive() {
    let project = sample().pf;
    let bytes = serial_bytes(&project);
    let mut archive = ZipArchive::new(Cursor::new(&bytes)).unwrap();
    let total_bytes: u64 = (0..archive.len()).map(|index| archive.by_index(index).unwrap().size()).sum();

    let accepted = load_with_budget(Cursor::new(&bytes), LoadBudget::new(total_bytes)).unwrap();
    let error = load_with_budget(Cursor::new(&bytes), LoadBudget::new(total_bytes - 1)).unwrap_err();

    assert_same(&project, &accepted);
    assert!(matches!(error, FormatError::TooLarge(_)), "{error}");
}

#[test]
fn entry_reads_stop_at_the_smaller_of_the_entry_and_project_limits() {
    for (entry_limit, project_limit, expected_read) in [(8, 100, 9), (100, 8, 9)] {
        let mut reader = Cursor::new(vec![1; 1000]);
        let mut budget = LoadBudget::new(project_limit);

        let error = read_all(&mut reader, entry_limit, &mut budget, "resource").unwrap_err();

        assert!(matches!(error, FormatError::TooLarge(_)), "{error}");
        assert_eq!(reader.position(), expected_read);
    }
}

#[test]
fn oversized_baked_data_is_rejected_before_reading_its_payload() {
    let mut reader = Cursor::new(header(16, 16, 1, 0));
    let mut budget = LoadBudget::new(BIN_HEADER_BYTES as u64 + 16 * 16 * 4 - 1);

    let error = read_baked(&mut reader, BIN_HEADER_BYTES as u64 + 16 * 16 * 4, 1, &mut budget, "baked map").unwrap_err();

    assert!(matches!(error, FormatError::TooLarge(_)), "the size guard must run before the truncated read: {error}");
    assert_eq!(reader.position(), BIN_HEADER_BYTES as u64);
}

#[test]
fn archive_preflight_counts_ignored_entries_and_allows_the_exact_limit() {
    let mut writer = ZipWriter::new(Cursor::new(Vec::new()));
    let options = SimpleFileOptions::default().compression_method(CompressionMethod::Deflated);
    for name in ["project.json", "unknown/future-data"] {
        writer.start_file(name, options).unwrap();
        writer.write_all(&[0; 16]).unwrap();
    }
    let bytes = writer.finish().unwrap().into_inner();
    let mut archive = ZipArchive::new(Cursor::new(bytes)).unwrap();

    check_archive(&mut archive, 32).unwrap();
    let error = check_archive(&mut archive, 31).unwrap_err();

    assert!(matches!(error, FormatError::TooLarge(_)), "{error}");
}

#[test]
fn overlapping_archive_entries_are_rejected_before_decompression() {
    let mut writer = ZipWriter::new(Cursor::new(Vec::new()));
    writer.start_file("resource", SimpleFileOptions::default()).unwrap();
    writer.write_all(&[0; 16]).unwrap();
    writer.shallow_copy_file("resource", "copy").unwrap();
    let bytes = writer.finish().unwrap().into_inner();
    let mut archive = ZipArchive::new(Cursor::new(bytes)).unwrap();

    let error = check_archive(&mut archive, 32).unwrap_err();

    assert!(error.to_string().contains("overlapping ZIP entries"), "{error}");
}

#[test]
fn actual_decompression_is_bounded_even_when_the_declared_size_is_small() {
    let mut writer = ZipWriter::new(Cursor::new(Vec::new()));
    writer.start_file("resource", SimpleFileOptions::default().compression_method(CompressionMethod::Deflated)).unwrap();
    writer.write_all(&vec![0; 1 << 20]).unwrap();
    let mut bytes = writer.finish().unwrap().into_inner();
    let directory = ZipArchive::new(Cursor::new(&bytes)).unwrap().central_directory_start() as usize;
    // The central header stores the uncompressed size at byte 24
    bytes.get_mut(directory + 24..directory + 28).unwrap().copy_from_slice(&1u32.to_le_bytes());
    let mut archive = ZipArchive::new(Cursor::new(bytes)).unwrap();
    check_archive(&mut archive, 1024).unwrap();
    let mut entry = archive.by_index(0).unwrap();
    let mut budget = LoadBudget::new(1024);

    let error = read_all(&mut entry, MAX_RESOURCE, &mut budget, "resource").unwrap_err();

    assert!(
        matches!(error, FormatError::TooLarge(_)) || error.to_string().contains("larger than its declared uncompressed size"),
        "actual bytes must be bounded independently of ZIP sizes: {error}"
    );
}

#[test]
fn baked_dimensions_must_match_the_entry_before_reserving_payload_bytes() {
    let mut reader = Cursor::new(header(1024, 1024, 3, 0));
    let mut budget = LoadBudget::new(16 << 20);

    let error = read_baked(&mut reader, BIN_HEADER_BYTES as u64, 3, &mut budget, "baked map").unwrap_err();

    assert!(error.to_string().contains("24 bytes for a 1024×1024×3 map"), "{error}");
    assert_eq!(budget.remaining(), (16 << 20) - BIN_HEADER_BYTES as u64);
    assert_eq!(reader.position(), BIN_HEADER_BYTES as u64);
}

#[test]
fn streamed_float_chunks_preserve_bits_across_the_chunk_boundary() {
    let values: Vec<u32> = (0..BAKED_CHUNK + 3).map(|index| (index as u32).wrapping_mul(0x9e3779b9)).collect();
    let mut bytes = header(values.len() as u32, 1, 1, 0);
    bytes.extend(values.iter().flat_map(|bits| bits.to_le_bytes()));
    let declared = bytes.len() as u64;
    let mut reader = Cursor::new(bytes);
    let mut budget = LoadBudget::new(declared);

    let (_, _, decoded) = read_baked(&mut reader, declared, 1, &mut budget, "baked map").unwrap();

    assert_eq!(decoded.into_iter().map(f32::to_bits).collect::<Vec<_>>(), values);
    assert_eq!(reader.position(), declared);
    assert_eq!(budget.remaining(), 0);
}

#[test]
fn archive_indexing_does_not_scan_large_payloads_and_rejects_large_metadata() {
    let mut writer = ZipWriter::new(Cursor::new(Vec::new()));
    writer.start_file("resource", SimpleFileOptions::default().compression_method(CompressionMethod::Stored)).unwrap();
    writer.write_all(&vec![7; 1 << 20]).unwrap();
    let bytes = writer.finish().unwrap().into_inner();

    let mut archive = open_archive(Cursor::new(bytes), 4096).unwrap();
    let mut first_byte = [0; 1];
    archive.by_index(0).unwrap().read_exact(&mut first_byte).unwrap();

    assert_eq!(first_byte, [7]);

    let mut writer = ZipWriter::new(Cursor::new(Vec::new()));
    writer.start_file("a".repeat(5000), SimpleFileOptions::default()).unwrap();
    writer.write_all(&[7]).unwrap();
    let bytes = writer.finish().unwrap().into_inner();

    assert!(open_archive(Cursor::new(bytes), 4096).is_err());
}

#[test]
fn zip64_entry_counts_remain_supported_and_bounded() {
    for count in [65_536, MAX_ENTRIES + 1] {
        let mut writer = ZipWriter::new(Cursor::new(Vec::new()));
        for index in 0..count {
            writer.start_file(format!("e{index}"), SimpleFileOptions::default().compression_method(CompressionMethod::Stored)).unwrap();
        }
        let bytes = writer.finish().unwrap().into_inner();

        let mut archive = open_archive(Cursor::new(bytes), MAX_ZIP_METADATA_BYTES).unwrap();
        let result = check_archive(&mut archive, 0);

        assert_eq!(archive.len(), count);
        if count <= MAX_ENTRIES {
            result.unwrap();
        } else {
            assert!(matches!(result, Err(FormatError::TooLarge(_))), "{result:?}");
        }
    }
}