blockworx/document/

coord.rs

//! Grid-space geometry for the legacy model, and its pixel mapping.
//!
//! The live editor's geometry is the document crate's, converted once in
//! [`crate::edit::lower`]. These types and their conversions survive only
//! for the dormant half — the on-disk bridge and the presentation layer's
//! own route geometry — and go with it (the editor-swap playbook, F7).

use egui::{Pos2, Rect, Vec2, pos2, vec2};
use serde::{Deserialize, Serialize};

use crate::grid::{grid_i32, grid_u32_ceil, px, px_u};

#[derive(
    Copy, Clone, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize,
)]
pub struct GridPos {
    pub x: i32,
    pub y: i32,
}

#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct GridSize {
    pub w: u32,
    pub h: u32,
}

#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct GridVec {
    pub dx: i32,
    pub dy: i32,
}

#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct GridRect {
    pub min: GridPos,
    pub size: GridSize,
}

impl GridPos {
    pub const ZERO: GridPos = GridPos { x: 0, y: 0 };

    pub const fn new(x: i32, y: i32) -> Self {
        Self { x, y }
    }
}

impl GridSize {
    pub const ZERO: GridSize = GridSize { w: 0, h: 0 };

    pub const fn new(w: u32, h: u32) -> Self {
        Self { w, h }
    }
}

impl GridVec {
    pub const ZERO: GridVec = GridVec { dx: 0, dy: 0 };

    pub const fn new(dx: i32, dy: i32) -> Self {
        Self { dx, dy }
    }
}

impl GridRect {
    pub const fn new(min: GridPos, size: GridSize) -> Self {
        Self { min, size }
    }

    pub fn from_min_size(min: GridPos, size: GridSize) -> Self {
        Self { min, size }
    }

    pub fn from_two_pos(a: GridPos, b: GridPos) -> Self {
        let min_x = a.x.min(b.x);
        let min_y = a.y.min(b.y);
        let max_x = a.x.max(b.x);
        let max_y = a.y.max(b.y);
        Self {
            min: GridPos::new(min_x, min_y),
            size: GridSize::new((max_x - min_x) as u32, (max_y - min_y) as u32),
        }
    }

    pub fn max(self) -> GridPos {
        GridPos::new(
            self.min.x + self.size.w as i32,
            self.min.y + self.size.h as i32,
        )
    }

    pub fn width(self) -> u32 {
        self.size.w
    }

    pub fn height(self) -> u32 {
        self.size.h
    }

    pub fn left(self) -> i32 {
        self.min.x
    }

    pub fn top(self) -> i32 {
        self.min.y
    }

    pub fn right(self) -> i32 {
        self.min.x + self.size.w as i32
    }

    pub fn bottom(self) -> i32 {
        self.min.y + self.size.h as i32
    }

    pub fn left_top(self) -> GridPos {
        self.min
    }

    pub fn right_top(self) -> GridPos {
        GridPos::new(self.right(), self.top())
    }

    pub fn left_bottom(self) -> GridPos {
        GridPos::new(self.left(), self.bottom())
    }

    pub fn right_bottom(self) -> GridPos {
        self.max()
    }

    pub fn contains(self, p: GridPos) -> bool {
        p.x >= self.left() && p.x <= self.right() && p.y >= self.top() && p.y <= self.bottom()
    }

    pub fn intersects(self, other: GridRect) -> bool {
        self.left() < other.right()
            && other.left() < self.right()
            && self.top() < other.bottom()
            && other.top() < self.bottom()
    }

    pub fn translate(self, delta: GridVec) -> Self {
        Self {
            min: GridPos::new(self.min.x + delta.dx, self.min.y + delta.dy),
            size: self.size,
        }
    }
}

impl std::ops::Add<GridVec> for GridPos {
    type Output = GridPos;
    fn add(self, rhs: GridVec) -> GridPos {
        GridPos::new(self.x + rhs.dx, self.y + rhs.dy)
    }
}

impl std::ops::Sub<GridPos> for GridPos {
    type Output = GridVec;
    fn sub(self, rhs: GridPos) -> GridVec {
        GridVec::new(self.x - rhs.x, self.y - rhs.y)
    }
}

/// Pixel-space conversions for [`GridPos`].
pub trait GridPosExt {
    /// The grid cell nearest to a world-space point.
    fn from_pos2_snapped(p: Pos2) -> Self;
    /// The world-space position of this grid cell's corner.
    fn to_pos2(self) -> Pos2;
}

impl GridPosExt for GridPos {
    fn from_pos2_snapped(p: Pos2) -> Self {
        Self::new(grid_i32(p.x), grid_i32(p.y))
    }

    fn to_pos2(self) -> Pos2 {
        pos2(px(self.x), px(self.y))
    }
}

/// Pixel-space conversions for [`GridSize`].
pub trait GridSizeExt {
    /// Convert a world-space extent to whole grid cells, rounding *up* so the
    /// resulting size always fully encloses the original extent. Clamped to at
    /// least one cell per axis.
    fn from_vec2_ceil(v: Vec2) -> Self;
}

impl GridSizeExt for GridSize {
    fn from_vec2_ceil(v: Vec2) -> Self {
        Self::new(grid_u32_ceil(v.x), grid_u32_ceil(v.y))
    }
}

/// Pixel-space conversions for [`GridRect`].
pub trait GridRectExt {
    /// The grid rect enclosing a world-space rect, each corner snapped.
    fn from_rect_snapped(r: Rect) -> Self;
    /// The world-space rect this grid rect covers.
    fn to_rect(self) -> Rect;
}

impl GridRectExt for GridRect {
    fn from_rect_snapped(r: Rect) -> Self {
        let min = GridPos::from_pos2_snapped(r.min);
        let max = GridPos::from_pos2_snapped(r.max);
        Self::from_two_pos(min, max)
    }

    fn to_rect(self) -> Rect {
        Rect::from_min_size(
            self.min.to_pos2(),
            vec2(px_u(self.size.w), px_u(self.size.h)),
        )
    }
}

impl From<GridPos> for Pos2 {
    fn from(p: GridPos) -> Self {
        p.to_pos2()
    }
}

/// The document's grid point in the presentation layer's vocabulary. One
/// cell, two spellings: the solved geometry is still measured in these
/// types while the authored corners live in the document's, and the two
/// meet here rather than through pixels.
impl From<blockworx_doc::geometry::GridPoint> for GridPos {
    fn from(p: blockworx_doc::geometry::GridPoint) -> Self {
        Self::new(p.x, p.y)
    }
}

impl From<GridPos> for blockworx_doc::geometry::GridPoint {
    fn from(p: GridPos) -> Self {
        Self { x: p.x, y: p.y }
    }
}

impl From<blockworx_doc::geometry::GridVec> for GridVec {
    fn from(v: blockworx_doc::geometry::GridVec) -> Self {
        Self::new(v.dx, v.dy)
    }
}

impl From<GridVec> for blockworx_doc::geometry::GridVec {
    fn from(v: GridVec) -> Self {
        Self::new(v.dx, v.dy)
    }
}

impl From<GridVec> for Vec2 {
    fn from(v: GridVec) -> Self {
        vec2(px(v.dx), px(v.dy))
    }
}

impl From<GridRect> for Rect {
    fn from(r: GridRect) -> Self {
        r.to_rect()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn gridpos_pos2_roundtrip() {
        for &(x, y) in &[(0, 0), (1, 1), (-3, 7), (100, -50)] {
            let g = GridPos::new(x, y);
            let p: Pos2 = g.into();
            let g2 = GridPos::from_pos2_snapped(p);
            assert_eq!(g, g2);
        }
    }

    #[test]
    fn gridrect_rect_roundtrip() {
        let r = GridRect::new(GridPos::new(-2, 3), GridSize::new(7, 4));
        let r2 = GridRect::from_rect_snapped(r.to_rect());
        assert_eq!(r, r2);
    }

    #[test]
    fn gridrect_intersects_matches_rect_semantics() {
        let a = GridRect::new(GridPos::new(0, 0), GridSize::new(2, 2));
        let b = GridRect::new(GridPos::new(2, 0), GridSize::new(2, 2));
        // Touching edges should not intersect (open-on-the-right).
        assert!(!a.intersects(b));
        let c = GridRect::new(GridPos::new(1, 0), GridSize::new(2, 2));
        assert!(a.intersects(c));
    }
}