[core] extract SegmentInfo from Segment

8 files changed, 72 insertions, 52 deletions

diff --git a/src/mbgl/gl/program.hpp b/src/mbgl/gl/program.hpp
index 583d53e4ec..48e9c720b5 100644
--- a/src/mbgl/gl/program.hpp
+++ b/src/mbgl/gl/program.hpp
@@ -138,8 +138,8 @@ public:
                          attributeBindings);
 
             context.draw(drawMode.primitiveType,
-                         segment.indexOffset,
-                         segment.indexLength);
+                         segment.info.indexOffset,
+                         segment.info.indexLength);
         }
     }
 
diff --git a/src/mbgl/gl/segment.hpp b/src/mbgl/gl/segment.hpp
index fe0658bf8e..442f5be532 100644
--- a/src/mbgl/gl/segment.hpp
+++ b/src/mbgl/gl/segment.hpp
@@ -11,23 +11,46 @@
 namespace mbgl {
 namespace gl {
 
-template <class Attributes>
-class Segment {
+class SegmentInfo {
 public:
-    Segment(std::size_t vertexOffset_,
-            std::size_t indexOffset_,
-            std::size_t vertexLength_ = 0,
-            std::size_t indexLength_ = 0)
+    SegmentInfo(std::size_t vertexOffset_,
+                std::size_t indexOffset_,
+                std::size_t vertexLength_ = 0,
+                std::size_t indexLength_ = 0)
         : vertexOffset(vertexOffset_),
           indexOffset(indexOffset_),
           vertexLength(vertexLength_),
-          indexLength(indexLength_) {}
+          indexLength(indexLength_) {
+    }
 
     const std::size_t vertexOffset;
     const std::size_t indexOffset;
-
     std::size_t vertexLength;
     std::size_t indexLength;
+};
+
+inline bool operator==(const SegmentInfo& lhs, const SegmentInfo& rhs) {
+    return lhs.vertexOffset == rhs.vertexOffset && lhs.indexOffset == rhs.indexOffset &&
+           lhs.vertexLength == rhs.vertexLength && lhs.indexLength == rhs.indexLength;
+}
+
+using SegmentInfoVector = std::vector<SegmentInfo>;
+
+template <class Attributes>
+class Segment {
+public:
+    Segment(std::size_t vertexOffset,
+            std::size_t indexOffset,
+            std::size_t vertexLength = 0,
+            std::size_t indexLength = 0)
+        : info(vertexOffset, indexOffset, vertexLength, indexLength) {
+    }
+
+    Segment(SegmentInfo info_)
+        : info(std::move(info_)) {
+    }
+
+    SegmentInfo info;
 
     void bind(Context& context,
               BufferID indexBuffer_,
@@ -54,7 +77,7 @@ public:
                          attributeLocations,
                          attributeBindings,
                          attributeBindings_,
-                         vertexOffset);
+                         info.vertexOffset);
     }
 
 private:
@@ -64,10 +87,7 @@ private:
 };
 
 template <class Attributes>
-class SegmentVector : public std::vector<Segment<Attributes>> {
-public:
-    SegmentVector() = default;
-};
+using SegmentVector = std::vector<Segment<Attributes>>;
 
 } // namespace gl
 } // namespace mbgl
diff --git a/src/mbgl/layout/symbol_layout.cpp b/src/mbgl/layout/symbol_layout.cpp
index adc7eaaed8..0df2df1988 100644
--- a/src/mbgl/layout/symbol_layout.cpp
+++ b/src/mbgl/layout/symbol_layout.cpp
@@ -576,15 +576,15 @@ void SymbolLayout::addSymbol(Buffer& buffer,
         minZoom = 0;
     }
 
-    if (buffer.segments.empty() || buffer.segments.back().vertexLength + vertexLength > std::numeric_limits<uint16_t>::max()) {
+    if (buffer.segments.empty() || buffer.segments.back().info.vertexLength + vertexLength > std::numeric_limits<uint16_t>::max()) {
         buffer.segments.emplace_back(buffer.vertices.vertexSize(), buffer.triangles.indexSize());
     }
 
     // We're generating triangle fans, so we always start with the first
     // coordinate in this polygon.
     auto& segment = buffer.segments.back();
-    assert(segment.vertexLength <= std::numeric_limits<uint16_t>::max());
-    uint16_t index = segment.vertexLength;
+    assert(segment.info.vertexLength <= std::numeric_limits<uint16_t>::max());
+    uint16_t index = segment.info.vertexLength;
 
     // Encode angle of glyph
     uint8_t glyphAngle = std::round((symbol.glyphAngle / (M_PI * 2)) * 256);
@@ -605,8 +605,8 @@ void SymbolLayout::addSymbol(Buffer& buffer,
     buffer.triangles.emplace_back(index + 0, index + 1, index + 2);
     buffer.triangles.emplace_back(index + 1, index + 2, index + 3);
 
-    segment.vertexLength += vertexLength;
-    segment.indexLength += 6;
+    segment.info.vertexLength += vertexLength;
+    segment.info.indexLength += 6;
 }
 
 void SymbolLayout::addToDebugBuffers(CollisionTile& collisionTile, SymbolBucket& bucket) {
@@ -639,12 +639,12 @@ void SymbolLayout::addToDebugBuffers(CollisionTile& collisionTile, SymbolBucket&
                 static constexpr std::size_t vertexLength = 4;
                 static constexpr std::size_t indexLength = 8;
 
-                if (collisionBox.segments.empty() || collisionBox.segments.back().vertexLength + vertexLength > std::numeric_limits<uint16_t>::max()) {
+                if (collisionBox.segments.empty() || collisionBox.segments.back().info.vertexLength + vertexLength > std::numeric_limits<uint16_t>::max()) {
                     collisionBox.segments.emplace_back(collisionBox.vertices.vertexSize(), collisionBox.lines.indexSize());
                 }
 
                 auto& segment = collisionBox.segments.back();
-                uint16_t index = segment.vertexLength;
+                uint16_t index = segment.info.vertexLength;
 
                 collisionBox.vertices.emplace_back(CollisionBoxProgram::vertex(anchor, tl, maxZoom, placementZoom));
                 collisionBox.vertices.emplace_back(CollisionBoxProgram::vertex(anchor, tr, maxZoom, placementZoom));
@@ -656,8 +656,8 @@ void SymbolLayout::addToDebugBuffers(CollisionTile& collisionTile, SymbolBucket&
                 collisionBox.lines.emplace_back(index + 2, index + 3);
                 collisionBox.lines.emplace_back(index + 3, index + 0);
 
-                segment.vertexLength += vertexLength;
-                segment.indexLength += indexLength;
+                segment.info.vertexLength += vertexLength;
+                segment.info.indexLength += indexLength;
             }
         };
         populateCollisionBox(symbolInstance.textCollisionFeature);
diff --git a/src/mbgl/renderer/buckets/circle_bucket.cpp b/src/mbgl/renderer/buckets/circle_bucket.cpp
index 8b5743d500..497c6e2155 100644
--- a/src/mbgl/renderer/buckets/circle_bucket.cpp
+++ b/src/mbgl/renderer/buckets/circle_bucket.cpp
@@ -60,7 +60,7 @@ void CircleBucket::addFeature(const GeometryTileFeature& feature,
             if ((mode != MapMode::Still) &&
                 (x < 0 || x >= util::EXTENT || y < 0 || y >= util::EXTENT)) continue;
 
-            if (segments.empty() || segments.back().vertexLength + vertexLength > std::numeric_limits<uint16_t>::max()) {
+            if (segments.empty() || segments.back().info.vertexLength + vertexLength > std::numeric_limits<uint16_t>::max()) {
                 // Move to a new segments because the old one can't hold the geometry.
                 segments.emplace_back(vertices.vertexSize(), triangles.indexSize());
             }
@@ -80,16 +80,16 @@ void CircleBucket::addFeature(const GeometryTileFeature& feature,
             vertices.emplace_back(CircleProgram::vertex(point, -1,  1)); // 4
 
             auto& segment = segments.back();
-            assert(segment.vertexLength <= std::numeric_limits<uint16_t>::max());
-            uint16_t index = segment.vertexLength;
+            assert(segment.info.vertexLength <= std::numeric_limits<uint16_t>::max());
+            uint16_t index = segment.info.vertexLength;
 
             // 1, 2, 3
             // 1, 4, 3
             triangles.emplace_back(index, index + 1, index + 2);
             triangles.emplace_back(index, index + 3, index + 2);
 
-            segment.vertexLength += vertexLength;
-            segment.indexLength += 6;
+            segment.info.vertexLength += vertexLength;
+            segment.info.indexLength += 6;
         }
     }
 
diff --git a/src/mbgl/renderer/buckets/fill_bucket.cpp b/src/mbgl/renderer/buckets/fill_bucket.cpp
index 042d7b7506..9cf1c9d6aa 100644
--- a/src/mbgl/renderer/buckets/fill_bucket.cpp
+++ b/src/mbgl/renderer/buckets/fill_bucket.cpp
@@ -61,13 +61,13 @@ void FillBucket::addFeature(const GeometryTileFeature& feature,
             if (nVertices == 0)
                 continue;
 
-            if (lineSegments.empty() || lineSegments.back().vertexLength + nVertices > std::numeric_limits<uint16_t>::max()) {
+            if (lineSegments.empty() || lineSegments.back().info.vertexLength + nVertices > std::numeric_limits<uint16_t>::max()) {
                 lineSegments.emplace_back(vertices.vertexSize(), lines.indexSize());
             }
 
             auto& lineSegment = lineSegments.back();
-            assert(lineSegment.vertexLength <= std::numeric_limits<uint16_t>::max());
-            uint16_t lineIndex = lineSegment.vertexLength;
+            assert(lineSegment.info.vertexLength <= std::numeric_limits<uint16_t>::max());
+            uint16_t lineIndex = lineSegment.info.vertexLength;
 
             vertices.emplace_back(FillProgram::layoutVertex(ring[0]));
             lines.emplace_back(lineIndex + nVertices - 1, lineIndex);
@@ -77,8 +77,8 @@ void FillBucket::addFeature(const GeometryTileFeature& feature,
                 lines.emplace_back(lineIndex + i - 1, lineIndex + i);
             }
 
-            lineSegment.vertexLength += nVertices;
-            lineSegment.indexLength += nVertices * 2;
+            lineSegment.info.vertexLength += nVertices;
+            lineSegment.info.indexLength += nVertices * 2;
         }
 
         std::vector<uint32_t> indices = mapbox::earcut(polygon);
@@ -86,13 +86,13 @@ void FillBucket::addFeature(const GeometryTileFeature& feature,
         std::size_t nIndicies = indices.size();
         assert(nIndicies % 3 == 0);
 
-        if (triangleSegments.empty() || triangleSegments.back().vertexLength + totalVertices > std::numeric_limits<uint16_t>::max()) {
+        if (triangleSegments.empty() || triangleSegments.back().info.vertexLength + totalVertices > std::numeric_limits<uint16_t>::max()) {
             triangleSegments.emplace_back(startVertices, triangles.indexSize());
         }
 
         auto& triangleSegment = triangleSegments.back();
-        assert(triangleSegment.vertexLength <= std::numeric_limits<uint16_t>::max());
-        uint16_t triangleIndex = triangleSegment.vertexLength;
+        assert(triangleSegment.info.vertexLength <= std::numeric_limits<uint16_t>::max());
+        uint16_t triangleIndex = triangleSegment.info.vertexLength;
 
         for (uint32_t i = 0; i < nIndicies; i += 3) {
             triangles.emplace_back(triangleIndex + indices[i],
@@ -100,8 +100,8 @@ void FillBucket::addFeature(const GeometryTileFeature& feature,
                                    triangleIndex + indices[i + 2]);
         }
 
-        triangleSegment.vertexLength += totalVertices;
-        triangleSegment.indexLength += nIndicies;
+        triangleSegment.info.vertexLength += totalVertices;
+        triangleSegment.info.indexLength += nIndicies;
     }
 
     for (auto& pair : paintPropertyBinders) {
diff --git a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
index f61f1d1549..ec507da900 100644
--- a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
+++ b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
@@ -67,14 +67,14 @@ void FillExtrusionBucket::addFeature(const GeometryTileFeature& feature,
         std::size_t startVertices = vertices.vertexSize();
 
         if (triangleSegments.empty() ||
-            triangleSegments.back().vertexLength + (5 * (totalVertices - 1) + 1) >
+            triangleSegments.back().info.vertexLength + (5 * (totalVertices - 1) + 1) >
                 std::numeric_limits<uint16_t>::max()) {
             triangleSegments.emplace_back(startVertices, triangles.indexSize());
         }
 
         auto& triangleSegment = triangleSegments.back();
-        assert(triangleSegment.vertexLength <= std::numeric_limits<uint16_t>::max());
-        uint16_t triangleIndex = triangleSegment.vertexLength;
+        assert(triangleSegment.info.vertexLength <= std::numeric_limits<uint16_t>::max());
+        uint16_t triangleIndex = triangleSegment.info.vertexLength;
 
         assert(triangleIndex + (5 * (totalVertices - 1) + 1) <=
                std::numeric_limits<uint16_t>::max());
@@ -118,8 +118,8 @@ void FillExtrusionBucket::addFeature(const GeometryTileFeature& feature,
                     triangles.emplace_back(triangleIndex, triangleIndex + 1, triangleIndex + 2);
                     triangles.emplace_back(triangleIndex + 1, triangleIndex + 2, triangleIndex + 3);
                     triangleIndex += 4;
-                    triangleSegment.vertexLength += 4;
-                    triangleSegment.indexLength += 6;
+                    triangleSegment.info.vertexLength += 4;
+                    triangleSegment.info.indexLength += 6;
                 }
             }
         }
@@ -134,8 +134,8 @@ void FillExtrusionBucket::addFeature(const GeometryTileFeature& feature,
                                    flatIndices[indices[i + 2]]);
         }
 
-        triangleSegment.vertexLength += totalVertices;
-        triangleSegment.indexLength += nIndices;
+        triangleSegment.info.vertexLength += totalVertices;
+        triangleSegment.info.indexLength += nIndices;
     }
 
     for (auto& pair : paintPropertyBinders) {
diff --git a/src/mbgl/renderer/buckets/line_bucket.cpp b/src/mbgl/renderer/buckets/line_bucket.cpp
index 3af3cd63d3..d81ad76851 100644
--- a/src/mbgl/renderer/buckets/line_bucket.cpp
+++ b/src/mbgl/renderer/buckets/line_bucket.cpp
@@ -371,20 +371,20 @@ void LineBucket::addGeometry(const GeometryCoordinates& coordinates, FeatureType
     const std::size_t endVertex = vertices.vertexSize();
     const std::size_t vertexCount = endVertex - startVertex;
 
-    if (segments.empty() || segments.back().vertexLength + vertexCount > std::numeric_limits<uint16_t>::max()) {
+    if (segments.empty() || segments.back().info.vertexLength + vertexCount > std::numeric_limits<uint16_t>::max()) {
         segments.emplace_back(startVertex, triangles.indexSize());
     }
 
     auto& segment = segments.back();
-    assert(segment.vertexLength <= std::numeric_limits<uint16_t>::max());
-    uint16_t index = segment.vertexLength;
+    assert(segment.info.vertexLength <= std::numeric_limits<uint16_t>::max());
+    uint16_t index = segment.info.vertexLength;
 
     for (const auto& triangle : triangleStore) {
         triangles.emplace_back(index + triangle.a, index + triangle.b, index + triangle.c);
     }
 
-    segment.vertexLength += vertexCount;
-    segment.indexLength += triangleStore.size() * 3;
+    segment.info.vertexLength += vertexCount;
+    segment.info.indexLength += triangleStore.size() * 3;
 }
 
 void LineBucket::addCurrentVertex(const GeometryCoordinate& currentCoordinate,
diff --git a/test/gl/bucket.test.cpp b/test/gl/bucket.test.cpp
index fdff0e990a..e0e7342c6f 100644
--- a/test/gl/bucket.test.cpp
+++ b/test/gl/bucket.test.cpp
@@ -84,7 +84,7 @@ TEST(Buckets, SymbolBucket) {
     ASSERT_FALSE(bucket.hasData());
     ASSERT_FALSE(bucket.needsUpload());
 
-    bucket.text.segments.emplace_back(0, 0);
+    bucket.text.segments.emplace_back(gl::SegmentInfo{ 0, 0 });
     ASSERT_TRUE(bucket.hasTextData());
     ASSERT_TRUE(bucket.hasData());
     ASSERT_TRUE(bucket.needsUpload());