diff options
Diffstat (limited to 'src')
119 files changed, 831 insertions, 661 deletions
diff --git a/src/mbgl/annotation/annotation_manager.cpp b/src/mbgl/annotation/annotation_manager.cpp index 09442b165c..e332850357 100644 --- a/src/mbgl/annotation/annotation_manager.cpp +++ b/src/mbgl/annotation/annotation_manager.cpp @@ -4,15 +4,17 @@ #include <mbgl/annotation/line_annotation_impl.hpp> #include <mbgl/annotation/fill_annotation_impl.hpp> #include <mbgl/annotation/style_sourced_annotation_impl.hpp> -#include <mbgl/source/source.hpp> +#include <mbgl/style/source.hpp> #include <mbgl/style/style.hpp> -#include <mbgl/layer/symbol_layer.hpp> -#include <mbgl/layer/symbol_layer_impl.hpp> +#include <mbgl/style/layers/symbol_layer.hpp> +#include <mbgl/style/layers/symbol_layer_impl.hpp> #include <boost/function_output_iterator.hpp> namespace mbgl { +using namespace style; + const std::string AnnotationManager::SourceID = "com.mapbox.annotations"; const std::string AnnotationManager::PointLayerID = "com.mapbox.annotations.points"; @@ -105,7 +107,7 @@ std::unique_ptr<AnnotationTile> AnnotationManager::getTile(const CanonicalTileID void AnnotationManager::updateStyle(Style& style) { // Create annotation source, point layer, and point bucket if (!style.getSource(SourceID)) { - std::unique_ptr<Source> source = std::make_unique<Source>(SourceType::Annotations, SourceID, "", util::tileSize, std::make_unique<SourceInfo>(), nullptr); + std::unique_ptr<Source> source = std::make_unique<Source>(SourceType::Annotations, SourceID, "", util::tileSize, std::make_unique<Tileset>(), nullptr); source->enabled = true; style.addSource(std::move(source)); diff --git a/src/mbgl/annotation/annotation_manager.hpp b/src/mbgl/annotation/annotation_manager.hpp index 6862739ebb..73907e10c8 100644 --- a/src/mbgl/annotation/annotation_manager.hpp +++ b/src/mbgl/annotation/annotation_manager.hpp @@ -18,7 +18,10 @@ class AnnotationTile; class AnnotationTileMonitor; class SymbolAnnotationImpl; class ShapeAnnotationImpl; + +namespace style { class Style; +} class AnnotationManager : private util::noncopyable { public: @@ -36,7 +39,7 @@ public: double getTopOffsetPixelsForIcon(const std::string& name); SpriteAtlas& getSpriteAtlas() { return spriteAtlas; } - void updateStyle(Style&); + void updateStyle(style::Style&); void addTileMonitor(AnnotationTileMonitor&); void removeTileMonitor(AnnotationTileMonitor&); diff --git a/src/mbgl/annotation/fill_annotation_impl.cpp b/src/mbgl/annotation/fill_annotation_impl.cpp index 17bdd9c38e..31c9f6d720 100644 --- a/src/mbgl/annotation/fill_annotation_impl.cpp +++ b/src/mbgl/annotation/fill_annotation_impl.cpp @@ -1,11 +1,11 @@ #include <mbgl/annotation/fill_annotation_impl.hpp> #include <mbgl/annotation/annotation_manager.hpp> #include <mbgl/style/style.hpp> -#include <mbgl/layer/fill_layer.hpp> +#include <mbgl/style/layers/fill_layer.hpp> namespace mbgl { -namespace geojsonvt = mapbox::geojsonvt; +using namespace style; FillAnnotationImpl::FillAnnotationImpl(const AnnotationID id_, const FillAnnotation& annotation_, const uint8_t maxZoom_) : ShapeAnnotationImpl(id_, maxZoom_), diff --git a/src/mbgl/annotation/fill_annotation_impl.hpp b/src/mbgl/annotation/fill_annotation_impl.hpp index c396499e38..b879860c08 100644 --- a/src/mbgl/annotation/fill_annotation_impl.hpp +++ b/src/mbgl/annotation/fill_annotation_impl.hpp @@ -9,7 +9,7 @@ class FillAnnotationImpl : public ShapeAnnotationImpl { public: FillAnnotationImpl(const AnnotationID, const FillAnnotation&, const uint8_t maxZoom); - void updateStyle(Style&) const final; + void updateStyle(style::Style&) const final; const ShapeAnnotationGeometry& geometry() const final; private: diff --git a/src/mbgl/annotation/line_annotation_impl.cpp b/src/mbgl/annotation/line_annotation_impl.cpp index 11febc7de7..85177591f4 100644 --- a/src/mbgl/annotation/line_annotation_impl.cpp +++ b/src/mbgl/annotation/line_annotation_impl.cpp @@ -1,11 +1,11 @@ #include <mbgl/annotation/line_annotation_impl.hpp> #include <mbgl/annotation/annotation_manager.hpp> #include <mbgl/style/style.hpp> -#include <mbgl/layer/line_layer.hpp> +#include <mbgl/style/layers/line_layer.hpp> namespace mbgl { -namespace geojsonvt = mapbox::geojsonvt; +using namespace style; LineAnnotationImpl::LineAnnotationImpl(const AnnotationID id_, const LineAnnotation& annotation_, const uint8_t maxZoom_) : ShapeAnnotationImpl(id_, maxZoom_), diff --git a/src/mbgl/annotation/line_annotation_impl.hpp b/src/mbgl/annotation/line_annotation_impl.hpp index 05d650c051..c9a37dd390 100644 --- a/src/mbgl/annotation/line_annotation_impl.hpp +++ b/src/mbgl/annotation/line_annotation_impl.hpp @@ -9,7 +9,7 @@ class LineAnnotationImpl : public ShapeAnnotationImpl { public: LineAnnotationImpl(const AnnotationID, const LineAnnotation&, const uint8_t maxZoom); - void updateStyle(Style&) const final; + void updateStyle(style::Style&) const final; const ShapeAnnotationGeometry& geometry() const final; private: diff --git a/src/mbgl/annotation/shape_annotation_impl.cpp b/src/mbgl/annotation/shape_annotation_impl.cpp index 283e736c6d..be6e12558d 100644 --- a/src/mbgl/annotation/shape_annotation_impl.cpp +++ b/src/mbgl/annotation/shape_annotation_impl.cpp @@ -10,6 +10,7 @@ namespace mbgl { +using namespace style; namespace geojsonvt = mapbox::geojsonvt; ShapeAnnotationImpl::ShapeAnnotationImpl(const AnnotationID id_, const uint8_t maxZoom_) diff --git a/src/mbgl/annotation/shape_annotation_impl.hpp b/src/mbgl/annotation/shape_annotation_impl.hpp index 7f36f8b888..e6ba9a4bd7 100644 --- a/src/mbgl/annotation/shape_annotation_impl.hpp +++ b/src/mbgl/annotation/shape_annotation_impl.hpp @@ -9,16 +9,19 @@ namespace mbgl { -class Style; class AnnotationTile; class CanonicalTileID; +namespace style { +class Style; +} + class ShapeAnnotationImpl { public: ShapeAnnotationImpl(const AnnotationID, const uint8_t maxZoom); virtual ~ShapeAnnotationImpl() = default; - virtual void updateStyle(Style&) const = 0; + virtual void updateStyle(style::Style&) const = 0; virtual const ShapeAnnotationGeometry& geometry() const = 0; void updateTile(const CanonicalTileID&, AnnotationTile&); diff --git a/src/mbgl/annotation/style_sourced_annotation_impl.cpp b/src/mbgl/annotation/style_sourced_annotation_impl.cpp index e1e11a664a..43a27c8aac 100644 --- a/src/mbgl/annotation/style_sourced_annotation_impl.cpp +++ b/src/mbgl/annotation/style_sourced_annotation_impl.cpp @@ -2,12 +2,12 @@ #include <mbgl/annotation/annotation_manager.hpp> #include <mbgl/style/style.hpp> #include <mbgl/style/layer.hpp> -#include <mbgl/layer/line_layer.hpp> -#include <mbgl/layer/fill_layer.hpp> +#include <mbgl/style/layers/line_layer.hpp> +#include <mbgl/style/layers/fill_layer.hpp> namespace mbgl { -namespace geojsonvt = mapbox::geojsonvt; +using namespace style; StyleSourcedAnnotationImpl::StyleSourcedAnnotationImpl(const AnnotationID id_, const StyleSourcedAnnotation& annotation_, const uint8_t maxZoom_) : ShapeAnnotationImpl(id_, maxZoom_), diff --git a/src/mbgl/annotation/style_sourced_annotation_impl.hpp b/src/mbgl/annotation/style_sourced_annotation_impl.hpp index 98e9910c66..09ef474fc0 100644 --- a/src/mbgl/annotation/style_sourced_annotation_impl.hpp +++ b/src/mbgl/annotation/style_sourced_annotation_impl.hpp @@ -9,7 +9,7 @@ class StyleSourcedAnnotationImpl : public ShapeAnnotationImpl { public: StyleSourcedAnnotationImpl(const AnnotationID, const StyleSourcedAnnotation&, const uint8_t maxZoom); - void updateStyle(Style&) const final; + void updateStyle(style::Style&) const final; const ShapeAnnotationGeometry& geometry() const final; private: diff --git a/src/mbgl/geometry/feature_index.cpp b/src/mbgl/geometry/feature_index.cpp index e72aa344fa..8c10344915 100644 --- a/src/mbgl/geometry/feature_index.cpp +++ b/src/mbgl/geometry/feature_index.cpp @@ -1,8 +1,8 @@ #include <mbgl/geometry/feature_index.hpp> #include <mbgl/style/style.hpp> #include <mbgl/style/layer.hpp> -#include <mbgl/layer/layer_impl.hpp> -#include <mbgl/layer/symbol_layer.hpp> +#include <mbgl/style/layer_impl.hpp> +#include <mbgl/style/layers/symbol_layer.hpp> #include <mbgl/text/collision_tile.hpp> #include <mbgl/util/constants.hpp> #include <mbgl/util/math.hpp> @@ -59,7 +59,7 @@ void FeatureIndex::query( const optional<std::vector<std::string>>& filterLayerIDs, const GeometryTile& geometryTile, const CanonicalTileID& tileID, - const Style& style) const { + const style::Style& style) const { mapbox::geometry::box<int16_t> box = mapbox::geometry::envelope(queryGeometry); @@ -94,7 +94,7 @@ void FeatureIndex::addFeature( const optional<std::vector<std::string>>& filterLayerIDs, const GeometryTile& geometryTile, const CanonicalTileID& tileID, - const Style& style, + const style::Style& style, const float bearing, const float pixelsToTileUnits) const { @@ -116,7 +116,7 @@ void FeatureIndex::addFeature( auto styleLayer = style.getLayer(layerID); if (!styleLayer || - (!styleLayer->is<SymbolLayer>() && + (!styleLayer->is<style::SymbolLayer>() && !styleLayer->baseImpl->queryIntersectsGeometry(queryGeometry, geometryTileFeature->getGeometries(), bearing, pixelsToTileUnits))) { continue; } @@ -128,7 +128,7 @@ void FeatureIndex::addFeature( optional<GeometryCollection> FeatureIndex::translateQueryGeometry( const GeometryCollection& queryGeometry, const std::array<float, 2>& translate, - const TranslateAnchorType anchorType, + const style::TranslateAnchorType anchorType, const float bearing, const float pixelsToTileUnits) { if (translate[0] == 0 && translate[1] == 0) { @@ -136,7 +136,7 @@ optional<GeometryCollection> FeatureIndex::translateQueryGeometry( } GeometryCoordinate translateVec(translate[0] * pixelsToTileUnits, translate[1] * pixelsToTileUnits); - if (anchorType == TranslateAnchorType::Viewport) { + if (anchorType == style::TranslateAnchorType::Viewport) { translateVec = util::rotate(translateVec, -bearing); } diff --git a/src/mbgl/geometry/feature_index.hpp b/src/mbgl/geometry/feature_index.hpp index 0dcc154f02..c944a98130 100644 --- a/src/mbgl/geometry/feature_index.hpp +++ b/src/mbgl/geometry/feature_index.hpp @@ -1,5 +1,6 @@ #pragma once +#include <mbgl/style/types.hpp> #include <mbgl/tile/geometry_tile.hpp> #include <mbgl/util/grid_index.hpp> #include <mbgl/util/feature.hpp> @@ -10,9 +11,11 @@ namespace mbgl { +namespace style { class Style; +} + class CollisionTile; -enum class TranslateAnchorType : bool; class CanonicalTileID; class IndexedSubfeature { @@ -39,12 +42,12 @@ public: const optional<std::vector<std::string>>& layerIDs, const GeometryTile&, const CanonicalTileID&, - const Style&) const; + const style::Style&) const; static optional<GeometryCollection> translateQueryGeometry( const GeometryCollection& queryGeometry, const std::array<float, 2>& translate, - const TranslateAnchorType, + const style::TranslateAnchorType, const float bearing, const float pixelsToTileUnits); @@ -60,7 +63,7 @@ private: const optional<std::vector<std::string>>& filterLayerIDs, const GeometryTile&, const CanonicalTileID&, - const Style&, + const style::Style&, const float bearing, const float pixelsToTileUnits) const; diff --git a/src/mbgl/layer/background_layer_impl.hpp b/src/mbgl/layer/background_layer_impl.hpp deleted file mode 100644 index 6af31dd921..0000000000 --- a/src/mbgl/layer/background_layer_impl.hpp +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once - -#include <mbgl/layer/layer_impl.hpp> -#include <mbgl/layer/background_layer.hpp> -#include <mbgl/layer/background_layer_properties.hpp> - -namespace mbgl { - -class BackgroundLayer::Impl : public Layer::Impl { -public: - std::unique_ptr<Layer> clone() const override; - - void parseLayout(const JSValue&) override {}; - void parsePaints(const JSValue&) override; - - void cascade(const StyleCascadeParameters&) override; - bool recalculate(const StyleCalculationParameters&) override; - - std::unique_ptr<Bucket> createBucket(StyleBucketParameters&) const override; - - BackgroundPaintProperties paint; -}; - -} // namespace mbgl diff --git a/src/mbgl/layer/raster_layer_impl.hpp b/src/mbgl/layer/raster_layer_impl.hpp deleted file mode 100644 index a83c7f259e..0000000000 --- a/src/mbgl/layer/raster_layer_impl.hpp +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once - -#include <mbgl/layer/layer_impl.hpp> -#include <mbgl/layer/raster_layer.hpp> -#include <mbgl/layer/raster_layer_properties.hpp> - -namespace mbgl { - -class RasterLayer::Impl : public Layer::Impl { -public: - std::unique_ptr<Layer> clone() const override; - - void parseLayout(const JSValue&) override {}; - void parsePaints(const JSValue&) override; - - void cascade(const StyleCascadeParameters&) override; - bool recalculate(const StyleCalculationParameters&) override; - - std::unique_ptr<Bucket> createBucket(StyleBucketParameters&) const override; - - RasterPaintProperties paint; -}; - -} // namespace mbgl diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp index 4f1c4634ca..ec961a6485 100644 --- a/src/mbgl/map/map.cpp +++ b/src/mbgl/map/map.cpp @@ -5,11 +5,11 @@ #include <mbgl/map/transform_state.hpp> #include <mbgl/annotation/annotation_manager.hpp> #include <mbgl/style/style.hpp> -#include <mbgl/style/style_observer.hpp> -#include <mbgl/style/property_transition.hpp> -#include <mbgl/style/style_update_parameters.hpp> -#include <mbgl/style/style_query_parameters.hpp> -#include <mbgl/layer/custom_layer.hpp> +#include <mbgl/style/layer.hpp> +#include <mbgl/style/observer.hpp> +#include <mbgl/style/transition_options.hpp> +#include <mbgl/style/update_parameters.hpp> +#include <mbgl/style/query_parameters.hpp> #include <mbgl/renderer/painter.hpp> #include <mbgl/storage/file_source.hpp> #include <mbgl/storage/resource.hpp> @@ -25,13 +25,15 @@ namespace mbgl { +using namespace style; + enum class RenderState { never, partial, fully }; -class Map::Impl : public StyleObserver { +class Map::Impl : public style::Observer { public: Impl(View&, FileSource&, MapMode, GLContextMode, ConstrainMode, ViewportMode); @@ -221,17 +223,17 @@ void Map::Impl::update() { style->recalculate(transform.getZoom(), timePoint, mode); } - StyleUpdateParameters parameters(pixelRatio, - debugOptions, - timePoint, - transform.getState(), - style->workers, - fileSource, - *texturePool, - style->shouldReparsePartialTiles, - mode, - *annotationManager, - *style); + style::UpdateParameters parameters(pixelRatio, + debugOptions, + timePoint, + transform.getState(), + style->workers, + fileSource, + *texturePool, + style->shouldReparsePartialTiles, + mode, + *annotationManager, + *style); style->update(parameters); @@ -799,19 +801,19 @@ bool Map::isFullyLoaded() const { return impl->style->isLoaded(); } -void Map::addClass(const std::string& className, const PropertyTransition& properties) { +void Map::addClass(const std::string& className, const TransitionOptions& properties) { if (impl->style->addClass(className, properties)) { update(Update::Classes); } } -void Map::removeClass(const std::string& className, const PropertyTransition& properties) { +void Map::removeClass(const std::string& className, const TransitionOptions& properties) { if (impl->style->removeClass(className, properties)) { update(Update::Classes); } } -void Map::setClasses(const std::vector<std::string>& classNames, const PropertyTransition& properties) { +void Map::setClasses(const std::vector<std::string>& classNames, const TransitionOptions& properties) { impl->style->setClasses(classNames, properties); update(Update::Classes); } diff --git a/src/mbgl/style/zoom_history.hpp b/src/mbgl/map/zoom_history.hpp index 8c88ea6507..8c88ea6507 100644 --- a/src/mbgl/style/zoom_history.hpp +++ b/src/mbgl/map/zoom_history.hpp diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp index 89b0ceefb2..c7ebe480ed 100644 --- a/src/mbgl/renderer/bucket.hpp +++ b/src/mbgl/renderer/bucket.hpp @@ -13,7 +13,6 @@ namespace mbgl { class Painter; -class Layer; class UnwrappedTileID; class CollisionTile; @@ -21,6 +20,10 @@ namespace gl { class ObjectStore; } +namespace style { +class Layer; +} + class Bucket : private util::noncopyable { public: Bucket() : uploaded(false) {} @@ -31,7 +34,7 @@ public: // Every time this bucket is getting rendered, this function is called. This happens either // once or twice (for Opaque and Transparent render passes). - virtual void render(Painter&, const Layer&, const UnwrappedTileID&, const mat4&) = 0; + virtual void render(Painter&, const style::Layer&, const UnwrappedTileID&, const mat4&) = 0; virtual ~Bucket() = default; diff --git a/src/mbgl/renderer/circle_bucket.cpp b/src/mbgl/renderer/circle_bucket.cpp index 969e05131b..4ae63fed46 100644 --- a/src/mbgl/renderer/circle_bucket.cpp +++ b/src/mbgl/renderer/circle_bucket.cpp @@ -2,10 +2,12 @@ #include <mbgl/renderer/painter.hpp> #include <mbgl/shader/circle_shader.hpp> -#include <mbgl/layer/circle_layer.hpp> +#include <mbgl/style/layers/circle_layer.hpp> #include <mbgl/util/constants.hpp> -using namespace mbgl; +namespace mbgl { + +using namespace style; CircleBucket::CircleBucket(MapMode mode_) : mode(mode_) { } @@ -97,3 +99,5 @@ void CircleBucket::drawCircles(CircleShader& shader, gl::ObjectStore& store) { elementsIndex += group->elements_length * elementsBuffer_.itemSize; } } + +} diff --git a/src/mbgl/renderer/circle_bucket.hpp b/src/mbgl/renderer/circle_bucket.hpp index 9c95fce045..fa34aa088a 100644 --- a/src/mbgl/renderer/circle_bucket.hpp +++ b/src/mbgl/renderer/circle_bucket.hpp @@ -19,7 +19,7 @@ public: ~CircleBucket() override; void upload(gl::ObjectStore&) override; - void render(Painter&, const Layer&, const UnwrappedTileID&, const mat4&) override; + void render(Painter&, const style::Layer&, const UnwrappedTileID&, const mat4&) override; bool hasData() const override; bool needsClipping() const override; diff --git a/src/mbgl/renderer/fill_bucket.cpp b/src/mbgl/renderer/fill_bucket.cpp index 4a9709f4e8..02f346decb 100644 --- a/src/mbgl/renderer/fill_bucket.cpp +++ b/src/mbgl/renderer/fill_bucket.cpp @@ -1,5 +1,5 @@ #include <mbgl/renderer/fill_bucket.hpp> -#include <mbgl/layer/fill_layer.hpp> +#include <mbgl/style/layers/fill_layer.hpp> #include <mbgl/renderer/painter.hpp> #include <mbgl/shader/plain_shader.hpp> #include <mbgl/shader/pattern_shader.hpp> @@ -12,22 +12,24 @@ #include <cassert> -struct GeometryTooLongException : std::exception {}; - -using namespace mbgl; - namespace mapbox { namespace util { -template <> struct nth<0, GeometryCoordinate> { - inline static int64_t get(const GeometryCoordinate& t) { return t.x; }; +template <> struct nth<0, mbgl::GeometryCoordinate> { + inline static int64_t get(const mbgl::GeometryCoordinate& t) { return t.x; }; }; -template <> struct nth<1, GeometryCoordinate> { - inline static int64_t get(const GeometryCoordinate& t) { return t.y; }; +template <> struct nth<1, mbgl::GeometryCoordinate> { + inline static int64_t get(const mbgl::GeometryCoordinate& t) { return t.y; }; }; } } +namespace mbgl { + +using namespace style; + +struct GeometryTooLongException : std::exception {}; + FillBucket::FillBucket() { } @@ -165,3 +167,5 @@ void FillBucket::drawVertices(OutlinePatternShader& shader, gl::ObjectStore& sto elements_index += group->elements_length * lineElementsBuffer.itemSize; } } + +} diff --git a/src/mbgl/renderer/fill_bucket.hpp b/src/mbgl/renderer/fill_bucket.hpp index 21e3239f29..35d70d169c 100644 --- a/src/mbgl/renderer/fill_bucket.hpp +++ b/src/mbgl/renderer/fill_bucket.hpp @@ -21,7 +21,7 @@ public: ~FillBucket() override; void upload(gl::ObjectStore&) override; - void render(Painter&, const Layer&, const UnwrappedTileID&, const mat4&) override; + void render(Painter&, const style::Layer&, const UnwrappedTileID&, const mat4&) override; bool hasData() const override; bool needsClipping() const override; diff --git a/src/mbgl/renderer/line_bucket.cpp b/src/mbgl/renderer/line_bucket.cpp index 8124a5daed..d207cdb8c5 100644 --- a/src/mbgl/renderer/line_bucket.cpp +++ b/src/mbgl/renderer/line_bucket.cpp @@ -1,5 +1,5 @@ #include <mbgl/renderer/line_bucket.hpp> -#include <mbgl/layer/line_layer.hpp> +#include <mbgl/style/layers/line_layer.hpp> #include <mbgl/geometry/elements_buffer.hpp> #include <mbgl/renderer/painter.hpp> #include <mbgl/shader/line_shader.hpp> @@ -11,7 +11,9 @@ #include <cassert> -using namespace mbgl; +namespace mbgl { + +using namespace style; LineBucket::LineBucket(uint32_t overscaling_) : overscaling(overscaling_) { } @@ -505,3 +507,5 @@ void LineBucket::drawLinePatterns(LinepatternShader& shader, gl::ObjectStore& st elements_index += group->elements_length * triangleElementsBuffer.itemSize; } } + +} diff --git a/src/mbgl/renderer/line_bucket.hpp b/src/mbgl/renderer/line_bucket.hpp index 1093ec2a48..d746f29c7e 100644 --- a/src/mbgl/renderer/line_bucket.hpp +++ b/src/mbgl/renderer/line_bucket.hpp @@ -5,13 +5,12 @@ #include <mbgl/geometry/vao.hpp> #include <mbgl/geometry/elements_buffer.hpp> #include <mbgl/geometry/line_buffer.hpp> -#include <mbgl/layer/line_layer_impl.hpp> +#include <mbgl/style/layers/line_layer_properties.hpp> #include <vector> namespace mbgl { -class Style; class LineVertexBuffer; class TriangleElementsBuffer; class LineShader; @@ -26,7 +25,7 @@ public: ~LineBucket() override; void upload(gl::ObjectStore&) override; - void render(Painter&, const Layer&, const UnwrappedTileID&, const mat4&) override; + void render(Painter&, const style::Layer&, const UnwrappedTileID&, const mat4&) override; bool hasData() const override; bool needsClipping() const override; @@ -50,7 +49,7 @@ private: std::vector<TriangleElement>& triangleStore); public: - LineLayoutProperties layout; + style::LineLayoutProperties layout; private: LineVertexBuffer vertexBuffer; diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp index ccc6e23408..1864bf7ef1 100644 --- a/src/mbgl/renderer/painter.cpp +++ b/src/mbgl/renderer/painter.cpp @@ -1,18 +1,17 @@ #include <mbgl/renderer/painter.hpp> -#include <mbgl/source/source.hpp> +#include <mbgl/style/source.hpp> #include <mbgl/tile/tile.hpp> #include <mbgl/platform/log.hpp> #include <mbgl/gl/debugging.hpp> #include <mbgl/style/style.hpp> -#include <mbgl/layer/layer_impl.hpp> -#include <mbgl/style/style_render_parameters.hpp> +#include <mbgl/style/layer_impl.hpp> -#include <mbgl/layer/background_layer.hpp> -#include <mbgl/layer/custom_layer.hpp> -#include <mbgl/layer/custom_layer_impl.hpp> +#include <mbgl/style/layers/background_layer.hpp> +#include <mbgl/style/layers/custom_layer.hpp> +#include <mbgl/style/layers/custom_layer_impl.hpp> #include <mbgl/sprite/sprite_atlas.hpp> #include <mbgl/geometry/line_atlas.hpp> @@ -46,7 +45,9 @@ #include <algorithm> #include <iostream> -using namespace mbgl; +namespace mbgl { + +using namespace style; Painter::Painter(const TransformState& state_, gl::ObjectStore& store_) : state(state_), @@ -308,3 +309,5 @@ void Painter::setDepthSublayer(int n) { float farDepth = nearDepth + depthRangeSize; config.depthRange = { nearDepth, farDepth }; } + +} diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp index ad26457555..f040fee67f 100644 --- a/src/mbgl/renderer/painter.hpp +++ b/src/mbgl/renderer/painter.hpp @@ -13,7 +13,7 @@ #include <mbgl/gl/gl_config.hpp> #include <mbgl/style/render_item.hpp> -#include <mbgl/style/types.hpp> +#include <mbgl/style/style.hpp> #include <mbgl/gl/gl.hpp> @@ -28,27 +28,19 @@ namespace mbgl { -class Style; class Tile; class SpriteAtlas; class GlyphAtlas; class LineAtlas; -class Source; struct FrameData; class TileData; class DebugBucket; class FillBucket; -class FillLayer; class LineBucket; -class LineLayer; class CircleBucket; -class CircleLayer; class SymbolBucket; -class SymbolLayer; class RasterBucket; -class RasterLayer; -class BackgroundLayer; class SDFShader; class PlainShader; @@ -72,6 +64,17 @@ namespace util { class ObjectStore; } +namespace style { +class Style; +class Source; +class FillLayer; +class LineLayer; +class CircleLayer; +class SymbolLayer; +class RasterLayer; +class BackgroundLayer; +} + struct FrameData { std::array<uint16_t, 2> framebufferSize; TimePoint timePoint; @@ -86,8 +89,8 @@ public: Painter(const TransformState&, gl::ObjectStore&); ~Painter(); - void render(const Style& style, - const FrameData& frame, + void render(const style::Style&, + const FrameData&, SpriteAtlas& annotationSpriteAtlas); // Renders debug information for a tile. @@ -99,12 +102,12 @@ public: void renderClipMasks(); void renderDebugText(TileData&, const mat4&); - void renderFill(FillBucket&, const FillLayer&, const UnwrappedTileID&, const mat4&); - void renderLine(LineBucket&, const LineLayer&, const UnwrappedTileID&, const mat4&); - void renderCircle(CircleBucket&, const CircleLayer&, const UnwrappedTileID&, const mat4&); - void renderSymbol(SymbolBucket&, const SymbolLayer&, const UnwrappedTileID&, const mat4&); - void renderRaster(RasterBucket&, const RasterLayer&, const UnwrappedTileID&, const mat4&); - void renderBackground(const BackgroundLayer&); + void renderFill(FillBucket&, const style::FillLayer&, const UnwrappedTileID&, const mat4&); + void renderLine(LineBucket&, const style::LineLayer&, const UnwrappedTileID&, const mat4&); + void renderCircle(CircleBucket&, const style::CircleLayer&, const UnwrappedTileID&, const mat4&); + void renderSymbol(SymbolBucket&, const style::SymbolLayer&, const UnwrappedTileID&, const mat4&); + void renderRaster(RasterBucket&, const style::RasterLayer&, const UnwrappedTileID&, const mat4&); + void renderBackground(const style::BackgroundLayer&); float saturationFactor(float saturation); float contrastFactor(float contrast); @@ -118,9 +121,9 @@ private: mat4 translatedMatrix(const mat4& matrix, const std::array<float, 2>& translation, const UnwrappedTileID& id, - TranslateAnchorType anchor); + style::TranslateAnchorType anchor); - std::vector<RenderItem> determineRenderOrder(const Style& style); + std::vector<RenderItem> determineRenderOrder(const style::Style&); template <class Iterator> void renderPass(RenderPass, @@ -138,7 +141,7 @@ private: void (SymbolBucket::*drawSDF)(SDFShader&, gl::ObjectStore&), // Layout - RotationAlignmentType rotationAlignment, + style::RotationAlignmentType rotationAlignment, float layoutSize, // Paint @@ -148,7 +151,7 @@ private: float haloWidth, float haloBlur, std::array<float, 2> translate, - TranslateAnchorType translateAnchor, + style::TranslateAnchorType translateAnchor, float paintSize); void setDepthSublayer(int n); diff --git a/src/mbgl/renderer/painter_background.cpp b/src/mbgl/renderer/painter_background.cpp index bc01d3c32f..07e5821ce8 100644 --- a/src/mbgl/renderer/painter_background.cpp +++ b/src/mbgl/renderer/painter_background.cpp @@ -1,14 +1,16 @@ #include <mbgl/renderer/painter.hpp> -#include <mbgl/layer/background_layer.hpp> -#include <mbgl/layer/background_layer_impl.hpp> +#include <mbgl/style/layers/background_layer.hpp> +#include <mbgl/style/layers/background_layer_impl.hpp> #include <mbgl/shader/pattern_shader.hpp> #include <mbgl/shader/plain_shader.hpp> #include <mbgl/sprite/sprite_atlas.hpp> #include <mbgl/util/mat4.hpp> #include <mbgl/util/tile_cover.hpp> -using namespace mbgl; +namespace mbgl { + +using namespace style; void Painter::renderBackground(const BackgroundLayer& layer) { // Note that for bottommost layers without a pattern, the background color is drawn with @@ -107,3 +109,5 @@ void Painter::renderBackground(const BackgroundLayer& layer) { MBGL_CHECK_ERROR(glDrawArrays(GL_TRIANGLE_STRIP, 0, (GLsizei)tileStencilBuffer.index())); } } + +} diff --git a/src/mbgl/renderer/painter_circle.cpp b/src/mbgl/renderer/painter_circle.cpp index c371f4debe..9f2cd17f7f 100644 --- a/src/mbgl/renderer/painter_circle.cpp +++ b/src/mbgl/renderer/painter_circle.cpp @@ -1,12 +1,14 @@ #include <mbgl/renderer/painter.hpp> #include <mbgl/renderer/circle_bucket.hpp> -#include <mbgl/layer/circle_layer.hpp> -#include <mbgl/layer/circle_layer_impl.hpp> +#include <mbgl/style/layers/circle_layer.hpp> +#include <mbgl/style/layers/circle_layer_impl.hpp> #include <mbgl/shader/circle_shader.hpp> -using namespace mbgl; +namespace mbgl { + +using namespace style; void Painter::renderCircle(CircleBucket& bucket, const CircleLayer& layer, @@ -43,3 +45,5 @@ void Painter::renderCircle(CircleBucket& bucket, bucket.drawCircles(*circleShader, store); } + +} diff --git a/src/mbgl/renderer/painter_clipping.cpp b/src/mbgl/renderer/painter_clipping.cpp index f0fd498267..e6ce1a040e 100644 --- a/src/mbgl/renderer/painter_clipping.cpp +++ b/src/mbgl/renderer/painter_clipping.cpp @@ -1,5 +1,5 @@ #include <mbgl/renderer/painter.hpp> -#include <mbgl/source/source.hpp> +#include <mbgl/style/source.hpp> #include <mbgl/shader/plain_shader.hpp> #include <mbgl/util/clip_id.hpp> #include <mbgl/util/string.hpp> diff --git a/src/mbgl/renderer/painter_fill.cpp b/src/mbgl/renderer/painter_fill.cpp index b499d20da3..b89686c815 100644 --- a/src/mbgl/renderer/painter_fill.cpp +++ b/src/mbgl/renderer/painter_fill.cpp @@ -1,14 +1,16 @@ #include <mbgl/renderer/painter.hpp> #include <mbgl/renderer/fill_bucket.hpp> -#include <mbgl/layer/fill_layer.hpp> -#include <mbgl/layer/fill_layer_impl.hpp> +#include <mbgl/style/layers/fill_layer.hpp> +#include <mbgl/style/layers/fill_layer_impl.hpp> #include <mbgl/sprite/sprite_atlas.hpp> #include <mbgl/shader/outline_shader.hpp> #include <mbgl/shader/outlinepattern_shader.hpp> #include <mbgl/shader/pattern_shader.hpp> #include <mbgl/shader/plain_shader.hpp> -using namespace mbgl; +namespace mbgl { + +using namespace style; void Painter::renderFill(FillBucket& bucket, const FillLayer& layer, @@ -195,3 +197,5 @@ void Painter::renderFill(FillBucket& bucket, bucket.drawVertices(*outlineShader, store); } } + +} diff --git a/src/mbgl/renderer/painter_line.cpp b/src/mbgl/renderer/painter_line.cpp index 3cf1ad4147..26041a8165 100644 --- a/src/mbgl/renderer/painter_line.cpp +++ b/src/mbgl/renderer/painter_line.cpp @@ -1,7 +1,7 @@ #include <mbgl/renderer/painter.hpp> #include <mbgl/renderer/line_bucket.hpp> -#include <mbgl/layer/line_layer.hpp> -#include <mbgl/layer/line_layer_impl.hpp> +#include <mbgl/style/layers/line_layer.hpp> +#include <mbgl/style/layers/line_layer_impl.hpp> #include <mbgl/shader/line_shader.hpp> #include <mbgl/shader/linesdf_shader.hpp> #include <mbgl/shader/linepattern_shader.hpp> @@ -9,7 +9,9 @@ #include <mbgl/geometry/line_atlas.hpp> #include <mbgl/util/mat2.hpp> -using namespace mbgl; +namespace mbgl { + +using namespace style; void Painter::renderLine(LineBucket& bucket, const LineLayer& layer, @@ -161,3 +163,5 @@ void Painter::renderLine(LineBucket& bucket, bucket.drawLines(*lineShader, store); } } + +} diff --git a/src/mbgl/renderer/painter_raster.cpp b/src/mbgl/renderer/painter_raster.cpp index 511ac96387..cce71e8ce2 100644 --- a/src/mbgl/renderer/painter_raster.cpp +++ b/src/mbgl/renderer/painter_raster.cpp @@ -1,11 +1,13 @@ #include <mbgl/renderer/painter.hpp> #include <mbgl/gl/gl.hpp> #include <mbgl/renderer/raster_bucket.hpp> -#include <mbgl/layer/raster_layer.hpp> -#include <mbgl/layer/raster_layer_impl.hpp> +#include <mbgl/style/layers/raster_layer.hpp> +#include <mbgl/style/layers/raster_layer_impl.hpp> #include <mbgl/shader/raster_shader.hpp> -using namespace mbgl; +namespace mbgl { + +using namespace style; void Painter::renderRaster(RasterBucket& bucket, const RasterLayer& layer, @@ -66,3 +68,5 @@ std::array<float, 3> Painter::spinWeights(float spin) { }}; return spin_weights; } + +} diff --git a/src/mbgl/renderer/painter_symbol.cpp b/src/mbgl/renderer/painter_symbol.cpp index 9774568074..3c453242ae 100644 --- a/src/mbgl/renderer/painter_symbol.cpp +++ b/src/mbgl/renderer/painter_symbol.cpp @@ -1,6 +1,7 @@ #include <mbgl/renderer/painter.hpp> #include <mbgl/renderer/symbol_bucket.hpp> -#include <mbgl/layer/symbol_layer.hpp> +#include <mbgl/style/layers/symbol_layer.hpp> +#include <mbgl/style/layers/symbol_layer_impl.hpp> #include <mbgl/geometry/glyph_atlas.hpp> #include <mbgl/sprite/sprite_atlas.hpp> #include <mbgl/shader/sdf_shader.hpp> @@ -10,7 +11,9 @@ #include <cmath> -using namespace mbgl; +namespace mbgl { + +using namespace style; void Painter::renderSDF(SymbolBucket &bucket, const UnwrappedTileID &tileID, @@ -257,3 +260,5 @@ void Painter::renderSymbol(SymbolBucket& bucket, config.activeTexture = GL_TEXTURE0; } + +} diff --git a/src/mbgl/renderer/raster_bucket.cpp b/src/mbgl/renderer/raster_bucket.cpp index b16d7f8161..39f8dacd92 100644 --- a/src/mbgl/renderer/raster_bucket.cpp +++ b/src/mbgl/renderer/raster_bucket.cpp @@ -1,9 +1,11 @@ #include <mbgl/renderer/raster_bucket.hpp> -#include <mbgl/layer/raster_layer.hpp> +#include <mbgl/style/layers/raster_layer.hpp> #include <mbgl/shader/raster_shader.hpp> #include <mbgl/renderer/painter.hpp> -using namespace mbgl; +namespace mbgl { + +using namespace style; RasterBucket::RasterBucket(gl::TexturePool& texturePool) : raster(texturePool) { @@ -40,3 +42,5 @@ bool RasterBucket::hasData() const { bool RasterBucket::needsClipping() const { return false; } + +} diff --git a/src/mbgl/renderer/raster_bucket.hpp b/src/mbgl/renderer/raster_bucket.hpp index 9125ef2047..93331755fb 100644 --- a/src/mbgl/renderer/raster_bucket.hpp +++ b/src/mbgl/renderer/raster_bucket.hpp @@ -14,7 +14,7 @@ public: RasterBucket(gl::TexturePool&); void upload(gl::ObjectStore&) override; - void render(Painter&, const Layer&, const UnwrappedTileID&, const mat4&) override; + void render(Painter&, const style::Layer&, const UnwrappedTileID&, const mat4&) override; bool hasData() const override; bool needsClipping() const override; diff --git a/src/mbgl/renderer/symbol_bucket.cpp b/src/mbgl/renderer/symbol_bucket.cpp index 67c8468ecd..f4e55432c1 100644 --- a/src/mbgl/renderer/symbol_bucket.cpp +++ b/src/mbgl/renderer/symbol_bucket.cpp @@ -1,6 +1,6 @@ #include <mbgl/renderer/symbol_bucket.hpp> #include <mbgl/style/filter_evaluator.hpp> -#include <mbgl/layer/symbol_layer.hpp> +#include <mbgl/style/layers/symbol_layer.hpp> #include <mbgl/tile/geometry_tile.hpp> #include <mbgl/sprite/sprite_image.hpp> #include <mbgl/sprite/sprite_store.hpp> @@ -31,6 +31,8 @@ namespace mbgl { +using namespace style; + SymbolInstance::SymbolInstance(Anchor& anchor, const GeometryCoordinates& line, const Shaping& shapedText, const PositionedIcon& shapedIcon, const SymbolLayoutProperties& layout, const bool addToBuffers, const uint32_t index_, diff --git a/src/mbgl/renderer/symbol_bucket.hpp b/src/mbgl/renderer/symbol_bucket.hpp index b19a86b275..314d44bdee 100644 --- a/src/mbgl/renderer/symbol_bucket.hpp +++ b/src/mbgl/renderer/symbol_bucket.hpp @@ -13,7 +13,7 @@ #include <mbgl/text/shaping.hpp> #include <mbgl/text/quads.hpp> #include <mbgl/style/filter.hpp> -#include <mbgl/layer/symbol_layer_impl.hpp> +#include <mbgl/style/layers/symbol_layer_properties.hpp> #include <memory> #include <map> @@ -46,7 +46,7 @@ class SymbolInstance { public: explicit SymbolInstance(Anchor& anchor, const GeometryCoordinates& line, const Shaping& shapedText, const PositionedIcon& shapedIcon, - const SymbolLayoutProperties& layout, const bool inside, const uint32_t index, + const style::SymbolLayoutProperties&, const bool inside, const uint32_t index, const float textBoxScale, const float textPadding, const float textAlongLine, const float iconBoxScale, const float iconPadding, const float iconAlongLine, const GlyphPositions& face, const IndexedSubfeature& indexedfeature); @@ -70,7 +70,7 @@ public: ~SymbolBucket() override; void upload(gl::ObjectStore&) override; - void render(Painter&, const Layer&, const UnwrappedTileID&, const mat4&) override; + void render(Painter&, const style::Layer&, const UnwrappedTileID&, const mat4&) override; bool hasData() const override; bool hasTextData() const; bool hasIconData() const; @@ -87,7 +87,7 @@ public: void drawIcons(IconShader&, gl::ObjectStore&); void drawCollisionBoxes(CollisionBoxShader&, gl::ObjectStore&); - void parseFeatures(const GeometryTileLayer&, const Filter&); + void parseFeatures(const GeometryTileLayer&, const style::Filter&); bool needsDependencies(GlyphStore&, SpriteStore&); void placeFeatures(CollisionTile&) override; @@ -109,7 +109,7 @@ private: const bool keepUpright, const bool alongLine, const float placementAngle); public: - SymbolLayoutProperties layout; + style::SymbolLayoutProperties layout; float iconMaxSize = 1.0f; float textMaxSize = 16.0f; diff --git a/src/mbgl/style/style_bucket_parameters.cpp b/src/mbgl/style/bucket_parameters.cpp index 0b4b2affcd..f3367d57e1 100644 --- a/src/mbgl/style/style_bucket_parameters.cpp +++ b/src/mbgl/style/bucket_parameters.cpp @@ -1,10 +1,11 @@ -#include <mbgl/style/style_bucket_parameters.hpp> +#include <mbgl/style/bucket_parameters.hpp> #include <mbgl/style/filter_evaluator.hpp> #include <mbgl/tile/geometry_tile.hpp> namespace mbgl { +namespace style { -void StyleBucketParameters::eachFilteredFeature(const Filter& filter, +void BucketParameters::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++) { @@ -18,4 +19,5 @@ void StyleBucketParameters::eachFilteredFeature(const Filter& filter, } } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/style_bucket_parameters.hpp b/src/mbgl/style/bucket_parameters.hpp index 17639afae7..f85e1e17ef 100644 --- a/src/mbgl/style/style_bucket_parameters.hpp +++ b/src/mbgl/style/bucket_parameters.hpp @@ -18,9 +18,11 @@ class GlyphStore; class CollisionTile; class FeatureIndex; -class StyleBucketParameters { +namespace style { + +class BucketParameters { public: - StyleBucketParameters(const OverscaledTileID& tileID_, + BucketParameters(const OverscaledTileID& tileID_, const GeometryTileLayer& layer_, const std::atomic<bool>& obsolete_, uintptr_t tileUID_, @@ -59,4 +61,5 @@ public: const MapMode mode; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/calculation_parameters.hpp b/src/mbgl/style/calculation_parameters.hpp new file mode 100644 index 0000000000..2afd7c4b34 --- /dev/null +++ b/src/mbgl/style/calculation_parameters.hpp @@ -0,0 +1,30 @@ +#pragma once + +#include <mbgl/map/zoom_history.hpp> +#include <mbgl/util/chrono.hpp> + +namespace mbgl { +namespace style { + +class CalculationParameters { +public: + explicit CalculationParameters(float z_) + : z(z_) {} + + CalculationParameters(float z_, + const TimePoint& now_, + const ZoomHistory& zoomHistory_, + const Duration& defaultFadeDuration_) + : z(z_), + now(now_), + zoomHistory(zoomHistory_), + defaultFadeDuration(defaultFadeDuration_) {} + + float z; + TimePoint now; + ZoomHistory zoomHistory; + Duration defaultFadeDuration; +}; + +} // namespace style +} // namespace mbgl diff --git a/src/mbgl/style/cascade_parameters.hpp b/src/mbgl/style/cascade_parameters.hpp new file mode 100644 index 0000000000..4ad6da2ce3 --- /dev/null +++ b/src/mbgl/style/cascade_parameters.hpp @@ -0,0 +1,22 @@ +#pragma once + +#include <mbgl/util/chrono.hpp> +#include <mbgl/style/class_dictionary.hpp> +#include <mbgl/style/transition_options.hpp> + +#include <vector> + +namespace mbgl { +namespace style { + +class TransitionOptions; + +class CascadeParameters { +public: + std::vector<ClassID> classes; + TimePoint now; + TransitionOptions transition; +}; + +} // namespace style +} // namespace mbgl diff --git a/src/mbgl/style/class_dictionary.cpp b/src/mbgl/style/class_dictionary.cpp index 53ea5c1484..ec06ee7d9d 100644 --- a/src/mbgl/style/class_dictionary.cpp +++ b/src/mbgl/style/class_dictionary.cpp @@ -3,6 +3,7 @@ #include <pthread.h> namespace mbgl { +namespace style { ClassDictionary::ClassDictionary() {} @@ -46,4 +47,5 @@ ClassID ClassDictionary::normalize(ClassID id) { } } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/class_dictionary.hpp b/src/mbgl/style/class_dictionary.hpp index 703e27b438..c95773d7c3 100644 --- a/src/mbgl/style/class_dictionary.hpp +++ b/src/mbgl/style/class_dictionary.hpp @@ -5,6 +5,7 @@ #include <unordered_map> namespace mbgl { +namespace style { enum class ClassID : uint32_t { Fallback = 0, // These values are from the fallback properties @@ -31,4 +32,5 @@ private: uint32_t offset = 0; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/filter_evaluator.hpp b/src/mbgl/style/filter_evaluator.hpp index b607a0c658..e03beaa4d0 100644 --- a/src/mbgl/style/filter_evaluator.hpp +++ b/src/mbgl/style/filter_evaluator.hpp @@ -6,6 +6,7 @@ #include <type_traits> namespace mbgl { +namespace style { class FilterEvaluator { public: @@ -159,3 +160,4 @@ private: }; } // namespace mbgl +} // namespace mbgl diff --git a/src/mbgl/layer/layer.cpp b/src/mbgl/style/layer.cpp index c26eb9a723..342699a2c9 100644 --- a/src/mbgl/layer/layer.cpp +++ b/src/mbgl/style/layer.cpp @@ -1,7 +1,8 @@ #include <mbgl/style/layer.hpp> -#include <mbgl/layer/layer_impl.hpp> +#include <mbgl/style/layer_impl.hpp> namespace mbgl { +namespace style { Layer::Layer(Type type_, std::unique_ptr<Impl> baseImpl_) : baseImpl(std::move(baseImpl_)), type(type_) { @@ -45,4 +46,5 @@ std::unique_ptr<Layer> Layer::copy(const std::string& id, return result; } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/layer_impl.cpp b/src/mbgl/style/layer_impl.cpp index 315a1cb1b1..74cc80d253 100644 --- a/src/mbgl/layer/layer_impl.cpp +++ b/src/mbgl/style/layer_impl.cpp @@ -1,6 +1,7 @@ -#include <mbgl/layer/layer_impl.hpp> +#include <mbgl/style/layer_impl.hpp> namespace mbgl { +namespace style { const std::string& Layer::Impl::bucketName() const { return ref.empty() ? id : ref; @@ -14,4 +15,5 @@ bool Layer::Impl::needsRendering() const { return passes != RenderPass::None && visibility != VisibilityType::None; } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/layer_impl.hpp b/src/mbgl/style/layer_impl.hpp index 3d6b5cccfd..dcd5d9906b 100644 --- a/src/mbgl/layer/layer_impl.hpp +++ b/src/mbgl/style/layer_impl.hpp @@ -14,11 +14,14 @@ namespace mbgl { -class StyleCascadeParameters; -class StyleCalculationParameters; -class StyleBucketParameters; class Bucket; +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 * of the code, but hidden from the public API. Like `Layer`, it is an abstract base class, with derived classes for @@ -44,13 +47,13 @@ public: const std::string& bucketName() const; // Partially evaluate paint properties based on a set of classes. - virtual void cascade(const StyleCascadeParameters&) = 0; + virtual void cascade(const CascadeParameters&) = 0; // Fully evaluate cascaded paint properties based on a zoom level. // Returns true if any paint properties have active transitions. - virtual bool recalculate(const StyleCalculationParameters&) = 0; + virtual bool recalculate(const CalculationParameters&) = 0; - virtual std::unique_ptr<Bucket> createBucket(StyleBucketParameters&) const = 0; + virtual std::unique_ptr<Bucket> createBucket(BucketParameters&) const = 0; // Checks whether this layer needs to be rendered in the given render pass. bool hasRenderPass(RenderPass) const; @@ -85,4 +88,5 @@ protected: RenderPass passes = RenderPass::None; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/background_layer.cpp b/src/mbgl/style/layers/background_layer.cpp index 36cf6be07c..aeb4067503 100644 --- a/src/mbgl/layer/background_layer.cpp +++ b/src/mbgl/style/layers/background_layer.cpp @@ -1,9 +1,10 @@ // This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`. -#include <mbgl/layer/background_layer.hpp> -#include <mbgl/layer/background_layer_impl.hpp> +#include <mbgl/style/layers/background_layer.hpp> +#include <mbgl/style/layers/background_layer_impl.hpp> namespace mbgl { +namespace style { BackgroundLayer::BackgroundLayer(const std::string& layerID) : Layer(Type::Background, std::make_unique<Impl>()) @@ -52,4 +53,5 @@ void BackgroundLayer::setBackgroundOpacity(PropertyValue<float> value) { impl->paint.backgroundOpacity.set(value); } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/background_layer_impl.cpp b/src/mbgl/style/layers/background_layer_impl.cpp index 626c8fc805..0c09c5d158 100644 --- a/src/mbgl/layer/background_layer_impl.cpp +++ b/src/mbgl/style/layers/background_layer_impl.cpp @@ -1,17 +1,18 @@ -#include <mbgl/layer/background_layer_impl.hpp> +#include <mbgl/style/layers/background_layer_impl.hpp> #include <mbgl/renderer/bucket.hpp> namespace mbgl { +namespace style { void BackgroundLayer::Impl::parsePaints(const JSValue& layer) { paint.parse(layer); } -void BackgroundLayer::Impl::cascade(const StyleCascadeParameters& parameters) { +void BackgroundLayer::Impl::cascade(const CascadeParameters& parameters) { paint.cascade(parameters); } -bool BackgroundLayer::Impl::recalculate(const StyleCalculationParameters& parameters) { +bool BackgroundLayer::Impl::recalculate(const CalculationParameters& parameters) { bool hasTransitions = paint.recalculate(parameters); passes = paint.backgroundOpacity > 0 ? RenderPass::Translucent : RenderPass::None; @@ -19,8 +20,9 @@ bool BackgroundLayer::Impl::recalculate(const StyleCalculationParameters& parame return hasTransitions; } -std::unique_ptr<Bucket> BackgroundLayer::Impl::createBucket(StyleBucketParameters&) const { +std::unique_ptr<Bucket> BackgroundLayer::Impl::createBucket(BucketParameters&) const { return nullptr; } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/layers/background_layer_impl.hpp b/src/mbgl/style/layers/background_layer_impl.hpp new file mode 100644 index 0000000000..19e2a062a4 --- /dev/null +++ b/src/mbgl/style/layers/background_layer_impl.hpp @@ -0,0 +1,26 @@ +#pragma once + +#include <mbgl/style/layer_impl.hpp> +#include <mbgl/style/layers/background_layer.hpp> +#include <mbgl/style/layers/background_layer_properties.hpp> + +namespace mbgl { +namespace style { + +class BackgroundLayer::Impl : public Layer::Impl { +public: + std::unique_ptr<Layer> clone() const override; + + void parseLayout(const JSValue&) override {}; + void parsePaints(const JSValue&) override; + + void cascade(const CascadeParameters&) override; + bool recalculate(const CalculationParameters&) override; + + std::unique_ptr<Bucket> createBucket(BucketParameters&) const override; + + BackgroundPaintProperties paint; +}; + +} // namespace style +} // namespace mbgl diff --git a/src/mbgl/layer/background_layer_properties.cpp b/src/mbgl/style/layers/background_layer_properties.cpp index d866df7eee..a20cedf12c 100644 --- a/src/mbgl/layer/background_layer_properties.cpp +++ b/src/mbgl/style/layers/background_layer_properties.cpp @@ -1,8 +1,9 @@ // This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`. -#include <mbgl/layer/background_layer_properties.hpp> +#include <mbgl/style/layers/background_layer_properties.hpp> namespace mbgl { +namespace style { void BackgroundPaintProperties::parse(const JSValue& value) { backgroundColor.parse("background-color", value); @@ -10,13 +11,13 @@ void BackgroundPaintProperties::parse(const JSValue& value) { backgroundOpacity.parse("background-opacity", value); } -void BackgroundPaintProperties::cascade(const StyleCascadeParameters& parameters) { +void BackgroundPaintProperties::cascade(const CascadeParameters& parameters) { backgroundColor.cascade(parameters); backgroundPattern.cascade(parameters); backgroundOpacity.cascade(parameters); } -bool BackgroundPaintProperties::recalculate(const StyleCalculationParameters& parameters) { +bool BackgroundPaintProperties::recalculate(const CalculationParameters& parameters) { bool hasTransitions = false; hasTransitions |= backgroundColor.calculate(parameters); @@ -26,4 +27,5 @@ bool BackgroundPaintProperties::recalculate(const StyleCalculationParameters& pa return hasTransitions; } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/background_layer_properties.hpp b/src/mbgl/style/layers/background_layer_properties.hpp index 20db9b22fb..a1a1a3a5a7 100644 --- a/src/mbgl/layer/background_layer_properties.hpp +++ b/src/mbgl/style/layers/background_layer_properties.hpp @@ -7,19 +7,21 @@ #include <mbgl/util/rapidjson.hpp> namespace mbgl { +namespace style { -class StyleCascadeParameters; -class StyleCalculationParameters; +class CascadeParameters; +class CalculationParameters; class BackgroundPaintProperties { public: void parse(const JSValue&); - void cascade(const StyleCascadeParameters&); - bool recalculate(const StyleCalculationParameters&); + void cascade(const CascadeParameters&); + bool recalculate(const CalculationParameters&); PaintProperty<Color> backgroundColor { {{ 0, 0, 0, 1 }} }; PaintProperty<std::string, CrossFadedPropertyEvaluator> backgroundPattern { "" }; PaintProperty<float> backgroundOpacity { 1 }; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/circle_layer.cpp b/src/mbgl/style/layers/circle_layer.cpp index efc0e9488d..bdfbf629e6 100644 --- a/src/mbgl/layer/circle_layer.cpp +++ b/src/mbgl/style/layers/circle_layer.cpp @@ -1,9 +1,10 @@ // This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`. -#include <mbgl/layer/circle_layer.hpp> -#include <mbgl/layer/circle_layer_impl.hpp> +#include <mbgl/style/layers/circle_layer.hpp> +#include <mbgl/style/layers/circle_layer_impl.hpp> namespace mbgl { +namespace style { CircleLayer::CircleLayer(const std::string& layerID) : Layer(Type::Circle, std::make_unique<Impl>()) @@ -100,4 +101,5 @@ void CircleLayer::setCircleTranslateAnchor(PropertyValue<TranslateAnchorType> va impl->paint.circleTranslateAnchor.set(value); } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/circle_layer_impl.cpp b/src/mbgl/style/layers/circle_layer_impl.cpp index b1ba778cd6..c2efac5cef 100644 --- a/src/mbgl/layer/circle_layer_impl.cpp +++ b/src/mbgl/style/layers/circle_layer_impl.cpp @@ -1,21 +1,22 @@ -#include <mbgl/layer/circle_layer_impl.hpp> -#include <mbgl/style/style_bucket_parameters.hpp> +#include <mbgl/style/layers/circle_layer_impl.hpp> +#include <mbgl/style/bucket_parameters.hpp> #include <mbgl/renderer/circle_bucket.hpp> #include <mbgl/geometry/feature_index.hpp> #include <mbgl/util/math.hpp> #include <mbgl/util/intersection_tests.hpp> namespace mbgl { +namespace style { void CircleLayer::Impl::parsePaints(const JSValue& layer) { paint.parse(layer); } -void CircleLayer::Impl::cascade(const StyleCascadeParameters& parameters) { +void CircleLayer::Impl::cascade(const CascadeParameters& parameters) { paint.cascade(parameters); } -bool CircleLayer::Impl::recalculate(const StyleCalculationParameters& parameters) { +bool CircleLayer::Impl::recalculate(const CalculationParameters& parameters) { bool hasTransitions = paint.recalculate(parameters); passes = (paint.circleRadius > 0 && paint.circleColor.value[3] > 0 && paint.circleOpacity > 0) @@ -24,7 +25,7 @@ bool CircleLayer::Impl::recalculate(const StyleCalculationParameters& parameters return hasTransitions; } -std::unique_ptr<Bucket> CircleLayer::Impl::createBucket(StyleBucketParameters& parameters) const { +std::unique_ptr<Bucket> CircleLayer::Impl::createBucket(BucketParameters& parameters) const { auto bucket = std::make_unique<CircleBucket>(parameters.mode); auto& name = bucketName(); @@ -57,4 +58,5 @@ bool CircleLayer::Impl::queryIntersectsGeometry( translatedQueryGeometry.value_or(queryGeometry), geometry, circleRadius); } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/circle_layer_impl.hpp b/src/mbgl/style/layers/circle_layer_impl.hpp index 1cb19a6205..463f3ca18d 100644 --- a/src/mbgl/layer/circle_layer_impl.hpp +++ b/src/mbgl/style/layers/circle_layer_impl.hpp @@ -1,10 +1,11 @@ #pragma once -#include <mbgl/layer/layer_impl.hpp> -#include <mbgl/layer/circle_layer.hpp> -#include <mbgl/layer/circle_layer_properties.hpp> +#include <mbgl/style/layer_impl.hpp> +#include <mbgl/style/layers/circle_layer.hpp> +#include <mbgl/style/layers/circle_layer_properties.hpp> namespace mbgl { +namespace style { class CircleLayer::Impl : public Layer::Impl { public: @@ -13,10 +14,10 @@ public: void parseLayout(const JSValue&) override {}; void parsePaints(const JSValue&) override; - void cascade(const StyleCascadeParameters&) override; - bool recalculate(const StyleCalculationParameters&) override; + void cascade(const CascadeParameters&) override; + bool recalculate(const CalculationParameters&) override; - std::unique_ptr<Bucket> createBucket(StyleBucketParameters&) const override; + std::unique_ptr<Bucket> createBucket(BucketParameters&) const override; float getQueryRadius() const override; bool queryIntersectsGeometry( @@ -28,4 +29,5 @@ public: CirclePaintProperties paint; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/circle_layer_properties.cpp b/src/mbgl/style/layers/circle_layer_properties.cpp index 48d99b579e..b21df1e2d0 100644 --- a/src/mbgl/layer/circle_layer_properties.cpp +++ b/src/mbgl/style/layers/circle_layer_properties.cpp @@ -1,8 +1,9 @@ // This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`. -#include <mbgl/layer/circle_layer_properties.hpp> +#include <mbgl/style/layers/circle_layer_properties.hpp> namespace mbgl { +namespace style { void CirclePaintProperties::parse(const JSValue& value) { circleRadius.parse("circle-radius", value); @@ -13,7 +14,7 @@ void CirclePaintProperties::parse(const JSValue& value) { circleTranslateAnchor.parse("circle-translate-anchor", value); } -void CirclePaintProperties::cascade(const StyleCascadeParameters& parameters) { +void CirclePaintProperties::cascade(const CascadeParameters& parameters) { circleRadius.cascade(parameters); circleColor.cascade(parameters); circleBlur.cascade(parameters); @@ -22,7 +23,7 @@ void CirclePaintProperties::cascade(const StyleCascadeParameters& parameters) { circleTranslateAnchor.cascade(parameters); } -bool CirclePaintProperties::recalculate(const StyleCalculationParameters& parameters) { +bool CirclePaintProperties::recalculate(const CalculationParameters& parameters) { bool hasTransitions = false; hasTransitions |= circleRadius.calculate(parameters); @@ -35,4 +36,5 @@ bool CirclePaintProperties::recalculate(const StyleCalculationParameters& parame return hasTransitions; } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/circle_layer_properties.hpp b/src/mbgl/style/layers/circle_layer_properties.hpp index a88db27605..956e423c45 100644 --- a/src/mbgl/layer/circle_layer_properties.hpp +++ b/src/mbgl/style/layers/circle_layer_properties.hpp @@ -7,15 +7,16 @@ #include <mbgl/util/rapidjson.hpp> namespace mbgl { +namespace style { -class StyleCascadeParameters; -class StyleCalculationParameters; +class CascadeParameters; +class CalculationParameters; class CirclePaintProperties { public: void parse(const JSValue&); - void cascade(const StyleCascadeParameters&); - bool recalculate(const StyleCalculationParameters&); + void cascade(const CascadeParameters&); + bool recalculate(const CalculationParameters&); PaintProperty<float> circleRadius { 5 }; PaintProperty<Color> circleColor { {{ 0, 0, 0, 1 }} }; @@ -25,4 +26,5 @@ public: PaintProperty<TranslateAnchorType> circleTranslateAnchor { TranslateAnchorType::Map }; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/custom_layer.cpp b/src/mbgl/style/layers/custom_layer.cpp index a33176e7f9..3407a7f5a5 100644 --- a/src/mbgl/layer/custom_layer.cpp +++ b/src/mbgl/style/layers/custom_layer.cpp @@ -1,7 +1,8 @@ -#include <mbgl/layer/custom_layer.hpp> -#include <mbgl/layer/custom_layer_impl.hpp> +#include <mbgl/style/layers/custom_layer.hpp> +#include <mbgl/style/layers/custom_layer_impl.hpp> namespace mbgl { +namespace style { CustomLayer::CustomLayer(const std::string& layerID, CustomLayerInitializeFunction init, @@ -19,4 +20,5 @@ CustomLayer::CustomLayer(const Impl& other) CustomLayer::~CustomLayer() = default; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/custom_layer_impl.cpp b/src/mbgl/style/layers/custom_layer_impl.cpp index 8a08c804ed..214d4ce663 100644 --- a/src/mbgl/layer/custom_layer_impl.cpp +++ b/src/mbgl/style/layers/custom_layer_impl.cpp @@ -1,8 +1,9 @@ -#include <mbgl/layer/custom_layer_impl.hpp> +#include <mbgl/style/layers/custom_layer_impl.hpp> #include <mbgl/renderer/bucket.hpp> #include <mbgl/map/transform_state.hpp> namespace mbgl { +namespace style { CustomLayer::Impl::Impl(const std::string& id_, CustomLayerInitializeFunction initializeFn_, @@ -54,13 +55,14 @@ void CustomLayer::Impl::render(const TransformState& state) const { renderFn(context, parameters); } -bool CustomLayer::Impl::recalculate(const StyleCalculationParameters&) { +bool CustomLayer::Impl::recalculate(const CalculationParameters&) { passes = RenderPass::Translucent; return false; } -std::unique_ptr<Bucket> CustomLayer::Impl::createBucket(StyleBucketParameters&) const { +std::unique_ptr<Bucket> CustomLayer::Impl::createBucket(BucketParameters&) const { return nullptr; } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/custom_layer_impl.hpp b/src/mbgl/style/layers/custom_layer_impl.hpp index 09709a2f9d..00e576b6a3 100644 --- a/src/mbgl/layer/custom_layer_impl.hpp +++ b/src/mbgl/style/layers/custom_layer_impl.hpp @@ -1,12 +1,14 @@ #pragma once -#include <mbgl/layer/layer_impl.hpp> -#include <mbgl/layer/custom_layer.hpp> +#include <mbgl/style/layer_impl.hpp> +#include <mbgl/style/layers/custom_layer.hpp> namespace mbgl { class TransformState; +namespace style { + class CustomLayer::Impl : public Layer::Impl { public: Impl(const std::string& id, @@ -27,10 +29,10 @@ private: void parseLayout(const JSValue&) final {} void parsePaints(const JSValue&) final {} - void cascade(const StyleCascadeParameters&) final {} - bool recalculate(const StyleCalculationParameters&) final; + void cascade(const CascadeParameters&) final {} + bool recalculate(const CalculationParameters&) final; - std::unique_ptr<Bucket> createBucket(StyleBucketParameters&) const final; + std::unique_ptr<Bucket> createBucket(BucketParameters&) const final; CustomLayerInitializeFunction initializeFn = nullptr; CustomLayerRenderFunction renderFn = nullptr; @@ -38,4 +40,5 @@ private: void* context = nullptr; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/fill_layer.cpp b/src/mbgl/style/layers/fill_layer.cpp index 77efaa61aa..1deaabb5ef 100644 --- a/src/mbgl/layer/fill_layer.cpp +++ b/src/mbgl/style/layers/fill_layer.cpp @@ -1,9 +1,10 @@ // This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`. -#include <mbgl/layer/fill_layer.hpp> -#include <mbgl/layer/fill_layer_impl.hpp> +#include <mbgl/style/layers/fill_layer.hpp> +#include <mbgl/style/layers/fill_layer_impl.hpp> namespace mbgl { +namespace style { FillLayer::FillLayer(const std::string& layerID) : Layer(Type::Fill, std::make_unique<Impl>()) @@ -108,4 +109,5 @@ void FillLayer::setFillPattern(PropertyValue<std::string> value) { impl->paint.fillPattern.set(value); } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/fill_layer_impl.cpp b/src/mbgl/style/layers/fill_layer_impl.cpp index 21f482922d..c183617482 100644 --- a/src/mbgl/layer/fill_layer_impl.cpp +++ b/src/mbgl/style/layers/fill_layer_impl.cpp @@ -1,21 +1,22 @@ -#include <mbgl/layer/fill_layer_impl.hpp> -#include <mbgl/style/style_bucket_parameters.hpp> +#include <mbgl/style/layers/fill_layer_impl.hpp> +#include <mbgl/style/bucket_parameters.hpp> #include <mbgl/renderer/fill_bucket.hpp> #include <mbgl/geometry/feature_index.hpp> #include <mbgl/util/math.hpp> #include <mbgl/util/intersection_tests.hpp> namespace mbgl { +namespace style { void FillLayer::Impl::parsePaints(const JSValue& layer) { paint.parse(layer); } -void FillLayer::Impl::cascade(const StyleCascadeParameters& parameters) { +void FillLayer::Impl::cascade(const CascadeParameters& parameters) { paint.cascade(parameters); } -bool FillLayer::Impl::recalculate(const StyleCalculationParameters& parameters) { +bool FillLayer::Impl::recalculate(const CalculationParameters& parameters) { bool hasTransitions = paint.recalculate(parameters); passes = RenderPass::None; @@ -33,7 +34,7 @@ bool FillLayer::Impl::recalculate(const StyleCalculationParameters& parameters) return hasTransitions; } -std::unique_ptr<Bucket> FillLayer::Impl::createBucket(StyleBucketParameters& parameters) const { +std::unique_ptr<Bucket> FillLayer::Impl::createBucket(BucketParameters& parameters) const { auto bucket = std::make_unique<FillBucket>(); auto& name = bucketName(); @@ -63,4 +64,5 @@ bool FillLayer::Impl::queryIntersectsGeometry( return util::multiPolygonIntersectsMultiPolygon(translatedQueryGeometry.value_or(queryGeometry), geometry); } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/fill_layer_impl.hpp b/src/mbgl/style/layers/fill_layer_impl.hpp index 2af0d6491d..a37dd76ace 100644 --- a/src/mbgl/layer/fill_layer_impl.hpp +++ b/src/mbgl/style/layers/fill_layer_impl.hpp @@ -1,10 +1,11 @@ #pragma once -#include <mbgl/layer/layer_impl.hpp> -#include <mbgl/layer/fill_layer.hpp> -#include <mbgl/layer/fill_layer_properties.hpp> +#include <mbgl/style/layer_impl.hpp> +#include <mbgl/style/layers/fill_layer.hpp> +#include <mbgl/style/layers/fill_layer_properties.hpp> namespace mbgl { +namespace style { class FillLayer::Impl : public Layer::Impl { public: @@ -13,10 +14,10 @@ public: void parseLayout(const JSValue&) override {}; void parsePaints(const JSValue&) override; - void cascade(const StyleCascadeParameters&) override; - bool recalculate(const StyleCalculationParameters&) override; + void cascade(const CascadeParameters&) override; + bool recalculate(const CalculationParameters&) override; - std::unique_ptr<Bucket> createBucket(StyleBucketParameters&) const override; + std::unique_ptr<Bucket> createBucket(BucketParameters&) const override; float getQueryRadius() const override; bool queryIntersectsGeometry( @@ -28,4 +29,5 @@ public: FillPaintProperties paint; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/fill_layer_properties.cpp b/src/mbgl/style/layers/fill_layer_properties.cpp index e0d4f10bc9..a4714689f9 100644 --- a/src/mbgl/layer/fill_layer_properties.cpp +++ b/src/mbgl/style/layers/fill_layer_properties.cpp @@ -1,8 +1,9 @@ // This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`. -#include <mbgl/layer/fill_layer_properties.hpp> +#include <mbgl/style/layers/fill_layer_properties.hpp> namespace mbgl { +namespace style { void FillPaintProperties::parse(const JSValue& value) { fillAntialias.parse("fill-antialias", value); @@ -14,7 +15,7 @@ void FillPaintProperties::parse(const JSValue& value) { fillPattern.parse("fill-pattern", value); } -void FillPaintProperties::cascade(const StyleCascadeParameters& parameters) { +void FillPaintProperties::cascade(const CascadeParameters& parameters) { fillAntialias.cascade(parameters); fillOpacity.cascade(parameters); fillColor.cascade(parameters); @@ -24,7 +25,7 @@ void FillPaintProperties::cascade(const StyleCascadeParameters& parameters) { fillPattern.cascade(parameters); } -bool FillPaintProperties::recalculate(const StyleCalculationParameters& parameters) { +bool FillPaintProperties::recalculate(const CalculationParameters& parameters) { bool hasTransitions = false; hasTransitions |= fillAntialias.calculate(parameters); @@ -38,4 +39,5 @@ bool FillPaintProperties::recalculate(const StyleCalculationParameters& paramete return hasTransitions; } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/fill_layer_properties.hpp b/src/mbgl/style/layers/fill_layer_properties.hpp index 2ae67ef0a0..43396f45d2 100644 --- a/src/mbgl/layer/fill_layer_properties.hpp +++ b/src/mbgl/style/layers/fill_layer_properties.hpp @@ -7,15 +7,16 @@ #include <mbgl/util/rapidjson.hpp> namespace mbgl { +namespace style { -class StyleCascadeParameters; -class StyleCalculationParameters; +class CascadeParameters; +class CalculationParameters; class FillPaintProperties { public: void parse(const JSValue&); - void cascade(const StyleCascadeParameters&); - bool recalculate(const StyleCalculationParameters&); + void cascade(const CascadeParameters&); + bool recalculate(const CalculationParameters&); PaintProperty<bool> fillAntialias { true }; PaintProperty<float> fillOpacity { 1 }; @@ -26,4 +27,5 @@ public: PaintProperty<std::string, CrossFadedPropertyEvaluator> fillPattern { "" }; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/line_layer.cpp b/src/mbgl/style/layers/line_layer.cpp index e1a7d813af..abe326a672 100644 --- a/src/mbgl/layer/line_layer.cpp +++ b/src/mbgl/style/layers/line_layer.cpp @@ -1,9 +1,10 @@ // This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`. -#include <mbgl/layer/line_layer.hpp> -#include <mbgl/layer/line_layer_impl.hpp> +#include <mbgl/style/layers/line_layer.hpp> +#include <mbgl/style/layers/line_layer_impl.hpp> namespace mbgl { +namespace style { LineLayer::LineLayer(const std::string& layerID) : Layer(Type::Line, std::make_unique<Impl>()) @@ -160,4 +161,5 @@ void LineLayer::setLinePattern(PropertyValue<std::string> value) { impl->paint.linePattern.set(value); } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/line_layer_impl.cpp b/src/mbgl/style/layers/line_layer_impl.cpp index aee1687046..b7ee9dc5bf 100644 --- a/src/mbgl/layer/line_layer_impl.cpp +++ b/src/mbgl/style/layers/line_layer_impl.cpp @@ -1,11 +1,12 @@ -#include <mbgl/layer/line_layer_impl.hpp> -#include <mbgl/style/style_bucket_parameters.hpp> +#include <mbgl/style/layers/line_layer_impl.hpp> +#include <mbgl/style/bucket_parameters.hpp> #include <mbgl/renderer/line_bucket.hpp> #include <mbgl/geometry/feature_index.hpp> #include <mbgl/util/math.hpp> #include <mbgl/util/intersection_tests.hpp> namespace mbgl { +namespace style { void LineLayer::Impl::parseLayout(const JSValue& value) { layout.parse(value); @@ -15,13 +16,13 @@ void LineLayer::Impl::parsePaints(const JSValue& layer) { paint.parse(layer); } -void LineLayer::Impl::cascade(const StyleCascadeParameters& parameters) { +void LineLayer::Impl::cascade(const CascadeParameters& parameters) { paint.cascade(parameters); } -bool LineLayer::Impl::recalculate(const StyleCalculationParameters& parameters) { +bool LineLayer::Impl::recalculate(const CalculationParameters& parameters) { // for scaling dasharrays - StyleCalculationParameters dashArrayParams = parameters; + CalculationParameters dashArrayParams = parameters; dashArrayParams.z = std::floor(dashArrayParams.z); paint.lineWidth.calculate(dashArrayParams); dashLineWidth = paint.lineWidth; @@ -34,11 +35,11 @@ bool LineLayer::Impl::recalculate(const StyleCalculationParameters& parameters) return hasTransitions; } -std::unique_ptr<Bucket> LineLayer::Impl::createBucket(StyleBucketParameters& parameters) const { +std::unique_ptr<Bucket> LineLayer::Impl::createBucket(BucketParameters& parameters) const { auto bucket = std::make_unique<LineBucket>(parameters.tileID.overscaleFactor()); bucket->layout = layout; - bucket->layout.recalculate(StyleCalculationParameters(parameters.tileID.overscaledZ)); + bucket->layout.recalculate(CalculationParameters(parameters.tileID.overscaledZ)); auto& name = bucketName(); parameters.eachFilteredFeature(filter, [&] (const auto& feature, std::size_t index, const std::string& layerName) { @@ -111,4 +112,5 @@ bool LineLayer::Impl::queryIntersectsGeometry( halfWidth); } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/line_layer_impl.hpp b/src/mbgl/style/layers/line_layer_impl.hpp index b602df52fa..3356dc2ceb 100644 --- a/src/mbgl/layer/line_layer_impl.hpp +++ b/src/mbgl/style/layers/line_layer_impl.hpp @@ -1,10 +1,11 @@ #pragma once -#include <mbgl/layer/layer_impl.hpp> -#include <mbgl/layer/line_layer.hpp> -#include <mbgl/layer/line_layer_properties.hpp> +#include <mbgl/style/layer_impl.hpp> +#include <mbgl/style/layers/line_layer.hpp> +#include <mbgl/style/layers/line_layer_properties.hpp> namespace mbgl { +namespace style { class LineLayer::Impl : public Layer::Impl { public: @@ -13,10 +14,10 @@ public: void parseLayout(const JSValue&) override; void parsePaints(const JSValue&) override; - void cascade(const StyleCascadeParameters&) override; - bool recalculate(const StyleCalculationParameters&) override; + void cascade(const CascadeParameters&) override; + bool recalculate(const CalculationParameters&) override; - std::unique_ptr<Bucket> createBucket(StyleBucketParameters&) const override; + std::unique_ptr<Bucket> createBucket(BucketParameters&) const override; float getQueryRadius() const override; bool queryIntersectsGeometry( @@ -35,4 +36,5 @@ private: float getLineWidth() const; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/line_layer_properties.cpp b/src/mbgl/style/layers/line_layer_properties.cpp index 4941a1ecd2..7c74f6de04 100644 --- a/src/mbgl/layer/line_layer_properties.cpp +++ b/src/mbgl/style/layers/line_layer_properties.cpp @@ -1,8 +1,9 @@ // This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`. -#include <mbgl/layer/line_layer_properties.hpp> +#include <mbgl/style/layers/line_layer_properties.hpp> namespace mbgl { +namespace style { void LineLayoutProperties::parse(const JSValue& value) { lineCap.parse("line-cap", value); @@ -11,7 +12,7 @@ void LineLayoutProperties::parse(const JSValue& value) { lineRoundLimit.parse("line-round-limit", value); } -void LineLayoutProperties::recalculate(const StyleCalculationParameters& parameters) { +void LineLayoutProperties::recalculate(const CalculationParameters& parameters) { lineCap.calculate(parameters); lineJoin.calculate(parameters); lineMiterLimit.calculate(parameters); @@ -31,7 +32,7 @@ void LinePaintProperties::parse(const JSValue& value) { linePattern.parse("line-pattern", value); } -void LinePaintProperties::cascade(const StyleCascadeParameters& parameters) { +void LinePaintProperties::cascade(const CascadeParameters& parameters) { lineOpacity.cascade(parameters); lineColor.cascade(parameters); lineTranslate.cascade(parameters); @@ -44,7 +45,7 @@ void LinePaintProperties::cascade(const StyleCascadeParameters& parameters) { linePattern.cascade(parameters); } -bool LinePaintProperties::recalculate(const StyleCalculationParameters& parameters) { +bool LinePaintProperties::recalculate(const CalculationParameters& parameters) { bool hasTransitions = false; hasTransitions |= lineOpacity.calculate(parameters); @@ -61,4 +62,5 @@ bool LinePaintProperties::recalculate(const StyleCalculationParameters& paramete return hasTransitions; } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/line_layer_properties.hpp b/src/mbgl/style/layers/line_layer_properties.hpp index f4dad055bd..e0c63b516b 100644 --- a/src/mbgl/layer/line_layer_properties.hpp +++ b/src/mbgl/style/layers/line_layer_properties.hpp @@ -7,14 +7,15 @@ #include <mbgl/util/rapidjson.hpp> namespace mbgl { +namespace style { -class StyleCascadeParameters; -class StyleCalculationParameters; +class CascadeParameters; +class CalculationParameters; class LineLayoutProperties { public: void parse(const JSValue&); - void recalculate(const StyleCalculationParameters&); + void recalculate(const CalculationParameters&); LayoutProperty<LineCapType> lineCap { LineCapType::Butt }; LayoutProperty<LineJoinType> lineJoin { LineJoinType::Miter }; @@ -25,8 +26,8 @@ public: class LinePaintProperties { public: void parse(const JSValue&); - void cascade(const StyleCascadeParameters&); - bool recalculate(const StyleCalculationParameters&); + void cascade(const CascadeParameters&); + bool recalculate(const CalculationParameters&); PaintProperty<float> lineOpacity { 1 }; PaintProperty<Color> lineColor { {{ 0, 0, 0, 1 }} }; @@ -40,4 +41,5 @@ public: PaintProperty<std::string, CrossFadedPropertyEvaluator> linePattern { "" }; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/raster_layer.cpp b/src/mbgl/style/layers/raster_layer.cpp index 661c44b7d5..fb7f08fbe9 100644 --- a/src/mbgl/layer/raster_layer.cpp +++ b/src/mbgl/style/layers/raster_layer.cpp @@ -1,9 +1,10 @@ // This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`. -#include <mbgl/layer/raster_layer.hpp> -#include <mbgl/layer/raster_layer_impl.hpp> +#include <mbgl/style/layers/raster_layer.hpp> +#include <mbgl/style/layers/raster_layer_impl.hpp> namespace mbgl { +namespace style { RasterLayer::RasterLayer(const std::string& layerID) : Layer(Type::Raster, std::make_unique<Impl>()) @@ -93,4 +94,5 @@ void RasterLayer::setRasterFadeDuration(PropertyValue<float> value) { impl->paint.rasterFadeDuration.set(value); } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/raster_layer_impl.cpp b/src/mbgl/style/layers/raster_layer_impl.cpp index f44a424f99..4854ec041d 100644 --- a/src/mbgl/layer/raster_layer_impl.cpp +++ b/src/mbgl/style/layers/raster_layer_impl.cpp @@ -1,17 +1,18 @@ -#include <mbgl/layer/raster_layer_impl.hpp> +#include <mbgl/style/layers/raster_layer_impl.hpp> #include <mbgl/renderer/bucket.hpp> namespace mbgl { +namespace style { void RasterLayer::Impl::parsePaints(const JSValue& layer) { paint.parse(layer); } -void RasterLayer::Impl::cascade(const StyleCascadeParameters& parameters) { +void RasterLayer::Impl::cascade(const CascadeParameters& parameters) { paint.cascade(parameters); } -bool RasterLayer::Impl::recalculate(const StyleCalculationParameters& parameters) { +bool RasterLayer::Impl::recalculate(const CalculationParameters& parameters) { bool hasTransitions = paint.recalculate(parameters); passes = paint.rasterOpacity > 0 ? RenderPass::Translucent : RenderPass::None; @@ -19,8 +20,9 @@ bool RasterLayer::Impl::recalculate(const StyleCalculationParameters& parameters return hasTransitions; } -std::unique_ptr<Bucket> RasterLayer::Impl::createBucket(StyleBucketParameters&) const { +std::unique_ptr<Bucket> RasterLayer::Impl::createBucket(BucketParameters&) const { return nullptr; } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/layers/raster_layer_impl.hpp b/src/mbgl/style/layers/raster_layer_impl.hpp new file mode 100644 index 0000000000..6812b469a6 --- /dev/null +++ b/src/mbgl/style/layers/raster_layer_impl.hpp @@ -0,0 +1,26 @@ +#pragma once + +#include <mbgl/style/layer_impl.hpp> +#include <mbgl/style/layers/raster_layer.hpp> +#include <mbgl/style/layers/raster_layer_properties.hpp> + +namespace mbgl { +namespace style { + +class RasterLayer::Impl : public Layer::Impl { +public: + std::unique_ptr<Layer> clone() const override; + + void parseLayout(const JSValue&) override {}; + void parsePaints(const JSValue&) override; + + void cascade(const CascadeParameters&) override; + bool recalculate(const CalculationParameters&) override; + + std::unique_ptr<Bucket> createBucket(BucketParameters&) const override; + + RasterPaintProperties paint; +}; + +} // namespace style +} // namespace mbgl diff --git a/src/mbgl/layer/raster_layer_properties.cpp b/src/mbgl/style/layers/raster_layer_properties.cpp index 898188bc83..0e6afc5e9c 100644 --- a/src/mbgl/layer/raster_layer_properties.cpp +++ b/src/mbgl/style/layers/raster_layer_properties.cpp @@ -1,8 +1,9 @@ // This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`. -#include <mbgl/layer/raster_layer_properties.hpp> +#include <mbgl/style/layers/raster_layer_properties.hpp> namespace mbgl { +namespace style { void RasterPaintProperties::parse(const JSValue& value) { rasterOpacity.parse("raster-opacity", value); @@ -14,7 +15,7 @@ void RasterPaintProperties::parse(const JSValue& value) { rasterFadeDuration.parse("raster-fade-duration", value); } -void RasterPaintProperties::cascade(const StyleCascadeParameters& parameters) { +void RasterPaintProperties::cascade(const CascadeParameters& parameters) { rasterOpacity.cascade(parameters); rasterHueRotate.cascade(parameters); rasterBrightnessMin.cascade(parameters); @@ -24,7 +25,7 @@ void RasterPaintProperties::cascade(const StyleCascadeParameters& parameters) { rasterFadeDuration.cascade(parameters); } -bool RasterPaintProperties::recalculate(const StyleCalculationParameters& parameters) { +bool RasterPaintProperties::recalculate(const CalculationParameters& parameters) { bool hasTransitions = false; hasTransitions |= rasterOpacity.calculate(parameters); @@ -38,4 +39,5 @@ bool RasterPaintProperties::recalculate(const StyleCalculationParameters& parame return hasTransitions; } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/raster_layer_properties.hpp b/src/mbgl/style/layers/raster_layer_properties.hpp index 46bd00ff2e..049da87312 100644 --- a/src/mbgl/layer/raster_layer_properties.hpp +++ b/src/mbgl/style/layers/raster_layer_properties.hpp @@ -7,15 +7,16 @@ #include <mbgl/util/rapidjson.hpp> namespace mbgl { +namespace style { -class StyleCascadeParameters; -class StyleCalculationParameters; +class CascadeParameters; +class CalculationParameters; class RasterPaintProperties { public: void parse(const JSValue&); - void cascade(const StyleCascadeParameters&); - bool recalculate(const StyleCalculationParameters&); + void cascade(const CascadeParameters&); + bool recalculate(const CalculationParameters&); PaintProperty<float> rasterOpacity { 1 }; PaintProperty<float> rasterHueRotate { 0 }; @@ -26,4 +27,5 @@ public: PaintProperty<float> rasterFadeDuration { 300 }; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/symbol_layer.cpp b/src/mbgl/style/layers/symbol_layer.cpp index 66d018b581..d7d6a02ace 100644 --- a/src/mbgl/layer/symbol_layer.cpp +++ b/src/mbgl/style/layers/symbol_layer.cpp @@ -1,9 +1,10 @@ // This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`. -#include <mbgl/layer/symbol_layer.hpp> -#include <mbgl/layer/symbol_layer_impl.hpp> +#include <mbgl/style/layers/symbol_layer.hpp> +#include <mbgl/style/layers/symbol_layer_impl.hpp> namespace mbgl { +namespace style { SymbolLayer::SymbolLayer(const std::string& layerID) : Layer(Type::Symbol, std::make_unique<Impl>()) @@ -381,4 +382,5 @@ void SymbolLayer::setTextTranslateAnchor(PropertyValue<TranslateAnchorType> valu impl->paint.textTranslateAnchor.set(value); } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/symbol_layer_impl.cpp b/src/mbgl/style/layers/symbol_layer_impl.cpp index 3a0e0dceca..a4dc264ed2 100644 --- a/src/mbgl/layer/symbol_layer_impl.cpp +++ b/src/mbgl/style/layers/symbol_layer_impl.cpp @@ -1,8 +1,9 @@ -#include <mbgl/layer/symbol_layer_impl.hpp> +#include <mbgl/style/layers/symbol_layer_impl.hpp> #include <mbgl/renderer/symbol_bucket.hpp> -#include <mbgl/style/style_bucket_parameters.hpp> +#include <mbgl/style/bucket_parameters.hpp> namespace mbgl { +namespace style { void SymbolLayer::Impl::parseLayout(const JSValue& value) { layout.parse(value); @@ -12,11 +13,11 @@ void SymbolLayer::Impl::parsePaints(const JSValue& layer) { paint.parse(layer); } -void SymbolLayer::Impl::cascade(const StyleCascadeParameters& parameters) { +void SymbolLayer::Impl::cascade(const CascadeParameters& parameters) { paint.cascade(parameters); } -bool SymbolLayer::Impl::recalculate(const StyleCalculationParameters& parameters) { +bool SymbolLayer::Impl::recalculate(const CalculationParameters& parameters) { bool hasTransitions = paint.recalculate(parameters); // text-size and icon-size are layout properties but they also need to be evaluated as paint properties: @@ -32,7 +33,7 @@ bool SymbolLayer::Impl::recalculate(const StyleCalculationParameters& parameters return hasTransitions; } -std::unique_ptr<Bucket> SymbolLayer::Impl::createBucket(StyleBucketParameters& parameters) const { +std::unique_ptr<Bucket> SymbolLayer::Impl::createBucket(BucketParameters& parameters) const { auto bucket = std::make_unique<SymbolBucket>(parameters.tileID.overscaleFactor(), parameters.tileID.overscaledZ, parameters.mode, @@ -41,7 +42,7 @@ std::unique_ptr<Bucket> SymbolLayer::Impl::createBucket(StyleBucketParameters& p bucket->layout = layout; - StyleCalculationParameters p(parameters.tileID.overscaledZ); + CalculationParameters p(parameters.tileID.overscaledZ); bucket->layout.symbolPlacement.calculate(p); if (bucket->layout.symbolPlacement.value == SymbolPlacementType::Line) { bucket->layout.iconRotationAlignment.value = RotationAlignmentType::Map; @@ -50,12 +51,12 @@ std::unique_ptr<Bucket> SymbolLayer::Impl::createBucket(StyleBucketParameters& p bucket->layout.recalculate(p); - bucket->layout.iconSize.calculate(StyleCalculationParameters(18)); - bucket->layout.textSize.calculate(StyleCalculationParameters(18)); + bucket->layout.iconSize.calculate(CalculationParameters(18)); + bucket->layout.textSize.calculate(CalculationParameters(18)); bucket->iconMaxSize = bucket->layout.iconSize; bucket->textMaxSize = bucket->layout.textSize; - bucket->layout.iconSize.calculate(StyleCalculationParameters(p.z + 1)); - bucket->layout.textSize.calculate(StyleCalculationParameters(p.z + 1)); + bucket->layout.iconSize.calculate(CalculationParameters(p.z + 1)); + bucket->layout.textSize.calculate(CalculationParameters(p.z + 1)); bucket->parseFeatures(parameters.layer, filter); @@ -77,4 +78,5 @@ std::unique_ptr<Bucket> SymbolLayer::Impl::createBucket(StyleBucketParameters& p return std::move(bucket); } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/symbol_layer_impl.hpp b/src/mbgl/style/layers/symbol_layer_impl.hpp index 46503ab916..9727cc6480 100644 --- a/src/mbgl/layer/symbol_layer_impl.hpp +++ b/src/mbgl/style/layers/symbol_layer_impl.hpp @@ -1,14 +1,15 @@ -#ifndef MBGL_SYMBOL_LAYER -#define MBGL_SYMBOL_LAYER +#pragma once -#include <mbgl/layer/layer_impl.hpp> -#include <mbgl/layer/symbol_layer.hpp> -#include <mbgl/layer/symbol_layer_properties.hpp> +#include <mbgl/style/layer_impl.hpp> +#include <mbgl/style/layers/symbol_layer.hpp> +#include <mbgl/style/layers/symbol_layer_properties.hpp> namespace mbgl { class SpriteAtlas; +namespace style { + class SymbolLayer::Impl : public Layer::Impl { public: std::unique_ptr<Layer> clone() const override; @@ -16,10 +17,10 @@ public: void parseLayout(const JSValue&) override; void parsePaints(const JSValue&) override; - void cascade(const StyleCascadeParameters&) override; - bool recalculate(const StyleCalculationParameters&) override; + void cascade(const CascadeParameters&) override; + bool recalculate(const CalculationParameters&) override; - std::unique_ptr<Bucket> createBucket(StyleBucketParameters&) const override; + std::unique_ptr<Bucket> createBucket(BucketParameters&) const override; SymbolLayoutProperties layout; SymbolPaintProperties paint; @@ -30,6 +31,5 @@ public: SpriteAtlas* spriteAtlas = nullptr; }; +} // namespace style } // namespace mbgl - -#endif diff --git a/src/mbgl/layer/symbol_layer_properties.cpp b/src/mbgl/style/layers/symbol_layer_properties.cpp index 4b9e9a5fb6..ce16ae2e50 100644 --- a/src/mbgl/layer/symbol_layer_properties.cpp +++ b/src/mbgl/style/layers/symbol_layer_properties.cpp @@ -1,8 +1,9 @@ // This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`. -#include <mbgl/layer/symbol_layer_properties.hpp> +#include <mbgl/style/layers/symbol_layer_properties.hpp> namespace mbgl { +namespace style { void SymbolLayoutProperties::parse(const JSValue& value) { symbolPlacement.parse("symbol-placement", value); @@ -38,7 +39,7 @@ void SymbolLayoutProperties::parse(const JSValue& value) { textOptional.parse("text-optional", value); } -void SymbolLayoutProperties::recalculate(const StyleCalculationParameters& parameters) { +void SymbolLayoutProperties::recalculate(const CalculationParameters& parameters) { symbolPlacement.calculate(parameters); symbolSpacing.calculate(parameters); symbolAvoidEdges.calculate(parameters); @@ -89,7 +90,7 @@ void SymbolPaintProperties::parse(const JSValue& value) { textTranslateAnchor.parse("text-translate-anchor", value); } -void SymbolPaintProperties::cascade(const StyleCascadeParameters& parameters) { +void SymbolPaintProperties::cascade(const CascadeParameters& parameters) { iconOpacity.cascade(parameters); iconColor.cascade(parameters); iconHaloColor.cascade(parameters); @@ -106,7 +107,7 @@ void SymbolPaintProperties::cascade(const StyleCascadeParameters& parameters) { textTranslateAnchor.cascade(parameters); } -bool SymbolPaintProperties::recalculate(const StyleCalculationParameters& parameters) { +bool SymbolPaintProperties::recalculate(const CalculationParameters& parameters) { bool hasTransitions = false; hasTransitions |= iconOpacity.calculate(parameters); @@ -127,4 +128,5 @@ bool SymbolPaintProperties::recalculate(const StyleCalculationParameters& parame return hasTransitions; } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/layer/symbol_layer_properties.hpp b/src/mbgl/style/layers/symbol_layer_properties.hpp index ccbecef00e..38455b5cac 100644 --- a/src/mbgl/layer/symbol_layer_properties.hpp +++ b/src/mbgl/style/layers/symbol_layer_properties.hpp @@ -7,14 +7,15 @@ #include <mbgl/util/rapidjson.hpp> namespace mbgl { +namespace style { -class StyleCascadeParameters; -class StyleCalculationParameters; +class CascadeParameters; +class CalculationParameters; class SymbolLayoutProperties { public: void parse(const JSValue&); - void recalculate(const StyleCalculationParameters&); + void recalculate(const CalculationParameters&); LayoutProperty<SymbolPlacementType> symbolPlacement { SymbolPlacementType::Point }; LayoutProperty<float> symbolSpacing { 250 }; @@ -52,8 +53,8 @@ public: class SymbolPaintProperties { public: void parse(const JSValue&); - void cascade(const StyleCascadeParameters&); - bool recalculate(const StyleCalculationParameters&); + void cascade(const CascadeParameters&); + bool recalculate(const CalculationParameters&); PaintProperty<float> iconOpacity { 1 }; PaintProperty<Color> iconColor { {{ 0, 0, 0, 1 }} }; @@ -71,4 +72,5 @@ public: PaintProperty<TranslateAnchorType> textTranslateAnchor { TranslateAnchorType::Map }; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/layout_property.hpp b/src/mbgl/style/layout_property.hpp index b4857aeae5..f5045b47fc 100644 --- a/src/mbgl/style/layout_property.hpp +++ b/src/mbgl/style/layout_property.hpp @@ -8,6 +8,7 @@ #include <utility> namespace mbgl { +namespace style { template <typename T> class LayoutProperty { @@ -30,7 +31,7 @@ public: } } - void calculate(const StyleCalculationParameters& parameters) { + void calculate(const CalculationParameters& parameters) { if (currentValue) { PropertyEvaluator<T> evaluator(parameters, defaultValue); value = PropertyValue<T>::visit(currentValue, evaluator); @@ -46,4 +47,5 @@ private: PropertyValue<T> currentValue; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/style_observer.hpp b/src/mbgl/style/observer.hpp index 9e2c946f7d..c19f58904f 100644 --- a/src/mbgl/style/style_observer.hpp +++ b/src/mbgl/style/observer.hpp @@ -2,22 +2,24 @@ #include <mbgl/text/glyph_store_observer.hpp> #include <mbgl/sprite/sprite_store_observer.hpp> -#include <mbgl/source/source_observer.hpp> +#include <mbgl/style/source_observer.hpp> namespace mbgl { +namespace style { -class StyleObserver : public GlyphStoreObserver, public SpriteStoreObserver, public SourceObserver { +class Observer : public GlyphStoreObserver, + public SpriteStoreObserver, + public SourceObserver { public: - virtual ~StyleObserver() = default; - /** * In addition to the individual glyph, sprite, and source events, the * following "rollup" events are provided for convenience. They are * strictly additive; e.g. when a source is loaded, both `onSourceLoaded` * and `onResourceLoaded` will be called. */ - virtual void onResourceLoaded() {} - virtual void onResourceError(std::exception_ptr) {} + virtual void onResourceLoaded() {}; + virtual void onResourceError(std::exception_ptr) {}; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/paint_property.hpp b/src/mbgl/style/paint_property.hpp index 8428a90533..62fd59684e 100644 --- a/src/mbgl/style/paint_property.hpp +++ b/src/mbgl/style/paint_property.hpp @@ -3,9 +3,9 @@ #include <mbgl/style/class_dictionary.hpp> #include <mbgl/style/property_parsing.hpp> #include <mbgl/style/property_evaluator.hpp> -#include <mbgl/style/property_transition.hpp> -#include <mbgl/style/style_cascade_parameters.hpp> -#include <mbgl/style/style_calculation_parameters.hpp> +#include <mbgl/style/transition_options.hpp> +#include <mbgl/style/cascade_parameters.hpp> +#include <mbgl/style/calculation_parameters.hpp> #include <mbgl/util/interpolate.hpp> #include <mbgl/util/std.hpp> #include <mbgl/util/rapidjson.hpp> @@ -14,6 +14,7 @@ #include <utility> namespace mbgl { +namespace style { template <class T, template <class S> class Evaluator = PropertyEvaluator> class PaintProperty { @@ -62,14 +63,14 @@ public: } if (it->value.HasMember(transitionName.c_str())) { - if (auto v = parsePropertyTransition(name, it->value[transitionName.c_str()])) { + if (auto v = parseTransitionOptions(name, it->value[transitionName.c_str()])) { transitions.emplace(classID, *v); } } } } - void cascade(const StyleCascadeParameters& params) { + void cascade(const CascadeParameters& params) { const bool overrideTransition = !params.transition.delay && !params.transition.duration; Duration delay = params.transition.delay.value_or(Duration::zero()); Duration duration = params.transition.duration.value_or(Duration::zero()); @@ -79,7 +80,7 @@ public: continue; if (overrideTransition && transitions.find(classID) != transitions.end()) { - const PropertyTransition& transition = transitions[classID]; + const TransitionOptions& transition = transitions[classID]; if (transition.delay) delay = *transition.delay; if (transition.duration) duration = *transition.duration; } @@ -95,7 +96,7 @@ public: assert(cascaded); } - bool calculate(const StyleCalculationParameters& parameters) { + bool calculate(const CalculationParameters& parameters) { assert(cascaded); Evaluator<T> evaluator(parameters, defaultValue); value = cascaded->calculate(evaluator, parameters.now); @@ -109,7 +110,7 @@ public: private: T defaultValue; std::map<ClassID, PropertyValue<T>> values; - std::map<ClassID, PropertyTransition> transitions; + std::map<ClassID, TransitionOptions> transitions; struct CascadedValue { CascadedValue(std::unique_ptr<CascadedValue> prior_, @@ -147,4 +148,5 @@ private: std::unique_ptr<CascadedValue> cascaded; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/style_parser.cpp b/src/mbgl/style/parser.cpp index 95ab36498d..28a7d2e81b 100644 --- a/src/mbgl/style/style_parser.cpp +++ b/src/mbgl/style/parser.cpp @@ -1,11 +1,11 @@ -#include <mbgl/style/style_parser.hpp> -#include <mbgl/layer/fill_layer.hpp> -#include <mbgl/layer/line_layer.hpp> -#include <mbgl/layer/circle_layer.hpp> -#include <mbgl/layer/symbol_layer.hpp> -#include <mbgl/layer/raster_layer.hpp> -#include <mbgl/layer/background_layer.hpp> -#include <mbgl/layer/layer_impl.hpp> +#include <mbgl/style/parser.hpp> +#include <mbgl/style/layer_impl.hpp> +#include <mbgl/style/layers/fill_layer.hpp> +#include <mbgl/style/layers/line_layer.hpp> +#include <mbgl/style/layers/circle_layer.hpp> +#include <mbgl/style/layers/symbol_layer.hpp> +#include <mbgl/style/layers/raster_layer.hpp> +#include <mbgl/style/layers/background_layer.hpp> #include <mbgl/platform/log.hpp> @@ -23,7 +23,7 @@ #include <set> namespace mbgl { - +namespace style { namespace { @@ -102,9 +102,9 @@ void parseTileJSONMember(const JSValue& value, std::array<double, 4>& target, co } // end namespace -StyleParser::~StyleParser() = default; +Parser::~Parser() = default; -void StyleParser::parse(const std::string& json) { +void Parser::parse(const std::string& json) { rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::CrtAllocator> document; document.Parse<0>(json.c_str()); @@ -143,7 +143,7 @@ void StyleParser::parse(const std::string& json) { } } -void StyleParser::parseSources(const JSValue& value) { +void Parser::parseSources(const JSValue& value) { if (!value.IsObject()) { Log::Warning(Event::ParseStyle, "sources must be an object"); return; @@ -174,7 +174,7 @@ void StyleParser::parseSources(const JSValue& value) { uint16_t tileSize = util::tileSize; - std::unique_ptr<SourceInfo> info; + std::unique_ptr<Tileset> tileset; std::unique_ptr<mapbox::geojsonvt::GeoJSONVT> geojsonvt; switch (type) { @@ -200,12 +200,12 @@ void StyleParser::parseSources(const JSValue& value) { continue; } } else { - info = parseTileJSON(sourceVal); + tileset = parseTileJSON(sourceVal); } break; case SourceType::GeoJSON: - info = std::make_unique<SourceInfo>(); + tileset = std::make_unique<Tileset>(); // We should probably split this up to have URLs in the url property, and actual data // in the data property. Until then, we're going to detect the content based on the @@ -218,7 +218,7 @@ void StyleParser::parseSources(const JSValue& value) { } else if (dataVal.IsObject()) { // We need to parse dataVal as a GeoJSON object geojsonvt = parseGeoJSON(dataVal); - info->maxZoom = geojsonvt->options.maxZoom; + tileset->maxZoom = geojsonvt->options.maxZoom; } else { Log::Error(Event::ParseStyle, "GeoJSON data must be a URL or an object"); continue; @@ -236,14 +236,14 @@ void StyleParser::parseSources(const JSValue& value) { } const std::string id { nameVal.GetString(), nameVal.GetStringLength() }; - std::unique_ptr<Source> source = std::make_unique<Source>(type, id, url, tileSize, std::move(info), std::move(geojsonvt)); + std::unique_ptr<Source> source = std::make_unique<Source>(type, id, url, tileSize, std::move(tileset), std::move(geojsonvt)); sourcesMap.emplace(id, source.get()); sources.emplace_back(std::move(source)); } } -std::unique_ptr<mapbox::geojsonvt::GeoJSONVT> StyleParser::parseGeoJSON(const JSValue& value) { +std::unique_ptr<mapbox::geojsonvt::GeoJSONVT> parseGeoJSON(const JSValue& value) { using namespace mapbox::geojsonvt; Options options; @@ -260,7 +260,7 @@ std::unique_ptr<mapbox::geojsonvt::GeoJSONVT> StyleParser::parseGeoJSON(const JS } } -std::unique_ptr<SourceInfo> StyleParser::parseTileJSON(const std::string& json, const std::string& sourceURL, SourceType type, uint16_t tileSize) { +std::unique_ptr<Tileset> parseTileJSON(const std::string& json, const std::string& sourceURL, SourceType type, uint16_t tileSize) { rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::CrtAllocator> document; document.Parse<0>(json.c_str()); @@ -270,7 +270,7 @@ std::unique_ptr<SourceInfo> StyleParser::parseTileJSON(const std::string& json, throw std::runtime_error(message.str()); } - std::unique_ptr<SourceInfo> result = StyleParser::parseTileJSON(document); + std::unique_ptr<Tileset> result = parseTileJSON(document); // TODO: Remove this hack by delivering proper URLs in the TileJSON to begin with. if (util::mapbox::isMapboxURL(sourceURL)) { @@ -282,24 +282,24 @@ std::unique_ptr<SourceInfo> StyleParser::parseTileJSON(const std::string& json, return result; } -std::unique_ptr<SourceInfo> StyleParser::parseTileJSON(const JSValue& value) { - auto info = std::make_unique<SourceInfo>(); - parseTileJSONMember(value, info->tiles, "tiles"); - parseTileJSONMember(value, info->minZoom, "minzoom"); - parseTileJSONMember(value, info->maxZoom, "maxzoom"); - parseTileJSONMember(value, info->attribution, "attribution"); +std::unique_ptr<Tileset> parseTileJSON(const JSValue& value) { + auto tileset = std::make_unique<Tileset>(); + parseTileJSONMember(value, tileset->tiles, "tiles"); + parseTileJSONMember(value, tileset->minZoom, "minzoom"); + parseTileJSONMember(value, tileset->maxZoom, "maxzoom"); + parseTileJSONMember(value, tileset->attribution, "attribution"); std::array<double, 4> array; parseTileJSONMember(value, array, "center"); - info->center = { array[0], array[1] }; - info->zoom = array[2]; + tileset->center = { array[0], array[1] }; + tileset->zoom = array[2]; parseTileJSONMember(value, array, "bounds"); - info->bounds = LatLngBounds::hull({ array[0], array[1] }, { array[2], array[3] }); + tileset->bounds = LatLngBounds::hull({ array[0], array[1] }, { array[2], array[3] }); - return info; + return tileset; } -void StyleParser::parseLayers(const JSValue& value) { +void Parser::parseLayers(const JSValue& value) { std::vector<std::string> ids; if (!value.IsArray()) { @@ -353,7 +353,7 @@ void StyleParser::parseLayers(const JSValue& value) { } } -void StyleParser::parseLayer(const std::string& id, const JSValue& value, std::unique_ptr<Layer>& layer) { +void Parser::parseLayer(const std::string& id, const JSValue& value, std::unique_ptr<Layer>& layer) { if (layer) { // Skip parsing this again. We already have a valid layer definition. return; @@ -486,7 +486,7 @@ MBGL_DEFINE_ENUM_CLASS(VisibilityTypeClass, VisibilityType, { { VisibilityType::None, "none" }, }); -void StyleParser::parseVisibility(Layer& layer, const JSValue& value) { +void Parser::parseVisibility(Layer& layer, const JSValue& value) { Layer::Impl& impl = *layer.baseImpl; if (!value.HasMember("visibility")) { return; @@ -664,7 +664,7 @@ Filter parseFilter(const JSValue& value) { } } -std::vector<FontStack> StyleParser::fontStacks() const { +std::vector<FontStack> Parser::fontStacks() const { std::set<FontStack> result; for (const auto& layer : layers) { @@ -685,4 +685,5 @@ std::vector<FontStack> StyleParser::fontStacks() const { return std::vector<FontStack>(result.begin(), result.end()); } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/style_parser.hpp b/src/mbgl/style/parser.hpp index b5445bbfb3..ea821fabde 100644 --- a/src/mbgl/style/style_parser.hpp +++ b/src/mbgl/style/parser.hpp @@ -1,10 +1,11 @@ #pragma once -#include <mbgl/style/types.hpp> #include <mbgl/style/layer.hpp> -#include <mbgl/source/source.hpp> +#include <mbgl/style/source.hpp> #include <mbgl/style/filter.hpp> + #include <mbgl/util/rapidjson.hpp> +#include <mbgl/util/font_stack.hpp> #include <vector> #include <memory> @@ -13,12 +14,18 @@ #include <forward_list> namespace mbgl { +namespace style { + +std::unique_ptr<Tileset> parseTileJSON(const std::string& json, const std::string& sourceURL, SourceType, uint16_t tileSize); +std::unique_ptr<Tileset> parseTileJSON(const JSValue&); + +std::unique_ptr<mapbox::geojsonvt::GeoJSONVT> parseGeoJSON(const JSValue&); Filter parseFilter(const JSValue&); -class StyleParser { +class Parser { public: - ~StyleParser(); + ~Parser(); void parse(const std::string&); @@ -31,11 +38,6 @@ public: // Statically evaluate layer properties to determine what font stacks are used. std::vector<FontStack> fontStacks() const; - static std::unique_ptr<SourceInfo> parseTileJSON(const std::string& json, const std::string& sourceURL, SourceType, uint16_t tileSize); - static std::unique_ptr<SourceInfo> parseTileJSON(const JSValue&); - - static std::unique_ptr<mapbox::geojsonvt::GeoJSONVT> parseGeoJSON(const JSValue&); - private: void parseSources(const JSValue&); void parseLayers(const JSValue&); @@ -49,4 +51,5 @@ private: std::forward_list<std::string> stack; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/property_evaluator.cpp b/src/mbgl/style/property_evaluator.cpp index 08eea899c2..d2e633c782 100644 --- a/src/mbgl/style/property_evaluator.cpp +++ b/src/mbgl/style/property_evaluator.cpp @@ -1,12 +1,14 @@ #include <mbgl/style/property_evaluator.hpp> -#include <mbgl/style/style_calculation_parameters.hpp> +#include <mbgl/style/calculation_parameters.hpp> #include <mbgl/style/types.hpp> #include <mbgl/util/interpolate.hpp> #include <mbgl/util/chrono.hpp> +#include <mbgl/util/color.hpp> #include <cmath> namespace mbgl { +namespace style { template <typename T> inline T defaultStopsValue(); @@ -140,4 +142,5 @@ Faded<T> CrossFadedPropertyEvaluator<T>::calculate(const T& min, const T& mid, c template class CrossFadedPropertyEvaluator<std::string>; template class CrossFadedPropertyEvaluator<std::vector<float>>; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/property_evaluator.hpp b/src/mbgl/style/property_evaluator.hpp index 112c373a44..77100bda46 100644 --- a/src/mbgl/style/property_evaluator.hpp +++ b/src/mbgl/style/property_evaluator.hpp @@ -4,15 +4,16 @@ #include <mbgl/util/interpolate.hpp> namespace mbgl { +namespace style { -class StyleCalculationParameters; +class CalculationParameters; template <typename T> class PropertyEvaluator { public: using ResultType = T; - PropertyEvaluator(const StyleCalculationParameters& parameters_, const T& defaultValue_) + PropertyEvaluator(const CalculationParameters& parameters_, const T& defaultValue_) : parameters(parameters_), defaultValue(defaultValue_) {} @@ -21,7 +22,7 @@ public: T operator()(const Function<T>&) const; private: - const StyleCalculationParameters& parameters; + const CalculationParameters& parameters; T defaultValue; }; @@ -39,7 +40,7 @@ class CrossFadedPropertyEvaluator { public: using ResultType = Faded<T>; - CrossFadedPropertyEvaluator(const StyleCalculationParameters& parameters_, const T& defaultValue_) + CrossFadedPropertyEvaluator(const CalculationParameters& parameters_, const T& defaultValue_) : parameters(parameters_), defaultValue(defaultValue_) {} @@ -50,13 +51,15 @@ public: private: Faded<T> calculate(const T& min, const T& mid, const T& max) const; - const StyleCalculationParameters& parameters; + const CalculationParameters& parameters; T defaultValue; }; +} // namespace style + namespace util { template <typename T> -struct Interpolator<Faded<T>> +struct Interpolator<style::Faded<T>> : Uninterpolated {}; } diff --git a/src/mbgl/style/property_parsing.cpp b/src/mbgl/style/property_parsing.cpp index 67baa3ec8d..9f60ddf3b6 100644 --- a/src/mbgl/style/property_parsing.cpp +++ b/src/mbgl/style/property_parsing.cpp @@ -1,11 +1,11 @@ #include <mbgl/style/property_parsing.hpp> -#include <mbgl/style/property_transition.hpp> #include <mbgl/platform/log.hpp> #include <csscolorparser/csscolorparser.hpp> namespace mbgl { +namespace style { template <> optional<bool> parseConstant(const char* name, const JSValue& value) { @@ -264,7 +264,7 @@ optional<std::vector<std::string>> parseConstant(const char* name, const JSValue return result; } -optional<PropertyTransition> parsePropertyTransition(const char *, const JSValue& value) { +optional<TransitionOptions> parseTransitionOptions(const char *, const JSValue& value) { if (!value.IsObject()) { return {}; } @@ -283,7 +283,8 @@ optional<PropertyTransition> parsePropertyTransition(const char *, const JSValue return {}; } - return PropertyTransition(duration, delay); + return TransitionOptions(duration, delay); } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/property_parsing.hpp b/src/mbgl/style/property_parsing.hpp index c0fe5ce2bc..bb894c2407 100644 --- a/src/mbgl/style/property_parsing.hpp +++ b/src/mbgl/style/property_parsing.hpp @@ -2,10 +2,11 @@ #include <mbgl/style/types.hpp> #include <mbgl/style/property_value.hpp> -#include <mbgl/style/property_transition.hpp> +#include <mbgl/style/transition_options.hpp> #include <mbgl/util/rapidjson.hpp> #include <mbgl/util/optional.hpp> +#include <mbgl/util/color.hpp> #include <mbgl/platform/log.hpp> @@ -14,6 +15,7 @@ #include <vector> namespace mbgl { +namespace style { template <typename T> optional<T> parseConstant(const char* name, const JSValue&); @@ -104,6 +106,7 @@ PropertyValue<T> parseProperty(const char* name, const JSValue& value) { return Function<T>(stops, base); } -optional<PropertyTransition> parsePropertyTransition(const char * name, const JSValue&); +optional<TransitionOptions> parseTransitionOptions(const char * name, const JSValue&); +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/property_value.hpp b/src/mbgl/style/property_value.hpp deleted file mode 100644 index 377e4f17e0..0000000000 --- a/src/mbgl/style/property_value.hpp +++ /dev/null @@ -1,36 +0,0 @@ -#pragma once - -#include <mbgl/util/variant.hpp> -#include <mbgl/style/types.hpp> - -namespace mbgl { - -class Undefined {}; - -template <class T> -class PropertyValue { -private: - using Value = variant<Undefined, T, Function<T>>; - Value value; - -public: - PropertyValue() : value() {} - PropertyValue( T constant) : value(constant) {} - PropertyValue(Function<T> function) : value(function) {} - - bool isUndefined() const { return value.which() == 0; } - bool isConstant() const { return value.which() == 1; } - bool isFunction() const { return value.which() == 2; } - - const T & asConstant() const { return value.template get< T >(); } - const Function<T>& asFunction() const { return value.template get<Function<T>>(); } - - explicit operator bool() const { return !isUndefined(); }; - - template <typename Visitor> - static auto visit(const PropertyValue<T>& value, Visitor&& visitor) { - return Value::visit(value.value, visitor); - } -}; - -} diff --git a/src/mbgl/style/style_query_parameters.hpp b/src/mbgl/style/query_parameters.hpp index 33115bdfb2..3c1abf3b70 100644 --- a/src/mbgl/style/style_query_parameters.hpp +++ b/src/mbgl/style/query_parameters.hpp @@ -8,11 +8,14 @@ namespace mbgl { class TransformState; -class StyleQueryParameters { +namespace style { + +class QueryParameters { public: const ScreenLineString& geometry; const TransformState& transformState; const optional<std::vector<std::string>>& layerIDs; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/render_item.hpp b/src/mbgl/style/render_item.hpp index ebf6799828..da59591c36 100644 --- a/src/mbgl/style/render_item.hpp +++ b/src/mbgl/style/render_item.hpp @@ -2,12 +2,15 @@ namespace mbgl { -class Layer; class Tile; class Bucket; +namespace style { +class Layer; +} + struct RenderItem { - inline RenderItem(const Layer& layer_, + inline RenderItem(const style::Layer& layer_, const Tile* tile_ = nullptr, Bucket* bucket_ = nullptr) : tile(tile_), bucket(bucket_), layer(layer_) { @@ -15,7 +18,7 @@ struct RenderItem { const Tile* const tile; Bucket* const bucket; - const Layer& layer; + const style::Layer& layer; }; } // namespace mbgl diff --git a/src/mbgl/source/source.cpp b/src/mbgl/style/source.cpp index 66546909ac..8e5973f412 100644 --- a/src/mbgl/source/source.cpp +++ b/src/mbgl/style/source.cpp @@ -1,5 +1,5 @@ -#include <mbgl/source/source.hpp> -#include <mbgl/source/source_observer.hpp> +#include <mbgl/style/source.hpp> +#include <mbgl/style/source_observer.hpp> #include <mbgl/map/transform.hpp> #include <mbgl/tile/tile.hpp> #include <mbgl/tile/vector_tile.hpp> @@ -12,8 +12,8 @@ #include <mbgl/storage/response.hpp> #include <mbgl/storage/file_source.hpp> #include <mbgl/style/layer.hpp> -#include <mbgl/style/style_update_parameters.hpp> -#include <mbgl/style/style_query_parameters.hpp> +#include <mbgl/style/update_parameters.hpp> +#include <mbgl/style/query_parameters.hpp> #include <mbgl/platform/log.hpp> #include <mbgl/math/minmax.hpp> #include <mbgl/math/clamp.hpp> @@ -24,7 +24,7 @@ #include <mbgl/tile/vector_tile_data.hpp> #include <mbgl/tile/raster_tile_data.hpp> -#include <mbgl/style/style_parser.hpp> +#include <mbgl/style/parser.hpp> #include <mbgl/gl/debugging.hpp> #include <mbgl/algorithm/update_renderables.hpp> @@ -39,6 +39,7 @@ #include <sstream> namespace mbgl { +namespace style { static SourceObserver nullObserver; @@ -46,13 +47,13 @@ Source::Source(SourceType type_, const std::string& id_, const std::string& url_, uint16_t tileSize_, - std::unique_ptr<SourceInfo>&& info_, + std::unique_ptr<Tileset>&& tileset_, std::unique_ptr<mapbox::geojsonvt::GeoJSONVT>&& geojsonvt_) : type(type_), id(id_), url(url_), tileSize(tileSize_), - info(std::move(info_)), + tileset(std::move(tileset_)), geojsonvt(std::move(geojsonvt_)), observer(&nullObserver) { } @@ -84,7 +85,7 @@ void Source::load(FileSource& fileSource) { } if (req) { - // We don't have a SourceInfo object yet, but there's already a request underway to load + // We don't have a Tileset object yet, but there's already a request underway to load // the data. return; } @@ -101,20 +102,20 @@ void Source::load(FileSource& fileSource) { bool reloadTiles = false; if (type == SourceType::Vector || type == SourceType::Raster) { - std::unique_ptr<SourceInfo> newInfo; + std::unique_ptr<Tileset> newTileset; - // Create a new copy of the SourceInfo object that holds the base values we've parsed + // Create a new copy of the Tileset object that holds the base values we've parsed // from the stylesheet. Then merge in the values parsed from the TileJSON we retrieved // via the URL. try { - newInfo = StyleParser::parseTileJSON(*res.data, url, type, tileSize); + newTileset = style::parseTileJSON(*res.data, url, type, tileSize); } catch (...) { observer->onSourceError(*this, std::current_exception()); return; } // Check whether previous information specifies different tile - if (info && info->tiles != newInfo->tiles) { + if (tileset && tileset->tiles != newTileset->tiles) { reloadTiles = true; // Tile size changed: We need to recalculate the tiles we need to load because we @@ -132,9 +133,9 @@ void Source::load(FileSource& fileSource) { // Center/bounds changed: We're not using these values currently } - info = std::move(newInfo); + tileset = std::move(newTileset); } else if (type == SourceType::GeoJSON) { - std::unique_ptr<SourceInfo> newInfo = std::make_unique<SourceInfo>(); + std::unique_ptr<Tileset> newTileset = std::make_unique<Tileset>(); rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::CrtAllocator> d; d.Parse<0>(res.data->c_str()); @@ -146,11 +147,11 @@ void Source::load(FileSource& fileSource) { return; } - geojsonvt = StyleParser::parseGeoJSON(d); + geojsonvt = style::parseGeoJSON(d); reloadTiles = true; - newInfo->maxZoom = geojsonvt->options.maxZoom; - info = std::move(newInfo); + newTileset->maxZoom = geojsonvt->options.maxZoom; + tileset = std::move(newTileset); } if (reloadTiles) { @@ -186,7 +187,7 @@ const std::map<UnwrappedTileID, Tile>& Source::getTiles() const { } std::unique_ptr<TileData> Source::createTile(const OverscaledTileID& overscaledTileID, - const StyleUpdateParameters& parameters) { + const UpdateParameters& parameters) { std::unique_ptr<TileData> data = cache.get(overscaledTileID); if (data) { return data; @@ -198,13 +199,13 @@ std::unique_ptr<TileData> Source::createTile(const OverscaledTileID& overscaledT // If we don't find working tile data, we're just going to load it. if (type == SourceType::Raster) { data = std::make_unique<RasterTileData>(overscaledTileID, parameters.pixelRatio, - info->tiles.at(0), parameters.texturePool, + tileset->tiles.at(0), parameters.texturePool, parameters.worker, parameters.fileSource, callback); } else { std::unique_ptr<GeometryTileMonitor> monitor; if (type == SourceType::Vector) { - monitor = std::make_unique<VectorTileMonitor>(overscaledTileID, parameters.pixelRatio, info->tiles.at(0), parameters.fileSource); + monitor = std::make_unique<VectorTileMonitor>(overscaledTileID, parameters.pixelRatio, tileset->tiles.at(0), parameters.fileSource); } else if (type == SourceType::Annotations) { monitor = std::make_unique<AnnotationTileMonitor>(overscaledTileID, parameters.annotationManager); } else if (type == SourceType::GeoJSON) { @@ -230,7 +231,7 @@ TileData* Source::getTileData(const OverscaledTileID& overscaledTileID) const { } } -bool Source::update(const StyleUpdateParameters& parameters) { +bool Source::update(const UpdateParameters& parameters) { bool allTilesUpdated = true; if (!loaded || parameters.animationTime <= updated) { @@ -242,8 +243,8 @@ bool Source::update(const StyleUpdateParameters& parameters) { int32_t dataTileZoom = overscaledZoom; std::vector<UnwrappedTileID> idealTiles; - if (overscaledZoom >= info->minZoom) { - int32_t idealZoom = std::min<int32_t>(info->maxZoom, overscaledZoom); + if (overscaledZoom >= tileset->minZoom) { + int32_t idealZoom = std::min<int32_t>(tileset->maxZoom, overscaledZoom); // Make sure we're not reparsing overzoomed raster tiles. if (type == SourceType::Raster) { @@ -278,7 +279,7 @@ bool Source::update(const StyleUpdateParameters& parameters) { tiles.clear(); algorithm::updateRenderables(getTileDataFn, createTileDataFn, retainTileDataFn, renderTileFn, - idealTiles, *info, dataTileZoom); + idealTiles, *tileset, dataTileZoom); if (type != SourceType::Raster && type != SourceType::Annotations && cache.getSize() == 0) { size_t conservativeCacheSize = @@ -341,7 +342,7 @@ static Point<int16_t> coordinateToTilePoint(const UnwrappedTileID& tileID, const }; } -std::unordered_map<std::string, std::vector<Feature>> Source::queryRenderedFeatures(const StyleQueryParameters& parameters) const { +std::unordered_map<std::string, std::vector<Feature>> Source::queryRenderedFeatures(const QueryParameters& parameters) const { LineString<double> queryGeometry; for (const auto& p : parameters.geometry) { @@ -423,4 +424,5 @@ void Source::dumpDebugLogs() const { } } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/source/source.hpp b/src/mbgl/style/source.hpp index cbdf4afa15..cadc45c25c 100644 --- a/src/mbgl/source/source.hpp +++ b/src/mbgl/style/source.hpp @@ -3,12 +3,13 @@ #include <mbgl/tile/tile_id.hpp> #include <mbgl/tile/tile_data.hpp> #include <mbgl/tile/tile_cache.hpp> -#include <mbgl/source/source_info.hpp> +#include <mbgl/style/types.hpp> #include <mbgl/renderer/renderable.hpp> #include <mbgl/util/mat4.hpp> #include <mbgl/util/rapidjson.hpp> #include <mbgl/util/feature.hpp> +#include <mbgl/util/tileset.hpp> #include <forward_list> #include <vector> @@ -22,15 +23,18 @@ class GeoJSONVT; namespace mbgl { -class Style; -class StyleUpdateParameters; -class StyleQueryParameters; class Painter; class FileSource; class AsyncRequest; class TransformState; class Tile; struct ClipID; + +namespace style { + +class Style; +class UpdateParameters; +class QueryParameters; class SourceObserver; class Source : private util::noncopyable { @@ -39,7 +43,7 @@ public: const std::string& id, const std::string& url, uint16_t tileSize, - std::unique_ptr<SourceInfo>&&, + std::unique_ptr<Tileset>&&, std::unique_ptr<mapbox::geojsonvt::GeoJSONVT>&&); ~Source(); @@ -48,13 +52,13 @@ public: bool isLoading() const; bool isLoaded() const; - const SourceInfo* getInfo() const { return info.get(); } + const Tileset* getTileset() const { return tileset.get(); } // Request or parse all the tiles relevant for the "TransformState". This method // will return true if all the tiles were scheduled for updating of false if // they were not. shouldReparsePartialTiles must be set to "true" if there is // new data available that a tile in the "partial" state might be interested at. - bool update(const StyleUpdateParameters&); + bool update(const UpdateParameters&); template <typename ClipIDGenerator> void updateClipIDs(ClipIDGenerator& generator) { @@ -69,7 +73,7 @@ public: TileData* getTileData(const OverscaledTileID&) const; std::unordered_map<std::string, std::vector<Feature>> - queryRenderedFeatures(const StyleQueryParameters&) const; + queryRenderedFeatures(const QueryParameters&) const; void setCacheSize(size_t); void onLowMemory(); @@ -86,11 +90,10 @@ public: private: void tileLoadingCallback(const OverscaledTileID&, std::exception_ptr, bool isNewTile); - std::unique_ptr<TileData> createTile(const OverscaledTileID&, - const StyleUpdateParameters& parameters); + std::unique_ptr<TileData> createTile(const OverscaledTileID&, const UpdateParameters&); private: - std::unique_ptr<const SourceInfo> info; + std::unique_ptr<const Tileset> tileset; std::unique_ptr<mapbox::geojsonvt::GeoJSONVT> geojsonvt; @@ -106,4 +109,5 @@ private: SourceObserver* observer = nullptr; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/source/source_observer.hpp b/src/mbgl/style/source_observer.hpp index 828e562a3e..a669e8e756 100644 --- a/src/mbgl/source/source_observer.hpp +++ b/src/mbgl/style/source_observer.hpp @@ -4,9 +4,12 @@ namespace mbgl { -class Source; class OverscaledTileID; +namespace style { + +class Source; + class SourceObserver { public: virtual ~SourceObserver() = default; @@ -18,4 +21,5 @@ public: virtual void onPlacementRedone() {} }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/style.cpp b/src/mbgl/style/style.cpp index ee847ccf57..136c98df03 100644 --- a/src/mbgl/style/style.cpp +++ b/src/mbgl/style/style.cpp @@ -1,23 +1,23 @@ #include <mbgl/style/style.hpp> -#include <mbgl/style/style_observer.hpp> -#include <mbgl/source/source.hpp> +#include <mbgl/style/observer.hpp> +#include <mbgl/style/source.hpp> #include <mbgl/tile/tile.hpp> #include <mbgl/map/transform_state.hpp> -#include <mbgl/layer/symbol_layer.hpp> -#include <mbgl/layer/symbol_layer_impl.hpp> -#include <mbgl/layer/custom_layer.hpp> -#include <mbgl/layer/custom_layer_impl.hpp> -#include <mbgl/layer/background_layer.hpp> -#include <mbgl/layer/background_layer_impl.hpp> +#include <mbgl/style/layers/symbol_layer.hpp> +#include <mbgl/style/layers/symbol_layer_impl.hpp> +#include <mbgl/style/layers/custom_layer.hpp> +#include <mbgl/style/layers/custom_layer_impl.hpp> +#include <mbgl/style/layers/background_layer.hpp> +#include <mbgl/style/layers/background_layer_impl.hpp> #include <mbgl/sprite/sprite_store.hpp> #include <mbgl/sprite/sprite_atlas.hpp> -#include <mbgl/layer/layer_impl.hpp> -#include <mbgl/style/style_parser.hpp> -#include <mbgl/style/property_transition.hpp> +#include <mbgl/style/layer_impl.hpp> +#include <mbgl/style/parser.hpp> +#include <mbgl/style/transition_options.hpp> #include <mbgl/style/class_dictionary.hpp> -#include <mbgl/style/style_update_parameters.hpp> -#include <mbgl/style/style_cascade_parameters.hpp> -#include <mbgl/style/style_calculation_parameters.hpp> +#include <mbgl/style/update_parameters.hpp> +#include <mbgl/style/cascade_parameters.hpp> +#include <mbgl/style/calculation_parameters.hpp> #include <mbgl/geometry/glyph_atlas.hpp> #include <mbgl/geometry/line_atlas.hpp> #include <mbgl/util/constants.hpp> @@ -30,10 +30,11 @@ #include <algorithm> namespace mbgl { +namespace style { -static StyleObserver nullObserver; +static Observer nullObserver; -bool Style::addClass(const std::string& className, const PropertyTransition& properties) { +bool Style::addClass(const std::string& className, const TransitionOptions& properties) { if (std::find(classes.begin(), classes.end(), className) != classes.end()) return false; classes.push_back(className); transitionProperties = properties; @@ -44,7 +45,7 @@ bool Style::hasClass(const std::string& className) const { return std::find(classes.begin(), classes.end(), className) != classes.end(); } -bool Style::removeClass(const std::string& className, const PropertyTransition& properties) { +bool Style::removeClass(const std::string& className, const TransitionOptions& properties) { const auto it = std::find(classes.begin(), classes.end(), className); if (it != classes.end()) { classes.erase(it); @@ -54,7 +55,7 @@ bool Style::removeClass(const std::string& className, const PropertyTransition& return false; } -void Style::setClasses(const std::vector<std::string>& classNames, const PropertyTransition& properties) { +void Style::setClasses(const std::vector<std::string>& classNames, const TransitionOptions& properties) { classes = classNames; transitionProperties = properties; } @@ -81,7 +82,7 @@ void Style::setJSON(const std::string& json, const std::string&) { layers.clear(); classes.clear(); - StyleParser parser; + Parser parser; parser.parse(json); for (auto& source : parser.sources) { @@ -153,7 +154,7 @@ void Style::removeLayer(const std::string& id) { layers.erase(it); } -void Style::update(const StyleUpdateParameters& parameters) { +void Style::update(const UpdateParameters& parameters) { bool allTilesUpdated = true; for (const auto& source : sources) { @@ -172,7 +173,7 @@ void Style::update(const StyleUpdateParameters& parameters) { void Style::cascade(const TimePoint& timePoint, MapMode mode) { // When in continuous mode, we can either have user- or style-defined // transitions. Still mode is always immediate. - static const PropertyTransition immediateTransition; + static const TransitionOptions immediateTransition; std::vector<ClassID> classIDs; for (const auto& className : classes) { @@ -181,7 +182,7 @@ void Style::cascade(const TimePoint& timePoint, MapMode mode) { classIDs.push_back(ClassID::Default); classIDs.push_back(ClassID::Fallback); - const StyleCascadeParameters parameters { + const CascadeParameters parameters { classIDs, mode == MapMode::Continuous ? timePoint : Clock::time_point::max(), mode == MapMode::Continuous ? transitionProperties.value_or(immediateTransition) : immediateTransition @@ -201,7 +202,7 @@ void Style::recalculate(float z, const TimePoint& timePoint, MapMode mode) { zoomHistory.update(z, timePoint); - const StyleCalculationParameters parameters { + const CalculationParameters parameters { z, mode == MapMode::Continuous ? timePoint : Clock::time_point::max(), zoomHistory, @@ -325,7 +326,7 @@ RenderData Style::getRenderData() const { return result; } -std::vector<Feature> Style::queryRenderedFeatures(const StyleQueryParameters& parameters) const { +std::vector<Feature> Style::queryRenderedFeatures(const QueryParameters& parameters) const { std::unordered_map<std::string, std::vector<Feature>> resultsByLayer; for (const auto& source : sources) { @@ -367,7 +368,7 @@ void Style::onLowMemory() { } } -void Style::setObserver(StyleObserver* observer_) { +void Style::setObserver(style::Observer* observer_) { observer = observer_; } @@ -440,4 +441,5 @@ void Style::dumpDebugLogs() const { spriteStore->dumpDebugLogs(); } +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/style.hpp b/src/mbgl/style/style.hpp index 6892f4967a..49af674336 100644 --- a/src/mbgl/style/style.hpp +++ b/src/mbgl/style/style.hpp @@ -1,20 +1,21 @@ #pragma once #include <mbgl/style/render_item.hpp> -#include <mbgl/style/zoom_history.hpp> -#include <mbgl/style/types.hpp> -#include <mbgl/style/property_transition.hpp> +#include <mbgl/style/transition_options.hpp> -#include <mbgl/source/source_observer.hpp> +#include <mbgl/style/observer.hpp> +#include <mbgl/style/source_observer.hpp> #include <mbgl/text/glyph_store_observer.hpp> #include <mbgl/sprite/sprite_store_observer.hpp> #include <mbgl/map/mode.hpp> +#include <mbgl/map/zoom_history.hpp> #include <mbgl/util/noncopyable.hpp> #include <mbgl/util/chrono.hpp> #include <mbgl/util/worker.hpp> #include <mbgl/util/optional.hpp> #include <mbgl/util/feature.hpp> +#include <mbgl/util/color.hpp> #include <cstdint> #include <string> @@ -25,20 +26,20 @@ namespace mbgl { class FileSource; class GlyphAtlas; -class GlyphStore; -class SpriteStore; class SpriteAtlas; class LineAtlas; -class StyleUpdateParameters; -class StyleQueryParameters; -class StyleObserver; struct RenderData { Color backgroundColor = {{ 0, 0, 0, 0 }}; - std::set<Source*> sources; + std::set<style::Source*> sources; std::vector<RenderItem> order; }; +namespace style { + +class UpdateParameters; +class QueryParameters; + class Style : public GlyphStoreObserver, public SpriteStoreObserver, public SourceObserver, @@ -49,13 +50,13 @@ public: void setJSON(const std::string& data, const std::string& base); - void setObserver(StyleObserver*); + void setObserver(Observer*); bool isLoaded() const; // Fetch the tiles needed by the current viewport and emit a signal when // a tile is ready so observers can render the tile. - void update(const StyleUpdateParameters&); + void update(const UpdateParameters&); void cascade(const TimePoint&, MapMode); void recalculate(float z, const TimePoint&, MapMode); @@ -75,15 +76,15 @@ public: optional<std::string> beforeLayerID = {}); void removeLayer(const std::string& layerID); - bool addClass(const std::string&, const PropertyTransition& = {}); - bool removeClass(const std::string&, const PropertyTransition& = {}); + bool addClass(const std::string&, const TransitionOptions& = {}); + bool removeClass(const std::string&, const TransitionOptions& = {}); bool hasClass(const std::string&) const; - void setClasses(const std::vector<std::string>&, const PropertyTransition& = {}); + void setClasses(const std::vector<std::string>&, const TransitionOptions& = {}); std::vector<std::string> getClasses() const; RenderData getRenderData() const; - std::vector<Feature> queryRenderedFeatures(const StyleQueryParameters&) const; + std::vector<Feature> queryRenderedFeatures(const QueryParameters&) const; float getQueryRadius() const; @@ -103,7 +104,7 @@ private: std::vector<std::unique_ptr<Source>> sources; std::vector<std::unique_ptr<Layer>> layers; std::vector<std::string> classes; - optional<PropertyTransition> transitionProperties; + optional<TransitionOptions> transitionProperties; std::vector<std::unique_ptr<Layer>>::const_iterator findLayer(const std::string& layerID) const; @@ -122,7 +123,8 @@ private: void onTileError(Source&, const OverscaledTileID&, std::exception_ptr) override; void onPlacementRedone() override; - StyleObserver* observer = nullptr; + Observer nullObserver; + Observer* observer = &nullObserver; std::exception_ptr lastError; @@ -135,4 +137,5 @@ public: Worker workers; }; +} // namespace style } // namespace mbgl diff --git a/src/mbgl/style/style_calculation_parameters.hpp b/src/mbgl/style/style_calculation_parameters.hpp deleted file mode 100644 index 1c50bd6128..0000000000 --- a/src/mbgl/style/style_calculation_parameters.hpp +++ /dev/null @@ -1,28 +0,0 @@ -#pragma once - -#include <mbgl/style/zoom_history.hpp> -#include <mbgl/util/chrono.hpp> - -namespace mbgl { - -class StyleCalculationParameters { -public: - explicit StyleCalculationParameters(float z_) - : z(z_) {} - - StyleCalculationParameters(float z_, - const TimePoint& now_, - const ZoomHistory& zoomHistory_, - const Duration& defaultFadeDuration_) - : z(z_), - now(now_), - zoomHistory(zoomHistory_), - defaultFadeDuration(defaultFadeDuration_) {} - - float z; - TimePoint now; - ZoomHistory zoomHistory; - Duration defaultFadeDuration; -}; - -} // namespace mbgl diff --git a/src/mbgl/style/style_cascade_parameters.hpp b/src/mbgl/style/style_cascade_parameters.hpp deleted file mode 100644 index 569145bd04..0000000000 --- a/src/mbgl/style/style_cascade_parameters.hpp +++ /dev/null @@ -1,20 +0,0 @@ -#pragma once - -#include <mbgl/map/mode.hpp> -#include <mbgl/util/chrono.hpp> -#include <mbgl/style/types.hpp> - -#include <vector> - -namespace mbgl { - -class PropertyTransition; - -class StyleCascadeParameters { -public: - std::vector<ClassID> classes; - TimePoint now; - PropertyTransition transition; -}; - -} // namespace mbgl diff --git a/src/mbgl/style/style_render_parameters.hpp b/src/mbgl/style/style_render_parameters.hpp deleted file mode 100644 index 7347717a1d..0000000000 --- a/src/mbgl/style/style_render_parameters.hpp +++ /dev/null @@ -1,15 +0,0 @@ -#pragma once - -namespace mbgl { - -class TransformState; - -class StyleRenderParameters { -public: - StyleRenderParameters(const TransformState& state_) - : state(state_) {} - - const TransformState& state; -}; - -} diff --git a/src/mbgl/style/style_update_parameters.hpp b/src/mbgl/style/update_parameters.hpp index 73ed500e8e..9faaa32d6f 100644 --- a/src/mbgl/style/style_update_parameters.hpp +++ b/src/mbgl/style/update_parameters.hpp @@ -7,13 +7,16 @@ namespace mbgl { class TransformState; class Worker; class FileSource; -class Style; namespace gl { class TexturePool; } class AnnotationManager; -class StyleUpdateParameters { +namespace style { + +class Style; + +class UpdateParameters { public: - StyleUpdateParameters(float pixelRatio_, + UpdateParameters(float pixelRatio_, MapDebugOptions debugOptions_, TimePoint animationTime_, const TransformState& transformState_, @@ -51,4 +54,5 @@ public: Style& style; }; -} +} // namespace style +} // namespace mbgl diff --git a/src/mbgl/text/glyph_pbf.hpp b/src/mbgl/text/glyph_pbf.hpp index 08616b268b..85f4b62e6f 100644 --- a/src/mbgl/text/glyph_pbf.hpp +++ b/src/mbgl/text/glyph_pbf.hpp @@ -2,7 +2,7 @@ #include <mbgl/text/glyph.hpp> #include <mbgl/text/glyph_store.hpp> -#include <mbgl/style/types.hpp> +#include <mbgl/util/font_stack.hpp> #include <mbgl/util/noncopyable.hpp> #include <atomic> diff --git a/src/mbgl/text/glyph_store.hpp b/src/mbgl/text/glyph_store.hpp index d614a4947f..edc89b4894 100644 --- a/src/mbgl/text/glyph_store.hpp +++ b/src/mbgl/text/glyph_store.hpp @@ -2,7 +2,7 @@ #include <mbgl/text/glyph.hpp> #include <mbgl/text/glyph_set.hpp> -#include <mbgl/style/types.hpp> +#include <mbgl/util/font_stack.hpp> #include <mbgl/util/exclusive.hpp> #include <mbgl/util/noncopyable.hpp> #include <mbgl/util/work_queue.hpp> diff --git a/src/mbgl/text/glyph_store_observer.hpp b/src/mbgl/text/glyph_store_observer.hpp index 89650892ea..39f10cd812 100644 --- a/src/mbgl/text/glyph_store_observer.hpp +++ b/src/mbgl/text/glyph_store_observer.hpp @@ -2,6 +2,7 @@ #include <mbgl/style/types.hpp> #include <mbgl/text/glyph_range.hpp> +#include <mbgl/util/font_stack.hpp> #include <exception> diff --git a/src/mbgl/text/quads.cpp b/src/mbgl/text/quads.cpp index 3cb508a102..ce320791c3 100644 --- a/src/mbgl/text/quads.cpp +++ b/src/mbgl/text/quads.cpp @@ -2,13 +2,15 @@ #include <mbgl/text/shaping.hpp> #include <mbgl/tile/geometry_tile.hpp> #include <mbgl/geometry/anchor.hpp> -#include <mbgl/layer/symbol_layer_properties.hpp> +#include <mbgl/style/layers/symbol_layer_properties.hpp> #include <mbgl/util/math.hpp> #include <mbgl/util/constants.hpp> #include <cassert> namespace mbgl { +using namespace style; + const float globalMinScale = 0.5f; // underscale by 1 zoom level SymbolQuads getIconQuads(Anchor& anchor, const PositionedIcon& shapedIcon, diff --git a/src/mbgl/text/quads.hpp b/src/mbgl/text/quads.hpp index c68ea2fe6a..0627647f4c 100644 --- a/src/mbgl/text/quads.hpp +++ b/src/mbgl/text/quads.hpp @@ -7,39 +7,43 @@ namespace mbgl { - struct SymbolQuad { - explicit SymbolQuad(const Point<float> &tl_, const Point<float> &tr_, - const Point<float> &bl_, const Point<float> &br_, - const Rect<uint16_t> &tex_, float angle_, const Point<float> &anchorPoint_, - float minScale_, float maxScale_) - : tl(tl_), - tr(tr_), - bl(bl_), - br(br_), - tex(tex_), - angle(angle_), - anchorPoint(anchorPoint_), - minScale(minScale_), - maxScale(maxScale_) {} - - Point<float> tl, tr, bl, br; - Rect<uint16_t> tex; - float angle; - Point<float> anchorPoint; - float minScale, maxScale; - }; - - typedef std::vector<SymbolQuad> SymbolQuads; - - struct Anchor; - class SymbolLayoutProperties; - class PositionedIcon; - - SymbolQuads getIconQuads(Anchor& anchor, const PositionedIcon& shapedIcon, - const GeometryCoordinates& line, const SymbolLayoutProperties& layout, - const bool alongLine); - - SymbolQuads getGlyphQuads(Anchor& anchor, const Shaping& shapedText, - const float boxScale, const GeometryCoordinates& line, const SymbolLayoutProperties& layout, - const bool alongLine, const GlyphPositions& face); +struct Anchor; +class PositionedIcon; + +namespace style { +class SymbolLayoutProperties; +} + +struct SymbolQuad { + explicit SymbolQuad(const Point<float> &tl_, const Point<float> &tr_, + const Point<float> &bl_, const Point<float> &br_, + const Rect<uint16_t> &tex_, float angle_, const Point<float> &anchorPoint_, + float minScale_, float maxScale_) + : tl(tl_), + tr(tr_), + bl(bl_), + br(br_), + tex(tex_), + angle(angle_), + anchorPoint(anchorPoint_), + minScale(minScale_), + maxScale(maxScale_) {} + + Point<float> tl, tr, bl, br; + Rect<uint16_t> tex; + float angle; + Point<float> anchorPoint; + float minScale, maxScale; +}; + +typedef std::vector<SymbolQuad> SymbolQuads; + +SymbolQuads getIconQuads(Anchor& anchor, const PositionedIcon& shapedIcon, + const GeometryCoordinates& line, const style::SymbolLayoutProperties&, + const bool alongLine); + +SymbolQuads getGlyphQuads(Anchor& anchor, const Shaping& shapedText, + const float boxScale, const GeometryCoordinates& line, const style::SymbolLayoutProperties&, + const bool alongLine, const GlyphPositions& face); + } // namespace mbgl diff --git a/src/mbgl/text/shaping.cpp b/src/mbgl/text/shaping.cpp index ce93b4977e..1091cd6e94 100644 --- a/src/mbgl/text/shaping.cpp +++ b/src/mbgl/text/shaping.cpp @@ -1,9 +1,9 @@ #include <mbgl/text/shaping.hpp> -#include <mbgl/layer/symbol_layer_properties.hpp> +#include <mbgl/style/layers/symbol_layer_properties.hpp> namespace mbgl { -PositionedIcon shapeIcon(const SpriteAtlasElement& image, const SymbolLayoutProperties& layout) { +PositionedIcon shapeIcon(const SpriteAtlasElement& image, const style::SymbolLayoutProperties& layout) { float dx = layout.iconOffset.value[0]; float dy = layout.iconOffset.value[1]; float x1 = dx - image.spriteImage->getWidth() / 2.0f; diff --git a/src/mbgl/text/shaping.hpp b/src/mbgl/text/shaping.hpp index ea169b8dc6..f81230acec 100644 --- a/src/mbgl/text/shaping.hpp +++ b/src/mbgl/text/shaping.hpp @@ -7,26 +7,28 @@ namespace mbgl { - struct SpriteAtlasElement; +struct SpriteAtlasElement; - class PositionedIcon { - public: - inline explicit PositionedIcon() {} - inline explicit PositionedIcon(const SpriteAtlasElement& _image, - float _top, float _bottom, float _left, float _right) : - image(_image), top(_top), bottom(_bottom), left(_left), right(_right) {} +namespace style { +class SymbolLayoutProperties; +} - optional<SpriteAtlasElement> image; - float top = 0; - float bottom = 0; - float left = 0; - float right = 0; +class PositionedIcon { + public: + inline explicit PositionedIcon() {} + inline explicit PositionedIcon(const SpriteAtlasElement& _image, + float _top, float _bottom, float _left, float _right) : + image(_image), top(_top), bottom(_bottom), left(_left), right(_right) {} - operator bool() const { return image && (*image).pos.hasArea(); } - }; + optional<SpriteAtlasElement> image; + float top = 0; + float bottom = 0; + float left = 0; + float right = 0; - class SymbolLayoutProperties; + operator bool() const { return image && (*image).pos.hasArea(); } +}; - PositionedIcon shapeIcon(const SpriteAtlasElement& image, const SymbolLayoutProperties&); +PositionedIcon shapeIcon(const SpriteAtlasElement& image, const style::SymbolLayoutProperties&); } // namespace mbgl diff --git a/src/mbgl/tile/raster_tile_data.cpp b/src/mbgl/tile/raster_tile_data.cpp index a5eab3fb23..420cb7055e 100644 --- a/src/mbgl/tile/raster_tile_data.cpp +++ b/src/mbgl/tile/raster_tile_data.cpp @@ -1,5 +1,5 @@ #include <mbgl/tile/raster_tile_data.hpp> -#include <mbgl/source/source.hpp> +#include <mbgl/style/source.hpp> #include <mbgl/storage/resource.hpp> #include <mbgl/storage/response.hpp> #include <mbgl/storage/file_source.hpp> @@ -61,7 +61,7 @@ RasterTileData::~RasterTileData() { cancel(); } -Bucket* RasterTileData::getBucket(const Layer&) { +Bucket* RasterTileData::getBucket(const style::Layer&) { return bucket.get(); } diff --git a/src/mbgl/tile/raster_tile_data.hpp b/src/mbgl/tile/raster_tile_data.hpp index ea9b144e25..62d21d28c4 100644 --- a/src/mbgl/tile/raster_tile_data.hpp +++ b/src/mbgl/tile/raster_tile_data.hpp @@ -7,9 +7,13 @@ namespace mbgl { class FileSource; class AsyncRequest; -class Layer; + namespace gl { class TexturePool; } +namespace style { +class Layer; +} + class RasterTileData : public TileData { public: RasterTileData(const OverscaledTileID&, @@ -22,7 +26,7 @@ public: ~RasterTileData(); void cancel() override; - Bucket* getBucket(const Layer&) override; + Bucket* getBucket(const style::Layer&) override; private: gl::TexturePool& texturePool; diff --git a/src/mbgl/tile/tile_data.hpp b/src/mbgl/tile/tile_data.hpp index 035a7ed319..5b6583faf8 100644 --- a/src/mbgl/tile/tile_data.hpp +++ b/src/mbgl/tile/tile_data.hpp @@ -16,11 +16,14 @@ namespace mbgl { -class Layer; class Worker; class DebugBucket; class TransformState; +namespace style { +class Layer; +} + class TileData : private util::noncopyable { public: TileData(const OverscaledTileID&); @@ -29,7 +32,7 @@ public: // Mark this tile as no longer needed and cancel any pending work. virtual void cancel() = 0; - virtual Bucket* getBucket(const Layer&) = 0; + virtual Bucket* getBucket(const style::Layer&) = 0; virtual bool parsePending(std::function<void (std::exception_ptr)>) { return true; } virtual void redoPlacement(PlacementConfig, const std::function<void()>&) {} diff --git a/src/mbgl/tile/tile_worker.cpp b/src/mbgl/tile/tile_worker.cpp index 9076684a2d..b2283043da 100644 --- a/src/mbgl/tile/tile_worker.cpp +++ b/src/mbgl/tile/tile_worker.cpp @@ -1,11 +1,11 @@ #include <mbgl/text/collision_tile.hpp> #include <mbgl/tile/tile_worker.hpp> #include <mbgl/tile/geometry_tile.hpp> -#include <mbgl/style/style_bucket_parameters.hpp> -#include <mbgl/layer/background_layer.hpp> -#include <mbgl/layer/custom_layer.hpp> -#include <mbgl/layer/symbol_layer.hpp> -#include <mbgl/layer/symbol_layer_impl.hpp> +#include <mbgl/style/bucket_parameters.hpp> +#include <mbgl/style/layers/background_layer.hpp> +#include <mbgl/style/layers/custom_layer.hpp> +#include <mbgl/style/layers/symbol_layer.hpp> +#include <mbgl/style/layers/symbol_layer_impl.hpp> #include <mbgl/sprite/sprite_atlas.hpp> #include <mbgl/geometry/glyph_atlas.hpp> #include <mbgl/renderer/symbol_bucket.hpp> @@ -15,7 +15,9 @@ #include <mbgl/util/exception.hpp> #include <utility> -using namespace mbgl; +namespace mbgl { + +using namespace mbgl::style; TileWorker::TileWorker(const OverscaledTileID& id_, std::string sourceID_, @@ -155,7 +157,7 @@ void TileWorker::parseLayer(const Layer* layer) { return; } - StyleBucketParameters parameters(id, + BucketParameters parameters(id, *geometryLayer, obsolete, reinterpret_cast<uintptr_t>(this), @@ -185,3 +187,5 @@ void TileWorker::insertBucket(const std::string& name, std::unique_ptr<Bucket> b result.buckets.emplace(name, std::move(bucket)); } } + +} diff --git a/src/mbgl/tile/tile_worker.hpp b/src/mbgl/tile/tile_worker.hpp index a04ef6a78f..2757c0f9ba 100644 --- a/src/mbgl/tile/tile_worker.hpp +++ b/src/mbgl/tile/tile_worker.hpp @@ -23,8 +23,11 @@ class SpriteStore; class GlyphAtlas; class GlyphStore; class Bucket; + +namespace style { class Layer; class SymbolLayer; +} // We're using this class to shuttle the resulting buckets from the worker thread to the MapContext // thread. This class is movable-only because the vector contains movable-only value elements. @@ -51,7 +54,7 @@ public: const MapMode); ~TileWorker(); - TileParseResult parseAllLayers(std::vector<std::unique_ptr<Layer>>, + TileParseResult parseAllLayers(std::vector<std::unique_ptr<style::Layer>>, std::unique_ptr<const GeometryTile> geometryTile, PlacementConfig); @@ -62,7 +65,7 @@ public: private: TileParseResult prepareResult(const PlacementConfig& config); - void parseLayer(const Layer*); + void parseLayer(const style::Layer*); void insertBucket(const std::string& name, std::unique_ptr<Bucket>); std::unique_ptr<CollisionTile> placeLayers(PlacementConfig); @@ -77,14 +80,14 @@ private: bool partialParse = false; - std::vector<std::unique_ptr<Layer>> layers; + std::vector<std::unique_ptr<style::Layer>> layers; std::unique_ptr<FeatureIndex> featureIndex; std::unique_ptr<const GeometryTile> geometryTile; // Contains buckets that we couldn't parse so far due to missing resources. // They will be attempted on subsequent parses. - std::list<std::pair<const SymbolLayer*, std::unique_ptr<Bucket>>> pending; + std::list<std::pair<const style::SymbolLayer*, std::unique_ptr<Bucket>>> pending; // Contains buckets that have been parsed, but still need placement. // They will be placed when all buckets have been parsed. diff --git a/src/mbgl/tile/vector_tile.cpp b/src/mbgl/tile/vector_tile.cpp index 8a69a82314..5126d0ce83 100644 --- a/src/mbgl/tile/vector_tile.cpp +++ b/src/mbgl/tile/vector_tile.cpp @@ -1,5 +1,5 @@ #include <mbgl/tile/vector_tile.hpp> -#include <mbgl/source/source.hpp> +#include <mbgl/style/source.hpp> #include <mbgl/storage/resource.hpp> #include <mbgl/storage/response.hpp> #include <mbgl/storage/file_source.hpp> diff --git a/src/mbgl/tile/vector_tile_data.cpp b/src/mbgl/tile/vector_tile_data.cpp index db0ec8029e..1ab2566a25 100644 --- a/src/mbgl/tile/vector_tile_data.cpp +++ b/src/mbgl/tile/vector_tile_data.cpp @@ -1,6 +1,6 @@ #include <mbgl/tile/vector_tile_data.hpp> #include <mbgl/tile/geometry_tile.hpp> -#include <mbgl/layer/layer_impl.hpp> +#include <mbgl/style/layer_impl.hpp> #include <mbgl/util/worker.hpp> #include <mbgl/util/work_request.hpp> #include <mbgl/style/style.hpp> @@ -14,7 +14,7 @@ namespace mbgl { VectorTileData::VectorTileData(const OverscaledTileID& id_, std::unique_ptr<GeometryTileMonitor> monitor_, std::string sourceID, - Style& style_, + style::Style& style_, const MapMode mode_, const std::function<void(std::exception_ptr)>& callback) : TileData(id_), @@ -139,7 +139,7 @@ bool VectorTileData::parsePending(std::function<void(std::exception_ptr)> callba return true; } -Bucket* VectorTileData::getBucket(const Layer& layer) { +Bucket* VectorTileData::getBucket(const style::Layer& layer) { const auto it = buckets.find(layer.baseImpl->bucketName()); if (it == buckets.end()) { return nullptr; diff --git a/src/mbgl/tile/vector_tile_data.hpp b/src/mbgl/tile/vector_tile_data.hpp index 4695338e1e..e7de39e038 100644 --- a/src/mbgl/tile/vector_tile_data.hpp +++ b/src/mbgl/tile/vector_tile_data.hpp @@ -11,23 +11,26 @@ namespace mbgl { -class Style; class AsyncRequest; class GeometryTileMonitor; class FeatureIndex; +namespace style { +class Style; +} + class VectorTileData : public TileData { public: VectorTileData(const OverscaledTileID&, std::unique_ptr<GeometryTileMonitor> monitor, std::string sourceID, - Style&, + style::Style&, const MapMode, const std::function<void(std::exception_ptr)>& callback); ~VectorTileData(); - Bucket* getBucket(const Layer&) override; + Bucket* getBucket(const style::Layer&) override; bool parsePending(std::function<void(std::exception_ptr)> callback) override; @@ -43,7 +46,7 @@ public: void cancel() override; private: - Style& style; + style::Style& style; Worker& worker; TileWorker tileWorker; diff --git a/src/mbgl/style/types.cpp b/src/mbgl/util/font_stack.cpp index 27574afa93..fb3b1b60a2 100644 --- a/src/mbgl/style/types.cpp +++ b/src/mbgl/util/font_stack.cpp @@ -1,4 +1,4 @@ -#include <mbgl/style/types.hpp> +#include <mbgl/util/font_stack.hpp> #include <boost/functional/hash.hpp> #include <boost/algorithm/string/join.hpp> diff --git a/src/mbgl/source/source_info.hpp b/src/mbgl/util/tileset.hpp index dc79695dc9..972fc51f8c 100644 --- a/src/mbgl/source/source_info.hpp +++ b/src/mbgl/util/tileset.hpp @@ -1,6 +1,5 @@ #pragma once -#include <mbgl/style/types.hpp> #include <mbgl/util/constants.hpp> #include <mbgl/util/geo.hpp> @@ -11,9 +10,7 @@ namespace mbgl { -class TileID; - -class SourceInfo { +class Tileset { public: std::vector<std::string> tiles; uint8_t minZoom = 0; diff --git a/src/mbgl/util/worker.cpp b/src/mbgl/util/worker.cpp index 43abe6792a..2bc545c704 100644 --- a/src/mbgl/util/worker.cpp +++ b/src/mbgl/util/worker.cpp @@ -30,7 +30,7 @@ public: } void parseGeometryTile(TileWorker* worker, - std::vector<std::unique_ptr<Layer>> layers, + std::vector<std::unique_ptr<style::Layer>> layers, std::unique_ptr<GeometryTile> tile, PlacementConfig config, std::function<void(TileParseResult)> callback) { @@ -79,7 +79,7 @@ Worker::parseRasterTile(std::unique_ptr<RasterBucket> bucket, std::unique_ptr<AsyncRequest> Worker::parseGeometryTile(TileWorker& worker, - std::vector<std::unique_ptr<Layer>> layers, + std::vector<std::unique_ptr<style::Layer>> layers, std::unique_ptr<GeometryTile> tile, PlacementConfig config, std::function<void(TileParseResult)> callback) { diff --git a/src/mbgl/util/worker.hpp b/src/mbgl/util/worker.hpp index 68625f42bf..678dfaedb3 100644 --- a/src/mbgl/util/worker.hpp +++ b/src/mbgl/util/worker.hpp @@ -40,7 +40,7 @@ public: std::function<void(RasterTileParseResult)> callback); Request parseGeometryTile(TileWorker&, - std::vector<std::unique_ptr<Layer>>, + std::vector<std::unique_ptr<style::Layer>>, std::unique_ptr<GeometryTile>, PlacementConfig, std::function<void(TileParseResult)> callback); |