Skip to content

armgit / BUI

Public Imported from GitHub
0

Blender's GPU Accelerated UI, Decoupled from it's original codebase. Supports Rust, Python, JS, React, C & C++. Twice as good as GPUI

19.6 KB
Raw Blame
//! CSS math: `calc()`, `min()`, `max()`, `clamp()`, `round()`, `mod()`,
//! `rem()`, `abs()`, `sign()`, trigonometry, `pow()`, `sqrt()`, `hypot()`,
//! `log()`, `exp()` and the constants `e`, `pi`, `infinity`, `NaN`, over
//! every length unit and angles.
//!
//! Expressions are interned: each distinct one is parsed once and lives for
//! the rest of the process, so lengths can hold a `&'static Calc` (they stay
//! `Copy`) and taffy can carry a resolved copy as its opaque calc pointer
//! (`tree.rs` evaluates it against the percentage basis during layout).

use crate::css::Tok;
use crate::geometry::{Units, ROOT_FONT_SIZE};
use std::hash::{Hash, Hasher};
use std::sync::{Mutex, OnceLock};

/// A math expression. Leaves keep their unit until [`Calc::resolve`]
/// bakes the font size and viewport in, leaving only px and %.
#[derive(Debug, PartialEq)]
#[repr(align(8))]
pub enum Calc {
    Num(f32),
    Px(f32),
    Pct(f32),
    Em(f32),
    Rem(f32),
    Vw(f32),
    Vh(f32),
    Vmin(f32),
    Vmax(f32),
    Add(Box<Calc>, Box<Calc>),
    Sub(Box<Calc>, Box<Calc>),
    Mul(Box<Calc>, Box<Calc>),
    Div(Box<Calc>, Box<Calc>),
    Min(Vec<Calc>),
    Max(Vec<Calc>),
    Clamp(Box<Calc>, Box<Calc>, Box<Calc>),
    /// round(strategy, value, step)
    Round(RoundMode, Box<Calc>, Box<Calc>),
    Mod(Box<Calc>, Box<Calc>),
    Rem2(Box<Calc>, Box<Calc>),
    Fn1(Fn1, Box<Calc>),
    Pow(Box<Calc>, Box<Calc>),
    Atan2(Box<Calc>, Box<Calc>),
    Log(Box<Calc>, Option<Box<Calc>>),
    Hypot(Vec<Calc>),
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum RoundMode {
    Nearest,
    Up,
    Down,
    ToZero,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Fn1 {
    Abs,
    Sign,
    Sqrt,
    Exp,
    Sin,
    Cos,
    Tan,
    Asin,
    Acos,
    Atan,
}

/// Names of functions that start a math expression.
pub fn is_math_fn(name: &str) -> bool {
    matches!(name, "calc" | "min" | "max" | "clamp" | "round" | "mod" | "rem" | "abs" | "sign"
        | "sqrt" | "exp" | "sin" | "cos" | "tan" | "asin" | "acos" | "atan" | "atan2" | "pow"
        | "hypot" | "log" | "-webkit-calc" | "-moz-calc")
}

impl Calc {
    /// Parse a math function (`calc(...)`, `min(...)` ...) into an interned expression.
    pub fn parse_fn(name: &str, args: &[Vec<Tok>]) -> Option<&'static Calc> {
        let c = Parser::function(name, args)?;
        Some(intern(c))
    }

    /// Whether the value depends on the percentage basis.
    pub fn has_pct(&self) -> bool {
        use Calc::*;
        match self {
            Pct(_) => true,
            Num(_) | Px(_) | Em(_) | Rem(_) | Vw(_) | Vh(_) | Vmin(_) | Vmax(_) => false,
            Add(a, b) | Sub(a, b) | Mul(a, b) | Div(a, b) | Mod(a, b) | Rem2(a, b) | Pow(a, b)
            | Atan2(a, b) | Round(_, a, b) => a.has_pct() || b.has_pct(),
            Min(v) | Max(v) | Hypot(v) => v.iter().any(Calc::has_pct),
            Clamp(a, b, c) => a.has_pct() || b.has_pct() || c.has_pct(),
            Fn1(_, a) => a.has_pct(),
            Log(a, b) => a.has_pct() || b.as_ref().is_some_and(|b| b.has_pct()),
        }
    }

    /// The value in px, percentages taken of `basis`.
    pub fn eval_units(&self, u: &Units, basis: f32) -> f32 {
        use Calc::*;
        let e = |c: &Calc| c.eval_units(u, basis);
        match self {
            Num(v) | Px(v) => *v,
            Pct(p) => p * basis / 100.0,
            Em(v) => v * u.font_size,
            Rem(v) => v * ROOT_FONT_SIZE,
            Vw(v) => v * u.viewport.0 / 100.0,
            Vh(v) => v * u.viewport.1 / 100.0,
            Vmin(v) => v * u.viewport.0.min(u.viewport.1) / 100.0,
            Vmax(v) => v * u.viewport.0.max(u.viewport.1) / 100.0,
            Add(a, b) => e(a) + e(b),
            Sub(a, b) => e(a) - e(b),
            Mul(a, b) => e(a) * e(b),
            Div(a, b) => e(a) / e(b),
            Min(v) => v.iter().map(e).fold(f32::INFINITY, f32::min),
            Max(v) => v.iter().map(e).fold(f32::NEG_INFINITY, f32::max),
            // clamp(MIN, VAL, MAX) = max(MIN, min(VAL, MAX))
            Clamp(lo, v, hi) => e(lo).max(e(v).min(e(hi))),
            Round(m, v, s) => round(*m, e(v), e(s)),
            Mod(a, b) => {
                let (a, b) = (e(a), e(b));
                a - b * (a / b).floor()
            }
            Rem2(a, b) => e(a) % e(b),
            Fn1(f, a) => {
                let a = e(a);
                match f {
                    self::Fn1::Abs => a.abs(),
                    self::Fn1::Sign => if a == 0.0 { 0.0 } else { a.signum() },
                    self::Fn1::Sqrt => a.sqrt(),
                    self::Fn1::Exp => a.exp(),
                    self::Fn1::Sin => a.sin(),
                    self::Fn1::Cos => a.cos(),
                    self::Fn1::Tan => a.tan(),
                    self::Fn1::Asin => a.asin(),
                    self::Fn1::Acos => a.acos(),
                    self::Fn1::Atan => a.atan(),
                }
            }
            Pow(a, b) => e(a).powf(e(b)),
            Atan2(a, b) => e(a).atan2(e(b)),
            Log(a, b) => match b {
                Some(b) => e(a).ln() / e(b).ln(),
                None => e(a).ln(),
            },
            Hypot(v) => v.iter().map(|c| e(c).powi(2)).sum::<f32>().sqrt(),
        }
    }

    /// Pixels when the value doesn't need a percentage basis.
    pub fn to_px(&self, u: &Units) -> Option<f32> {
        (!self.has_pct()).then(|| self.eval_units(u, 0.0))
    }

    /// A copy with font-relative and viewport units baked in (px and %
    /// remain), interned: what taffy evaluates during layout.
    pub fn resolve(&self, u: &Units) -> &'static Resolved {
        Resolved::new(intern(self.bake(u)))
    }

    fn bake(&self, u: &Units) -> Calc {
        self.bake_with(&|leaf| match leaf {
            Calc::Num(x) => Calc::Num(*x),
            Calc::Pct(x) => Calc::Pct(*x),
            other => Calc::Px(other.eval_units(u, 0.0)),
        })
    }

    /// A copy with every leaf mapped by `f`.
    fn bake_with(&self, f: &dyn Fn(&Calc) -> Calc) -> Calc {
        use Calc::*;
        let b = |c: &Calc| Box::new(c.bake_with(f));
        let v = |l: &[Calc]| l.iter().map(|c| c.bake_with(f)).collect();
        match self {
            Num(_) | Pct(_) | Px(_) | Em(_) | Rem(_) | Vw(_) | Vh(_) | Vmin(_) | Vmax(_) => f(self),
            Add(a, c) => Add(b(a), b(c)),
            Sub(a, c) => Sub(b(a), b(c)),
            Mul(a, c) => Mul(b(a), b(c)),
            Div(a, c) => Div(b(a), b(c)),
            Min(l) => Min(v(l)),
            Max(l) => Max(v(l)),
            Clamp(a, c, d) => Clamp(b(a), b(c), b(d)),
            Round(m, a, c) => Round(*m, b(a), b(c)),
            Mod(a, c) => Mod(b(a), b(c)),
            Rem2(a, c) => Rem2(b(a), b(c)),
            Fn1(f, a) => Fn1(*f, b(a)),
            Pow(a, c) => Pow(b(a), b(c)),
            Atan2(a, c) => Atan2(b(a), b(c)),
            Log(a, c) => Log(b(a), c.as_ref().map(|c| b(c))),
            Hypot(l) => Hypot(v(l)),
        }
    }

    fn hash_into<H: Hasher>(&self, h: &mut H) {
        use Calc::*;
        std::mem::discriminant(self).hash(h);
        match self {
            Num(x) | Px(x) | Pct(x) | Em(x) | Rem(x) | Vw(x) | Vh(x) | Vmin(x) | Vmax(x) => {
                x.to_bits().hash(h)
            }
            Add(a, b) | Sub(a, b) | Mul(a, b) | Div(a, b) | Mod(a, b) | Rem2(a, b) | Pow(a, b)
            | Atan2(a, b) => {
                a.hash_into(h);
                b.hash_into(h);
            }
            Round(m, a, b) => {
                m.hash(h);
                a.hash_into(h);
                b.hash_into(h);
            }
            Min(v) | Max(v) | Hypot(v) => {
                v.len().hash(h);
                v.iter().for_each(|c| c.hash_into(h));
            }
            Clamp(a, b, c) => {
                a.hash_into(h);
                b.hash_into(h);
                c.hash_into(h);
            }
            Fn1(f, a) => {
                f.hash(h);
                a.hash_into(h);
            }
            Log(a, b) => {
                a.hash_into(h);
                if let Some(b) = b {
                    b.hash_into(h);
                }
            }
        }
    }
}

fn clone_calc(c: &Calc) -> Calc {
    c.bake_with(&|leaf| match *leaf {
        Calc::Num(x) => Calc::Num(x),
        Calc::Px(x) => Calc::Px(x),
        Calc::Pct(x) => Calc::Pct(x),
        Calc::Em(x) => Calc::Em(x),
        Calc::Rem(x) => Calc::Rem(x),
        Calc::Vw(x) => Calc::Vw(x),
        Calc::Vh(x) => Calc::Vh(x),
        Calc::Vmin(x) => Calc::Vmin(x),
        Calc::Vmax(x) => Calc::Vmax(x),
        _ => Calc::Num(0.0), // bake_with only passes leaves
    })
}

fn round(m: RoundMode, v: f32, step: f32) -> f32 {
    if step == 0.0 || !step.is_finite() {
        return if step == 0.0 { f32::NAN } else { v };
    }
    let q = v / step;
    let r = match m {
        RoundMode::Nearest => (q + 0.5).floor(),
        RoundMode::Up => q.ceil(),
        RoundMode::Down => q.floor(),
        RoundMode::ToZero => q.trunc(),
    };
    r * step
}

/// A baked expression in taffy's calc slot: px and % only.
#[repr(transparent)]
pub struct Resolved(Calc);

impl Resolved {
    fn new(c: &'static Calc) -> &'static Resolved {
        // SAFETY: Resolved is a transparent wrapper around Calc.
        unsafe { &*(c as *const Calc as *const Resolved) }
    }

    /// The opaque pointer taffy stores (8-byte aligned, as it requires).
    pub fn as_ptr(&'static self) -> *const () {
        self as *const Resolved as *const ()
    }

    /// # Safety
    /// `ptr` must come from [`Resolved::as_ptr`].
    pub unsafe fn from_ptr(ptr: *const ()) -> &'static Resolved {
        unsafe { &*(ptr as *const Resolved) }
    }

    pub fn eval(&self, basis: f32) -> f32 {
        let u = Units { font_size: 16.0, viewport: (0.0, 0.0) };
        let v = self.0.eval_units(&u, basis);
        if v.is_nan() { 0.0 } else { v }
    }
}

/// Every distinct expression, kept for the life of the process (they are
/// few: the stylesheets' and styles' calc() values).
fn intern(c: Calc) -> &'static Calc {
    static MAP: OnceLock<Mutex<crate::style::FnvMap<u64, Vec<&'static Calc>>>> = OnceLock::new();
    let mut h = crate::style::Fnv::default();
    c.hash_into(&mut h);
    let key = h.finish();
    let mut map = MAP.get_or_init(Default::default).lock().unwrap_or_else(|e| e.into_inner());
    let bucket = map.entry(key).or_default();
    if let Some(found) = bucket.iter().find(|x| ***x == c) {
        return found;
    }
    let leaked: &'static Calc = Box::leak(Box::new(c));
    bucket.push(leaked);
    leaked
}

/// Recursive-descent parser over a function's argument tokens.
struct Parser<'a> {
    toks: &'a [Tok],
    i: usize,
}

impl<'a> Parser<'a> {
    fn function(name: &str, args: &[Vec<Tok>]) -> Option<Calc> {
        let sum = |a: &Vec<Tok>| Parser::sum_all(a);
        let two = |f: fn(Box<Calc>, Box<Calc>) -> Calc| -> Option<Calc> {
            Some(f(Box::new(sum(args.first()?)?), Box::new(sum(args.get(1)?)?)))
        };
        Some(match name {
            "calc" | "-webkit-calc" | "-moz-calc" => sum(args.first()?)?,
            "min" => Calc::Min(args.iter().map(sum).collect::<Option<_>>()?),
            "max" => Calc::Max(args.iter().map(sum).collect::<Option<_>>()?),
            "hypot" => Calc::Hypot(args.iter().map(sum).collect::<Option<_>>()?),
            "clamp" if args.len() == 3 => Calc::Clamp(Box::new(sum(&args[0])?), Box::new(sum(&args[1])?),
                                                      Box::new(sum(&args[2])?)),
            "round" => {
                let (mode, rest) = match args.first()?.as_slice() {
                    [Tok::Ident(m)] => (match m.as_ref() {
                        "nearest" => RoundMode::Nearest,
                        "up" => RoundMode::Up,
                        "down" => RoundMode::Down,
                        "to-zero" => RoundMode::ToZero,
                        _ => return None,
                    }, &args[1..]),
                    _ => (RoundMode::Nearest, args),
                };
                let v = sum(rest.first()?)?;
                let step = match rest.get(1) {
                    Some(s) => sum(s)?,
                    None => Calc::Num(1.0),
                };
                Calc::Round(mode, Box::new(v), Box::new(step))
            }
            "mod" => two(Calc::Mod)?,
            "rem" => two(Calc::Rem2)?,
            "pow" => two(Calc::Pow)?,
            "atan2" => two(Calc::Atan2)?,
            "log" => Calc::Log(Box::new(sum(args.first()?)?),
                               match args.get(1) { Some(b) => Some(Box::new(sum(b)?)), None => None }),
            f => {
                let op = match f {
                    "abs" => Fn1::Abs,
                    "sign" => Fn1::Sign,
                    "sqrt" => Fn1::Sqrt,
                    "exp" => Fn1::Exp,
                    "sin" => Fn1::Sin,
                    "cos" => Fn1::Cos,
                    "tan" => Fn1::Tan,
                    "asin" => Fn1::Asin,
                    "acos" => Fn1::Acos,
                    "atan" => Fn1::Atan,
                    _ => return None,
                };
                Calc::Fn1(op, Box::new(sum(args.first()?)?))
            }
        })
    }

    fn sum_all(toks: &'a [Tok]) -> Option<Calc> {
        let mut p = Parser { toks, i: 0 };
        let v = p.sum()?;
        (p.i == toks.len()).then_some(v)
    }

    fn peek(&self) -> Option<&'a Tok> {
        self.toks.get(self.i)
    }

    fn sum(&mut self) -> Option<Calc> {
        let mut acc = self.product()?;
        loop {
            match self.peek() {
                Some(Tok::Delim('+')) => {
                    self.i += 1;
                    acc = Calc::Add(Box::new(acc), Box::new(self.product()?));
                }
                Some(t) if is_minus(t) => {
                    self.i += 1;
                    acc = Calc::Sub(Box::new(acc), Box::new(self.product()?));
                }
                // `100%-2rem` (no spaces, as Tailwind writes it): the tokenizer
                // reads a signed number; treat it as a sum
                Some(Tok::Num(v) | Tok::Dim(v, _) | Tok::Pct(v)) if *v < 0.0 => {
                    acc = Calc::Add(Box::new(acc), Box::new(self.product()?));
                }
                _ => return Some(acc),
            }
        }
    }

    fn product(&mut self) -> Option<Calc> {
        let mut acc = self.unary()?;
        loop {
            match self.peek() {
                Some(Tok::Delim('*')) => {
                    self.i += 1;
                    acc = Calc::Mul(Box::new(acc), Box::new(self.unary()?));
                }
                Some(Tok::Slash) => {
                    self.i += 1;
                    acc = Calc::Div(Box::new(acc), Box::new(self.unary()?));
                }
                _ => return Some(acc),
            }
        }
    }

    fn unary(&mut self) -> Option<Calc> {
        let t = self.peek()?;
        self.i += 1;
        Some(match t {
            Tok::Delim('(') => {
                let v = self.sum()?;
                match self.peek() {
                    Some(Tok::Delim(')')) => self.i += 1,
                    _ => return None,
                }
                v
            }
            t if is_minus(t) => Calc::Mul(Box::new(Calc::Num(-1.0)), Box::new(self.unary()?)),
            Tok::Delim('+') => self.unary()?,
            Tok::Num(v) => Calc::Num(*v),
            Tok::Pct(v) => Calc::Pct(*v),
            Tok::Dim(v, unit) => leaf(*v, unit)?,
            Tok::Ident(s) => match s.as_ref() {
                "e" => Calc::Num(std::f32::consts::E),
                "pi" => Calc::Num(std::f32::consts::PI),
                "infinity" => Calc::Num(f32::INFINITY),
                "-infinity" => Calc::Num(f32::NEG_INFINITY),
                "nan" => Calc::Num(f32::NAN),
                "-e" => Calc::Num(-std::f32::consts::E),
                "-pi" => Calc::Num(-std::f32::consts::PI),
                _ => return None,
            },
            Tok::Func(fx) => Parser::function(&fx.name, &fx.args)?,
            Tok::Calc(c) => clone_calc(c),
            _ => return None,
        })
    }
}

/// `-` between spaces tokenizes as an identifier (it can start one).
fn is_minus(t: &Tok) -> bool {
    matches!(t, Tok::Delim('-')) || matches!(t, Tok::Ident(s) if s == "-")
}

/// One dimension as an expression leaf (angles become radians, times seconds).
pub fn leaf(v: f32, unit: &str) -> Option<Calc> {
    use std::f32::consts::PI;
    Some(match unit {
        "px" => Calc::Px(v),
        "rem" => Calc::Rem(v),
        "em" => Calc::Em(v),
        "ex" | "rex" => Calc::Em(v * 0.5),
        "ch" | "rch" => Calc::Em(v * 0.55),
        "cap" | "rcap" => Calc::Em(v * 0.7),
        "ic" | "ric" => Calc::Em(v),
        "lh" => Calc::Em(v * 1.3),
        "rlh" => Calc::Px(v * ROOT_FONT_SIZE * 1.3),
        "vw" | "svw" | "lvw" | "dvw" | "vi" | "svi" | "lvi" | "dvi" | "cqw" | "cqi" => Calc::Vw(v),
        "vh" | "svh" | "lvh" | "dvh" | "vb" | "svb" | "lvb" | "dvb" | "cqh" | "cqb" => Calc::Vh(v),
        "vmin" | "svmin" | "lvmin" | "dvmin" | "cqmin" => Calc::Vmin(v),
        "vmax" | "svmax" | "lvmax" | "dvmax" | "cqmax" => Calc::Vmax(v),
        "pt" => Calc::Px(v * 4.0 / 3.0),
        "pc" => Calc::Px(v * 16.0),
        "in" => Calc::Px(v * 96.0),
        "cm" => Calc::Px(v * 96.0 / 2.54),
        "mm" => Calc::Px(v * 96.0 / 25.4),
        "q" => Calc::Px(v * 96.0 / 101.6),
        "deg" => Calc::Num(v * PI / 180.0),
        "grad" => Calc::Num(v * PI / 200.0),
        "rad" => Calc::Num(v),
        "turn" => Calc::Num(v * 2.0 * PI),
        "s" => Calc::Num(v),
        "ms" => Calc::Num(v / 1000.0),
        "x" | "dppx" => Calc::Num(v),
        "dpi" => Calc::Num(v / 96.0),
        "dpcm" => Calc::Num(v * 2.54 / 96.0),
        "fr" => return None,
        _ => return None,
    })
}

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

    fn eval(s: &str, basis: f32) -> f32 {
        let t = tokenize(s);
        let Tok::Func(fx) = &t[0] else { panic!("{s}") };
        let c = Calc::parse_fn(&fx.name, &fx.args).unwrap_or_else(|| panic!("parse {s}"));
        c.eval_units(&Units { font_size: 10.0, viewport: (1000.0, 500.0) }, basis)
    }

    #[test]
    fn arithmetic_and_units() {
        assert_eq!(eval("calc(100% - 2rem)", 200.0), 168.0);
        assert_eq!(eval("calc(100%-2rem)", 200.0), 168.0);
        assert_eq!(eval("calc((1px + 2px) * 3)", 0.0), 9.0);
        assert_eq!(eval("calc(10px * 2 / 4)", 0.0), 5.0);
        assert_eq!(eval("calc(2em + 10vw)", 0.0), 120.0);
        assert_eq!(eval("calc(-1 * 5px)", 0.0), -5.0);
        assert_eq!(eval("calc(50vmin)", 0.0), 250.0);
    }

    #[test]
    fn functions() {
        assert_eq!(eval("min(10px, 5px, 20px)", 0.0), 5.0);
        assert_eq!(eval("max(10%, 30px)", 100.0), 30.0);
        assert_eq!(eval("clamp(10px, 50%, 40px)", 200.0), 40.0);
        assert_eq!(eval("round(up, 11px, 5px)", 0.0), 15.0);
        assert_eq!(eval("round(12.4px, 1px)", 0.0), 12.0);
        assert_eq!(eval("mod(-7px, 3px)", 0.0), 2.0);
        assert_eq!(eval("rem(-7px, 3px)", 0.0), -1.0);
        assert_eq!(eval("abs(-4px)", 0.0), 4.0);
        assert_eq!(eval("calc(sign(-3px) * 2px)", 0.0), -2.0);
        assert!((eval("calc(sin(90deg) * 10px)", 0.0) - 10.0).abs() < 1e-4);
        assert_eq!(eval("calc(pow(2, 3) * 1px)", 0.0), 8.0);
        assert_eq!(eval("hypot(3px, 4px)", 0.0), 5.0);
        assert!((eval("calc(pi * 1px)", 0.0) - std::f32::consts::PI).abs() < 1e-6);
    }

    #[test]
    fn interned_and_resolved() {
        let t = tokenize("calc(100% - 1em)");
        let Tok::Func(fx) = &t[0] else { panic!() };
        let a = Calc::parse_fn(&fx.name, &fx.args).unwrap();
        let b = Calc::parse_fn(&fx.name, &fx.args).unwrap();
        assert!(std::ptr::eq(a, b));
        let r = a.resolve(&Units { font_size: 20.0, viewport: (0.0, 0.0) });
        assert_eq!(r.eval(100.0), 80.0);
        assert_eq!(r.as_ptr() as usize % 8, 0);
    }
}