[core] Remove ProjectedCollisionBox from CollisionBox

- Minus 20 bytes from CollisionBox size.
- Fix constness at Placement::placeBucket

Author: pozdnyakov

src/mbgl/renderer/buckets/symbol_bucket.cpp

@@ -227,8 +227,8 @@ void SymbolBucket::sortFeatures(const float angle) {
     }
 }
 
-std::vector<std::reference_wrapper<SymbolInstance>> SymbolBucket::getSortedSymbols(const float angle) {
-    std::vector<std::reference_wrapper<SymbolInstance>> result(symbolInstances.begin(), symbolInstances.end());
+std::vector<std::reference_wrapper<const SymbolInstance>> SymbolBucket::getSortedSymbols(const float angle) const {
+    std::vector<std::reference_wrapper<const SymbolInstance>> result(symbolInstances.begin(), symbolInstances.end());
     const float sin = std::sin(angle);
     const float cos = std::cos(angle);
 

src/mbgl/renderer/buckets/symbol_bucket.hpp

@@ -70,7 +70,7 @@ class SymbolBucket final : public Bucket {
 
     void sortFeatures(const float angle);
     // The result contains references to the `symbolInstances` items, sorted by viewport Y.
-    std::vector<std::reference_wrapper<SymbolInstance>> getSortedSymbols(const float angle);
+    std::vector<std::reference_wrapper<const SymbolInstance>> getSortedSymbols(const float angle) const;
 
     Immutable<style::SymbolLayoutProperties::PossiblyEvaluated> layout;
     const std::string bucketLeaderID;
@@ -84,7 +84,8 @@ class SymbolBucket final : public Bucket {
     bool placementChangesUploaded : 1;
     bool dynamicUploaded : 1;
     bool sortUploaded : 1;
-    bool justReloaded : 1;
+    // Set and used by placement.
+    mutable bool justReloaded : 1;
     bool hasVariablePlacement : 1;
 
     std::vector<SymbolInstance> symbolInstances;
@@ -113,8 +114,7 @@ class SymbolBucket final : public Bucket {
 
     std::unique_ptr<SymbolSizeBinder> iconSizeBinder;
 
-    struct IconBuffer : public Buffer {
-    } icon;
+    Buffer icon;
 
     struct CollisionBuffer {
         gfx::VertexVector<gfx::Vertex<CollisionBoxLayoutAttributes>> vertices;

src/mbgl/text/collision_feature.hpp

@@ -64,9 +64,6 @@ class CollisionBox {
     float y2;
 
     float signedDistanceFromAnchor;
-
-    // generated/updated at placement time
-    ProjectedCollisionBox projected;
 };
 
 class CollisionFeature {

src/mbgl/text/collision_index.cpp

@@ -79,54 +79,58 @@ bool CollisionIndex::isInsideTile(float x1, float y1, float x2, float y2, const
 }
 
 
-std::pair<bool,bool> CollisionIndex::placeFeature(CollisionFeature& feature,
+std::pair<bool,bool> CollisionIndex::placeFeature(const CollisionFeature& feature,
                                       Point<float> shift,
                                       const mat4& posMatrix,
                                       const mat4& labelPlaneMatrix,
                                       const float textPixelRatio,
-                                      PlacedSymbol& symbol,
+                                      const PlacedSymbol& symbol,
                                       const float scale,
                                       const float fontSize,
                                       const bool allowOverlap,
                                       const bool pitchWithMap,
                                       const bool collisionDebug,
                                       const optional<CollisionTileBoundaries>& avoidEdges,
-                                      const optional<std::function<bool(const IndexedSubfeature&)>> collisionGroupPredicate) {
+                                      const optional<std::function<bool(const IndexedSubfeature&)>> collisionGroupPredicate,
+                                      std::vector<ProjectedCollisionBox>& projectedBoxes) {
+    assert(projectedBoxes.empty());
     if (!feature.alongLine) {
-        CollisionBox& box = feature.boxes.front();
+        const CollisionBox& box = feature.boxes.front();
         const auto projectedPoint = projectAndGetPerspectiveRatio(posMatrix, box.anchor);
         const float tileToViewport = textPixelRatio * projectedPoint.second;
         float px1 = (box.x1 + shift.x) * tileToViewport + projectedPoint.first.x;
         float py1 = (box.y1 + shift.y) * tileToViewport + projectedPoint.first.y;
         float px2 = (box.x2 + shift.x) * tileToViewport + projectedPoint.first.x;
         float py2 = (box.y2 + shift.y) * tileToViewport + projectedPoint.first.y;
-        box.projected = ProjectedCollisionBox{ px1, py1, px2, py2 };
+        projectedBoxes.emplace_back(px1, py1, px2, py2);
 
         if ((avoidEdges && !isInsideTile(px1, py1, px2, py2, *avoidEdges)) ||
             !isInsideGrid(px1, py1, px2, py2) ||
-            (!allowOverlap && collisionGrid.hitTest(box.projected.box(), collisionGroupPredicate))) {
+            (!allowOverlap && collisionGrid.hitTest(projectedBoxes.back().box(), collisionGroupPredicate))) {
             return { false, false };
         }
 
         return {true, isOffscreen(px1, py1, px2, py2)};
     } else {
-        return placeLineFeature(feature, posMatrix, labelPlaneMatrix, textPixelRatio, symbol, scale, fontSize, allowOverlap, pitchWithMap, collisionDebug, avoidEdges, collisionGroupPredicate);
+        return placeLineFeature(feature, posMatrix, labelPlaneMatrix, textPixelRatio, symbol, scale, fontSize, allowOverlap, pitchWithMap, collisionDebug, avoidEdges, collisionGroupPredicate, projectedBoxes);
     }
 }
 
-std::pair<bool,bool> CollisionIndex::placeLineFeature(CollisionFeature& feature,
+std::pair<bool,bool> CollisionIndex::placeLineFeature(const CollisionFeature& feature,
                                       const mat4& posMatrix,
                                       const mat4& labelPlaneMatrix,
                                       const float textPixelRatio,
-                                      PlacedSymbol& symbol,
+                                      const PlacedSymbol& symbol,
                                       const float scale,
                                       const float fontSize,
                                       const bool allowOverlap,
                                       const bool pitchWithMap,
                                       const bool collisionDebug,
                                       const optional<CollisionTileBoundaries>& avoidEdges,
-                                      const optional<std::function<bool(const IndexedSubfeature&)>> collisionGroupPredicate) {
+                                      const optional<std::function<bool(const IndexedSubfeature&)>> collisionGroupPredicate,
+                                      std::vector<ProjectedCollisionBox>& projectedBoxes) {
     assert(feature.alongLine);
+    assert(projectedBoxes.empty());
     const auto tileUnitAnchorPoint = symbol.anchorPoint;
     const auto projectedAnchor = projectAnchor(posMatrix, tileUnitAnchorPoint);
 
@@ -164,8 +168,9 @@ std::pair<bool,bool> CollisionIndex::placeLineFeature(CollisionFeature& feature,
     }
 
     bool previousCirclePlaced = false;
+    projectedBoxes.resize(feature.boxes.size());
     for (size_t i = 0; i < feature.boxes.size(); i++) {
-        CollisionBox& circle = feature.boxes[i];
+        const CollisionBox& circle = feature.boxes[i];
         const float boxSignedDistanceFromAnchor = circle.signedDistanceFromAnchor;
         if (!firstAndLastGlyph ||
             (boxSignedDistanceFromAnchor < -firstTileDistance) ||
@@ -182,9 +187,9 @@ std::pair<bool,bool> CollisionIndex::placeLineFeature(CollisionFeature& feature,
         const float radius = tileUnitRadius * tileToViewport;
 
         if (previousCirclePlaced) {
-            const CollisionBox& previousCircle = feature.boxes[i - 1];
-            assert(previousCircle.projected.isCircle());
-            const auto& previousCenter = previousCircle.projected.circle().center;
+            const ProjectedCollisionBox& previousCircle = projectedBoxes[i - 1];
+            assert(previousCircle.isCircle());
+            const auto& previousCenter = previousCircle.circle().center;
             const float dx = projectedPoint.x - previousCenter.x;
             const float dy = projectedPoint.y - previousCenter.y;
             // The circle edges touch when the distance between their centers is 2x the radius
@@ -217,13 +222,13 @@ std::pair<bool,bool> CollisionIndex::placeLineFeature(CollisionFeature& feature,
         float py1 = projectedPoint.y - radius;
         float py2 = projectedPoint.y + radius;
 
-        circle.projected = ProjectedCollisionBox{projectedPoint.x, projectedPoint.y, radius};
+        projectedBoxes[i] = ProjectedCollisionBox{projectedPoint.x, projectedPoint.y, radius};
 
         entirelyOffscreen &= isOffscreen(px1, py1, px2, py2);
         inGrid |= isInsideGrid(px1, py1, px2, py2);
 
         if ((avoidEdges && !isInsideTile(px1, py1, px2, py2, *avoidEdges)) ||
-            (!allowOverlap && collisionGrid.hitTest(circle.projected.circle(), collisionGroupPredicate))) {
+            (!allowOverlap && collisionGrid.hitTest(projectedBoxes[i].circle(), collisionGroupPredicate))) {
             if (!collisionDebug) {
                 return {false, false};
             } else {
@@ -238,38 +243,38 @@ std::pair<bool,bool> CollisionIndex::placeLineFeature(CollisionFeature& feature,
 }
 
 
-void CollisionIndex::insertFeature(CollisionFeature& feature, bool ignorePlacement, uint32_t bucketInstanceId, uint16_t collisionGroupId) {
+void CollisionIndex::insertFeature(const CollisionFeature& feature, const std::vector<ProjectedCollisionBox>& projectedBoxes, bool ignorePlacement, uint32_t bucketInstanceId, uint16_t collisionGroupId) {
     if (feature.alongLine) {
-        for (auto& circle : feature.boxes) {
-            if (!circle.projected.isCircle()) {
+        for (auto& circle : projectedBoxes) {
+            if (!circle.isCircle()) {
                 continue;
             }
 
             if (ignorePlacement) {
                 ignoredGrid.insert(
                     IndexedSubfeature(feature.indexedFeature, bucketInstanceId, collisionGroupId),
-                    circle.projected.circle()
+                    circle.circle()
                 );
             } else {
                 collisionGrid.insert(
                     IndexedSubfeature(feature.indexedFeature, bucketInstanceId, collisionGroupId),
-                    circle.projected.circle()
+                    circle.circle()
                 );
             }
         }
     } else {
-        assert(feature.boxes.size() == 1);
-        auto& box = feature.boxes[0];
-        assert(box.projected.isBox());
+        assert(projectedBoxes.size() == 1);
+        auto& box = projectedBoxes[0];
+        assert(box.isBox());
         if (ignorePlacement) {
             ignoredGrid.insert(
                 IndexedSubfeature(feature.indexedFeature, bucketInstanceId, collisionGroupId),
-                box.projected.box()
+                box.box()
             );
         } else {
             collisionGrid.insert(
                 IndexedSubfeature(feature.indexedFeature, bucketInstanceId, collisionGroupId),
-                box.projected.box()
+                box.box()
             );
         }
     }

src/mbgl/text/collision_index.hpp

@@ -22,21 +22,22 @@ class CollisionIndex {
 
     explicit CollisionIndex(const TransformState&);
 
-    std::pair<bool,bool> placeFeature(CollisionFeature& feature,
+    std::pair<bool,bool> placeFeature(const CollisionFeature& feature,
                                       Point<float> shift,
                                       const mat4& posMatrix,
                                       const mat4& labelPlaneMatrix,
                                       const float textPixelRatio,
-                                      PlacedSymbol& symbol,
+                                      const PlacedSymbol& symbol,
                                       const float scale,
                                       const float fontSize,
                                       const bool allowOverlap,
                                       const bool pitchWithMap,
                                       const bool collisionDebug,
                                       const optional<CollisionTileBoundaries>& avoidEdges,
-                                      const optional<std::function<bool(const IndexedSubfeature&)>> collisionGroupPredicate);
+                                      const optional<std::function<bool(const IndexedSubfeature&)>> collisionGroupPredicate,
+                                      std::vector<ProjectedCollisionBox>& /*out*/);
 
-    void insertFeature(CollisionFeature& feature, bool ignorePlacement, uint32_t bucketInstanceId, uint16_t collisionGroupId);
+    void insertFeature(const CollisionFeature& feature, const std::vector<ProjectedCollisionBox>&, bool ignorePlacement, uint32_t bucketInstanceId, uint16_t collisionGroupId);
 
     std::unordered_map<uint32_t, std::vector<IndexedSubfeature>> queryRenderedSymbols(const ScreenLineString&) const;
 
@@ -49,18 +50,19 @@ class CollisionIndex {
     bool isInsideGrid(float x1, float y1, float x2, float y2) const;
     bool isInsideTile(float x1, float y1, float x2, float y2, const CollisionTileBoundaries& tileBoundaries) const;
 
-    std::pair<bool,bool> placeLineFeature(CollisionFeature& feature,
+    std::pair<bool,bool> placeLineFeature(const CollisionFeature& feature,
                                   const mat4& posMatrix,
                                   const mat4& labelPlaneMatrix,
                                   const float textPixelRatio,
-                                  PlacedSymbol& symbol,
+                                  const PlacedSymbol& symbol,
                                   const float scale,
                                   const float fontSize,
                                   const bool allowOverlap,
                                   const bool pitchWithMap,
                                   const bool collisionDebug,
                                   const optional<CollisionTileBoundaries>& avoidEdges,
-                                  const optional<std::function<bool(const IndexedSubfeature&)>> collisionGroupPredicate);
+                                  const optional<std::function<bool(const IndexedSubfeature&)>> collisionGroupPredicate,
+                                  std::vector<ProjectedCollisionBox>& /*out*/);
 
     float approximateTileDistance(const TileDistance& tileDistance, const float lastSegmentAngle, const float pixelsToTileUnits, const float cameraToAnchorDistance, const bool pitchWithMap);