Merge branch 'release-boba' into master
# Conflicts: # circle.yml # include/mbgl/style/expression/let.hpp # platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/geometry/LatLngBounds.java # platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapGestureDetector.java # platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapKeyListener.java # platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapView.java # platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/MapboxMap.java # platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/Projection.java # platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/maps/Transform.java # platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/geometry/LatLngBoundsTest.java # platform/android/MapboxGLAndroidSDKTestApp/src/main/AndroidManifest.xml # platform/android/gradle/dependencies.gradle # platform/android/src/example_custom_layer.cpp # platform/android/src/geojson/point.cpp # platform/darwin/src/NSPredicate+MGLAdditions.mm # platform/darwin/test/MGLExpressionTests.mm # platform/ios/Mapbox-iOS-SDK-nightly-dynamic.podspec # platform/ios/Mapbox-iOS-SDK-symbols.podspec # platform/ios/Mapbox-iOS-SDK.podspec # platform/ios/app/MBXViewController.m # src/mbgl/renderer/layers/render_custom_layer.cpp # src/mbgl/style/conversion/filter.cpp # src/mbgl/style/expression/interpolate.cpp # src/mbgl/style/expression/value.cpp # test/style/filter.test.cpp
This commit is contained in:
@@ -17,8 +17,9 @@
|
||||
|
||||
namespace mbgl {
|
||||
|
||||
FeatureIndex::FeatureIndex()
|
||||
: grid(util::EXTENT, util::EXTENT, util::EXTENT / 16) { // 16x16 grid -> 32px cell
|
||||
FeatureIndex::FeatureIndex(std::unique_ptr<const GeometryTileData> tileData_)
|
||||
: grid(util::EXTENT, util::EXTENT, util::EXTENT / 16) // 16x16 grid -> 32px cell
|
||||
, tileData(std::move(tileData_)) {
|
||||
}
|
||||
|
||||
void FeatureIndex::insert(const GeometryCollection& geometries,
|
||||
@@ -47,12 +48,15 @@ void FeatureIndex::query(
|
||||
const double tileSize,
|
||||
const double scale,
|
||||
const RenderedQueryOptions& queryOptions,
|
||||
const GeometryTileData& geometryTileData,
|
||||
const UnwrappedTileID& tileID,
|
||||
const std::string& sourceID,
|
||||
const std::vector<const RenderLayer*>& layers,
|
||||
const CollisionIndex& collisionIndex,
|
||||
const float additionalQueryRadius) const {
|
||||
|
||||
if (!tileData) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Determine query radius
|
||||
const float pixelsToTileUnits = util::EXTENT / tileSize / scale;
|
||||
@@ -72,13 +76,13 @@ void FeatureIndex::query(
|
||||
if (indexedFeature.sortIndex == previousSortIndex) continue;
|
||||
previousSortIndex = indexedFeature.sortIndex;
|
||||
|
||||
addFeature(result, indexedFeature, queryGeometry, queryOptions, geometryTileData, tileID.canonical, layers, bearing, pixelsToTileUnits);
|
||||
addFeature(result, indexedFeature, queryGeometry, queryOptions, tileID.canonical, layers, bearing, pixelsToTileUnits);
|
||||
}
|
||||
|
||||
std::vector<IndexedSubfeature> symbolFeatures = collisionIndex.queryRenderedSymbols(queryGeometry, tileID, sourceID);
|
||||
std::sort(symbolFeatures.begin(), symbolFeatures.end(), topDownSymbols);
|
||||
for (const auto& symbolFeature : symbolFeatures) {
|
||||
addFeature(result, symbolFeature, queryGeometry, queryOptions, geometryTileData, tileID.canonical, layers, bearing, pixelsToTileUnits);
|
||||
addFeature(result, symbolFeature, queryGeometry, queryOptions, tileID.canonical, layers, bearing, pixelsToTileUnits);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -87,7 +91,6 @@ void FeatureIndex::addFeature(
|
||||
const IndexedSubfeature& indexedFeature,
|
||||
const GeometryCoordinates& queryGeometry,
|
||||
const RenderedQueryOptions& options,
|
||||
const GeometryTileData& geometryTileData,
|
||||
const CanonicalTileID& tileID,
|
||||
const std::vector<const RenderLayer*>& layers,
|
||||
const float bearing,
|
||||
@@ -113,7 +116,7 @@ void FeatureIndex::addFeature(
|
||||
}
|
||||
|
||||
if (!geometryTileFeature) {
|
||||
sourceLayer = geometryTileData.getLayer(indexedFeature.sourceLayerName);
|
||||
sourceLayer = tileData->getLayer(indexedFeature.sourceLayerName);
|
||||
assert(sourceLayer);
|
||||
|
||||
geometryTileFeature = sourceLayer->getFeature(indexedFeature.index);
|
||||
|
||||
@@ -50,8 +50,10 @@ public:
|
||||
|
||||
class FeatureIndex {
|
||||
public:
|
||||
FeatureIndex();
|
||||
FeatureIndex(std::unique_ptr<const GeometryTileData> tileData_);
|
||||
|
||||
const GeometryTileData* getData() { return tileData.get(); }
|
||||
|
||||
void insert(const GeometryCollection&, std::size_t index, const std::string& sourceLayerName, const std::string& bucketName);
|
||||
|
||||
void query(
|
||||
@@ -61,7 +63,6 @@ public:
|
||||
const double tileSize,
|
||||
const double scale,
|
||||
const RenderedQueryOptions& options,
|
||||
const GeometryTileData&,
|
||||
const UnwrappedTileID&,
|
||||
const std::string&,
|
||||
const std::vector<const RenderLayer*>&,
|
||||
@@ -83,7 +84,6 @@ private:
|
||||
const IndexedSubfeature&,
|
||||
const GeometryCoordinates& queryGeometry,
|
||||
const RenderedQueryOptions& options,
|
||||
const GeometryTileData&,
|
||||
const CanonicalTileID&,
|
||||
const std::vector<const RenderLayer*>&,
|
||||
const float bearing,
|
||||
@@ -93,5 +93,6 @@ private:
|
||||
unsigned int sortIndex = 0;
|
||||
|
||||
std::unordered_map<std::string, std::vector<std::string>> bucketLayerIDs;
|
||||
std::unique_ptr<const GeometryTileData> tileData;
|
||||
};
|
||||
} // namespace mbgl
|
||||
|
||||
@@ -27,7 +27,7 @@ SymbolInstance::SymbolInstance(Anchor& anchor_,
|
||||
anchor(anchor_),
|
||||
line(line_),
|
||||
index(index_),
|
||||
hasText(shapedTextOrientations.first || shapedTextOrientations.second),
|
||||
hasText(false),
|
||||
hasIcon(shapedIcon),
|
||||
|
||||
// Create the collision features that will be used to check whether this symbol instance can be placed
|
||||
@@ -48,6 +48,8 @@ SymbolInstance::SymbolInstance(Anchor& anchor_,
|
||||
if (shapedTextOrientations.second) {
|
||||
verticalGlyphQuads = getGlyphQuads(shapedTextOrientations.second, layout, textPlacement, positions);
|
||||
}
|
||||
// 'hasText' depends on finding at least one glyph in the shaping that's also in the GlyphPositionMap
|
||||
hasText = horizontalGlyphQuads.size() > 0 || verticalGlyphQuads.size() > 0;
|
||||
|
||||
if (shapedTextOrientations.first && shapedTextOrientations.second) {
|
||||
writingModes = WritingModeType::Horizontal | WritingModeType::Vertical;
|
||||
|
||||
@@ -126,7 +126,7 @@ SymbolLayout::SymbolLayout(const BucketParameters& parameters,
|
||||
|
||||
if (hasText) {
|
||||
std::string u8string = layout.evaluate<TextField>(zoom, ft);
|
||||
if (layout.get<TextField>().isConstant()) {
|
||||
if (layout.get<TextField>().isConstant() && !leader.layout.get<TextField>().isExpression()) {
|
||||
u8string = util::replaceTokens(u8string, getValue);
|
||||
}
|
||||
|
||||
@@ -159,7 +159,7 @@ SymbolLayout::SymbolLayout(const BucketParameters& parameters,
|
||||
|
||||
if (hasIcon) {
|
||||
std::string icon = layout.evaluate<IconImage>(zoom, ft);
|
||||
if (layout.get<IconImage>().isConstant()) {
|
||||
if (layout.get<IconImage>().isConstant() && !leader.layout.get<IconImage>().isExpression()) {
|
||||
icon = util::replaceTokens(icon, getValue);
|
||||
}
|
||||
ft.icon = icon;
|
||||
|
||||
@@ -240,7 +240,11 @@ namespace mbgl {
|
||||
const PlacedSymbol& symbol,
|
||||
const mat4& labelPlaneMatrix,
|
||||
const bool returnTileDistance) {
|
||||
|
||||
if (symbol.glyphOffsets.empty()) {
|
||||
assert(false);
|
||||
return optional<std::pair<PlacedGlyph, PlacedGlyph>>();
|
||||
}
|
||||
|
||||
const float firstGlyphOffset = symbol.glyphOffsets.front();
|
||||
const float lastGlyphOffset = symbol.glyphOffsets.back();;
|
||||
|
||||
|
||||
@@ -446,7 +446,6 @@ CameraOptions Map::cameraForGeometry(const Geometry<double>& geometry, const Edg
|
||||
latLngs.push_back({ pt.y, pt.x });
|
||||
});
|
||||
return cameraForLatLngs(latLngs, padding, bearing);
|
||||
|
||||
}
|
||||
|
||||
LatLngBounds Map::latLngBoundsForCamera(const CameraOptions& camera) const {
|
||||
|
||||
@@ -61,8 +61,8 @@ struct SymbolLayoutAttributes : gl::Attributes<
|
||||
{{
|
||||
static_cast<int16_t>(labelAnchor.x),
|
||||
static_cast<int16_t>(labelAnchor.y),
|
||||
static_cast<int16_t>(::round(o.x * 64)), // use 1/64 pixels for placement
|
||||
static_cast<int16_t>(::round((o.y + glyphOffsetY) * 64))
|
||||
static_cast<int16_t>(::round(o.x * 32)), // use 1/32 pixels for placement
|
||||
static_cast<int16_t>(::round((o.y + glyphOffsetY) * 32))
|
||||
}},
|
||||
{{
|
||||
tx,
|
||||
|
||||
@@ -6,23 +6,24 @@
|
||||
#include <mbgl/style/layers/custom_layer_impl.hpp>
|
||||
#include <mbgl/map/transform_state.hpp>
|
||||
#include <mbgl/gl/gl.hpp>
|
||||
#include <mbgl/util/mat4.hpp>
|
||||
|
||||
namespace mbgl {
|
||||
|
||||
using namespace style;
|
||||
|
||||
RenderCustomLayer::RenderCustomLayer(Immutable<style::CustomLayer::Impl> _impl)
|
||||
: RenderLayer(LayerType::Custom, _impl) {
|
||||
: RenderLayer(LayerType::Custom, _impl), host(_impl->host) {
|
||||
assert(BackendScope::exists());
|
||||
host->initialize();
|
||||
}
|
||||
|
||||
RenderCustomLayer::~RenderCustomLayer() {
|
||||
assert(BackendScope::exists());
|
||||
if (initialized) {
|
||||
if (contextDestroyed && impl().contextLostFn ) {
|
||||
impl().contextLostFn(impl().context);
|
||||
} else if (!contextDestroyed && impl().deinitializeFn) {
|
||||
impl().deinitializeFn(impl().context);
|
||||
}
|
||||
if (contextDestroyed) {
|
||||
host->contextLost();
|
||||
} else {
|
||||
host->deinitialize();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -44,15 +45,13 @@ std::unique_ptr<Bucket> RenderCustomLayer::createBucket(const BucketParameters&,
|
||||
}
|
||||
|
||||
void RenderCustomLayer::render(PaintParameters& paintParameters, RenderSource*) {
|
||||
if (context != impl().context || !initialized) {
|
||||
if (host != impl().host) {
|
||||
//If the context changed, deinitialize the previous one before initializing the new one.
|
||||
if (context && !contextDestroyed && impl().deinitializeFn) {
|
||||
MBGL_CHECK_ERROR(impl().deinitializeFn(context));
|
||||
if (host && !contextDestroyed) {
|
||||
MBGL_CHECK_ERROR(host->deinitialize());
|
||||
}
|
||||
context = impl().context;
|
||||
assert(impl().initializeFn);
|
||||
MBGL_CHECK_ERROR(impl().initializeFn(impl().context));
|
||||
initialized = true;
|
||||
host = impl().host;
|
||||
MBGL_CHECK_ERROR(host->initialize());
|
||||
}
|
||||
|
||||
gl::Context& glContext = paintParameters.context;
|
||||
@@ -74,9 +73,11 @@ void RenderCustomLayer::render(PaintParameters& paintParameters, RenderSource*)
|
||||
parameters.bearing = -state.getAngle() * util::RAD2DEG;
|
||||
parameters.pitch = state.getPitch();
|
||||
parameters.fieldOfView = state.getFieldOfView();
|
||||
mat4 projMatrix;
|
||||
state.getProjMatrix(projMatrix);
|
||||
parameters.projectionMatrix = projMatrix;
|
||||
|
||||
assert(impl().renderFn);
|
||||
MBGL_CHECK_ERROR(impl().renderFn(context, parameters));
|
||||
MBGL_CHECK_ERROR(host->render(parameters));
|
||||
|
||||
// Reset the view back to our original one, just in case the CustomLayer changed
|
||||
// the viewport or Framebuffer.
|
||||
|
||||
@@ -24,9 +24,8 @@ public:
|
||||
};
|
||||
|
||||
private:
|
||||
bool initialized = false;
|
||||
bool contextDestroyed = false;
|
||||
void * context = nullptr;
|
||||
std::shared_ptr<style::CustomLayerHost> host;
|
||||
};
|
||||
|
||||
template <>
|
||||
|
||||
@@ -22,7 +22,10 @@ varying float v_notUsed;
|
||||
void main() {
|
||||
vec4 projectedPoint = u_matrix * vec4(a_anchor_pos, 0, 1);
|
||||
highp float camera_to_anchor_distance = projectedPoint.w;
|
||||
highp float collision_perspective_ratio = 0.5 + 0.5 * (u_camera_to_center_distance / camera_to_anchor_distance);
|
||||
highp float collision_perspective_ratio = clamp(
|
||||
0.5 + 0.5 * (u_camera_to_center_distance / camera_to_anchor_distance),
|
||||
0.0, // Prevents oversized near-field boxes in pitched/overzoomed tiles
|
||||
4.0);
|
||||
|
||||
gl_Position = u_matrix * vec4(a_pos, 0.0, 1.0);
|
||||
gl_Position.xy += a_extrude * u_extrude_scale * gl_Position.w * collision_perspective_ratio;
|
||||
|
||||
@@ -215,8 +215,14 @@ void main() {
|
||||
|
||||
float x_a = mod(v_linesofar / u_pattern_size_a.x, 1.0);
|
||||
float x_b = mod(v_linesofar / u_pattern_size_b.x, 1.0);
|
||||
float y_a = 0.5 + (v_normal.y * v_width2.s / u_pattern_size_a.y);
|
||||
float y_b = 0.5 + (v_normal.y * v_width2.s / u_pattern_size_b.y);
|
||||
|
||||
// v_normal.y is 0 at the midpoint of the line, -1 at the lower edge, 1 at the upper edge
|
||||
// we clamp the line width outset to be between 0 and half the pattern height plus padding (2.0)
|
||||
// to ensure we don't sample outside the designated symbol on the sprite sheet.
|
||||
// 0.5 is added to shift the component to be bounded between 0 and 1 for interpolation of
|
||||
// the texture coordinate
|
||||
float y_a = 0.5 + (v_normal.y * clamp(v_width2.s, 0.0, (u_pattern_size_a.y + 2.0) / 2.0) / u_pattern_size_a.y);
|
||||
float y_b = 0.5 + (v_normal.y * clamp(v_width2.s, 0.0, (u_pattern_size_b.y + 2.0) / 2.0) / u_pattern_size_b.y);
|
||||
vec2 pos_a = mix(u_pattern_tl_a / u_texsize, u_pattern_br_a / u_texsize, vec2(x_a, y_a));
|
||||
vec2 pos_b = mix(u_pattern_tl_b / u_texsize, u_pattern_br_b / u_texsize, vec2(x_b, y_b));
|
||||
|
||||
|
||||
@@ -80,7 +80,10 @@ void main() {
|
||||
highp float distance_ratio = u_pitch_with_map ?
|
||||
camera_to_anchor_distance / u_camera_to_center_distance :
|
||||
u_camera_to_center_distance / camera_to_anchor_distance;
|
||||
highp float perspective_ratio = 0.5 + 0.5 * distance_ratio;
|
||||
highp float perspective_ratio = clamp(
|
||||
0.5 + 0.5 * distance_ratio,
|
||||
0.0, // Prevents oversized near-field symbols in pitched/overzoomed tiles
|
||||
4.0);
|
||||
|
||||
size *= perspective_ratio;
|
||||
|
||||
@@ -102,7 +105,7 @@ void main() {
|
||||
mat2 rotation_matrix = mat2(angle_cos, -1.0 * angle_sin, angle_sin, angle_cos);
|
||||
|
||||
vec4 projected_pos = u_label_plane_matrix * vec4(a_projected_pos.xy, 0.0, 1.0);
|
||||
gl_Position = u_gl_coord_matrix * vec4(projected_pos.xy / projected_pos.w + rotation_matrix * (a_offset / 64.0 * fontScale), 0.0, 1.0);
|
||||
gl_Position = u_gl_coord_matrix * vec4(projected_pos.xy / projected_pos.w + rotation_matrix * (a_offset / 32.0 * fontScale), 0.0, 1.0);
|
||||
|
||||
v_tex = a_tex / u_texsize;
|
||||
vec2 fade_opacity = unpack_opacity(a_fade_opacity);
|
||||
|
||||
@@ -156,7 +156,10 @@ void main() {
|
||||
highp float distance_ratio = u_pitch_with_map ?
|
||||
camera_to_anchor_distance / u_camera_to_center_distance :
|
||||
u_camera_to_center_distance / camera_to_anchor_distance;
|
||||
highp float perspective_ratio = 0.5 + 0.5 * distance_ratio;
|
||||
highp float perspective_ratio = clamp(
|
||||
0.5 + 0.5 * distance_ratio,
|
||||
0.0, // Prevents oversized near-field symbols in pitched/overzoomed tiles
|
||||
4.0);
|
||||
|
||||
size *= perspective_ratio;
|
||||
|
||||
@@ -180,7 +183,7 @@ void main() {
|
||||
mat2 rotation_matrix = mat2(angle_cos, -1.0 * angle_sin, angle_sin, angle_cos);
|
||||
|
||||
vec4 projected_pos = u_label_plane_matrix * vec4(a_projected_pos.xy, 0.0, 1.0);
|
||||
gl_Position = u_gl_coord_matrix * vec4(projected_pos.xy / projected_pos.w + rotation_matrix * (a_offset / 64.0 * fontScale), 0.0, 1.0);
|
||||
gl_Position = u_gl_coord_matrix * vec4(projected_pos.xy / projected_pos.w + rotation_matrix * (a_offset / 32.0 * fontScale), 0.0, 1.0);
|
||||
float gamma_scale = gl_Position.w;
|
||||
|
||||
vec2 tex = a_tex / u_texsize;
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#include <mbgl/util/geometry.hpp>
|
||||
#include <mbgl/style/expression/expression.hpp>
|
||||
#include <mbgl/style/expression/type.hpp>
|
||||
#include <mbgl/style/conversion/expression.hpp>
|
||||
#include <mbgl/style/expression/parsing_context.hpp>
|
||||
|
||||
namespace mbgl {
|
||||
namespace style {
|
||||
@@ -236,10 +236,13 @@ optional<Filter> convertCompoundFilter(const Convertible& value, Error& error) {
|
||||
}
|
||||
|
||||
optional<Filter> convertExpressionFilter(const Convertible& value, Error& error) {
|
||||
optional<std::unique_ptr<Expression>> expression = convert<std::unique_ptr<Expression>>(value, error, expression::type::Boolean);
|
||||
expression::ParsingContext ctx(expression::type::Boolean);
|
||||
expression::ParseResult expression = ctx.parseExpression(value);
|
||||
if (!expression) {
|
||||
error = { ctx.getCombinedErrors() };
|
||||
return {};
|
||||
}
|
||||
|
||||
return { ExpressionFilter { std::move(*expression) } };
|
||||
}
|
||||
|
||||
|
||||
@@ -290,138 +290,19 @@ void stringify(Writer& writer, const Undefined&) {
|
||||
writer.Null();
|
||||
}
|
||||
|
||||
template <class Writer>
|
||||
void stringify(Writer& writer, const CategoricalValue& v) {
|
||||
CategoricalValue::visit(v, [&] (const auto& v_) { stringify(writer, v_); });
|
||||
}
|
||||
|
||||
template <class Writer>
|
||||
class StringifyStops {
|
||||
public:
|
||||
Writer& writer;
|
||||
|
||||
template <class T>
|
||||
void operator()(const ExponentialStops<T>& f) {
|
||||
writer.Key("type");
|
||||
writer.String("exponential");
|
||||
writer.Key("base");
|
||||
writer.Double(f.base);
|
||||
writer.Key("stops");
|
||||
stringifyStops(f.stops);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void operator()(const IntervalStops<T>& f) {
|
||||
writer.Key("type");
|
||||
writer.String("interval");
|
||||
writer.Key("stops");
|
||||
stringifyStops(f.stops);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void operator()(const CategoricalStops<T>& f) {
|
||||
writer.Key("type");
|
||||
writer.String("categorical");
|
||||
writer.Key("stops");
|
||||
stringifyStops(f.stops);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void operator()(const IdentityStops<T>&) {
|
||||
writer.Key("type");
|
||||
writer.String("identity");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void operator()(const CompositeExponentialStops<T>& f) {
|
||||
writer.Key("type");
|
||||
writer.String("exponential");
|
||||
writer.Key("base");
|
||||
writer.Double(f.base);
|
||||
writer.Key("stops");
|
||||
stringifyCompositeStops(f.stops);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void operator()(const CompositeIntervalStops<T>& f) {
|
||||
writer.Key("type");
|
||||
writer.String("interval");
|
||||
writer.Key("stops");
|
||||
stringifyCompositeStops(f.stops);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void operator()(const CompositeCategoricalStops<T>& f) {
|
||||
writer.Key("type");
|
||||
writer.String("categorical");
|
||||
writer.Key("stops");
|
||||
stringifyCompositeStops(f.stops);
|
||||
}
|
||||
|
||||
private:
|
||||
template <class K, class V>
|
||||
void stringifyStops(const std::map<K, V>& stops) {
|
||||
writer.StartArray();
|
||||
for (const auto& stop : stops) {
|
||||
writer.StartArray();
|
||||
stringify(writer, stop.first);
|
||||
stringify(writer, stop.second);
|
||||
writer.EndArray();
|
||||
}
|
||||
writer.EndArray();
|
||||
}
|
||||
|
||||
template <class InnerStops>
|
||||
void stringifyCompositeStops(const std::map<float, InnerStops>& stops) {
|
||||
writer.StartArray();
|
||||
for (const auto& outer : stops) {
|
||||
for (const auto& inner : outer.second) {
|
||||
writer.StartArray();
|
||||
writer.StartObject();
|
||||
writer.Key("zoom");
|
||||
writer.Double(outer.first);
|
||||
writer.Key("value");
|
||||
stringify(writer, inner.first);
|
||||
writer.EndObject();
|
||||
stringify(writer, inner.second);
|
||||
writer.EndArray();
|
||||
}
|
||||
}
|
||||
writer.EndArray();
|
||||
}
|
||||
};
|
||||
|
||||
template <class Writer, class T>
|
||||
void stringify(Writer& writer, const CameraFunction<T>& f) {
|
||||
writer.StartObject();
|
||||
CameraFunction<T>::Stops::visit(f.stops, StringifyStops<Writer> { writer });
|
||||
writer.EndObject();
|
||||
void stringify(Writer& writer, const CameraFunction<T>& fn) {
|
||||
stringify(writer, fn.getExpression().serialize());
|
||||
}
|
||||
|
||||
template <class Writer, class T>
|
||||
void stringify(Writer& writer, const SourceFunction<T>& f) {
|
||||
writer.StartObject();
|
||||
writer.Key("property");
|
||||
writer.String(f.property);
|
||||
SourceFunction<T>::Stops::visit(f.stops, StringifyStops<Writer> { writer });
|
||||
if (f.defaultValue) {
|
||||
writer.Key("default");
|
||||
stringify(writer, *f.defaultValue);
|
||||
}
|
||||
writer.EndObject();
|
||||
void stringify(Writer& writer, const SourceFunction<T>& fn) {
|
||||
stringify(writer, fn.getExpression().serialize());
|
||||
}
|
||||
|
||||
template <class Writer, class T>
|
||||
void stringify(Writer& writer, const CompositeFunction<T>& f) {
|
||||
writer.StartObject();
|
||||
writer.Key("property");
|
||||
writer.String(f.property);
|
||||
CompositeFunction<T>::Stops::visit(f.stops, StringifyStops<Writer> { writer });
|
||||
if (f.defaultValue) {
|
||||
writer.Key("default");
|
||||
stringify(writer, *f.defaultValue);
|
||||
}
|
||||
writer.EndObject();
|
||||
void stringify(Writer& writer, const CompositeFunction<T>& fn) {
|
||||
stringify(writer, fn.getExpression().serialize());
|
||||
}
|
||||
|
||||
template <class Writer, class T>
|
||||
|
||||
@@ -19,15 +19,21 @@ EvaluationResult At::evaluate(const EvaluationContext& params) const {
|
||||
const auto i = evaluatedIndex->get<double>();
|
||||
const auto inputArray = evaluatedInput->get<std::vector<Value>>();
|
||||
|
||||
if (i < 0 || i >= inputArray.size()) {
|
||||
if (i < 0) {
|
||||
return EvaluationError {
|
||||
"Array index out of bounds: " + stringify(i) +
|
||||
" > " + util::toString(inputArray.size()) + "."
|
||||
"Array index out of bounds: " + util::toString(i) + " < 0."
|
||||
};
|
||||
}
|
||||
|
||||
if (i >= inputArray.size()) {
|
||||
return EvaluationError {
|
||||
"Array index out of bounds: " + util::toString(i) +
|
||||
" > " + util::toString(inputArray.size() - 1) + "."
|
||||
};
|
||||
}
|
||||
if (i != std::floor(i)) {
|
||||
return EvaluationError {
|
||||
"Array index must be an integer, but found " + stringify(i) + " instead."
|
||||
"Array index must be an integer, but found " + util::toString(i) + " instead."
|
||||
};
|
||||
}
|
||||
return inputArray[static_cast<std::size_t>(i)];
|
||||
|
||||
@@ -6,6 +6,7 @@
|
||||
#include <mbgl/util/ignore.hpp>
|
||||
#include <mbgl/util/string.hpp>
|
||||
#include <mbgl/util/platform.hpp>
|
||||
#include <cmath>
|
||||
|
||||
namespace mbgl {
|
||||
namespace style {
|
||||
@@ -209,12 +210,7 @@ std::unordered_map<std::string, CompoundExpressionRegistry::Definition> initiali
|
||||
);
|
||||
});
|
||||
define("to-rgba", [](const Color& color) -> Result<std::array<double, 4>> {
|
||||
return std::array<double, 4> {{
|
||||
255 * color.r / color.a,
|
||||
255 * color.g / color.a,
|
||||
255 * color.b / color.a,
|
||||
color.a
|
||||
}};
|
||||
return color.toArray();
|
||||
});
|
||||
|
||||
define("rgba", rgba);
|
||||
@@ -271,13 +267,6 @@ std::unordered_map<std::string, CompoundExpressionRegistry::Definition> initiali
|
||||
return object.at(key);
|
||||
});
|
||||
|
||||
define("length", [](const std::vector<Value>& arr) -> Result<double> {
|
||||
return arr.size();
|
||||
});
|
||||
define("length", [] (const std::string s) -> Result<double> {
|
||||
return s.size();
|
||||
});
|
||||
|
||||
define("properties", [](const EvaluationContext& params) -> Result<std::unordered_map<std::string, Value>> {
|
||||
if (!params.feature) {
|
||||
return EvaluationError {
|
||||
@@ -374,6 +363,11 @@ std::unordered_map<std::string, CompoundExpressionRegistry::Definition> initiali
|
||||
return result;
|
||||
});
|
||||
|
||||
define("round", [](double x) -> Result<double> { return std::round(x); });
|
||||
define("floor", [](double x) -> Result<double> { return std::floor(x); });
|
||||
define("ceil", [](double x) -> Result<double> { return std::ceil(x); });
|
||||
define("abs", [](double x) -> Result<double> { return std::abs(x); });
|
||||
|
||||
define(">", [](double lhs, double rhs) -> Result<bool> { return lhs > rhs; });
|
||||
define(">", [](const std::string& lhs, const std::string& rhs) -> Result<bool> { return lhs > rhs; });
|
||||
define(">=", [](double lhs, double rhs) -> Result<bool> { return lhs >= rhs; });
|
||||
|
||||
@@ -223,7 +223,11 @@ mbgl::Value Interpolate<T>::serialize() const {
|
||||
|
||||
interpolator.match(
|
||||
[&](const ExponentialInterpolator& exponential) {
|
||||
serialized.emplace_back(std::vector<mbgl::Value>{{ std::string("exponential"), exponential.base }});
|
||||
if (exponential.base == 1) {
|
||||
serialized.emplace_back(std::vector<mbgl::Value>{{ std::string("linear") }});
|
||||
} else {
|
||||
serialized.emplace_back(std::vector<mbgl::Value>{{ std::string("exponential"), exponential.base }});
|
||||
}
|
||||
},
|
||||
[&](const CubicBezierInterpolator& cubicBezier) {
|
||||
static const std::string cubicBezierTag("cubic-bezier");
|
||||
|
||||
66
src/mbgl/style/expression/length.cpp
Normal file
66
src/mbgl/style/expression/length.cpp
Normal file
@@ -0,0 +1,66 @@
|
||||
#include <mbgl/style/expression/length.hpp>
|
||||
#include <mbgl/util/string.hpp>
|
||||
|
||||
namespace mbgl {
|
||||
namespace style {
|
||||
namespace expression {
|
||||
|
||||
Length::Length(std::unique_ptr<Expression> input_)
|
||||
: Expression(type::Number),
|
||||
input(std::move(input_)) {
|
||||
}
|
||||
|
||||
EvaluationResult Length::evaluate(const EvaluationContext& params) const {
|
||||
const EvaluationResult value = input->evaluate(params);
|
||||
if (!value) return value;
|
||||
return value->match(
|
||||
[] (const std::string& s) {
|
||||
return EvaluationResult { double(s.size()) };
|
||||
},
|
||||
[] (const std::vector<Value>& v) {
|
||||
return EvaluationResult { double(v.size()) };
|
||||
},
|
||||
[&] (const auto&) -> EvaluationResult {
|
||||
return EvaluationError { "Expected value to be of type string or array, but found " + toString(typeOf(*value)) + " instead." };
|
||||
});
|
||||
}
|
||||
|
||||
void Length::eachChild(const std::function<void(const Expression&)>& visit) const {
|
||||
visit(*input);
|
||||
}
|
||||
|
||||
bool Length::operator==(const Expression& e) const {
|
||||
if (auto eq = dynamic_cast<const Length*>(&e)) {
|
||||
return *eq->input == *input;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
std::vector<optional<Value>> Length::possibleOutputs() const {
|
||||
return { nullopt };
|
||||
}
|
||||
|
||||
using namespace mbgl::style::conversion;
|
||||
ParseResult Length::parse(const Convertible& value, ParsingContext& ctx) {
|
||||
std::size_t length = arrayLength(value);
|
||||
|
||||
if (length != 2) {
|
||||
ctx.error("Expected one argument, but found " + util::toString(length) + " instead.");
|
||||
return ParseResult();
|
||||
}
|
||||
|
||||
ParseResult input = ctx.parse(arrayMember(value, 1), 1);
|
||||
if (!input) return ParseResult();
|
||||
|
||||
type::Type type = (*input)->getType();
|
||||
if (!type.is<type::Array>() && !type.is<type::StringType>() && !type.is<type::ValueType>()) {
|
||||
ctx.error("Expected argument of type string or array, but found " + toString(type) + " instead.");
|
||||
return ParseResult();
|
||||
}
|
||||
|
||||
return ParseResult(std::make_unique<Length>(std::move(*input)));
|
||||
}
|
||||
|
||||
} // namespace expression
|
||||
} // namespace style
|
||||
} // namespace mbgl
|
||||
@@ -15,6 +15,7 @@
|
||||
#include <mbgl/style/expression/compound_expression.hpp>
|
||||
#include <mbgl/style/expression/equals.hpp>
|
||||
#include <mbgl/style/expression/interpolate.hpp>
|
||||
#include <mbgl/style/expression/length.hpp>
|
||||
#include <mbgl/style/expression/let.hpp>
|
||||
#include <mbgl/style/expression/literal.hpp>
|
||||
#include <mbgl/style/expression/match.hpp>
|
||||
@@ -31,23 +32,36 @@ namespace style {
|
||||
namespace expression {
|
||||
|
||||
bool isConstant(const Expression& expression) {
|
||||
if (dynamic_cast<const Var*>(&expression)) {
|
||||
return false;
|
||||
if (auto varExpression = dynamic_cast<const Var*>(&expression)) {
|
||||
return isConstant(*varExpression->getBoundExpression());
|
||||
}
|
||||
|
||||
|
||||
if (auto compound = dynamic_cast<const CompoundExpressionBase*>(&expression)) {
|
||||
if (compound->getName() == "error") {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool isTypeAnnotation = dynamic_cast<const Coercion*>(&expression) ||
|
||||
dynamic_cast<const Assertion*>(&expression) ||
|
||||
dynamic_cast<const ArrayAssertion*>(&expression);
|
||||
|
||||
bool literalArgs = true;
|
||||
bool childrenConstant = true;
|
||||
expression.eachChild([&](const Expression& child) {
|
||||
if (!dynamic_cast<const Literal*>(&child)) {
|
||||
literalArgs = false;
|
||||
// We can _almost_ assume that if `expressions` children are constant,
|
||||
// they would already have been evaluated to Literal values when they
|
||||
// were parsed. Type annotations are the exception, because they might
|
||||
// have been inferred and added after a child was parsed.
|
||||
|
||||
// So we recurse into isConstant() for the children of type annotations,
|
||||
// but otherwise simply check whether they are Literals.
|
||||
if (isTypeAnnotation) {
|
||||
childrenConstant = childrenConstant && isConstant(child);
|
||||
} else {
|
||||
childrenConstant = childrenConstant && dynamic_cast<const Literal*>(&child);
|
||||
}
|
||||
});
|
||||
if (!literalArgs) {
|
||||
if (!childrenConstant) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -89,6 +103,7 @@ const ExpressionRegistry& getExpressionRegistry() {
|
||||
{"case", Case::parse},
|
||||
{"coalesce", Coalesce::parse},
|
||||
{"interpolate", parseInterpolate},
|
||||
{"length", Length::parse},
|
||||
{"let", Let::parse},
|
||||
{"literal", Literal::parse},
|
||||
{"match", parseMatch},
|
||||
@@ -139,15 +154,15 @@ ParseResult ParsingContext::parse(const Convertible& value, TypeAnnotationOption
|
||||
return parsed;
|
||||
}
|
||||
|
||||
if (expected) {
|
||||
auto array = [&](std::unique_ptr<Expression> expression) {
|
||||
std::vector<std::unique_ptr<Expression>> args;
|
||||
args.push_back(std::move(expression));
|
||||
return args;
|
||||
};
|
||||
auto array = [&](std::unique_ptr<Expression> expression) {
|
||||
std::vector<std::unique_ptr<Expression>> args;
|
||||
args.push_back(std::move(expression));
|
||||
return args;
|
||||
};
|
||||
|
||||
if (expected) {
|
||||
const type::Type actual = (*parsed)->getType();
|
||||
if ((*expected == type::String || *expected == type::Number || *expected == type::Boolean) && actual == type::Value) {
|
||||
if ((*expected == type::String || *expected == type::Number || *expected == type::Boolean || *expected == type::Object) && actual == type::Value) {
|
||||
if (typeAnnotationOption == includeTypeAnnotations) {
|
||||
parsed = { std::make_unique<Assertion>(*expected, array(std::move(*parsed))) };
|
||||
}
|
||||
@@ -167,7 +182,7 @@ ParseResult ParsingContext::parse(const Convertible& value, TypeAnnotationOption
|
||||
}
|
||||
}
|
||||
|
||||
// If an expression's arguments are all literals, we can evaluate
|
||||
// If an expression's arguments are all constant, we can evaluate
|
||||
// it immediately and replace it with a literal value in the
|
||||
// parsed result.
|
||||
if (!dynamic_cast<Literal *>(parsed->get()) && isConstant(**parsed)) {
|
||||
@@ -191,8 +206,16 @@ ParseResult ParsingContext::parse(const Convertible& value, TypeAnnotationOption
|
||||
}
|
||||
}
|
||||
|
||||
// if this is the root expression, enforce constraints on the use ["zoom"].
|
||||
if (key.size() == 0 && !isZoomConstant(**parsed)) {
|
||||
return parsed;
|
||||
}
|
||||
|
||||
ParseResult ParsingContext::parseExpression(const Convertible& value, TypeAnnotationOption typeAnnotationOption) {
|
||||
return parse(value, typeAnnotationOption);
|
||||
}
|
||||
|
||||
ParseResult ParsingContext::parseLayerPropertyExpression(const Convertible& value, TypeAnnotationOption typeAnnotationOption) {
|
||||
ParseResult parsed = parse(value, typeAnnotationOption);
|
||||
if (parsed && !isZoomConstant(**parsed)) {
|
||||
optional<variant<const InterpolateBase*, const Step*, ParsingError>> zoomCurve = findZoomCurve(parsed->get());
|
||||
if (!zoomCurve) {
|
||||
error(R"("zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.)");
|
||||
@@ -202,10 +225,23 @@ ParseResult ParsingContext::parse(const Convertible& value, TypeAnnotationOption
|
||||
return ParseResult();
|
||||
}
|
||||
}
|
||||
|
||||
return parsed;
|
||||
}
|
||||
|
||||
const std::string ParsingContext::getCombinedErrors() const {
|
||||
std::string combinedError;
|
||||
for (const ParsingError& parsingError : *errors) {
|
||||
if (combinedError.size() > 0) {
|
||||
combinedError += "\n";
|
||||
}
|
||||
if (parsingError.key.size() > 0) {
|
||||
combinedError += parsingError.key + ": ";
|
||||
}
|
||||
combinedError += parsingError.message;
|
||||
}
|
||||
return combinedError;
|
||||
}
|
||||
|
||||
optional<std::string> ParsingContext::checkType(const type::Type& t) {
|
||||
assert(expected);
|
||||
optional<std::string> err = type::checkSubtype(*expected, t);
|
||||
|
||||
@@ -106,12 +106,13 @@ Value ValueConverter<mbgl::Value>::toExpressionValue(const mbgl::Value& value) {
|
||||
mbgl::Value ValueConverter<mbgl::Value>::fromExpressionValue(const Value& value) {
|
||||
return value.match(
|
||||
[&](const Color& color)->mbgl::Value {
|
||||
std::array<double, 4> array = color.toArray();
|
||||
return std::vector<mbgl::Value>{
|
||||
std::string("rgba"),
|
||||
double(255 * color.r / color.a),
|
||||
double(255 * color.g / color.a),
|
||||
double(255 * color.b / color.a),
|
||||
double(color.a)
|
||||
array[0],
|
||||
array[1],
|
||||
array[2],
|
||||
array[3],
|
||||
};
|
||||
},
|
||||
[&](const std::vector<Value>& values)->mbgl::Value {
|
||||
|
||||
@@ -53,12 +53,14 @@ void BackgroundLayer::setMinZoom(float minZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->minZoom = minZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
void BackgroundLayer::setMaxZoom(float maxZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->maxZoom = maxZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
// Layout properties
|
||||
|
||||
@@ -81,12 +81,14 @@ void CircleLayer::setMinZoom(float minZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->minZoom = minZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
void CircleLayer::setMaxZoom(float maxZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->maxZoom = maxZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
// Layout properties
|
||||
|
||||
@@ -6,20 +6,8 @@ namespace mbgl {
|
||||
namespace style {
|
||||
|
||||
CustomLayer::CustomLayer(const std::string& layerID,
|
||||
CustomLayerInitializeFunction init,
|
||||
CustomLayerRenderFunction render,
|
||||
CustomLayerContextLostFunction contextLost,
|
||||
CustomLayerDeinitializeFunction deinit,
|
||||
void* context)
|
||||
: Layer(makeMutable<Impl>(layerID, init, render, contextLost, deinit, context)) {
|
||||
}
|
||||
|
||||
CustomLayer::CustomLayer(const std::string& layerID,
|
||||
CustomLayerInitializeFunction init,
|
||||
CustomLayerRenderFunction render,
|
||||
CustomLayerDeinitializeFunction deinit,
|
||||
void* context)
|
||||
: Layer(makeMutable<Impl>(layerID, init, render, nullptr, deinit, context)) {
|
||||
std::unique_ptr<CustomLayerHost> host)
|
||||
: Layer(makeMutable<Impl>(layerID, std::move(host))) {
|
||||
}
|
||||
|
||||
CustomLayer::~CustomLayer() = default;
|
||||
|
||||
@@ -4,17 +4,9 @@ namespace mbgl {
|
||||
namespace style {
|
||||
|
||||
CustomLayer::Impl::Impl(const std::string& id_,
|
||||
CustomLayerInitializeFunction initializeFn_,
|
||||
CustomLayerRenderFunction renderFn_,
|
||||
CustomLayerContextLostFunction contextLostFn_,
|
||||
CustomLayerDeinitializeFunction deinitializeFn_,
|
||||
void* context_)
|
||||
std::unique_ptr<CustomLayerHost> host_)
|
||||
: Layer::Impl(LayerType::Custom, id_, std::string()) {
|
||||
initializeFn = initializeFn_;
|
||||
renderFn = renderFn_;
|
||||
deinitializeFn = deinitializeFn_;
|
||||
contextLostFn = contextLostFn_;
|
||||
context = context_;
|
||||
host = std::move(host_);
|
||||
}
|
||||
|
||||
bool CustomLayer::Impl::hasLayoutDifference(const Layer::Impl&) const {
|
||||
|
||||
@@ -3,6 +3,8 @@
|
||||
#include <mbgl/style/layer_impl.hpp>
|
||||
#include <mbgl/style/layers/custom_layer.hpp>
|
||||
|
||||
#include <memory>
|
||||
|
||||
namespace mbgl {
|
||||
|
||||
class TransformState;
|
||||
@@ -12,20 +14,12 @@ namespace style {
|
||||
class CustomLayer::Impl : public Layer::Impl {
|
||||
public:
|
||||
Impl(const std::string& id,
|
||||
CustomLayerInitializeFunction,
|
||||
CustomLayerRenderFunction,
|
||||
CustomLayerContextLostFunction,
|
||||
CustomLayerDeinitializeFunction,
|
||||
void* context);
|
||||
std::unique_ptr<CustomLayerHost> host);
|
||||
|
||||
bool hasLayoutDifference(const Layer::Impl&) const override;
|
||||
void stringifyLayout(rapidjson::Writer<rapidjson::StringBuffer>&) const override;
|
||||
|
||||
CustomLayerInitializeFunction initializeFn = nullptr;
|
||||
CustomLayerRenderFunction renderFn = nullptr;
|
||||
CustomLayerContextLostFunction contextLostFn = nullptr;
|
||||
CustomLayerDeinitializeFunction deinitializeFn = nullptr;
|
||||
void* context = nullptr;
|
||||
std::shared_ptr<CustomLayerHost> host;
|
||||
};
|
||||
|
||||
} // namespace style
|
||||
|
||||
@@ -81,12 +81,14 @@ void FillExtrusionLayer::setMinZoom(float minZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->minZoom = minZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
void FillExtrusionLayer::setMaxZoom(float maxZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->maxZoom = maxZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
// Layout properties
|
||||
|
||||
@@ -81,12 +81,14 @@ void FillLayer::setMinZoom(float minZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->minZoom = minZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
void FillLayer::setMaxZoom(float maxZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->maxZoom = maxZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
// Layout properties
|
||||
|
||||
@@ -85,12 +85,14 @@ void HeatmapLayer::setMinZoom(float minZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->minZoom = minZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
void HeatmapLayer::setMaxZoom(float maxZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->maxZoom = maxZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
// Layout properties
|
||||
|
||||
@@ -59,12 +59,14 @@ void HillshadeLayer::setMinZoom(float minZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->minZoom = minZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
void HillshadeLayer::setMaxZoom(float maxZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->maxZoom = maxZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
// Layout properties
|
||||
|
||||
@@ -108,12 +108,14 @@ void <%- camelize(type) %>Layer::setMinZoom(float minZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->minZoom = minZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
void <%- camelize(type) %>Layer::setMaxZoom(float maxZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->maxZoom = maxZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
// Layout properties
|
||||
|
||||
@@ -82,12 +82,14 @@ void LineLayer::setMinZoom(float minZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->minZoom = minZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
void LineLayer::setMaxZoom(float maxZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->maxZoom = maxZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
// Layout properties
|
||||
|
||||
@@ -59,12 +59,14 @@ void RasterLayer::setMinZoom(float minZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->minZoom = minZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
void RasterLayer::setMaxZoom(float maxZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->maxZoom = maxZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
// Layout properties
|
||||
|
||||
@@ -82,12 +82,14 @@ void SymbolLayer::setMinZoom(float minZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->minZoom = minZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
void SymbolLayer::setMaxZoom(float maxZoom) {
|
||||
auto impl_ = mutableImpl();
|
||||
impl_->maxZoom = maxZoom;
|
||||
baseImpl = std::move(impl_);
|
||||
observer->onLayerChanged(*this);
|
||||
}
|
||||
|
||||
// Layout properties
|
||||
|
||||
@@ -125,23 +125,16 @@ void GeometryTile::setShowCollisionBoxes(const bool showCollisionBoxes_) {
|
||||
}
|
||||
|
||||
void GeometryTile::onLayout(LayoutResult result, const uint64_t resultCorrelationID) {
|
||||
// Don't mark ourselves loaded or renderable until the first successful placement
|
||||
// TODO: Ideally we'd render this tile without symbols as long as this tile wasn't
|
||||
// replacing a tile at a different zoom that _did_ have symbols.
|
||||
(void)resultCorrelationID;
|
||||
nonSymbolBuckets = std::move(result.nonSymbolBuckets);
|
||||
pendingFeatureIndex = std::move(result.featureIndex);
|
||||
pendingData = std::move(result.tileData);
|
||||
observer->onTileChanged(*this);
|
||||
}
|
||||
|
||||
void GeometryTile::onPlacement(PlacementResult result, const uint64_t resultCorrelationID) {
|
||||
loaded = true;
|
||||
renderable = true;
|
||||
if (resultCorrelationID == correlationID) {
|
||||
pending = false;
|
||||
}
|
||||
symbolBuckets = std::move(result.symbolBuckets);
|
||||
|
||||
buckets = std::move(result.buckets);
|
||||
|
||||
featureIndexPendingCommit = { std::move(result.featureIndex) };
|
||||
|
||||
if (result.glyphAtlasImage) {
|
||||
glyphAtlasImage = std::move(*result.glyphAtlasImage);
|
||||
}
|
||||
@@ -183,11 +176,7 @@ void GeometryTile::upload(gl::Context& context) {
|
||||
}
|
||||
};
|
||||
|
||||
for (auto& entry : nonSymbolBuckets) {
|
||||
uploadFn(*entry.second);
|
||||
}
|
||||
|
||||
for (auto& entry : symbolBuckets) {
|
||||
for (auto& entry : buckets) {
|
||||
uploadFn(*entry.second);
|
||||
}
|
||||
|
||||
@@ -203,7 +192,6 @@ void GeometryTile::upload(gl::Context& context) {
|
||||
}
|
||||
|
||||
Bucket* GeometryTile::getBucket(const Layer::Impl& layer) const {
|
||||
const auto& buckets = layer.type == LayerType::Symbol ? symbolBuckets : nonSymbolBuckets;
|
||||
const auto it = buckets.find(layer.id);
|
||||
if (it == buckets.end()) {
|
||||
return nullptr;
|
||||
@@ -214,11 +202,11 @@ Bucket* GeometryTile::getBucket(const Layer::Impl& layer) const {
|
||||
}
|
||||
|
||||
void GeometryTile::commitFeatureIndex() {
|
||||
if (pendingFeatureIndex) {
|
||||
featureIndex = std::move(pendingFeatureIndex);
|
||||
}
|
||||
if (pendingData) {
|
||||
data = std::move(pendingData);
|
||||
// We commit our pending FeatureIndex when a global placement has run,
|
||||
// synchronizing the global CollisionIndex with the latest buckets/FeatureIndex
|
||||
if (featureIndexPendingCommit) {
|
||||
featureIndex = std::move(*featureIndexPendingCommit);
|
||||
featureIndexPendingCommit = nullopt;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -230,7 +218,7 @@ void GeometryTile::queryRenderedFeatures(
|
||||
const RenderedQueryOptions& options,
|
||||
const CollisionIndex& collisionIndex) {
|
||||
|
||||
if (!featureIndex || !data) return;
|
||||
if (!getData()) return;
|
||||
|
||||
// Determine the additional radius needed factoring in property functions
|
||||
float additionalRadius = 0;
|
||||
@@ -247,7 +235,6 @@ void GeometryTile::queryRenderedFeatures(
|
||||
util::tileSize * id.overscaleFactor(),
|
||||
std::pow(2, transformState.getZoom() - id.overscaledZ),
|
||||
options,
|
||||
*data,
|
||||
id.toUnwrapped(),
|
||||
sourceID,
|
||||
layers,
|
||||
@@ -259,8 +246,8 @@ void GeometryTile::querySourceFeatures(
|
||||
std::vector<Feature>& result,
|
||||
const SourceQueryOptions& options) {
|
||||
|
||||
// Data not yet available
|
||||
if (!data) {
|
||||
// Data not yet available, or tile is empty
|
||||
if (!getData()) {
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -273,7 +260,7 @@ void GeometryTile::querySourceFeatures(
|
||||
for (auto sourceLayer : *options.sourceLayers) {
|
||||
// Go throught all sourceLayers, if any
|
||||
// to gather all the features
|
||||
auto layer = data->getLayer(sourceLayer);
|
||||
auto layer = getData()->getLayer(sourceLayer);
|
||||
|
||||
if (layer) {
|
||||
auto featureCount = layer->featureCount();
|
||||
|
||||
@@ -65,33 +65,21 @@ public:
|
||||
|
||||
class LayoutResult {
|
||||
public:
|
||||
std::unordered_map<std::string, std::shared_ptr<Bucket>> nonSymbolBuckets;
|
||||
std::unordered_map<std::string, std::shared_ptr<Bucket>> buckets;
|
||||
std::unique_ptr<FeatureIndex> featureIndex;
|
||||
std::unique_ptr<GeometryTileData> tileData;
|
||||
|
||||
LayoutResult(std::unordered_map<std::string, std::shared_ptr<Bucket>> nonSymbolBuckets_,
|
||||
std::unique_ptr<FeatureIndex> featureIndex_,
|
||||
std::unique_ptr<GeometryTileData> tileData_)
|
||||
: nonSymbolBuckets(std::move(nonSymbolBuckets_)),
|
||||
featureIndex(std::move(featureIndex_)),
|
||||
tileData(std::move(tileData_)) {}
|
||||
};
|
||||
void onLayout(LayoutResult, uint64_t correlationID);
|
||||
|
||||
class PlacementResult {
|
||||
public:
|
||||
std::unordered_map<std::string, std::shared_ptr<Bucket>> symbolBuckets;
|
||||
optional<AlphaImage> glyphAtlasImage;
|
||||
optional<PremultipliedImage> iconAtlasImage;
|
||||
|
||||
PlacementResult(std::unordered_map<std::string, std::shared_ptr<Bucket>> symbolBuckets_,
|
||||
optional<AlphaImage> glyphAtlasImage_,
|
||||
optional<PremultipliedImage> iconAtlasImage_)
|
||||
: symbolBuckets(std::move(symbolBuckets_)),
|
||||
LayoutResult(std::unordered_map<std::string, std::shared_ptr<Bucket>> buckets_,
|
||||
std::unique_ptr<FeatureIndex> featureIndex_,
|
||||
optional<AlphaImage> glyphAtlasImage_,
|
||||
optional<PremultipliedImage> iconAtlasImage_)
|
||||
: buckets(std::move(buckets_)),
|
||||
featureIndex(std::move(featureIndex_)),
|
||||
glyphAtlasImage(std::move(glyphAtlasImage_)),
|
||||
iconAtlasImage(std::move(iconAtlasImage_)) {}
|
||||
};
|
||||
void onPlacement(PlacementResult, uint64_t correlationID);
|
||||
void onLayout(LayoutResult, uint64_t correlationID);
|
||||
|
||||
void onError(std::exception_ptr, uint64_t correlationID);
|
||||
|
||||
@@ -104,7 +92,7 @@ public:
|
||||
|
||||
protected:
|
||||
const GeometryTileData* getData() {
|
||||
return data.get();
|
||||
return featureIndex ? featureIndex->getData() : nullptr;
|
||||
}
|
||||
|
||||
private:
|
||||
@@ -123,17 +111,14 @@ private:
|
||||
|
||||
uint64_t correlationID = 0;
|
||||
|
||||
std::unordered_map<std::string, std::shared_ptr<Bucket>> nonSymbolBuckets;
|
||||
std::unordered_map<std::string, std::shared_ptr<Bucket>> buckets;
|
||||
|
||||
optional<std::unique_ptr<FeatureIndex>> featureIndexPendingCommit;
|
||||
std::unique_ptr<FeatureIndex> featureIndex;
|
||||
std::unique_ptr<FeatureIndex> pendingFeatureIndex;
|
||||
std::unique_ptr<const GeometryTileData> data;
|
||||
std::unique_ptr<const GeometryTileData> pendingData;
|
||||
|
||||
optional<AlphaImage> glyphAtlasImage;
|
||||
optional<PremultipliedImage> iconAtlasImage;
|
||||
|
||||
std::unordered_map<std::string, std::shared_ptr<Bucket>> symbolBuckets;
|
||||
|
||||
const MapMode mode;
|
||||
|
||||
bool showCollisionBoxes;
|
||||
|
||||
@@ -41,48 +41,73 @@ GeometryTileWorker::GeometryTileWorker(ActorRef<GeometryTileWorker> self_,
|
||||
GeometryTileWorker::~GeometryTileWorker() = default;
|
||||
|
||||
/*
|
||||
NOTE: The comments below are technically correct, but currently
|
||||
conceptually misleading. The change to foreground label placement
|
||||
means that:
|
||||
(1) "placement" here is a misnomer: the remaining role of
|
||||
"attemptPlacement" is symbol buffer generation
|
||||
(2) Once a tile has completed layout, we will only run
|
||||
"attemptPlacement" once
|
||||
(3) Tiles won't be rendered until "attemptPlacement" has run once
|
||||
|
||||
TODO: Simplify GeometryTileWorker to fit its new role
|
||||
https://github.com/mapbox/mapbox-gl-native/issues/10457
|
||||
|
||||
GeometryTileWorker is a state machine. This is its transition diagram.
|
||||
States are indicated by [state], lines are transitions triggered by
|
||||
messages, (parentheses) are actions taken on transition.
|
||||
|
||||
[idle] <----------------------------.
|
||||
| |
|
||||
set{Data,Layers,Placement}, symbolDependenciesChanged |
|
||||
| |
|
||||
(do layout/placement; self-send "coalesced") |
|
||||
v |
|
||||
[coalescing] --- coalesced ------------.
|
||||
| |
|
||||
.-----------------. .---------------.
|
||||
[Idle] <-------------------------.
|
||||
| |
|
||||
set{Data,Layers}, symbolDependenciesChanged, |
|
||||
setShowCollisionBoxes |
|
||||
| |
|
||||
(do parse and/or symbol layout; self-send "coalesced") |
|
||||
v |
|
||||
[Coalescing] --- coalesced ---------.
|
||||
| |
|
||||
.-----------. .---------------------.
|
||||
| |
|
||||
.--- set{Data,Layers} setPlacement -----.
|
||||
| | | |
|
||||
| v v |
|
||||
.-- [need layout] <-- set{Data,Layers} -- [need placement] --.
|
||||
.--- set{Data,Layers} setShowCollisionBoxes,
|
||||
| | symbolDependenciesChanged --.
|
||||
| | | |
|
||||
| v v |
|
||||
.-- [NeedsParse] <-- set{Data,Layers} -- [NeedsSymbolLayout] ---.
|
||||
| |
|
||||
coalesced coalesced
|
||||
| |
|
||||
v v
|
||||
(do layout or placement; self-send "coalesced"; goto [coalescing])
|
||||
(do parse or symbol layout; self-send "coalesced"; goto [coalescing])
|
||||
|
||||
The idea is that in the [idle] state, layout or placement happens immediately
|
||||
in response to a "set" message. During this processing, multiple "set" messages
|
||||
might get queued in the mailbox. At the end of processing, we self-send "coalesced",
|
||||
read all the queued messages until we get to "coalesced", and then redo either
|
||||
layout or placement if there were one or more "set"s (with layout taking priority,
|
||||
since it will trigger placement when complete), or return to the [idle] state if not.
|
||||
The idea is that in the [idle] state, parsing happens immediately in response to
|
||||
a "set" message, and symbol layout happens once all symbol dependencies are met.
|
||||
During this processing, multiple "set" messages might get queued in the mailbox.
|
||||
At the end of processing, we self-send "coalesced", read all the queued messages
|
||||
until we get to "coalesced", and then re-parse if there were one or more "set"s or
|
||||
return to the [idle] state if not.
|
||||
|
||||
One important goal of the design is to prevent starvation. Under heavy load new
|
||||
requests for tiles should not prevent in progress request from completing.
|
||||
It is nevertheless possible to restart an in-progress request:
|
||||
|
||||
- [Idle] setData -> parse()
|
||||
sends getGlyphs, hasPendingSymbolDependencies() is true
|
||||
enters [Coalescing], sends coalesced
|
||||
- [Coalescing] coalesced -> [Idle]
|
||||
- [Idle] setData -> new parse(), interrupts old parse()
|
||||
sends getGlyphs, hasPendingSymbolDependencies() is true
|
||||
enters [Coalescing], sends coalesced
|
||||
- [Coalescing] onGlyphsAvailable -> [NeedsSymbolLayout]
|
||||
hasPendingSymbolDependencies() may or may not be true
|
||||
- [NeedsSymbolLayout] coalesced -> performSymbolLayout()
|
||||
Generates result depending on whether dependencies are met
|
||||
-> [Idle]
|
||||
|
||||
In this situation, we are counting on the idea that even with rapid changes to
|
||||
the tile's data, the set of glyphs/images it requires will not keep growing without
|
||||
limit.
|
||||
|
||||
Although parsing (which populates all non-symbol buckets and requests dependencies
|
||||
for symbol buckets) is internally separate from symbol layout, we only return
|
||||
results to the foreground when we have completed both steps. Because we _move_
|
||||
the result buckets to the foreground, it is necessary to re-generate all buckets from
|
||||
scratch for `setShowCollisionBoxes`, even though it only affects symbol layers.
|
||||
|
||||
The GL JS equivalent (in worker_tile.js and vector_tile_worker_source.js)
|
||||
is somewhat simpler because it relies on getGlyphs/getImages calls that transfer
|
||||
an entire set of glyphs/images on every tile load, while the native logic
|
||||
maintains a local state that can be incrementally updated. Because each tile load
|
||||
call becomes self-contained, the equivalent of the coalescing logic is handled by
|
||||
'reloadTile' queueing a single extra 'reloadTile' callback to run after the next
|
||||
completed parse.
|
||||
*/
|
||||
|
||||
void GeometryTileWorker::setData(std::unique_ptr<const GeometryTileData> data_, uint64_t correlationID_) {
|
||||
@@ -92,14 +117,14 @@ void GeometryTileWorker::setData(std::unique_ptr<const GeometryTileData> data_,
|
||||
|
||||
switch (state) {
|
||||
case Idle:
|
||||
redoLayout();
|
||||
parse();
|
||||
coalesce();
|
||||
break;
|
||||
|
||||
case Coalescing:
|
||||
case NeedLayout:
|
||||
case NeedPlacement:
|
||||
state = NeedLayout;
|
||||
case NeedsParse:
|
||||
case NeedsSymbolLayout:
|
||||
state = NeedsParse;
|
||||
break;
|
||||
}
|
||||
} catch (...) {
|
||||
@@ -114,16 +139,16 @@ void GeometryTileWorker::setLayers(std::vector<Immutable<Layer::Impl>> layers_,
|
||||
|
||||
switch (state) {
|
||||
case Idle:
|
||||
redoLayout();
|
||||
parse();
|
||||
coalesce();
|
||||
break;
|
||||
|
||||
case Coalescing:
|
||||
case NeedPlacement:
|
||||
state = NeedLayout;
|
||||
case NeedsSymbolLayout:
|
||||
state = NeedsParse;
|
||||
break;
|
||||
|
||||
case NeedLayout:
|
||||
case NeedsParse:
|
||||
break;
|
||||
}
|
||||
} catch (...) {
|
||||
@@ -138,16 +163,20 @@ void GeometryTileWorker::setShowCollisionBoxes(bool showCollisionBoxes_, uint64_
|
||||
|
||||
switch (state) {
|
||||
case Idle:
|
||||
attemptPlacement();
|
||||
coalesce();
|
||||
if (!hasPendingParseResult()) {
|
||||
// Trigger parse if nothing is in flight, otherwise symbol layout will automatically
|
||||
// pick up the change
|
||||
parse();
|
||||
coalesce();
|
||||
}
|
||||
break;
|
||||
|
||||
case Coalescing:
|
||||
state = NeedPlacement;
|
||||
state = NeedsSymbolLayout;
|
||||
break;
|
||||
|
||||
case NeedPlacement:
|
||||
case NeedLayout:
|
||||
case NeedsSymbolLayout:
|
||||
case NeedsParse:
|
||||
break;
|
||||
}
|
||||
} catch (...) {
|
||||
@@ -160,19 +189,23 @@ void GeometryTileWorker::symbolDependenciesChanged() {
|
||||
switch (state) {
|
||||
case Idle:
|
||||
if (symbolLayoutsNeedPreparation) {
|
||||
attemptPlacement();
|
||||
// symbolLayoutsNeedPreparation can only be set true by parsing
|
||||
// and the parse result can only be cleared by performSymbolLayout
|
||||
// which also clears symbolLayoutsNeedPreparation
|
||||
assert(hasPendingParseResult());
|
||||
performSymbolLayout();
|
||||
coalesce();
|
||||
}
|
||||
break;
|
||||
|
||||
case Coalescing:
|
||||
if (symbolLayoutsNeedPreparation) {
|
||||
state = NeedPlacement;
|
||||
state = NeedsSymbolLayout;
|
||||
}
|
||||
break;
|
||||
|
||||
case NeedPlacement:
|
||||
case NeedLayout:
|
||||
case NeedsSymbolLayout:
|
||||
case NeedsParse:
|
||||
break;
|
||||
}
|
||||
} catch (...) {
|
||||
@@ -191,13 +224,16 @@ void GeometryTileWorker::coalesced() {
|
||||
state = Idle;
|
||||
break;
|
||||
|
||||
case NeedLayout:
|
||||
redoLayout();
|
||||
case NeedsParse:
|
||||
parse();
|
||||
coalesce();
|
||||
break;
|
||||
|
||||
case NeedPlacement:
|
||||
attemptPlacement();
|
||||
case NeedsSymbolLayout:
|
||||
// We may have entered NeedsSymbolLayout while coalescing
|
||||
// after a performSymbolLayout. In that case, we need to
|
||||
// start over with parsing in order to do another layout.
|
||||
hasPendingParseResult() ? performSymbolLayout() : parse();
|
||||
coalesce();
|
||||
break;
|
||||
}
|
||||
@@ -279,7 +315,7 @@ static std::vector<std::unique_ptr<RenderLayer>> toRenderLayers(const std::vecto
|
||||
return renderLayers;
|
||||
}
|
||||
|
||||
void GeometryTileWorker::redoLayout() {
|
||||
void GeometryTileWorker::parse() {
|
||||
if (!data || !layers) {
|
||||
return;
|
||||
}
|
||||
@@ -292,8 +328,8 @@ void GeometryTileWorker::redoLayout() {
|
||||
}
|
||||
|
||||
std::unordered_map<std::string, std::unique_ptr<SymbolLayout>> symbolLayoutMap;
|
||||
std::unordered_map<std::string, std::shared_ptr<Bucket>> buckets;
|
||||
auto featureIndex = std::make_unique<FeatureIndex>();
|
||||
buckets.clear();
|
||||
featureIndex = std::make_unique<FeatureIndex>(*data ? (*data)->clone() : nullptr);
|
||||
BucketParameters parameters { id, mode, pixelRatio };
|
||||
|
||||
GlyphDependencies glyphDependencies;
|
||||
@@ -368,13 +404,7 @@ void GeometryTileWorker::redoLayout() {
|
||||
requestNewGlyphs(glyphDependencies);
|
||||
requestNewImages(imageDependencies);
|
||||
|
||||
parent.invoke(&GeometryTile::onLayout, GeometryTile::LayoutResult {
|
||||
std::move(buckets),
|
||||
std::move(featureIndex),
|
||||
*data ? (*data)->clone() : nullptr,
|
||||
}, correlationID);
|
||||
|
||||
attemptPlacement();
|
||||
performSymbolLayout();
|
||||
}
|
||||
|
||||
bool GeometryTileWorker::hasPendingSymbolDependencies() const {
|
||||
@@ -385,9 +415,13 @@ bool GeometryTileWorker::hasPendingSymbolDependencies() const {
|
||||
}
|
||||
return !pendingImageDependencies.empty();
|
||||
}
|
||||
|
||||
bool GeometryTileWorker::hasPendingParseResult() const {
|
||||
return bool(featureIndex);
|
||||
}
|
||||
|
||||
void GeometryTileWorker::attemptPlacement() {
|
||||
if (!data || !layers || hasPendingSymbolDependencies()) {
|
||||
void GeometryTileWorker::performSymbolLayout() {
|
||||
if (!data || !layers || !hasPendingParseResult() || hasPendingSymbolDependencies()) {
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -414,8 +448,6 @@ void GeometryTileWorker::attemptPlacement() {
|
||||
symbolLayoutsNeedPreparation = false;
|
||||
}
|
||||
|
||||
std::unordered_map<std::string, std::shared_ptr<Bucket>> buckets;
|
||||
|
||||
for (auto& symbolLayout : symbolLayouts) {
|
||||
if (obsolete) {
|
||||
return;
|
||||
@@ -435,11 +467,12 @@ void GeometryTileWorker::attemptPlacement() {
|
||||
}
|
||||
|
||||
firstLoad = false;
|
||||
|
||||
parent.invoke(&GeometryTile::onPlacement, GeometryTile::PlacementResult {
|
||||
|
||||
parent.invoke(&GeometryTile::onLayout, GeometryTile::LayoutResult {
|
||||
std::move(buckets),
|
||||
std::move(featureIndex),
|
||||
std::move(glyphAtlasImage),
|
||||
std::move(iconAtlasImage),
|
||||
std::move(iconAtlasImage)
|
||||
}, correlationID);
|
||||
}
|
||||
|
||||
|
||||
@@ -8,6 +8,8 @@
|
||||
#include <mbgl/util/optional.hpp>
|
||||
#include <mbgl/util/immutable.hpp>
|
||||
#include <mbgl/style/layer_impl.hpp>
|
||||
#include <mbgl/geometry/feature_index.hpp>
|
||||
#include <mbgl/renderer/bucket.hpp>
|
||||
|
||||
#include <atomic>
|
||||
#include <memory>
|
||||
@@ -43,8 +45,8 @@ public:
|
||||
|
||||
private:
|
||||
void coalesced();
|
||||
void redoLayout();
|
||||
void attemptPlacement();
|
||||
void parse();
|
||||
void performSymbolLayout();
|
||||
|
||||
void coalesce();
|
||||
|
||||
@@ -53,6 +55,7 @@ private:
|
||||
|
||||
void symbolDependenciesChanged();
|
||||
bool hasPendingSymbolDependencies() const;
|
||||
bool hasPendingParseResult() const;
|
||||
|
||||
ActorRef<GeometryTileWorker> self;
|
||||
ActorRef<GeometryTile> parent;
|
||||
@@ -62,12 +65,15 @@ private:
|
||||
const std::atomic<bool>& obsolete;
|
||||
const MapMode mode;
|
||||
const float pixelRatio;
|
||||
|
||||
std::unique_ptr<FeatureIndex> featureIndex;
|
||||
std::unordered_map<std::string, std::shared_ptr<Bucket>> buckets;
|
||||
|
||||
enum State {
|
||||
Idle,
|
||||
Coalescing,
|
||||
NeedLayout,
|
||||
NeedPlacement
|
||||
NeedsParse,
|
||||
NeedsSymbolLayout
|
||||
};
|
||||
|
||||
State state = Idle;
|
||||
|
||||
@@ -23,11 +23,25 @@ optional<Color> Color::parse(const std::string& s) {
|
||||
}
|
||||
|
||||
std::string Color::stringify() const {
|
||||
std::array<double, 4> array = toArray();
|
||||
return "rgba(" +
|
||||
util::toString(r * 255 / a) + "," +
|
||||
util::toString(g * 255 / a) + "," +
|
||||
util::toString(b * 255 / a) + "," +
|
||||
util::toString(a) + ")";
|
||||
util::toString(array[0]) + "," +
|
||||
util::toString(array[1]) + "," +
|
||||
util::toString(array[2]) + "," +
|
||||
util::toString(array[3]) + ")";
|
||||
}
|
||||
|
||||
std::array<double, 4> Color::toArray() const {
|
||||
if (a == 0) {
|
||||
return {{ 0, 0, 0, 0 }};
|
||||
} else {
|
||||
return {{
|
||||
r * 255 / a,
|
||||
g * 255 / a,
|
||||
b * 255 / a,
|
||||
a,
|
||||
}};
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace mbgl
|
||||
|
||||
Reference in New Issue
Block a user