zed/crates/gpui3/src/scene.rs

use std::cmp;

use super::{Bounds, Hsla, Pixels, Point};
use crate::{Corners, Edges, FontId, GlyphId};
use bytemuck::{Pod, Zeroable};
use plane_split::BspSplitter;

// Exported to metal
pub type PointF = Point<f32>;

pub struct Scene {
    opaque_primitives: PrimitiveBatch,
    transparent_primitives: slotmap::SlotMap<slotmap::DefaultKey, Primitive>,
    splitter: BspSplitter<slotmap::DefaultKey>,
    max_order: u32,
    scale_factor: f32,
}

impl Scene {
    pub fn new(scale_factor: f32) -> Scene {
        Scene {
            opaque_primitives: PrimitiveBatch::default(),
            transparent_primitives: slotmap::SlotMap::new(),
            splitter: BspSplitter::new(),
            max_order: 0,
            scale_factor,
        }
    }

    pub fn insert(&mut self, primitive: impl Into<Primitive>) {
        let mut primitive = primitive.into();
        primitive.scale(self.scale_factor);
        self.max_order = cmp::max(self.max_order, primitive.order());
        match primitive {
            Primitive::Quad(quad) => self.opaque_primitives.quads.push(quad),
        }
    }

    pub fn opaque_primitives(&self) -> &PrimitiveBatch {
        &self.opaque_primitives
    }

    pub fn max_order(&self) -> u32 {
        self.max_order
    }
}

#[derive(Clone, Debug)]
pub enum Primitive {
    Quad(Quad),
}

impl Primitive {
    pub fn order(&self) -> u32 {
        match self {
            Primitive::Quad(quad) => quad.order,
        }
    }

    pub fn is_transparent(&self) -> bool {
        match self {
            Primitive::Quad(quad) => {
                quad.background.is_transparent() && quad.border_color.is_transparent()
            }
        }
    }

    pub fn scale(&mut self, factor: f32) {
        match self {
            Primitive::Quad(quad) => {
                quad.scale(factor);
            }
        }
    }
}

#[derive(Default)]
pub struct PrimitiveBatch {
    pub quads: Vec<Quad>,
}

#[derive(Debug, Clone, Copy, Zeroable, Pod)]
#[repr(C)]
pub struct Quad {
    pub order: u32,
    pub bounds: Bounds<Pixels>,
    pub clip_bounds: Bounds<Pixels>,
    pub clip_corner_radii: Corners<Pixels>,
    pub background: Hsla,
    pub border_color: Hsla,
    pub corner_radii: Corners<Pixels>,
    pub border_widths: Edges<Pixels>,
}

impl Quad {
    pub fn vertices(&self) -> impl Iterator<Item = Point<Pixels>> {
        let x1 = self.bounds.origin.x;
        let y1 = self.bounds.origin.y;
        let x2 = x1 + self.bounds.size.width;
        let y2 = y1 + self.bounds.size.height;
        [
            Point::new(x1, y1),
            Point::new(x2, y1),
            Point::new(x2, y2),
            Point::new(x1, y2),
        ]
        .into_iter()
    }
}

impl Quad {
    pub fn scale(&mut self, factor: f32) {
        self.bounds.origin *= factor;
        self.bounds.size *= factor;
        self.clip_bounds.origin *= factor;
        self.clip_corner_radii *= factor;
        self.corner_radii *= factor;
        self.border_widths *= factor;
    }
}

impl From<Quad> for Primitive {
    fn from(quad: Quad) -> Self {
        Primitive::Quad(quad)
    }
}