Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

5.3 KB
Raw Blame
use super::*;
use std::cell::Cell;

fn close(actual: [f64; 3], expected: [f64; 3]) {
    for (a, b) in actual.into_iter().zip(expected) {
        assert!((a - b).abs() < 1e-7, "{actual:?} != {expected:?}");
    }
}

#[test]
fn linear_checkerboard_mean_and_fractional_lod() {
    let pixels = [0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0.];
    let base = TextureView::new(&pixels, [2, 2]).unwrap();
    let chain = MipChain::prepare(base, 16, || false).unwrap();
    assert_eq!(chain.level_count(), 2);
    assert_eq!(chain.tail_bytes(), 16);
    assert_eq!(chain.retained_bytes(), chain.tail_bytes() + chain.tail.capacity() * size_of::<Level>() + size_of::<MipChain<'_>>());
    assert_eq!(MIP_RECIPE_ID, "solidcraft.opaque-linear-area-mips/1");
    close(chain.sample_repeat_lod_opaque([0.25, 0.25], 0.).unwrap(), [0.; 3]);
    close(chain.sample_repeat_lod_opaque([0.25, 0.25], 1.).unwrap(), [0.5; 3]);
    close(chain.sample_repeat_lod_opaque([0.25, 0.25], 0.25).unwrap(), [0.125; 3]);
    close(chain.sample_repeat_lod_opaque([0.25, 0.25], 0.5).unwrap(), [0.25; 3]);
}

#[test]
fn odd_edges_contribute_by_area_instead_of_being_dropped_or_overweighted() {
    // Five pixels reduce to two equal-width cells: [0,0,0] and [0,0,1].
    // The middle pixel straddles the boundary, the last pixel weighs 1/2.5.
    let mut pixels = [0., 0., 0., 1.].repeat(5);
    pixels[16] = 1.;
    let chain = MipChain::prepare(TextureView::new(&pixels, [5, 1]).unwrap(), 48, || false).unwrap();
    assert_eq!(chain.dimensions(1), Some([2, 1]));
    close(chain.level(1).unwrap().sample_repeat_opaque([0.75, 0.5]).unwrap(), [0.4, 0., 0.]);
    close(chain.sample_repeat_lod_opaque([0., 0.], 2.).unwrap(), [0.2, 0., 0.]);
}

#[test]
fn rectangular_odd_pyramid_preserves_independent_mean() {
    let mut pixels = Vec::new();
    for i in 0..15 {
        pixels.extend([i as f32 / 16., 0.25, (14 - i) as f32 / 16., (i % 2) as f32]);
    }
    let chain = MipChain::prepare(TextureView::new(&pixels, [5, 3]).unwrap(), 48, || false).unwrap();
    assert_eq!(chain.level_count(), 3);
    assert_eq!(chain.dimensions(0), Some([5, 3]));
    assert_eq!(chain.dimensions(1), Some([2, 1]));
    assert_eq!(chain.dimensions(2), Some([1, 1]));
    assert_eq!(chain.dimensions(usize::MAX), None);
    close(chain.sample_repeat_lod_opaque([-9.5, 12.], 2.).unwrap(), [7. / 16., 0.25, 7. / 16.]);
}

#[test]
fn single_texel_borrows_base_and_needs_no_pixel_budget() {
    let pixels = [0.25, 0.5, 0.75, 0.];
    let chain = MipChain::prepare(TextureView::new(&pixels, [1, 1]).unwrap(), 0, || false).unwrap();
    assert_eq!(chain.level_count(), 1);
    assert_eq!(chain.tail_bytes(), 0);
    assert!(std::ptr::eq(chain.level(0).unwrap().rgba.as_ptr(), pixels.as_ptr()));
    close(chain.sample_repeat_lod_opaque([-0.1, 0.7], 0.).unwrap(), [0.25, 0.5, 0.75]);
}

#[test]
fn constant_images_and_single_axes_are_invariant_at_all_lods() {
    for dimensions in [[1, 7], [7, 1], [7, 5]] {
        let pixels = [0.25, 0.5, 0.75, 0.].repeat((dimensions[0] * dimensions[1]) as usize);
        let chain = MipChain::prepare(TextureView::new(&pixels, dimensions).unwrap(), MAX_MIP_TAIL_BYTES, || false).unwrap();
        for quarter in 0..=(chain.level_count() - 1) * 4 {
            close(chain.sample_repeat_lod_opaque([-2.34, 1.92], quarter as f64 / 4.).unwrap(), [0.25, 0.5, 0.75]);
        }
    }
}

#[test]
fn hostile_lod_and_uv_refuse_without_changing_the_chain() {
    let pixels = [0., 0., 0., 1.].repeat(4);
    let chain = MipChain::prepare(TextureView::new(&pixels, [2, 2]).unwrap(), 16, || false).unwrap();
    for lod in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY, -0.001, 1.001, f64::MAX] {
        assert_eq!(chain.sample_repeat_lod_opaque([0., 0.], lod), Err(MipError::Lod));
    }
    assert_eq!(chain.sample_repeat_lod_opaque([f64::NAN, 0.], 0.5), Err(MipError::Sampling(SamplingError::Coordinates)));
    close(chain.sample_repeat_lod_opaque([0.25, 0.25], 0.).unwrap(), [0.; 3]);
}

#[test]
fn exact_budget_and_global_cap_are_admitted_before_work() {
    let pixels = [0., 0., 0., 1.].repeat(4);
    let base = TextureView::new(&pixels, [2, 2]).unwrap();
    assert!(matches!(MipChain::prepare(base, 15, || false), Err(MipError::Budget)));
    assert!(MipChain::prepare(base, 16, || false).is_ok());
    assert!(matches!(MipChain::prepare(base, MAX_MIP_TAIL_BYTES + 1, || false), Err(MipError::Budget)));
    assert!(matches!(MipChain::prepare(base, usize::MAX, || false), Err(MipError::Budget)));
    assert_eq!(required_bytes(2048, 2048).unwrap(), 22_369_616);
    assert!(required_bytes(2048, 2048).unwrap() < MAX_MIP_TAIL_BYTES);
}

#[test]
fn cancellation_before_during_and_after_preparation_never_returns_a_partial_chain() {
    let pixels = [0.25, 0.5, 0.75, 0.].repeat(64);
    let base = TextureView::new(&pixels, [8, 8]).unwrap();
    let successful_calls = Cell::new(0);
    MipChain::prepare(base, MAX_MIP_TAIL_BYTES, || {
        successful_calls.set(successful_calls.get() + 1);
        false
    })
    .unwrap();
    for stop in 1..=successful_calls.get() {
        let calls = Cell::new(0);
        let result = MipChain::prepare(base, MAX_MIP_TAIL_BYTES, || {
            calls.set(calls.get() + 1);
            calls.get() == stop
        });
        assert!(matches!(result, Err(MipError::Cancelled)));
    }
    assert!(MipChain::prepare(base, MAX_MIP_TAIL_BYTES, || false).is_ok());
}