From d6c2b148ddd4d2004db14608905b6eea72facc81 Mon Sep 17 00:00:00 2001 From: mwilsnd <53413200+mwilsnd@users.noreply.github.com> Date: Tue, 16 Jan 2024 09:31:44 -0500 Subject: [PATCH] Metal layer depth range support (#2013) Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> Co-authored-by: Alex Cristici --- include/mbgl/gfx/drawable.hpp | 4 ++++ include/mbgl/renderer/layer_group.hpp | 16 +++++++++++++++- include/mbgl/renderer/layer_tweaker.hpp | 1 + src/mbgl/gfx/depth_mode.hpp | 6 ++++++ src/mbgl/gl/context.cpp | 6 ++++++ src/mbgl/gl/context.hpp | 2 ++ src/mbgl/gl/value.cpp | 2 ++ src/mbgl/gl/value.hpp | 2 ++ src/mbgl/mtl/context.cpp | 7 ++----- src/mbgl/renderer/layer_group.cpp | 1 + src/mbgl/renderer/layer_tweaker.cpp | 17 ++++++++++++++--- .../layers/background_layer_tweaker.cpp | 3 ++- .../renderer/layers/circle_layer_tweaker.cpp | 3 ++- .../renderer/layers/collision_layer_tweaker.cpp | 3 ++- .../layers/fill_extrusion_layer_tweaker.cpp | 3 ++- src/mbgl/renderer/layers/fill_layer_tweaker.cpp | 4 +++- .../renderer/layers/heatmap_layer_tweaker.cpp | 2 +- .../renderer/layers/hillshade_layer_tweaker.cpp | 2 +- src/mbgl/renderer/layers/line_layer_tweaker.cpp | 3 ++- .../renderer/layers/raster_layer_tweaker.cpp | 9 ++++++++- src/mbgl/renderer/layers/render_fill_layer.cpp | 2 +- .../renderer/layers/symbol_layer_tweaker.cpp | 3 ++- src/mbgl/renderer/paint_parameters.cpp | 11 ++++++++++- src/mbgl/renderer/paint_parameters.hpp | 6 +++++- src/mbgl/renderer/render_target.cpp | 6 ++++-- src/mbgl/renderer/renderer_impl.cpp | 10 ++++++---- .../renderer/sources/render_tile_source.cpp | 2 +- src/mbgl/style/layers/custom_drawable_layer.cpp | 4 ++-- 28 files changed, 109 insertions(+), 31 deletions(-) diff --git a/include/mbgl/gfx/drawable.hpp b/include/mbgl/gfx/drawable.hpp index c84f4af3c7b..be68a343e0a 100644 --- a/include/mbgl/gfx/drawable.hpp +++ b/include/mbgl/gfx/drawable.hpp @@ -152,6 +152,9 @@ class Drawable { /// Set sub-layer index virtual void setSubLayerIndex(int32_t value) { subLayerIndex = value; } + void setLayerIndex(int32_t value) { layerIndex = value; } + int32_t getLayerIndex() const { return layerIndex; } + /// Depth writability for 2D drawables DepthMaskType getDepthType() const { return depthType; } @@ -252,6 +255,7 @@ class Drawable { DrawPriority drawPriority = 0; int32_t lineWidth = 1; int32_t subLayerIndex = 0; + int32_t layerIndex = 0; DepthMaskType depthType; // = DepthMaskType::ReadOnly; UniqueDrawableData drawableData{}; gfx::VertexAttributeArrayPtr vertexAttributes; diff --git a/include/mbgl/renderer/layer_group.hpp b/include/mbgl/renderer/layer_group.hpp index 4acdfbef9ba..dd9c0b00b7c 100644 --- a/include/mbgl/renderer/layer_group.hpp +++ b/include/mbgl/renderer/layer_group.hpp @@ -72,7 +72,7 @@ class LayerGroupBase : public util::SimpleIdentifiable { int32_t getLayerIndex() const { return layerIndex; } /// Update the layer index to a new value - void updateLayerIndex(int32_t value) { layerIndex = value; } + virtual void updateLayerIndex(int32_t value) { layerIndex = value; } /// Get the number of drawables contained virtual std::size_t getDrawableCount() const = 0; @@ -163,6 +163,13 @@ class TileLayerGroup : public LayerGroupBase { void setStencilTiles(RenderTiles); + void updateLayerIndex(int32_t value) override { + layerIndex = value; + for (auto* drawable : sortedDrawables) { + drawable->setLayerIndex(value); + } + } + protected: // When stencil clipping is enabled for the layer, this is the set // of tile IDs that need to be rendered to the stencil buffer. @@ -232,6 +239,13 @@ class LayerGroup : public LayerGroupBase { std::size_t clearDrawables() override; + void updateLayerIndex(int32_t value) override { + layerIndex = value; + for (auto& drawable : drawables) { + drawable->setLayerIndex(value); + } + } + protected: using DrawableCollection = std::set; DrawableCollection drawables; diff --git a/include/mbgl/renderer/layer_tweaker.hpp b/include/mbgl/renderer/layer_tweaker.hpp index 7107de38861..347580466e2 100644 --- a/include/mbgl/renderer/layer_tweaker.hpp +++ b/include/mbgl/renderer/layer_tweaker.hpp @@ -57,6 +57,7 @@ class LayerTweaker { style::TranslateAnchorType, bool nearClipped, bool inViewportPixelUnits, + const gfx::Drawable& drawable, bool aligned = false); protected: diff --git a/src/mbgl/gfx/depth_mode.hpp b/src/mbgl/gfx/depth_mode.hpp index 4548240c999..d1ece4e06cd 100644 --- a/src/mbgl/gfx/depth_mode.hpp +++ b/src/mbgl/gfx/depth_mode.hpp @@ -10,9 +10,15 @@ class DepthMode { public: DepthFunctionType func; DepthMaskType mask; +#if MLN_RENDER_BACKEND_OPENGL Range range; +#endif +#if MLN_RENDER_BACKEND_OPENGL static DepthMode disabled() { return DepthMode{DepthFunctionType::Always, DepthMaskType::ReadOnly, {0.0, 1.0}}; } +#else + static DepthMode disabled() { return DepthMode{DepthFunctionType::Always, DepthMaskType::ReadOnly}; } +#endif }; } // namespace gfx diff --git a/src/mbgl/gl/context.cpp b/src/mbgl/gl/context.cpp index 1fc9ccf58aa..3f7b36c526b 100644 --- a/src/mbgl/gl/context.cpp +++ b/src/mbgl/gl/context.cpp @@ -490,7 +490,9 @@ void Context::setDirtyState() { stencilMask.setDirty(); stencilTest.setDirty(); stencilOp.setDirty(); +#if MLN_RENDER_BACKEND_OPENGL depthRange.setDirty(); +#endif depthMask.setDirty(); depthTest.setDirty(); depthFunc.setDirty(); @@ -615,12 +617,16 @@ void Context::setDepthMode(const gfx::DepthMode& depth) { // https://github.com/mapbox/mapbox-gl-native/issues/9164 depthFunc = depth.func; depthMask = depth.mask; +#if MLN_RENDER_BACKEND_OPENGL depthRange = depth.range; +#endif } else { depthTest = true; depthFunc = depth.func; depthMask = depth.mask; +#if MLN_RENDER_BACKEND_OPENGL depthRange = depth.range; +#endif } } diff --git a/src/mbgl/gl/context.hpp b/src/mbgl/gl/context.hpp index 1c90020023f..a0d684da84d 100644 --- a/src/mbgl/gl/context.hpp +++ b/src/mbgl/gl/context.hpp @@ -169,7 +169,9 @@ class Context final : public gfx::Context { State stencilMask; State stencilTest; State stencilOp; +#if MLN_RENDER_BACKEND_OPENGL State depthRange; +#endif State depthMask; State depthTest; State depthFunc; diff --git a/src/mbgl/gl/value.cpp b/src/mbgl/gl/value.cpp index 69d6053d171..d77e7b5016d 100644 --- a/src/mbgl/gl/value.cpp +++ b/src/mbgl/gl/value.cpp @@ -133,6 +133,7 @@ StencilOp::Type StencilOp::Get() { Enum::from(dppass)}; } +#if MLN_RENDER_BACKEND_OPENGL const constexpr DepthRange::Type DepthRange::Default; void DepthRange::Set(const Type& value) { @@ -144,6 +145,7 @@ DepthRange::Type DepthRange::Get() { MBGL_CHECK_ERROR(glGetFloatv(GL_DEPTH_RANGE, floats)); return {floats[0], floats[1]}; } +#endif const constexpr DepthTest::Type DepthTest::Default; diff --git a/src/mbgl/gl/value.hpp b/src/mbgl/gl/value.hpp index feda4410c6e..cea3136a008 100644 --- a/src/mbgl/gl/value.hpp +++ b/src/mbgl/gl/value.hpp @@ -98,12 +98,14 @@ constexpr bool operator!=(const StencilOp::Type& a, const StencilOp::Type& b) { return a.sfail != b.sfail || a.dpfail != b.dpfail || a.dppass != b.dppass; } +#if MLN_RENDER_BACKEND_OPENGL struct DepthRange { using Type = Range; static const constexpr Type Default = {0, 1}; static void Set(const Type&); static Type Get(); }; +#endif struct DepthTest { using Type = bool; diff --git a/src/mbgl/mtl/context.cpp b/src/mbgl/mtl/context.cpp index ee4ad699503..7a58732a9b7 100644 --- a/src/mbgl/mtl/context.cpp +++ b/src/mbgl/mtl/context.cpp @@ -269,11 +269,8 @@ const auto clipMaskStencilMode = gfx::StencilMode{ /*.depthFail=*/gfx::StencilOpType::Keep, /*.pass=*/gfx::StencilOpType::Replace, }; -const auto clipMaskDepthMode = gfx::DepthMode{ - /*.func=*/gfx::DepthFunctionType::Always, - /*.mask=*/gfx::DepthMaskType::ReadOnly, - /*.range=*/{0, 1}, -}; +const auto clipMaskDepthMode = gfx::DepthMode{/*.func=*/gfx::DepthFunctionType::Always, + /*.mask=*/gfx::DepthMaskType::ReadOnly}; } // namespace bool Context::renderTileClippingMasks(gfx::RenderPass& renderPass, diff --git a/src/mbgl/renderer/layer_group.cpp b/src/mbgl/renderer/layer_group.cpp index caf0cfc2f3c..49e869fc202 100644 --- a/src/mbgl/renderer/layer_group.cpp +++ b/src/mbgl/renderer/layer_group.cpp @@ -10,6 +10,7 @@ namespace mbgl { void LayerGroupBase::addDrawable(gfx::UniqueDrawable& drawable) { + drawable->setLayerIndex(layerIndex); // init their tweakers for (const auto& tweaker : drawable->getTweakers()) { tweaker->init(*drawable); diff --git a/src/mbgl/renderer/layer_tweaker.cpp b/src/mbgl/renderer/layer_tweaker.cpp index 013d6ec886d..426fd57b385 100644 --- a/src/mbgl/renderer/layer_tweaker.cpp +++ b/src/mbgl/renderer/layer_tweaker.cpp @@ -32,15 +32,26 @@ mat4 LayerTweaker::getTileMatrix(const UnwrappedTileID& tileID, style::TranslateAnchorType anchor, bool nearClipped, bool inViewportPixelUnits, + [[maybe_unused]] const gfx::Drawable& drawable, bool aligned) { // from RenderTile::prepare mat4 tileMatrix; parameters.state.matrixFor(/*out*/ tileMatrix, tileID); // nearClippedMatrix has near plane moved further, to enhance depth buffer precision - const auto& projMatrix = aligned ? parameters.transformParams.alignedProjMatrix - : (nearClipped ? parameters.transformParams.nearClippedProjMatrix - : parameters.transformParams.projMatrix); + auto projMatrix = aligned ? parameters.transformParams.alignedProjMatrix + : (nearClipped ? parameters.transformParams.nearClippedProjMatrix + : parameters.transformParams.projMatrix); + +#if !MLN_RENDER_BACKEND_OPENGL + // Offset the projection matrix NDC depth range for the drawable's layer and sublayer. + if (!drawable.getIs3D()) { + projMatrix[14] -= ((1 + drawable.getLayerIndex()) * PaintParameters::numSublayers - + drawable.getSubLayerIndex()) * + PaintParameters::depthEpsilon; + } +#endif + matrix::multiply(tileMatrix, projMatrix, tileMatrix); return RenderTile::translateVtxMatrix( diff --git a/src/mbgl/renderer/layers/background_layer_tweaker.cpp b/src/mbgl/renderer/layers/background_layer_tweaker.cpp index 7949be8ea5c..3e9c93d322b 100644 --- a/src/mbgl/renderer/layers/background_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/background_layer_tweaker.cpp @@ -64,7 +64,8 @@ void BackgroundLayerTweaker::execute(LayerGroupBase& layerGroup, const PaintPara (shader == context.getGenericShader(parameters.shaders, std::string(BackgroundPatternShaderName)))); const UnwrappedTileID tileID = drawable.getTileID()->toUnwrapped(); - const auto matrix = parameters.matrixForTile(tileID); + const auto matrix = getTileMatrix( + tileID, parameters, {0.f, 0.f}, TranslateAnchorType::Viewport, false, false, drawable); const BackgroundDrawableUBO drawableUBO = {/* .matrix = */ util::cast(matrix)}; diff --git a/src/mbgl/renderer/layers/circle_layer_tweaker.cpp b/src/mbgl/renderer/layers/circle_layer_tweaker.cpp index 2b450e31d7d..1755175412a 100644 --- a/src/mbgl/renderer/layers/circle_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/circle_layer_tweaker.cpp @@ -87,7 +87,8 @@ void CircleLayerTweaker::execute(LayerGroupBase& layerGroup, const PaintParamete const auto anchor = evaluated.get(); constexpr bool inViewportPixelUnits = false; // from RenderTile::translatedMatrix constexpr bool nearClipped = false; - const auto matrix = getTileMatrix(tileID, parameters, translation, anchor, nearClipped, inViewportPixelUnits); + const auto matrix = getTileMatrix( + tileID, parameters, translation, anchor, nearClipped, inViewportPixelUnits, drawable); const auto pixelsToTileUnits = tileID.pixelsToTileUnits(1.0f, static_cast(zoom)); const auto extrudeScale = pitchWithMap ? std::array{pixelsToTileUnits, pixelsToTileUnits} diff --git a/src/mbgl/renderer/layers/collision_layer_tweaker.cpp b/src/mbgl/renderer/layers/collision_layer_tweaker.cpp index a5b9f9a5143..5e5f9700618 100644 --- a/src/mbgl/renderer/layers/collision_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/collision_layer_tweaker.cpp @@ -49,7 +49,8 @@ void CollisionLayerTweaker::execute(LayerGroupBase& layerGroup, const PaintParam const auto anchor = data.translateAnchor; constexpr bool nearClipped = false; constexpr bool inViewportPixelUnits = false; - const auto matrix = getTileMatrix(tileID, parameters, translate, anchor, nearClipped, inViewportPixelUnits); + const auto matrix = getTileMatrix( + tileID, parameters, translate, anchor, nearClipped, inViewportPixelUnits, drawable); // extrude scale const auto pixelRatio = tileID.pixelsToTileUnits(1.0f, static_cast(parameters.state.getZoom())); diff --git a/src/mbgl/renderer/layers/fill_extrusion_layer_tweaker.cpp b/src/mbgl/renderer/layers/fill_extrusion_layer_tweaker.cpp index 30455c5950b..71ceba343fb 100644 --- a/src/mbgl/renderer/layers/fill_extrusion_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/fill_extrusion_layer_tweaker.cpp @@ -90,7 +90,8 @@ void FillExtrusionLayerTweaker::execute(LayerGroupBase& layerGroup, const PaintP const auto anchor = evaluated.get(); constexpr bool inViewportPixelUnits = false; // from RenderTile::translatedMatrix constexpr bool nearClipped = true; - const auto matrix = getTileMatrix(tileID, parameters, translation, anchor, nearClipped, inViewportPixelUnits); + const auto matrix = getTileMatrix( + tileID, parameters, translation, anchor, nearClipped, inViewportPixelUnits, drawable); const auto tileRatio = 1 / tileID.pixelsToTileUnits(1, state.getIntegerZoom()); const auto zoomScale = state.zoomScale(tileID.canonical.z); diff --git a/src/mbgl/renderer/layers/fill_layer_tweaker.cpp b/src/mbgl/renderer/layers/fill_layer_tweaker.cpp index f3f65a466c9..bbd34ca1000 100644 --- a/src/mbgl/renderer/layers/fill_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/fill_layer_tweaker.cpp @@ -153,7 +153,9 @@ void FillLayerTweaker::execute(LayerGroupBase& layerGroup, const PaintParameters constexpr bool inViewportPixelUnits = false; // from RenderTile::translatedMatrix constexpr bool nearClipped = false; - const auto matrix = getTileMatrix(tileID, parameters, translation, anchor, nearClipped, inViewportPixelUnits); + + const auto matrix = getTileMatrix( + tileID, parameters, translation, anchor, nearClipped, inViewportPixelUnits, drawable); // from FillPatternProgram::layoutUniformValues const auto tileRatio = 1.0f / tileID.pixelsToTileUnits(1.0f, intZoom); diff --git a/src/mbgl/renderer/layers/heatmap_layer_tweaker.cpp b/src/mbgl/renderer/layers/heatmap_layer_tweaker.cpp index 9042a589067..a7e55df952d 100644 --- a/src/mbgl/renderer/layers/heatmap_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/heatmap_layer_tweaker.cpp @@ -61,7 +61,7 @@ void HeatmapLayerTweaker::execute(LayerGroupBase& layerGroup, const PaintParamet constexpr bool nearClipped = false; constexpr bool inViewportPixelUnits = false; const auto matrix = getTileMatrix( - tileID, parameters, {0.f, 0.f}, TranslateAnchorType::Viewport, nearClipped, inViewportPixelUnits); + tileID, parameters, {0.f, 0.f}, TranslateAnchorType::Viewport, nearClipped, inViewportPixelUnits, drawable); const HeatmapDrawableUBO drawableUBO = { /* .matrix = */ util::cast(matrix), /* .extrude_scale = */ tileID.pixelsToTileUnits(1.0f, static_cast(zoom)), diff --git a/src/mbgl/renderer/layers/hillshade_layer_tweaker.cpp b/src/mbgl/renderer/layers/hillshade_layer_tweaker.cpp index f14787e6429..702b94d9a3c 100644 --- a/src/mbgl/renderer/layers/hillshade_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/hillshade_layer_tweaker.cpp @@ -62,7 +62,7 @@ void HillshadeLayerTweaker::execute(LayerGroupBase& layerGroup, const PaintParam drawable.mutableUniformBuffers().addOrReplace(idHillshadeEvaluatedPropsUBOName, evaluatedPropsUniformBuffer); const auto matrix = getTileMatrix( - tileID, parameters, {0.f, 0.f}, TranslateAnchorType::Viewport, false, false, true); + tileID, parameters, {0.f, 0.f}, TranslateAnchorType::Viewport, false, false, drawable, true); HillshadeDrawableUBO drawableUBO = {/* .matrix = */ util::cast(matrix), /* .latrange = */ getLatRange(tileID), /* .light = */ getLight(parameters, evaluated)}; diff --git a/src/mbgl/renderer/layers/line_layer_tweaker.cpp b/src/mbgl/renderer/layers/line_layer_tweaker.cpp index bcb96430044..57929104cf1 100644 --- a/src/mbgl/renderer/layers/line_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/line_layer_tweaker.cpp @@ -130,7 +130,8 @@ void LineLayerTweaker::execute(LayerGroupBase& layerGroup, const PaintParameters constexpr bool inViewportPixelUnits = false; // from RenderTile::translatedMatrix auto& uniforms = drawable.mutableUniformBuffers(); - const auto matrix = getTileMatrix(tileID, parameters, translation, anchor, nearClipped, inViewportPixelUnits); + const auto matrix = getTileMatrix( + tileID, parameters, translation, anchor, nearClipped, inViewportPixelUnits, drawable); uniforms.addOrReplace(idLineDynamicUBOName, dynamicBuffer); diff --git a/src/mbgl/renderer/layers/raster_layer_tweaker.cpp b/src/mbgl/renderer/layers/raster_layer_tweaker.cpp index 80d0caed14f..eb91f380ec3 100644 --- a/src/mbgl/renderer/layers/raster_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/raster_layer_tweaker.cpp @@ -65,7 +65,14 @@ void RasterLayerTweaker::execute([[maybe_unused]] LayerGroupBase& layerGroup, } else { // this is a tile drawable const UnwrappedTileID tileID = drawable.getTileID()->toUnwrapped(); - matrix = parameters.matrixForTile(tileID, !parameters.state.isChanging()); + matrix = getTileMatrix(tileID, + parameters, + {0.f, 0.f}, + TranslateAnchorType::Viewport, + false, + false, + drawable, + !parameters.state.isChanging()); } const RasterDrawableUBO drawableUBO{ diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp index d3bd88c6799..dd1436651ea 100644 --- a/src/mbgl/renderer/layers/render_fill_layer.cpp +++ b/src/mbgl/renderer/layers/render_fill_layer.cpp @@ -368,7 +368,7 @@ class OutlineDrawableTweaker : public gfx::DrawableTweaker { static const StringIdentity idLineUBOName = stringIndexer().get("LineBasicUBO"); { const auto matrix = LayerTweaker::getTileMatrix( - tileID, parameters, {{0, 0}}, style::TranslateAnchorType::Viewport, false, false, false); + tileID, parameters, {{0, 0}}, style::TranslateAnchorType::Viewport, false, false, drawable, false); const shaders::LineBasicUBO lineUBO{ /*matrix = */ util::cast(matrix), diff --git a/src/mbgl/renderer/layers/symbol_layer_tweaker.cpp b/src/mbgl/renderer/layers/symbol_layer_tweaker.cpp index 715bc738a7e..aa737811093 100644 --- a/src/mbgl/renderer/layers/symbol_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/symbol_layer_tweaker.cpp @@ -128,7 +128,8 @@ void SymbolLayerTweaker::execute(LayerGroupBase& layerGroup, const PaintParamete : evaluated.get(); constexpr bool nearClipped = false; constexpr bool inViewportPixelUnits = false; - const auto matrix = getTileMatrix(tileID, parameters, translate, anchor, nearClipped, inViewportPixelUnits); + const auto matrix = getTileMatrix( + tileID, parameters, translate, anchor, nearClipped, inViewportPixelUnits, drawable); // from symbol_program, makeValues const auto currentZoom = static_cast(parameters.state.getZoom()); diff --git a/src/mbgl/renderer/paint_parameters.cpp b/src/mbgl/renderer/paint_parameters.cpp index 0e801a0421a..77ba42d4821 100644 --- a/src/mbgl/renderer/paint_parameters.cpp +++ b/src/mbgl/renderer/paint_parameters.cpp @@ -82,16 +82,25 @@ mat4 PaintParameters::matrixForTile(const UnwrappedTileID& tileID, bool aligned) return matrix; } -gfx::DepthMode PaintParameters::depthModeForSublayer(uint8_t n, gfx::DepthMaskType mask) const { +gfx::DepthMode PaintParameters::depthModeForSublayer([[maybe_unused]] uint8_t n, gfx::DepthMaskType mask) const { if (currentLayer < opaquePassCutoff) { return gfx::DepthMode::disabled(); } + +#if MLN_RENDER_BACKEND_OPENGL float depth = depthRangeSize + ((1 + currentLayer) * numSublayers + n) * depthEpsilon; return gfx::DepthMode{gfx::DepthFunctionType::LessEqual, mask, {depth, depth}}; +#else + return gfx::DepthMode{gfx::DepthFunctionType::LessEqual, mask}; +#endif } gfx::DepthMode PaintParameters::depthModeFor3D() const { +#if MLN_RENDER_BACKEND_OPENGL return gfx::DepthMode{gfx::DepthFunctionType::LessEqual, gfx::DepthMaskType::ReadWrite, {0.0, depthRangeSize}}; +#else + return gfx::DepthMode{gfx::DepthFunctionType::LessEqual, gfx::DepthMaskType::ReadWrite}; +#endif } namespace { diff --git a/src/mbgl/renderer/paint_parameters.hpp b/src/mbgl/renderer/paint_parameters.hpp index d2bab39879b..6bb5a13fcde 100644 --- a/src/mbgl/renderer/paint_parameters.hpp +++ b/src/mbgl/renderer/paint_parameters.hpp @@ -121,14 +121,18 @@ class PaintParameters { int32_t nextStencilID = 1; public: - const int numSublayers = 3; uint32_t currentLayer; float depthRangeSize; uint32_t opaquePassCutoff = 0; float symbolFadeChange; const uint64_t frameCount; + static constexpr int numSublayers = 3; +#if MLN_RENDER_BACKEND_OPENGL static constexpr float depthEpsilon = 1.0f / (1 << 16); +#else + static constexpr float depthEpsilon = 1.0f / (1 << 12); +#endif static constexpr int maxStencilValue = 255; }; diff --git a/src/mbgl/renderer/render_target.cpp b/src/mbgl/renderer/render_target.cpp index 5ceb64a21d6..61bad83696d 100644 --- a/src/mbgl/renderer/render_target.cpp +++ b/src/mbgl/renderer/render_target.cpp @@ -74,7 +74,8 @@ void RenderTarget::render(RenderOrchestrator& orchestrator, const RenderTree& re // draw layer groups, opaque pass parameters.pass = RenderPass::Opaque; parameters.currentLayer = 0; - parameters.depthRangeSize = 1 - (numLayerGroups() + 2) * parameters.numSublayers * PaintParameters::depthEpsilon; + parameters.depthRangeSize = 1 - + (numLayerGroups() + 2) * PaintParameters::numSublayers * PaintParameters::depthEpsilon; visitLayerGroups([&](LayerGroupBase& layerGroup) { layerGroup.render(orchestrator, parameters); @@ -84,7 +85,8 @@ void RenderTarget::render(RenderOrchestrator& orchestrator, const RenderTree& re // draw layer groups, translucent pass parameters.pass = RenderPass::Translucent; parameters.currentLayer = static_cast(numLayerGroups()) - 1; - parameters.depthRangeSize = 1 - (numLayerGroups() + 2) * parameters.numSublayers * PaintParameters::depthEpsilon; + parameters.depthRangeSize = 1 - + (numLayerGroups() + 2) * PaintParameters::numSublayers * PaintParameters::depthEpsilon; visitLayerGroups([&](LayerGroupBase& layerGroup) { layerGroup.render(orchestrator, parameters); diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp index 22d9704761d..0546d96afad 100644 --- a/src/mbgl/renderer/renderer_impl.cpp +++ b/src/mbgl/renderer/renderer_impl.cpp @@ -330,7 +330,8 @@ void Renderer::Impl::render(const RenderTree& renderTree, const auto maxLayerIndex = orchestrator.maxLayerIndex(); parameters.pass = RenderPass::Opaque; parameters.currentLayer = 0; - parameters.depthRangeSize = 1 - (maxLayerIndex + 3) * parameters.numSublayers * PaintParameters::depthEpsilon; + parameters.depthRangeSize = 1 - + (maxLayerIndex + 3) * PaintParameters::numSublayers * PaintParameters::depthEpsilon; // draw layer groups, opaque pass orchestrator.visitLayerGroups([&](LayerGroupBase& layerGroup) { @@ -343,7 +344,8 @@ void Renderer::Impl::render(const RenderTree& renderTree, const auto debugGroup(parameters.renderPass->createDebugGroup("drawables-translucent")); const auto maxLayerIndex = orchestrator.maxLayerIndex(); parameters.pass = RenderPass::Translucent; - parameters.depthRangeSize = 1 - (maxLayerIndex + 3) * parameters.numSublayers * PaintParameters::depthEpsilon; + parameters.depthRangeSize = 1 - + (maxLayerIndex + 3) * PaintParameters::numSublayers * PaintParameters::depthEpsilon; // draw layer groups, translucent pass orchestrator.visitLayerGroups([&](LayerGroupBase& layerGroup) { @@ -358,7 +360,7 @@ void Renderer::Impl::render(const RenderTree& renderTree, const auto renderLayerOpaquePass = [&] { const auto debugGroup(parameters.renderPass->createDebugGroup("opaque")); parameters.pass = RenderPass::Opaque; - parameters.depthRangeSize = 1 - (layerRenderItems.size() + 2) * parameters.numSublayers * + parameters.depthRangeSize = 1 - (layerRenderItems.size() + 2) * PaintParameters::numSublayers * PaintParameters::depthEpsilon; uint32_t i = 0; @@ -376,7 +378,7 @@ void Renderer::Impl::render(const RenderTree& renderTree, const auto renderLayerTranslucentPass = [&] { const auto debugGroup(parameters.renderPass->createDebugGroup("translucent")); parameters.pass = RenderPass::Translucent; - parameters.depthRangeSize = 1 - (layerRenderItems.size() + 2) * parameters.numSublayers * + parameters.depthRangeSize = 1 - (layerRenderItems.size() + 2) * PaintParameters::numSublayers * PaintParameters::depthEpsilon; int32_t i = static_cast(layerRenderItems.size()) - 1; diff --git a/src/mbgl/renderer/sources/render_tile_source.cpp b/src/mbgl/renderer/sources/render_tile_source.cpp index b05eb756754..44203838483 100644 --- a/src/mbgl/renderer/sources/render_tile_source.cpp +++ b/src/mbgl/renderer/sources/render_tile_source.cpp @@ -208,7 +208,7 @@ void TileSourceRenderItem::updateDebugDrawables(DebugLayerGroupMap& debugLayerGr parameters.state.matrixFor(/*out*/ tileMatrix, tileID); const auto matrix = LayerTweaker::getTileMatrix( - tileID, parameters, {{0, 0}}, style::TranslateAnchorType::Viewport, false, false, false); + tileID, parameters, {{0, 0}}, style::TranslateAnchorType::Viewport, false, false, drawable, false); static const StringIdentity idLineDynamicUBOName = stringIndexer().get("LineDynamicUBO"); const shaders::LineDynamicUBO dynamicUBO = { diff --git a/src/mbgl/style/layers/custom_drawable_layer.cpp b/src/mbgl/style/layers/custom_drawable_layer.cpp index 37422228574..0b48648ba82 100644 --- a/src/mbgl/style/layers/custom_drawable_layer.cpp +++ b/src/mbgl/style/layers/custom_drawable_layer.cpp @@ -95,7 +95,7 @@ class LineDrawableTweaker : public gfx::DrawableTweaker { parameters.state.matrixFor(/*out*/ tileMatrix, tileID); const auto matrix = LayerTweaker::getTileMatrix( - tileID, parameters, {{0, 0}}, style::TranslateAnchorType::Viewport, false, false, false); + tileID, parameters, {{0, 0}}, style::TranslateAnchorType::Viewport, false, false, drawable, false); static const StringIdentity idLineDynamicUBOName = stringIndexer().get("LineDynamicUBO"); const shaders::LineDynamicUBO dynamicUBO = { @@ -149,7 +149,7 @@ class FillDrawableTweaker : public gfx::DrawableTweaker { parameters.state.matrixFor(/*out*/ tileMatrix, tileID); const auto matrix = LayerTweaker::getTileMatrix( - tileID, parameters, {{0, 0}}, style::TranslateAnchorType::Viewport, false, false, false); + tileID, parameters, {{0, 0}}, style::TranslateAnchorType::Viewport, false, false, drawable, false); static const StringIdentity idFillDrawableUBOName = stringIndexer().get("FillDrawableUBO"); const shaders::FillDrawableUBO fillUBO{/*matrix = */ util::cast(matrix)};