Add support for Z order

Author: 38

src/coord/ranged3d/cartesian3d.rs

@@ -102,4 +102,8 @@ impl<X: Ranged, Y: Ranged, Z: Ranged> CoordTranslate for Cartesian3d<X, Y, Z> {
         let pixel_coord_3d = self.map_3d(&coord.0, &coord.1, &coord.2);
         self.projection * pixel_coord_3d
     }
+
+    fn depth(&self, coord: &Self::From) -> i32 {
+        self.projected_depth(&coord.0, &coord.1, &coord.2)
+    }
 }

src/coord/translate.rs

@@ -7,6 +7,11 @@ pub trait CoordTranslate {
 
     /// Translate the guest coordinate to the guest coordinate
     fn translate(&self, from: &Self::From) -> BackendCoord;
+
+    /// Get the Z-value of current coordinate
+    fn depth(&self, _from: &Self::From) -> i32 {
+        0
+    }
 }
 
 impl<C, T> CoordTranslate for T

src/drawing/area.rs

@@ -1,7 +1,7 @@
 use crate::coord::cartesian::{Cartesian2d, MeshLine};
 use crate::coord::ranged1d::{KeyPointHint, Ranged};
 use crate::coord::{CoordTranslate, Shift};
-use crate::element::{Drawable, PointCollection};
+use crate::element::{CoordMapper, Drawable, PointCollection};
 use crate::style::text_anchor::{HPos, Pos, VPos};
 use crate::style::{Color, SizeDesc, TextStyle};
 
@@ -17,7 +17,7 @@ use std::rc::Rc;
 
 /// The representation of the rectangle in backend canvas
 #[derive(Clone, Debug)]
-struct Rect {
+pub struct Rect {
     x0: i32,
     y0: i32,
     x1: i32,
@@ -104,7 +104,7 @@ impl Rect {
     }
 
     /// Make the coordinate in the range of the rectangle
-    fn truncate(&self, p: (i32, i32)) -> (i32, i32) {
+    pub fn truncate(&self, p: (i32, i32)) -> (i32, i32) {
         (p.0.min(self.x1).max(self.x0), p.1.min(self.y1).max(self.y0))
     }
 }
@@ -308,14 +308,15 @@ impl<DB: DrawingBackend, CT: CoordTranslate> DrawingArea<DB, CT> {
     }
 
     /// Draw an high-level element
-    pub fn draw<'a, E>(&self, element: &'a E) -> Result<(), DrawingAreaError<DB>>
+    pub fn draw<'a, E, B>(&self, element: &'a E) -> Result<(), DrawingAreaError<DB>>
     where
-        &'a E: PointCollection<'a, CT::From>,
-        E: Drawable<DB>,
+        B: CoordMapper,
+        &'a E: PointCollection<'a, CT::From, B>,
+        E: Drawable<DB, B>,
     {
         let backend_coords = element.point_iter().into_iter().map(|p| {
             let b = p.borrow();
-            self.rect.truncate(self.coord.translate(b))
+            B::map(&self.coord, b, &self.rect)
         });
         self.backend_ops(move |b| element.draw(backend_coords, b, self.dim_in_pixel()))
     }

src/drawing/mod.rs

@@ -13,6 +13,6 @@ about the [coordinate abstraction](../coord/index.html) and [element system](../
 mod area;
 mod backend_impl;
 
-pub use area::{DrawingArea, DrawingAreaErrorKind, IntoDrawingArea};
+pub use area::{DrawingArea, DrawingAreaErrorKind, IntoDrawingArea, Rect};
 
 pub use backend_impl::*;

src/element/basic_shapes_3d.rs

@@ -0,0 +1,82 @@
+use super::{BackendCoordAndZ, Drawable, PointCollection};
+use crate::style::ShapeStyle;
+use plotters_backend::{BackendCoord, DrawingBackend, DrawingErrorKind};
+
+pub struct Cubiod<X, Y, Z> {
+    face_style: ShapeStyle,
+    edge_style: ShapeStyle,
+    vert: [(X, Y, Z); 8],
+}
+
+impl<X: Clone, Y: Clone, Z: Clone> Cubiod<X, Y, Z> {
+    pub fn new<FS: Into<ShapeStyle>, ES: Into<ShapeStyle>>(
+        [(x0, y0, z0), (x1, y1, z1)]: [(X, Y, Z); 2],
+        face_style: FS,
+        edge_style: ES,
+    ) -> Self {
+        Self {
+            face_style: face_style.into(),
+            edge_style: edge_style.into(),
+            vert: [
+                (x0.clone(), y0.clone(), z0.clone()),
+                (x0.clone(), y0.clone(), z1.clone()),
+                (x0.clone(), y1.clone(), z0.clone()),
+                (x0.clone(), y1.clone(), z1.clone()),
+                (x1.clone(), y0.clone(), z0.clone()),
+                (x1.clone(), y0.clone(), z1.clone()),
+                (x1.clone(), y1.clone(), z0.clone()),
+                (x1.clone(), y1.clone(), z1.clone()),
+            ],
+        }
+    }
+}
+
+impl<'a, X: 'a, Y: 'a, Z: 'a> PointCollection<'a, (X, Y, Z), BackendCoordAndZ>
+    for &'a Cubiod<X, Y, Z>
+{
+    type Point = &'a (X, Y, Z);
+    type IntoIter = &'a [(X, Y, Z)];
+    fn point_iter(self) -> Self::IntoIter {
+        &self.vert
+    }
+}
+
+impl<X, Y, Z, DB: DrawingBackend> Drawable<DB, BackendCoordAndZ> for Cubiod<X, Y, Z> {
+    fn draw<I: Iterator<Item = (BackendCoord, i32)>>(
+        &self,
+        points: I,
+        backend: &mut DB,
+        _: (u32, u32),
+    ) -> Result<(), DrawingErrorKind<DB::ErrorType>> {
+        let vert: Vec<_> = points.collect();
+        let mut polygon = vec![];
+        for mask in vec![1, 2, 4] {
+            let mask_a = if mask == 4 { 1 } else { mask * 2 };
+            let mask_b = if mask == 1 { 4 } else { mask / 2 };
+            let a = 0;
+            let b = a | mask_a;
+            let c = a | mask_a | mask_b;
+            let d = a | mask_b;
+            polygon.push([vert[a], vert[b], vert[c], vert[d]]);
+            polygon.push([
+                vert[a | mask],
+                vert[b | mask],
+                vert[c | mask],
+                vert[d | mask],
+            ]);
+        }
+        polygon.sort_by_cached_key(|t| std::cmp::Reverse(t[0].1 + t[1].1 + t[2].1 + t[3].1));
+
+        for p in polygon {
+            backend.fill_polygon(p.iter().map(|(coord, _)| *coord), &self.face_style)?;
+            backend.draw_path(
+                p.iter()
+                    .map(|(coord, _)| *coord)
+                    .chain(std::iter::once(p[0].0)),
+                &self.edge_style,
+            )?;
+        }
+
+        Ok(())
+    }
+}

src/element/mod.rs

@@ -160,6 +160,9 @@ use std::borrow::Borrow;
 mod basic_shapes;
 pub use basic_shapes::*;
 
+mod basic_shapes_3d;
+pub use basic_shapes_3d::*;
+
 mod text;
 pub use text::*;
 
@@ -192,6 +195,9 @@ pub use self::image::BitMapElement;
 mod dynelem;
 pub use dynelem::{DynElement, IntoDynElement};
 
+use crate::coord::CoordTranslate;
+use crate::drawing::Rect;
+
 /// A type which is logically a collection of points, under any given coordinate system.
 /// Note: Ideally, a point collection trait should be any type of which coordinate elements can be
 /// iterated. This is similar to `iter` method of many collection types in std.
@@ -220,7 +226,7 @@ pub use dynelem::{DynElement, IntoDynElement};
 ///
 /// TODO: Once GAT is ready on stable Rust, we should simplify the design.
 ///
-pub trait PointCollection<'a, Coord> {
+pub trait PointCollection<'a, Coord, CM = BackendCoordOnly> {
     /// The item in point iterator
     type Point: Borrow<Coord> + 'a;
 
@@ -231,13 +237,42 @@ pub trait PointCollection<'a, Coord> {
     fn point_iter(self) -> Self::IntoIter;
 }
 /// The trait indicates we are able to draw it on a drawing area
-pub trait Drawable<DB: DrawingBackend> {
+pub trait Drawable<DB: DrawingBackend, CM: CoordMapper = BackendCoordOnly> {
     /// Actually draws the element. The key points is already translated into the
     /// image coordinate and can be used by DC directly
-    fn draw<I: Iterator<Item = BackendCoord>>(
+    fn draw<I: Iterator<Item = CM::Output>>(
         &self,
         pos: I,
         backend: &mut DB,
         parent_dim: (u32, u32),
     ) -> Result<(), DrawingErrorKind<DB::ErrorType>>;
 }
+
+pub trait CoordMapper {
+    type Output;
+    fn map<CT: CoordTranslate>(coord_trans: &CT, from: &CT::From, rect: &Rect) -> Self::Output;
+}
+
+pub struct BackendCoordOnly;
+
+impl CoordMapper for BackendCoordOnly {
+    type Output = BackendCoord;
+    fn map<CT: CoordTranslate>(coord_trans: &CT, from: &CT::From, rect: &Rect) -> BackendCoord {
+        rect.truncate(coord_trans.translate(from))
+    }
+}
+
+pub struct BackendCoordAndZ;
+
+impl CoordMapper for BackendCoordAndZ {
+    type Output = (BackendCoord, i32);
+    fn map<CT: CoordTranslate>(
+        coord_trans: &CT,
+        from: &CT::From,
+        rect: &Rect,
+    ) -> (BackendCoord, i32) {
+        let coord = rect.truncate(coord_trans.translate(from));
+        let z = coord_trans.depth(from);
+        (coord, z)
+    }
+}