#include #include #include #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); evaluatedPropertiesChange = true; } 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); } } void RenderBackgroundLayer::layerRemoved(UniqueChangeRequestVec& changes) { // Remove everything if (tileLayerGroup) { changes.emplace_back(std::make_unique(tileLayerGroup->getLayerIndex())); tileLayerGroup.reset(); } } 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, "BackgroundShader"); } const auto removeAll = [&]() { if (tileLayerGroup) { stats.tileDrawablesRemoved += tileLayerGroup->getDrawableCount(); tileLayerGroup->clearDrawables(); } }; const auto zoom = state.getIntegerZoom(); const auto tileCover = util::tileCover(state, zoom); // renderTiles is always empty, we use tileCover instead // if (!renderTiles || renderTiles->empty()) { if (tileCover.empty()) { removeAll(); return; } const auto& evaluated = getEvaluated(evaluatedProperties); // TODO: If background is solid, we can skip drawables and rely on the clear color const auto drawPasses = evaluated.get() == 0.0f ? RenderPass::None : (!unevaluated.get().isUndefined() || evaluated.get() < 1.0f || evaluated.get().a < 1.0f) ? RenderPass::Translucent : RenderPass::Opaque | RenderPass::Translucent; // evaluated based on opaquePassCutoff in render() // unevaluated.hasTransition(); // getCrossfade(evaluatedProperties).t != 1; // If the result is transparent or missing, just remove any existing drawables and stop if (drawPasses == RenderPass::None) { removeAll(); return; } if (evaluatedPropertiesChange) { BackgroundLayerUBO backgroundLayerUBO; backgroundLayerUBO.color = evaluated.get(); backgroundLayerUBO.opacity = evaluated.get(); uniformBuffer = context.createUniformBuffer(&backgroundLayerUBO, sizeof(backgroundLayerUBO)); evaluatedPropertiesChange = false; } if (!tileLayerGroup) { tileLayerGroup = context.createTileLayerGroup(layerIndex, /*initialCapacity=*/64); if (!tileLayerGroup) { return; } changes.emplace_back(std::make_unique(tileLayerGroup, /*canReplace=*/true)); } // 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()); std::unique_ptr builder; for (const auto renderPass : {RenderPass::Opaque, RenderPass::Translucent}) { tileLayerGroup->observeDrawables([&](gfx::UniqueDrawable& drawable) { // Has this tile dropped out of the cover set? const auto tileID = drawable->getTileID(); if (tileID && newTileIDs.find(*tileID) == newTileIDs.end()) { drawable.reset(); ++stats.tileDrawablesRemoved; return; } }); // 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) { auto& tileDrawable = tileLayerGroup->getDrawable(renderPass, tileID); if (!(renderPass & drawPasses)) { // Not in this pass if (tileDrawable) { tileLayerGroup->removeDrawable(renderPass, tileID); ++stats.tileDrawablesRemoved; } continue; } if (tileDrawable) { // Already created, update it. tileDrawable->mutableUniformBuffers().addOrReplace("BackgroundLayerUBO", uniformBuffer); continue; } // We actually need to build things, so set up a builder if we haven't already if (!builder) { builder = context.createDrawableBuilder("background"); builder->setRenderPass(drawPasses); builder->setShader(shader); builder->addTweaker(context.createDrawableTweaker()); 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); drawable->mutableUniformBuffers().addOrReplace("BackgroundLayerUBO", uniformBuffer); tileLayerGroup->addDrawable(renderPass, tileID, std::move(drawable)); ++stats.tileDrawablesAdded; // Log::Warning(Event::General, "Adding drawable for " + util::toString(tileID) + " total " + // std::to_string(stats.tileDrawablesAdded+1)); } } } } } // namespace mbgl