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

Drawable Renderer (#1570), Setting up for fill patterns.

Browse Source 
Handle color and cull modes better.
Rename `DrawableBuilder::ColorMode` to `ColorAttrMode` to avoid confusion with `gfx::ColorMode`.
This commit is contained in:
Tim Sylvester
2023-05-23 12:59:36 -07:00
committed by Bart Louwers
parent ec45ef654e
commit b8bdf0643c
21 changed files with 721 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
src/mbgl/gfx/drawable.cpp
View File

@@ -1,4 +1,6 @@
#include <mbgl/gfx/drawable.hpp>
#include <mbgl/gfx/cull_face_mode.hpp>
#include <mbgl/gfx/types.hpp>
#include <mbgl/renderer/render_pass.hpp>
#include <mbgl/util/mat4.hpp>
@@ -6,11 +8,26 @@
namespace mbgl {
namespace gfx {
struct Drawable::Impl {
gfx::CullFaceMode cullFaceMode = gfx::CullFaceMode::disabled();
};
Drawable::Drawable(std::string name_)
: name(name_),
renderPass(RenderPass::Opaque),
matrix(matrix::identity4()),
depthType(DepthMaskType::ReadOnly) {}
depthType(DepthMaskType::ReadOnly),
impl(std::make_unique<Impl>()) {}
Drawable::~Drawable() = default;
const gfx::CullFaceMode& Drawable::getCullFaceMode() const {
return impl->cullFaceMode;
}
void Drawable::setCullFaceMode(const gfx::CullFaceMode& value) {
impl->cullFaceMode = value;
}
} // namespace gfx
} // namespace mbgl

15
src/mbgl/gfx/drawable_builder.cpp
View File

@@ -23,6 +23,13 @@ void DrawableBuilder::setColor(const Color& value) {
impl->currentColor = value;
}
const gfx::CullFaceMode& DrawableBuilder::getCullFaceMode() const {
return impl->cullFaceMode;
}
void DrawableBuilder::setCullFaceMode(const gfx::CullFaceMode& value) {
impl->cullFaceMode = value;
}
const UniqueDrawable& DrawableBuilder::getCurrentDrawable(bool createIfNone) {
if (!currentDrawable && createIfNone) {
currentDrawable = createDrawable();
@@ -39,9 +46,9 @@ void DrawableBuilder::flush() {
draw->setLayerIndex(layerIndex);
draw->setSubLayerIndex(subLayerIndex);
draw->setDepthType(depthType);
draw->setCullFaceMode(impl->cullFaceMode);
draw->setShader(shader);
draw->setMatrix(matrix);
draw->addTweakers(tweakers.begin(), tweakers.end());
if (auto drawAttrs = getVertexAttributes().clone()) {
vertexAttrs.observeAttributes([&](const std::string& iName, const VertexAttribute& iAttr) {
@@ -100,7 +107,7 @@ void DrawableBuilder::addTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1
impl->vertices.emplace_back(Impl::VT({{{x1, y1}}}));
impl->vertices.emplace_back(Impl::VT({{{x2, y2}}}));
impl->triangleIndexes.emplace_back(n, n + 1, n + 2);
if (colorMode == ColorMode::PerVertex) {
if (colorAttrMode == ColorAttrMode::PerVertex) {
impl->colors.insert(impl->colors.end(), 3, impl->currentColor);
}
}
@@ -109,7 +116,7 @@ void DrawableBuilder::appendTriangle(int16_t x0, int16_t y0) {
const auto n = (uint16_t)impl->vertices.elements();
impl->vertices.emplace_back(Impl::VT({{{x0, y0}}}));
impl->triangleIndexes.emplace_back(n - 2, n - 1, n);
if (colorMode == ColorMode::PerVertex) {
if (colorAttrMode == ColorAttrMode::PerVertex) {
impl->colors.emplace_back(impl->currentColor);
}
}
@@ -134,7 +141,7 @@ std::size_t DrawableBuilder::addVertices(const std::vector<std::array<int16_t, 2
std::for_each(std::next(vertices.begin(), vertexOffset),
std::next(vertices.begin(), vertexOffset + vertexLength),
[&](const std::array<int16_t, 2>& x) { impl->vertices.emplace_back(Impl::VT({{x}})); });
if (colorMode == ColorMode::PerVertex) {
if (colorAttrMode == ColorAttrMode::PerVertex) {
for (size_t i = 0; i < vertexLength; ++i) {
impl->colors.emplace_back(impl->currentColor);
}

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

@@ -1,4 +1,5 @@
#include <mbgl/gfx/attribute.hpp>
#include <mbgl/gfx/cull_face_mode.hpp>
#include <mbgl/gfx/index_vector.hpp>
#include <mbgl/gfx/vertex_vector.hpp>
#include <mbgl/programs/segment.hpp>
@@ -16,6 +17,7 @@ struct DrawableBuilder::Impl {
gfx::IndexVector<gfx::Lines> lineIndexes;
Color currentColor = Color::white();
std::vector<Color> colors;
gfx::CullFaceMode cullFaceMode = gfx::CullFaceMode::disabled();
};
} // namespace gfx

2
src/mbgl/gl/context.cpp
View File

@@ -477,7 +477,7 @@ bool Context::setupDraw(const PaintParameters& parameters, const gfx::Drawable&
setStencilMode(gfx::StencilMode::disabled());
}
setColorMode(gfx::ColorMode::alphaBlended());
setColorMode(parameters.colorModeForRenderPass());
setCullFaceMode(gfx::CullFaceMode::disabled());
auto& drawableGL = static_cast<const DrawableGL&>(drawable);

2
src/mbgl/gl/drawable_gl_builder.cpp
View File

@@ -21,7 +21,7 @@ void DrawableGLBuilder::init() {
posAttr->set(index++, gfx::VertexAttribute::int2{vert.a1[0], vert.a1[1]});
}
}
if (colorMode != ColorMode::None && !colorAttrName.empty()) {
if (colorAttrMode != ColorAttrMode::None && !colorAttrName.empty()) {
if (const auto& colorAttr = attrs.getOrAdd(colorAttrName)) {
// We should have either a single color or one per vertex. Otherwise,
// the color mode was probably changed after vertexes were added.

4
src/mbgl/gl/renderer_backend.cpp
View File

@@ -95,7 +95,9 @@ void registerTypes(gfx::ShaderRegistry& registry, gl::Context& glContext, const
void RendererBackend::initShaders(gfx::ShaderRegistry& shaders, const ProgramParameters& programParameters) {
registerTypes<shaders::BuiltIn::BackgroundShader,
shaders::BuiltIn::FillShader,
shaders::BuiltIn::FillOutlineShader>(shaders, static_cast<gl::Context&>(*context), programParameters);
shaders::BuiltIn::FillOutlineShader,
shaders::BuiltIn::FillOutlinePatternShader,
shaders::BuiltIn::FillPatternShader>(shaders, static_cast<gl::Context&>(*context), programParameters);
}
} // namespace gl

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

@@ -315,8 +315,7 @@ void RenderBackgroundLayer::update(const int32_t layerIndex,
builder = context.createDrawableBuilder("background");
builder->setRenderPass(drawPasses);
builder->setShader(shader);
builder->addTweaker(context.createDrawableTweaker());
builder->setColorMode(gfx::DrawableBuilder::ColorMode::PerDrawable);
builder->setColorAttrMode(gfx::DrawableBuilder::ColorAttrMode::PerDrawable);
builder->setDepthType(gfx::DepthMaskType::ReadWrite);
builder->setLayerIndex(layerIndex);
}
@@ -336,8 +335,6 @@ void RenderBackgroundLayer::update(const int32_t layerIndex,
drawable->mutableUniformBuffers().addOrReplace("BackgroundLayerUBO", uniformBuffer);
tileLayerGroup->addDrawable(renderPass, tileID, std::move(drawable));
++stats.tileDrawablesAdded;
// Log::Warning(Event::General, "Adding drawable for " + util::toString(tileID) + " total " +
// std::to_string(stats.tileDrawablesAdded+1));
}
}
}

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

@@ -278,6 +278,10 @@ void RenderFillLayer::layerRemoved(UniqueChangeRequestVec& changes) {
}
}
void RenderFillLayer::removeTile(RenderPass renderPass, const OverscaledTileID& tileID) {
stats.tileDrawablesRemoved += tileLayerGroup->removeDrawables(renderPass, tileID).size();
}
void RenderFillLayer::update(const int32_t layerIndex,
gfx::ShaderRegistry& shaders,
gfx::Context& context,
@@ -285,14 +289,7 @@ void RenderFillLayer::update(const int32_t layerIndex,
UniqueChangeRequestVec& changes) {
std::unique_lock<std::mutex> guard(mutex);
if (!fillShader) {
fillShader = context.getGenericShader(shaders, "FillShader");
}
if (!outlineShader) {
outlineShader = context.getGenericShader(shaders, "FillOutlineShader");
}
if (!fillShader || !outlineShader || !renderTiles || renderTiles->empty()) {
if (!renderTiles || renderTiles->empty()) {
if (tileLayerGroup) {
stats.tileDrawablesRemoved += tileLayerGroup->getDrawableCount();
tileLayerGroup->clearDrawables();
@@ -309,6 +306,19 @@ void RenderFillLayer::update(const int32_t layerIndex,
changes.emplace_back(std::make_unique<AddLayerGroupRequest>(tileLayerGroup, /*canReplace=*/true));
}
if (!fillShader) {
fillShader = context.getGenericShader(shaders, "FillShader");
}
if (!outlineShader) {
outlineShader = context.getGenericShader(shaders, "FillOutlineShader");
}
if (!patternShader) {
patternShader = context.getGenericShader(shaders, "FillPatternShader");
}
if (!outlinePatternShader) {
outlinePatternShader = context.getGenericShader(shaders, "FillOutlinePatternShader");
}
std::unordered_set<OverscaledTileID> newTileIDs(renderTiles->size());
std::transform(renderTiles->begin(),
renderTiles->end(),
@@ -317,6 +327,8 @@ void RenderFillLayer::update(const int32_t layerIndex,
std::unique_ptr<gfx::DrawableBuilder> fillBuilder;
std::unique_ptr<gfx::DrawableBuilder> outlineBuilder;
std::unique_ptr<gfx::DrawableBuilder> patternBuilder;
std::unique_ptr<gfx::DrawableBuilder> outlinePatternBuilder;
std::vector<gfx::DrawablePtr> newTiles;
gfx::VertexAttributeArray fillVertexAttrs;
gfx::VertexAttributeArray outlineVertexAttrs;
@@ -336,29 +348,38 @@ void RenderFillLayer::update(const int32_t layerIndex,
}
});
if (unevaluated.get<FillPattern>().isUndefined()) {
// parameters.renderTileClippingMasks(renderTiles);
for (const RenderTile& tile : *renderTiles) {
const auto& tileID = tile.getOverscaledTileID();
// parameters.renderTileClippingMasks(renderTiles);
auto& tileDrawable = tileLayerGroup->getDrawable(renderPass, tileID);
for (const RenderTile& tile : *renderTiles) {
const auto& tileID = tile.getOverscaledTileID();
const auto removeTile = [&]() {
if (tileDrawable) {
// Remove and discard all drawables for the tile
tileLayerGroup->removeDrawables(renderPass, tileID);
++stats.tileDrawablesRemoved;
}
};
auto& tileDrawable = tileLayerGroup->getDrawable(renderPass, tileID);
const LayerRenderData* renderData = getRenderDataForPass(tile, renderPass);
if (!renderData) {
removeTile();
continue;
const LayerRenderData* renderData = getRenderDataForPass(tile, renderPass);
if (!renderData) {
removeTile(renderPass, tileID);
continue;
}
auto& bucket = static_cast<FillBucket&>(*renderData->bucket);
const auto& evaluated = getEvaluated<FillLayerProperties>(renderData->layerProperties);
std::vector<std::array<int16_t, 2>> rawVerts;
const auto buildVertices = [&](){
const std::vector<gfx::VertexVector<gfx::detail::VertexType<gfx::AttributeType<int16_t, 2>>>::Vertex>&
verts = bucket.vertices.vector();
if (rawVerts.size() < verts.size()) {
rawVerts.resize(verts.size());
std::transform(verts.begin(), verts.end(), rawVerts.begin(), [](const auto& x) { return x.a1; });
}
};
fillVertexAttrs.clear();
outlineVertexAttrs.clear();
auto& bucket = static_cast<FillBucket&>(*renderData->bucket);
const auto& evaluated = getEvaluated<FillLayerProperties>(renderData->layerProperties);
const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID());
if (unevaluated.get<FillPattern>().isUndefined()) {
const auto evalColor = evaluated.get<FillColor>().constantOr(Color());
const auto fillOpacity = evaluated.get<FillOpacity>().constantOr(0);
const auto fillColor = evalColor * (fillOpacity > 0.0f ? fillOpacity : 1.0f);
@@ -370,15 +391,10 @@ void RenderFillLayer::update(const int32_t layerIndex,
const auto doOutline = evaluated.get<FillAntialias>() && renderPass == RenderPass::Translucent;
if (!doFill && !doOutline) {
removeTile();
removeTile(renderPass, tileID);
continue;
}
fillVertexAttrs.clear();
outlineVertexAttrs.clear();
const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID());
if (doFill) {
if (auto& binder = paintPropertyBinders.get<FillColor>()) {
const auto count = binder->getVertexCount();
@@ -439,23 +455,23 @@ void RenderFillLayer::update(const int32_t layerIndex,
continue;
}
if (doFill && !fillBuilder) {
if (doFill && !fillBuilder && fillShader) {
fillBuilder = context.createDrawableBuilder("fill");
fillBuilder->setShader(fillShader);
// fillBuilder->addTweaker(context.createDrawableTweaker());
fillBuilder->setColorMode(gfx::DrawableBuilder::ColorMode::None);
fillBuilder->setColorAttrMode(gfx::DrawableBuilder::ColorAttrMode::None);
fillBuilder->setDepthType((renderPass == RenderPass::Opaque) ? gfx::DepthMaskType::ReadWrite
: gfx::DepthMaskType::ReadOnly);
fillBuilder->setCullFaceMode(gfx::CullFaceMode::disabled());
fillBuilder->setDepthType(gfx::DepthMaskType::ReadWrite);
fillBuilder->setLayerIndex(layerIndex);
}
if (doOutline && !outlineBuilder) {
if (doOutline && !outlineBuilder && outlineShader) {
outlineBuilder = context.createDrawableBuilder("fill-outline");
outlineBuilder->setShader(outlineShader);
// outlineBuilder->addTweaker(context.createDrawableTweaker());
outlineBuilder->setColorMode(gfx::DrawableBuilder::ColorMode::None);
outlineBuilder->setColorAttrMode(gfx::DrawableBuilder::ColorAttrMode::None);
outlineBuilder->setLineWidth(2);
outlineBuilder->setDepthType(gfx::DepthMaskType::ReadOnly);
outlineBuilder->setCullFaceMode(gfx::CullFaceMode::disabled());
outlineBuilder->setLayerIndex(layerIndex);
outlineBuilder->setSubLayerIndex(unevaluated.get<FillOutlineColor>().isUndefined() ? 2 : 0);
}
@@ -490,12 +506,8 @@ void RenderFillLayer::update(const int32_t layerIndex,
outlineBuilder->setVertexAttributes(outlineVertexAttrs);
}
const std::vector<gfx::VertexVector<gfx::detail::VertexType<gfx::AttributeType<int16_t, 2>>>::Vertex>&
verts = bucket.vertices.vector();
std::vector<std::array<int16_t, 2>> rawVerts(verts.size());
std::transform(verts.begin(), verts.end(), rawVerts.begin(), [](const auto& x) { return x.a1; });
if (fillBuilder) {
buildVertices();
fillBuilder->addVertices(rawVerts, 0, rawVerts.size());
for (const auto& seg : bucket.triangleSegments) {
@@ -507,11 +519,12 @@ void RenderFillLayer::update(const int32_t layerIndex,
for (auto& drawable : fillBuilder->clearDrawables()) {
drawable->setTileID(tileID);
// tileLayerGroup->addDrawable(renderPass, tileID, std::move(drawable));
tileLayerGroup->addDrawable(renderPass, tileID, std::move(drawable));
++stats.tileDrawablesAdded;
}
}
if (outlineBuilder) {
buildVertices();
outlineBuilder->addVertices(rawVerts, 0, rawVerts.size());
for (const auto& seg : bucket.lineSegments) {
@@ -527,94 +540,143 @@ void RenderFillLayer::update(const int32_t layerIndex,
++stats.tileDrawablesAdded;
}
}
} else { // FillPattern is defined
if (renderPass != RenderPass::Translucent) {
continue;
}
const auto& crossfade = getCrossfade<FillLayerProperties>(renderData->layerProperties);
const auto doOutline = evaluated.get<FillAntialias>() && unevaluated.get<FillOutlineColor>().isUndefined();
const auto& fillPatternValue =
evaluated.get<FillPattern>().constantOr(Faded<expression::Image>{"", ""});
const auto patternPosA = tile.getPattern(fillPatternValue.from.id());
const auto patternPosB = tile.getPattern(fillPatternValue.to.id());
paintPropertyBinders.setPatternParameters(patternPosA, patternPosB, crossfade);
if (!patternBuilder && patternShader) {
patternBuilder = context.createDrawableBuilder("fill-pattern");
patternBuilder->setShader(fillShader);
patternBuilder->setColorAttrMode(gfx::DrawableBuilder::ColorAttrMode::None);
patternBuilder->setDepthType(gfx::DepthMaskType::ReadWrite);
patternBuilder->setCullFaceMode(gfx::CullFaceMode::disabled());
patternBuilder->setLayerIndex(layerIndex);
outlinePatternBuilder->setSubLayerIndex(1);
}
if (doOutline && !outlinePatternBuilder && outlinePatternShader) {
outlinePatternBuilder = context.createDrawableBuilder("fill-outline-pattern");
outlinePatternBuilder->setShader(outlineShader);
outlinePatternBuilder->setColorAttrMode(gfx::DrawableBuilder::ColorAttrMode::None);
outlinePatternBuilder->setLineWidth(2);
outlinePatternBuilder->setDepthType(gfx::DepthMaskType::ReadOnly);
outlinePatternBuilder->setCullFaceMode(gfx::CullFaceMode::disabled());
outlinePatternBuilder->setLayerIndex(layerIndex);
outlinePatternBuilder->setSubLayerIndex(2);
}
// parameters.stencilModeForClipping(tile.id),
// parameters.colorModeForRenderPass(),
// gfx::CullFaceMode::disabled(),
// std::forward<decltype(textureBindings)>(textureBindings),
if (patternBuilder) {
patternBuilder->setRenderPass(renderPass);
//patternBuilder->setVertexAttributes(fillVertexAttrs);
}
if (outlinePatternBuilder) {
outlinePatternBuilder->setRenderPass(renderPass);
//outlinePatternBuilder->setVertexAttributes(outlineVertexAttrs);
}
if (patternBuilder) {
buildVertices();
patternBuilder->addVertices(rawVerts, 0, rawVerts.size());
for (const auto& seg : bucket.triangleSegments) {
patternBuilder->addTriangles(bucket.triangles.vector(), seg.indexOffset, seg.indexLength);
}
patternBuilder->flush();
for (auto& drawable : patternBuilder->clearDrawables()) {
drawable->setTileID(tileID);
//tileLayerGroup->addDrawable(renderPass, tileID, std::move(drawable));
++stats.tileDrawablesAdded;
}
}
if (outlinePatternBuilder) {
buildVertices();
outlinePatternBuilder->addVertices(rawVerts, 0, rawVerts.size());
for (const auto& seg : bucket.lineSegments) {
outlinePatternBuilder->addLines(bucket.lines.vector(), seg.indexOffset, seg.indexLength);
}
outlinePatternBuilder->flush();
for (auto& drawable : outlinePatternBuilder->clearDrawables()) {
drawable->setTileID(tileID);
//tileLayerGroup->addDrawable(renderPass, tileID, std::move(drawable));
++stats.tileDrawablesAdded;
}
}
// auto draw = [&](auto& programInstance,
// const auto& drawMode,
// const auto& depthMode,
// const auto& indexBuffer,
// const auto& segments,
// auto&& textureBindings) {
// const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID());
// paintPropertyBinders.setPatternParameters(patternPosA, patternPosB, crossfade);
//
// const auto allUniformValues = programInstance.computeAllUniformValues(
// FillPatternProgram::layoutUniformValues(
// tile.translatedMatrix(
// evaluated.get<FillTranslate>(), evaluated.get<FillTranslateAnchor>(),
// parameters.state),
// parameters.backend.getDefaultRenderable().getSize(),
// tile.getIconAtlasTexture().size,
// crossfade,
// tile.id,
// parameters.state,
// parameters.pixelRatio),
// paintPropertyBinders,
// evaluated,
// static_cast<float>(parameters.state.getZoom()));
// const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
// *bucket.vertexBuffer, paintPropertyBinders, evaluated);
//
// checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));
//
// };
//
// if (bucket.triangleIndexBuffer) {
// draw(*fillPatternProgram,
// gfx::Triangles(),
// parameters.depthModeForSublayer(1, gfx::DepthMaskType::ReadWrite),
// *bucket.triangleIndexBuffer,
// bucket.triangleSegments,
// FillPatternProgram::TextureBindings{
// textures::image::Value{tile.getIconAtlasTexture().getResource(),
// gfx::TextureFilterType::Linear},
// });
// }
// if (evaluated.get<FillAntialias>() && unevaluated.get<FillOutlineColor>().isUndefined()) {
// draw(*fillOutlinePatternProgram,
// gfx::Lines{2.0f},
// parameters.depthModeForSublayer(2, gfx::DepthMaskType::ReadOnly),
// *bucket.lineIndexBuffer,
// bucket.lineSegments,
// FillOutlinePatternProgram::TextureBindings{
// textures::image::Value{tile.getIconAtlasTexture().getResource(),
// gfx::TextureFilterType::Linear},
// });
// }
//}
}
} else { // FillPattern is defined
// if (parameters.pass != RenderPass::Translucent) {
// return;
// }
//
// parameters.renderTileClippingMasks(renderTiles);
//
// for (const RenderTile& tile : *renderTiles) {
// const LayerRenderData* renderData = getRenderDataForPass(tile, parameters.pass);
// if (!renderData) {
// continue;
// }
// auto& bucket = static_cast<FillBucket&>(*renderData->bucket);
// const auto& evaluated = getEvaluated<FillLayerProperties>(renderData->layerProperties);
// const auto& crossfade = getCrossfade<FillLayerProperties>(renderData->layerProperties);
//
// const auto& fillPatternValue =
// evaluated.get<FillPattern>().constantOr(Faded<expression::Image>{"", ""});
// std::optional<ImagePosition> patternPosA = tile.getPattern(fillPatternValue.from.id());
// std::optional<ImagePosition> patternPosB = tile.getPattern(fillPatternValue.to.id());
//
// auto draw = [&](auto& programInstance,
// const auto& drawMode,
// const auto& depthMode,
// const auto& indexBuffer,
// const auto& segments,
// auto&& textureBindings) {
// const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID());
// paintPropertyBinders.setPatternParameters(patternPosA, patternPosB, crossfade);
//
// const auto allUniformValues = programInstance.computeAllUniformValues(
// FillPatternProgram::layoutUniformValues(
// tile.translatedMatrix(
// evaluated.get<FillTranslate>(), evaluated.get<FillTranslateAnchor>(),
// parameters.state),
// parameters.backend.getDefaultRenderable().getSize(),
// tile.getIconAtlasTexture().size,
// crossfade,
// tile.id,
// parameters.state,
// parameters.pixelRatio),
// paintPropertyBinders,
// evaluated,
// static_cast<float>(parameters.state.getZoom()));
// const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
// *bucket.vertexBuffer, paintPropertyBinders, evaluated);
//
// checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));
//
// programInstance.draw(parameters.context,
// *parameters.renderPass,
// drawMode,
// depthMode,
// parameters.stencilModeForClipping(tile.id),
// parameters.colorModeForRenderPass(),
// gfx::CullFaceMode::disabled(),
// indexBuffer,
// segments,
// allUniformValues,
// allAttributeBindings,
// std::forward<decltype(textureBindings)>(textureBindings),
// getID());
// };
//
// if (bucket.triangleIndexBuffer) {
// draw(*fillPatternProgram,
// gfx::Triangles(),
// parameters.depthModeForSublayer(1, gfx::DepthMaskType::ReadWrite),
// *bucket.triangleIndexBuffer,
// bucket.triangleSegments,
// FillPatternProgram::TextureBindings{
// textures::image::Value{tile.getIconAtlasTexture().getResource(),
// gfx::TextureFilterType::Linear},
// });
// }
// if (evaluated.get<FillAntialias>() && unevaluated.get<FillOutlineColor>().isUndefined()) {
// draw(*fillOutlinePatternProgram,
// gfx::Lines{2.0f},
// parameters.depthModeForSublayer(2, gfx::DepthMaskType::ReadOnly),
// *bucket.lineIndexBuffer,
// bucket.lineSegments,
// FillOutlinePatternProgram::TextureBindings{
// textures::image::Value{tile.getIconAtlasTexture().getResource(),
// gfx::TextureFilterType::Linear},
// });
// }
// }
}
}
}

5
src/mbgl/renderer/layers/render_fill_layer.hpp
View File

@@ -46,6 +46,9 @@ private:
const mat4&,
const FeatureState&) const override;
/// Remove all drawables for the tile from the layer group
void removeTile(RenderPass, const OverscaledTileID&);
// Paint properties
style::FillPaintProperties::Unevaluated unevaluated;
@@ -57,6 +60,8 @@ private:
gfx::ShaderProgramBasePtr fillShader;
gfx::ShaderProgramBasePtr outlineShader;
gfx::ShaderProgramBasePtr patternShader;
gfx::ShaderProgramBasePtr outlinePatternShader;
};
} // namespace mbgl