use crate::cameras::{Camera, OrthographicCamera, PerspectiveCamera};
use crate::core::ObjectKind;
use crate::math::{Box3, Color, Vector3};
use crate::renderer::{Renderer, ShadowMap, ViewportRect};
use crate::scene::Scene;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Pane {
Top,
Front,
Side,
Perspective,
}
impl Pane {
pub const ALL: [Pane; 4] = [Pane::Top, Pane::Front, Pane::Side, Pane::Perspective];
pub const fn index(self) -> usize {
match self {
Pane::Top => 0,
Pane::Front => 1,
Pane::Side => 2,
Pane::Perspective => 3,
}
}
pub const fn name(self) -> &'static str {
match self {
Pane::Top => "top",
Pane::Front => "front",
Pane::Side => "side",
Pane::Perspective => "perspective",
}
}
pub fn from_name(name: &str) -> Option<Pane> {
match name.to_ascii_lowercase().as_str() {
"top" => Some(Pane::Top),
"front" => Some(Pane::Front),
"side" | "right" => Some(Pane::Side),
"perspective" | "persp" => Some(Pane::Perspective),
_ => None,
}
}
}
pub trait ViewportControl {
fn size(&self) -> (f32, f32);
fn viewport(&self) -> Option<ViewportRect>;
fn set_viewport(&mut self, x: f32, y: f32, width: f32, height: f32);
fn reset_viewport(&mut self);
fn scissor(&self) -> Option<ViewportRect>;
fn set_scissor(&mut self, x: f32, y: f32, width: f32, height: f32);
fn reset_scissor(&mut self);
fn scissor_test(&self) -> bool;
fn set_scissor_test(&mut self, enabled: bool);
fn auto_clear(&self) -> bool;
fn set_auto_clear(&mut self, enabled: bool);
fn shadow_map(&mut self) -> Option<&mut ShadowMap> {
None
}
}
macro_rules! forward_viewport_control {
($ty:ty) => {
impl ViewportControl for $ty {
fn size(&self) -> (f32, f32) {
<$ty>::size(self)
}
fn viewport(&self) -> Option<ViewportRect> {
<$ty>::viewport(self)
}
fn set_viewport(&mut self, x: f32, y: f32, width: f32, height: f32) {
<$ty>::set_viewport(self, x, y, width, height)
}
fn reset_viewport(&mut self) {
<$ty>::reset_viewport(self)
}
fn scissor(&self) -> Option<ViewportRect> {
<$ty>::scissor(self)
}
fn set_scissor(&mut self, x: f32, y: f32, width: f32, height: f32) {
<$ty>::set_scissor(self, x, y, width, height)
}
fn reset_scissor(&mut self) {
<$ty>::reset_scissor(self)
}
fn scissor_test(&self) -> bool {
<$ty>::scissor_test(self)
}
fn set_scissor_test(&mut self, enabled: bool) {
<$ty>::set_scissor_test(self, enabled)
}
fn auto_clear(&self) -> bool {
<$ty>::auto_clear(self)
}
fn set_auto_clear(&mut self, enabled: bool) {
<$ty>::set_auto_clear(self, enabled)
}
fn shadow_map(&mut self) -> Option<&mut ShadowMap> {
Some(<$ty>::shadow_map_mut(self))
}
}
};
}
forward_viewport_control!(Renderer);
cfg_metal! {
forward_viewport_control!(crate::metal::MetalRenderer);
}
pub trait PaneSurface {
fn renderer(&mut self) -> &mut dyn ViewportControl;
fn draw(&mut self, scene: &mut Scene, camera: &dyn Camera);
fn clear(&mut self, color: Color, alpha: f32);
}
pub struct ViewSurface<'a> {
pub renderer: &'a mut Renderer,
pub view: &'a wgpu::TextureView,
pub linear_framebuffer: bool,
}
impl PaneSurface for ViewSurface<'_> {
fn renderer(&mut self) -> &mut dyn ViewportControl {
self.renderer
}
fn draw(&mut self, scene: &mut Scene, camera: &dyn Camera) {
self.renderer
.render(scene, camera, self.view, self.linear_framebuffer);
}
fn clear(&mut self, color: Color, alpha: f32) {
self.renderer
.clear(self.view, self.linear_framebuffer, color, alpha);
}
}
#[cfg(not(target_arch = "wasm32"))]
impl PaneSurface for crate::HeadlessRenderer {
fn renderer(&mut self) -> &mut dyn ViewportControl {
crate::HeadlessRenderer::renderer(self)
}
fn draw(&mut self, scene: &mut Scene, camera: &dyn Camera) {
self.render(scene, camera);
}
fn clear(&mut self, color: Color, alpha: f32) {
crate::HeadlessRenderer::clear(self, color, alpha);
}
}
cfg_metal! {
impl PaneSurface for crate::metal::MetalHeadlessRenderer {
fn renderer(&mut self) -> &mut dyn ViewportControl {
crate::metal::MetalHeadlessRenderer::renderer(self)
}
fn draw(&mut self, scene: &mut Scene, camera: &dyn Camera) {
if let Err(e) = self.render(scene, camera) {
log::warn!("quad view: metal pane render failed: {e}");
}
}
fn clear(&mut self, color: Color, alpha: f32) {
if let Err(e) = crate::metal::MetalHeadlessRenderer::clear(self, color, alpha) {
log::warn!("quad view: metal clear failed: {e}");
}
}
}
}
cfg_metal! {
pub struct MetalViewSurface<'a> {
renderer: &'a mut crate::metal::MetalRenderer,
pass: crate::metal::PassAttachments,
}
}
cfg_metal! {
impl<'a> MetalViewSurface<'a> {
pub fn new(
renderer: &'a mut crate::metal::MetalRenderer,
pass: crate::metal::PassAttachments,
) -> Self {
let (w, h) = pass.size();
renderer.set_drawing_buffer_size(w, h);
Self { renderer, pass }
}
pub fn present(self) -> Result<(), crate::metal::MetalError> {
self.renderer.present(&self.pass)
}
}
}
cfg_metal! {
impl PaneSurface for MetalViewSurface<'_> {
fn renderer(&mut self) -> &mut dyn ViewportControl {
self.renderer
}
fn draw(&mut self, scene: &mut Scene, camera: &dyn Camera) {
let pass = self.pass.without_drawable();
if let Err(e) = self.renderer.render(scene, camera, &pass) {
log::warn!("quad view: metal pane render failed: {e}");
}
}
fn clear(&mut self, color: Color, alpha: f32) {
if let Err(e) = self.renderer.clear(&self.pass, color, alpha) {
log::warn!("quad view: metal clear failed: {e}");
}
}
}
}
#[derive(Clone, Debug)]
pub struct QuadView {
pub top: OrthographicCamera,
pub front: OrthographicCamera,
pub side: OrthographicCamera,
pub layout: [Pane; 4],
pub gap: f32,
pub border: f32,
pub gap_color: Option<Color>,
pub backgrounds: [Option<Color>; 4],
pub maximized: Option<Pane>,
pub margin: f32,
pub zoom: f32,
pub share_shadows: bool,
center: Vector3,
box_center: Vector3,
half: Vector3,
}
impl Default for QuadView {
fn default() -> Self {
Self::new()
}
}
impl QuadView {
pub fn new() -> Self {
let cam = || OrthographicCamera::new(-1.0, 1.0, 1.0, -1.0, 0.1, 10.0);
let mut q = Self {
top: cam(),
front: cam(),
side: cam(),
layout: [Pane::Top, Pane::Perspective, Pane::Front, Pane::Side],
gap: 2.0,
border: 0.0,
gap_color: Some(Color::from_hex(0x303030)),
backgrounds: [None; 4],
maximized: None,
margin: 0.1,
zoom: 1.0,
share_shadows: true,
center: Vector3::ZERO,
box_center: Vector3::ZERO,
half: Vector3::new(1.0, 1.0, 1.0),
};
q.place_cameras();
q
}
pub fn toggle_maximize(&mut self, pane: Pane) {
self.maximized = if self.maximized == Some(pane) {
None
} else {
Some(pane)
};
}
pub fn ortho_camera(&self, pane: Pane) -> Option<&OrthographicCamera> {
match pane {
Pane::Top => Some(&self.top),
Pane::Front => Some(&self.front),
Pane::Side => Some(&self.side),
Pane::Perspective => None,
}
}
pub fn ortho_camera_mut(&mut self, pane: Pane) -> Option<&mut OrthographicCamera> {
match pane {
Pane::Top => Some(&mut self.top),
Pane::Front => Some(&mut self.front),
Pane::Side => Some(&mut self.side),
Pane::Perspective => None,
}
}
pub fn frame_box(&mut self, bounds: &Box3) {
if bounds.is_empty() {
return;
}
self.center = bounds.center();
self.box_center = self.center;
self.zoom = 1.0;
let s = bounds.size();
let eps = (s.x.max(s.y).max(s.z) * 1e-3).max(1e-4);
self.half = Vector3::new(
(s.x * 0.5).max(eps),
(s.y * 0.5).max(eps),
(s.z * 0.5).max(eps),
);
self.place_cameras();
}
pub fn frame_scene(&mut self, scene: &mut Scene) -> Option<Box3> {
let b = scene_bounds(scene)?;
self.frame_box(&b);
Some(b)
}
pub fn target(&self) -> Vector3 {
self.center
}
pub fn pan_by(&mut self, delta: Vector3) {
self.center = self.center + delta;
self.place_cameras();
}
pub fn pane_axes(pane: Pane) -> Option<(Vector3, Vector3)> {
match pane {
Pane::Top => Some((Vector3::new(1.0, 0.0, 0.0), Vector3::new(0.0, 0.0, -1.0))),
Pane::Front => Some((Vector3::new(1.0, 0.0, 0.0), Vector3::new(0.0, 1.0, 0.0))),
Pane::Side => Some((Vector3::new(0.0, 0.0, -1.0), Vector3::new(0.0, 1.0, 0.0))),
Pane::Perspective => None,
}
}
fn place_cameras(&mut self) {
let r = self.half.length().max(1e-4);
let d = 2.0 * r;
let (pan, depth) = (self.center, self.box_center);
let place = |cam: &mut OrthographicCamera, dir: Vector3, up: Vector3, _: Vector3| {
let c = pan - dir * (pan - depth).dot(dir);
cam.position = c + dir * d;
cam.target = c;
cam.up = up;
cam.near = 0.5 * r;
cam.far = 3.5 * r;
};
let c = self.center;
place(
&mut self.top,
Vector3::new(0.0, 1.0, 0.0),
Vector3::new(0.0, 0.0, -1.0),
c,
);
place(
&mut self.front,
Vector3::new(0.0, 0.0, 1.0),
Vector3::new(0.0, 1.0, 0.0),
c,
);
place(
&mut self.side,
Vector3::new(1.0, 0.0, 0.0),
Vector3::new(0.0, 1.0, 0.0),
c,
);
}
fn view_half(&self, pane: Pane) -> (f32, f32) {
let h = self.half;
match pane {
Pane::Top => (h.x, h.z),
Pane::Front => (h.x, h.y),
Pane::Side => (h.z, h.y),
Pane::Perspective => (0.0, 0.0),
}
}
pub fn visible_panes(&self, width: f32, height: f32) -> Vec<(Pane, ViewportRect)> {
self.panes(width, height).collect()
}
fn panes(&self, width: f32, height: f32) -> impl Iterator<Item = (Pane, ViewportRect)> + '_ {
Pane::ALL
.into_iter()
.filter_map(move |p| self.pane_rect(p, width, height).map(|r| (p, r)))
}
pub fn pane_rect(&self, pane: Pane, width: f32, height: f32) -> Option<ViewportRect> {
let b = self.border.max(0.0);
let g = self.gap.max(0.0);
let inner_w = (width - 2.0 * b).max(0.0);
let inner_h = (height - 2.0 * b).max(0.0);
if let Some(m) = self.maximized {
return (m == pane).then(|| ViewportRect::new(b, b, inner_w, inner_h));
}
let slot = self.layout.iter().position(|&p| p == pane)?;
let left_w = ((inner_w - g) * 0.5).floor().max(0.0);
let bottom_h = ((inner_h - g) * 0.5).floor().max(0.0);
let right_x = b + left_w + g;
let right_w = (width - b - right_x).max(0.0);
let top_y = b + bottom_h + g;
let top_h = (height - b - top_y).max(0.0);
let (col_right, row_top) = (slot % 2 == 1, slot < 2);
let (x, w) = if col_right {
(right_x, right_w)
} else {
(b, left_w)
};
let (y, h) = if row_top {
(top_y, top_h)
} else {
(b, bottom_h)
};
Some(ViewportRect::new(x, y, w, h))
}
pub fn pane_at(&self, x: f32, y: f32, width: f32, height: f32) -> Option<Pane> {
Pane::ALL.into_iter().find(|&p| {
self.pane_rect(p, width, height)
.is_some_and(|r| r.contains(x, y))
})
}
pub fn units_per_pixel(&self, width: f32, height: f32) -> Option<f32> {
let pad = 1.0 + self.margin.max(0.0);
let mut upp: f32 = 0.0;
for (p, r) in self.panes(width, height) {
if p == Pane::Perspective || r.width <= 0.0 || r.height <= 0.0 {
continue;
}
let (hx, hy) = self.view_half(p);
upp = upp
.max(2.0 * hx * pad / r.width)
.max(2.0 * hy * pad / r.height);
}
let zoom = if self.zoom.is_finite() && self.zoom > 0.0 {
self.zoom
} else {
1.0
};
(upp > 0.0).then_some(upp / zoom)
}
pub fn fit(&mut self, width: f32, height: f32) {
let Some(upp) = self.units_per_pixel(width, height) else {
return;
};
for p in [Pane::Top, Pane::Front, Pane::Side] {
let Some(r) = self.pane_rect(p, width, height) else {
continue;
};
if let Some(cam) = self.ortho_camera_mut(p) {
let (hw, hh) = (0.5 * r.width * upp, 0.5 * r.height * upp);
cam.left = -hw;
cam.right = hw;
cam.top = hh;
cam.bottom = -hh;
}
}
}
pub fn render<S: PaneSurface + ?Sized>(
&mut self,
surface: &mut S,
scene: &mut Scene,
perspective: &PerspectiveCamera,
) {
let (w, h) = surface.renderer().size();
self.fit(w, h);
let r = surface.renderer();
let saved = (r.viewport(), r.scissor(), r.scissor_test(), r.auto_clear());
r.set_auto_clear(true);
r.set_scissor_test(true);
let shared_shadows = if self.share_shadows {
r.shadow_map().filter(|m| m.auto_update).map(|m| {
let saved = *m;
m.auto_update = false;
m.needs_update = true;
saved
})
} else {
None
};
if let Some(gc) = self.gap_color
&& (self.gap > 0.0 || self.border > 0.0)
{
surface.renderer().reset_scissor();
surface.clear(gc, 1.0);
}
for (pane, rect) in self.panes(w, h) {
if rect.width <= 0.0 || rect.height <= 0.0 {
continue;
}
let r = surface.renderer();
r.set_viewport(rect.x, rect.y, rect.width, rect.height);
r.set_scissor(rect.x, rect.y, rect.width, rect.height);
let saved_bg = scene.background;
if let Some(bg) = self.backgrounds[pane.index()] {
scene.background = bg;
}
match pane {
Pane::Perspective => {
let mut cam = perspective.clone();
cam.set_aspect(rect.aspect());
surface.draw(scene, &cam);
}
_ => {
let cam = self.ortho_camera(pane).cloned().expect("ortho pane");
surface.draw(scene, &cam);
}
}
scene.background = saved_bg;
}
let r = surface.renderer();
match saved.0 {
Some(v) => r.set_viewport(v.x, v.y, v.width, v.height),
None => r.reset_viewport(),
}
match saved.1 {
Some(s) => r.set_scissor(s.x, s.y, s.width, s.height),
None => r.reset_scissor(),
}
r.set_scissor_test(saved.2);
r.set_auto_clear(saved.3);
if let (Some(saved), Some(m)) = (shared_shadows, r.shadow_map()) {
*m = saved;
}
}
#[cfg(metal_backend)]
pub fn metal_views(
&mut self,
perspective: &PerspectiveCamera,
width: f32,
height: f32,
pixel_ratio: f32,
) -> Vec<crate::metal::RenderView> {
use crate::metal::{enums::MTLViewport, RenderView};
self.fit(width, height);
let pr = if pixel_ratio > 0.0 { pixel_ratio } else { 1.0 };
let target_h = (height * pr).round() as i64;
self.panes(width, height)
.filter(|(_, r)| r.width > 0.0 && r.height > 0.0)
.map(|(pane, r)| {
let view = match pane {
Pane::Perspective => {
let mut cam = perspective.clone();
cam.set_aspect(r.aspect());
RenderView::from_camera(&cam)
}
_ => RenderView::from_camera(self.ortho_camera(pane).expect("ortho pane")),
};
let d = r.to_device(pr);
view.with_viewport(MTLViewport {
origin_x: d.x as f64,
origin_y: (target_h - d.y - d.h) as f64,
width: d.w as f64,
height: d.h as f64,
znear: 0.0,
zfar: 1.0,
})
})
.collect()
}
}
pub fn scene_bounds(scene: &mut Scene) -> Option<Box3> {
scene.update_world();
let mut total = Box3::empty();
for (_, obj) in scene.arena.nodes.iter() {
if !obj.visible {
continue;
}
let geom = match &obj.kind {
ObjectKind::Mesh(m) => &m.geometry,
_ => continue,
};
let local = match geom.bounding_box {
Some(b) => b,
None => {
let Some(points) = geom.positions() else {
continue;
};
let mut b = Box3::empty();
for p in points {
b.expand_by_point(p);
}
b
}
};
if local.is_empty() {
continue;
}
total = total.union(&local.apply_matrix4(&obj.matrix_world));
}
(!total.is_empty()).then_some(total)
}
#[cfg(test)]
mod tests {
use super::*;
fn quad() -> QuadView {
let mut q = QuadView::new();
q.gap = 4.0;
q.border = 2.0;
q
}
#[test]
fn panes_tile_the_target_with_exact_gaps() {
let q = quad();
let (w, h) = (801.0, 601.0);
let tl = q.pane_rect(Pane::Top, w, h).unwrap();
let tr = q.pane_rect(Pane::Perspective, w, h).unwrap();
let bl = q.pane_rect(Pane::Front, w, h).unwrap();
let br = q.pane_rect(Pane::Side, w, h).unwrap();
assert_eq!((bl.x, bl.y), (2.0, 2.0));
assert_eq!(tr.x + tr.width, w - 2.0);
assert_eq!(tr.y + tr.height, h - 2.0);
assert_eq!(br.x - (bl.x + bl.width), 4.0);
assert_eq!(tl.y - (bl.y + bl.height), 4.0);
assert_eq!((tl.x, tl.width), (bl.x, bl.width));
assert_eq!((tr.x, tr.width), (br.x, br.width));
assert_eq!((tl.y, tl.height), (tr.y, tr.height));
assert_eq!((bl.y, bl.height), (br.y, br.height));
for r in [tl, tr, bl, br] {
for v in [r.x, r.y, r.width, r.height] {
assert_eq!(v, v.floor());
}
}
assert_eq!(bl.width, 396.0);
assert_eq!(br.width, 397.0);
assert!(tl.y > bl.y);
}
#[test]
fn pane_names_round_trip() {
for p in Pane::ALL {
assert_eq!(Pane::from_name(p.name()), Some(p));
}
assert_eq!(Pane::from_name("Persp"), Some(Pane::Perspective));
assert_eq!(Pane::from_name("right"), Some(Pane::Side));
assert_eq!(Pane::from_name("back"), None);
}
#[test]
fn maximise_shows_one_pane_and_toggles_back() {
let mut q = quad();
q.toggle_maximize(Pane::Front);
let panes = q.visible_panes(400.0, 300.0);
assert_eq!(panes.len(), 1);
assert_eq!(
panes[0],
(Pane::Front, ViewportRect::new(2.0, 2.0, 396.0, 296.0))
);
assert!(q.pane_rect(Pane::Top, 400.0, 300.0).is_none());
q.toggle_maximize(Pane::Front);
assert_eq!(q.visible_panes(400.0, 300.0).len(), 4);
q.toggle_maximize(Pane::Top);
q.toggle_maximize(Pane::Side);
assert_eq!(q.maximized, Some(Pane::Side));
}
#[test]
fn hit_testing_finds_panes_and_misses_gaps() {
let q = quad();
let (w, h) = (400.0, 300.0);
assert_eq!(q.pane_at(10.0, 10.0, w, h), Some(Pane::Front));
assert_eq!(q.pane_at(390.0, 290.0, w, h), Some(Pane::Perspective));
assert_eq!(q.pane_at(10.0, 290.0, w, h), Some(Pane::Top));
assert_eq!(q.pane_at(390.0, 10.0, w, h), Some(Pane::Side));
let bl = q.pane_rect(Pane::Front, w, h).unwrap();
assert_eq!(q.pane_at(bl.x + bl.width + 1.0, 10.0, w, h), None);
assert_eq!(q.pane_at(0.5, 0.5, w, h), None, "border");
}
#[test]
fn cameras_follow_the_documented_axes() {
let mut q = QuadView::new();
q.frame_box(&Box3::new(
Vector3::new(-1.0, -2.0, -3.0),
Vector3::new(1.0, 2.0, 3.0),
));
q.fit(400.0, 400.0);
let ndc = |cam: &OrthographicCamera, p: Vector3| cam.world_to_ndc(p).unwrap();
let o = Vector3::ZERO;
let check = |cam: &OrthographicCamera, right: Vector3, up: Vector3| {
let c = ndc(cam, o);
let r = ndc(cam, right);
let u = ndc(cam, up);
assert!(r.x > c.x + 1e-3 && (r.y - c.y).abs() < 1e-4, "right {r:?}");
assert!(u.y > c.y + 1e-3 && (u.x - c.x).abs() < 1e-4, "up {u:?}");
};
check(
&q.top,
Vector3::new(0.5, 0.0, 0.0),
Vector3::new(0.0, 0.0, -0.5),
);
check(
&q.front,
Vector3::new(0.5, 0.0, 0.0),
Vector3::new(0.0, 0.5, 0.0),
);
check(
&q.side,
Vector3::new(0.0, 0.0, -0.5),
Vector3::new(0.0, 0.5, 0.0),
);
}
#[test]
fn ortho_fit_contains_the_box_with_one_shared_scale() {
let mut q = QuadView::new();
q.gap = 0.0;
q.margin = 0.0;
let b = Box3::new(Vector3::new(-1.0, -2.0, -3.0), Vector3::new(1.0, 2.0, 3.0));
q.frame_box(&b);
q.fit(800.0, 600.0);
for cam in [&q.top, &q.front, &q.side] {
for i in 0..8 {
let p = Vector3::new(
if i & 1 == 0 { b.min.x } else { b.max.x },
if i & 2 == 0 { b.min.y } else { b.max.y },
if i & 4 == 0 { b.min.z } else { b.max.z },
);
let n = cam.world_to_ndc(p).unwrap();
assert!(n.x.abs() <= 1.0 + 1e-4 && n.y.abs() <= 1.0 + 1e-4, "{n:?}");
assert!((0.0..=1.0).contains(&n.z), "depth {n:?}");
}
}
let height = |c: &OrthographicCamera| c.top - c.bottom;
assert!((height(&q.top) - height(&q.front)).abs() < 1e-5);
assert!((height(&q.front) - height(&q.side)).abs() < 1e-5);
for cam in [&q.top, &q.front, &q.side] {
let a = (cam.right - cam.left) / (cam.top - cam.bottom);
assert!((a - 4.0 / 3.0).abs() < 1e-5);
}
let top_h = q.top.top - q.top.bottom;
assert!((top_h - 6.0).abs() < 1e-4, "{top_h}");
let side_w = q.side.right - q.side.left;
assert!((side_w - 8.0).abs() < 1e-4, "{side_w}");
}
#[test]
fn frame_scene_finds_mesh_bounds() {
use crate::{BasicMaterial, BoxGeometry, Material, Mesh, Object3D};
let mut scene = Scene::new();
let mut o = Object3D::mesh(Mesh::new(
BoxGeometry::new(2.0, 2.0, 2.0),
Material::Basic(BasicMaterial::new(Color::WHITE)),
));
o.position = Vector3::new(10.0, 0.0, 0.0);
scene.add(o);
let mut q = QuadView::new();
let b = q.frame_scene(&mut scene).unwrap();
assert!((b.min.x - 9.0).abs() < 1e-5 && (b.max.x - 11.0).abs() < 1e-5);
assert_eq!(q.target(), Vector3::new(10.0, 0.0, 0.0));
assert!(QuadView::new().frame_scene(&mut Scene::new()).is_none());
}
}