From a9adebcab33986adfe998ecef09b0a4bab036bfb Mon Sep 17 00:00:00 2001
From: Joshua Barretto <joshua.s.barretto@gmail.com>
Date: Sun, 19 Apr 2020 20:46:04 +0100
Subject: [PATCH] Improved rendering performance with smarter meshing order

---
 voxygen/src/mesh/terrain.rs | 25 +++++++++++++++++++++----
 voxygen/src/render/mesh.rs  | 24 +++++++++++++++++++++++-
 2 files changed, 44 insertions(+), 5 deletions(-)

diff --git a/voxygen/src/mesh/terrain.rs b/voxygen/src/mesh/terrain.rs
index 82a301040d..43ee5261d4 100644
--- a/voxygen/src/mesh/terrain.rs
+++ b/voxygen/src/mesh/terrain.rs
@@ -219,9 +219,6 @@ impl<V: RectRasterableVol<Vox = Block> + ReadVol + Debug> Meshable<TerrainPipeli
         &self,
         range: Self::Supplement,
     ) -> (Mesh<Self::Pipeline>, Mesh<Self::TranslucentPipeline>) {
-        let mut opaque_mesh = Mesh::new();
-        let mut fluid_mesh = Mesh::new();
-
         let mut light = calc_light(range, self);
 
         let mut lowest_opaque = range.size().d;
@@ -300,6 +297,12 @@ impl<V: RectRasterableVol<Vox = Block> + ReadVol + Debug> Meshable<TerrainPipeli
             highest_opaque
         }
         .min(range.size().d - 1);
+
+        // We use multiple meshes and then combine them later such that we can group similar z
+        // levels together (better rendering performance)
+        let mut opaque_meshes = vec![Mesh::new(); ((z_end + 1 - z_start).clamped(1, 60) as usize / 10).max(1)];
+        let mut fluid_mesh = Mesh::new();
+
         for x in 1..range.size().w - 1 {
             for y in 1..range.size().w - 1 {
                 let mut lights = [[[None; 3]; 3]; 3];
@@ -376,10 +379,12 @@ impl<V: RectRasterableVol<Vox = Block> + ReadVol + Debug> Meshable<TerrainPipeli
                         [[[get_color(blocks[1][1][1].as_ref(), false); 3]; 3]; 3]
                     };
 
+                    let opaque_mesh_index = ((z - z_start) * opaque_meshes.len() as i32 / (z_end + 1 - z_start).max(1)) as usize;
+                    let selected_opaque_mesh = &mut opaque_meshes[opaque_mesh_index];
                     // Create mesh polygons
                     if block.map_or(false, |vox| vox.is_opaque()) {
                         vol::push_vox_verts(
-                            &mut opaque_mesh,
+                            selected_opaque_mesh,
                             faces_to_make(&blocks, false, |vox| !vox.is_opaque()),
                             offs,
                             &colors,
@@ -414,6 +419,18 @@ impl<V: RectRasterableVol<Vox = Block> + ReadVol + Debug> Meshable<TerrainPipeli
             }
         }
 
+        let opaque_mesh = opaque_meshes
+            .into_iter()
+            .rev()
+            .fold(Mesh::new(), |mut opaque_mesh, m: Mesh<Self::Pipeline>| {
+                m.verts().chunks_exact(3).rev().for_each(|vs| {
+                    opaque_mesh.push(vs[0]);
+                    opaque_mesh.push(vs[1]);
+                    opaque_mesh.push(vs[2]);
+                });
+                opaque_mesh
+            });
+
         (opaque_mesh, fluid_mesh)
     }
 }
diff --git a/voxygen/src/render/mesh.rs b/voxygen/src/render/mesh.rs
index 1d3a45431b..9a0b6a3251 100644
--- a/voxygen/src/render/mesh.rs
+++ b/voxygen/src/render/mesh.rs
@@ -1,11 +1,16 @@
 use super::Pipeline;
 
 /// A `Vec`-based mesh structure used to store mesh data on the CPU.
-#[derive(Clone)]
 pub struct Mesh<P: Pipeline> {
     verts: Vec<P::Vertex>,
 }
 
+impl<P: Pipeline> Clone for Mesh<P> where P::Vertex: Clone {
+    fn clone(&self) -> Self {
+        Self { verts: self.verts.clone() }
+    }
+}
+
 impl<P: Pipeline> Mesh<P> {
     /// Create a new `Mesh`.
     pub fn new() -> Self { Self { verts: vec![] } }
@@ -55,6 +60,23 @@ impl<P: Pipeline> Mesh<P> {
             self.verts.push(f(vert.clone()));
         }
     }
+
+    pub fn verts(&self) -> &[P::Vertex] {
+        &self.verts
+    }
+
+    pub fn iter(&self) -> std::slice::Iter<P::Vertex> {
+        self.verts.iter()
+    }
+}
+
+impl<P: Pipeline> IntoIterator for Mesh<P> {
+    type Item = P::Vertex;
+    type IntoIter = std::vec::IntoIter<P::Vertex>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.verts.into_iter()
+    }
 }
 
 /// Represents a triangle stored on the CPU.