#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if MLN_DRAWABLE_RENDERER #include #include #include #include #include #endif namespace mbgl { using namespace style; namespace { #if MLN_DRAWABLE_RENDERER constexpr auto FillShaderName = "FillShader"; constexpr auto FillOutlineShaderName = "FillOutlineShader"; constexpr auto FillPatternShaderName = "FillPatternShader"; constexpr auto FillOutlinePatternShaderName = "FillOutlinePatternShader"; constexpr auto IconTextureName = "u_image"; #endif // MLN_DRAWABLE_RENDERER inline const FillLayer::Impl& impl_cast(const Immutable& impl) { assert(impl->getTypeInfo() == FillLayer::Impl::staticTypeInfo()); return static_cast(*impl); } } // namespace RenderFillLayer::RenderFillLayer(Immutable _impl) : RenderLayer(makeMutable(std::move(_impl))), unevaluated(impl_cast(baseImpl).paint.untransitioned()) {} RenderFillLayer::~RenderFillLayer() = default; void RenderFillLayer::transition(const TransitionParameters& parameters) { unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); } void RenderFillLayer::evaluate(const PropertyEvaluationParameters& parameters) { auto properties = makeMutable(staticImmutableCast(baseImpl), parameters.getCrossfadeParameters(), unevaluated.evaluate(parameters)); auto& evaluated = properties->evaluated; if (unevaluated.get().isUndefined()) { evaluated.get() = evaluated.get(); } passes = RenderPass::Translucent; if (!(!unevaluated.get().isUndefined() || evaluated.get().constantOr(Color()).a < 1.0f || evaluated.get().constantOr(0) < 1.0f)) { // Supply both - evaluated based on opaquePassCutoff in render(). passes |= RenderPass::Opaque; } properties->renderPasses = mbgl::underlying_type(passes); evaluatedProperties = std::move(properties); #if MLN_DRAWABLE_RENDERER if (layerGroup) { layerGroup->setLayerTweaker(std::make_shared(evaluatedProperties)); } #endif } bool RenderFillLayer::hasTransition() const { return unevaluated.hasTransition(); } bool RenderFillLayer::hasCrossfade() const { return getCrossfade(evaluatedProperties).t != 1; } #if MLN_LEGACY_RENDERER void RenderFillLayer::render(PaintParameters& parameters) { assert(renderTiles); if (!parameters.shaders.getLegacyGroup().populate(fillProgram)) return; if (!parameters.shaders.getLegacyGroup().populate(fillPatternProgram)) return; if (!parameters.shaders.getLegacyGroup().populate(fillOutlineProgram)) return; if (!parameters.shaders.getLegacyGroup().populate(fillOutlinePatternProgram)) return; if (unevaluated.get().isUndefined()) { parameters.renderTileClippingMasks(renderTiles); for (const RenderTile& tile : *renderTiles) { const LayerRenderData* renderData = getRenderDataForPass(tile, parameters.pass); if (!renderData) { continue; } auto& bucket = static_cast(*renderData->bucket); const auto& evaluated = getEvaluated(renderData->layerProperties); auto draw = [&](auto& programInstance, const auto& drawMode, const auto& depthMode, const auto& indexBuffer, const auto& segments, auto&& textureBindings) { const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID()); const auto allUniformValues = programInstance.computeAllUniformValues( FillProgram::LayoutUniformValues{ uniforms::matrix::Value(tile.translatedMatrix( evaluated.get(), evaluated.get(), parameters.state)), uniforms::world::Value(parameters.backend.getDefaultRenderable().getSize()), }, paintPropertyBinders, evaluated, static_cast(parameters.state.getZoom())); const auto allAttributeBindings = programInstance.computeAllAttributeBindings( *bucket.vertexBuffer, paintPropertyBinders, evaluated); checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings)); programInstance.draw(parameters.context, *parameters.renderPass, drawMode, depthMode, parameters.stencilModeForClipping(tile.id), parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(), indexBuffer, segments, allUniformValues, allAttributeBindings, std::forward(textureBindings), getID()); }; auto fillRenderPass = (evaluated.get().constantOr(Color()).a >= 1.0f && evaluated.get().constantOr(0) >= 1.0f && parameters.currentLayer >= parameters.opaquePassCutoff) ? RenderPass::Opaque : RenderPass::Translucent; if (bucket.triangleIndexBuffer && parameters.pass == fillRenderPass) { draw(*fillProgram, gfx::Triangles(), parameters.depthModeForSublayer(1, parameters.pass == RenderPass::Opaque ? gfx::DepthMaskType::ReadWrite : gfx::DepthMaskType::ReadOnly), *bucket.triangleIndexBuffer, bucket.triangleSegments, FillProgram::TextureBindings{}); } if (evaluated.get() && parameters.pass == RenderPass::Translucent) { draw(*fillOutlineProgram, gfx::Lines{2.0f}, parameters.depthModeForSublayer(unevaluated.get().isUndefined() ? 2 : 0, gfx::DepthMaskType::ReadOnly), *bucket.lineIndexBuffer, bucket.lineSegments, FillOutlineProgram::TextureBindings{}); } } } else { if (parameters.pass != RenderPass::Translucent) { return; } parameters.renderTileClippingMasks(renderTiles); for (const RenderTile& tile : *renderTiles) { const LayerRenderData* renderData = getRenderDataForPass(tile, parameters.pass); if (!renderData) { continue; } auto& bucket = static_cast(*renderData->bucket); const auto& evaluated = getEvaluated(renderData->layerProperties); const auto& crossfade = getCrossfade(renderData->layerProperties); const auto& fillPatternValue = evaluated.get().constantOr(Faded{"", ""}); std::optional patternPosA = tile.getPattern(fillPatternValue.from.id()); std::optional patternPosB = tile.getPattern(fillPatternValue.to.id()); auto draw = [&](auto& programInstance, const auto& drawMode, const auto& depthMode, const auto& indexBuffer, const auto& segments, auto&& textureBindings) { const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID()); paintPropertyBinders.setPatternParameters(patternPosA, patternPosB, crossfade); const auto allUniformValues = programInstance.computeAllUniformValues( FillPatternProgram::layoutUniformValues( tile.translatedMatrix( evaluated.get(), evaluated.get(), parameters.state), parameters.backend.getDefaultRenderable().getSize(), tile.getIconAtlasTexture()->getSize(), crossfade, tile.id, parameters.state, parameters.pixelRatio), paintPropertyBinders, evaluated, static_cast(parameters.state.getZoom())); const auto allAttributeBindings = programInstance.computeAllAttributeBindings( *bucket.vertexBuffer, paintPropertyBinders, evaluated); checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings)); programInstance.draw(parameters.context, *parameters.renderPass, drawMode, depthMode, parameters.stencilModeForClipping(tile.id), parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(), indexBuffer, segments, allUniformValues, allAttributeBindings, std::forward(textureBindings), getID()); }; if (bucket.triangleIndexBuffer) { draw(*fillPatternProgram, gfx::Triangles(), parameters.depthModeForSublayer(1, gfx::DepthMaskType::ReadWrite), *bucket.triangleIndexBuffer, bucket.triangleSegments, FillPatternProgram::TextureBindings{ tile.getIconAtlasTextureBinding(gfx::TextureFilterType::Linear), }); } if (evaluated.get() && unevaluated.get().isUndefined()) { draw(*fillOutlinePatternProgram, gfx::Lines{2.0f}, parameters.depthModeForSublayer(2, gfx::DepthMaskType::ReadOnly), *bucket.lineIndexBuffer, bucket.lineSegments, FillOutlinePatternProgram::TextureBindings{ tile.getIconAtlasTextureBinding(gfx::TextureFilterType::Linear), }); } } } } #endif // MLN_LEGACY_RENDERER bool RenderFillLayer::queryIntersectsFeature(const GeometryCoordinates& queryGeometry, const GeometryTileFeature& feature, const float, const TransformState& transformState, const float pixelsToTileUnits, const mat4&, const FeatureState&) const { const auto& evaluated = getEvaluated(evaluatedProperties); auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry(queryGeometry, evaluated.get(), evaluated.get(), static_cast(transformState.getBearing()), pixelsToTileUnits); return util::polygonIntersectsMultiPolygon(translatedQueryGeometry.value_or(queryGeometry), feature.getGeometries()); } #if MLN_DRAWABLE_RENDERER void RenderFillLayer::update(gfx::ShaderRegistry& shaders, gfx::Context& context, const TransformState& state, [[maybe_unused]] const RenderTree& renderTree, [[maybe_unused]] UniqueChangeRequestVec& changes) { std::unique_lock guard(mutex); if (!renderTiles || renderTiles->empty()) { removeAllDrawables(); return; } // Set up a layer group if (!layerGroup) { if (auto layerGroup_ = context.createTileLayerGroup(layerIndex, /*initialCapacity=*/64, getID())) { layerGroup_->setLayerTweaker(std::make_shared(evaluatedProperties)); setLayerGroup(std::move(layerGroup_), changes); } } auto* tileLayerGroup = static_cast(layerGroup.get()); if (!fillShaderGroup) { fillShaderGroup = shaders.getShaderGroup(std::string(FillShaderName)); } if (!outlineShaderGroup) { outlineShaderGroup = shaders.getShaderGroup(std::string(FillOutlineShaderName)); } if (!patternShaderGroup) { patternShaderGroup = shaders.getShaderGroup(std::string(FillPatternShaderName)); } if (!outlinePatternShaderGroup) { outlinePatternShaderGroup = shaders.getShaderGroup(std::string(FillOutlinePatternShaderName)); } if (!fillShaderGroup || !outlineShaderGroup || !patternShaderGroup || !outlinePatternShaderGroup) { removeAllDrawables(); return; } std::unordered_set newTileIDs(renderTiles->size()); std::transform(renderTiles->begin(), renderTiles->end(), std::inserter(newTileIDs, newTileIDs.begin()), [](const auto& renderTile) -> OverscaledTileID { return renderTile.get().getOverscaledTileID(); }); std::unique_ptr fillBuilder; std::unique_ptr outlineBuilder; std::unique_ptr patternBuilder; std::unique_ptr outlinePatternBuilder; gfx::VertexAttributeArray fillVertexAttrs; gfx::VertexAttributeArray outlineVertexAttrs; gfx::VertexAttributeArray patternVertexAttrs; gfx::VertexAttributeArray patternOutlineVertexAttrs; const auto layerPrefix = getID() + "/"; const auto renderPass = static_cast(evaluatedProperties->renderPasses); const auto finish = [&](gfx::DrawableBuilder& builder, const OverscaledTileID& tileID, const FillInterpolateUBO& interpUBO, const FillDrawableTilePropsUBO& tileUBO) { builder.flush(); for (auto& drawable : builder.clearDrawables()) { drawable->setTileID(tileID); auto& uniforms = drawable->mutableUniformBuffers(); uniforms.createOrUpdate(FillLayerTweaker::FillInterpolateUBOName, &interpUBO, context); uniforms.createOrUpdate(FillLayerTweaker::FillTilePropsUBOName, &tileUBO, context); tileLayerGroup->addDrawable(renderPass, tileID, std::move(drawable)); ++stats.drawablesAdded; } }; const auto commonInit = [&](gfx::DrawableBuilder& builder) { builder.setCullFaceMode(gfx::CullFaceMode::disabled()); builder.setEnableStencil(true); }; tileLayerGroup->observeDrawables([&](gfx::UniqueDrawable& drawable) { // If the render pass has changed or the tile has dropped out of the cover set, remove it. const auto tileID = drawable->getTileID(); if (drawable->getRenderPass() != renderPass || (tileID && newTileIDs.find(*tileID) == newTileIDs.end())) { drawable.reset(); ++stats.drawablesRemoved; } }); for (const RenderTile& tile : *renderTiles) { const auto& tileID = tile.getOverscaledTileID(); const LayerRenderData* renderData = getRenderDataForPass(tile, renderPass); if (!renderData) { removeTile(renderPass, tileID); continue; } auto& bucket = static_cast(*renderData->bucket); const auto& binders = bucket.paintPropertyBinders.at(getID()); const auto& evaluated = getEvaluated(renderData->layerProperties); const auto& crossfade = getCrossfade(renderData->layerProperties); const auto& fillPatternValue = evaluated.get().constantOr(Faded{"", ""}); const auto patternPosA = tile.getPattern(fillPatternValue.from.id()); const auto patternPosB = tile.getPattern(fillPatternValue.to.id()); binders.setPatternParameters(patternPosA, patternPosB, crossfade); const auto zoom = static_cast(state.getZoom()); const FillInterpolateUBO interpolateUBO = { /* .color_t = */ std::get<0>(binders.get()->interpolationFactor(zoom)), /* .opacity_t = */ std::get<0>(binders.get()->interpolationFactor(zoom)), /* .outline_color_t = */ std::get<0>(binders.get()->interpolationFactor(zoom)), /* .pattern_from_t = */ std::get<0>(binders.get()->interpolationFactor(zoom)), /* .pattern_to_t = */ std::get<0>(binders.get()->interpolationFactor(zoom)), /* .fade = */ crossfade.t, /* .padding = */ 0, 0}; // TODO: only update if properties re-evaluated? const FillDrawableTilePropsUBO tileProps = { /* pattern_from = */ patternPosA ? util::cast(patternPosA->tlbr()) : std::array{0}, /* pattern_to = */ patternPosB ? util::cast(patternPosB->tlbr()) : std::array{0}, }; // If we already have drawables for this tile, update them. if (tileLayerGroup->getDrawableCount(renderPass, tileID) > 0) { // TODO: Share buffers tileLayerGroup->observeDrawables(renderPass, tileID, [&](gfx::Drawable& drawable) { drawable.mutableUniformBuffers().createOrUpdate( FillLayerTweaker::FillInterpolateUBOName, &interpolateUBO, context); drawable.mutableUniformBuffers().createOrUpdate( FillLayerTweaker::FillTilePropsUBOName, &tileProps, context); }); continue; } std::vector> rawVerts; const auto buildVertices = [&]() { const auto& verts = bucket.vertices.vector(); if (rawVerts.size() < verts.size()) { rawVerts.resize(verts.size()); std::transform(verts.begin(), verts.end(), rawVerts.begin(), [](const auto& x) { return x.a1; }); } }; fillVertexAttrs.clear(); outlineVertexAttrs.clear(); gfx::DrawableTweakerPtr tweaker; if (fillBuilder) { fillBuilder->clearTweakers(); } if (outlineBuilder) { outlineBuilder->clearTweakers(); } // `Fill*Program` all use `style::FillPaintProperties` const auto fillUniformProps = fillVertexAttrs.readDataDrivenPaintProperties( binders, evaluated); const auto outlineUniformProps = outlineVertexAttrs.readDataDrivenPaintProperties( binders, evaluated); if (unevaluated.get().isUndefined()) { // Fill will occur in opaque or translucent pass based on `opaquePassCutoff`. // Outline always occurs in translucent pass, defaults to fill color const auto doOutline = evaluated.get(); const auto fillShader = std::static_pointer_cast( fillShaderGroup->getOrCreateShader(context, fillUniformProps)); const auto outlineShader = doOutline ? std::static_pointer_cast( outlineShaderGroup->getOrCreateShader(context, outlineUniformProps)) : nullptr; if (!fillBuilder && fillShader) { if (auto builder = context.createDrawableBuilder(layerPrefix + "fill")) { commonInit(*builder); builder->setDepthType((renderPass == RenderPass::Opaque) ? gfx::DepthMaskType::ReadWrite : gfx::DepthMaskType::ReadOnly); builder->setColorMode(renderPass == RenderPass::Translucent ? gfx::ColorMode::alphaBlended() : gfx::ColorMode::unblended()); builder->setSubLayerIndex(0); builder->setRenderPass(renderPass); fillBuilder = std::move(builder); } } if (doOutline && !outlineBuilder && outlineShader) { if (auto builder = context.createDrawableBuilder(layerPrefix + "fill-outline")) { commonInit(*builder); builder->setLineWidth(2.0f); builder->setDepthType(gfx::DepthMaskType::ReadOnly); builder->setColorMode(gfx::ColorMode::alphaBlended()); builder->setSubLayerIndex(unevaluated.get().isUndefined() ? 2 : 0); builder->setRenderPass(RenderPass::Translucent); outlineBuilder = std::move(builder); } } if (fillBuilder) { buildVertices(); fillBuilder->setShader(fillShader); fillBuilder->setVertexAttributes(fillVertexAttrs); fillBuilder->addVertices(rawVerts, 0, rawVerts.size()); fillBuilder->setSegments(gfx::Triangles(), bucket.triangles.vector(), bucket.triangleSegments.data(), bucket.triangleSegments.size()); finish(*fillBuilder, tileID, interpolateUBO, tileProps); } if (outlineBuilder) { buildVertices(); outlineBuilder->setShader(outlineShader); outlineBuilder->setVertexAttributes(outlineVertexAttrs); outlineBuilder->addVertices(rawVerts, 0, rawVerts.size()); outlineBuilder->setSegments( gfx::Lines(2), bucket.lines.vector(), bucket.lineSegments.data(), bucket.lineSegments.size()); finish(*outlineBuilder, tileID, interpolateUBO, tileProps); } } else { // FillPattern is defined if ((renderPass & RenderPass::Translucent) == 0) { continue; } // Outline does not default to fill in the pattern case const auto doOutline = evaluated.get() && unevaluated.get().isUndefined(); const auto fillShader = std::static_pointer_cast( patternShaderGroup->getOrCreateShader(context, fillUniformProps)); const auto outlineShader = doOutline ? std::static_pointer_cast( outlinePatternShaderGroup->getOrCreateShader( context, outlineUniformProps)) : nullptr; if (!patternBuilder) { if (auto builder = context.createDrawableBuilder(layerPrefix + "fill-pattern")) { commonInit(*builder); builder->setDepthType(gfx::DepthMaskType::ReadWrite); builder->setColorMode(gfx::ColorMode::alphaBlended()); builder->setSubLayerIndex(1); builder->setRenderPass(RenderPass::Translucent); if (tweaker) { builder->addTweaker(tweaker); } patternBuilder = std::move(builder); } } if (doOutline && !outlinePatternBuilder) { if (auto builder = context.createDrawableBuilder(layerPrefix + "fill-outline-pattern")) { commonInit(*builder); builder->setLineWidth(2.0f); builder->setDepthType(gfx::DepthMaskType::ReadOnly); builder->setColorMode(gfx::ColorMode::alphaBlended()); builder->setSubLayerIndex(2); builder->setRenderPass(RenderPass::Translucent); if (tweaker) { builder->addTweaker(tweaker); } outlinePatternBuilder = std::move(builder); } } if ((patternBuilder || outlineBuilder) && !tweaker) { if (const auto& atlases = tile.getAtlasTextures()) { tweaker = std::make_shared(atlases, /*glyphName=*/std::string(), std::string(IconTextureName), /*isText=*/false); if (patternBuilder) { patternBuilder->addTweaker(tweaker); } if (outlineBuilder) { outlineBuilder->addTweaker(tweaker); } } } if (patternBuilder) { buildVertices(); patternBuilder->setShader(fillShader); patternBuilder->setRenderPass(renderPass); patternBuilder->setVertexAttributes(fillVertexAttrs); patternBuilder->addVertices(rawVerts, 0, rawVerts.size()); patternBuilder->setSegments(gfx::Triangles(), bucket.triangles.vector(), bucket.triangleSegments.data(), bucket.triangleSegments.size()); finish(*patternBuilder, tileID, interpolateUBO, tileProps); } if (outlinePatternBuilder) { buildVertices(); outlinePatternBuilder->setShader(outlineShader); outlinePatternBuilder->setRenderPass(renderPass); outlinePatternBuilder->setVertexAttributes(outlineVertexAttrs); outlinePatternBuilder->addVertices(rawVerts, 0, rawVerts.size()); outlinePatternBuilder->setSegments( gfx::Lines(2), bucket.lines.vector(), bucket.lineSegments.data(), bucket.lineSegments.size()); finish(*outlinePatternBuilder, tileID, interpolateUBO, tileProps); } } } } #endif } // namespace mbgl