From ac64a4a660a6f2bc4ac2c81895620b1061cb5ff5 Mon Sep 17 00:00:00 2001 From: Chris Loer Date: Mon, 2 Oct 2017 15:31:03 -0700 Subject: Initial implementation of "PlacementState": intended to be used by renderer to pause and restart placement. --- cmake/core-files.cmake | 2 + src/mbgl/renderer/placement_state.cpp | 103 ++++++++++++++++++++++++++++++++++ src/mbgl/renderer/placement_state.hpp | 70 +++++++++++++++++++++++ src/mbgl/renderer/render_layer.hpp | 3 + src/mbgl/tile/tile.hpp | 7 +++ 5 files changed, 185 insertions(+) create mode 100644 src/mbgl/renderer/placement_state.cpp create mode 100644 src/mbgl/renderer/placement_state.hpp diff --git a/cmake/core-files.cmake b/cmake/core-files.cmake index 2eadc747d1..4d10952da5 100644 --- a/cmake/core-files.cmake +++ b/cmake/core-files.cmake @@ -179,6 +179,8 @@ set(MBGL_CORE_FILES src/mbgl/renderer/paint_parameters.hpp src/mbgl/renderer/paint_property_binder.hpp src/mbgl/renderer/paint_property_statistics.hpp + src/mbgl/renderer/placement_state.hpp + src/mbgl/renderer/placement_state.cpp src/mbgl/renderer/possibly_evaluated_property_value.hpp src/mbgl/renderer/property_evaluation_parameters.hpp src/mbgl/renderer/property_evaluator.hpp diff --git a/src/mbgl/renderer/placement_state.cpp b/src/mbgl/renderer/placement_state.cpp new file mode 100644 index 0000000000..f00001ec23 --- /dev/null +++ b/src/mbgl/renderer/placement_state.cpp @@ -0,0 +1,103 @@ +#include +#include +#include +#include +#include +#include + + +namespace mbgl { + +LayerPlacementState::LayerPlacementState() : currentTileIndex(0) +{ +} + +bool LayerPlacementState::continuePlacement(RenderSymbolLayer& layer, + CollisionIndex& collisionIndex, + const bool showCollisionBoxes, + std::function shouldPausePlacement) { + while (currentTileIndex < layer.renderTiles.size()) { + RenderTile& tile = layer.renderTiles[currentTileIndex++]; + tile.tile.placeLayer(showCollisionBoxes, collisionIndex, layer.impl()); + + if (shouldPausePlacement()) { + return true; + } + } + return false; +} + +PlacementState::PlacementState(const TransformState& transformState, + const std::vector& order, + const bool forceFullPlacement_, + const bool showCollisionBoxes_, + Duration fadeDuration, + optional& previousPlacement) + : collisionIndex(transformState) + , currentLayerIndex(order.size() - 1) + , forceFullPlacement(forceFullPlacement_) + , showCollisionBoxes(showCollisionBoxes_) +{ + if (forceFullPlacement || !previousPlacement) { + delayUntil = TimePoint(); + } else { + delayUntil = previousPlacement->delayUntil + Milliseconds(300); + } + + if (previousPlacement) { + collisionFadeTimes = previousPlacement->collisionFadeTimes; + } else { + collisionFadeTimes = { TimePoint::min(), fadeDuration }; + } +} + +void PlacementState::continuePlacement(std::vector& order, std::vector& sources) { + const TimePoint startTime; + + if (startTime < delayUntil) return; + + auto shouldPausePlacement = [&] () { + const Duration elapsedTime = TimePoint() - startTime; + return forceFullPlacement ? false : elapsedTime > Milliseconds(2); + }; + + do { + RenderLayer& renderLayer = order[currentLayerIndex]; + if (renderLayer.is()) { + if (inProgressLayer) { + inProgressLayer = LayerPlacementState(); + } + + bool pausePlacement = inProgressLayer->continuePlacement(*renderLayer.as(), + collisionIndex, + showCollisionBoxes, + shouldPausePlacement); + + if (pausePlacement) { + // We didn't finish placing all layers within 2ms, + // but we can keep rendering with a partial placement + // We'll resume here on the next frame + return; + } + + inProgressLayer = std::experimental::nullopt; + } + + currentLayerIndex--; + } while (currentLayerIndex > 0); + + for (RenderSource& source : sources) { + auto tiles = source.getRenderTiles(); + for (RenderTile& tile : tiles) { + tile.tile.commitPlacement(collisionIndex, collisionFadeTimes); + } + } + + done = true; +} + +bool PlacementState::stillFading() const { + return TimePoint() < collisionFadeTimes.latestStart + collisionFadeTimes.fadeDuration; +} + +}; // mbgl diff --git a/src/mbgl/renderer/placement_state.hpp b/src/mbgl/renderer/placement_state.hpp new file mode 100644 index 0000000000..07c655ca03 --- /dev/null +++ b/src/mbgl/renderer/placement_state.hpp @@ -0,0 +1,70 @@ +#pragma once + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +namespace mbgl { + +// TODO: Placeholder +class CollisionIndex { +public: + CollisionIndex(const TransformState&) {} +}; + +class RenderLayer; +class RenderSymbolLayer; +class RenderSource; + +struct CollisionFadeTimes { + TimePoint latestStart; + Duration fadeDuration; +}; + +class LayerPlacementState { +public: + LayerPlacementState(); + bool continuePlacement(RenderSymbolLayer& renderLayer, + CollisionIndex& collisionIndex, + const bool showCollisionBoxes, + std::function shouldPausePlacement); + +private: + size_t currentTileIndex; +}; + +class PlacementState +{ +public: + PlacementState(const TransformState& transformState, + const std::vector& order, + const bool forceFullPlacement, + const bool showCollisionBoxes, + Duration fadeDuration, + optional& previousPlacement); + + bool isDone() const { return done; } + bool stillFading() const; + + void continuePlacement(std::vector& order, std::vector& sources); + +private: + CollisionIndex collisionIndex; + bool done; + size_t currentLayerIndex; + bool forceFullPlacement; + bool showCollisionBoxes; + TimePoint delayUntil; + CollisionFadeTimes collisionFadeTimes; + optional inProgressLayer; + +}; + +}; // mbgl diff --git a/src/mbgl/renderer/render_layer.hpp b/src/mbgl/renderer/render_layer.hpp index dfc6bcf2fd..afd1e9546b 100644 --- a/src/mbgl/renderer/render_layer.hpp +++ b/src/mbgl/renderer/render_layer.hpp @@ -86,6 +86,9 @@ protected: // evaluated StyleProperties object and is updated accordingly. RenderPass passes = RenderPass::None; + // TODO: Placement needs access to the renderTiles -- figure out how best to coordinate + friend class LayerPlacementState; + //Stores current set of tiles to be rendered for this layer. std::vector> renderTiles; diff --git a/src/mbgl/tile/tile.hpp b/src/mbgl/tile/tile.hpp index 39cc0de8bd..eb6ad0c128 100644 --- a/src/mbgl/tile/tile.hpp +++ b/src/mbgl/tile/tile.hpp @@ -27,6 +27,9 @@ class RenderLayer; class RenderedQueryOptions; class SourceQueryOptions; +class CollisionIndex; +struct CollisionFadeTimes; + namespace gl { class Context; } // namespace gl @@ -57,6 +60,10 @@ public: virtual void setLayers(const std::vector>&) {} virtual void setMask(TileMask&&) {} + // TODO: Implement + virtual void placeLayer(const bool, CollisionIndex& , const style::Layer::Impl&) {}; + virtual void commitPlacement(const CollisionIndex&, CollisionFadeTimes&) {}; + virtual void queryRenderedFeatures( std::unordered_map>& result, const GeometryCoordinates& queryGeometry, -- cgit v1.2.1