From aeaa611005b32d38554ba50935ffc32abef421e2 Mon Sep 17 00:00:00 2001
From: Emil Ernerfeldt <emilernerfeldt@gmail.com>
Date: Tue, 19 May 2020 20:54:02 +0200
Subject: [PATCH] terminology: remove uses of the word "mesh". Prefer
 "triangles".

---
 emigui/README.md            |   2 +-
 emigui/src/context.rs       |  25 ++---
 emigui/src/lib.rs           |   2 +-
 emigui/src/mesher.rs        | 194 +++++++++++++++++++-----------------
 emigui/src/texture_atlas.rs |  14 +--
 emigui/src/types.rs         |   5 +-
 emigui_glium/src/painter.rs |  12 +--
 emigui_wasm/src/webgl.rs    |  22 ++--
 8 files changed, 141 insertions(+), 135 deletions(-)

diff --git a/emigui/README.md b/emigui/README.md
index 0c05582c..560e74a8 100644
--- a/emigui/README.md
+++ b/emigui/README.md
@@ -98,7 +98,7 @@ Add extremely quick animations for some things, maybe 2-3 frames. For instance:
 * [x] Combine Emigui and Context?
 * [x] Solve which parts of Context are behind a mutex
 * [x] Rename Region to Ui
-* [ ] Move Path and Mesh to own crate
+* [ ] Move Path and Triangles to own crate
 * [ ] Maybe find a shorter name for the library like `egui`?
 
 ### Global widget search
diff --git a/emigui/src/context.rs b/emigui/src/context.rs
index d05af3b9..1fb8f780 100644
--- a/emigui/src/context.rs
+++ b/emigui/src/context.rs
@@ -19,7 +19,7 @@ struct PaintStats {
 pub struct Context {
     /// The default style for new `Ui`:s
     style: Mutex<Style>,
-    mesher_options: Mutex<mesher::MesherOptions>,
+    paint_options: Mutex<mesher::PaintOptions>,
     fonts: Arc<Fonts>,
     /// HACK: set a new font next frame
     new_fonts: Mutex<Option<Arc<Fonts>>>,
@@ -45,7 +45,7 @@ impl Clone for Context {
     fn clone(&self) -> Self {
         Context {
             style: Mutex::new(self.style()),
-            mesher_options: Mutex::new(*self.mesher_options.lock()),
+            paint_options: Mutex::new(*self.paint_options.lock()),
             fonts: self.fonts.clone(),
             new_fonts: Mutex::new(self.new_fonts.lock().clone()),
             memory: self.memory.clone(),
@@ -65,7 +65,7 @@ impl Context {
     pub fn new(pixels_per_point: f32) -> Arc<Context> {
         Arc::new(Context {
             style: Default::default(),
-            mesher_options: Default::default(),
+            paint_options: Default::default(),
             fonts: Arc::new(Fonts::new(pixels_per_point)),
             new_fonts: Default::default(),
             memory: Default::default(),
@@ -214,20 +214,21 @@ impl Context {
     }
 
     fn paint(&self) -> PaintBatches {
-        let mut mesher_options = *self.mesher_options.lock();
-        mesher_options.aa_size = 1.0 / self.pixels_per_point();
-        mesher_options.aa_size *= 1.5; // Looks better, but TODO: should not be needed
+        let mut paint_options = *self.paint_options.lock();
+        paint_options.aa_size = 1.0 / self.pixels_per_point();
+        paint_options.aa_size *= 1.5; // Looks better, but TODO: should not be needed
         let paint_commands = self.drain_paint_lists();
         let num_primitives = paint_commands.len();
-        let batches = mesher::mesh_paint_commands(mesher_options, self.fonts(), paint_commands);
+        let batches =
+            mesher::paint_commands_into_triangles(paint_options, self.fonts(), paint_commands);
 
         {
             let mut stats = PaintStats::default();
             stats.num_batches = batches.len();
             stats.num_primitives = num_primitives;
-            for (_, mesh) in &batches {
-                stats.num_vertices += mesh.vertices.len();
-                stats.num_triangles += mesh.indices.len() / 3;
+            for (_, triangles) in &batches {
+                stats.num_vertices += triangles.vertices.len();
+                stats.num_triangles += triangles.indices.len() / 3;
             }
             *self.paint_stats.lock() = stats;
         }
@@ -477,7 +478,7 @@ impl Context {
         CollapsingHeader::new("Style")
             // .default_open()
             .show(ui, |ui| {
-                self.mesher_options.lock().ui(ui);
+                self.paint_options.lock().ui(ui);
                 self.style_ui(ui);
             });
 
@@ -603,7 +604,7 @@ impl Context {
     }
 }
 
-impl mesher::MesherOptions {
+impl mesher::PaintOptions {
     pub fn ui(&mut self, ui: &mut Ui) {
         use crate::widgets::*;
         ui.add(Checkbox::new(&mut self.anti_alias, "Antialias"));
diff --git a/emigui/src/lib.rs b/emigui/src/lib.rs
index baa957ad..6291f357 100644
--- a/emigui/src/lib.rs
+++ b/emigui/src/lib.rs
@@ -52,7 +52,7 @@ pub use {
     layout::*,
     math::*,
     memory::Memory,
-    mesher::{Mesh, PaintBatches, Vertex},
+    mesher::{PaintBatches, Triangles, Vertex},
     movement_tracker::MovementTracker,
     style::Style,
     texture_atlas::Texture,
diff --git a/emigui/src/mesher.rs b/emigui/src/mesher.rs
index e7b70a70..5071dbc4 100644
--- a/emigui/src/mesher.rs
+++ b/emigui/src/mesher.rs
@@ -22,24 +22,24 @@ pub struct Vertex {
 }
 
 #[derive(Clone, Debug, Default, serde_derive::Serialize)]
-pub struct Mesh {
+pub struct Triangles {
     /// Draw as triangles (i.e. the length is a multiple of three)
     pub indices: Vec<u32>,
     pub vertices: Vec<Vertex>,
 }
 
 /// Grouped by clip rectangles, in pixel coordinates
-pub type PaintBatches = Vec<(Rect, Mesh)>;
+pub type PaintBatches = Vec<(Rect, Triangles)>;
 
 // ----------------------------------------------------------------------------
 
-impl Mesh {
-    pub fn append(&mut self, mesh: &Mesh) {
+impl Triangles {
+    pub fn append(&mut self, triangles: &Triangles) {
         let index_offset = self.vertices.len() as u32;
-        for index in &mesh.indices {
+        for index in &triangles.indices {
             self.indices.push(index_offset + index);
         }
-        self.vertices.extend(mesh.vertices.iter());
+        self.vertices.extend(triangles.vertices.iter());
     }
 
     fn triangle(&mut self, a: u32, b: u32, c: u32) {
@@ -72,9 +72,10 @@ impl Mesh {
         self.vertices.push(bottom_right);
     }
 
-    /// Split a large mesh into many small.
-    /// All the returned meshes will have indices that fit into u16.
-    pub fn split_to_u16(self) -> Vec<Mesh> {
+    /// This is for platsform that only support 16-bit index buffers.
+    /// Splits this mesh into many small if needed.
+    /// All the returned meshes will have indices that fit into a `u16`.
+    pub fn split_to_u16(self) -> Vec<Triangles> {
         const MAX_SIZE: u32 = 1 << 16;
 
         if self.vertices.len() < MAX_SIZE as usize {
@@ -113,7 +114,7 @@ impl Mesh {
                 MAX_SIZE
             );
 
-            output.push(Mesh {
+            output.push(Triangles {
                 indices: self.indices[span_start..index_cursor]
                     .iter()
                     .map(|vi| vi - min_vindex)
@@ -276,14 +277,14 @@ pub enum PathType {
 use self::PathType::{Closed, Open};
 
 #[derive(Clone, Copy)]
-pub struct MesherOptions {
+pub struct PaintOptions {
     pub anti_alias: bool,
     /// Size of a pixel in points, e.g. 0.5
     pub aa_size: f32,
     pub debug_paint_clip_rects: bool,
 }
 
-impl Default for MesherOptions {
+impl Default for PaintOptions {
     fn default() -> Self {
         Self {
             anti_alias: true,
@@ -293,7 +294,12 @@ impl Default for MesherOptions {
     }
 }
 
-pub fn fill_closed_path(mesh: &mut Mesh, options: MesherOptions, path: &[PathPoint], color: Color) {
+pub fn fill_closed_path(
+    triangles: &mut Triangles,
+    options: PaintOptions,
+    path: &[PathPoint],
+    color: Color,
+) {
     if color == color::TRANSPARENT {
         return;
     }
@@ -306,34 +312,35 @@ pub fn fill_closed_path(mesh: &mut Mesh, options: MesherOptions, path: &[PathPoi
     };
     if options.anti_alias {
         let color_outer = color::TRANSPARENT;
-        let idx_inner = mesh.vertices.len() as u32;
+        let idx_inner = triangles.vertices.len() as u32;
         let idx_outer = idx_inner + 1;
         for i in 2..n {
-            mesh.triangle(idx_inner + 2 * (i - 1), idx_inner, idx_inner + 2 * i);
+            triangles.triangle(idx_inner + 2 * (i - 1), idx_inner, idx_inner + 2 * i);
         }
         let mut i0 = n - 1;
         for i1 in 0..n {
             let p1 = &path[i1 as usize];
             let dm = p1.normal * options.aa_size * 0.5;
-            mesh.vertices.push(vert(p1.pos - dm, color));
-            mesh.vertices.push(vert(p1.pos + dm, color_outer));
-            mesh.triangle(idx_inner + i1 * 2, idx_inner + i0 * 2, idx_outer + 2 * i0);
-            mesh.triangle(idx_outer + i0 * 2, idx_outer + i1 * 2, idx_inner + 2 * i1);
+            triangles.vertices.push(vert(p1.pos - dm, color));
+            triangles.vertices.push(vert(p1.pos + dm, color_outer));
+            triangles.triangle(idx_inner + i1 * 2, idx_inner + i0 * 2, idx_outer + 2 * i0);
+            triangles.triangle(idx_outer + i0 * 2, idx_outer + i1 * 2, idx_inner + 2 * i1);
             i0 = i1;
         }
     } else {
-        let idx = mesh.vertices.len() as u32;
-        mesh.vertices
+        let idx = triangles.vertices.len() as u32;
+        triangles
+            .vertices
             .extend(path.iter().map(|p| vert(p.pos, color)));
         for i in 2..n {
-            mesh.triangle(idx, idx + i - 1, idx + i);
+            triangles.triangle(idx, idx + i - 1, idx + i);
         }
     }
 }
 
 pub fn paint_path(
-    mesh: &mut Mesh,
-    options: MesherOptions,
+    triangles: &mut Triangles,
+    options: PaintOptions,
     path_type: PathType,
     path: &[PathPoint],
     color: Color,
@@ -344,7 +351,7 @@ pub fn paint_path(
     }
 
     let n = path.len() as u32;
-    let idx = mesh.vertices.len() as u32;
+    let idx = triangles.vertices.len() as u32;
 
     let vert = |pos, color| Vertex {
         pos,
@@ -377,18 +384,20 @@ pub fn paint_path(
                 let p1 = &path[i1 as usize];
                 let p = p1.pos;
                 let n = p1.normal;
-                mesh.vertices
+                triangles
+                    .vertices
                     .push(vert(p + n * options.aa_size, color_outer));
-                mesh.vertices.push(vert(p, color_inner));
-                mesh.vertices
+                triangles.vertices.push(vert(p, color_inner));
+                triangles
+                    .vertices
                     .push(vert(p - n * options.aa_size, color_outer));
 
                 if connect_with_previous {
-                    mesh.triangle(idx + 3 * i0 + 0, idx + 3 * i0 + 1, idx + 3 * i1 + 0);
-                    mesh.triangle(idx + 3 * i0 + 1, idx + 3 * i1 + 0, idx + 3 * i1 + 1);
+                    triangles.triangle(idx + 3 * i0 + 0, idx + 3 * i0 + 1, idx + 3 * i1 + 0);
+                    triangles.triangle(idx + 3 * i0 + 1, idx + 3 * i1 + 0, idx + 3 * i1 + 1);
 
-                    mesh.triangle(idx + 3 * i0 + 1, idx + 3 * i0 + 2, idx + 3 * i1 + 1);
-                    mesh.triangle(idx + 3 * i0 + 2, idx + 3 * i1 + 1, idx + 3 * i1 + 2);
+                    triangles.triangle(idx + 3 * i0 + 1, idx + 3 * i0 + 2, idx + 3 * i1 + 1);
+                    triangles.triangle(idx + 3 * i0 + 2, idx + 3 * i1 + 1, idx + 3 * i1 + 2);
                 }
                 i0 = i1;
             }
@@ -413,20 +422,28 @@ pub fn paint_path(
                 let p1 = &path[i1 as usize];
                 let p = p1.pos;
                 let n = p1.normal;
-                mesh.vertices.push(vert(p + n * outer_rad, color_outer));
-                mesh.vertices.push(vert(p + n * inner_rad, color_inner));
-                mesh.vertices.push(vert(p - n * inner_rad, color_inner));
-                mesh.vertices.push(vert(p - n * outer_rad, color_outer));
+                triangles
+                    .vertices
+                    .push(vert(p + n * outer_rad, color_outer));
+                triangles
+                    .vertices
+                    .push(vert(p + n * inner_rad, color_inner));
+                triangles
+                    .vertices
+                    .push(vert(p - n * inner_rad, color_inner));
+                triangles
+                    .vertices
+                    .push(vert(p - n * outer_rad, color_outer));
 
                 if connect_with_previous {
-                    mesh.triangle(idx + 4 * i0 + 0, idx + 4 * i0 + 1, idx + 4 * i1 + 0);
-                    mesh.triangle(idx + 4 * i0 + 1, idx + 4 * i1 + 0, idx + 4 * i1 + 1);
+                    triangles.triangle(idx + 4 * i0 + 0, idx + 4 * i0 + 1, idx + 4 * i1 + 0);
+                    triangles.triangle(idx + 4 * i0 + 1, idx + 4 * i1 + 0, idx + 4 * i1 + 1);
 
-                    mesh.triangle(idx + 4 * i0 + 1, idx + 4 * i0 + 2, idx + 4 * i1 + 1);
-                    mesh.triangle(idx + 4 * i0 + 2, idx + 4 * i1 + 1, idx + 4 * i1 + 2);
+                    triangles.triangle(idx + 4 * i0 + 1, idx + 4 * i0 + 2, idx + 4 * i1 + 1);
+                    triangles.triangle(idx + 4 * i0 + 2, idx + 4 * i1 + 1, idx + 4 * i1 + 2);
 
-                    mesh.triangle(idx + 4 * i0 + 2, idx + 4 * i0 + 3, idx + 4 * i1 + 2);
-                    mesh.triangle(idx + 4 * i0 + 3, idx + 4 * i1 + 2, idx + 4 * i1 + 3);
+                    triangles.triangle(idx + 4 * i0 + 2, idx + 4 * i0 + 3, idx + 4 * i1 + 2);
+                    triangles.triangle(idx + 4 * i0 + 3, idx + 4 * i1 + 2, idx + 4 * i1 + 3);
                 }
                 i0 = i1;
             }
@@ -434,12 +451,12 @@ pub fn paint_path(
     } else {
         let last_index = if path_type == Closed { n } else { n - 1 };
         for i in 0..last_index {
-            mesh.triangle(
+            triangles.triangle(
                 idx + (2 * i + 0) % (2 * n),
                 idx + (2 * i + 1) % (2 * n),
                 idx + (2 * i + 2) % (2 * n),
             );
-            mesh.triangle(
+            triangles.triangle(
                 idx + (2 * i + 2) % (2 * n),
                 idx + (2 * i + 1) % (2 * n),
                 idx + (2 * i + 3) % (2 * n),
@@ -455,14 +472,22 @@ pub fn paint_path(
                 return;
             }
             for p in path {
-                mesh.vertices.push(vert(p.pos + radius * p.normal, color));
-                mesh.vertices.push(vert(p.pos - radius * p.normal, color));
+                triangles
+                    .vertices
+                    .push(vert(p.pos + radius * p.normal, color));
+                triangles
+                    .vertices
+                    .push(vert(p.pos - radius * p.normal, color));
             }
         } else {
             let radius = width / 2.0;
             for p in path {
-                mesh.vertices.push(vert(p.pos + radius * p.normal, color));
-                mesh.vertices.push(vert(p.pos - radius * p.normal, color));
+                triangles
+                    .vertices
+                    .push(vert(p.pos + radius * p.normal, color));
+                triangles
+                    .vertices
+                    .push(vert(p.pos - radius * p.normal, color));
             }
         }
     }
@@ -481,14 +506,15 @@ fn mul_color(color: Color, factor: f32) -> Color {
 
 // ----------------------------------------------------------------------------
 
-/// path: only used to reuse memory
-pub fn mesh_command(
-    path: &mut Path,
-    options: MesherOptions,
+/// `reused_path`: only used to reuse memory
+pub fn paint_command_into_triangles(
+    reused_path: &mut Path,
+    options: PaintOptions,
     fonts: &Fonts,
     command: PaintCmd,
-    out_mesh: &mut Mesh,
+    out: &mut Triangles,
 ) {
+    let path = reused_path;
     path.clear();
 
     match command {
@@ -500,21 +526,14 @@ pub fn mesh_command(
         } => {
             path.add_circle(center, radius);
             if let Some(color) = fill_color {
-                fill_closed_path(out_mesh, options, &path.0, color);
+                fill_closed_path(out, options, &path.0, color);
             }
             if let Some(outline) = outline {
-                paint_path(
-                    out_mesh,
-                    options,
-                    Closed,
-                    &path.0,
-                    outline.color,
-                    outline.width,
-                );
+                paint_path(out, options, Closed, &path.0, outline.color, outline.width);
             }
         }
-        PaintCmd::Mesh(mesh) => {
-            out_mesh.append(&mesh);
+        PaintCmd::Triangles(triangles) => {
+            out.append(&triangles);
         }
         PaintCmd::LineSegment {
             points,
@@ -522,7 +541,7 @@ pub fn mesh_command(
             width,
         } => {
             path.add_line_segment(points);
-            paint_path(out_mesh, options, Open, &path.0, color, width);
+            paint_path(out, options, Open, &path.0, color, width);
         }
         PaintCmd::LinePath {
             points,
@@ -532,7 +551,7 @@ pub fn mesh_command(
             let n = points.len();
             if n >= 2 {
                 path.add_line(&points);
-                paint_path(out_mesh, options, Open, &path.0, color, width);
+                paint_path(out, options, Open, &path.0, color, width);
             }
         }
         PaintCmd::Path {
@@ -546,18 +565,11 @@ pub fn mesh_command(
                     closed,
                     "You asked to fill a path that is not closed. That makes no sense."
                 );
-                fill_closed_path(out_mesh, options, &path.0, fill_color);
+                fill_closed_path(out, options, &path.0, fill_color);
             }
             if let Some(outline) = outline {
                 let typ = if closed { Closed } else { Open };
-                paint_path(
-                    out_mesh,
-                    options,
-                    typ,
-                    &path.0,
-                    outline.color,
-                    outline.width,
-                );
+                paint_path(out, options, typ, &path.0, outline.color, outline.width);
             }
         }
         PaintCmd::Rect {
@@ -573,17 +585,10 @@ pub fn mesh_command(
 
             path.add_rounded_rectangle(rect, corner_radius);
             if let Some(fill_color) = fill_color {
-                fill_closed_path(out_mesh, options, &path.0, fill_color);
+                fill_closed_path(out, options, &path.0, fill_color);
             }
             if let Some(outline) = outline {
-                paint_path(
-                    out_mesh,
-                    options,
-                    Closed,
-                    &path.0,
-                    outline.color,
-                    outline.width,
-                );
+                paint_path(out, options, Closed, &path.0, outline.color, outline.width);
             }
         }
         PaintCmd::Text {
@@ -614,7 +619,7 @@ pub fn mesh_command(
                             uv: glyph.max,
                             color,
                         };
-                        out_mesh.add_rect(top_left, bottom_right);
+                        out.add_rect(top_left, bottom_right);
                     }
                 }
             }
@@ -623,11 +628,12 @@ pub fn mesh_command(
     }
 }
 
-pub fn mesh_paint_commands(
-    options: MesherOptions,
+/// Turns `PaintCmd`:s into sets of triangles
+pub fn paint_commands_into_triangles(
+    options: PaintOptions,
     fonts: &Fonts,
     commands: Vec<(Rect, PaintCmd)>,
-) -> Vec<(Rect, Mesh)> {
+) -> Vec<(Rect, Triangles)> {
     let mut reused_path = Path::default();
 
     let mut batches = PaintBatches::default();
@@ -635,16 +641,16 @@ pub fn mesh_paint_commands(
         // TODO: cull(clip_rect, cmd)
 
         if batches.is_empty() || batches.last().unwrap().0 != clip_rect {
-            batches.push((clip_rect, Mesh::default()));
+            batches.push((clip_rect, Triangles::default()));
         }
 
-        let out_mesh = &mut batches.last_mut().unwrap().1;
-        mesh_command(&mut reused_path, options, fonts, cmd, out_mesh);
+        let out = &mut batches.last_mut().unwrap().1;
+        paint_command_into_triangles(&mut reused_path, options, fonts, cmd, out);
     }
 
     if options.debug_paint_clip_rects {
-        for (clip_rect, mesh) in &mut batches {
-            mesh_command(
+        for (clip_rect, triangles) in &mut batches {
+            paint_command_into_triangles(
                 &mut reused_path,
                 options,
                 fonts,
@@ -654,7 +660,7 @@ pub fn mesh_paint_commands(
                     fill_color: None,
                     outline: Some(Outline::new(2.0, srgba(150, 255, 150, 255))),
                 },
-                mesh,
+                triangles,
             )
         }
     }
diff --git a/emigui/src/texture_atlas.rs b/emigui/src/texture_atlas.rs
index 14b7195c..2c33c5a0 100644
--- a/emigui/src/texture_atlas.rs
+++ b/emigui/src/texture_atlas.rs
@@ -93,7 +93,7 @@ impl TextureAtlas {
 impl Texture {
     pub fn ui(&self, ui: &mut crate::Ui) {
         use crate::{
-            color::WHITE, containers::show_tooltip, label, math::*, Mesh, PaintCmd, Vertex,
+            color::WHITE, containers::show_tooltip, label, math::*, PaintCmd, Triangles, Vertex,
         };
 
         ui.add(label!(
@@ -117,9 +117,9 @@ impl Texture {
             uv: (self.width as u16 - 1, self.height as u16 - 1),
             color: WHITE,
         };
-        let mut mesh = Mesh::default();
-        mesh.add_rect(top_left, bottom_right);
-        ui.add_paint_cmd(PaintCmd::Mesh(mesh));
+        let mut triangles = Triangles::default();
+        triangles.add_rect(top_left, bottom_right);
+        ui.add_paint_cmd(PaintCmd::Triangles(triangles));
 
         if interact.hovered {
             show_tooltip(ui.ctx(), |ui| {
@@ -142,9 +142,9 @@ impl Texture {
                     uv: ((u + texel_radius) as u16, (v + texel_radius) as u16),
                     color: WHITE,
                 };
-                let mut mesh = Mesh::default();
-                mesh.add_rect(top_left, bottom_right);
-                ui.add_paint_cmd(PaintCmd::Mesh(mesh));
+                let mut triangles = Triangles::default();
+                triangles.add_rect(top_left, bottom_right);
+                ui.add_paint_cmd(PaintCmd::Triangles(triangles));
             });
         }
     }
diff --git a/emigui/src/types.rs b/emigui/src/types.rs
index 98e05824..20b3c0d3 100644
--- a/emigui/src/types.rs
+++ b/emigui/src/types.rs
@@ -7,7 +7,7 @@ use crate::{
     font::Galley,
     fonts::TextStyle,
     math::{Pos2, Rect},
-    mesher::{Mesh, Path},
+    mesher::{Path, Triangles},
     Context, Ui,
 };
 
@@ -174,8 +174,7 @@ pub enum PaintCmd {
         text_style: TextStyle, // TODO: Font?
         color: Color,
     },
-    /// Low-level triangle mesh
-    Mesh(Mesh),
+    Triangles(Triangles),
 }
 
 impl PaintCmd {
diff --git a/emigui_glium/src/painter.rs b/emigui_glium/src/painter.rs
index 872292b9..cd0c5127 100644
--- a/emigui_glium/src/painter.rs
+++ b/emigui_glium/src/painter.rs
@@ -1,7 +1,7 @@
 #![allow(deprecated)] // legacy implement_vertex macro
 
 use {
-    emigui::{Mesh, PaintBatches, Rect},
+    emigui::{PaintBatches, Rect, Triangles},
     glium::{implement_vertex, index::PrimitiveType, program, texture, uniform, Frame, Surface},
 };
 
@@ -220,8 +220,8 @@ impl Painter {
 
         let mut target = display.draw();
         target.clear_color(0.0, 0.0, 0.0, 0.0);
-        for (clip_rect, mesh) in batches {
-            self.paint_batch(&mut target, display, clip_rect, &mesh, texture)
+        for (clip_rect, triangles) in batches {
+            self.paint_batch(&mut target, display, clip_rect, &triangles, texture)
         }
         target.finish().unwrap();
     }
@@ -232,7 +232,7 @@ impl Painter {
         target: &mut Frame,
         display: &glium::Display,
         clip_rect: Rect,
-        mesh: &Mesh,
+        triangles: &Triangles,
         texture: &emigui::Texture,
     ) {
         let vertex_buffer = {
@@ -244,7 +244,7 @@ impl Painter {
             }
             implement_vertex!(Vertex, a_pos, a_color, a_tc);
 
-            let vertices: Vec<Vertex> = mesh
+            let vertices: Vec<Vertex> = triangles
                 .vertices
                 .iter()
                 .map(|v| Vertex {
@@ -257,7 +257,7 @@ impl Painter {
             glium::VertexBuffer::new(display, &vertices).unwrap()
         };
 
-        let indices: Vec<u32> = mesh.indices.iter().map(|idx| *idx as u32).collect();
+        let indices: Vec<u32> = triangles.indices.iter().map(|idx| *idx as u32).collect();
 
         let index_buffer =
             glium::IndexBuffer::new(display, PrimitiveType::TrianglesList, &indices).unwrap();
diff --git a/emigui_wasm/src/webgl.rs b/emigui_wasm/src/webgl.rs
index f335370a..33ac3cfb 100644
--- a/emigui_wasm/src/webgl.rs
+++ b/emigui_wasm/src/webgl.rs
@@ -4,7 +4,7 @@ use {
     web_sys::{WebGlBuffer, WebGlProgram, WebGlRenderingContext, WebGlShader, WebGlTexture},
 };
 
-use emigui::{vec2, Color, Mesh, PaintBatches, Pos2, Texture};
+use emigui::{vec2, Color, PaintBatches, Pos2, Texture, Triangles};
 
 type Gl = WebGlRenderingContext;
 
@@ -209,7 +209,7 @@ impl Painter {
         );
         gl.clear(Gl::COLOR_BUFFER_BIT);
 
-        for (clip_rect, mesh) in batches {
+        for (clip_rect, triangles) in batches {
             // Avoid infinities in shader:
             let clip_min = clip_rect.min.max(Pos2::default());
             let clip_max = clip_rect.max.min(Pos2::default() + screen_size_points);
@@ -222,27 +222,27 @@ impl Painter {
                 clip_max.y,
             );
 
-            for mesh in mesh.split_to_u16() {
-                self.paint_mesh(&mesh)?;
+            for triangles in triangles.split_to_u16() {
+                self.paint_triangles(&triangles)?;
             }
         }
         Ok(())
     }
 
-    fn paint_mesh(&self, mesh: &Mesh) -> Result<(), JsValue> {
-        let indices: Vec<u16> = mesh.indices.iter().map(|idx| *idx as u16).collect();
+    fn paint_triangles(&self, triangles: &Triangles) -> Result<(), JsValue> {
+        let indices: Vec<u16> = triangles.indices.iter().map(|idx| *idx as u16).collect();
 
-        let mut positions: Vec<f32> = Vec::with_capacity(2 * mesh.vertices.len());
-        let mut tex_coords: Vec<u16> = Vec::with_capacity(2 * mesh.vertices.len());
-        for v in &mesh.vertices {
+        let mut positions: Vec<f32> = Vec::with_capacity(2 * triangles.vertices.len());
+        let mut tex_coords: Vec<u16> = Vec::with_capacity(2 * triangles.vertices.len());
+        for v in &triangles.vertices {
             positions.push(v.pos.x);
             positions.push(v.pos.y);
             tex_coords.push(v.uv.0);
             tex_coords.push(v.uv.1);
         }
 
-        let mut colors: Vec<u8> = Vec::with_capacity(4 * mesh.vertices.len());
-        for v in &mesh.vertices {
+        let mut colors: Vec<u8> = Vec::with_capacity(4 * triangles.vertices.len());
+        for v in &triangles.vertices {
             colors.push(v.color.r);
             colors.push(v.color.g);
             colors.push(v.color.b);