Factor out mask texture UV calculation, and rename a couple of render commands

renderer/src/builder.rs

@@ -127,10 +127,10 @@ impl<'a> SceneBuilder<'a> {
                                                           paint_metadata,
                                                           0..path_count);
         if !solid_tiles.is_empty() {
-            self.listener.send(RenderCommand::SolidTile(solid_tiles));
+            self.listener.send(RenderCommand::DrawSolidTiles(solid_tiles));
         }
         if !culled_tiles.alpha_tiles.is_empty() {
-            self.listener.send(RenderCommand::AlphaTile(culled_tiles.alpha_tiles));
+            self.listener.send(RenderCommand::DrawAlphaTiles(culled_tiles.alpha_tiles));
         }
     }
 

renderer/src/gpu/renderer.rs

@@ -239,13 +239,13 @@ where
                 self.draw_buffered_fills();
                 self.begin_composite_timer_query();
             }
-            RenderCommand::SolidTile(ref solid_tile_vertices) => {
+            RenderCommand::DrawSolidTiles(ref solid_tile_vertices) => {
                 let count = solid_tile_vertices.len() / 4;
                 self.stats.solid_tile_count += count;
                 self.upload_solid_tiles(solid_tile_vertices);
                 self.draw_solid_tiles(count as u32);
             }
-            RenderCommand::AlphaTile(ref alpha_tiles) => {
+            RenderCommand::DrawAlphaTiles(ref alpha_tiles) => {
                 let count = alpha_tiles.len();
                 self.stats.alpha_tile_count += count;
                 self.upload_alpha_tiles(alpha_tiles);

renderer/src/gpu_data.rs

@@ -22,8 +22,8 @@ pub enum RenderCommand {
     AddPaintData(PaintData),
     AddFills(Vec<FillBatchPrimitive>),
     FlushFills,
-    AlphaTile(Vec<AlphaTile>),
+    DrawAlphaTiles(Vec<AlphaTile>),
-    SolidTile(Vec<SolidTileVertex>),
+    DrawSolidTiles(Vec<SolidTileVertex>),
     Finish { build_time: Duration },
 }
 
@@ -100,11 +100,11 @@ impl Debug for RenderCommand {
             }
             RenderCommand::AddFills(ref fills) => write!(formatter, "AddFills(x{})", fills.len()),
             RenderCommand::FlushFills => write!(formatter, "FlushFills"),
-            RenderCommand::AlphaTile(ref tiles) => {
+            RenderCommand::DrawAlphaTiles(ref tiles) => {
-                write!(formatter, "AlphaTile(x{})", tiles.len())
+                write!(formatter, "DrawAlphaTiles(x{})", tiles.len())
             }
-            RenderCommand::SolidTile(ref tiles) => {
+            RenderCommand::DrawSolidTiles(ref tiles) => {
-                write!(formatter, "SolidTile(x{})", tiles.len())
+                write!(formatter, "DrawSolidTiles(x{})", tiles.len())
             }
             RenderCommand::Finish { .. } => write!(formatter, "Finish"),
         }

renderer/src/tiles.rs

@@ -551,12 +551,7 @@ impl AlphaTileVertex {
            -> AlphaTileVertex {
         let tile_position = tile_origin + tile_offset;
         let color_uv = paint_metadata.calculate_tex_coords(tile_position).scale(65535.0).to_i32();
-
+        let mask_uv = calculate_mask_uv(tile_index as u16, tile_offset);
-        let mask_u = tile_index as i32 % MASK_TILES_ACROSS as i32;
-        let mask_v = tile_index as i32 / MASK_TILES_ACROSS as i32;
-        let mask_scale = 65535.0 / MASK_TILES_ACROSS as f32;
-        let mask_uv = Vector2I::new(mask_u, mask_v) + tile_offset;
-        let mask_uv = mask_uv.to_f32().scale(mask_scale).to_i32();
 
         AlphaTileVertex {
             tile_x: tile_position.x() as i16,
@@ -576,6 +571,14 @@ impl AlphaTileVertex {
     }
 }
 
+fn calculate_mask_uv(tile_index: u16, tile_offset: Vector2I) -> Vector2I {
+    let mask_u = tile_index as i32 % MASK_TILES_ACROSS as i32;
+    let mask_v = tile_index as i32 / MASK_TILES_ACROSS as i32;
+    let mask_scale = 65535.0 / MASK_TILES_ACROSS as f32;
+    let mask_uv = Vector2I::new(mask_u, mask_v) + tile_offset;
+    mask_uv.to_f32().scale(mask_scale).to_i32()
+}
+
 impl Default for TileObjectPrimitive {
     #[inline]
     fn default() -> TileObjectPrimitive {