Files
MapLibreParticleLab/src/mbgl/renderer/sources/render_raster_dem_source.cpp
Scott Hoyt ca5f79c12d Fix for raster dem encoding override in style.json (#3570)
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
2025-08-01 13:50:09 +02:00

125 lines
6.1 KiB
C++

#include <mbgl/renderer/sources/render_raster_dem_source.hpp>
#include <mbgl/renderer/render_tile.hpp>
#include <mbgl/tile/raster_dem_tile.hpp>
#include <mbgl/algorithm/update_tile_masks.hpp>
#include <mbgl/geometry/dem_data.hpp>
#include <mbgl/renderer/buckets/hillshade_bucket.hpp>
#include <mbgl/renderer/tile_parameters.hpp>
namespace mbgl {
using namespace style;
RenderRasterDEMSource::RenderRasterDEMSource(Immutable<style::TileSource::Impl> impl_,
const TaggedScheduler& threadPool_)
: RenderTileSetSource(std::move(impl_), threadPool_) {}
const style::TileSource::Impl& RenderRasterDEMSource::impl() const {
return static_cast<const style::TileSource::Impl&>(*baseImpl);
}
const std::optional<Tileset>& RenderRasterDEMSource::getTileset() const {
return impl().tileset;
}
void RenderRasterDEMSource::updateInternal(const Tileset& tileset,
const std::vector<Immutable<LayerProperties>>& layers,
const bool needsRendering,
const bool needsRelayout,
const TileParameters& parameters) {
tilePyramid.update(layers,
needsRendering,
needsRelayout,
parameters,
*baseImpl,
impl().getTileSize(),
tileset.zoomRange,
tileset.bounds,
[&](const OverscaledTileID& tileID, TileObserver* observer_) {
return std::make_unique<RasterDEMTile>(tileID, baseImpl->id, parameters, tileset, observer_);
});
algorithm::updateTileMasks(tilePyramid.getRenderedTiles());
}
void RenderRasterDEMSource::onTileChanged(Tile& tile) {
auto& demtile = static_cast<RasterDEMTile&>(tile);
std::map<DEMTileNeighbors, DEMTileNeighbors> opposites = {
{DEMTileNeighbors::Left, DEMTileNeighbors::Right},
{DEMTileNeighbors::Right, DEMTileNeighbors::Left},
{DEMTileNeighbors::TopLeft, DEMTileNeighbors::BottomRight},
{DEMTileNeighbors::TopCenter, DEMTileNeighbors::BottomCenter},
{DEMTileNeighbors::TopRight, DEMTileNeighbors::BottomLeft},
{DEMTileNeighbors::BottomRight, DEMTileNeighbors::TopLeft},
{DEMTileNeighbors::BottomCenter, DEMTileNeighbors::TopCenter},
{DEMTileNeighbors::BottomLeft, DEMTileNeighbors::TopRight}};
if (tile.isRenderable() && demtile.neighboringTiles != DEMTileNeighbors::Complete) {
const CanonicalTileID canonical = tile.id.canonical;
const auto dim = static_cast<uint32_t>(std::pow(2, canonical.z));
const uint32_t px = (canonical.x - 1 + dim) % dim;
const int pxw = canonical.x == 0 ? tile.id.wrap - 1 : tile.id.wrap;
const uint32_t nx = (canonical.x + 1 + dim) % dim;
const int nxw = (canonical.x + 1 == dim) ? tile.id.wrap + 1 : tile.id.wrap;
auto getNeighbor = [&](DEMTileNeighbors mask) {
if (mask == DEMTileNeighbors::Left) {
return OverscaledTileID(tile.id.overscaledZ, pxw, canonical.z, px, canonical.y);
} else if (mask == DEMTileNeighbors::Right) {
return OverscaledTileID(tile.id.overscaledZ, nxw, canonical.z, nx, canonical.y);
} else if (mask == DEMTileNeighbors::TopLeft) {
return OverscaledTileID(tile.id.overscaledZ, pxw, canonical.z, px, canonical.y - 1);
} else if (mask == DEMTileNeighbors::TopCenter) {
return OverscaledTileID(tile.id.overscaledZ, tile.id.wrap, canonical.z, canonical.x, canonical.y - 1);
} else if (mask == DEMTileNeighbors::TopRight) {
return OverscaledTileID(tile.id.overscaledZ, nxw, canonical.z, nx, canonical.y - 1);
} else if (mask == DEMTileNeighbors::BottomLeft) {
return OverscaledTileID(tile.id.overscaledZ, pxw, canonical.z, px, canonical.y + 1);
} else if (mask == DEMTileNeighbors::BottomCenter) {
return OverscaledTileID(tile.id.overscaledZ, tile.id.wrap, canonical.z, canonical.x, canonical.y + 1);
} else if (mask == DEMTileNeighbors::BottomRight) {
return OverscaledTileID(tile.id.overscaledZ, nxw, canonical.z, nx, canonical.y + 1);
} else {
throw std::runtime_error("mask is not a valid tile neighbor");
}
};
for (uint8_t i = 0; i < 8; i++) {
auto mask = DEMTileNeighbors(std::pow(2, i));
// only backfill if this neighbor has not been previously backfilled
if ((demtile.neighboringTiles & mask) != mask) {
OverscaledTileID neighborid = getNeighbor(mask);
Tile* renderableNeighbor = tilePyramid.getTile(neighborid);
if (renderableNeighbor != nullptr && renderableNeighbor->isRenderable()) {
auto& borderTile = static_cast<RasterDEMTile&>(*renderableNeighbor);
demtile.backfillBorder(borderTile, mask);
// if the border tile has not been backfilled by a previous
// instance of the main tile, backfill its corresponding
// neighbor as well.
const DEMTileNeighbors& borderMask = opposites[mask];
if ((borderTile.neighboringTiles & borderMask) != borderMask) {
borderTile.backfillBorder(demtile, borderMask);
}
}
}
}
}
RenderTileSource::onTileChanged(tile);
}
std::unordered_map<std::string, std::vector<Feature>> RenderRasterDEMSource::queryRenderedFeatures(
const ScreenLineString&,
const TransformState&,
const std::unordered_map<std::string, const RenderLayer*>&,
const RenderedQueryOptions&,
const mat4&) const {
return std::unordered_map<std::string, std::vector<Feature>>{};
}
std::vector<Feature> RenderRasterDEMSource::querySourceFeatures(const SourceQueryOptions&) const {
return {};
}
} // namespace mbgl