diff options
Diffstat (limited to 'src/mbgl')
23 files changed, 139 insertions, 388 deletions
diff --git a/src/mbgl/algorithm/covered_by_children.hpp b/src/mbgl/algorithm/covered_by_children.hpp deleted file mode 100644 index fe5af3f3db..0000000000 --- a/src/mbgl/algorithm/covered_by_children.hpp +++ /dev/null @@ -1,39 +0,0 @@ -#pragma once - -#include <mbgl/tile/tile_id.hpp> - -namespace mbgl { -namespace algorithm { - -template <typename Iterator> -bool coveredByChildren(const UnwrappedTileID& id, Iterator it, const Iterator& end) { - for (const auto& child : id.children()) { - it = std::lower_bound(it, end, child, [](const auto& a, const auto& b) { return std::get<0>(a) < b; }); - - // Child is not present, neither its grandchildren. - if (it == end) { - return false; - } - - // Child is not present, but its grandchildren are. - if (std::get<0>(*it) != child) { - // This child is not covered by its grandchildren. - if (!coveredByChildren(child, it, end)) { - return false; - } - } - } - - // We looked at all four children (recursively) and verified that they're covered. - return true; -} - -template <typename Container> -bool coveredByChildren(const UnwrappedTileID& id, const Container& container) { - return coveredByChildren( - id, container.upper_bound(id), - container.lower_bound(UnwrappedTileID{ static_cast<int16_t>(id.wrap + 1), { 0, 0, 0 } })); -} - -} // namespace algorithm -} // namespace mbgl diff --git a/src/mbgl/algorithm/generate_clip_ids.cpp b/src/mbgl/algorithm/generate_clip_ids.cpp deleted file mode 100644 index aefa55b929..0000000000 --- a/src/mbgl/algorithm/generate_clip_ids.cpp +++ /dev/null @@ -1,76 +0,0 @@ -#include <mbgl/algorithm/generate_clip_ids_impl.hpp> -#include <mbgl/algorithm/covered_by_children.hpp> - -#include <mbgl/util/std.hpp> - -#include <list> -#include <vector> -#include <bitset> -#include <cassert> -#include <algorithm> -#include <iterator> - -namespace mbgl { -namespace algorithm { - -ClipIDGenerator::Leaf::Leaf(ClipID& clip_) : clip(clip_) { -} - -void ClipIDGenerator::Leaf::add(const CanonicalTileID& p) { - // Ensure that no already present child is a parent of the new p. - for (const auto& child : children) { - if (p.isChildOf(child)) { - return; - } - } - children.emplace(p); -} - -bool ClipIDGenerator::Leaf::operator==(const Leaf& other) const { - return children == other.children; -} - -std::map<UnwrappedTileID, ClipID> ClipIDGenerator::getClipIDs() const { - std::map<UnwrappedTileID, ClipID> clipIDs; - - // Merge everything. - for (auto& pair : pool) { - auto& id = pair.first; - auto& leaf = pair.second; - auto res = clipIDs.emplace(id, leaf.clip); - if (!res.second) { - // Merge with the existing ClipID when there was already an element with the - // same tile ID. - res.first->second |= leaf.clip; - } - } - - for (auto it = clipIDs.begin(); it != clipIDs.end(); ++it) { - auto& childId = it->first; - auto& childClip = it->second; - - // Loop through all preceding stencils, and find all parents. - - for (auto parentIt = std::reverse_iterator<decltype(it)>(it); - parentIt != clipIDs.rend(); ++parentIt) { - auto& parentId = parentIt->first; - if (childId.isChildOf(parentId)) { - // Once we have a parent, we add the bits that this ID hasn't set yet. - const auto& parentClip = parentIt->second; - const auto mask = ~(childClip.mask & parentClip.mask); - childClip.reference |= mask & parentClip.reference; - childClip.mask |= parentClip.mask; - } - } - } - - // Remove tiles that are entirely covered by children. - util::erase_if(clipIDs, [&](const auto& stencil) { - return algorithm::coveredByChildren(stencil.first, clipIDs); - }); - - return clipIDs; -} - -} // namespace algorithm -} // namespace mbgl diff --git a/src/mbgl/algorithm/generate_clip_ids.hpp b/src/mbgl/algorithm/generate_clip_ids.hpp deleted file mode 100644 index 6950433578..0000000000 --- a/src/mbgl/algorithm/generate_clip_ids.hpp +++ /dev/null @@ -1,36 +0,0 @@ -#pragma once - -#include <mbgl/tile/tile_id.hpp> -#include <mbgl/util/clip_id.hpp> - -#include <set> -#include <vector> -#include <map> - -namespace mbgl { -namespace algorithm { - -class ClipIDGenerator { -private: - struct Leaf { - Leaf(ClipID&); - void add(const CanonicalTileID &p); - bool operator==(const Leaf &other) const; - - std::set<CanonicalTileID> children; - ClipID& clip; - }; - - uint8_t bit_offset = 0; - std::multimap<UnwrappedTileID, Leaf> pool; - -public: - // The given vector must be sorted by id. - template <typename Renderable> - void update(std::vector<std::reference_wrapper<Renderable>> sortedRenderables); - - std::map<UnwrappedTileID, ClipID> getClipIDs() const; -}; - -} // namespace algorithm -} // namespace mbgl diff --git a/src/mbgl/algorithm/generate_clip_ids_impl.hpp b/src/mbgl/algorithm/generate_clip_ids_impl.hpp deleted file mode 100644 index a4af9c8cbb..0000000000 --- a/src/mbgl/algorithm/generate_clip_ids_impl.hpp +++ /dev/null @@ -1,91 +0,0 @@ -#pragma once - -#include <mbgl/algorithm/generate_clip_ids.hpp> -#include <mbgl/math/log2.hpp> -#include <mbgl/util/logging.hpp> - -namespace mbgl { -namespace algorithm { - -template <typename Renderable> -void ClipIDGenerator::update(std::vector<std::reference_wrapper<Renderable>> renderables) { - std::size_t size = 0; - assert(std::is_sorted(renderables.begin(), renderables.end(), - [](const Renderable& a, const Renderable& b) { return a.id < b.id; })); - - const auto end = renderables.end(); - for (auto it = renderables.begin(); it != end; ++it) { - auto& renderable = it->get(); - if (!renderable.used || !renderable.needsClipping) { - continue; - } - - renderable.clip = {}; - Leaf leaf{ renderable.clip }; - - // Try to add all remaining ids as children. We sorted the tile list - // by z earlier, so all preceding items cannot be children of the current - // tile. We also compute the lower bound of the next wrap, because items of the next wrap - // can never be children of the current wrap. - auto child_it = std::next(it); - const auto children_end = std::lower_bound( - child_it, end, UnwrappedTileID{ static_cast<int16_t>(renderable.id.wrap + 1), { 0, 0, 0 } }, - [](auto& a, auto& b) { return a.get().id < b; }); - for (; child_it != children_end; ++child_it) { - auto& childTileID = child_it->get().id; - if (childTileID.isChildOf(it->get().id)) { - leaf.add(childTileID.canonical); - } - } - - // Find a leaf with matching children. - for (auto its = pool.equal_range(renderable.id); its.first != its.second; ++its.first) { - auto& existing = its.first->second; - if (existing == leaf) { - leaf.clip = existing.clip; - break; - } - } - if (leaf.clip.reference.none()) { - // We haven't found an existing clip ID - size++; - } - - pool.emplace(renderable.id, std::move(leaf)); - } - - if (size > 0) { - const uint32_t bit_count = util::ceil_log2(size + 1); - const std::bitset<8> mask = uint64_t(((1ul << bit_count) - 1) << bit_offset); - - // We are starting our count with 1 since we need at least 1 bit set to distinguish between - // areas without any tiles whatsoever and the current area. - uint8_t count = 1; - for (auto& it : renderables) { - auto& renderable = it.get(); - if (!renderable.used || !renderable.needsClipping) { - continue; - } - renderable.clip.mask |= mask; - - // Assign only to clip IDs that have no value yet. - if (renderable.clip.reference.none()) { - renderable.clip.reference = uint32_t(count++) << bit_offset; - } - } - - bit_offset += bit_count; - } - - // Prevent this warning from firing on every frame, - // which can be expensive in some platforms. - static bool warned = false; - - if (!warned && bit_offset > 8) { - Log::Error(Event::OpenGL, "stencil mask overflow"); - warned = true; - } -} - -} // namespace algorithm -} // namespace mbgl diff --git a/src/mbgl/annotation/render_annotation_source.cpp b/src/mbgl/annotation/render_annotation_source.cpp index ff6e6e34b7..740ad32244 100644 --- a/src/mbgl/annotation/render_annotation_source.cpp +++ b/src/mbgl/annotation/render_annotation_source.cpp @@ -3,9 +3,6 @@ #include <mbgl/renderer/render_tile.hpp> #include <mbgl/renderer/paint_parameters.hpp> -#include <mbgl/algorithm/generate_clip_ids.hpp> -#include <mbgl/algorithm/generate_clip_ids_impl.hpp> - #include <mbgl/layermanager/layer_manager.hpp> namespace mbgl { @@ -51,7 +48,6 @@ void RenderAnnotationSource::update(Immutable<style::Source::Impl> baseImpl_, } void RenderAnnotationSource::startRender(PaintParameters& parameters) { - parameters.clipIDGenerator.update(tilePyramid.getRenderTiles()); tilePyramid.startRender(parameters); } diff --git a/src/mbgl/gfx/context.hpp b/src/mbgl/gfx/context.hpp index 140d3b2356..c56ace2252 100644 --- a/src/mbgl/gfx/context.hpp +++ b/src/mbgl/gfx/context.hpp @@ -168,6 +168,8 @@ public: virtual void visualizeStencilBuffer() = 0; virtual void visualizeDepthBuffer(float depthRangeSize) = 0; #endif + + virtual void clearStencilBuffer(int32_t) = 0; }; } // namespace gfx diff --git a/src/mbgl/gl/context.cpp b/src/mbgl/gl/context.cpp index 394f2cd0d7..b6a7bcc44c 100644 --- a/src/mbgl/gl/context.cpp +++ b/src/mbgl/gl/context.cpp @@ -870,5 +870,10 @@ void Context::visualizeDepthBuffer(const float depthRangeSize) { #endif +void Context::clearStencilBuffer(const int32_t bits) { + MBGL_CHECK_ERROR(glClearStencil(bits)); + MBGL_CHECK_ERROR(glClear(GL_STENCIL_BUFFER_BIT)); +} + } // namespace gl } // namespace mbgl diff --git a/src/mbgl/gl/context.hpp b/src/mbgl/gl/context.hpp index ae935e32cb..aa8d2c4c84 100644 --- a/src/mbgl/gl/context.hpp +++ b/src/mbgl/gl/context.hpp @@ -247,6 +247,8 @@ public: void visualizeStencilBuffer() override; void visualizeDepthBuffer(float depthRangeSize) override; #endif + + void clearStencilBuffer(int32_t) override; }; } // namespace gl diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp index a0531afaed..e96dee0cf5 100644 --- a/src/mbgl/renderer/layers/render_circle_layer.cpp +++ b/src/mbgl/renderer/layers/render_circle_layer.cpp @@ -103,9 +103,7 @@ void RenderCircleLayer::render(PaintParameters& parameters, RenderSource*) { *parameters.renderPass, gfx::Triangles(), parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly), - parameters.mapMode != MapMode::Continuous - ? parameters.stencilModeForClipping(tile.clip) - : gfx::StencilMode::disabled(), + gfx::StencilMode::disabled(), parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(), *bucket.indexBuffer, diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp index 85ae12b9d9..ec446136dc 100644 --- a/src/mbgl/renderer/layers/render_fill_layer.cpp +++ b/src/mbgl/renderer/layers/render_fill_layer.cpp @@ -1,6 +1,7 @@ #include <mbgl/renderer/layers/render_fill_layer.hpp> #include <mbgl/renderer/buckets/fill_bucket.hpp> #include <mbgl/renderer/render_tile.hpp> +#include <mbgl/renderer/render_source.hpp> #include <mbgl/renderer/paint_parameters.hpp> #include <mbgl/renderer/image_manager.hpp> #include <mbgl/programs/programs.hpp> @@ -73,6 +74,7 @@ bool RenderFillLayer::hasCrossfade() const { void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) { if (unevaluated.get<FillPattern>().isUndefined()) { + parameters.renderTileClippingMasks(renderTiles); for (const RenderTile& tile : renderTiles) { const LayerRenderData* renderData = tile.tile.getLayerRenderData(*baseImpl); if (!renderData) { @@ -115,7 +117,7 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) { *parameters.renderPass, drawMode, depthMode, - parameters.stencilModeForClipping(tile.clip), + parameters.stencilModeForClipping(tile.id), parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(), indexBuffer, @@ -157,6 +159,8 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) { return; } + parameters.renderTileClippingMasks(renderTiles); + for (const RenderTile& tile : renderTiles) { const LayerRenderData* renderData = tile.tile.getLayerRenderData(*baseImpl); if (!renderData) { @@ -209,7 +213,7 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) { *parameters.renderPass, drawMode, depthMode, - parameters.stencilModeForClipping(tile.clip), + parameters.stencilModeForClipping(tile.id), parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(), indexBuffer, diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp index 1f3c179acc..48249002ea 100644 --- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp +++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp @@ -98,10 +98,6 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) { const auto extrudeScale = tile.id.pixelsToTileUnits(1, parameters.state.getZoom()); - const auto stencilMode = parameters.mapMode != MapMode::Continuous - ? parameters.stencilModeForClipping(tile.clip) - : gfx::StencilMode::disabled(); - const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID()); auto& programInstance = parameters.programs.getHeatmapLayerPrograms().heatmap; @@ -129,7 +125,7 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) { *renderPass, gfx::Triangles(), parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly), - stencilMode, + gfx::StencilMode::disabled(), gfx::ColorMode::additive(), gfx::CullFaceMode::disabled(), *bucket.indexBuffer, diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp index 8fbe799f17..596a121249 100644 --- a/src/mbgl/renderer/layers/render_line_layer.cpp +++ b/src/mbgl/renderer/layers/render_line_layer.cpp @@ -1,6 +1,7 @@ #include <mbgl/renderer/layers/render_line_layer.hpp> #include <mbgl/renderer/buckets/line_bucket.hpp> #include <mbgl/renderer/render_tile.hpp> +#include <mbgl/renderer/render_source.hpp> #include <mbgl/renderer/paint_parameters.hpp> #include <mbgl/renderer/image_manager.hpp> #include <mbgl/programs/programs.hpp> @@ -62,6 +63,8 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) { return; } + parameters.renderTileClippingMasks(renderTiles); + for (const RenderTile& tile : renderTiles) { const LayerRenderData* renderData = tile.tile.getLayerRenderData(*baseImpl); if (!renderData) { @@ -98,7 +101,7 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) { *parameters.renderPass, gfx::Triangles(), parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly), - parameters.stencilModeForClipping(tile.clip), + parameters.stencilModeForClipping(tile.id), parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(), *bucket.indexBuffer, diff --git a/src/mbgl/renderer/paint_parameters.cpp b/src/mbgl/renderer/paint_parameters.cpp index 624deeec0a..e9f42d2579 100644 --- a/src/mbgl/renderer/paint_parameters.cpp +++ b/src/mbgl/renderer/paint_parameters.cpp @@ -1,8 +1,11 @@ #include <mbgl/renderer/paint_parameters.hpp> #include <mbgl/renderer/update_parameters.hpp> #include <mbgl/renderer/render_static_data.hpp> +#include <mbgl/renderer/render_source.hpp> +#include <mbgl/renderer/render_tile.hpp> #include <mbgl/gfx/command_encoder.hpp> #include <mbgl/gfx/render_pass.hpp> +#include <mbgl/gfx/cull_face_mode.hpp> #include <mbgl/map/transform_state.hpp> namespace mbgl { @@ -73,15 +76,94 @@ gfx::DepthMode PaintParameters::depthModeFor3D(gfx::DepthMaskType mask) const { return gfx::DepthMode { gfx::DepthFunctionType::LessEqual, mask, { 0.0, 1.0 } }; } -gfx::StencilMode PaintParameters::stencilModeForClipping(const ClipID& id) const { - return gfx::StencilMode { - gfx::StencilMode::Equal { static_cast<uint32_t>(id.mask.to_ulong()) }, - static_cast<int32_t>(id.reference.to_ulong()), - 0, - gfx::StencilOpType::Keep, - gfx::StencilOpType::Keep, - gfx::StencilOpType::Replace - }; +void PaintParameters::clearStencil() { + nextStencilID = 1; + context.clearStencilBuffer(0b00000000); +} + +namespace { + +// Detects a difference in keys of renderTiles and tileClippingMaskIDs +bool tileIDsIdentical(const std::vector<std::reference_wrapper<RenderTile>>& renderTiles, + const std::map<UnwrappedTileID, int32_t>& tileClippingMaskIDs) { + assert(std::is_sorted(renderTiles.begin(), renderTiles.end(), + [](const RenderTile& a, const RenderTile& b) { return a.id < b.id; })); + if (renderTiles.size() != tileClippingMaskIDs.size()) { + return false; + } + return std::equal(renderTiles.begin(), renderTiles.end(), tileClippingMaskIDs.begin(), + [](const RenderTile& a, const auto& b) { return a.id == b.first; }); +} + +} // namespace + +void PaintParameters::renderTileClippingMasks(const std::vector<std::reference_wrapper<RenderTile>>& renderTiles) { + if (renderTiles.empty() || tileIDsIdentical(renderTiles, tileClippingMaskIDs)) { + // The current stencil mask is for this source already; no need to draw another one. + return; + } + + if (nextStencilID + renderTiles.size() > 256) { + // we'll run out of fresh IDs so we need to clear and start from scratch + clearStencil(); + } + + tileClippingMaskIDs.clear(); + + auto& program = staticData.programs.clippingMask; + const style::Properties<>::PossiblyEvaluated properties {}; + const ClippingMaskProgram::Binders paintAttributeData(properties, 0); + + for (const RenderTile& renderTile : renderTiles) { + const int32_t stencilID = nextStencilID++; + tileClippingMaskIDs.emplace(renderTile.id, stencilID); + + program.draw( + context, + *renderPass, + gfx::Triangles(), + gfx::DepthMode::disabled(), + gfx::StencilMode { + gfx::StencilMode::Always{}, + stencilID, + 0b11111111, + gfx::StencilOpType::Keep, + gfx::StencilOpType::Keep, + gfx::StencilOpType::Replace + }, + gfx::ColorMode::disabled(), + gfx::CullFaceMode::disabled(), + staticData.quadTriangleIndexBuffer, + staticData.tileTriangleSegments, + program.computeAllUniformValues( + ClippingMaskProgram::LayoutUniformValues { + uniforms::matrix::Value( matrixForTile(renderTile.id) ), + }, + paintAttributeData, + properties, + state.getZoom() + ), + program.computeAllAttributeBindings( + staticData.tileVertexBuffer, + paintAttributeData, + properties + ), + ClippingMaskProgram::TextureBindings{}, + "clipping" + ); + } +} + +gfx::StencilMode PaintParameters::stencilModeForClipping(const UnwrappedTileID& tileID) const { + auto it = tileClippingMaskIDs.find(tileID); + assert(it != tileClippingMaskIDs.end()); + const int32_t id = it != tileClippingMaskIDs.end() ? it->second : 0b00000000; + return gfx::StencilMode{ gfx::StencilMode::Equal{ 0b11111111 }, + id, + 0b00000000, + gfx::StencilOpType::Keep, + gfx::StencilOpType::Keep, + gfx::StencilOpType::Replace }; } gfx::ColorMode PaintParameters::colorModeForRenderPass() const { diff --git a/src/mbgl/renderer/paint_parameters.hpp b/src/mbgl/renderer/paint_parameters.hpp index 523975c78c..1a576b6c9c 100644 --- a/src/mbgl/renderer/paint_parameters.hpp +++ b/src/mbgl/renderer/paint_parameters.hpp @@ -7,10 +7,11 @@ #include <mbgl/gfx/stencil_mode.hpp> #include <mbgl/gfx/color_mode.hpp> #include <mbgl/util/mat4.hpp> -#include <mbgl/algorithm/generate_clip_ids.hpp> #include <mbgl/text/placement.hpp> #include <array> +#include <map> +#include <vector> namespace mbgl { @@ -21,6 +22,8 @@ class TransformState; class ImageManager; class LineAtlas; class UnwrappedTileID; +class RenderSource; +class RenderTile; namespace gfx { class Context; @@ -62,13 +65,11 @@ public: float pixelRatio; Placement::VariableOffsets variableOffsets; std::array<float, 2> pixelsToGLUnits; - algorithm::ClipIDGenerator clipIDGenerator; Programs& programs; gfx::DepthMode depthModeForSublayer(uint8_t n, gfx::DepthMaskType) const; gfx::DepthMode depthModeFor3D(gfx::DepthMaskType) const; - gfx::StencilMode stencilModeForClipping(const ClipID&) const; gfx::ColorMode colorModeForRenderPass() const; mat4 matrixForTile(const UnwrappedTileID&, bool aligned = false) const; @@ -77,10 +78,24 @@ public: mat4 alignedProjMatrix; mat4 nearClippedProjMatrix; + // Stencil handling +public: + void renderTileClippingMasks(const std::vector<std::reference_wrapper<RenderTile>>&); + gfx::StencilMode stencilModeForClipping(const UnwrappedTileID&) const; + +private: + void clearStencil(); + + // This needs to be an ordered map so that we have the same order as the renderTiles. + std::map<UnwrappedTileID, int32_t> tileClippingMaskIDs; + int32_t nextStencilID = 1; + +public: int numSublayers = 3; uint32_t currentLayer; float depthRangeSize; const float depthEpsilon = 1.0f / (1 << 16); + float symbolFadeChange; }; diff --git a/src/mbgl/renderer/render_layer.cpp b/src/mbgl/renderer/render_layer.cpp index 5868c38fbc..b7639f83fe 100644 --- a/src/mbgl/renderer/render_layer.cpp +++ b/src/mbgl/renderer/render_layer.cpp @@ -2,6 +2,7 @@ #include <mbgl/renderer/paint_parameters.hpp> #include <mbgl/renderer/render_tile.hpp> #include <mbgl/style/types.hpp> +#include <mbgl/style/layer.hpp> #include <mbgl/tile/tile.hpp> #include <mbgl/gfx/context.hpp> #include <mbgl/util/logging.hpp> diff --git a/src/mbgl/renderer/render_tile.cpp b/src/mbgl/renderer/render_tile.cpp index 5429536c3f..e175b761fe 100644 --- a/src/mbgl/renderer/render_tile.cpp +++ b/src/mbgl/renderer/render_tile.cpp @@ -101,7 +101,7 @@ void RenderTile::finishRender(PaintParameters& parameters) { *parameters.renderPass, gfx::Lines { 4.0f * parameters.pixelRatio }, gfx::DepthMode::disabled(), - parameters.stencilModeForClipping(clip), + gfx::StencilMode::disabled(), gfx::ColorMode::unblended(), gfx::CullFaceMode::disabled(), *tile.debugBucket->indexBuffer, @@ -125,7 +125,7 @@ void RenderTile::finishRender(PaintParameters& parameters) { *parameters.renderPass, gfx::Lines { 2.0f * parameters.pixelRatio }, gfx::DepthMode::disabled(), - parameters.stencilModeForClipping(clip), + gfx::StencilMode::disabled(), gfx::ColorMode::unblended(), gfx::CullFaceMode::disabled(), *tile.debugBucket->indexBuffer, @@ -152,7 +152,7 @@ void RenderTile::finishRender(PaintParameters& parameters) { *parameters.renderPass, gfx::LineStrip { 4.0f * parameters.pixelRatio }, gfx::DepthMode::disabled(), - parameters.stencilModeForClipping(clip), + gfx::StencilMode::disabled(), gfx::ColorMode::unblended(), gfx::CullFaceMode::disabled(), parameters.staticData.tileBorderIndexBuffer, diff --git a/src/mbgl/renderer/render_tile.hpp b/src/mbgl/renderer/render_tile.hpp index bfa695586c..ddfcaa8d4d 100644 --- a/src/mbgl/renderer/render_tile.hpp +++ b/src/mbgl/renderer/render_tile.hpp @@ -2,7 +2,6 @@ #include <mbgl/tile/tile_id.hpp> #include <mbgl/util/mat4.hpp> -#include <mbgl/util/clip_id.hpp> #include <mbgl/style/types.hpp> #include <mbgl/renderer/tile_mask.hpp> @@ -24,7 +23,6 @@ public: UnwrappedTileID id; Tile& tile; - ClipID clip; mat4 matrix; mat4 nearClippedMatrix; bool used = false; diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp index 1b17324ccf..ecb26fa330 100644 --- a/src/mbgl/renderer/renderer_impl.cpp +++ b/src/mbgl/renderer/renderer_impl.cpp @@ -420,61 +420,6 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) { parameters.renderPass = parameters.encoder->createRenderPass("main buffer", { parameters.backend.getDefaultRenderable(), color, 1, 0 }); } - // - CLIPPING MASKS ---------------------------------------------------------------------------- - // Draws the clipping masks to the stencil buffer. - { - const auto debugGroup(parameters.renderPass->createDebugGroup("clipping masks")); - - static const Properties<>::PossiblyEvaluated properties {}; - static const ClippingMaskProgram::Binders paintAttributeData(properties, 0); - - for (const auto& clipID : parameters.clipIDGenerator.getClipIDs()) { - auto& program = parameters.staticData.programs.clippingMask; - - program.draw( - parameters.context, - *parameters.renderPass, - gfx::Triangles(), - gfx::DepthMode::disabled(), - gfx::StencilMode { - gfx::StencilMode::Always(), - static_cast<int32_t>(clipID.second.reference.to_ulong()), - 0b11111111, - gfx::StencilOpType::Keep, - gfx::StencilOpType::Keep, - gfx::StencilOpType::Replace - }, - gfx::ColorMode::disabled(), - gfx::CullFaceMode::disabled(), - parameters.staticData.quadTriangleIndexBuffer, - parameters.staticData.tileTriangleSegments, - program.computeAllUniformValues( - ClippingMaskProgram::LayoutUniformValues { - uniforms::matrix::Value( parameters.matrixForTile(clipID.first) ), - }, - paintAttributeData, - properties, - parameters.state.getZoom() - ), - program.computeAllAttributeBindings( - parameters.staticData.tileVertexBuffer, - paintAttributeData, - properties - ), - ClippingMaskProgram::TextureBindings{}, - "clipping" - ); - } - } - -#if not defined(NDEBUG) - // Render tile clip boundaries, using stencil buffer to calculate fill color. - if (parameters.debugOptions & MapDebugOptions::StencilClip) { - parameters.context.visualizeStencilBuffer(); - return; - } -#endif - // Actually render the layers parameters.depthRangeSize = 1 - (renderItems.size() + 2) * parameters.numSublayers * parameters.depthEpsilon; @@ -530,8 +475,11 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) { } #if not defined(NDEBUG) - // Render the depth buffer. - if (parameters.debugOptions & MapDebugOptions::DepthBuffer) { + if (parameters.debugOptions & MapDebugOptions::StencilClip) { + // Render tile clip boundaries, using stencil buffer to calculate fill color. + parameters.context.visualizeStencilBuffer(); + } else if (parameters.debugOptions & MapDebugOptions::DepthBuffer) { + // Render the depth buffer. parameters.context.visualizeDepthBuffer(parameters.depthRangeSize); } #endif diff --git a/src/mbgl/renderer/sources/render_custom_geometry_source.cpp b/src/mbgl/renderer/sources/render_custom_geometry_source.cpp index 30b6e65f24..8de79d8016 100644 --- a/src/mbgl/renderer/sources/render_custom_geometry_source.cpp +++ b/src/mbgl/renderer/sources/render_custom_geometry_source.cpp @@ -3,9 +3,6 @@ #include <mbgl/renderer/paint_parameters.hpp> #include <mbgl/tile/custom_geometry_tile.hpp> -#include <mbgl/algorithm/generate_clip_ids.hpp> -#include <mbgl/algorithm/generate_clip_ids_impl.hpp> - namespace mbgl { using namespace style; @@ -51,7 +48,6 @@ void RenderCustomGeometrySource::update(Immutable<style::Source::Impl> baseImpl_ } void RenderCustomGeometrySource::startRender(PaintParameters& parameters) { - parameters.clipIDGenerator.update(tilePyramid.getRenderTiles()); tilePyramid.startRender(parameters); } diff --git a/src/mbgl/renderer/sources/render_geojson_source.cpp b/src/mbgl/renderer/sources/render_geojson_source.cpp index 332ea4d170..0234b97eca 100644 --- a/src/mbgl/renderer/sources/render_geojson_source.cpp +++ b/src/mbgl/renderer/sources/render_geojson_source.cpp @@ -4,9 +4,6 @@ #include <mbgl/tile/geojson_tile.hpp> #include <mbgl/renderer/tile_parameters.hpp> -#include <mbgl/algorithm/generate_clip_ids.hpp> -#include <mbgl/algorithm/generate_clip_ids_impl.hpp> - #include <mapbox/eternal.hpp> namespace mbgl { @@ -127,7 +124,6 @@ void RenderGeoJSONSource::update(Immutable<style::Source::Impl> baseImpl_, } void RenderGeoJSONSource::startRender(PaintParameters& parameters) { - parameters.clipIDGenerator.update(tilePyramid.getRenderTiles()); tilePyramid.startRender(parameters); } diff --git a/src/mbgl/renderer/sources/render_vector_source.cpp b/src/mbgl/renderer/sources/render_vector_source.cpp index efcd11094c..518692fc77 100644 --- a/src/mbgl/renderer/sources/render_vector_source.cpp +++ b/src/mbgl/renderer/sources/render_vector_source.cpp @@ -3,9 +3,6 @@ #include <mbgl/renderer/paint_parameters.hpp> #include <mbgl/tile/vector_tile.hpp> -#include <mbgl/algorithm/generate_clip_ids.hpp> -#include <mbgl/algorithm/generate_clip_ids_impl.hpp> - namespace mbgl { using namespace style; @@ -61,7 +58,6 @@ void RenderVectorSource::update(Immutable<style::Source::Impl> baseImpl_, } void RenderVectorSource::startRender(PaintParameters& parameters) { - parameters.clipIDGenerator.update(tilePyramid.getRenderTiles()); tilePyramid.startRender(parameters); } diff --git a/src/mbgl/util/clip_id.cpp b/src/mbgl/util/clip_id.cpp deleted file mode 100644 index a73692c451..0000000000 --- a/src/mbgl/util/clip_id.cpp +++ /dev/null @@ -1,11 +0,0 @@ -#include <mbgl/util/clip_id.hpp> - -#include <iostream> - -namespace mbgl { - -::std::ostream& operator<<(::std::ostream& os, const ClipID& rhs) { - return os << "mask=" << rhs.mask << ",ref=" << rhs.reference; -} - -} // namespace mbgl diff --git a/src/mbgl/util/clip_id.hpp b/src/mbgl/util/clip_id.hpp deleted file mode 100644 index de2dc51919..0000000000 --- a/src/mbgl/util/clip_id.hpp +++ /dev/null @@ -1,34 +0,0 @@ -#pragma once - -#include <bitset> -#include <string> -#include <list> -#include <set> -#include <vector> -#include <forward_list> -#include <iosfwd> -#include <map> - -namespace mbgl { - -struct ClipID { - ClipID() {} - ClipID(const std::string &mask_, const std::string &reference_) : mask(mask_), reference(reference_) {} - - std::bitset<8> mask; - std::bitset<8> reference; - - bool operator==(const ClipID &other) const { - return mask == other.mask && reference == other.reference; - } - - ClipID& operator|=(const ClipID &other) { - mask |= other.mask; - reference |= other.reference; - return *this; - } -}; - -::std::ostream& operator<<(::std::ostream& os, const ClipID& rhs); - -} // namespace mbgl |