tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[core] Extract renderTileDebug; inline renderClippingMask

Browse Source
This commit is contained in:
John Firebaugh
2017-07-18 11:19:35 -07:00
parent 2c0fe49650
commit ac58130d36
10 changed files with 175 additions and 270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
cmake/core-files.cmake
View File

@@ -244,10 +244,6 @@ set(MBGL_CORE_FILES
src/mbgl/renderer/layers/render_symbol_layer.cpp
src/mbgl/renderer/layers/render_symbol_layer.hpp
# renderer/painters
src/mbgl/renderer/painters/painter_clipping.cpp
src/mbgl/renderer/painters/painter_debug.cpp
# renderer/sources
src/mbgl/renderer/sources/render_geojson_source.cpp
src/mbgl/renderer/sources/render_geojson_source.hpp

12
src/mbgl/renderer/bucket.hpp
View File

@@ -1,27 +1,17 @@
#pragma once
#include <mbgl/renderer/render_pass.hpp>
#include <mbgl/util/noncopyable.hpp>
#include <mbgl/tile/geometry_tile_data.hpp>
#include <mbgl/renderer/render_layer.hpp>
#include <atomic>
#include <string>
#include <unordered_map>
namespace mbgl {
class Painter;
class PaintParameters;
class RenderTile;
namespace gl {
class Context;
} // namespace gl
namespace style {
class Layer;
} // namespace style
class RenderLayer;
class Bucket : private util::noncopyable {
public:

110
src/mbgl/renderer/painter.cpp
View File

@@ -3,35 +3,27 @@
#include <mbgl/renderer/render_tile.hpp>
#include <mbgl/renderer/render_source.hpp>
#include <mbgl/renderer/render_style.hpp>
#include <mbgl/renderer/image_manager.hpp>
#include <mbgl/renderer/layers/render_fill_extrusion_layer.hpp>
#include <mbgl/style/source.hpp>
#include <mbgl/style/source_impl.hpp>
#include <mbgl/style/layer_impl.hpp>
#include <mbgl/map/view.hpp>
#include <mbgl/util/logging.hpp>
#include <mbgl/gl/debugging.hpp>
#include <mbgl/style/layer_impl.hpp>
#include <mbgl/style/layers/custom_layer_impl.hpp>
#include <mbgl/tile/tile.hpp>
#include <mbgl/renderer/layers/render_background_layer.hpp>
#include <mbgl/renderer/layers/render_custom_layer.hpp>
#include <mbgl/style/layers/custom_layer_impl.hpp>
#include <mbgl/renderer/layers/render_fill_extrusion_layer.hpp>
#include <mbgl/renderer/image_manager.hpp>
#include <mbgl/geometry/line_atlas.hpp>
#include <mbgl/programs/program_parameters.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/util/constants.hpp>
#include <mbgl/util/mat3.hpp>
#include <mbgl/util/string.hpp>
#include <mbgl/util/stopwatch.hpp>
#include <mbgl/util/clip_id.hpp>
#include <mbgl/util/logging.hpp>
#include <mbgl/util/color.hpp>
#include <cassert>
#include <algorithm>
@@ -196,15 +188,66 @@ void Painter::render(RenderStyle& style, const FrameData& frame_, View& view) {
MBGL_DEBUG_GROUP(context, "clipping masks");
static const style::FillPaintProperties::PossiblyEvaluated properties {};
static const FillProgram::PaintPropertyBinders paintAttibuteData(properties, 0);
for (const auto& clipID : clipIDGenerator.getClipIDs()) {
MBGL_DEBUG_GROUP(context, std::string{ "mask: " } + util::toString(clipID.first));
renderClippingMask(clipID.first, clipID.second);
programs->fill.get(properties).draw(
context,
gl::Triangles(),
gl::DepthMode::disabled(),
gl::StencilMode {
gl::StencilMode::Always(),
static_cast<int32_t>(clipID.second.reference.to_ulong()),
0b11111111,
gl::StencilMode::Keep,
gl::StencilMode::Keep,
gl::StencilMode::Replace
},
gl::ColorMode::disabled(),
FillProgram::UniformValues {
uniforms::u_matrix::Value{ matrixForTile(clipID.first) },
uniforms::u_world::Value{ context.viewport.getCurrentValue().size },
},
tileVertexBuffer,
quadTriangleIndexBuffer,
tileTriangleSegments,
paintAttibuteData,
properties,
state.getZoom(),
"clipping"
);
}
}
#if not MBGL_USE_GLES2 and not defined(NDEBUG)
// Render tile clip boundaries, using stencil buffer to calculate fill color.
if (frame.debugOptions & MapDebugOptions::StencilClip) {
renderClipMasks(parameters);
context.setStencilMode(gl::StencilMode::disabled());
context.setDepthMode(gl::DepthMode::disabled());
context.setColorMode(gl::ColorMode::unblended());
context.program = 0;
// Reset the value in case someone else changed it, or it's dirty.
context.pixelTransferStencil = gl::value::PixelTransferStencil::Default;
// Read the stencil buffer
const auto viewport = context.viewport.getCurrentValue();
auto image =
context.readFramebuffer<AlphaImage, gl::TextureFormat::Stencil>(viewport.size, false);
// Scale the Stencil buffer to cover the entire color space.
auto it = image.data.get();
auto end = it + viewport.size.width * viewport.size.height;
const auto factor = 255.0f / *std::max_element(it, end);
for (; it != end; ++it) {
*it *= factor;
}
context.pixelZoom = { 1, 1 };
context.rasterPos = { -1, -1, 0, 1 };
context.drawPixels(image);
return;
}
#endif
@@ -245,8 +288,26 @@ void Painter::render(RenderStyle& style, const FrameData& frame_, View& view) {
}
#if not MBGL_USE_GLES2 and not defined(NDEBUG)
// Render the depth buffer.
if (frame.debugOptions & MapDebugOptions::DepthBuffer) {
renderDepthBuffer(parameters);
context.setStencilMode(gl::StencilMode::disabled());
context.setDepthMode(gl::DepthMode::disabled());
context.setColorMode(gl::ColorMode::unblended());
context.program = 0;
// Scales the values in the depth buffer so that they cover the entire grayscale range. This
// makes it easier to spot tiny differences.
const float base = 1.0f / (1.0f - depthRangeSize);
context.pixelTransferDepth = { base, 1.0f - base };
// Read the stencil buffer
auto viewport = context.viewport.getCurrentValue();
auto image =
context.readFramebuffer<AlphaImage, gl::TextureFormat::Depth>(viewport.size, false);
context.pixelZoom = { 1, 1 };
context.rasterPos = { -1, -1, 0, 1 };
context.drawPixels(image);
}
#endif
@@ -288,6 +349,8 @@ void Painter::renderPass(PaintParameters& parameters,
continue;
if (layer.is<RenderFillExtrusionLayer>()) {
MBGL_DEBUG_GROUP(context, item.layer.getID());
const auto size = context.viewport.getCurrentValue().size;
if (!extrusionTexture || extrusionTexture->getSize() != size) {
@@ -300,7 +363,7 @@ void Painter::renderPass(PaintParameters& parameters,
context.setDepthMode(depthModeForSublayer(0, gl::DepthMode::ReadWrite));
context.clear(Color{ 0.0f, 0.0f, 0.0f, 0.0f }, 1.0f, {});
renderItem(parameters, item);
item.layer.render(*this, parameters, item.source);
parameters.view.bind();
context.bindTexture(extrusionTexture->getTexture());
@@ -329,7 +392,8 @@ void Painter::renderPass(PaintParameters& parameters,
state.getZoom(),
layer.getID());
} else {
renderItem(parameters, item);
MBGL_DEBUG_GROUP(context, item.layer.getID());
item.layer.render(*this, parameters, item.source);
}
}
@@ -338,12 +402,6 @@ void Painter::renderPass(PaintParameters& parameters,
}
}
void Painter::renderItem(PaintParameters& parameters, const RenderItem& item) {
RenderLayer& layer = item.layer;
MBGL_DEBUG_GROUP(context, layer.getID());
layer.render(*this, parameters, item.source);
}
mat4 Painter::matrixForTile(const UnwrappedTileID& tileID) {
mat4 matrix;
state.matrixFor(matrix, tileID);

23
src/mbgl/renderer/painter.hpp
View File

@@ -8,39 +8,31 @@
#include <mbgl/renderer/render_item.hpp>
#include <mbgl/renderer/bucket.hpp>
#include <mbgl/renderer/render_light.hpp>
#include <mbgl/renderer/render_pass.hpp>
#include <mbgl/gl/context.hpp>
#include <mbgl/programs/debug_program.hpp>
#include <mbgl/programs/program_parameters.hpp>
#include <mbgl/programs/fill_program.hpp>
#include <mbgl/programs/extrusion_texture_program.hpp>
#include <mbgl/programs/raster_program.hpp>
#include <mbgl/util/noncopyable.hpp>
#include <mbgl/util/chrono.hpp>
#include <mbgl/util/constants.hpp>
#include <mbgl/util/offscreen_texture.hpp>
#include <mbgl/algorithm/generate_clip_ids.hpp>
#include <array>
#include <vector>
#include <set>
#include <map>
namespace mbgl {
class RenderStyle;
class RenderTile;
class ImageManager;
class View;
class LineAtlas;
struct FrameData;
class Tile;
class DebugBucket;
class Programs;
class PaintParameters;
class TilePyramid;
struct ClipID;
struct FrameData {
@@ -61,19 +53,6 @@ public:
View&);
void cleanup();
void renderClippingMask(const UnwrappedTileID&, const ClipID&);
void renderTileDebug(const RenderTile&);
void renderTileDebug(const mat4& matrix);
void renderItem(PaintParameters&, const RenderItem&);
#ifndef NDEBUG
// Renders tile clip boundaries, using stencil buffer to calculate fill color.
void renderClipMasks(PaintParameters&);
// Renders the depth buffer.
void renderDepthBuffer(PaintParameters&);
#endif
bool needsAnimation() const;
template <class Iterator>

38
src/mbgl/renderer/painters/painter_clipping.cpp
View File

@@ -1,38 +0,0 @@
#include <mbgl/renderer/painter.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/programs/fill_program.hpp>
#include <mbgl/util/clip_id.hpp>
namespace mbgl {
void Painter::renderClippingMask(const UnwrappedTileID& tileID, const ClipID& clip) {
static const style::FillPaintProperties::PossiblyEvaluated properties {};
static const FillProgram::PaintPropertyBinders paintAttibuteData(properties, 0);
programs->fill.get(properties).draw(
context,
gl::Triangles(),
gl::DepthMode::disabled(),
gl::StencilMode {
gl::StencilMode::Always(),
static_cast<int32_t>(clip.reference.to_ulong()),
0b11111111,
gl::StencilMode::Keep,
gl::StencilMode::Keep,
gl::StencilMode::Replace
},
gl::ColorMode::disabled(),
FillProgram::UniformValues {
uniforms::u_matrix::Value{ matrixForTile(tileID) },
uniforms::u_world::Value{ context.viewport.getCurrentValue().size },
},
tileVertexBuffer,
quadTriangleIndexBuffer,
tileTriangleSegments,
paintAttibuteData,
properties,
state.getZoom(),
"clipping"
);
}
} // namespace mbgl

164
src/mbgl/renderer/painters/painter_debug.cpp
View File

@@ -1,164 +0,0 @@
#include <mbgl/renderer/painter.hpp>
#include <mbgl/renderer/buckets/debug_bucket.hpp>
#include <mbgl/renderer/render_tile.hpp>
#include <mbgl/renderer/paint_parameters.hpp>
#include <mbgl/map/view.hpp>
#include <mbgl/tile/tile.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/programs/fill_program.hpp>
#include <mbgl/util/string.hpp>
#include <mbgl/gl/debugging.hpp>
#include <mbgl/util/color.hpp>
namespace mbgl {
using namespace style;
void Painter::renderTileDebug(const RenderTile& renderTile) {
if (frame.debugOptions == MapDebugOptions::NoDebug)
return;
MBGL_DEBUG_GROUP(context, std::string { "debug " } + util::toString(renderTile.id));
static const style::Properties<>::PossiblyEvaluated properties {};
static const DebugProgram::PaintPropertyBinders paintAttibuteData(properties, 0);
auto draw = [&] (Color color, const auto& vertexBuffer, const auto& indexBuffer, const auto& segments, auto drawMode) {
programs->debug.draw(
context,
drawMode,
gl::DepthMode::disabled(),
stencilModeForClipping(renderTile.clip),
gl::ColorMode::unblended(),
DebugProgram::UniformValues {
uniforms::u_matrix::Value{ renderTile.matrix },
uniforms::u_color::Value{ color }
},
vertexBuffer,
indexBuffer,
segments,
paintAttibuteData,
properties,
state.getZoom(),
"debug"
);
};
if (frame.debugOptions & (MapDebugOptions::Timestamps | MapDebugOptions::ParseStatus)) {
Tile& tile = renderTile.tile;
if (!tile.debugBucket || tile.debugBucket->renderable != tile.isRenderable() ||
tile.debugBucket->complete != tile.isComplete() ||
!(tile.debugBucket->modified == tile.modified) ||
!(tile.debugBucket->expires == tile.expires) ||
tile.debugBucket->debugMode != frame.debugOptions) {
tile.debugBucket = std::make_unique<DebugBucket>(
tile.id, tile.isRenderable(), tile.isComplete(), tile.modified,
tile.expires, frame.debugOptions, context);
}
draw(Color::white(),
*tile.debugBucket->vertexBuffer,
*tile.debugBucket->indexBuffer,
tile.debugBucket->segments,
gl::Lines { 4.0f * frame.pixelRatio });
draw(Color::black(),
*tile.debugBucket->vertexBuffer,
*tile.debugBucket->indexBuffer,
tile.debugBucket->segments,
gl::Lines { 2.0f * frame.pixelRatio });
}
if (frame.debugOptions & MapDebugOptions::TileBorders) {
draw(Color::red(),
tileVertexBuffer,
tileBorderIndexBuffer,
tileBorderSegments,
gl::LineStrip { 4.0f * frame.pixelRatio });
}
}
void Painter::renderTileDebug(const mat4& matrix) {
if (frame.debugOptions == MapDebugOptions::NoDebug)
return;
static const style::Properties<>::PossiblyEvaluated properties {};
static const DebugProgram::PaintPropertyBinders paintAttibuteData(properties, 0);
if (frame.debugOptions & MapDebugOptions::TileBorders) {
programs->debug.draw(
context,
gl::LineStrip { 4.0f * frame.pixelRatio },
gl::DepthMode::disabled(),
gl::StencilMode::disabled(),
gl::ColorMode::unblended(),
DebugProgram::UniformValues {
uniforms::u_matrix::Value{ matrix },
uniforms::u_color::Value{ Color::red() }
},
tileVertexBuffer,
tileBorderIndexBuffer,
tileBorderSegments,
paintAttibuteData,
properties,
state.getZoom(),
"debug"
);
}
}
#ifndef NDEBUG
void Painter::renderClipMasks(PaintParameters&) {
context.setStencilMode(gl::StencilMode::disabled());
context.setDepthMode(gl::DepthMode::disabled());
context.setColorMode(gl::ColorMode::unblended());
context.program = 0;
#if not MBGL_USE_GLES2
// Reset the value in case someone else changed it, or it's dirty.
context.pixelTransferStencil = gl::value::PixelTransferStencil::Default;
// Read the stencil buffer
const auto viewport = context.viewport.getCurrentValue();
auto image =
context.readFramebuffer<AlphaImage, gl::TextureFormat::Stencil>(viewport.size, false);
// Scale the Stencil buffer to cover the entire color space.
auto it = image.data.get();
auto end = it + viewport.size.width * viewport.size.height;
const auto factor = 255.0f / *std::max_element(it, end);
for (; it != end; ++it) {
*it *= factor;
}
context.pixelZoom = { 1, 1 };
context.rasterPos = { -1, -1, 0, 1 };
context.drawPixels(image);
#endif // MBGL_USE_GLES2
}
void Painter::renderDepthBuffer(PaintParameters&) {
context.setStencilMode(gl::StencilMode::disabled());
context.setDepthMode(gl::DepthMode::disabled());
context.setColorMode(gl::ColorMode::unblended());
context.program = 0;
#if not MBGL_USE_GLES2
// Scales the values in the depth buffer so that they cover the entire grayscale range. This
// makes it easier to spot tiny differences.
const float base = 1.0f / (1.0f - depthRangeSize);
context.pixelTransferDepth = { base, 1.0f - base };
// Read the stencil buffer
auto viewport = context.viewport.getCurrentValue();
auto image =
context.readFramebuffer<AlphaImage, gl::TextureFormat::Depth>(viewport.size, false);
context.pixelZoom = { 1, 1 };
context.rasterPos = { -1, -1, 0, 1 };
context.drawPixels(image);
#endif // MBGL_USE_GLES2
}
#endif // NDEBUG
} // namespace mbgl

63
src/mbgl/renderer/render_tile.cpp
View File

@@ -1,5 +1,7 @@
#include <mbgl/renderer/render_tile.hpp>
#include <mbgl/renderer/painter.hpp>
#include <mbgl/renderer/buckets/debug_bucket.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/map/transform_state.hpp>
#include <mbgl/tile/tile.hpp>
#include <mbgl/util/math.hpp>
@@ -60,4 +62,65 @@ void RenderTile::startRender(Painter& painter) {
matrix::multiply(nearClippedMatrix, painter.nearClippedProjMatrix, nearClippedMatrix);
}
void RenderTile::finishRender(Painter& painter) {
if (!used || painter.frame.debugOptions == MapDebugOptions::NoDebug)
return;
static const style::Properties<>::PossiblyEvaluated properties {};
static const DebugProgram::PaintPropertyBinders paintAttibuteData(properties, 0);
auto draw = [&] (Color color, const auto& vertexBuffer, const auto& indexBuffer, const auto& segments, auto drawMode) {
painter.programs->debug.draw(
painter.context,
drawMode,
gl::DepthMode::disabled(),
painter.stencilModeForClipping(clip),
gl::ColorMode::unblended(),
DebugProgram::UniformValues {
uniforms::u_matrix::Value{ matrix },
uniforms::u_color::Value{ color }
},
vertexBuffer,
indexBuffer,
segments,
paintAttibuteData,
properties,
painter.state.getZoom(),
"debug"
);
};
if (painter.frame.debugOptions & (MapDebugOptions::Timestamps | MapDebugOptions::ParseStatus)) {
if (!tile.debugBucket || tile.debugBucket->renderable != tile.isRenderable() ||
tile.debugBucket->complete != tile.isComplete() ||
!(tile.debugBucket->modified == tile.modified) ||
!(tile.debugBucket->expires == tile.expires) ||
tile.debugBucket->debugMode != painter.frame.debugOptions) {
tile.debugBucket = std::make_unique<DebugBucket>(
tile.id, tile.isRenderable(), tile.isComplete(), tile.modified,
tile.expires, painter.frame.debugOptions, painter.context);
}
draw(Color::white(),
*tile.debugBucket->vertexBuffer,
*tile.debugBucket->indexBuffer,
tile.debugBucket->segments,
gl::Lines { 4.0f * painter.frame.pixelRatio });
draw(Color::black(),
*tile.debugBucket->vertexBuffer,
*tile.debugBucket->indexBuffer,
tile.debugBucket->segments,
gl::Lines { 2.0f * painter.frame.pixelRatio });
}
if (painter.frame.debugOptions & MapDebugOptions::TileBorders) {
draw(Color::red(),
painter.tileVertexBuffer,
painter.tileBorderIndexBuffer,
painter.tileBorderSegments,
gl::LineStrip { 4.0f * painter.frame.pixelRatio });
}
}
} // namespace mbgl

1
src/mbgl/renderer/render_tile.hpp
View File

@@ -37,6 +37,7 @@ public:
const TransformState&) const;
void startRender(Painter&);
void finishRender(Painter&);
mat4 translateVtxMatrix(const mat4& tileMatrix,
const std::array<float, 2>& translation,

26
src/mbgl/renderer/sources/render_image_source.cpp
View File

@@ -5,6 +5,7 @@
#include <mbgl/renderer/render_tile.hpp>
#include <mbgl/renderer/sources/render_image_source.hpp>
#include <mbgl/renderer/tile_parameters.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/util/tile_coordinate.hpp>
#include <mbgl/util/tile_cover.hpp>
#include <mbgl/util/logging.hpp>
@@ -48,11 +49,32 @@ void RenderImageSource::startRender(Painter& painter) {
}
void RenderImageSource::finishRender(Painter& painter) {
if (!isLoaded()) {
if (!isLoaded() || !(painter.frame.debugOptions & MapDebugOptions::TileBorders)) {
return;
}
static const style::Properties<>::PossiblyEvaluated properties {};
static const DebugProgram::PaintPropertyBinders paintAttibuteData(properties, 0);
for (auto matrix : matrices) {
painter.renderTileDebug(matrix);
painter.programs->debug.draw(
painter.context,
gl::LineStrip { 4.0f * painter.frame.pixelRatio },
gl::DepthMode::disabled(),
gl::StencilMode::disabled(),
gl::ColorMode::unblended(),
DebugProgram::UniformValues {
uniforms::u_matrix::Value{ matrix },
uniforms::u_color::Value{ Color::red() }
},
painter.tileVertexBuffer,
painter.tileBorderIndexBuffer,
painter.tileBorderSegments,
paintAttibuteData,
properties,
painter.state.getZoom(),
"debug"
);
}
}

4
src/mbgl/renderer/tile_pyramid.cpp
View File

@@ -47,9 +47,7 @@ void TilePyramid::startRender(Painter& painter) {
void TilePyramid::finishRender(Painter& painter) {
for (auto& tile : renderTiles) {
if (tile.used) {
painter.renderTileDebug(tile);
}
tile.finishRender(painter);
}
}