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

[core] introduce gfx::RenderPass

Browse Source
This commit is contained in:
Konstantin Käfer
2019-04-02 22:35:46 +02:00
parent b1a2513b61
commit d7aaf83421
26 changed files with 189 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/core-files.json
View File

@@ -26,6 +26,7 @@
"src/mbgl/gl/enum.cpp",
"src/mbgl/gl/object.cpp",
"src/mbgl/gl/offscreen_texture.cpp",
"src/mbgl/gl/render_pass.cpp",
"src/mbgl/gl/renderer_backend.cpp",
"src/mbgl/gl/texture.cpp",
"src/mbgl/gl/uniform.cpp",
@@ -525,6 +526,7 @@
"mbgl/gfx/index_vector.hpp": "src/mbgl/gfx/index_vector.hpp",
"mbgl/gfx/offscreen_texture.hpp": "src/mbgl/gfx/offscreen_texture.hpp",
"mbgl/gfx/program.hpp": "src/mbgl/gfx/program.hpp",
"mbgl/gfx/render_pass.hpp": "src/mbgl/gfx/render_pass.hpp",
"mbgl/gfx/renderbuffer.hpp": "src/mbgl/gfx/renderbuffer.hpp",
"mbgl/gfx/stencil_mode.hpp": "src/mbgl/gfx/stencil_mode.hpp",
"mbgl/gfx/texture.hpp": "src/mbgl/gfx/texture.hpp",
@@ -548,6 +550,7 @@
"mbgl/gl/offscreen_texture.hpp": "src/mbgl/gl/offscreen_texture.hpp",
"mbgl/gl/program.hpp": "src/mbgl/gl/program.hpp",
"mbgl/gl/program_binary_extension.hpp": "src/mbgl/gl/program_binary_extension.hpp",
"mbgl/gl/render_pass.hpp": "src/mbgl/gl/render_pass.hpp",
"mbgl/gl/renderbuffer_resource.hpp": "src/mbgl/gl/renderbuffer_resource.hpp",
"mbgl/gl/state.hpp": "src/mbgl/gl/state.hpp",
"mbgl/gl/texture.hpp": "src/mbgl/gl/texture.hpp",

7
src/mbgl/gfx/command_encoder.hpp
View File

@@ -2,9 +2,14 @@
#include <mbgl/gfx/debug_group.hpp>
#include <memory>
namespace mbgl {
namespace gfx {
class RenderPassDescriptor;
class RenderPass;
class CommandEncoder {
protected:
explicit CommandEncoder() = default;
@@ -21,6 +26,8 @@ public:
DebugGroup<CommandEncoder> createDebugGroup(const char* name) {
return { *this, name };
}
virtual std::unique_ptr<RenderPass> createRenderPass(const char* name, const RenderPassDescriptor&) = 0;
};
} // namespace gfx

2
src/mbgl/gfx/program.hpp
View File

@@ -13,6 +13,7 @@ class ColorMode;
class CullFaceMode;
class DrawScope;
class IndexBuffer;
class RenderPass;
template <class> class UniformValues;
template <class> class AttributeBindings;
template <class> class TextureBindings;
@@ -35,6 +36,7 @@ public:
using TextureList = typename Name::TextureList;
virtual void draw(Context&,
RenderPass&,
const DrawMode&,
const DepthMode&,
const StencilMode&,

41
src/mbgl/gfx/render_pass.hpp Normal file
View File

@@ -0,0 +1,41 @@
#pragma once
#include <mbgl/gfx/debug_group.hpp>
#include <mbgl/util/color.hpp>
#include <mbgl/util/optional.hpp>
#include <cstdint>
namespace mbgl {
namespace gfx {
class Renderable;
class RenderPassDescriptor {
public:
Renderable& renderable;
optional<Color> clearColor;
optional<float> clearDepth;
optional<int32_t> clearStencil;
};
class RenderPass {
protected:
RenderPass() = default;
friend class DebugGroup<RenderPass>;
virtual void pushDebugGroup(const char* name) = 0;
virtual void popDebugGroup() = 0;
public:
virtual ~RenderPass() = default;
RenderPass(const RenderPass&) = delete;
RenderPass& operator=(const RenderPass&) = delete;
DebugGroup<RenderPass> createDebugGroup(const char* name) {
return { *this, name };
}
};
} // namespace gfx
} // namespace mbgl

6
src/mbgl/gl/command_encoder.cpp
View File

@@ -1,4 +1,5 @@
#include <mbgl/gl/command_encoder.hpp>
#include <mbgl/gl/render_pass.hpp>
#include <mbgl/gl/context.hpp>
#include <mbgl/gl/debugging_extension.hpp>
#include <mbgl/platform/gl_functions.hpp>
@@ -13,6 +14,11 @@ CommandEncoder::~CommandEncoder() {
context.performCleanup();
}
std::unique_ptr<gfx::RenderPass>
CommandEncoder::createRenderPass(const char* name, const gfx::RenderPassDescriptor& descriptor) {
return std::make_unique<gl::RenderPass>(*this, name, descriptor);
}
void CommandEncoder::pushDebugGroup(const char* name) {
(void)name;
#ifndef NDEBUG

5
src/mbgl/gl/command_encoder.hpp
View File

@@ -6,6 +6,7 @@ namespace mbgl {
namespace gl {
class Context;
class RenderPass;
class CommandEncoder final : public gfx::CommandEncoder {
public:
@@ -14,6 +15,10 @@ public:
~CommandEncoder() override;
friend class RenderPass;
std::unique_ptr<gfx::RenderPass> createRenderPass(const char* name, const gfx::RenderPassDescriptor&) override;
private:
void pushDebugGroup(const char* name) override;
void popDebugGroup() override;

1
src/mbgl/gl/program.hpp
View File

@@ -156,6 +156,7 @@ public:
};
void draw(gfx::Context& genericContext,
gfx::RenderPass&,
const gfx::DrawMode& drawMode,
const gfx::DepthMode& depthMode,
const gfx::StencilMode& stencilMode,

28
src/mbgl/gl/render_pass.cpp Normal file
View File

@@ -0,0 +1,28 @@
#include <mbgl/gl/render_pass.hpp>
#include <mbgl/gl/command_encoder.hpp>
#include <mbgl/gl/renderable_resource.hpp>
#include <mbgl/gl/context.hpp>
namespace mbgl {
namespace gl {
RenderPass::RenderPass(gl::CommandEncoder& commandEncoder_,
const char* name,
const gfx::RenderPassDescriptor& descriptor)
: commandEncoder(commandEncoder_), debugGroup(commandEncoder.createDebugGroup(name)) {
descriptor.renderable.getResource<gl::RenderableResource>().bind();
const auto clearDebugGroup(commandEncoder.createDebugGroup("clear"));
commandEncoder.context.clear(descriptor.clearColor, descriptor.clearDepth,
descriptor.clearStencil);
}
void RenderPass::pushDebugGroup(const char* name) {
commandEncoder.pushDebugGroup(name);
}
void RenderPass::popDebugGroup() {
commandEncoder.popDebugGroup();
}
} // namespace gl
} // namespace mbgl

31
src/mbgl/gl/render_pass.hpp Normal file
View File

@@ -0,0 +1,31 @@
#pragma once
#include <mbgl/gfx/render_pass.hpp>
namespace mbgl {
namespace gfx {
class CommandEncoder;
} // namespace gfx
namespace gl {
class CommandEncoder;
class Context;
class RenderPass final : public gfx::RenderPass {
public:
RenderPass(gl::CommandEncoder&, const char* name, const gfx::RenderPassDescriptor&);
private:
void pushDebugGroup(const char* name) override;
void popDebugGroup() override;
private:
gl::CommandEncoder& commandEncoder;
const gfx::DebugGroup<gfx::CommandEncoder> debugGroup;
};
} // namespace gl
} // namespace mbgl

4
src/mbgl/programs/collision_box_program.hpp
View File

@@ -57,6 +57,7 @@ public:
template <class DrawMode>
void draw(gfx::Context& context,
gfx::RenderPass& renderPass,
const DrawMode& drawMode,
const gfx::DepthMode& depthMode,
const gfx::StencilMode& stencilMode,
@@ -90,6 +91,7 @@ public:
program->draw(
context,
renderPass,
std::move(drawMode),
std::move(depthMode),
std::move(stencilMode),
@@ -141,6 +143,7 @@ public:
template <class DrawMode>
void draw(gfx::Context& context,
gfx::RenderPass& renderPass,
const DrawMode& drawMode,
const gfx::DepthMode& depthMode,
const gfx::StencilMode& stencilMode,
@@ -172,6 +175,7 @@ public:
program->draw(
context,
renderPass,
std::move(drawMode),
std::move(depthMode),
std::move(stencilMode),

6
src/mbgl/programs/program.hpp
View File

@@ -13,6 +13,10 @@
namespace mbgl {
namespace gfx {
class RenderPass;
} // namespace gfx
template <class Name,
gfx::PrimitiveType Primitive,
class LayoutAttributeList,
@@ -67,6 +71,7 @@ public:
template <class DrawMode>
void draw(gfx::Context& context,
gfx::RenderPass& renderPass,
const DrawMode& drawMode,
const gfx::DepthMode& depthMode,
const gfx::StencilMode& stencilMode,
@@ -93,6 +98,7 @@ public:
program->draw(
context,
renderPass,
drawMode,
depthMode,
stencilMode,

2
src/mbgl/programs/symbol_program.hpp
View File

@@ -300,6 +300,7 @@ public:
template <class DrawMode>
void draw(gfx::Context& context,
gfx::RenderPass& renderPass,
const DrawMode& drawMode,
const gfx::DepthMode& depthMode,
const gfx::StencilMode& stencilMode,
@@ -326,6 +327,7 @@ public:
program->draw(
context,
renderPass,
drawMode,
depthMode,
stencilMode,

1
src/mbgl/renderer/layers/render_background_layer.cpp
View File

@@ -67,6 +67,7 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
program.draw(
parameters.context,
*parameters.renderPass,
gfx::Triangles(),
parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
gfx::StencilMode::disabled(),

1
src/mbgl/renderer/layers/render_circle_layer.cpp
View File

@@ -97,6 +97,7 @@ void RenderCircleLayer::render(PaintParameters& parameters, RenderSource*) {
programInstance.draw(
parameters.context,
*parameters.renderPass,
gfx::Triangles(),
parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
parameters.mapMode != MapMode::Continuous

14
src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
View File

@@ -13,9 +13,8 @@
#include <mbgl/util/intersection_tests.hpp>
#include <mbgl/tile/geometry_tile.hpp>
#include <mbgl/gfx/renderer_backend.hpp>
#include <mbgl/gfx/render_pass.hpp>
#include <mbgl/gfx/cull_face_mode.hpp>
#include <mbgl/gl/context.hpp>
#include <mbgl/gl/renderable_resource.hpp>
namespace mbgl {
@@ -52,9 +51,6 @@ bool RenderFillExtrusionLayer::hasCrossfade() const {
}
void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*) {
// TODO: remove cast
gl::Context& glContext = static_cast<gl::Context&>(parameters.context);
if (parameters.pass == RenderPass::Opaque) {
return;
}
@@ -67,14 +63,14 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
renderTexture = parameters.context.createOffscreenTexture(size, *parameters.staticData.depthRenderbuffer);
}
renderTexture->getResource<gl::RenderableResource>().bind();
optional<float> depthClearValue = {};
if (parameters.staticData.depthRenderbuffer->needsClearing()) depthClearValue = 1.0;
// Flag the depth buffer as no longer needing to be cleared for the remainder of this pass.
parameters.staticData.depthRenderbuffer->setShouldClear(false);
glContext.clear(Color{ 0.0f, 0.0f, 0.0f, 0.0f }, depthClearValue, {});
auto renderPass = parameters.encoder->createRenderPass(
"fill extrusion",
{ *renderTexture, Color{ 0.0f, 0.0f, 0.0f, 0.0f }, depthClearValue, {} });
auto draw = [&](auto& programInstance, const auto& tileBucket, auto&& uniformValues,
const optional<ImagePosition>& patternPositionA,
@@ -98,6 +94,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
programInstance.draw(
parameters.context,
*renderPass,
gfx::Triangles(),
parameters.depthModeFor3D(gfx::DepthMaskType::ReadWrite),
gfx::StencilMode::disabled(),
@@ -201,6 +198,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
programInstance.draw(
parameters.context,
*parameters.renderPass,
gfx::Triangles(),
gfx::DepthMode::disabled(),
gfx::StencilMode::disabled(),

2
src/mbgl/renderer/layers/render_fill_layer.cpp
View File

@@ -104,6 +104,7 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
programInstance.draw(
parameters.context,
*parameters.renderPass,
drawMode,
depthMode,
parameters.stencilModeForClipping(tile.clip),
@@ -194,6 +195,7 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
programInstance.draw(
parameters.context,
*parameters.renderPass,
drawMode,
depthMode,
parameters.stencilModeForClipping(tile.clip),

20
src/mbgl/renderer/layers/render_heatmap_layer.cpp
View File

@@ -10,8 +10,8 @@
#include <mbgl/style/layers/heatmap_layer_impl.hpp>
#include <mbgl/geometry/feature_index.hpp>
#include <mbgl/gfx/cull_face_mode.hpp>
#include <mbgl/gl/context.hpp>
#include <mbgl/gl/renderable_resource.hpp>
#include <mbgl/gfx/render_pass.hpp>
#include <mbgl/gfx/context.hpp>
#include <mbgl/util/math.hpp>
#include <mbgl/util/intersection_tests.hpp>
@@ -57,6 +57,10 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
const auto& viewportSize = parameters.staticData.backendSize;
const auto size = Size{viewportSize.width / 4, viewportSize.height / 4};
if (!colorRampTexture) {
colorRampTexture = parameters.context.createTexture(colorRamp, gfx::TextureChannelDataType::UnsignedByte);
}
if (!renderTexture || renderTexture->getSize() != size) {
renderTexture.reset();
if (parameters.context.supportsHalfFloatTextures) {
@@ -74,14 +78,8 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
}
}
renderTexture->getResource<gl::RenderableResource>().bind();
if (!colorRampTexture) {
colorRampTexture = parameters.context.createTexture(colorRamp, gfx::TextureChannelDataType::UnsignedByte);
}
// TODO: remove cast
static_cast<gl::Context&>(parameters.context).clear(Color{ 0.0f, 0.0f, 0.0f, 1.0f }, {}, {});
auto renderPass = parameters.encoder->createRenderPass(
"heatmap texture", { *renderTexture, Color{ 0.0f, 0.0f, 0.0f, 1.0f }, {}, {} });
for (const RenderTile& tile : renderTiles) {
auto bucket_ = tile.tile.getBucket<HeatmapBucket>(*baseImpl);
@@ -120,6 +118,7 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
programInstance.draw(
parameters.context,
*renderPass,
gfx::Triangles(),
parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
stencilMode,
@@ -165,6 +164,7 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
programInstance.draw(
parameters.context,
*parameters.renderPass,
gfx::Triangles(),
gfx::DepthMode::disabled(),
gfx::StencilMode::disabled(),

8
src/mbgl/renderer/layers/render_hillshade_layer.cpp
View File

@@ -11,7 +11,7 @@
#include <mbgl/style/layers/hillshade_layer_impl.hpp>
#include <mbgl/gfx/cull_face_mode.hpp>
#include <mbgl/gfx/offscreen_texture.hpp>
#include <mbgl/gl/renderable_resource.hpp>
#include <mbgl/gfx/render_pass.hpp>
#include <mbgl/util/geo.hpp>
namespace mbgl {
@@ -98,6 +98,7 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src
programInstance.draw(
parameters.context,
*parameters.renderPass,
gfx::Triangles(),
parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
gfx::StencilMode::disabled(),
@@ -132,7 +133,9 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src
const uint16_t stride = bucket.getDEMData().stride;
const uint16_t tilesize = bucket.getDEMData().dim;
auto view = parameters.context.createOffscreenTexture({ tilesize, tilesize });
view->getResource<gl::RenderableResource>().bind();
auto renderPass = parameters.encoder->createRenderPass(
"hillshade prepare", { *view, Color{ 0.0f, 0.0f, 0.0f, 0.0f }, {}, {} });
const Properties<>::PossiblyEvaluated properties;
const HillshadePrepareProgram::Binders paintAttributeData{ properties, 0 };
@@ -160,6 +163,7 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src
programInstance.draw(
parameters.context,
*renderPass,
gfx::Triangles(),
parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
gfx::StencilMode::disabled(),

1
src/mbgl/renderer/layers/render_line_layer.cpp
View File

@@ -86,6 +86,7 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
programInstance.draw(
parameters.context,
*parameters.renderPass,
gfx::Triangles(),
parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
parameters.stencilModeForClipping(tile.clip),

1
src/mbgl/renderer/layers/render_raster_layer.cpp
View File

@@ -110,6 +110,7 @@ void RenderRasterLayer::render(PaintParameters& parameters, RenderSource* source
programInstance.draw(
parameters.context,
*parameters.renderPass,
gfx::Triangles(),
parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
gfx::StencilMode::disabled(),

3
src/mbgl/renderer/layers/render_symbol_layer.cpp
View File

@@ -130,6 +130,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
programInstance.draw(
parameters.context,
*parameters.renderPass,
gfx::Triangles(),
values_.pitchAlignment == AlignmentType::Map
? parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly)
@@ -352,6 +353,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
}};
parameters.programs.getSymbolLayerPrograms().collisionBox.draw(
parameters.context,
*parameters.renderPass,
gfx::Lines { 1.0f },
gfx::DepthMode::disabled(),
gfx::StencilMode::disabled(),
@@ -388,6 +390,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
parameters.programs.getSymbolLayerPrograms().collisionCircle.draw(
parameters.context,
*parameters.renderPass,
gfx::Triangles(),
gfx::DepthMode::disabled(),
gfx::StencilMode::disabled(),

1
src/mbgl/renderer/paint_parameters.cpp
View File

@@ -2,6 +2,7 @@
#include <mbgl/renderer/update_parameters.hpp>
#include <mbgl/renderer/render_static_data.hpp>
#include <mbgl/gfx/command_encoder.hpp>
#include <mbgl/gfx/render_pass.hpp>
#include <mbgl/map/transform_state.hpp>
namespace mbgl {

2
src/mbgl/renderer/paint_parameters.hpp
View File

@@ -26,6 +26,7 @@ namespace gfx {
class Context;
class RendererBackend;
class CommandEncoder;
class RenderPass;
} // namespace gfx
class PaintParameters {
@@ -44,6 +45,7 @@ public:
gfx::Context& context;
gfx::RendererBackend& backend;
const std::unique_ptr<gfx::CommandEncoder> encoder;
std::unique_ptr<gfx::RenderPass> renderPass;
const TransformState& state;
const EvaluatedLight& evaluatedLight;

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

@@ -98,6 +98,7 @@ void RenderTile::finishRender(PaintParameters& parameters) {
program.draw(
parameters.context,
*parameters.renderPass,
gfx::Lines { 4.0f * parameters.pixelRatio },
gfx::DepthMode::disabled(),
parameters.stencilModeForClipping(clip),
@@ -121,6 +122,7 @@ void RenderTile::finishRender(PaintParameters& parameters) {
program.draw(
parameters.context,
*parameters.renderPass,
gfx::Lines { 2.0f * parameters.pixelRatio },
gfx::DepthMode::disabled(),
parameters.stencilModeForClipping(clip),
@@ -147,6 +149,7 @@ void RenderTile::finishRender(PaintParameters& parameters) {
assert(tile.debugBucket);
parameters.programs.debug.draw(
parameters.context,
*parameters.renderPass,
gfx::LineStrip { 4.0f * parameters.pixelRatio },
gfx::DepthMode::disabled(),
parameters.stencilModeForClipping(clip),

34
src/mbgl/renderer/renderer_impl.cpp
View File

@@ -16,9 +16,10 @@
#include <mbgl/gfx/backend_scope.hpp>
#include <mbgl/renderer/image_manager.hpp>
#include <mbgl/gfx/renderer_backend.hpp>
#include <mbgl/gfx/render_pass.hpp>
#include <mbgl/gfx/cull_face_mode.hpp>
#include <mbgl/gl/context.hpp>
#include <mbgl/gl/renderable_resource.hpp>
#include <mbgl/gfx/context.hpp>
#include <mbgl/gfx/renderable.hpp>
#include <mbgl/geometry/line_atlas.hpp>
#include <mbgl/style/source_impl.hpp>
#include <mbgl/style/transition_options.hpp>
@@ -366,9 +367,6 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
parameters.symbolFadeChange = placement->symbolFadeChange(updateParameters.timePoint);
// TODO: remove cast
gl::Context& glContext = static_cast<gl::Context&>(parameters.context);
// - UPLOAD PASS -------------------------------------------------------------------------------
// Uploads all required buffers and images before we do any actual rendering.
{
@@ -415,22 +413,19 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
// Renders the backdrop of the OpenGL view. This also paints in areas where we don't have any
// tiles whatsoever.
{
using namespace gl::value;
parameters.backend.getDefaultRenderable().getResource<gl::RenderableResource>().bind();
optional<Color> color;
if (parameters.debugOptions & MapDebugOptions::Overdraw) {
glContext.clear(Color::black(), ClearDepth::Default, ClearStencil::Default);
} else if (backend.contextIsShared()) {
glContext.clear({}, ClearDepth::Default, ClearStencil::Default);
} else {
glContext.clear(backgroundColor, ClearDepth::Default, ClearStencil::Default);
color = Color::black();
} else if (!backend.contextIsShared()) {
color = backgroundColor;
}
parameters.renderPass = parameters.encoder->createRenderPass("main buffer", { parameters.backend.getDefaultRenderable(), color, 1, 0 });
}
// - CLIPPING MASKS ----------------------------------------------------------------------------
// Draws the clipping masks to the stencil buffer.
{
const auto debugGroup(parameters.encoder->createDebugGroup("clipping masks"));
const auto debugGroup(parameters.renderPass->createDebugGroup("clipping masks"));
static const Properties<>::PossiblyEvaluated properties {};
static const ClippingMaskProgram::Binders paintAttributeData(properties, 0);
@@ -440,6 +435,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
program.draw(
parameters.context,
*parameters.renderPass,
gfx::Triangles(),
gfx::DepthMode::disabled(),
gfx::StencilMode {
@@ -489,13 +485,13 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
// Render everything top-to-bottom by using reverse iterators. Render opaque objects first.
{
parameters.pass = RenderPass::Opaque;
const auto debugGroup(parameters.encoder->createDebugGroup("opaque"));
const auto debugGroup(parameters.renderPass->createDebugGroup("opaque"));
uint32_t i = 0;
for (auto it = renderItems.rbegin(); it != renderItems.rend(); ++it, ++i) {
parameters.currentLayer = i;
if (it->layer.hasRenderPass(parameters.pass)) {
const auto layerDebugGroup(parameters.encoder->createDebugGroup(it->layer.getID().c_str()));
const auto layerDebugGroup(parameters.renderPass->createDebugGroup(it->layer.getID().c_str()));
it->layer.render(parameters, it->source);
}
}
@@ -505,13 +501,13 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
// Make a second pass, rendering translucent objects. This time, we render bottom-to-top.
{
parameters.pass = RenderPass::Translucent;
const auto debugGroup(parameters.encoder->createDebugGroup("translucent"));
const auto debugGroup(parameters.renderPass->createDebugGroup("translucent"));
uint32_t i = static_cast<uint32_t>(renderItems.size()) - 1;
for (auto it = renderItems.begin(); it != renderItems.end(); ++it, --i) {
parameters.currentLayer = i;
if (it->layer.hasRenderPass(parameters.pass)) {
const auto layerDebugGroup(parameters.encoder->createDebugGroup(it->layer.getID().c_str()));
const auto layerDebugGroup(parameters.renderPass->createDebugGroup(it->layer.getID().c_str()));
it->layer.render(parameters, it->source);
}
}
@@ -520,7 +516,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
// - DEBUG PASS --------------------------------------------------------------------------------
// Renders debug overlays.
{
const auto debugGroup(parameters.encoder->createDebugGroup("debug"));
const auto debugGroup(parameters.renderPass->createDebugGroup("debug"));
// Finalize the rendering, e.g. by calling debug render calls per tile.
// This guarantees that we have at least one function per tile called.

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

@@ -64,6 +64,7 @@ void RenderImageSource::finishRender(PaintParameters& parameters) {
for (auto matrix : matrices) {
programInstance.draw(
parameters.context,
*parameters.renderPass,
gfx::LineStrip { 4.0f * parameters.pixelRatio },
gfx::DepthMode::disabled(),
gfx::StencilMode::disabled(),