From 356bba9e3be9ba9940d163020ec1369779487135 Mon Sep 17 00:00:00 2001 From: John Firebaugh Date: Tue, 18 Jul 2017 10:16:17 -0700 Subject: [core] Inline Painter::renderFill --- src/mbgl/renderer/layers/render_fill_layer.cpp | 142 ++++++++++++++++++++++-- src/mbgl/renderer/painter.hpp | 3 - src/mbgl/renderer/painters/painter_fill.cpp | 143 ------------------------- 3 files changed, 134 insertions(+), 154 deletions(-) delete mode 100644 src/mbgl/renderer/painters/painter_fill.cpp (limited to 'src') diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp index 3063da36be..973b08dd1f 100644 --- a/src/mbgl/renderer/layers/render_fill_layer.cpp +++ b/src/mbgl/renderer/layers/render_fill_layer.cpp @@ -2,6 +2,10 @@ #include #include #include +#include +#include +#include +#include #include #include #include @@ -10,6 +14,8 @@ namespace mbgl { +using namespace style; + RenderFillLayer::RenderFillLayer(Immutable _impl) : RenderLayer(style::LayerType::Fill, _impl), unevaluated(impl().paint.untransitioned()) { @@ -54,14 +60,134 @@ bool RenderFillLayer::hasTransition() const { } void RenderFillLayer::render(Painter& painter, PaintParameters& parameters, RenderSource*) { - for (const RenderTile& tile : renderTiles) { - Bucket* bucket = tile.tile.getBucket(*baseImpl); - assert(dynamic_cast(bucket)); - painter.renderFill( - parameters, - *reinterpret_cast(bucket), - *this, - tile); + if (evaluated.get().from.empty()) { + for (const RenderTile& tile : renderTiles) { + assert(dynamic_cast(tile.tile.getBucket(*baseImpl))); + FillBucket& bucket = *reinterpret_cast(tile.tile.getBucket(*baseImpl)); + + auto draw = [&] (uint8_t sublayer, + auto& program, + const auto& drawMode, + const auto& indexBuffer, + const auto& segments) { + program.get(evaluated).draw( + painter.context, + drawMode, + painter.depthModeForSublayer(sublayer, gl::DepthMode::ReadWrite), + painter.stencilModeForClipping(tile.clip), + painter.colorModeForRenderPass(), + FillProgram::UniformValues { + uniforms::u_matrix::Value{ + tile.translatedMatrix(evaluated.get(), + evaluated.get(), + painter.state) + }, + uniforms::u_world::Value{ painter.context.viewport.getCurrentValue().size }, + }, + *bucket.vertexBuffer, + indexBuffer, + segments, + bucket.paintPropertyBinders.at(getID()), + evaluated, + painter.state.getZoom(), + getID() + ); + }; + + if (evaluated.get() && !unevaluated.get().isUndefined() && painter.pass == RenderPass::Translucent) { + draw(2, + parameters.programs.fillOutline, + gl::Lines { 2.0f }, + *bucket.lineIndexBuffer, + bucket.lineSegments); + } + + // Only draw the fill when it's opaque and we're drawing opaque fragments, + // or when it's translucent and we're drawing translucent fragments. + if ((evaluated.get().constantOr(Color()).a >= 1.0f + && evaluated.get().constantOr(0) >= 1.0f) == (painter.pass == RenderPass::Opaque)) { + draw(1, + parameters.programs.fill, + gl::Triangles(), + *bucket.triangleIndexBuffer, + bucket.triangleSegments); + } + + if (evaluated.get() && unevaluated.get().isUndefined() && painter.pass == RenderPass::Translucent) { + draw(2, + parameters.programs.fillOutline, + gl::Lines { 2.0f }, + *bucket.lineIndexBuffer, + bucket.lineSegments); + } + } + } else { + if (painter.pass != RenderPass::Translucent) { + return; + } + + optional imagePosA = painter.imageManager->getPattern(evaluated.get().from); + optional imagePosB = painter.imageManager->getPattern(evaluated.get().to); + + if (!imagePosA || !imagePosB) { + return; + } + + painter.imageManager->bind(painter.context, 0); + + for (const RenderTile& tile : renderTiles) { + assert(dynamic_cast(tile.tile.getBucket(*baseImpl))); + FillBucket& bucket = *reinterpret_cast(tile.tile.getBucket(*baseImpl)); + + auto draw = [&] (uint8_t sublayer, + auto& program, + const auto& drawMode, + const auto& indexBuffer, + const auto& segments) { + program.get(evaluated).draw( + painter.context, + drawMode, + painter.depthModeForSublayer(sublayer, gl::DepthMode::ReadWrite), + painter.stencilModeForClipping(tile.clip), + painter.colorModeForRenderPass(), + FillPatternUniforms::values( + tile.translatedMatrix(evaluated.get(), + evaluated.get(), + painter.state), + painter.context.viewport.getCurrentValue().size, + painter.imageManager->getPixelSize(), + *imagePosA, + *imagePosB, + evaluated.get(), + tile.id, + painter.state + ), + *bucket.vertexBuffer, + indexBuffer, + segments, + bucket.paintPropertyBinders.at(getID()), + evaluated, + painter.state.getZoom(), + getID() + ); + }; + + draw(0, + parameters.programs.fillPattern, + gl::Triangles(), + *bucket.triangleIndexBuffer, + bucket.triangleSegments); + + if (!evaluated.get() || !unevaluated.get().isUndefined()) { + continue; + } + + draw(2, + parameters.programs.fillOutlinePattern, + gl::Lines { 2.0f }, + *bucket.lineIndexBuffer, + bucket.lineSegments); + } } } diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp index 645ddfd3ab..aef315ba22 100644 --- a/src/mbgl/renderer/painter.hpp +++ b/src/mbgl/renderer/painter.hpp @@ -39,13 +39,11 @@ struct FrameData; class Tile; class DebugBucket; -class FillBucket; class FillExtrusionBucket; class LineBucket; class SymbolBucket; class RasterBucket; -class RenderFillLayer; class RenderFillExtrusionLayer; class RenderLineLayer; class RenderSymbolLayer; @@ -79,7 +77,6 @@ public: void renderClippingMask(const UnwrappedTileID&, const ClipID&); void renderTileDebug(const RenderTile&); void renderTileDebug(const mat4& matrix); - void renderFill(PaintParameters&, FillBucket&, const RenderFillLayer&, const RenderTile&); void renderFillExtrusion(PaintParameters&, FillExtrusionBucket&, const RenderFillExtrusionLayer&, const RenderTile&); void renderLine(PaintParameters&, LineBucket&, const RenderLineLayer&, const RenderTile&); void renderSymbol(PaintParameters&, SymbolBucket&, const RenderSymbolLayer&, const RenderTile&); diff --git a/src/mbgl/renderer/painters/painter_fill.cpp b/src/mbgl/renderer/painters/painter_fill.cpp deleted file mode 100644 index 3ca3bdf6b8..0000000000 --- a/src/mbgl/renderer/painters/painter_fill.cpp +++ /dev/null @@ -1,143 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -namespace mbgl { - -using namespace style; - -void Painter::renderFill(PaintParameters& parameters, - FillBucket& bucket, - const RenderFillLayer& layer, - const RenderTile& tile) { - const FillPaintProperties::PossiblyEvaluated& properties = layer.evaluated; - - if (!properties.get().from.empty()) { - if (pass != RenderPass::Translucent) { - return; - } - - optional imagePosA = imageManager->getPattern(properties.get().from); - optional imagePosB = imageManager->getPattern(properties.get().to); - - if (!imagePosA || !imagePosB) { - return; - } - - imageManager->bind(context, 0); - - auto draw = [&] (uint8_t sublayer, - auto& program, - const auto& drawMode, - const auto& indexBuffer, - const auto& segments) { - program.get(properties).draw( - context, - drawMode, - depthModeForSublayer(sublayer, gl::DepthMode::ReadWrite), - stencilModeForClipping(tile.clip), - colorModeForRenderPass(), - FillPatternUniforms::values( - tile.translatedMatrix(properties.get(), - properties.get(), - state), - context.viewport.getCurrentValue().size, - imageManager->getPixelSize(), - *imagePosA, - *imagePosB, - properties.get(), - tile.id, - state - ), - *bucket.vertexBuffer, - indexBuffer, - segments, - bucket.paintPropertyBinders.at(layer.getID()), - properties, - state.getZoom(), - layer.getID() - ); - }; - - draw(0, - parameters.programs.fillPattern, - gl::Triangles(), - *bucket.triangleIndexBuffer, - bucket.triangleSegments); - - if (!properties.get() || !layer.unevaluated.get().isUndefined()) { - return; - } - - draw(2, - parameters.programs.fillOutlinePattern, - gl::Lines { 2.0f }, - *bucket.lineIndexBuffer, - bucket.lineSegments); - } else { - auto draw = [&] (uint8_t sublayer, - auto& program, - const auto& drawMode, - const auto& indexBuffer, - const auto& segments) { - program.get(properties).draw( - context, - drawMode, - depthModeForSublayer(sublayer, gl::DepthMode::ReadWrite), - stencilModeForClipping(tile.clip), - colorModeForRenderPass(), - FillProgram::UniformValues { - uniforms::u_matrix::Value{ - tile.translatedMatrix(properties.get(), - properties.get(), - state) - }, - uniforms::u_world::Value{ context.viewport.getCurrentValue().size }, - }, - *bucket.vertexBuffer, - indexBuffer, - segments, - bucket.paintPropertyBinders.at(layer.getID()), - properties, - state.getZoom(), - layer.getID() - ); - }; - - if (properties.get() && !layer.unevaluated.get().isUndefined() && pass == RenderPass::Translucent) { - draw(2, - parameters.programs.fillOutline, - gl::Lines { 2.0f }, - *bucket.lineIndexBuffer, - bucket.lineSegments); - } - - // Only draw the fill when it's opaque and we're drawing opaque fragments, - // or when it's translucent and we're drawing translucent fragments. - if ((properties.get().constantOr(Color()).a >= 1.0f - && properties.get().constantOr(0) >= 1.0f) == (pass == RenderPass::Opaque)) { - draw(1, - parameters.programs.fill, - gl::Triangles(), - *bucket.triangleIndexBuffer, - bucket.triangleSegments); - } - - if (properties.get() && layer.unevaluated.get().isUndefined() && pass == RenderPass::Translucent) { - draw(2, - parameters.programs.fillOutline, - gl::Lines { 2.0f }, - *bucket.lineIndexBuffer, - bucket.lineSegments); - } - } -} - -} // namespace mbgl -- cgit v1.2.1