1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
#pragma once
#include <mbgl/renderer/bucket.hpp>
#include <mbgl/map/mode.hpp>
#include <mbgl/gfx/vertex_buffer.hpp>
#include <mbgl/gfx/index_buffer.hpp>
#include <mbgl/programs/segment.hpp>
#include <mbgl/programs/symbol_program.hpp>
#include <mbgl/programs/collision_box_program.hpp>
#include <mbgl/text/glyph_range.hpp>
#include <mbgl/style/layers/symbol_layer_properties.hpp>
#include <mbgl/layout/symbol_feature.hpp>
#include <mbgl/layout/symbol_instance.hpp>
#include <vector>
namespace mbgl {
class CrossTileSymbolLayerIndex;
class PlacedSymbol {
public:
PlacedSymbol(Point<float> anchorPoint_,
std::size_t segment_,
float lowerSize_,
float upperSize_,
std::array<float, 2> lineOffset_,
WritingModeType writingModes_,
GeometryCoordinates line_,
std::vector<float> tileDistances_,
optional<size_t> placedIconIndex_ = nullopt)
: anchorPoint(anchorPoint_),
segment(segment_),
lowerSize(lowerSize_),
upperSize(upperSize_),
lineOffset(lineOffset_),
writingModes(writingModes_),
line(std::move(line_)),
tileDistances(std::move(tileDistances_)),
hidden(false),
vertexStartIndex(0),
placedIconIndex(std::move(placedIconIndex_)) {}
Point<float> anchorPoint;
std::size_t segment;
float lowerSize;
float upperSize;
std::array<float, 2> lineOffset;
WritingModeType writingModes;
GeometryCoordinates line;
std::vector<float> tileDistances;
std::vector<float> glyphOffsets;
bool hidden;
size_t vertexStartIndex;
// The crossTileID is only filled/used on the foreground for variable text anchors
uint32_t crossTileID = 0u;
// The placedOrientation is only used when symbol layer's property is set to support
// placement for orientation variants.
optional<style::TextWritingModeType> placedOrientation;
float angle = 0;
// Reference to placed icon, only applicable for text symbols.
optional<size_t> placedIconIndex;
};
class SymbolBucket final : public Bucket {
public:
SymbolBucket(Immutable<style::SymbolLayoutProperties::PossiblyEvaluated>,
const std::map<std::string, Immutable<style::LayerProperties>>&,
const style::PropertyValue<float>& textSize,
const style::PropertyValue<float>& iconSize,
float zoom,
bool iconsNeedLinear,
bool sortFeaturesByY,
const std::string bucketLeaderID,
const std::vector<SymbolInstance>&&,
const float tilePixelRatio,
bool allowVerticalPlacement,
std::vector<style::TextWritingModeType> placementModes,
bool iconsInText);
~SymbolBucket() override;
void upload(gfx::UploadPass&) override;
bool hasData() const override;
std::pair<uint32_t, bool> registerAtCrossTileIndex(CrossTileSymbolLayerIndex&,
const OverscaledTileID&,
const TransformState& transformState) override;
void place(Placement&, const BucketPlacementParameters&, std::set<uint32_t>&) override;
void updateVertices(
const Placement&, bool updateOpacities, const TransformState&, const RenderTile&, std::set<uint32_t>&) override;
bool hasTextData() const;
bool hasIconData() const;
bool hasSdfIconData() const;
bool hasIconCollisionBoxData() const;
bool hasIconCollisionCircleData() const;
bool hasTextCollisionBoxData() const;
bool hasTextCollisionCircleData() const;
bool hasFormatSectionOverrides() const;
void sortFeatures(const float angle);
// The result contains references to the `symbolInstances` items, sorted by viewport Y.
std::vector<std::reference_wrapper<const SymbolInstance>> getSortedSymbols(const float angle) const;
Immutable<style::SymbolLayoutProperties::PossiblyEvaluated> layout;
const std::string bucketLeaderID;
float sortedAngle = std::numeric_limits<float>::max();
// Flags
const bool iconsNeedLinear : 1;
const bool sortFeaturesByY : 1;
bool staticUploaded : 1;
bool placementChangesUploaded : 1;
bool dynamicUploaded : 1;
bool sortUploaded : 1;
bool iconsInText : 1;
// Set and used by placement.
mutable bool justReloaded : 1;
bool hasVariablePlacement : 1;
std::vector<SymbolInstance> symbolInstances;
struct PaintProperties {
SymbolIconProgram::Binders iconBinders;
SymbolSDFTextProgram::Binders textBinders;
};
std::map<std::string, PaintProperties> paintProperties;
std::unique_ptr<SymbolSizeBinder> textSizeBinder;
struct Buffer {
gfx::VertexVector<SymbolLayoutVertex> vertices;
gfx::VertexVector<gfx::Vertex<SymbolDynamicLayoutAttributes>> dynamicVertices;
gfx::VertexVector<gfx::Vertex<SymbolOpacityAttributes>> opacityVertices;
gfx::IndexVector<gfx::Triangles> triangles;
SegmentVector<SymbolTextAttributes> segments;
std::vector<PlacedSymbol> placedSymbols;
optional<gfx::VertexBuffer<SymbolLayoutVertex>> vertexBuffer;
optional<gfx::VertexBuffer<gfx::Vertex<SymbolDynamicLayoutAttributes>>> dynamicVertexBuffer;
optional<gfx::VertexBuffer<gfx::Vertex<SymbolOpacityAttributes>>> opacityVertexBuffer;
optional<gfx::IndexBuffer> indexBuffer;
} text;
std::unique_ptr<SymbolSizeBinder> iconSizeBinder;
Buffer icon;
Buffer sdfIcon;
struct CollisionBuffer {
gfx::VertexVector<gfx::Vertex<CollisionBoxLayoutAttributes>> vertices;
gfx::VertexVector<gfx::Vertex<CollisionBoxDynamicAttributes>> dynamicVertices;
SegmentVector<CollisionBoxProgram::AttributeList> segments;
optional<gfx::VertexBuffer<gfx::Vertex<CollisionBoxLayoutAttributes>>> vertexBuffer;
optional<gfx::VertexBuffer<gfx::Vertex<CollisionBoxDynamicAttributes>>> dynamicVertexBuffer;
};
struct CollisionBoxBuffer : public CollisionBuffer {
gfx::IndexVector<gfx::Lines> lines;
optional<gfx::IndexBuffer> indexBuffer;
};
std::unique_ptr<CollisionBoxBuffer> iconCollisionBox;
std::unique_ptr<CollisionBoxBuffer> textCollisionBox;
CollisionBoxBuffer& getOrCreateIconCollisionBox() {
if (!iconCollisionBox) iconCollisionBox = std::make_unique<CollisionBoxBuffer>();
return *iconCollisionBox;
}
CollisionBoxBuffer& getOrCreateTextCollisionBox() {
if (!textCollisionBox) textCollisionBox = std::make_unique<CollisionBoxBuffer>();
return *textCollisionBox;
}
struct CollisionCircleBuffer : public CollisionBuffer {
gfx::IndexVector<gfx::Triangles> triangles;
optional<gfx::IndexBuffer> indexBuffer;
};
std::unique_ptr<CollisionCircleBuffer> iconCollisionCircle;
std::unique_ptr<CollisionCircleBuffer> textCollisionCircle;
CollisionCircleBuffer& getOrCreateIconCollisionCircleBuffer() {
if (!iconCollisionCircle) iconCollisionCircle = std::make_unique<CollisionCircleBuffer>();
return *iconCollisionCircle;
}
CollisionCircleBuffer& getOrCreateTextCollisionCircleBuffer() {
if (!textCollisionCircle) textCollisionCircle = std::make_unique<CollisionCircleBuffer>();
return *textCollisionCircle;
}
const float tilePixelRatio;
uint32_t bucketInstanceId;
const bool allowVerticalPlacement;
const std::vector<style::TextWritingModeType> placementModes;
mutable optional<bool> hasFormatSectionOverrides_;
FeatureSortOrder featureSortOrder;
};
} // namespace mbgl
|
