From bb2e07b7b863e97b268db664a7e1ea5f23521142 Mon Sep 17 00:00:00 2001
From: Max Ammann <max@maxammann.org>
Date: Mon, 11 Nov 2024 16:07:03 +0100
Subject: [PATCH] Move code to tessellation_new.rs

---
 .idea/runConfigurations/Run_demo__debug_.xml |   1 +
 maplibre/src/legacy/layout/symbol_feature.rs |   2 +-
 maplibre/src/legacy/shaping.rs               |   2 -
 maplibre/src/legacy/style_types.rs           |   5 +-
 maplibre/src/sdf/mod.rs                      |   4 +-
 maplibre/src/sdf/tessellation_new.rs         | 172 ++++++++++++------
 maplibre/src/vector/process_vector.rs        | 175 +------------------
 7 files changed, 130 insertions(+), 231 deletions(-)

diff --git a/.idea/runConfigurations/Run_demo__debug_.xml b/.idea/runConfigurations/Run_demo__debug_.xml
index ef52bbb6a..30da9ba7f 100644
--- a/.idea/runConfigurations/Run_demo__debug_.xml
+++ b/.idea/runConfigurations/Run_demo__debug_.xml
@@ -1,5 +1,6 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Run demo (debug)" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
+    <option name="buildProfileId" value="dev" />
     <option name="command" value="run -p maplibre-demo -- headed" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
     <envs>
diff --git a/maplibre/src/legacy/layout/symbol_feature.rs b/maplibre/src/legacy/layout/symbol_feature.rs
index a0d7c5630..ce12e917e 100644
--- a/maplibre/src/legacy/layout/symbol_feature.rs
+++ b/maplibre/src/legacy/layout/symbol_feature.rs
@@ -47,7 +47,7 @@ impl SymbolGeometryTileFeature {
         FeatureType::Point
     }
     /// maplibre/maplibre-native#4add9ea original name: getValue
-    pub fn get_value(&self, key: &String) -> Option<&Value> {
+    pub fn get_value(&self, key: &str) -> Option<&Value> {
         todo!()
     }
     /// maplibre/maplibre-native#4add9ea original name: getProperties
diff --git a/maplibre/src/legacy/shaping.rs b/maplibre/src/legacy/shaping.rs
index 6adac074f..82fb2a1f9 100644
--- a/maplibre/src/legacy/shaping.rs
+++ b/maplibre/src/legacy/shaping.rs
@@ -701,8 +701,6 @@ fn shape_lines(
                     rect = glyph_position.rect;
                     metrics = glyph_position.metrics;
                 } else {
-                    // TODO why would a glyph position not be available but a glyph? Maybe if a glyph bitmap is empty?
-                    unreachable!();
                     let glyphs = glyph_map.get(&section.font_stack_hash);
                     if glyphs.is_none() {
                         continue;
diff --git a/maplibre/src/legacy/style_types.rs b/maplibre/src/legacy/style_types.rs
index 15e8436e1..442ea094a 100644
--- a/maplibre/src/legacy/style_types.rs
+++ b/maplibre/src/legacy/style_types.rs
@@ -1015,7 +1015,7 @@ pub mod expression {
             // TODO remove
             Formatted {
                 sections: vec![FormattedSection {
-                    text: "AllerAnfangistschwer".to_string(),
+                    text: "Aller Anfang ist schwer".to_string(),
                     image: None,
                     font_scale: None,
                     font_stack: None,
@@ -1147,6 +1147,9 @@ impl SymbolLayoutProperties_PossiblyEvaluated {
         p2: CanonicalTileID,
     ) -> T::Type {
         //todo!()
+
+        //p1.get_value(&T::name());
+
         T::default_value()
     }
 
diff --git a/maplibre/src/sdf/mod.rs b/maplibre/src/sdf/mod.rs
index 3e5205486..0aeff78d7 100644
--- a/maplibre/src/sdf/mod.rs
+++ b/maplibre/src/sdf/mod.rs
@@ -38,9 +38,9 @@ mod resource;
 mod resource_system;
 mod upload_system;
 
-pub mod tessellation;
-mod tessellation_new;
 pub mod text;
+pub mod tessellation;
+pub mod tessellation_new;
 
 struct SymbolPipeline(wgpu::RenderPipeline);
 
diff --git a/maplibre/src/sdf/tessellation_new.rs b/maplibre/src/sdf/tessellation_new.rs
index 277ac56ef..b318c7be9 100644
--- a/maplibre/src/sdf/tessellation_new.rs
+++ b/maplibre/src/sdf/tessellation_new.rs
@@ -8,7 +8,7 @@ use geozero::{
 };
 use lyon::{
     geom::euclid::{Box2D, Point2D},
-    tessellation::{geometry_builder::MaxIndex, VertexBuffers},
+    tessellation::{VertexBuffers},
 };
 
 use crate::{
@@ -32,15 +32,19 @@ use crate::{
     render::shaders::ShaderSymbolVertexNew,
     sdf::Feature,
 };
+use crate::legacy::buckets::symbol_bucket::SymbolBucketBuffer;
+use crate::legacy::tagged_string::SectionOptions;
+use crate::sdf::tessellation::IndexDataType;
+use crate::sdf::text::GlyphSet;
 
 type GeoResult<T> = geozero::error::Result<T>;
 
 /// Build tessellations with vectors.
-pub struct TextTessellatorNew<I> {
+pub struct TextTessellatorNew {
     geo_writer: GeoWriter,
 
     // output
-    pub quad_buffer: VertexBuffers<ShaderSymbolVertexNew, I>,
+    pub quad_buffer: VertexBuffers<ShaderSymbolVertexNew, IndexDataType>,
     pub features: Vec<Feature>,
 
     // iteration variables
@@ -49,44 +53,19 @@ pub struct TextTessellatorNew<I> {
     current_origin: Option<Box2D<f32, TileSpace>>,
 }
 
-impl<I> TextTessellatorNew<I> {
-    pub fn finish() {
+impl TextTessellatorNew {
+    pub fn finish(&mut self) {
+        let data = include_bytes!("../../../data/0-255.pbf");
+        let glyphs = GlyphSet::try_from(data.as_slice()).unwrap();
+
         let font_stack = vec![
             "Open Sans Regular".to_string(),
             "Arial Unicode MS Regular".to_string(),
         ];
 
-        // load glyph/image data
-
-        let image_positions = ImagePositions::new();
-
-        let glyph_position = GlyphPosition {
-            rect: Rect::new(Point2D::new(0, 0), Size2D::new(10, 10)),
-            metrics: GlyphMetrics {
-                width: 18,
-                height: 18,
-                left: 2,
-                top: -8,
-                advance: 21,
-            },
-        };
-        let glyph_positions: GlyphPositions = GlyphPositions::from([(
-            FontStackHasher::new(&font_stack),
-            GlyphPositionMap::from([('中' as Char16, glyph_position)]),
-        )]);
+        let layer_name = "layer".to_string();
 
-        let mut glyph = Glyph::default();
-        glyph.id = '中' as Char16;
-        glyph.metrics = glyph_position.metrics;
-
-        let glyphs: GlyphMap = GlyphMap::from([(
-            FontStackHasher::new(&font_stack),
-            Glyphs::from([('中' as Char16, Some(glyph))]),
-        )]);
-
-        let empty_image_map = ImageMap::new();
-
-        // layouting
+        let section_options = SectionOptions::new(1.0, font_stack.clone(), None);
 
         let mut glyph_dependencies = GlyphDependencies::new();
 
@@ -94,28 +73,87 @@ impl<I> TextTessellatorNew<I> {
             canonical: CanonicalTileID { x: 0, y: 0, z: 0 },
             overscaled_z: 0,
         };
-        let parameters = BucketParameters {
+        let mut parameters = BucketParameters {
             tile_id: tile_id,
             mode: MapMode::Continuous,
             pixel_ratio: 1.0,
             layer_type: LayerTypeInfo,
         };
-        let mut layout = SymbolLayout::new(
-            &parameters,
-            &vec![LayerProperties {
-                id: "layer".to_string(),
-                layer: SymbolLayer {
-                    layout: SymbolLayoutProperties_Unevaluated,
+        let layer_data = SymbolGeometryTileLayer {
+            name: layer_name.clone(),
+            features: vec![SymbolGeometryTileFeature::new(Box::new(
+                VectorGeometryTileFeature {
+                    geometry: vec![GeometryCoordinates(vec![Point2D::new(
+                        512, 512,
+                    )])],
                 },
-            }],
-            Box::new(SymbolGeometryTileLayer {
-                name: "layer".to_string(),
-                features: vec![SymbolGeometryTileFeature::new(Box::new(
-                    VectorGeometryTileFeature {
-                        geometry: vec![GeometryCoordinates(vec![Point2D::new(1024, 1024)])],
+            ))],
+        };
+        let layer_properties = vec![LayerProperties {
+            id: layer_name.clone(),
+            layer: SymbolLayer {
+                layout: SymbolLayoutProperties_Unevaluated,
+            },
+        }];
+
+        let image_positions = ImagePositions::new();
+
+        let glyph_map = GlyphPositionMap::from_iter(glyphs.glyphs.iter().map(
+            |(unicode_point, glyph)| {
+                (
+                    *unicode_point as Char16,
+                    GlyphPosition {
+                        rect: Rect::new(
+                            Point2D::new(
+                                glyph.tex_origin_x as u16 + 3,
+                                glyph.tex_origin_y as u16 + 3,
+                            ),
+                            Size2D::new(
+                                glyph.buffered_dimensions().0 as u16,
+                                glyph.buffered_dimensions().1 as u16,
+                            ),
+                        ), // FIXME: verify if this mapping is correct
+                        metrics: GlyphMetrics {
+                            width: glyph.width,
+                            height: glyph.height,
+                            left: glyph.left_bearing,
+                            top: glyph.top_bearing,
+                            advance: glyph.h_advance,
+                        },
                     },
-                ))],
-            }),
+                )
+            },
+        ));
+
+        let glyph_positions: GlyphPositions =
+            GlyphPositions::from([(FontStackHasher::new(&font_stack), glyph_map)]);
+
+        let glyphs: GlyphMap = GlyphMap::from([(
+            FontStackHasher::new(&font_stack),
+            Glyphs::from_iter(glyphs.glyphs.iter().map(
+                |(unicode_point, glyph)| {
+                    (
+                        *unicode_point as Char16,
+                        Some(Glyph {
+                            id: *unicode_point as Char16,
+                            bitmap: Default::default(),
+                            metrics: GlyphMetrics {
+                                width: glyph.width,
+                                height: glyph.height,
+                                left: glyph.left_bearing,
+                                top: glyph.top_bearing,
+                                advance: glyph.h_advance,
+                            },
+                        }),
+                    )
+                },
+            )),
+        )]);
+
+        let mut layout = SymbolLayout::new(
+            &parameters,
+            &layer_properties,
+            Box::new(layer_data),
             &mut LayoutParameters {
                 bucket_parameters: &mut parameters.clone(),
                 glyph_dependencies: &mut glyph_dependencies,
@@ -123,8 +161,11 @@ impl<I> TextTessellatorNew<I> {
                 available_images: &mut Default::default(),
             },
         )
-        .unwrap();
+            .unwrap();
+
+        assert_eq!(glyph_dependencies.len(), 1);
 
+        let empty_image_map = ImageMap::new();
         layout.prepare_symbols(
             &glyphs,
             &glyph_positions,
@@ -141,10 +182,27 @@ impl<I> TextTessellatorNew<I> {
             false,
             &tile_id.canonical,
         );
+
+        let new_buffer = output.remove(&layer_name).unwrap();
+
+        let mut buffer = VertexBuffers::new();
+        let text_buffer = new_buffer.bucket.text;
+        let SymbolBucketBuffer {
+            shared_vertices,
+            triangles,
+            ..
+        } = text_buffer;
+        buffer.vertices = shared_vertices
+            .iter()
+            .map(|v| ShaderSymbolVertexNew::new(v))
+            .collect();
+        buffer.indices = triangles.indices.iter().map(|i| *i as u32).collect();
+
+        self.quad_buffer = buffer;
     }
 }
 
-impl<I> Default for TextTessellatorNew<I> {
+impl Default for TextTessellatorNew {
     fn default() -> Self {
         Self {
             geo_writer: Default::default(),
@@ -157,7 +215,7 @@ impl<I> Default for TextTessellatorNew<I> {
     }
 }
 
-impl<I> GeomProcessor for TextTessellatorNew<I> {
+impl GeomProcessor for TextTessellatorNew {
     fn xy(&mut self, x: f64, y: f64, idx: usize) -> GeoResult<()> {
         self.geo_writer.xy(x, y, idx)
     }
@@ -196,8 +254,8 @@ impl<I> GeomProcessor for TextTessellatorNew<I> {
     }
 }
 
-impl<I: std::ops::Add + From<lyon::tessellation::VertexId> + MaxIndex> PropertyProcessor
-    for TextTessellatorNew<I>
+impl PropertyProcessor
+    for TextTessellatorNew
 {
     fn property(
         &mut self,
@@ -218,8 +276,8 @@ impl<I: std::ops::Add + From<lyon::tessellation::VertexId> + MaxIndex> PropertyP
     }
 }
 
-impl<I: std::ops::Add + From<lyon::tessellation::VertexId> + MaxIndex> FeatureProcessor
-    for TextTessellatorNew<I>
+impl FeatureProcessor
+    for TextTessellatorNew
 {
     fn feature_end(&mut self, _idx: u64) -> geozero::error::Result<()> {
         let geometry = self.geo_writer.take_geometry();
diff --git a/maplibre/src/vector/process_vector.rs b/maplibre/src/vector/process_vector.rs
index 11ab3e506..5498fef3d 100644
--- a/maplibre/src/vector/process_vector.rs
+++ b/maplibre/src/vector/process_vector.rs
@@ -1,6 +1,6 @@
 use std::{
     borrow::Cow,
-    collections::{HashMap, HashSet},
+    collections::{HashSet},
     marker::PhantomData,
 };
 
@@ -8,39 +8,19 @@ use geozero::{
     mvt::{tile, Message},
     GeozeroDatasource,
 };
-use lyon::tessellation::VertexBuffers;
 use thiserror::Error;
 
 use crate::{
     coords::WorldTileCoords,
-    euclid::{Point2D, Rect, Size2D},
     io::{
         apc::{Context, SendError},
         geometry_index::{IndexProcessor, IndexedGeometry, TileIndex},
     },
-    legacy::{
-        bidi::Char16,
-        buckets::symbol_bucket::SymbolBucketBuffer,
-        font_stack::FontStackHasher,
-        geometry_tile_data::{GeometryCoordinates, SymbolGeometryTileLayer},
-        glyph::{Glyph, GlyphDependencies, GlyphMap, GlyphMetrics, Glyphs},
-        glyph_atlas::{GlyphPosition, GlyphPositionMap, GlyphPositions},
-        image::ImageMap,
-        image_atlas::ImagePositions,
-        layout::{
-            layout::{BucketParameters, LayerTypeInfo, LayoutParameters},
-            symbol_feature::{SymbolGeometryTileFeature, VectorGeometryTileFeature},
-            symbol_layout::{FeatureIndex, LayerProperties, SymbolLayer, SymbolLayout},
-        },
-        style_types::SymbolLayoutProperties_Unevaluated,
-        tagged_string::SectionOptions,
-        CanonicalTileID, MapMode, OverscaledTileID,
-    },
     render::{
         shaders::{ShaderSymbolVertex, ShaderSymbolVertexNew},
         ShaderVertex,
     },
-    sdf::{tessellation::TextTessellator, text::GlyphSet, Feature},
+    sdf::{tessellation::TextTessellator, Feature},
     style::layer::{LayerPaint, StyleLayer},
     vector::{
         tessellation::{IndexDataType, OverAlignedVertexBuffer, ZeroTessellator},
@@ -50,6 +30,7 @@ use crate::{
         },
     },
 };
+use crate::sdf::tessellation_new::TextTessellatorNew;
 
 #[derive(Error, Debug)]
 pub enum ProcessVectorError {
@@ -106,162 +87,20 @@ pub fn process_vector_tile<T: VectorTransferables, C: Context>(
                         }
                     }
                     LayerPaint::Symbol(_) => {
-                        let data = include_bytes!("../../../data/0-255.pbf");
-                        let glyphs = GlyphSet::try_from(data.as_slice()).unwrap();
-
-                        let font_stack = vec![
-                            "Open Sans Regular".to_string(),
-                            "Arial Unicode MS Regular".to_string(),
-                        ];
-
-                        let layer_name = "layer".to_string();
-
-                        let section_options = SectionOptions::new(1.0, font_stack.clone(), None);
-
-                        let mut glyph_dependencies = GlyphDependencies::new();
-
-                        let tile_id = OverscaledTileID {
-                            canonical: CanonicalTileID { x: 0, y: 0, z: 0 },
-                            overscaled_z: 0,
-                        };
-                        let mut parameters = BucketParameters {
-                            tile_id: tile_id,
-                            mode: MapMode::Continuous,
-                            pixel_ratio: 1.0,
-                            layer_type: LayerTypeInfo,
-                        };
-                        let layer_data = SymbolGeometryTileLayer {
-                            name: layer_name.clone(),
-                            features: vec![SymbolGeometryTileFeature::new(Box::new(
-                                VectorGeometryTileFeature {
-                                    geometry: vec![GeometryCoordinates(vec![Point2D::new(
-                                        512, 512,
-                                    )])],
-                                },
-                            ))],
-                        };
-                        let layer_properties = vec![LayerProperties {
-                            id: layer_name.clone(),
-                            layer: SymbolLayer {
-                                layout: SymbolLayoutProperties_Unevaluated,
-                            },
-                        }];
-
-                        let image_positions = ImagePositions::new();
-
-                        let glyph_map = GlyphPositionMap::from_iter(glyphs.glyphs.iter().map(
-                            |(unicode_point, glyph)| {
-                                (
-                                    *unicode_point as Char16,
-                                    GlyphPosition {
-                                        rect: Rect::new(
-                                            Point2D::new(
-                                                glyph.tex_origin_x as u16 + 3,
-                                                glyph.tex_origin_y as u16 + 3,
-                                            ),
-                                            Size2D::new(
-                                                glyph.buffered_dimensions().0 as u16,
-                                                glyph.buffered_dimensions().1 as u16,
-                                            ),
-                                        ), // FIXME: verify if this mapping is correct
-                                        metrics: GlyphMetrics {
-                                            width: glyph.width,
-                                            height: glyph.height,
-                                            left: glyph.left_bearing,
-                                            top: glyph.top_bearing,
-                                            advance: glyph.h_advance,
-                                        },
-                                    },
-                                )
-                            },
-                        ));
-
-                        let glyph_positions: GlyphPositions =
-                            GlyphPositions::from([(FontStackHasher::new(&font_stack), glyph_map)]);
-
-                        let glyphs: GlyphMap = GlyphMap::from([(
-                            FontStackHasher::new(&font_stack),
-                            Glyphs::from_iter(glyphs.glyphs.iter().map(
-                                |(unicode_point, glyph)| {
-                                    (
-                                        *unicode_point as Char16,
-                                        Some(Glyph {
-                                            id: *unicode_point as Char16,
-                                            bitmap: Default::default(),
-                                            metrics: GlyphMetrics {
-                                                width: glyph.width,
-                                                height: glyph.height,
-                                                left: glyph.left_bearing,
-                                                top: glyph.top_bearing,
-                                                advance: glyph.h_advance,
-                                            },
-                                        }),
-                                    )
-                                },
-                            )),
-                        )]);
-
-                        let mut layout = SymbolLayout::new(
-                            &parameters,
-                            &layer_properties,
-                            Box::new(layer_data),
-                            &mut LayoutParameters {
-                                bucket_parameters: &mut parameters.clone(),
-                                glyph_dependencies: &mut glyph_dependencies,
-                                image_dependencies: &mut Default::default(),
-                                available_images: &mut Default::default(),
-                            },
-                        )
-                        .unwrap();
-
-                        assert_eq!(glyph_dependencies.len(), 1);
-
-                        let empty_image_map = ImageMap::new();
-                        layout.prepare_symbols(
-                            &glyphs,
-                            &glyph_positions,
-                            &empty_image_map,
-                            &image_positions,
-                        );
-
-                        let mut output = HashMap::new();
-                        layout.create_bucket(
-                            image_positions,
-                            Box::new(FeatureIndex),
-                            &mut output,
-                            false,
-                            false,
-                            &tile_id.canonical,
-                        );
-
-                        let new_buffer = output.remove(&layer_name).unwrap();
-
-                        let mut buffer = VertexBuffers::new();
-                        let text_buffer = new_buffer.bucket.text;
-                        let SymbolBucketBuffer {
-                            shared_vertices,
-                            triangles,
-                            ..
-                        } = text_buffer;
-                        buffer.vertices = shared_vertices
-                            .iter()
-                            .map(|v| ShaderSymbolVertexNew::new(v))
-                            .collect();
-                        buffer.indices = triangles.indices.iter().map(|i| *i as u32).collect();
-
                         // TODO
                         let mut tessellator = TextTessellator::<IndexDataType>::default();
+                        let mut tessellator_new = TextTessellatorNew::default();
 
-                        //if let Err(e) = layer.process(&mut tessellator) {
-                        if let Err(e) = Ok::<(), ProcessVectorError>(()) {
+                        if let Err(e) = layer.process(&mut tessellator_new) {
                             context.layer_missing(coords, &source_layer)?;
 
                             tracing::error!("tesselation for layer source {source_layer} at {coords} failed {e:?}");
                         } else {
+                            tessellator_new.finish();
                             context.symbol_layer_tesselation_finished(
                                 coords,
                                 tessellator.quad_buffer.into(),
-                                buffer.into(),
+                                tessellator_new.quad_buffer.into(),
                                 tessellator.features,
                                 original_layer,
                             )?;