[core] Store SegmentVectors in ephemeral render objects

We used some shared SegmentVectors, e.g. for drawing raster or background tiles.
In longer running maps, this lead to resource accumulation. By storing the SegmentVectors
and the contained gfx::DrawScope objects, we ensure that resources get released
when the associated render objects vanish.
This commit is contained in:
Konstantin Käfer
2019-08-16 12:03:53 +02:00
committed by Alexander Shalamov
parent 189ed4aac3
commit a876c965a5
23 changed files with 250 additions and 289 deletions

View File

@@ -772,8 +772,6 @@ add_library(
${PROJECT_SOURCE_DIR}/src/mbgl/util/http_timeout.hpp
${PROJECT_SOURCE_DIR}/src/mbgl/util/i18n.cpp
${PROJECT_SOURCE_DIR}/src/mbgl/util/i18n.hpp
${PROJECT_SOURCE_DIR}/src/mbgl/util/id.cpp
${PROJECT_SOURCE_DIR}/src/mbgl/util/id.hpp
${PROJECT_SOURCE_DIR}/src/mbgl/util/interpolate.cpp
${PROJECT_SOURCE_DIR}/src/mbgl/util/intersection_tests.cpp
${PROJECT_SOURCE_DIR}/src/mbgl/util/intersection_tests.hpp

View File

@@ -2,7 +2,6 @@
#include <mbgl/geometry/debug_font_data.hpp>
#include <mbgl/tile/tile_id.hpp>
#include <mbgl/util/string.hpp>
#include <mbgl/util/id.hpp>
#include <cmath>
#include <string>
@@ -20,9 +19,7 @@ DebugBucket::DebugBucket(const OverscaledTileID& id,
complete(complete_),
modified(std::move(modified_)),
expires(std::move(expires_)),
debugMode(debugMode_),
drawScopeID("__debug/" + util::toHex(util::nextID())) {
debugMode(debugMode_) {
auto addText = [&] (const std::string& text, double left, double baseline, double scale) {
for (uint8_t c : text) {
if (c < 32 || c >= 127)

View File

@@ -40,9 +40,9 @@ public:
gfx::IndexVector<gfx::Lines> indices;
SegmentVector<DebugAttributes> segments;
SegmentVector<DebugAttributes> tileBorderSegments;
optional<gfx::VertexBuffer<DebugLayoutVertex>> vertexBuffer;
optional<gfx::IndexBuffer> indexBuffer;
const std::string drawScopeID;
};
} // namespace mbgl

View File

@@ -2,21 +2,15 @@
#include <mbgl/renderer/layers/render_raster_layer.hpp>
#include <mbgl/programs/raster_program.hpp>
#include <mbgl/gfx/upload_pass.hpp>
#include <mbgl/util/id.hpp>
namespace mbgl {
using namespace style;
RasterBucket::RasterBucket(PremultipliedImage&& image_)
: image(std::make_shared<PremultipliedImage>(std::move(image_))),
drawScopeID(util::toHex(util::nextID())) {
}
: image(std::make_shared<PremultipliedImage>(std::move(image_))) {}
RasterBucket::RasterBucket(std::shared_ptr<PremultipliedImage> image_)
: image(std::move(image_)),
drawScopeID(util::toHex(util::nextID())) {
}
RasterBucket::RasterBucket(std::shared_ptr<PremultipliedImage> image_) : image(std::move(image_)) {}
RasterBucket::~RasterBucket() = default;
@@ -27,8 +21,10 @@ void RasterBucket::upload(gfx::UploadPass& uploadPass) {
if (!texture) {
texture = uploadPass.createTexture(*image);
}
if (!segments.empty()) {
if (!vertices.empty()) {
vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices));
}
if (!indices.empty()) {
indexBuffer = uploadPass.createIndexBuffer(std::move(indices));
}
uploaded = true;

View File

@@ -37,7 +37,6 @@ public:
optional<gfx::VertexBuffer<RasterLayoutVertex>> vertexBuffer;
optional<gfx::IndexBuffer> indexBuffer;
const std::string drawScopeID;
};
} // namespace mbgl

View File

@@ -7,7 +7,6 @@
#include <mbgl/renderer/image_manager.hpp>
#include <mbgl/renderer/render_static_data.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/programs/background_program.hpp>
#include <mbgl/util/tile_cover.hpp>
#include <mbgl/map/transform_state.hpp>
#include <mbgl/gfx/cull_face_mode.hpp>
@@ -18,7 +17,7 @@ using namespace style;
namespace {
inline const BackgroundLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
inline const BackgroundLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) {
assert(impl->getTypeInfo() == BackgroundLayer::Impl::staticTypeInfo());
return static_cast<const style::BackgroundLayer::Impl&>(*impl);
}
@@ -27,13 +26,12 @@ inline const BackgroundLayer::Impl& impl(const Immutable<style::Layer::Impl>& im
RenderBackgroundLayer::RenderBackgroundLayer(Immutable<style::BackgroundLayer::Impl> _impl)
: RenderLayer(makeMutable<BackgroundLayerProperties>(std::move(_impl))),
unevaluated(impl(baseImpl).paint.untransitioned()) {
}
unevaluated(impl_cast(baseImpl).paint.untransitioned()) {}
RenderBackgroundLayer::~RenderBackgroundLayer() = default;
void RenderBackgroundLayer::transition(const TransitionParameters &parameters) {
unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
}
void RenderBackgroundLayer::evaluate(const PropertyEvaluationParameters &parameters) {
@@ -69,7 +67,7 @@ void RenderBackgroundLayer::render(PaintParameters& parameters) {
const Properties<>::PossiblyEvaluated properties;
const BackgroundProgram::Binders paintAttributeData(properties, 0);
auto draw = [&](auto& program, auto&& uniformValues, const auto& textureBindings, const UnwrappedTileID& id) {
auto draw = [&](auto& program, auto&& uniformValues, const auto& textureBindings, const uint32_t id) {
const auto allUniformValues = program.computeAllUniformValues(
std::move(uniformValues),
paintAttributeData,
@@ -88,20 +86,24 @@ void RenderBackgroundLayer::render(PaintParameters& parameters) {
parameters.context,
*parameters.renderPass,
gfx::Triangles(),
parameters.depthModeForSublayer(0, parameters.pass == RenderPass::Opaque
? gfx::DepthMaskType::ReadWrite
: gfx::DepthMaskType::ReadOnly),
parameters.depthModeForSublayer(
0,
parameters.pass == RenderPass::Opaque ? gfx::DepthMaskType::ReadWrite : gfx::DepthMaskType::ReadOnly),
gfx::StencilMode::disabled(),
parameters.colorModeForRenderPass(),
gfx::CullFaceMode::disabled(),
*parameters.staticData.quadTriangleIndexBuffer,
parameters.staticData.tileTriangleSegments,
segments,
allUniformValues,
allAttributeBindings,
textureBindings,
getID() + "/" + util::toString(id)
);
util::toString(id));
};
if (segments.empty()) {
segments = parameters.staticData.tileTriangleSegments();
}
const auto& evaluated = static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).evaluated;
const auto& crossfade = static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).crossfade;
if (!evaluated.get<BackgroundPattern>().to.empty()) {
@@ -113,24 +115,21 @@ void RenderBackgroundLayer::render(PaintParameters& parameters) {
if (!imagePosA || !imagePosB)
return;
uint32_t i = 0;
for (const auto& tileID : util::tileCover(parameters.state, parameters.state.getIntegerZoom())) {
draw(
parameters.programs.getBackgroundLayerPrograms().backgroundPattern,
BackgroundPatternProgram::layoutUniformValues(
parameters.matrixForTile(tileID),
evaluated.get<BackgroundOpacity>(),
parameters.patternAtlas.getPixelSize(),
*imagePosA,
*imagePosB,
crossfade,
tileID,
parameters.state
),
BackgroundPatternProgram::TextureBindings{
textures::image::Value{ parameters.patternAtlas.textureBinding() },
},
tileID
);
draw(parameters.programs.getBackgroundLayerPrograms().backgroundPattern,
BackgroundPatternProgram::layoutUniformValues(parameters.matrixForTile(tileID),
evaluated.get<BackgroundOpacity>(),
parameters.patternAtlas.getPixelSize(),
*imagePosA,
*imagePosB,
crossfade,
tileID,
parameters.state),
BackgroundPatternProgram::TextureBindings{
textures::image::Value{parameters.patternAtlas.textureBinding()},
},
i++);
}
} else {
auto backgroundRenderPass = (evaluated.get<BackgroundColor>().a >= 1.0f
@@ -139,17 +138,16 @@ void RenderBackgroundLayer::render(PaintParameters& parameters) {
if (parameters.pass != backgroundRenderPass) {
return;
}
uint32_t i = 0;
for (const auto& tileID : util::tileCover(parameters.state, parameters.state.getIntegerZoom())) {
draw(
parameters.programs.getBackgroundLayerPrograms().background,
BackgroundProgram::LayoutUniformValues {
uniforms::matrix::Value( parameters.matrixForTile(tileID) ),
uniforms::color::Value( evaluated.get<BackgroundColor>() ),
uniforms::opacity::Value( evaluated.get<BackgroundOpacity>() ),
},
BackgroundProgram::TextureBindings{},
tileID
);
draw(parameters.programs.getBackgroundLayerPrograms().background,
BackgroundProgram::LayoutUniformValues{
uniforms::matrix::Value(parameters.matrixForTile(tileID)),
uniforms::color::Value(evaluated.get<BackgroundColor>()),
uniforms::opacity::Value(evaluated.get<BackgroundOpacity>()),
},
BackgroundProgram::TextureBindings{},
i++);
}
}
}

View File

@@ -1,5 +1,6 @@
#pragma once
#include <mbgl/programs/background_program.hpp>
#include <mbgl/renderer/render_layer.hpp>
#include <mbgl/style/layers/background_layer_impl.hpp>
#include <mbgl/style/layers/background_layer_properties.hpp>
@@ -22,6 +23,7 @@ private:
// Paint properties
style::BackgroundPaintProperties::Unevaluated unevaluated;
SegmentVector<BackgroundAttributes> segments;
};
} // namespace mbgl

View File

@@ -17,7 +17,7 @@ using namespace style;
namespace {
inline const style::CircleLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
inline const style::CircleLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) {
assert(impl->getTypeInfo() == CircleLayer::Impl::staticTypeInfo());
return static_cast<const style::CircleLayer::Impl&>(*impl);
}
@@ -26,11 +26,10 @@ inline const style::CircleLayer::Impl& impl(const Immutable<style::Layer::Impl>&
RenderCircleLayer::RenderCircleLayer(Immutable<style::CircleLayer::Impl> _impl)
: RenderLayer(makeMutable<CircleLayerProperties>(std::move(_impl))),
unevaluated(impl(baseImpl).paint.untransitioned()) {
}
unevaluated(impl_cast(baseImpl).paint.untransitioned()) {}
void RenderCircleLayer::transition(const TransitionParameters& parameters) {
unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
}
void RenderCircleLayer::evaluate(const PropertyEvaluationParameters& parameters) {

View File

@@ -23,7 +23,7 @@ using namespace style;
namespace {
inline const FillExtrusionLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
inline const FillExtrusionLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) {
assert(impl->getTypeInfo() == FillExtrusionLayer::Impl::staticTypeInfo());
return static_cast<const FillExtrusionLayer::Impl&>(*impl);
}
@@ -32,13 +32,12 @@ inline const FillExtrusionLayer::Impl& impl(const Immutable<style::Layer::Impl>&
RenderFillExtrusionLayer::RenderFillExtrusionLayer(Immutable<style::FillExtrusionLayer::Impl> _impl)
: RenderLayer(makeMutable<FillExtrusionLayerProperties>(std::move(_impl))),
unevaluated(impl(baseImpl).paint.untransitioned()) {
}
unevaluated(impl_cast(baseImpl).paint.untransitioned()) {}
RenderFillExtrusionLayer::~RenderFillExtrusionLayer() = default;
void RenderFillExtrusionLayer::transition(const TransitionParameters& parameters) {
unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
}
void RenderFillExtrusionLayer::evaluate(const PropertyEvaluationParameters& parameters) {

View File

@@ -24,7 +24,7 @@ using namespace style;
namespace {
inline const FillLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
inline const FillLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) {
assert(impl->getTypeInfo() == FillLayer::Impl::staticTypeInfo());
return static_cast<const FillLayer::Impl&>(*impl);
}
@@ -33,13 +33,12 @@ inline const FillLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
RenderFillLayer::RenderFillLayer(Immutable<style::FillLayer::Impl> _impl)
: RenderLayer(makeMutable<FillLayerProperties>(std::move(_impl))),
unevaluated(impl(baseImpl).paint.untransitioned()) {
}
unevaluated(impl_cast(baseImpl).paint.untransitioned()) {}
RenderFillLayer::~RenderFillLayer() = default;
void RenderFillLayer::transition(const TransitionParameters& parameters) {
unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
}
void RenderFillLayer::evaluate(const PropertyEvaluationParameters& parameters) {

View File

@@ -4,7 +4,6 @@
#include <mbgl/renderer/paint_parameters.hpp>
#include <mbgl/renderer/render_static_data.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/programs/heatmap_program.hpp>
#include <mbgl/tile/tile.hpp>
#include <mbgl/style/layers/heatmap_layer.hpp>
#include <mbgl/style/layers/heatmap_layer_impl.hpp>
@@ -21,7 +20,7 @@ using namespace style;
namespace {
inline const HeatmapLayer::Impl& impl(const Immutable<Layer::Impl>& impl) {
inline const HeatmapLayer::Impl& impl_cast(const Immutable<Layer::Impl>& impl) {
assert(impl->getTypeInfo() == HeatmapLayer::Impl::staticTypeInfo());
return static_cast<const HeatmapLayer::Impl&>(*impl);
}
@@ -30,13 +29,13 @@ inline const HeatmapLayer::Impl& impl(const Immutable<Layer::Impl>& impl) {
RenderHeatmapLayer::RenderHeatmapLayer(Immutable<HeatmapLayer::Impl> _impl)
: RenderLayer(makeMutable<HeatmapLayerProperties>(std::move(_impl))),
unevaluated(impl(baseImpl).paint.untransitioned()), colorRamp({256, 1}) {
}
unevaluated(impl_cast(baseImpl).paint.untransitioned()),
colorRamp({256, 1}) {}
RenderHeatmapLayer::~RenderHeatmapLayer() = default;
void RenderHeatmapLayer::transition(const TransitionParameters& parameters) {
unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
updateColorRamp();
}
@@ -177,6 +176,10 @@ void RenderHeatmapLayer::render(PaintParameters& parameters) {
checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));
if (segments.empty()) {
// Copy over the segments so that we can create our own DrawScopes.
segments = parameters.staticData.heatmapTextureSegments();
}
programInstance.draw(
parameters.context,
*parameters.renderPass,
@@ -186,15 +189,14 @@ void RenderHeatmapLayer::render(PaintParameters& parameters) {
parameters.colorModeForRenderPass(),
gfx::CullFaceMode::disabled(),
*parameters.staticData.quadTriangleIndexBuffer,
parameters.staticData.heatmapTextureSegments,
segments,
allUniformValues,
allAttributeBindings,
HeatmapTextureProgram::TextureBindings{
textures::image::Value{ renderTexture->getTexture().getResource(), gfx::TextureFilterType::Linear },
textures::color_ramp::Value{ colorRampTexture->getResource(), gfx::TextureFilterType::Linear },
textures::image::Value{renderTexture->getTexture().getResource(), gfx::TextureFilterType::Linear},
textures::color_ramp::Value{colorRampTexture->getResource(), gfx::TextureFilterType::Linear},
},
getID()
);
getID());
}
}

View File

@@ -1,10 +1,11 @@
#pragma once
#include <mbgl/gfx/offscreen_texture.hpp>
#include <mbgl/gfx/texture.hpp>
#include <mbgl/programs/heatmap_program.hpp>
#include <mbgl/renderer/render_layer.hpp>
#include <mbgl/style/layers/heatmap_layer_impl.hpp>
#include <mbgl/style/layers/heatmap_layer_properties.hpp>
#include <mbgl/gfx/texture.hpp>
#include <mbgl/gfx/offscreen_texture.hpp>
#include <mbgl/util/optional.hpp>
namespace mbgl {
@@ -24,14 +25,14 @@ private:
bool queryIntersectsFeature(const GeometryCoordinates&, const GeometryTileFeature&, const float,
const TransformState&, const float, const mat4&, const FeatureState&) const override;
void updateColorRamp();
// Paint properties
style::HeatmapPaintProperties::Unevaluated unevaluated;
PremultipliedImage colorRamp;
std::unique_ptr<gfx::OffscreenTexture> renderTexture;
optional<gfx::Texture> colorRampTexture;
void updateColorRamp();
SegmentVector<HeatmapTextureAttributes> segments;
};
} // namespace mbgl

View File

@@ -20,7 +20,7 @@ using namespace style;
namespace {
inline const HillshadeLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
inline const HillshadeLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) {
assert(impl->getTypeInfo() == HillshadeLayer::Impl::staticTypeInfo());
return static_cast<const HillshadeLayer::Impl&>(*impl);
}
@@ -29,8 +29,7 @@ inline const HillshadeLayer::Impl& impl(const Immutable<style::Layer::Impl>& imp
RenderHillshadeLayer::RenderHillshadeLayer(Immutable<style::HillshadeLayer::Impl> _impl)
: RenderLayer(makeMutable<HillshadeLayerProperties>(std::move(_impl))),
unevaluated(impl(baseImpl).paint.untransitioned()) {
}
unevaluated(impl_cast(baseImpl).paint.untransitioned()) {}
RenderHillshadeLayer::~RenderHillshadeLayer() = default;
@@ -48,7 +47,7 @@ const std::array<float, 2> RenderHillshadeLayer::getLight(const PaintParameters&
}
void RenderHillshadeLayer::transition(const TransitionParameters& parameters) {
unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
}
void RenderHillshadeLayer::evaluate(const PropertyEvaluationParameters& parameters) {
@@ -111,21 +110,19 @@ void RenderHillshadeLayer::render(PaintParameters& parameters) {
checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));
programInstance.draw(
parameters.context,
*parameters.renderPass,
gfx::Triangles(),
parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
gfx::StencilMode::disabled(),
parameters.colorModeForRenderPass(),
gfx::CullFaceMode::disabled(),
indexBuffer,
segments,
allUniformValues,
allAttributeBindings,
textureBindings,
getID() + "/" + util::toString(id)
);
programInstance.draw(parameters.context,
*parameters.renderPass,
gfx::Triangles(),
parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
gfx::StencilMode::disabled(),
parameters.colorModeForRenderPass(),
gfx::CullFaceMode::disabled(),
indexBuffer,
segments,
allUniformValues,
allAttributeBindings,
textureBindings,
getID());
};
mat4 mat;
@@ -177,29 +174,30 @@ void RenderHillshadeLayer::render(PaintParameters& parameters) {
checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));
programInstance.draw(
parameters.context,
*renderPass,
gfx::Triangles(),
parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
gfx::StencilMode::disabled(),
parameters.colorModeForRenderPass(),
gfx::CullFaceMode::disabled(),
*parameters.staticData.quadTriangleIndexBuffer,
parameters.staticData.rasterSegments,
allUniformValues,
allAttributeBindings,
HillshadePrepareProgram::TextureBindings{
textures::image::Value{ bucket.dem->getResource() },
},
getID() + "/p/" + util::toString(tile.id)
);
// Copy over the segments so that we can create our own DrawScopes that get destroyed
// after this draw call.
auto segments = parameters.staticData.rasterSegments();
programInstance.draw(parameters.context,
*renderPass,
gfx::Triangles(),
parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
gfx::StencilMode::disabled(),
parameters.colorModeForRenderPass(),
gfx::CullFaceMode::disabled(),
*parameters.staticData.quadTriangleIndexBuffer,
segments,
allUniformValues,
allAttributeBindings,
HillshadePrepareProgram::TextureBindings{
textures::image::Value{bucket.dem->getResource()},
},
"prepare");
bucket.texture = std::move(view->getTexture());
bucket.setPrepared(true);
} else if (parameters.pass == RenderPass::Translucent) {
assert(bucket.texture);
if (bucket.vertexBuffer && bucket.indexBuffer && !bucket.segments.empty()) {
if (bucket.vertexBuffer && bucket.indexBuffer) {
// Draw only the parts of the tile that aren't drawn by another tile in the layer.
draw(parameters.matrixForTile(tile.id, true),
*bucket.vertexBuffer,
@@ -211,13 +209,17 @@ void RenderHillshadeLayer::render(PaintParameters& parameters) {
});
} else {
// Draw the full tile.
if (bucket.segments.empty()) {
// Copy over the segments so that we can create our own DrawScopes.
bucket.segments = parameters.staticData.rasterSegments();
}
draw(parameters.matrixForTile(tile.id, true),
*parameters.staticData.rasterVertexBuffer,
*parameters.staticData.quadTriangleIndexBuffer,
parameters.staticData.rasterSegments,
bucket.segments,
tile.id,
HillshadeProgram::TextureBindings{
textures::image::Value{ bucket.texture->getResource(), gfx::TextureFilterType::Linear },
textures::image::Value{bucket.texture->getResource(), gfx::TextureFilterType::Linear},
});
}
}

View File

@@ -23,7 +23,7 @@ using namespace style;
namespace {
inline const LineLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
inline const LineLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) {
assert(impl->getTypeInfo() == LineLayer::Impl::staticTypeInfo());
return static_cast<const LineLayer::Impl&>(*impl);
}
@@ -32,14 +32,13 @@ inline const LineLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
RenderLineLayer::RenderLineLayer(Immutable<style::LineLayer::Impl> _impl)
: RenderLayer(makeMutable<LineLayerProperties>(std::move(_impl))),
unevaluated(impl(baseImpl).paint.untransitioned()),
colorRamp({256, 1}) {
}
unevaluated(impl_cast(baseImpl).paint.untransitioned()),
colorRamp({256, 1}) {}
RenderLineLayer::~RenderLineLayer() = default;
void RenderLineLayer::transition(const TransitionParameters& parameters) {
unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
updateColorRamp();
}

View File

@@ -16,7 +16,7 @@ using namespace style;
namespace {
inline const RasterLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
inline const RasterLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) {
assert(impl->getTypeInfo() == RasterLayer::Impl::staticTypeInfo());
return static_cast<const RasterLayer::Impl&>(*impl);
}
@@ -25,13 +25,12 @@ inline const RasterLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl)
RenderRasterLayer::RenderRasterLayer(Immutable<style::RasterLayer::Impl> _impl)
: RenderLayer(makeMutable<RasterLayerProperties>(std::move(_impl))),
unevaluated(impl(baseImpl).paint.untransitioned()) {
}
unevaluated(impl_cast(baseImpl).paint.untransitioned()) {}
RenderRasterLayer::~RenderRasterLayer() = default;
void RenderRasterLayer::transition(const TransitionParameters& parameters) {
unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
}
void RenderRasterLayer::evaluate(const PropertyEvaluationParameters& parameters) {
@@ -153,14 +152,14 @@ void RenderRasterLayer::render(PaintParameters& parameters) {
size_t i = 0;
for (const auto& matrix_ : imageData->matrices) {
draw(matrix_,
*bucket.vertexBuffer,
*bucket.indexBuffer,
bucket.segments,
RasterProgram::TextureBindings{
textures::image0::Value{ bucket.texture->getResource(), filter },
textures::image1::Value{ bucket.texture->getResource(), filter },
},
bucket.drawScopeID + std::to_string(i++));
*bucket.vertexBuffer,
*bucket.indexBuffer,
bucket.segments,
RasterProgram::TextureBindings{
textures::image0::Value{bucket.texture->getResource(), filter},
textures::image1::Value{bucket.texture->getResource(), filter},
},
std::to_string(i++));
}
} else if (renderTiles) {
for (const RenderTile& tile : *renderTiles) {
@@ -174,28 +173,32 @@ void RenderRasterLayer::render(PaintParameters& parameters) {
continue;
assert(bucket.texture);
if (bucket.vertexBuffer && bucket.indexBuffer && !bucket.segments.empty()) {
if (bucket.vertexBuffer && bucket.indexBuffer) {
// Draw only the parts of the tile that aren't drawn by another tile in the layer.
draw(parameters.matrixForTile(tile.id, true),
*bucket.vertexBuffer,
*bucket.indexBuffer,
bucket.segments,
RasterProgram::TextureBindings{
textures::image0::Value{ bucket.texture->getResource(), filter },
textures::image1::Value{ bucket.texture->getResource(), filter },
textures::image0::Value{bucket.texture->getResource(), filter},
textures::image1::Value{bucket.texture->getResource(), filter},
},
bucket.drawScopeID);
"image");
} else {
// Draw the full tile.
if (bucket.segments.empty()) {
// Copy over the segments so that we can create our own DrawScopes.
bucket.segments = parameters.staticData.rasterSegments();
}
draw(parameters.matrixForTile(tile.id, true),
*parameters.staticData.rasterVertexBuffer,
*parameters.staticData.quadTriangleIndexBuffer,
parameters.staticData.rasterSegments,
bucket.segments,
RasterProgram::TextureBindings{
textures::image0::Value{ bucket.texture->getResource(), filter },
textures::image1::Value{ bucket.texture->getResource(), filter },
textures::image0::Value{bucket.texture->getResource(), filter},
textures::image1::Value{bucket.texture->getResource(), filter},
},
bucket.drawScopeID);
"image");
}
}
}

View File

@@ -290,7 +290,7 @@ void drawText(const DrawFn& draw,
}
}
inline const SymbolLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
inline const SymbolLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) {
assert(impl->getTypeInfo() == SymbolLayer::Impl::staticTypeInfo());
return static_cast<const SymbolLayer::Impl&>(*impl);
}
@@ -299,14 +299,14 @@ inline const SymbolLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl)
RenderSymbolLayer::RenderSymbolLayer(Immutable<style::SymbolLayer::Impl> _impl)
: RenderLayer(makeMutable<SymbolLayerProperties>(std::move(_impl))),
unevaluated(impl(baseImpl).paint.untransitioned()) {
}
unevaluated(impl_cast(baseImpl).paint.untransitioned()) {}
RenderSymbolLayer::~RenderSymbolLayer() = default;
void RenderSymbolLayer::transition(const TransitionParameters& parameters) {
unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
hasFormatSectionOverrides = SymbolLayerPaintPropertyOverrides::hasOverrides(impl(baseImpl).layout.get<TextField>());
unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
hasFormatSectionOverrides =
SymbolLayerPaintPropertyOverrides::hasOverrides(impl_cast(baseImpl).layout.get<TextField>());
}
void RenderSymbolLayer::evaluate(const PropertyEvaluationParameters& parameters) {
@@ -314,7 +314,7 @@ void RenderSymbolLayer::evaluate(const PropertyEvaluationParameters& parameters)
staticImmutableCast<SymbolLayer::Impl>(baseImpl),
unevaluated.evaluate(parameters));
auto& evaluated = properties->evaluated;
auto& layout = impl(baseImpl).layout;
auto& layout = impl_cast(baseImpl).layout;
if (hasFormatSectionOverrides) {
SymbolLayerPaintPropertyOverrides::setOverrides(layout, evaluated);
@@ -346,7 +346,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters) {
return;
}
const bool sortFeaturesByKey = !impl(baseImpl).layout.get<SymbolSortKey>().isUndefined();
const bool sortFeaturesByKey = !impl_cast(baseImpl).layout.get<SymbolSortKey>().isUndefined();
std::multiset<RenderableSegment> renderableSegments;
const auto draw = [&parameters, this] (auto& programInstance,

View File

@@ -129,39 +129,30 @@ void PaintParameters::renderTileClippingMasks(const RenderTiles& renderTiles) {
const int32_t stencilID = nextStencilID++;
tileClippingMaskIDs.emplace(renderTile.id, stencilID);
program.draw(
context,
*renderPass,
gfx::Triangles(),
gfx::DepthMode::disabled(),
gfx::StencilMode {
gfx::StencilMode::Always{},
stencilID,
0b11111111,
gfx::StencilOpType::Keep,
gfx::StencilOpType::Keep,
gfx::StencilOpType::Replace
},
gfx::ColorMode::disabled(),
gfx::CullFaceMode::disabled(),
*staticData.quadTriangleIndexBuffer,
staticData.tileTriangleSegments,
program.computeAllUniformValues(
ClippingMaskProgram::LayoutUniformValues {
uniforms::matrix::Value( matrixForTile(renderTile.id) ),
},
paintAttributeData,
properties,
state.getZoom()
),
program.computeAllAttributeBindings(
*staticData.tileVertexBuffer,
paintAttributeData,
properties
),
ClippingMaskProgram::TextureBindings{},
"clipping/" + util::toString(stencilID)
);
program.draw(context,
*renderPass,
gfx::Triangles(),
gfx::DepthMode::disabled(),
gfx::StencilMode{gfx::StencilMode::Always{},
stencilID,
0b11111111,
gfx::StencilOpType::Keep,
gfx::StencilOpType::Keep,
gfx::StencilOpType::Replace},
gfx::ColorMode::disabled(),
gfx::CullFaceMode::disabled(),
*staticData.quadTriangleIndexBuffer,
staticData.clippingMaskSegments,
program.computeAllUniformValues(
ClippingMaskProgram::LayoutUniformValues{
uniforms::matrix::Value(matrixForTile(renderTile.id)),
},
paintAttributeData,
properties,
state.getZoom()),
program.computeAllAttributeBindings(*staticData.tileVertexBuffer, paintAttributeData, properties),
ClippingMaskProgram::TextureBindings{},
"clipping/" + util::toString(stencilID));
}
}

View File

@@ -50,15 +50,37 @@ static gfx::VertexVector<HeatmapTextureLayoutVertex> heatmapTextureVertices() {
}
RenderStaticData::RenderStaticData(gfx::Context& context, float pixelRatio)
: programs(context, ProgramParameters { pixelRatio, false })
: programs(context, ProgramParameters{pixelRatio, false}),
clippingMaskSegments(tileTriangleSegments())
#ifndef NDEBUG
, overdrawPrograms(context, ProgramParameters { pixelRatio, true })
,
overdrawPrograms(context, ProgramParameters{pixelRatio, true})
#endif
{
tileTriangleSegments.emplace_back(0, 0, 4, 6);
tileBorderSegments.emplace_back(0, 0, 4, 5);
rasterSegments.emplace_back(0, 0, 4, 6);
heatmapTextureSegments.emplace_back(0, 0, 4, 6);
}
SegmentVector<BackgroundAttributes> RenderStaticData::tileTriangleSegments() {
SegmentVector<BackgroundAttributes> segments;
segments.emplace_back(0, 0, 4, 6);
return segments;
}
SegmentVector<DebugAttributes> RenderStaticData::tileBorderSegments() {
SegmentVector<DebugAttributes> segments;
segments.emplace_back(0, 0, 4, 5);
return segments;
}
SegmentVector<RasterAttributes> RenderStaticData::rasterSegments() {
SegmentVector<RasterAttributes> segments;
segments.emplace_back(0, 0, 4, 6);
return segments;
}
SegmentVector<HeatmapTextureAttributes> RenderStaticData::heatmapTextureSegments() {
SegmentVector<HeatmapTextureAttributes> segments;
segments.emplace_back(0, 0, 4, 6);
return segments;
}
void RenderStaticData::upload(gfx::UploadPass& uploadPass) {

View File

@@ -30,10 +30,10 @@ public:
optional<gfx::IndexBuffer> quadTriangleIndexBuffer;
optional<gfx::IndexBuffer> tileBorderIndexBuffer;
SegmentVector<BackgroundAttributes> tileTriangleSegments;
SegmentVector<DebugAttributes> tileBorderSegments;
SegmentVector<RasterAttributes> rasterSegments;
SegmentVector<HeatmapTextureAttributes> heatmapTextureSegments;
static SegmentVector<BackgroundAttributes> tileTriangleSegments();
static SegmentVector<DebugAttributes> tileBorderSegments();
static SegmentVector<RasterAttributes> rasterSegments();
static SegmentVector<HeatmapTextureAttributes> heatmapTextureSegments();
optional<gfx::Renderbuffer<gfx::RenderbufferPixelType::Depth>> depthRenderbuffer;
bool has3D = false;
@@ -42,6 +42,8 @@ public:
Programs programs;
const SegmentVector<BackgroundAttributes> clippingMaskSegments;
#ifndef NDEBUG
Programs overdrawPrograms;
#endif

View File

@@ -147,81 +147,66 @@ void RenderTile::finishRender(PaintParameters& parameters) const {
program.draw(
parameters.context,
*parameters.renderPass,
gfx::Lines { 4.0f * parameters.pixelRatio },
gfx::Lines{4.0f * parameters.pixelRatio},
gfx::DepthMode::disabled(),
gfx::StencilMode::disabled(),
gfx::ColorMode::unblended(),
gfx::CullFaceMode::disabled(),
*debugBucket->indexBuffer,
debugBucket->segments,
program.computeAllUniformValues(
DebugProgram::LayoutUniformValues {
uniforms::matrix::Value( matrix ),
uniforms::color::Value( Color::white() )
},
paintAttributeData,
properties,
parameters.state.getZoom()
),
program.computeAllUniformValues(DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix),
uniforms::color::Value(Color::white())},
paintAttributeData,
properties,
parameters.state.getZoom()),
allAttributeBindings,
DebugProgram::TextureBindings{},
"__debug/" + debugBucket->drawScopeID + "/text-outline"
);
"text-outline");
program.draw(
parameters.context,
*parameters.renderPass,
gfx::Lines { 2.0f * parameters.pixelRatio },
gfx::Lines{2.0f * parameters.pixelRatio},
gfx::DepthMode::disabled(),
gfx::StencilMode::disabled(),
gfx::ColorMode::unblended(),
gfx::CullFaceMode::disabled(),
*debugBucket->indexBuffer,
debugBucket->segments,
program.computeAllUniformValues(
DebugProgram::LayoutUniformValues {
uniforms::matrix::Value( matrix ),
uniforms::color::Value( Color::black() )
},
paintAttributeData,
properties,
parameters.state.getZoom()
),
program.computeAllUniformValues(DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix),
uniforms::color::Value(Color::black())},
paintAttributeData,
properties,
parameters.state.getZoom()),
allAttributeBindings,
DebugProgram::TextureBindings{},
"__debug/" + debugBucket->drawScopeID + "/text"
);
"text");
}
if (parameters.debugOptions & MapDebugOptions::TileBorders) {
assert(debugBucket);
if (debugBucket->tileBorderSegments.empty()) {
debugBucket->tileBorderSegments = parameters.staticData.tileBorderSegments();
}
parameters.programs.debug.draw(
parameters.context,
*parameters.renderPass,
gfx::LineStrip { 4.0f * parameters.pixelRatio },
gfx::LineStrip{4.0f * parameters.pixelRatio},
gfx::DepthMode::disabled(),
gfx::StencilMode::disabled(),
gfx::ColorMode::unblended(),
gfx::CullFaceMode::disabled(),
*parameters.staticData.tileBorderIndexBuffer,
parameters.staticData.tileBorderSegments,
program.computeAllUniformValues(
DebugProgram::LayoutUniformValues {
uniforms::matrix::Value( matrix ),
uniforms::color::Value( Color::red() )
},
paintAttributeData,
properties,
parameters.state.getZoom()
),
debugBucket->tileBorderSegments,
program.computeAllUniformValues(DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix),
uniforms::color::Value(Color::red())},
paintAttributeData,
properties,
parameters.state.getZoom()),
program.computeAllAttributeBindings(
*parameters.staticData.tileVertexBuffer,
paintAttributeData,
properties
),
*parameters.staticData.tileVertexBuffer, paintAttributeData, properties),
DebugProgram::TextureBindings{},
"__debug/" + debugBucket->drawScopeID
);
"border");
}
}

View File

@@ -36,33 +36,25 @@ void ImageSourceRenderData::render(PaintParameters& parameters) const {
auto& programInstance = parameters.programs.debug;
for (auto matrix : matrices) {
programInstance.draw(
parameters.context,
*parameters.renderPass,
gfx::LineStrip { 4.0f * parameters.pixelRatio },
gfx::DepthMode::disabled(),
gfx::StencilMode::disabled(),
gfx::ColorMode::unblended(),
gfx::CullFaceMode::disabled(),
*parameters.staticData.tileBorderIndexBuffer,
parameters.staticData.tileBorderSegments,
programInstance.computeAllUniformValues(
DebugProgram::LayoutUniformValues {
uniforms::matrix::Value( matrix ),
uniforms::color::Value( Color::red() )
},
paintAttributeData,
properties,
parameters.state.getZoom()
),
programInstance.computeAllAttributeBindings(
*parameters.staticData.tileVertexBuffer,
paintAttributeData,
properties
),
DebugProgram::TextureBindings{},
"image"
);
programInstance.draw(parameters.context,
*parameters.renderPass,
gfx::LineStrip{4.0f * parameters.pixelRatio},
gfx::DepthMode::disabled(),
gfx::StencilMode::disabled(),
gfx::ColorMode::unblended(),
gfx::CullFaceMode::disabled(),
*parameters.staticData.tileBorderIndexBuffer,
parameters.staticData.tileBorderSegments(),
programInstance.computeAllUniformValues(
DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix),
uniforms::color::Value(Color::red())},
paintAttributeData,
properties,
parameters.state.getZoom()),
programInstance.computeAllAttributeBindings(
*parameters.staticData.tileVertexBuffer, paintAttributeData, properties),
DebugProgram::TextureBindings{},
"image");
}
}

View File

@@ -1,14 +0,0 @@
#include <mbgl/util/id.hpp>
#include <atomic>
namespace mbgl {
namespace util {
uint64_t nextID() {
static std::atomic<uint64_t> GUID { 0 };
return GUID++;
}
} // namespace util
} // namespace mbgl

View File

@@ -1,11 +0,0 @@
#pragma once
#include <cstdint>
namespace mbgl {
namespace util {
uint64_t nextID();
} // namespace util
} // namespace mbgl