tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

make StyleBucket mutable

Browse Source 
refs #881
This commit is contained in:
Konstantin Käfer
2015-02-17 17:49:02 -08:00
parent df23a6b7d7
commit 89c0ff5f39
14 changed files with 120 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
src/mbgl/map/tile_parser.cpp
View File

@@ -56,12 +56,12 @@ void TileParser::parse() {
bool TileParser::obsolete() const { return tile.state == TileData::State::obsolete; }
void TileParser::parseStyleLayers(util::ptr<StyleLayerGroup> group) {
void TileParser::parseStyleLayers(util::ptr<const StyleLayerGroup> group) {
if (!group) {
return;
}
for (const util::ptr<StyleLayer> &layer_desc : group->layers) {
for (const util::ptr<const StyleLayer> &layer_desc : group->layers) {
// Cancel early when parsing.
if (obsolete()) {
return;
@@ -78,7 +78,7 @@ void TileParser::parseStyleLayers(util::ptr<StyleLayerGroup> group) {
auto bucket_it = tile.buckets.find(layer_desc->bucket->name);
if (bucket_it == tile.buckets.end()) {
// We need to create this bucket since it doesn't exist yet.
std::unique_ptr<Bucket> bucket = createBucket(layer_desc->bucket);
std::unique_ptr<Bucket> bucket = createBucket(*layer_desc->bucket);
if (bucket) {
// Bucket creation might fail because the data tile may not
// contain any data that falls into this bucket.
@@ -115,35 +115,26 @@ private:
};
template <typename T>
void TileParser::applyLayoutProperty(PropertyKey key, ClassProperties &classProperties, T &target, const float z) {
void applyLayoutProperty(PropertyKey key, const ClassProperties &classProperties, T &target, const float z) {
auto it = classProperties.properties.find(key);
if (it != classProperties.properties.end()) {
const PropertyEvaluator<T> evaluator(z);
target = mapbox::util::apply_visitor(evaluator, it->second);
}
}
template <>
void TileParser::applyLayoutProperties<FillProperties>(StyleBucket &bucket_desc, const float) {
bucket_desc.render.set<StyleBucketFill>();
void parseLayoutProperties(StyleBucketFill &/*fill*/, const StyleBucket &/*bucket*/, const float /*z*/) {
// no-op; Fill buckets don't currently have any applicable layout properties
}
template<>
void TileParser::applyLayoutProperties<LineProperties>(StyleBucket &bucket_desc, const float z) {
bucket_desc.render.set<StyleBucketLine>();
StyleBucketLine &line = bucket_desc.render.get<StyleBucketLine>();
void parseLayoutProperties(StyleBucketLine &line, const StyleBucket &bucket_desc, const float z) {
applyLayoutProperty(PropertyKey::LineCap, bucket_desc.layout, line.cap, z);
applyLayoutProperty(PropertyKey::LineJoin, bucket_desc.layout, line.join, z);
applyLayoutProperty(PropertyKey::LineMiterLimit, bucket_desc.layout, line.miter_limit, z);
applyLayoutProperty(PropertyKey::LineRoundLimit, bucket_desc.layout, line.round_limit, z);
}
template<>
void TileParser::applyLayoutProperties<SymbolProperties>(StyleBucket &bucket_desc, const float z) {
bucket_desc.render.set<StyleBucketSymbol>();
StyleBucketSymbol &symbol = bucket_desc.render.get<StyleBucketSymbol>();
void parseLayoutProperties(StyleBucketSymbol &symbol, const StyleBucket &bucket_desc, const float z) {
applyLayoutProperty(PropertyKey::SymbolPlacement, bucket_desc.layout, symbol.placement, z);
if (symbol.placement == PlacementType::Line) {
symbol.icon.rotation_alignment = RotationAlignmentType::Map;
@@ -183,39 +174,31 @@ void TileParser::applyLayoutProperties<SymbolProperties>(StyleBucket &bucket_des
applyLayoutProperty(PropertyKey::TextAllowOverlap, bucket_desc.layout, symbol.text.allow_overlap, z);
}
std::unique_ptr<Bucket> TileParser::createBucket(util::ptr<StyleBucket> bucket_desc) {
if (!bucket_desc) {
fprintf(stderr, "missing bucket desc\n");
return nullptr;
}
std::unique_ptr<Bucket> TileParser::createBucket(const StyleBucket &bucket_desc) {
// Skip this bucket if we are to not render this
if (tile.id.z < std::floor(bucket_desc->min_zoom) && std::floor(bucket_desc->min_zoom) < tile.source.max_zoom) return nullptr;
if (tile.id.z >= std::ceil(bucket_desc->max_zoom)) return nullptr;
if (bucket_desc->visibility == mbgl::VisibilityType::None) return nullptr;
if (tile.id.z < std::floor(bucket_desc.min_zoom) && std::floor(bucket_desc.min_zoom) < tile.source.max_zoom) return nullptr;
if (tile.id.z >= std::ceil(bucket_desc.max_zoom)) return nullptr;
if (bucket_desc.visibility == mbgl::VisibilityType::None) return nullptr;
auto layer_it = vector_data.layers.find(bucket_desc->source_layer);
auto layer_it = vector_data.layers.find(bucket_desc.source_layer);
if (layer_it != vector_data.layers.end()) {
const VectorTileLayer &layer = layer_it->second;
if (bucket_desc->type == StyleLayerType::Fill) {
applyLayoutProperties<FillProperties>(*bucket_desc, tile.id.z);
return createFillBucket(layer, bucket_desc->filter, bucket_desc->render.get<StyleBucketFill>());
} else if (bucket_desc->type == StyleLayerType::Line) {
applyLayoutProperties<LineProperties>(*bucket_desc, tile.id.z);
return createLineBucket(layer, bucket_desc->filter, bucket_desc->render.get<StyleBucketLine>());
} else if (bucket_desc->type == StyleLayerType::Symbol) {
applyLayoutProperties<SymbolProperties>(*bucket_desc, tile.id.z);
return createSymbolBucket(layer, bucket_desc->filter, bucket_desc->render.get<StyleBucketSymbol>());
} else if (bucket_desc->type == StyleLayerType::Raster) {
if (bucket_desc.type == StyleLayerType::Fill) {
return createFillBucket(layer, bucket_desc);
} else if (bucket_desc.type == StyleLayerType::Line) {
return createLineBucket(layer, bucket_desc);
} else if (bucket_desc.type == StyleLayerType::Symbol) {
return createSymbolBucket(layer, bucket_desc);
} else if (bucket_desc.type == StyleLayerType::Raster) {
return nullptr;
} else {
fprintf(stderr, "[WARNING] unknown bucket render type for layer '%s' (source layer '%s')\n", bucket_desc->name.c_str(), bucket_desc->source_layer.c_str());
fprintf(stderr, "[WARNING] unknown bucket render type for layer '%s' (source layer '%s')\n", bucket_desc.name.c_str(), bucket_desc.source_layer.c_str());
}
} else {
// The layer specified in the bucket does not exist. Do nothing.
if (debug::tileParseWarnings) {
fprintf(stderr, "[WARNING] layer '%s' does not exist in tile %d/%d/%d\n",
bucket_desc->source_layer.c_str(), tile.id.z, tile.id.x, tile.id.y);
bucket_desc.source_layer.c_str(), tile.id.z, tile.id.x, tile.id.y);
}
}
@@ -240,9 +223,15 @@ void TileParser::addBucketGeometries(Bucket& bucket, const VectorTileLayer& laye
}
}
std::unique_ptr<Bucket> TileParser::createFillBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketFill &fill) {
std::unique_ptr<FillBucket> bucket = util::make_unique<FillBucket>(tile.fillVertexBuffer, tile.triangleElementsBuffer, tile.lineElementsBuffer, fill);
addBucketGeometries(bucket, layer, filter);
std::unique_ptr<Bucket> TileParser::createFillBucket(const VectorTileLayer &layer,
const StyleBucket &bucket_desc) {
auto fill = util::make_unique<StyleBucketFill>();
parseLayoutProperties(*fill, bucket_desc, tile.id.z);
auto bucket = util::make_unique<FillBucket>(std::move(fill),
tile.fillVertexBuffer,
tile.triangleElementsBuffer,
tile.lineElementsBuffer);
addBucketGeometries(bucket, layer, bucket_desc.filter);
return obsolete() ? nullptr : std::move(bucket);
}
@@ -251,16 +240,25 @@ std::unique_ptr<Bucket> TileParser::createRasterBucket(const StyleBucketRaster &
return obsolete() ? nullptr : std::move(bucket);
}
std::unique_ptr<Bucket> TileParser::createLineBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketLine &line) {
std::unique_ptr<LineBucket> bucket = util::make_unique<LineBucket>(tile.lineVertexBuffer, tile.triangleElementsBuffer, tile.pointElementsBuffer, line);
addBucketGeometries(bucket, layer, filter);
std::unique_ptr<Bucket> TileParser::createLineBucket(const VectorTileLayer &layer,
const StyleBucket &bucket_desc) {
auto line = util::make_unique<StyleBucketLine>();
parseLayoutProperties(*line, bucket_desc, tile.id.z);
auto bucket = util::make_unique<LineBucket>(std::move(line),
tile.lineVertexBuffer,
tile.triangleElementsBuffer,
tile.pointElementsBuffer);
addBucketGeometries(bucket, layer, bucket_desc.filter);
return obsolete() ? nullptr : std::move(bucket);
}
std::unique_ptr<Bucket> TileParser::createSymbolBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketSymbol &symbol) {
std::unique_ptr<SymbolBucket> bucket = util::make_unique<SymbolBucket>(symbol, *collision);
bucket->addFeatures(layer, filter, tile.id, spriteAtlas, *sprite, glyphAtlas, glyphStore);
std::unique_ptr<Bucket> TileParser::createSymbolBucket(const VectorTileLayer &layer,
const StyleBucket &bucket_desc) {
auto symbol = util::make_unique<StyleBucketSymbol>();
parseLayoutProperties(*symbol, bucket_desc, tile.id.z);
auto bucket = util::make_unique<SymbolBucket>(std::move(symbol), *collision);
bucket->addFeatures(
layer, bucket_desc.filter, tile.id, spriteAtlas, *sprite, glyphAtlas, glyphStore);
return obsolete() ? nullptr : std::move(bucket);
}
}

14
src/mbgl/map/tile_parser.hpp
View File

@@ -49,17 +49,13 @@ public:
private:
bool obsolete() const;
void parseStyleLayers(util::ptr<StyleLayerGroup> group);
void parseStyleLayers(util::ptr<const StyleLayerGroup> group);
template <typename T> void applyLayoutProperties(StyleBucket &bucket, float z);
template <typename T> void applyLayoutProperty(PropertyKey key, ClassProperties &classProperties, T &, float z);
std::unique_ptr<Bucket> createBucket(util::ptr<StyleBucket> bucket_desc);
std::unique_ptr<Bucket> createFillBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketFill &fill);
std::unique_ptr<Bucket> createBucket(const StyleBucket &bucket_desc);
std::unique_ptr<Bucket> createFillBucket(const VectorTileLayer &layer, const StyleBucket &bucket_desc);
std::unique_ptr<Bucket> createRasterBucket(const StyleBucketRaster &raster);
std::unique_ptr<Bucket> createLineBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketLine &line);
std::unique_ptr<Bucket> createSymbolBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketSymbol &symbol);
std::unique_ptr<Bucket> createLineBucket(const VectorTileLayer& layer, const StyleBucket &bucket_desc);
std::unique_ptr<Bucket> createSymbolBucket(const VectorTileLayer& layer, const StyleBucket &bucket_desc);
template <class Bucket> void addBucketGeometries(Bucket& bucket, const VectorTileLayer& layer, const FilterExpression &filter);

27
src/mbgl/renderer/fill_bucket.cpp
View File

@@ -31,18 +31,22 @@ void FillBucket::free(void *, void *ptr) {
::free(ptr);
}
FillBucket::FillBucket(FillVertexBuffer &vertexBuffer_,
FillBucket::FillBucket(std::unique_ptr<const StyleBucketFill> layout_,
FillVertexBuffer &vertexBuffer_,
TriangleElementsBuffer &triangleElementsBuffer_,
LineElementsBuffer &lineElementsBuffer_,
const StyleBucketFill &properties_)
: properties(properties_),
allocator(new TESSalloc{&alloc, &realloc, &free, nullptr, // userData
64, // meshEdgeBucketSize
64, // meshVertexBucketSize
32, // meshFaceBucketSize
64, // dictNodeBucketSize
8, // regionBucketSize
128, // extraVertices allocated for the priority queue.
LineElementsBuffer &lineElementsBuffer_)
: layout(std::move(layout_)),
allocator(new TESSalloc{
&alloc,
&realloc,
&free,
nullptr, // userData
64, // meshEdgeBucketSize
64, // meshVertexBucketSize
32, // meshFaceBucketSize
64, // dictNodeBucketSize
8, // regionBucketSize
128, // extraVertices allocated for the priority queue.
}),
tesselator(tessNewTess(allocator)),
vertexBuffer(vertexBuffer_),
@@ -52,6 +56,7 @@ FillBucket::FillBucket(FillVertexBuffer &vertexBuffer_,
triangle_elements_start(triangleElementsBuffer_.index()),
line_elements_start(lineElementsBuffer.index()) {
assert(tesselator);
assert(layout);
}
FillBucket::~FillBucket() {

10
src/mbgl/renderer/fill_bucket.hpp
View File

@@ -38,10 +38,10 @@ class FillBucket : public Bucket {
typedef ElementGroup<1> line_group_type;
public:
FillBucket(FillVertexBuffer& vertexBuffer,
TriangleElementsBuffer& triangleElementsBuffer,
LineElementsBuffer& lineElementsBuffer,
const StyleBucketFill& properties);
FillBucket(std::unique_ptr<const StyleBucketFill> layout,
FillVertexBuffer &vertexBuffer,
TriangleElementsBuffer &triangleElementsBuffer,
LineElementsBuffer &lineElementsBuffer);
~FillBucket();
virtual void render(Painter& painter, util::ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
@@ -55,7 +55,7 @@ public:
void drawVertices(OutlineShader& shader);
public:
const StyleBucketFill &properties;
const std::unique_ptr<const StyleBucketFill> layout;
private:
TESSalloc *allocator;

16
src/mbgl/renderer/line_bucket.cpp
View File

@@ -18,18 +18,18 @@ struct geometry_too_long_exception : std::exception {};
using namespace mbgl;
LineBucket::LineBucket(LineVertexBuffer& vertexBuffer_,
TriangleElementsBuffer& triangleElementsBuffer_,
PointElementsBuffer& pointElementsBuffer_,
const StyleBucketLine& properties_)
: properties(properties_),
LineBucket::LineBucket(std::unique_ptr<const StyleBucketLine> layout_,
LineVertexBuffer &vertexBuffer_,
TriangleElementsBuffer &triangleElementsBuffer_,
PointElementsBuffer &pointElementsBuffer_)
: layout(std::move(layout_)),
vertexBuffer(vertexBuffer_),
triangleElementsBuffer(triangleElementsBuffer_),
pointElementsBuffer(pointElementsBuffer_),
vertex_start(vertexBuffer_.index()),
triangle_elements_start(triangleElementsBuffer_.index()),
point_elements_start(pointElementsBuffer_.index())
{
point_elements_start(pointElementsBuffer_.index()) {
assert(layout);
}
void LineBucket::addGeometry(pbf& geom) {
@@ -61,6 +61,8 @@ struct TriangleElement {
typedef uint16_t PointElement;
void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
assert(layout);
auto &properties = *layout;
// TODO: use roundLimit
// const float roundLimit = geometry.round_limit;

10
src/mbgl/renderer/line_bucket.hpp
View File

@@ -25,10 +25,10 @@ class LineBucket : public Bucket {
typedef ElementGroup<1> point_group_type;
public:
LineBucket(LineVertexBuffer& vertexBuffer,
TriangleElementsBuffer& triangleElementsBuffer,
PointElementsBuffer& pointElementsBuffer,
const StyleBucketLine& properties);
LineBucket(std::unique_ptr<const StyleBucketLine> layout,
LineVertexBuffer &vertexBuffer,
TriangleElementsBuffer &triangleElementsBuffer,
PointElementsBuffer &pointElementsBuffer);
virtual void render(Painter& painter, util::ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
virtual bool hasData() const;
@@ -44,7 +44,7 @@ public:
void drawPoints(LinejoinShader& shader);
public:
const StyleBucketLine &properties;
const std::unique_ptr<const StyleBucketLine> layout;
private:
LineVertexBuffer& vertexBuffer;

7
src/mbgl/renderer/painter_line.cpp
View File

@@ -14,7 +14,8 @@ void Painter::renderLine(LineBucket& bucket, util::ptr<StyleLayer> layer_desc, c
if (pass == RenderPass::Opaque) return;
if (!bucket.hasData()) return;
const LineProperties &properties = layer_desc->getProperties<LineProperties>();
const auto &properties = layer_desc->getProperties<LineProperties>();
const auto &layout = *bucket.layout;
// the distance over which the line edge fades out.
// Retina devices need a smaller distance to avoid aliasing.
@@ -81,8 +82,8 @@ void Painter::renderLine(LineBucket& bucket, util::ptr<StyleLayer> layer_desc, c
linesdfShader->u_blur = blur;
linesdfShader->u_color = color;
LinePatternPos posA = lineAtlas.getDashPosition(properties.dash_array.from, bucket.properties.cap == CapType::Round);
LinePatternPos posB = lineAtlas.getDashPosition(properties.dash_array.to, bucket.properties.cap == CapType::Round);
LinePatternPos posA = lineAtlas.getDashPosition(properties.dash_array.from, layout.cap == CapType::Round);
LinePatternPos posB = lineAtlas.getDashPosition(properties.dash_array.to, layout.cap == CapType::Round);
lineAtlas.bind();
float patternratio = std::pow(2.0, std::floor(std::log2(state.getScale())) - id.z) / 8.0;

19
src/mbgl/renderer/painter_symbol.cpp
View File

@@ -117,7 +117,8 @@ void Painter::renderSymbol(SymbolBucket &bucket, util::ptr<StyleLayer> layer_des
return;
}
const SymbolProperties &properties = layer_desc->getProperties<SymbolProperties>();
const auto &properties = layer_desc->getProperties<SymbolProperties>();
const auto &layout = *bucket.layout;
MBGL_CHECK_ERROR(glDisable(GL_STENCIL_TEST));
@@ -125,21 +126,21 @@ void Painter::renderSymbol(SymbolBucket &bucket, util::ptr<StyleLayer> layer_des
bool sdf = bucket.sdfIcons;
const float angleOffset =
bucket.properties.icon.rotation_alignment == RotationAlignmentType::Map
layout.icon.rotation_alignment == RotationAlignmentType::Map
? state.getAngle()
: 0;
// If layerStyle.size > bucket.info.fontSize then labels may collide
const float fontSize = properties.icon.size != 0 ? properties.icon.size : bucket.properties.icon.max_size;
const float fontSize = properties.icon.size != 0 ? properties.icon.size : layout.icon.max_size;
const float fontScale = fontSize / 1.0f;
spriteAtlas.bind(state.isChanging() || bucket.properties.placement == PlacementType::Line || angleOffset != 0 || fontScale != 1 || sdf);
spriteAtlas.bind(state.isChanging() || layout.placement == PlacementType::Line || angleOffset != 0 || fontScale != 1 || sdf);
if (sdf) {
renderSDF(bucket,
id,
matrix,
bucket.properties.icon,
layout.icon,
properties.icon,
1.0f,
{{ float(spriteAtlas.getWidth()) / 4.0f, float(spriteAtlas.getHeight()) / 4.0f }},
@@ -166,12 +167,12 @@ void Painter::renderSymbol(SymbolBucket &bucket, util::ptr<StyleLayer> layer_des
const float angle = std::round(state.getAngle() / M_PI * 128);
// adjust min/max zooms for variable font sies
float zoomAdjust = std::log(fontSize / bucket.properties.icon.max_size) / std::log(2);
float zoomAdjust = std::log(fontSize / layout.icon.max_size) / std::log(2);
iconShader->u_angle = (int32_t)(angle + 256) % 256;
bool flip = (bucket.properties.icon.rotation_alignment == RotationAlignmentType::Map)
&& bucket.properties.icon.keep_upright;
bool flip = (layout.icon.rotation_alignment == RotationAlignmentType::Map)
&& layout.icon.keep_upright;
iconShader->u_flip = flip ? 1 : 0;
iconShader->u_zoom = (state.getNormalizedZoom() - zoomAdjust) * 10; // current zoom level
@@ -192,7 +193,7 @@ void Painter::renderSymbol(SymbolBucket &bucket, util::ptr<StyleLayer> layer_des
renderSDF(bucket,
id,
matrix,
bucket.properties.text,
layout.text,
properties.text,
24.0f,
{{ float(glyphAtlas.width) / 4, float(glyphAtlas.height) / 4 }},

10
src/mbgl/renderer/symbol_bucket.cpp
View File

@@ -20,8 +20,10 @@
namespace mbgl {
SymbolBucket::SymbolBucket(const StyleBucketSymbol &properties_, Collision &collision_)
: properties(properties_), collision(collision_) {}
SymbolBucket::SymbolBucket(std::unique_ptr<const StyleBucketSymbol> layout_, Collision &collision_)
: layout(std::move(layout_)), collision(collision_) {
assert(layout);
}
void SymbolBucket::render(Painter &painter, util::ptr<StyleLayer> layer_desc,
const Tile::ID &id, const mat4 &matrix) {
@@ -44,6 +46,7 @@ std::vector<SymbolFeature> SymbolBucket::processFeatures(const VectorTileLayer &
const FilterExpression &filter,
GlyphStore &glyphStore,
const Sprite &sprite) {
auto &properties = *layout;
const bool has_text = properties.text.field.size();
const bool has_icon = properties.icon.image.size();
@@ -120,7 +123,7 @@ std::vector<SymbolFeature> SymbolBucket::processFeatures(const VectorTileLayer &
void SymbolBucket::addFeatures(const VectorTileLayer &layer, const FilterExpression &filter,
const Tile::ID &id, SpriteAtlas &spriteAtlas, Sprite &sprite,
GlyphAtlas & glyphAtlas, GlyphStore &glyphStore) {
auto &properties = *layout;
const std::vector<SymbolFeature> features = processFeatures(layer, filter, glyphStore, sprite);
float horizontalAlign = 0.5;
@@ -220,6 +223,7 @@ const PlacementRange fullRange{{2 * M_PI, 0}};
void SymbolBucket::addFeature(const std::vector<Coordinate> &line, const Shaping &shaping,
const GlyphPositions &face, const Rect<uint16_t> &image) {
assert(line.size());
auto &properties = *layout;
const float minScale = 0.5f;
const float glyphSize = 24.0f;

4
src/mbgl/renderer/symbol_bucket.hpp
View File

@@ -54,7 +54,7 @@ class SymbolBucket : public Bucket {
typedef ElementGroup<2> IconElementGroup;
public:
SymbolBucket(const StyleBucketSymbol &properties, Collision &collision);
SymbolBucket(std::unique_ptr<const StyleBucketSymbol> layout, Collision &collision);
virtual void render(Painter &painter, util::ptr<StyleLayer> layer_desc, const Tile::ID &id, const mat4 &matrix);
virtual bool hasData() const;
@@ -89,7 +89,7 @@ private:
const FontStack &fontStack, GlyphAtlas &glyphAtlas, GlyphPositions &face);
public:
const StyleBucketSymbol &properties;
const std::unique_ptr<const StyleBucketSymbol> layout;
bool sdfIcons = false;
private:

7
src/mbgl/style/style_bucket.cpp
View File

@@ -9,13 +9,6 @@ template<> const StyleBucketRaster &defaultLayoutProperties() { static StyleBuck
template<> const StyleBucketBackground &defaultLayoutProperties() { static StyleBucketBackground p; return p; }
StyleBucket::StyleBucket(StyleLayerType type_) : type(type_) {
switch (type) {
case StyleLayerType::Fill: render.set<StyleBucketFill>(); break;
case StyleLayerType::Line: render.set<StyleBucketLine>(); break;
case StyleLayerType::Symbol: render.set<StyleBucketSymbol>(); break;
case StyleLayerType::Raster: render.set<StyleBucketRaster>(); break;
default: break;
}
}
}

5
src/mbgl/style/style_bucket.hpp
View File

@@ -104,10 +104,6 @@ class StyleBucketBackground {
public:
};
typedef mapbox::util::variant<StyleBucketFill, StyleBucketLine, StyleBucketSymbol,
StyleBucketRaster, StyleBucketBackground, std::false_type> StyleBucketRender;
class StyleBucket : public util::noncopyable {
public:
typedef util::ptr<StyleBucket> Ptr;
@@ -119,7 +115,6 @@ public:
std::string source_layer;
FilterExpression filter;
ClassProperties layout;
StyleBucketRender render = std::false_type();
float min_zoom = -std::numeric_limits<float>::infinity();
float max_zoom = std::numeric_limits<float>::infinity();
VisibilityType visibility = VisibilityType::Visible;

2
src/mbgl/style/style_layer.hpp
View File

@@ -67,7 +67,7 @@ public:
// Bucket information, telling the renderer how to generate the geometries
// for this layer (feature property filters, tessellation instructions, ...).
util::ptr<StyleBucket> bucket;
util::ptr<const StyleBucket> bucket;
// Contains all style classes that can be applied to this layer.
const std::map<ClassID, ClassProperties> styles;

18
src/mbgl/style/style_parser.cpp
View File

@@ -894,10 +894,10 @@ void StyleParser::parseReference(JSVal value, util::ptr<StyleLayer> &layer) {
#pragma mark - Parse Bucket
void StyleParser::parseBucket(JSVal value, util::ptr<StyleLayer> &layer) {
layer->bucket = std::make_shared<StyleBucket>(layer->type);
util::ptr<StyleBucket> bucket = std::make_shared<StyleBucket>(layer->type);
// We name the buckets according to the layer that defined it.
layer->bucket->name = layer->id;
bucket->name = layer->id;
if (value.HasMember("source")) {
JSVal value_source = replaceConstant(value["source"]);
@@ -905,7 +905,7 @@ void StyleParser::parseBucket(JSVal value, util::ptr<StyleLayer> &layer) {
const std::string source_name = { value_source.GetString(), value_source.GetStringLength() };
auto source_it = sources.find(source_name);
if (source_it != sources.end()) {
layer->bucket->style_source = source_it->second;
bucket->style_source = source_it->second;
} else {
Log::Warning(Event::ParseStyle, "can't find source '%s' required for layer '%s'", source_name.c_str(), layer->id.c_str());
}
@@ -917,7 +917,7 @@ void StyleParser::parseBucket(JSVal value, util::ptr<StyleLayer> &layer) {
if (value.HasMember("source-layer")) {
JSVal value_source_layer = replaceConstant(value["source-layer"]);
if (value_source_layer.IsString()) {
layer->bucket->source_layer = { value_source_layer.GetString(), value_source_layer.GetStringLength() };
bucket->source_layer = { value_source_layer.GetString(), value_source_layer.GetStringLength() };
} else {
Log::Warning(Event::ParseStyle, "source-layer of layer '%s' must be a string", layer->id.c_str());
}
@@ -925,18 +925,18 @@ void StyleParser::parseBucket(JSVal value, util::ptr<StyleLayer> &layer) {
if (value.HasMember("filter")) {
JSVal value_filter = replaceConstant(value["filter"]);
layer->bucket->filter = parseFilterExpression(value_filter);
bucket->filter = parseFilterExpression(value_filter);
}
if (value.HasMember("layout")) {
JSVal value_render = replaceConstant(value["layout"]);
parseLayout(value_render, layer->bucket);
parseLayout(value_render, bucket);
}
if (value.HasMember("minzoom")) {
JSVal min_zoom = value["minzoom"];
if (min_zoom.IsNumber()) {
layer->bucket->min_zoom = min_zoom.GetDouble();
bucket->min_zoom = min_zoom.GetDouble();
} else {
Log::Warning(Event::ParseStyle, "minzoom of layer %s must be numeric", layer->id.c_str());
}
@@ -945,11 +945,13 @@ void StyleParser::parseBucket(JSVal value, util::ptr<StyleLayer> &layer) {
if (value.HasMember("maxzoom")) {
JSVal max_zoom = value["maxzoom"];
if (max_zoom.IsNumber()) {
layer->bucket->min_zoom = max_zoom.GetDouble();
bucket->min_zoom = max_zoom.GetDouble();
} else {
Log::Warning(Event::ParseStyle, "maxzoom of layer %s must be numeric", layer->id.c_str());
}
}
layer->bucket = bucket;
}
void StyleParser::parseSprite(JSVal value) {