diff options
Diffstat (limited to 'src/mbgl/style')
18 files changed, 398 insertions, 59 deletions
diff --git a/src/mbgl/style/bucket_parameters.hpp b/src/mbgl/style/bucket_parameters.hpp index 9aad35dcad..f608e000d2 100644 --- a/src/mbgl/style/bucket_parameters.hpp +++ b/src/mbgl/style/bucket_parameters.hpp @@ -1,54 +1,16 @@ #pragma once -#include <mbgl/map/mode.hpp> -#include <mbgl/tile/tile_id.hpp> -#include <mbgl/style/filter.hpp> - -#include <atomic> -#include <functional> +#include <mbgl/util/variant.hpp> +#include <mapbox/recursive_wrapper.hpp> namespace mbgl { - -class TileID; -class GeometryTileLayer; -class GeometryTileFeature; -class GlyphAtlas; -class CollisionTile; -class FeatureIndex; - namespace style { -class BucketParameters { -public: - BucketParameters(const OverscaledTileID& tileID_, - const GeometryTileLayer& layer_, - const std::atomic<bool>& obsolete_, - uintptr_t tileUID_, - GlyphAtlas& glyphAtlas_, - FeatureIndex& featureIndex_, - const MapMode mode_) - : tileID(tileID_), - layer(layer_), - obsolete(obsolete_), - tileUID(tileUID_), - glyphAtlas(glyphAtlas_), - featureIndex(featureIndex_), - mode(mode_) {} - - bool cancelled() const { - return obsolete; - } - - void eachFilteredFeature(const Filter&, std::function<void (const GeometryTileFeature&, std::size_t index, const std::string& layerName)>); +class GeometryBucketParameters; +class RasterBucketParameters; - const OverscaledTileID& tileID; - const GeometryTileLayer& layer; - const std::atomic<bool>& obsolete; - uintptr_t tileUID; - GlyphAtlas& glyphAtlas; - FeatureIndex& featureIndex; - const MapMode mode; -}; +using BucketParameters = variant<mapbox::util::recursive_wrapper<GeometryBucketParameters>, + mapbox::util::recursive_wrapper<RasterBucketParameters>>; } // namespace style } // namespace mbgl diff --git a/src/mbgl/style/bucket_parameters.cpp b/src/mbgl/style/geometry_bucket_parameters.cpp index 64f53babcd..acbd20b073 100644 --- a/src/mbgl/style/bucket_parameters.cpp +++ b/src/mbgl/style/geometry_bucket_parameters.cpp @@ -1,11 +1,11 @@ -#include <mbgl/style/bucket_parameters.hpp> +#include <mbgl/style/geometry_bucket_parameters.hpp> #include <mbgl/style/filter_evaluator.hpp> #include <mbgl/tile/geometry_tile_data.hpp> namespace mbgl { namespace style { -void BucketParameters::eachFilteredFeature(const Filter& filter, +void GeometryBucketParameters::eachFilteredFeature(const Filter& filter, std::function<void (const GeometryTileFeature&, std::size_t index, const std::string& layerName)> function) { auto name = layer.getName(); for (std::size_t i = 0; !cancelled() && i < layer.featureCount(); i++) { diff --git a/src/mbgl/style/geometry_bucket_parameters.hpp b/src/mbgl/style/geometry_bucket_parameters.hpp new file mode 100644 index 0000000000..dce205324d --- /dev/null +++ b/src/mbgl/style/geometry_bucket_parameters.hpp @@ -0,0 +1,55 @@ +#pragma once + +#include <mbgl/map/mode.hpp> +#include <mbgl/tile/tile_id.hpp> +#include <mbgl/style/bucket_parameters.hpp> +#include <mbgl/style/filter.hpp> + +#include <atomic> +#include <functional> + +namespace mbgl { + +class TileID; +class GeometryTileLayer; +class GeometryTileFeature; +class GlyphAtlas; +class CollisionTile; +class FeatureIndex; + +namespace style { + +class GeometryBucketParameters { +public: + GeometryBucketParameters(const OverscaledTileID& tileID_, + const GeometryTileLayer& layer_, + const std::atomic<bool>& obsolete_, + uintptr_t tileUID_, + GlyphAtlas& glyphAtlas_, + FeatureIndex& featureIndex_, + const MapMode mode_) + : tileID(tileID_), + layer(layer_), + obsolete(obsolete_), + tileUID(tileUID_), + glyphAtlas(glyphAtlas_), + featureIndex(featureIndex_), + mode(mode_) {} + + bool cancelled() const { + return obsolete; + } + + void eachFilteredFeature(const Filter&, std::function<void (const GeometryTileFeature&, std::size_t index, const std::string& layerName)>); + + const OverscaledTileID& tileID; + const GeometryTileLayer& layer; + const std::atomic<bool>& obsolete; + uintptr_t tileUID; + GlyphAtlas& glyphAtlas; + FeatureIndex& featureIndex; + const MapMode mode; +}; + +} // namespace style +} // namespace mbgl diff --git a/src/mbgl/style/layer_impl.hpp b/src/mbgl/style/layer_impl.hpp index 4bf2956a6d..52ce1e6176 100644 --- a/src/mbgl/style/layer_impl.hpp +++ b/src/mbgl/style/layer_impl.hpp @@ -3,6 +3,7 @@ #include <mbgl/style/layer.hpp> #include <mbgl/style/types.hpp> #include <mbgl/style/filter.hpp> +#include <mbgl/style/bucket_parameters.hpp> #include <mbgl/style/layer_observer.hpp> #include <mbgl/renderer/render_pass.hpp> #include <mbgl/util/noncopyable.hpp> @@ -20,7 +21,6 @@ namespace style { class CascadeParameters; class CalculationParameters; -class BucketParameters; /** * `Layer::Impl` contains the internal implementation of `Layer`: the details that need to be accessible to other parts diff --git a/src/mbgl/style/layers/circle_layer_impl.cpp b/src/mbgl/style/layers/circle_layer_impl.cpp index 33699b6665..fd121115a9 100644 --- a/src/mbgl/style/layers/circle_layer_impl.cpp +++ b/src/mbgl/style/layers/circle_layer_impl.cpp @@ -1,5 +1,5 @@ #include <mbgl/style/layers/circle_layer_impl.hpp> -#include <mbgl/style/bucket_parameters.hpp> +#include <mbgl/style/geometry_bucket_parameters.hpp> #include <mbgl/renderer/circle_bucket.hpp> #include <mbgl/geometry/feature_index.hpp> #include <mbgl/util/math.hpp> @@ -21,7 +21,9 @@ bool CircleLayer::Impl::recalculate(const CalculationParameters& parameters) { return hasTransitions; } -std::unique_ptr<Bucket> CircleLayer::Impl::createBucket(BucketParameters& parameters) const { +std::unique_ptr<Bucket> CircleLayer::Impl::createBucket(BucketParameters& params) const { + auto& parameters = params.get<GeometryBucketParameters>(); + auto bucket = std::make_unique<CircleBucket>(parameters.mode); auto& name = bucketName(); diff --git a/src/mbgl/style/layers/fill_layer_impl.cpp b/src/mbgl/style/layers/fill_layer_impl.cpp index fc439f1cd1..0e4873b3dc 100644 --- a/src/mbgl/style/layers/fill_layer_impl.cpp +++ b/src/mbgl/style/layers/fill_layer_impl.cpp @@ -1,5 +1,5 @@ #include <mbgl/style/layers/fill_layer_impl.hpp> -#include <mbgl/style/bucket_parameters.hpp> +#include <mbgl/style/geometry_bucket_parameters.hpp> #include <mbgl/renderer/fill_bucket.hpp> #include <mbgl/geometry/feature_index.hpp> #include <mbgl/util/math.hpp> @@ -30,7 +30,8 @@ bool FillLayer::Impl::recalculate(const CalculationParameters& parameters) { return hasTransitions; } -std::unique_ptr<Bucket> FillLayer::Impl::createBucket(BucketParameters& parameters) const { +std::unique_ptr<Bucket> FillLayer::Impl::createBucket(BucketParameters& params) const { + auto& parameters = params.get<GeometryBucketParameters>(); auto bucket = std::make_unique<FillBucket>(); auto& name = bucketName(); diff --git a/src/mbgl/style/layers/line_layer_impl.cpp b/src/mbgl/style/layers/line_layer_impl.cpp index c116af5fc2..4fc0ddef07 100644 --- a/src/mbgl/style/layers/line_layer_impl.cpp +++ b/src/mbgl/style/layers/line_layer_impl.cpp @@ -1,5 +1,5 @@ #include <mbgl/style/layers/line_layer_impl.hpp> -#include <mbgl/style/bucket_parameters.hpp> +#include <mbgl/style/geometry_bucket_parameters.hpp> #include <mbgl/renderer/line_bucket.hpp> #include <mbgl/geometry/feature_index.hpp> #include <mbgl/util/math.hpp> @@ -27,7 +27,8 @@ bool LineLayer::Impl::recalculate(const CalculationParameters& parameters) { return hasTransitions; } -std::unique_ptr<Bucket> LineLayer::Impl::createBucket(BucketParameters& parameters) const { +std::unique_ptr<Bucket> LineLayer::Impl::createBucket(BucketParameters& params) const { + auto& parameters = params.get<GeometryBucketParameters>(); auto bucket = std::make_unique<LineBucket>(parameters.tileID.overscaleFactor()); bucket->layout = layout; diff --git a/src/mbgl/style/layers/raster_layer_impl.cpp b/src/mbgl/style/layers/raster_layer_impl.cpp index 879bfa4559..41370905e7 100644 --- a/src/mbgl/style/layers/raster_layer_impl.cpp +++ b/src/mbgl/style/layers/raster_layer_impl.cpp @@ -1,5 +1,7 @@ #include <mbgl/style/layers/raster_layer_impl.hpp> -#include <mbgl/renderer/bucket.hpp> +#include <mbgl/style/raster_bucket_parameters.hpp> +#include <mbgl/renderer/raster_bucket.hpp> +#include <mbgl/util/image.hpp> namespace mbgl { namespace style { @@ -16,8 +18,9 @@ bool RasterLayer::Impl::recalculate(const CalculationParameters& parameters) { return hasTransitions; } -std::unique_ptr<Bucket> RasterLayer::Impl::createBucket(BucketParameters&) const { - return nullptr; +std::unique_ptr<Bucket> RasterLayer::Impl::createBucket(BucketParameters& params) const { + auto& parameters = params.get<RasterBucketParameters>(); + return std::make_unique<RasterBucket>(decodeImage(*parameters.data)); } } // namespace style diff --git a/src/mbgl/style/layers/symbol_layer_impl.cpp b/src/mbgl/style/layers/symbol_layer_impl.cpp index 0ac9ff832d..661a635809 100644 --- a/src/mbgl/style/layers/symbol_layer_impl.cpp +++ b/src/mbgl/style/layers/symbol_layer_impl.cpp @@ -1,5 +1,5 @@ #include <mbgl/style/layers/symbol_layer_impl.hpp> -#include <mbgl/style/bucket_parameters.hpp> +#include <mbgl/style/geometry_bucket_parameters.hpp> #include <mbgl/layout/symbol_layout.hpp> #include <mbgl/renderer/bucket.hpp> @@ -31,7 +31,8 @@ std::unique_ptr<Bucket> SymbolLayer::Impl::createBucket(BucketParameters&) const return nullptr; } -std::unique_ptr<SymbolLayout> SymbolLayer::Impl::createLayout(BucketParameters& parameters) const { +std::unique_ptr<SymbolLayout> SymbolLayer::Impl::createLayout(BucketParameters& params) const { + auto& parameters = params.get<GeometryBucketParameters>(); SymbolLayoutProperties layoutProperties = layout; CalculationParameters p(parameters.tileID.overscaledZ); diff --git a/src/mbgl/style/layers/terrain_layer.cpp b/src/mbgl/style/layers/terrain_layer.cpp new file mode 100644 index 0000000000..3d2a077477 --- /dev/null +++ b/src/mbgl/style/layers/terrain_layer.cpp @@ -0,0 +1,156 @@ +// This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`. + +#include <mbgl/style/layers/terrain_layer.hpp> +#include <mbgl/style/layers/terrain_layer_impl.hpp> + +namespace mbgl { +namespace style { + +TerrainLayer::TerrainLayer(const std::string& layerID, const std::string& sourceID) + : Layer(Type::Terrain, std::make_unique<Impl>()) + , impl(static_cast<Impl*>(baseImpl.get())) { + impl->id = layerID; + impl->source = sourceID; +} + +TerrainLayer::TerrainLayer(const Impl& other) + : Layer(Type::Terrain, std::make_unique<Impl>(other)) + , impl(static_cast<Impl*>(baseImpl.get())) { +} + +TerrainLayer::~TerrainLayer() = default; + +std::unique_ptr<Layer> TerrainLayer::Impl::clone() const { + return std::make_unique<TerrainLayer>(*this); +} + +std::unique_ptr<Layer> TerrainLayer::Impl::cloneRef(const std::string& id_) const { + auto result = std::make_unique<TerrainLayer>(*this); + result->impl->id = id_; + result->impl->ref = this->id; + result->impl->paint = TerrainPaintProperties(); + return std::move(result); +} + +// Source + +const std::string& TerrainLayer::getSourceID() const { + return impl->source; +} + +void TerrainLayer::setSourceLayer(const std::string& sourceLayer) { + impl->sourceLayer = sourceLayer; +} + +const std::string& TerrainLayer::getSourceLayer() const { + return impl->sourceLayer; +} + +// Filter + +void TerrainLayer::setFilter(const Filter& filter) { + impl->filter = filter; + impl->observer->onLayerFilterChanged(*this); +} + +const Filter& TerrainLayer::getFilter() const { + return impl->filter; +} + +// Layout properties + + +// Paint properties + +PropertyValue<Color> TerrainLayer::getDefaultTerrainShadowColor() { + return { { 0, 0, 1, 1 } }; +} + +PropertyValue<Color> TerrainLayer::getTerrainShadowColor(const optional<std::string>& klass) const { + return impl->paint.terrainShadowColor.get(klass); +} + +void TerrainLayer::setTerrainShadowColor(PropertyValue<Color> value, const optional<std::string>& klass) { + if (value == getTerrainShadowColor(klass)) + return; + impl->paint.terrainShadowColor.set(value, klass); + impl->observer->onLayerPaintPropertyChanged(*this); +} + +PropertyValue<Color> TerrainLayer::getDefaultTerrainHighlightColor() { + return { { 1, 1, 0, 1 } }; +} + +PropertyValue<Color> TerrainLayer::getTerrainHighlightColor(const optional<std::string>& klass) const { + return impl->paint.terrainHighlightColor.get(klass); +} + +void TerrainLayer::setTerrainHighlightColor(PropertyValue<Color> value, const optional<std::string>& klass) { + if (value == getTerrainHighlightColor(klass)) + return; + impl->paint.terrainHighlightColor.set(value, klass); + impl->observer->onLayerPaintPropertyChanged(*this); +} + +PropertyValue<Color> TerrainLayer::getDefaultTerrainAccentColor() { + return { Color::black() }; +} + +PropertyValue<Color> TerrainLayer::getTerrainAccentColor(const optional<std::string>& klass) const { + return impl->paint.terrainAccentColor.get(klass); +} + +void TerrainLayer::setTerrainAccentColor(PropertyValue<Color> value, const optional<std::string>& klass) { + if (value == getTerrainAccentColor(klass)) + return; + impl->paint.terrainAccentColor.set(value, klass); + impl->observer->onLayerPaintPropertyChanged(*this); +} + +PropertyValue<float> TerrainLayer::getDefaultTerrainIlluminationDirection() { + return { 135 }; +} + +PropertyValue<float> TerrainLayer::getTerrainIlluminationDirection(const optional<std::string>& klass) const { + return impl->paint.terrainIlluminationDirection.get(klass); +} + +void TerrainLayer::setTerrainIlluminationDirection(PropertyValue<float> value, const optional<std::string>& klass) { + if (value == getTerrainIlluminationDirection(klass)) + return; + impl->paint.terrainIlluminationDirection.set(value, klass); + impl->observer->onLayerPaintPropertyChanged(*this); +} + +PropertyValue<AlignmentType> TerrainLayer::getDefaultTerrainIlluminationAlignment() { + return { AlignmentType::Viewport }; +} + +PropertyValue<AlignmentType> TerrainLayer::getTerrainIlluminationAlignment(const optional<std::string>& klass) const { + return impl->paint.terrainIlluminationAlignment.get(klass); +} + +void TerrainLayer::setTerrainIlluminationAlignment(PropertyValue<AlignmentType> value, const optional<std::string>& klass) { + if (value == getTerrainIlluminationAlignment(klass)) + return; + impl->paint.terrainIlluminationAlignment.set(value, klass); + impl->observer->onLayerPaintPropertyChanged(*this); +} + +PropertyValue<float> TerrainLayer::getDefaultTerrainExaggeration() { + return { 1 }; +} + +PropertyValue<float> TerrainLayer::getTerrainExaggeration(const optional<std::string>& klass) const { + return impl->paint.terrainExaggeration.get(klass); +} + +void TerrainLayer::setTerrainExaggeration(PropertyValue<float> value, const optional<std::string>& klass) { + if (value == getTerrainExaggeration(klass)) + return; + impl->paint.terrainExaggeration.set(value, klass); + impl->observer->onLayerPaintPropertyChanged(*this); +} + +} // namespace style +} // namespace mbgl diff --git a/src/mbgl/style/layers/terrain_layer_impl.cpp b/src/mbgl/style/layers/terrain_layer_impl.cpp new file mode 100644 index 0000000000..79e41fa935 --- /dev/null +++ b/src/mbgl/style/layers/terrain_layer_impl.cpp @@ -0,0 +1,47 @@ +#include <mbgl/style/layers/terrain_layer_impl.hpp> +#include <mbgl/style/geometry_bucket_parameters.hpp> +#include <mbgl/style/raster_bucket_parameters.hpp> +#include <mbgl/renderer/terrain_bucket.hpp> + +namespace mbgl { +namespace style { + +void TerrainLayer::Impl::cascade(const CascadeParameters& parameters) { + paint.cascade(parameters); +} + +bool TerrainLayer::Impl::recalculate(const CalculationParameters& parameters) { + bool hasTransitions = paint.recalculate(parameters); + + passes = RenderPass::Translucent; + + return hasTransitions; +} + +std::unique_ptr<Bucket> TerrainLayer::Impl::createBucket(BucketParameters& params) const { + if (params.is<mapbox::util::recursive_wrapper<GeometryBucketParameters>>()) { + // DEM data encoded into vector tile + auto& parameters = params.get<GeometryBucketParameters>(); + auto& layer = parameters.layer; + + for (std::size_t i = 0; !parameters.cancelled() && i < layer.featureCount(); i++) { + auto feature = layer.getFeature(i); + if (feature->getType() == FeatureType(4)) { + return std::make_unique<TerrainBucket>(feature->getDEMPyramid()); + } else { + // Trying to create a DEM from another feature type. + } + } + } else if (params.is<mapbox::util::recursive_wrapper<RasterBucketParameters>>()) { + // DEM data from raster tile + auto& parameters = params.get<RasterBucketParameters>(); + if (parameters.data) { + return std::make_unique<TerrainBucket>(decodeImage(*parameters.data)); + } + } + + return nullptr; +} + +} // namespace style +} // namespace mbgl diff --git a/src/mbgl/style/layers/terrain_layer_impl.hpp b/src/mbgl/style/layers/terrain_layer_impl.hpp new file mode 100644 index 0000000000..ce2c7a7e42 --- /dev/null +++ b/src/mbgl/style/layers/terrain_layer_impl.hpp @@ -0,0 +1,24 @@ +#pragma once + +#include <mbgl/style/layer_impl.hpp> +#include <mbgl/style/layers/terrain_layer.hpp> +#include <mbgl/style/layers/terrain_layer_properties.hpp> + +namespace mbgl { +namespace style { + +class TerrainLayer::Impl : public Layer::Impl { +public: + std::unique_ptr<Layer> clone() const override; + std::unique_ptr<Layer> cloneRef(const std::string& id) const override; + + void cascade(const CascadeParameters&) override; + bool recalculate(const CalculationParameters&) override; + + std::unique_ptr<Bucket> createBucket(BucketParameters&) const override; + + TerrainPaintProperties paint; +}; + +} // namespace style +} // namespace mbgl diff --git a/src/mbgl/style/layers/terrain_layer_properties.cpp b/src/mbgl/style/layers/terrain_layer_properties.cpp new file mode 100644 index 0000000000..7373ef0f00 --- /dev/null +++ b/src/mbgl/style/layers/terrain_layer_properties.cpp @@ -0,0 +1,31 @@ +// This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`. + +#include <mbgl/style/layers/terrain_layer_properties.hpp> + +namespace mbgl { +namespace style { + +void TerrainPaintProperties::cascade(const CascadeParameters& parameters) { + terrainShadowColor.cascade(parameters); + terrainHighlightColor.cascade(parameters); + terrainAccentColor.cascade(parameters); + terrainIlluminationDirection.cascade(parameters); + terrainIlluminationAlignment.cascade(parameters); + terrainExaggeration.cascade(parameters); +} + +bool TerrainPaintProperties::recalculate(const CalculationParameters& parameters) { + bool hasTransitions = false; + + hasTransitions |= terrainShadowColor.calculate(parameters); + hasTransitions |= terrainHighlightColor.calculate(parameters); + hasTransitions |= terrainAccentColor.calculate(parameters); + hasTransitions |= terrainIlluminationDirection.calculate(parameters); + hasTransitions |= terrainIlluminationAlignment.calculate(parameters); + hasTransitions |= terrainExaggeration.calculate(parameters); + + return hasTransitions; +} + +} // namespace style +} // namespace mbgl diff --git a/src/mbgl/style/layers/terrain_layer_properties.hpp b/src/mbgl/style/layers/terrain_layer_properties.hpp new file mode 100644 index 0000000000..ad058b0e35 --- /dev/null +++ b/src/mbgl/style/layers/terrain_layer_properties.hpp @@ -0,0 +1,29 @@ +// This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`. + +#pragma once + +#include <mbgl/style/types.hpp> +#include <mbgl/style/layout_property.hpp> +#include <mbgl/style/paint_property.hpp> + +namespace mbgl { +namespace style { + +class CascadeParameters; +class CalculationParameters; + +class TerrainPaintProperties { +public: + void cascade(const CascadeParameters&); + bool recalculate(const CalculationParameters&); + + PaintProperty<Color> terrainShadowColor { { 0, 0, 1, 1 } }; + PaintProperty<Color> terrainHighlightColor { { 1, 1, 0, 1 } }; + PaintProperty<Color> terrainAccentColor { Color::black() }; + PaintProperty<float> terrainIlluminationDirection { 135 }; + PaintProperty<AlignmentType> terrainIlluminationAlignment { AlignmentType::Viewport }; + PaintProperty<float> terrainExaggeration { 1 }; +}; + +} // namespace style +} // namespace mbgl diff --git a/src/mbgl/style/raster_bucket_parameters.hpp b/src/mbgl/style/raster_bucket_parameters.hpp new file mode 100644 index 0000000000..cd2a7c5fd7 --- /dev/null +++ b/src/mbgl/style/raster_bucket_parameters.hpp @@ -0,0 +1,24 @@ +#pragma once + +#include <mbgl/style/bucket_parameters.hpp> +#include <mbgl/tile/tile_id.hpp> + +#include <memory> +#include <string> + +namespace mbgl { +namespace style { + +class RasterBucketParameters { +public: + RasterBucketParameters(const OverscaledTileID& tileID_, + std::shared_ptr<const std::string> data_) + : tileID(tileID_), data(data_) { + } + + const OverscaledTileID& tileID; + std::shared_ptr<const std::string> data; +}; + +} // namespace style +} // namespace mbgl diff --git a/src/mbgl/style/source_impl.cpp b/src/mbgl/style/source_impl.cpp index afaa94878c..f601796c98 100644 --- a/src/mbgl/style/source_impl.cpp +++ b/src/mbgl/style/source_impl.cpp @@ -55,6 +55,7 @@ void Source::Impl::startRender(algorithm::ClipIDGenerator& generator, const mat4& projMatrix, const TransformState& transform) { if (type == SourceType::Vector || + type == SourceType::Raster || type == SourceType::GeoJSON || type == SourceType::Annotations) { generator.update(renderTiles); diff --git a/src/mbgl/style/sources/raster_source_impl.cpp b/src/mbgl/style/sources/raster_source_impl.cpp index b727651260..91a93c800c 100644 --- a/src/mbgl/style/sources/raster_source_impl.cpp +++ b/src/mbgl/style/sources/raster_source_impl.cpp @@ -12,7 +12,7 @@ RasterSource::Impl::Impl(std::string id_, Source& base_, std::unique_ptr<Tile> RasterSource::Impl::createTile(const OverscaledTileID& tileID, const UpdateParameters& parameters) { - return std::make_unique<RasterTile>(tileID, parameters, tileset); + return std::make_unique<RasterTile>(tileID, base.getID(), parameters, tileset); } } // namespace style diff --git a/src/mbgl/style/style.cpp b/src/mbgl/style/style.cpp index 3c2b97b65d..7781f6ecdd 100644 --- a/src/mbgl/style/style.cpp +++ b/src/mbgl/style/style.cpp @@ -11,6 +11,7 @@ #include <mbgl/style/layers/line_layer.hpp> #include <mbgl/style/layers/circle_layer.hpp> #include <mbgl/style/layers/raster_layer.hpp> +#include <mbgl/style/layers/terrain_layer.hpp> #include <mbgl/style/layer_impl.hpp> #include <mbgl/style/parser.hpp> #include <mbgl/style/query_parameters.hpp> @@ -542,6 +543,7 @@ struct QueueSourceReloadVisitor { // they don't participate in layout. void operator()(CustomLayer&) {} void operator()(RasterLayer&) {} + void operator()(TerrainLayer&) {} void operator()(BackgroundLayer&) {} template <class VectorLayer> |