Merge branch 'topic/drawable-fixes' into topic/drawable (#1560)

Co-authored-by: Stefan Karschti <stefan.karschti@gmail.com>
Co-authored-by: Alex Cristici <alex.cristici@gmail.com>
Co-authored-by: Tim Sylvester <tim@wetdogweather.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
This commit is contained in:
mwilsnd
2023-08-25 13:33:01 -05:00
committed by Bart Louwers
parent 7afd821720
commit 642903fdb4
76 changed files with 1680 additions and 445 deletions

View File

@@ -2,7 +2,6 @@
#include <mbgl/renderer/buckets/debug_bucket.hpp>
#include <mbgl/renderer/render_tile.hpp>
#include <mbgl/renderer/render_tree.hpp>
#include <mbgl/renderer/paint_parameters.hpp>
#include <mbgl/renderer/tile_parameters.hpp>
#include <mbgl/renderer/tile_render_data.hpp>
@@ -10,26 +9,21 @@
#include <mbgl/util/constants.hpp>
#include <mbgl/util/math.hpp>
#if MLN_DRAWABLE_RENDERER
#include <mbgl/renderer/layer_group.hpp>
#include <mbgl/renderer/render_static_data.hpp>
#include <mbgl/gfx/drawable.hpp>
#include <mbgl/gfx/drawable_builder.hpp>
#include <mbgl/shaders/shader_program_base.hpp>
#include <mbgl/util/convert.hpp>
#include <unordered_set>
#endif
namespace mbgl {
using namespace style;
class TileSourceRenderItem : public RenderItem {
public:
TileSourceRenderItem(Immutable<std::vector<RenderTile>> renderTiles_, std::string name_)
: renderTiles(std::move(renderTiles_)),
name(std::move(name_)) {}
private:
void upload(gfx::UploadPass&) const override;
void render(PaintParameters&) const override;
bool hasRenderPass(RenderPass) const override { return false; }
const std::string& getName() const override { return name; }
Immutable<std::vector<RenderTile>> renderTiles;
std::string name;
};
void TileSourceRenderItem::upload(gfx::UploadPass& parameters) const {
for (auto& tile : *renderTiles) {
tile.upload(parameters);
@@ -42,6 +36,225 @@ void TileSourceRenderItem::render(PaintParameters& parameters) const {
}
}
#if MLN_DRAWABLE_RENDERER
void TileSourceRenderItem::updateDebugDrawables(DebugLayerGroupMap& debugLayerGroups,
PaintParameters& parameters) const {
if (!(parameters.debugOptions &
(MapDebugOptions::Timestamps | MapDebugOptions::ParseStatus | MapDebugOptions::TileBorders))) {
debugLayerGroups.clear();
return;
}
// Debug UBO definition
struct alignas(16) DebugUBO {
std::array<float, 4 * 4> matrix;
Color color;
float overlay_scale;
float pad1, pad2, pad3;
};
static_assert(sizeof(DebugUBO) % 16 == 0);
constexpr auto DebugUBOName = "DebugUBO";
// initialize
auto& context = parameters.context;
const auto renderPass = RenderPass::None;
auto& shaders = *parameters.staticData.shaders;
constexpr auto DebugShaderName = "DebugShader";
gfx::ShaderProgramBasePtr debugShader = context.getGenericShader(shaders, std::string(DebugShaderName));
// create a builder
constexpr auto VertexAttribName = "a_pos";
std::unique_ptr<gfx::DrawableBuilder> builder = context.createDrawableBuilder("debug-builder");
builder->setShader(debugShader);
builder->setRenderPass(renderPass);
builder->setEnableDepth(false);
builder->setColorMode(gfx::ColorMode::unblended());
builder->setCullFaceMode(gfx::CullFaceMode::disabled());
builder->setEnableStencil(false);
builder->setVertexAttrName(VertexAttribName);
// add or get the layer group for a debug type
const auto addOrGetLayerGroupForType = [&debugLayerGroups, &context](
DebugType type,
const std::string&& layerName) -> DebugLayerGroupMap::const_iterator {
auto it = debugLayerGroups.find(type);
if (it == debugLayerGroups.end()) {
auto inserted = debugLayerGroups.insert(std::make_pair(
type, context.createTileLayerGroup(static_cast<int32_t>(type), /*initialCapacity=*/64, layerName)));
assert(inserted.second);
it = inserted.first;
}
return it;
};
// build a set of tiles to cover
std::unordered_set<OverscaledTileID> newTiles;
for (auto& tile : *renderTiles) {
if (tile.getNeedsRendering()) {
newTiles.insert(tile.getOverscaledTileID());
}
}
// create texture. to be reused for all the tiles of the debug layers
auto texture = context.createTexture2D();
std::optional<uint32_t> samplerLocation;
{
std::array<uint8_t, 4> data{{0, 0, 0, 0}};
auto emptyImage = std::make_shared<PremultipliedImage>(Size(1, 1), data.data(), data.size());
texture->setImage(emptyImage);
texture->setSamplerConfiguration(
{gfx::TextureFilterType::Linear, gfx::TextureWrapType::Clamp, gfx::TextureWrapType::Clamp});
constexpr auto DebugOverlayUniformName = "u_overlay";
samplerLocation = debugShader->getSamplerLocation(DebugOverlayUniformName);
}
assert(samplerLocation.has_value());
if (!samplerLocation.has_value()) return;
// function to update existing tile drawables with UBO value. return number of updated drawables
const auto updateDrawables =
[&](TileLayerGroup* tileLayerGroup, const OverscaledTileID& tileID, const DebugUBO& debugUBO) -> size_t {
auto updatedCount = tileLayerGroup->visitDrawables(renderPass, tileID, [&](gfx::Drawable& drawable) {
// update existing drawable
auto& uniforms = drawable.mutableUniformBuffers();
uniforms.createOrUpdate(DebugUBOName, &debugUBO, context);
});
return updatedCount;
};
// function to add drawable
const auto addDrawable = [&](TileLayerGroup* tileLayerGroup,
const OverscaledTileID& tileID,
const DebugUBO& debugUBO,
const gfx::DrawMode mode,
const auto& vertices,
const auto& indexes,
const auto& segments) {
// create new drawable
std::vector<std::array<int16_t, 2>> verts(vertices.size());
std::transform(vertices.begin(), vertices.end(), verts.begin(), [](const auto& v) -> std::array<int16_t, 2> {
return v.a1;
});
builder->addVertices(verts, 0, verts.size());
builder->setSegments(mode, indexes, segments.data(), segments.size());
// texture
builder->setTexture(texture, samplerLocation.value());
// finish
builder->flush();
for (auto& drawable : builder->clearDrawables()) {
drawable->setTileID(tileID);
auto& uniforms = drawable->mutableUniformBuffers();
uniforms.createOrUpdate(DebugUBOName, &debugUBO, context);
tileLayerGroup->addDrawable(renderPass, tileID, std::move(drawable));
}
};
// Timestamps or Parse Status
if (parameters.debugOptions & (MapDebugOptions::Timestamps | MapDebugOptions::ParseStatus)) {
TileLayerGroup* outlineLayerGroup = static_cast<TileLayerGroup*>(
addOrGetLayerGroupForType(DebugType::TextOutline, "debug-text-outline")->second.get());
TileLayerGroup* textLayerGroup = static_cast<TileLayerGroup*>(
addOrGetLayerGroupForType(DebugType::Text, "debug-text")->second.get());
// erase drawables that are not in the current tile set
for (auto& lg : {outlineLayerGroup, textLayerGroup}) {
lg->removeDrawablesIf([&](gfx::Drawable& drawable) {
return !(drawable.getTileID().has_value() && newTiles.count(*drawable.getTileID()) > 0);
});
}
// add new drawables and update existing ones
for (auto& tile : *renderTiles) {
if (tile.getNeedsRendering()) {
const auto tileID = tile.getOverscaledTileID();
const auto& debugBucket = tile.debugBucket;
if (!debugBucket) continue;
const DebugUBO outlineUBO{/*matrix = */ util::cast<float>(tile.matrix),
/*color = */ Color::white(),
/*overlay_scale = */ 1.0f,
0,
0,
0};
if (0 == updateDrawables(outlineLayerGroup, tileID, outlineUBO)) {
addDrawable(outlineLayerGroup,
tileID,
outlineUBO,
gfx::Lines(4.0f * parameters.pixelRatio),
debugBucket->vertices.vector(),
debugBucket->indices.vector(),
debugBucket->segments);
}
const DebugUBO textUBO{/*matrix = */ util::cast<float>(tile.matrix),
/*color = */ Color::black(),
/*overlay_scale = */ 1.0f,
0,
0,
0};
if (0 == updateDrawables(textLayerGroup, tileID, textUBO)) {
addDrawable(textLayerGroup,
tileID,
textUBO,
gfx::Lines(2.0f * parameters.pixelRatio),
debugBucket->vertices.vector(),
debugBucket->indices.vector(),
debugBucket->segments);
}
}
}
} else {
// tile texts are not required, erase layer groups
debugLayerGroups.erase(DebugType::TextOutline);
debugLayerGroups.erase(DebugType::Text);
}
// Tile Borders
if (parameters.debugOptions & (MapDebugOptions::TileBorders)) {
TileLayerGroup* tileLayerGroup = static_cast<TileLayerGroup*>(
addOrGetLayerGroupForType(DebugType::Border, "debug-border")->second.get());
// erase drawables that are not in the current tile set
tileLayerGroup->removeDrawablesIf([&](gfx::Drawable& drawable) {
return !(drawable.getTileID().has_value() && newTiles.count(*drawable.getTileID()) > 0);
});
// add new drawables and update existing ones
auto vertices = RenderStaticData::tileVertices().vector();
auto indexes = RenderStaticData::tileLineStripIndices().vector();
auto segments = RenderStaticData::tileBorderSegments();
for (auto& tile : *renderTiles) {
if (tile.getNeedsRendering()) {
const auto tileID = tile.getOverscaledTileID();
const auto& debugBucket = tile.debugBucket;
if (!debugBucket) continue;
const DebugUBO debugUBO{/*matrix = */ util::cast<float>(tile.matrix),
/*color = */ Color::red(),
/*overlay_scale = */ 1.0f,
0,
0,
0};
if (0 == updateDrawables(tileLayerGroup, tileID, debugUBO)) {
addDrawable(tileLayerGroup,
tileID,
debugUBO,
gfx::LineStrip(4.0f * parameters.pixelRatio),
vertices,
indexes,
segments);
}
}
}
} else {
// if tile borders are not required, erase layer group
debugLayerGroups.erase(DebugType::Border);
}
}
#endif
RenderTileSource::RenderTileSource(Immutable<style::Source::Impl> impl_)
: RenderSource(std::move(impl_)),
renderTiles(makeMutable<std::vector<RenderTile>>()) {