GitCorner

Code

ossartcrafttexturecraft🌐
d84914ef1e5a
//! The divider between the 3D and 2D views in the split layout resizes them and keeps the pointer from the views

use egui::{Event, Modifiers, PointerButton, Pos2, pos2};
use egui_kittest::Harness;
use texturecraft_engine::core::Channel;
use texturecraft_ui_egui::TextureCraftApp;
use texturecraft_ui_egui::state::UiState;
use texturecraft_ui_egui::ui_state_store::UiStateStore;

/// Narrowest a split view may get, as in `viewport.rs`
const MIN_VIEW_WIDTH: f32 = 16.0;

/// A press clear of the divider's 8 point grab zone and egui's 5 point interact radius
const BESIDE_DIVIDER: f32 = 16.0;

/// App storage held in memory, saved the way the app saves its state between runs
#[derive(Default)]
struct MemoryStorage(std::collections::HashMap<String, String>);

impl eframe::Storage for MemoryStorage {
    fn get_string(&self, key: &str) -> Option<String> {
        self.0.get(key).cloned()
    }

    fn set_string(&mut self, key: &str, value: String) {
        self.0.insert(key.to_owned(), value);
    }

    fn remove_string(&mut self, key: &str) {
        self.0.remove(key);
    }

    fn flush(&mut self) {}
}

/// The sample project in the default split layout at 1600 x 960
fn split_app() -> Harness<'static, TextureCraftApp> {
    let session = texturecraft_engine::sample_session(256, 64).unwrap();
    let mut harness = Harness::builder().with_size(egui::vec2(1600.0, 960.0)).build_eframe(|cc| TextureCraftApp::new(cc, session));
    harness.run_steps(4);
    harness
}

/// Drag with `button` from `from` to `to` in a few moves
fn drag(harness: &mut Harness<'_, TextureCraftApp>, button: PointerButton, from: Pos2, to: Pos2) {
    harness.hover_at(from);
    harness.run_steps(1);
    harness.event(Event::PointerButton { pos: from, button, pressed: true, modifiers: Modifiers::NONE });
    harness.run_steps(2);

    for step in 1..=4 {
        harness.hover_at(from + (to - from) * (step as f32 / 4.0));
        harness.run_steps(1);
    }

    harness.event(Event::PointerButton { pos: to, button, pressed: false, modifiers: Modifiers::NONE });
    harness.run_steps(3);
}

/// The divider's x position: the 3D view ends 1 point left of it
fn divider_x(harness: &Harness<'_, TextureCraftApp>) -> f32 {
    harness.state().viewport_rect.right() + 1.0
}

/// Allocated tiles in the selected layer's base color
fn painted_tiles(harness: &Harness<'_, TextureCraftApp>) -> usize {
    let session = &harness.state().session;
    let layer = session.selected_layer().expect("a selected layer");
    session.doc.pixels.layer(layer, Channel::BaseColor).map_or(0, |image| image.allocated_count())
}

/// The 2D view's texture as drawn: its centre's offset from the view's centre and its half width and height, in pixels at 1 point per pixel
fn uv_texture_on_screen(harness: &Harness<'_, TextureCraftApp>, views_right: f32) -> [f32; 4] {
    let app = harness.state();

    // egui draws the view's frame into its rect rounded to whole pixels
    let width = views_right.round() - (divider_x(harness) + 1.0).round();
    let height = app.viewport_rect.bottom().round() - app.viewport_rect.top().round();
    let texture_size = app.session.doc.project.texture_sets[app.session.ts()].size();
    let [scale_x, scale_y] = texturecraft_render::uv_view_scale(width / height, app.ui.uv_zoom, texture_size);
    let [pan_x, pan_y] = app.ui.uv_pan;
    [pan_x * width * 0.5, pan_y * height * 0.5, scale_x * width * 0.5, scale_y * height * 0.5]
}

/// The 3D camera's yaw and pitch
fn camera_angles(harness: &Harness<'_, TextureCraftApp>) -> (f32, f32) {
    let camera = &harness.state().session.camera;
    (camera.yaw, camera.pitch)
}

#[test]
fn swapping_waits_for_the_active_stroke_to_finish() {
    let mut harness = split_app();
    let context = harness.ctx.clone();
    let app = harness.state_mut();
    app.session.begin_stroke_uv(texturecraft_engine::geom::glam::Vec2::splat(0.5), 1.0).unwrap();

    texturecraft_ui_egui::menus::invoke(app, &context, "ui.layout.swap");

    assert!(!app.ui.swap_views);
    assert!(app.session.stroke_active());
    app.session.end_stroke().unwrap();

    texturecraft_ui_egui::menus::invoke(app, &context, "ui.layout.swap");

    assert!(app.ui.swap_views);
}

#[test]
fn dragging_the_divider_resizes_the_views_within_their_minimum_width() {
    let mut harness = split_app();
    let views_left = harness.state().viewport_rect.left();
    let start_x = divider_x(&harness);
    let views_width = (start_x - views_left) * 2.0;
    let views_right = views_left + views_width;
    let y = harness.state().viewport_rect.center().y;
    assert_eq!(harness.state().ui.split_ratio, 0.5);

    drag(&mut harness, PointerButton::Primary, pos2(start_x, y), pos2(start_x - 200.0, y));
    assert!((divider_x(&harness) - (start_x - 200.0)).abs() < 0.5, "follows the pointer: {}", divider_x(&harness));
    assert!((harness.state().ui.split_ratio - (start_x - 200.0 - views_left) / views_width).abs() < 1e-3);

    let x = divider_x(&harness);
    drag(&mut harness, PointerButton::Primary, pos2(x, y), pos2(views_left + 10.0, y));
    assert!((divider_x(&harness) - views_left - MIN_VIEW_WIDTH).abs() < 0.5, "clamped on the left: {}", divider_x(&harness));

    let x = divider_x(&harness);
    drag(&mut harness, PointerButton::Primary, pos2(x, y), pos2(views_right - 10.0, y));
    assert!((views_right - divider_x(&harness) - MIN_VIEW_WIDTH).abs() < 0.5, "clamped on the right: {}", divider_x(&harness));
}

#[test]
fn pressing_on_the_divider_neither_paints_nor_moves_the_camera() {
    let mut harness = split_app();

    // Pan the texture's centre under the divider so a press there would paint if the 2D view got it
    harness.state_mut().ui.uv_pan[0] = -1.0;
    harness.run_steps(2);
    let x = divider_x(&harness);
    let y = harness.state().viewport_rect.center().y;
    let (tiles, angles) = (painted_tiles(&harness), camera_angles(&harness));

    harness.hover_at(pos2(x, y));
    harness.run_steps(1);
    harness.event(Event::PointerButton { pos: pos2(x, y), button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE });
    harness.event(Event::PointerButton { pos: pos2(x, y), button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE });
    harness.run_steps(3);
    drag(&mut harness, PointerButton::Primary, pos2(x, y), pos2(x, y + 120.0));
    drag(&mut harness, PointerButton::Secondary, pos2(x, y), pos2(x + 120.0, y));
    assert_eq!(painted_tiles(&harness), tiles, "nothing painted");
    assert_eq!(camera_angles(&harness), angles, "no orbit");
    assert_eq!(divider_x(&harness), x, "a vertical or right-button drag leaves the divider in place");

    // Beside the divider the views get the same input again
    drag(&mut harness, PointerButton::Primary, pos2(x + BESIDE_DIVIDER, y), pos2(x + BESIDE_DIVIDER, y + 40.0));
    assert!(painted_tiles(&harness) > tiles, "the 2D view paints");
    drag(&mut harness, PointerButton::Secondary, pos2(x - BESIDE_DIVIDER, y), pos2(x - BESIDE_DIVIDER - 120.0, y));
    assert_ne!(camera_angles(&harness), angles, "the 3D view orbits");
}

#[test]
fn the_divider_position_survives_a_restart_and_old_saved_states_load_centred() {
    let mut storage = MemoryStorage::default();
    let mut ui_state = UiState::default();
    ui_state.split_ratio = 0.3;
    UiStateStore::default().save(&ui_state, &mut storage);
    let restored = UiStateStore::default().load(Some(&storage)).expect("saved state loads");
    assert_eq!(restored.split_ratio, 0.3);

    // A state saved before the divider existed has no ratio
    let mut saved: serde_json::Value = serde_json::from_str(&storage.0["ui.json"]).unwrap();
    assert!(saved.as_object_mut().unwrap().remove("split_ratio").is_some(), "the saved state names the ratio: {saved}");
    storage.0.insert("ui.json".to_owned(), saved.to_string());
    let restored = UiStateStore::default().load(Some(&storage)).expect("an older saved state loads");
    assert_eq!(restored.split_ratio, 0.5);
}

#[test]
fn old_textures_tab_index_migrates_without_changing_new_all_types() {
    let mut storage = MemoryStorage::default();
    let mut state = UiState::default();
    state.shelf_tab = 8;
    UiStateStore::default().save(&state, &mut storage);

    assert_eq!(UiStateStore::default().load(Some(&storage)).map(|ui| ui.shelf_tab), Some(8));

    let mut legacy: serde_json::Value = serde_json::from_str(&storage.0["ui.json"]).unwrap();
    legacy.as_object_mut().unwrap().remove("shelf_path");
    legacy.as_object_mut().unwrap().insert("shelf_filter".into(), "shelf_path".into());
    storage.0.insert("ui.json".into(), legacy.to_string());
    assert_eq!(UiStateStore::default().load(Some(&storage)).map(|ui| ui.shelf_tab), Some(6));

    state.shelf_tab = 0;
    UiStateStore::default().save(&state, &mut storage);
    assert_eq!(UiStateStore::default().load(Some(&storage)).map(|ui| ui.shelf_tab), Some(0));
}

#[test]
fn dragging_the_divider_keeps_the_uv_texture_size_and_offset_on_screen() {
    // Zoomed in, a 2D sliver needs a zoom far past the one the view starts with
    for zoom in [1.0, 4.0] {
        let mut harness = split_app();
        harness.state_mut().ui.uv_zoom = zoom;
        harness.state_mut().ui.uv_pan = [0.2, 0.1];
        harness.run_steps(2);
        // The split starts centred, so the views end as far right of the divider as they start left of it
        let views_left = harness.state().viewport_rect.left();
        let views_right = views_left + (divider_x(&harness) - views_left) * 2.0;
        let y = harness.state().viewport_rect.center().y;
        let before = uv_texture_on_screen(&harness, views_right);

        let assert_unchanged = |harness: &Harness<'_, TextureCraftApp>| {
            let after = uv_texture_on_screen(harness, views_right);
            for (was, is) in before.iter().zip(after) {
                assert!((was - is).abs() < 0.5, "zoom {zoom}, divider at {}: {before:?} became {after:?}", divider_x(harness));
            }
        };

        for to in [views_left + 300.0, views_right - 150.0, views_right - 10.0, views_left + 500.0] {
            let x = divider_x(&harness);
            drag(&mut harness, PointerButton::Primary, pos2(x, y), pos2(to, y));
            assert_unchanged(&harness);
        }

        // A slow drag past the right end, checked every frame for a nudge at the pixel rounding or the stop
        let from = pos2(divider_x(&harness), y);
        harness.hover_at(from);
        harness.run_steps(1);
        harness.event(Event::PointerButton { pos: from, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE });
        harness.run_steps(1);
        let mut pointer_x = from.x;
        while pointer_x < views_right + 20.0 {
            // Not a whole number of pixels, so the divider lands at every kind of rounding
            pointer_x += 3.3;
            harness.hover_at(pos2(pointer_x, y));
            harness.run_steps(1);
            assert_unchanged(&harness);
        }
        harness.event(Event::PointerButton { pos: pos2(pointer_x, y), button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE });
        harness.run_steps(2);
        assert_unchanged(&harness);

        // Inside the wheel's 0.1 to 40 range, so the next scroll in the narrow view can't snap the zoom
        let stopped_zoom = harness.state().ui.uv_zoom;
        assert!((0.1..=40.0).contains(&stopped_zoom), "zoom {zoom} stopped at {stopped_zoom}");
    }
}

/// Press F4, the default key of Swap 3D/2D
fn press_f4(harness: &mut Harness<'_, TextureCraftApp>) {
    harness.event(Event::Key { key: egui::Key::F4, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE });
    harness.run_steps(3);
    harness.event(Event::Key { key: egui::Key::F4, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE });
    harness.run_steps(2);
}

#[test]
fn f4_swaps_the_views_and_both_still_work_and_the_state_is_saved() {
    let mut harness = split_app();
    let rect_3d = harness.state().viewport_rect;
    let y = rect_3d.center().y;
    assert!(!harness.state().ui.swap_views);

    press_f4(&mut harness);
    assert!(harness.state().ui.swap_views, "F4 swaps");
    let swapped_3d = harness.state().viewport_rect;
    assert!(swapped_3d.left() > rect_3d.center().x, "3D is on the right now: {swapped_3d:?}");

    // 2D is on the left: a drag there paints, a right-drag in 3D orbits
    let (tiles, angles) = (painted_tiles(&harness), camera_angles(&harness));
    let left_x = rect_3d.left() + 200.0;
    drag(&mut harness, PointerButton::Primary, pos2(left_x, y), pos2(left_x, y + 40.0));
    assert!(painted_tiles(&harness) > tiles, "the 2D view on the left paints");
    let right_x = swapped_3d.center().x;
    drag(&mut harness, PointerButton::Secondary, pos2(right_x, y), pos2(right_x - 120.0, y));
    assert_ne!(camera_angles(&harness), angles, "the 3D view on the right orbits");

    // The divider drags on the swapped sides and the 3D view's share follows
    let divider = swapped_3d.left() - 1.0;
    drag(&mut harness, PointerButton::Primary, pos2(divider, y), pos2(divider + 100.0, y));
    assert!((harness.state().viewport_rect.left() - 1.0 - (divider + 100.0)).abs() < 0.5, "the divider follows the pointer");
    assert!(harness.state().ui.split_ratio < 0.5, "the 3D view got narrower");

    // Saved with the UI state, and F4 swaps back
    let mut ui_state = harness.state().ui.clone();
    let json = serde_json::to_string(&ui_state).unwrap();
    ui_state = serde_json::from_str(&json).unwrap();
    assert!(ui_state.swap_views);
    press_f4(&mut harness);
    assert!(!harness.state().ui.swap_views);
    assert!(
        harness.state().viewport_rect.right() < rect_3d.right() + 400.0 && harness.state().viewport_rect.left() == rect_3d.left(),
        "3D is back on the left"
    );
}