#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace mbgl { using namespace style; namespace { inline const BackgroundLayer::Impl& impl_cast(const Immutable& impl) { assert(impl->getTypeInfo() == BackgroundLayer::Impl::staticTypeInfo()); return static_cast(*impl); } } // namespace RenderBackgroundLayer::RenderBackgroundLayer(Immutable _impl) : RenderLayer(makeMutable(std::move(_impl))), unevaluated(impl_cast(baseImpl).paint.untransitioned()) {} RenderBackgroundLayer::~RenderBackgroundLayer() = default; void RenderBackgroundLayer::transition(const TransitionParameters& parameters) { unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated)); } void RenderBackgroundLayer::evaluate(const PropertyEvaluationParameters& parameters) { auto evaluated = unevaluated.evaluate(parameters); auto properties = makeMutable( staticImmutableCast(baseImpl), parameters.getCrossfadeParameters(), evaluated); passes = properties->evaluated.get() == 0.0f ? RenderPass::None : (!unevaluated.get().isUndefined() || properties->evaluated.get() < 1.0f || properties->evaluated.get().a < 1.0f) ? RenderPass::Translucent // Supply both - evaluated based on opaquePassCutoff in render(). : RenderPass::Opaque | RenderPass::Translucent; properties->renderPasses = mbgl::underlying_type(passes); evaluatedProperties = std::move(properties); } bool RenderBackgroundLayer::hasTransition() const { return unevaluated.hasTransition(); } bool RenderBackgroundLayer::hasCrossfade() const { return getCrossfade(evaluatedProperties).t != 1; } void RenderBackgroundLayer::render(PaintParameters& parameters) { // Note that for bottommost layers without a pattern, the background color // is drawn with glClear rather than this method. // Ensure programs are available if (!parameters.shaders.populate(backgroundProgram)) return; if (!parameters.shaders.populate(backgroundPatternProgram)) return; const Properties<>::PossiblyEvaluated properties; const BackgroundProgram::Binders paintAttributeData(properties, 0); auto draw = [&](auto& program, auto&& uniformValues, const auto& textureBindings, const uint32_t id) { const auto allUniformValues = program.computeAllUniformValues( std::forward(uniformValues), paintAttributeData, properties, static_cast(parameters.state.getZoom())); const auto allAttributeBindings = program.computeAllAttributeBindings( *parameters.staticData.tileVertexBuffer, paintAttributeData, properties); checkRenderability(parameters, program.activeBindingCount(allAttributeBindings)); program.draw( parameters.context, *parameters.renderPass, gfx::Triangles(), parameters.depthModeForSublayer( 0, parameters.pass == RenderPass::Opaque ? gfx::DepthMaskType::ReadWrite : gfx::DepthMaskType::ReadOnly), gfx::StencilMode::disabled(), parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(), *parameters.staticData.quadTriangleIndexBuffer, segments, allUniformValues, allAttributeBindings, textureBindings, util::toString(id)); }; if (segments.empty()) { segments = RenderStaticData::tileTriangleSegments(); } const auto& evaluated = static_cast(*evaluatedProperties).evaluated; const auto& crossfade = static_cast(*evaluatedProperties).crossfade; if (!evaluated.get().to.empty()) { std::optional imagePosA = parameters.patternAtlas.getPattern( evaluated.get().from.id()); std::optional imagePosB = parameters.patternAtlas.getPattern( evaluated.get().to.id()); if (!imagePosA || !imagePosB) return; uint32_t i = 0; for (const auto& tileID : util::tileCover(parameters.state, parameters.state.getIntegerZoom())) { const UnwrappedTileID unwrappedTileID = tileID.toUnwrapped(); draw(*backgroundPatternProgram, BackgroundPatternProgram::layoutUniformValues(parameters.matrixForTile(unwrappedTileID), evaluated.get(), parameters.patternAtlas.getPixelSize(), *imagePosA, *imagePosB, crossfade, unwrappedTileID, parameters.state), BackgroundPatternProgram::TextureBindings{ textures::image::Value{parameters.patternAtlas.textureBinding()}, }, i++); } } else { auto backgroundRenderPass = (evaluated.get().a >= 1.0f && evaluated.get() >= 1.0f && parameters.currentLayer >= parameters.opaquePassCutoff) ? RenderPass::Opaque : RenderPass::Translucent; if (parameters.pass != backgroundRenderPass) { return; } uint32_t i = 0; for (const auto& tileID : util::tileCover(parameters.state, parameters.state.getIntegerZoom())) { draw(*backgroundProgram, BackgroundProgram::LayoutUniformValues{ uniforms::matrix::Value(parameters.matrixForTile(tileID.toUnwrapped())), uniforms::color::Value(evaluated.get()), uniforms::opacity::Value(evaluated.get()), }, BackgroundProgram::TextureBindings{}, i++); } } } std::optional RenderBackgroundLayer::getSolidBackground() const { const auto& evaluated = getEvaluated(evaluatedProperties); if (!evaluated.get().from.empty() || evaluated.get() <= 0.0f) { return std::nullopt; } return std::nullopt; // return { evaluated.get() * evaluated.get() }; } namespace { void addPatternIfNeeded(const std::string& id, const LayerPrepareParameters& params) { if (!params.patternAtlas.getPattern(id)) { if (auto* image = params.imageManager.getImage(id)) { params.patternAtlas.addPattern(*image); } } } } // namespace void RenderBackgroundLayer::prepare(const LayerPrepareParameters& params) { const auto& evaluated = getEvaluated(evaluatedProperties); if (!evaluated.get().to.empty()) { // Ensures that the pattern bitmap gets copied to atlas bitmap. // Atlas bitmap is uploaded to atlas texture in upload. addPatternIfNeeded(evaluated.get().from.id(), params); addPatternIfNeeded(evaluated.get().to.id(), params); } } constexpr auto shaderName = "background_generic"; void RenderBackgroundLayer::layerRemoved(UniqueChangeRequestVec& changes) { // TODO: This isn't happening on style change, so old tile drawables are being left active // Remove everything decltype(tileDrawables) localDrawables; { std::unique_lock guard(mutex); localDrawables = std::move(tileDrawables); } removeDrawables( localDrawables.cbegin(), localDrawables.cend(), changes, [](auto& ii) { return ii->second->getId(); }); } void RenderBackgroundLayer::update(const int32_t layerIndex, gfx::ShaderRegistry& shaders, gfx::Context& context, const TransformState& state, UniqueChangeRequestVec& changes) { std::unique_lock guard(mutex); if (!shader) { shader = context.getGenericShader(shaders, shaderName); } const auto& evaluated = getEvaluated(evaluatedProperties); // TODO: If background is solid, we can skip drawables and rely on the clear color // const auto passes = eval.get() == 0.0f // ? RenderPass::None // : (!uneval.get().isUndefined() // || eval.get() < 1.0f // || eval.get().a < 1.0f) // ? RenderPass::Translucent // : RenderPass::Opaque | RenderPass::Translucent; // evaluated based on opaquePassCutoff in render() // unevaluated.hasTransition(); // getCrossfade(evaluatedProperties).t != 1; std::optional color; if (evaluated.get().from.empty()) { const auto opacity = evaluated.get(); if (opacity > 0.0f) { color = evaluated.get() * evaluated.get(); } } // If the result is transparent or missing, just remove any existing drawables and stop if (!color) { removeDrawables( tileDrawables.cbegin(), tileDrawables.cend(), changes, [](auto& ii) { return ii->second->getId(); }); tileDrawables.clear(); return; } const bool colorChange = (color != lastColor); const bool layerChange = (layerIndex != lastLayerIndex); lastColor = color; lastLayerIndex = layerIndex; const auto zoom = state.getIntegerZoom(); const auto tileCover = util::tileCover(state, zoom); // Drawables per overscaled or canonical tile? // const UnwrappedTileID unwrappedTileID = tileID.toUnwrapped(); // Put the tile cover into a searchable form. // TODO: Likely better to sort and `std::binary_search` the vector. // If it's returned in a well-defined order, we might not even need to sort. const std::unordered_set newTileIDs(tileCover.begin(), tileCover.end()); // For each existing tile drawable... for (auto iter = tileDrawables.begin(); iter != tileDrawables.end();) { const auto& drawable = iter->second; // Has this tile dropped out of the cover set? if (newTileIDs.find(iter->first) == newTileIDs.end()) { // remove it changes.emplace_back(std::make_unique(drawable->getId())); // Log::Warning(Event::General, "Removing drawable for " + util::toString(iter->first) + " total " + // std::to_string(stats.tileDrawablesRemoved+1)); iter = tileDrawables.erase(iter); ++stats.tileDrawablesRemoved; continue; } ++iter; // If the color evaluated to a new value, update all vertexes of the drawable to the new color if (colorChange) { drawable->resetColor(*color); } if (layerChange) { drawable->setLayerIndex(layerIndex); } } std::unique_ptr builder; // For each tile in the cover set, add a tile drawable if one doesn't already exist. // We currently assume only one drawable per tile. for (const auto& tileID : tileCover) { const auto result = tileDrawables.insert(std::make_pair(tileID, gfx::DrawablePtr())); if (!result.second) { // Already present // TODO: Update matrix here or in the tweaker? continue; } // We actually need to build things, so set up a builder if we haven't already if (!builder) { builder = context.createDrawableBuilder("background"); builder->setShader(shader); builder->addTweaker(context.createDrawableTweaker()); builder->setColor(*color); builder->setColorMode(gfx::DrawableBuilder::ColorMode::PerDrawable); builder->setDepthType(gfx::DepthMaskType::ReadWrite); builder->setLayerIndex(layerIndex); } // Tile coordinates are fixed... builder->addQuad(0, 0, util::EXTENT, util::EXTENT); // ... they're placed with the matrix in the uniforms, which changes with the view builder->setMatrix(/*parameters.matrixForTile(tileID.toUnwrapped())*/ matrix::identity4()); builder->flush(); auto newDrawables = builder->clearDrawables(); if (!newDrawables.empty()) { auto& drawable = newDrawables[0]; drawable->setTileID(tileID); result.first->second = drawable; changes.emplace_back(std::make_unique(std::move(drawable))); ++stats.tileDrawablesAdded; // Log::Warning(Event::General, "Adding drawable for " + util::toString(tileID) + " total " + // std::to_string(stats.tileDrawablesAdded+1)); } } } } // namespace mbgl