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

Share bucket indices (#1358)

Browse Source 
Co-authored-by: Stefan Karschti <stefan.karschti@gmail.com>
This commit is contained in:
Tim Sylvester
2023-07-13 12:45:54 -07:00
committed by Bart Louwers
parent 996b388601
commit 7f862cd8ff
26 changed files with 159 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
include/mbgl/gfx/drawable.hpp
View File

@@ -26,11 +26,13 @@ class CullFaceMode;
enum class DepthMaskType : bool;
class DrawableTweaker;
class DrawMode;
class IndexVectorBase;
class ShaderProgramBase;
class VertexAttributeArray;
using DrawPriority = int64_t;
using DrawableTweakerPtr = std::shared_ptr<DrawableTweaker>;
using IndexVectorBasePtr = std::shared_ptr<IndexVectorBase>;
using ShaderProgramBasePtr = std::shared_ptr<ShaderProgramBase>;
using Texture2DPtr = std::shared_ptr<Texture2D>;
@@ -155,8 +157,9 @@ public:
/// Incompatible with adding primitives
virtual void setVertices(std::vector<uint8_t>&&, std::size_t, AttributeDataType) = 0;
/// Create a segment wrapper
virtual void setIndexData(std::vector<std::uint16_t> indexes, std::vector<UniqueDrawSegment> segments) = 0;
/// Provide raw indexes and segments
void setIndexData(std::vector<std::uint16_t> indexes, std::vector<UniqueDrawSegment>);
virtual void setIndexData(gfx::IndexVectorBasePtr, std::vector<UniqueDrawSegment>) = 0;
/// Get the tweakers attached to this drawable
const std::vector<DrawableTweakerPtr>& getTweakers() const { return tweakers; }

4
include/mbgl/gfx/drawable_builder.hpp
View File

@@ -14,10 +14,12 @@ class SegmentBase;
namespace gfx {
class DrawableTweaker;
class IndexVectorBase;
class ShaderProgramBase;
class VertexAttributeArray;
using DrawableTweakerPtr = std::shared_ptr<DrawableTweaker>;
using IndexVectorBasePtr = std::shared_ptr<IndexVectorBase>;
using ShaderProgramBasePtr = std::shared_ptr<ShaderProgramBase>;
using Texture2DPtr = std::shared_ptr<Texture2D>;
@@ -137,8 +139,8 @@ public:
/// Incompatible with adding primitives
void setRawVertices(std::vector<uint8_t>&&, std::size_t, AttributeDataType);
void setSegments(gfx::DrawMode, std::vector<uint16_t> indexes, const std::vector<SegmentBase>&);
void setSegments(gfx::DrawMode, std::vector<uint16_t> indexes, const SegmentBase*, std::size_t segmentCount);
void setSegments(gfx::DrawMode, gfx::IndexVectorBasePtr, const SegmentBase*, std::size_t segmentCount);
/// Add lines based on existing vertices
void addLines(const std::vector<uint16_t>& indexes,

2
include/mbgl/gfx/drawable_impl.hpp
View File

@@ -1,6 +1,8 @@
#pragma once
#include <mbgl/gfx/draw_mode.hpp>
#include <mbgl/gfx/drawable.hpp>
#include <mbgl/programs/segment.hpp>
namespace mbgl {
namespace gfx {

4
include/mbgl/gl/drawable_gl.hpp
View File

@@ -19,7 +19,7 @@ class IndexBuffer;
class UploadPass;
class VertexBufferResource;
using UniqueVertexBufferResource = std::unique_ptr<gfx::VertexBufferResource>;
using UniqueVertexBufferResource = std::unique_ptr<VertexBufferResource>;
} // namespace gfx
@@ -36,7 +36,7 @@ public:
void draw(PaintParameters&) const override;
struct DrawSegmentGL;
void setIndexData(std::vector<std::uint16_t> indexes, std::vector<UniqueDrawSegment> segments) override;
void setIndexData(gfx::IndexVectorBasePtr, std::vector<UniqueDrawSegment> segments) override;
void setVertices(std::vector<uint8_t>&&, std::size_t, gfx::AttributeDataType) override;

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

@@ -2,6 +2,8 @@
#include <mbgl/gfx/color_mode.hpp>
#include <mbgl/gfx/cull_face_mode.hpp>
#include <mbgl/gfx/drawable_impl.hpp>
#include <mbgl/gfx/index_vector.hpp>
#include <mbgl/gfx/types.hpp>
#include <mbgl/renderer/render_pass.hpp>
@@ -37,6 +39,10 @@ void Drawable::setCullFaceMode(const gfx::CullFaceMode& value) {
impl->cullFaceMode = value;
}
void Drawable::setIndexData(std::vector<std::uint16_t> indexes, std::vector<UniqueDrawSegment> segments) {
setIndexData(std::make_shared<gfx::IndexVectorBase>(std::move(indexes)), std::move(segments));
}
static const gfx::Texture2DPtr noTexture;
const gfx::Texture2DPtr& Drawable::getTexture(int32_t location) const {

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

@@ -103,7 +103,8 @@ void DrawableBuilder::addTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1
impl->vertices.emplace_back(Impl::VT({{{x0, y0}}}));
impl->vertices.emplace_back(Impl::VT({{{x1, y1}}}));
impl->vertices.emplace_back(Impl::VT({{{x2, y2}}}));
impl->indexes.insert(impl->indexes.end(), {n, static_cast<uint16_t>(n + 1), static_cast<uint16_t>(n + 2)});
impl->buildIndexes.insert(impl->buildIndexes.end(),
{n, static_cast<uint16_t>(n + 1), static_cast<uint16_t>(n + 2)});
if (impl->segments.empty()) {
impl->segments.emplace_back(createSegment(gfx::Triangles(), {0, 0}));
@@ -116,7 +117,8 @@ void DrawableBuilder::addTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1
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->indexes.insert(impl->indexes.end(), {static_cast<uint16_t>(n - 2), static_cast<uint16_t>(n - 1), n});
impl->buildIndexes.insert(impl->buildIndexes.end(),
{static_cast<uint16_t>(n - 2), static_cast<uint16_t>(n - 1), n});
assert(!impl->segments.empty());
auto& segment = impl->segments.back();
@@ -153,17 +155,18 @@ void DrawableBuilder::setRawVertices(std::vector<uint8_t>&& data, std::size_t co
impl->rawVerticesType = type;
}
void DrawableBuilder::setSegments(gfx::DrawMode mode,
std::vector<uint16_t> indexes,
const std::vector<SegmentBase>& segments) {
setSegments(mode, std::move(indexes), segments.data(), segments.size());
}
void DrawableBuilder::setSegments(gfx::DrawMode mode,
void DrawableBuilder::setSegments(const gfx::DrawMode mode,
std::vector<uint16_t> indexes,
const SegmentBase* segments,
std::size_t segmentCount) {
impl->indexes = std::move(indexes);
const std::size_t segmentCount) {
setSegments(mode, std::make_shared<gfx::IndexVectorBase>(std::move(indexes)), segments, segmentCount);
}
void DrawableBuilder::setSegments(const gfx::DrawMode mode,
gfx::IndexVectorBasePtr indexes,
const SegmentBase* segments,
const std::size_t segmentCount) {
impl->sharedIndexes = std::move(indexes);
for (std::size_t i = 0; i < segmentCount; ++i) {
const auto& seg = segments[i];
#if !defined(NDEBUG)
@@ -174,10 +177,10 @@ void DrawableBuilder::setSegments(gfx::DrawMode mode,
}
const auto vertexCount = curVertexCount();
assert(!vertexCount || seg.vertexOffset + seg.vertexLength <= curVertexCount());
assert(seg.indexOffset + seg.indexLength <= impl->indexes.size());
assert(seg.indexOffset + seg.indexLength <= impl->sharedIndexes->elements());
if (vertexCount) {
for (decltype(seg.indexLength) j = 0; j < seg.indexLength; ++j) {
assert(impl->indexes[seg.indexOffset + j] < vertexCount);
assert(impl->sharedIndexes->vector()[seg.indexOffset + j] < vertexCount);
}
}
#endif
@@ -208,13 +211,13 @@ void DrawableBuilder::addLines(const std::vector<uint16_t>& indexes,
/*.vertexLength = */ 0,
/*.indexLength = */ indexLength}));
if (impl->indexes.empty()) {
impl->indexes.reserve(indexLength);
if (impl->buildIndexes.empty()) {
impl->buildIndexes.reserve(indexLength);
}
for (auto i = std::next(indexes.begin(), indexOffset); i != std::next(indexes.begin(), indexOffset + indexLength);
++i) {
impl->indexes.emplace_back(static_cast<uint16_t>(*i + baseIndex));
impl->buildIndexes.emplace_back(static_cast<uint16_t>(*i + baseIndex));
}
}
@@ -228,17 +231,17 @@ void DrawableBuilder::addTriangles(const std::vector<uint16_t>& indexes,
impl->segments.emplace_back(createSegment(Triangles(),
SegmentBase{/*.vertexOffset = */ 0,
/*.indexOffset = */ impl->indexes.size(),
/*.indexOffset = */ impl->buildIndexes.size(),
/*.vertexLength = */ impl->vertices.elements(),
/*.indexLength = */ indexLength}));
if (impl->indexes.empty()) {
impl->indexes.reserve(indexLength);
if (impl->buildIndexes.empty()) {
impl->buildIndexes.reserve(indexLength);
}
for (auto i = std::next(indexes.begin(), indexOffset); i != std::next(indexes.begin(), indexOffset + indexLength);
++i) {
impl->indexes.emplace_back(static_cast<uint16_t>(*i + baseIndex));
impl->buildIndexes.emplace_back(static_cast<uint16_t>(*i + baseIndex));
}
}

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

@@ -19,7 +19,8 @@ struct DrawableBuilder::Impl {
std::vector<uint8_t> rawVertices;
std::size_t rawVerticesCount = 0;
std::vector<uint16_t> indexes;
std::vector<uint16_t> buildIndexes;
std::shared_ptr<gfx::IndexVectorBase> sharedIndexes;
std::vector<std::unique_ptr<Drawable::DrawSegment>> segments;
AttributeDataType rawVerticesType = static_cast<AttributeDataType>(-1);

31
src/mbgl/gfx/index_vector.hpp
View File

@@ -8,16 +8,16 @@
namespace mbgl {
namespace gfx {
template <class DrawMode>
class IndexVector {
public:
static constexpr std::size_t groupSize = BufferGroupSizeOf<DrawMode>::value;
class IndexVectorBase {
protected:
std::vector<uint16_t> v;
template <class... Args>
void emplace_back(Args&&... args) {
static_assert(sizeof...(args) == groupSize, "wrong buffer element count");
util::ignore({(v.emplace_back(std::forward<Args>(args)), 0)...});
}
public:
using value_type = decltype(v)::value_type;
IndexVectorBase() = default;
IndexVectorBase(std::vector<uint16_t>&& indexes)
: v(std::move(indexes)) {}
std::size_t elements() const { return v.size(); }
@@ -30,9 +30,18 @@ public:
const uint16_t* data() const { return v.data(); }
const std::vector<uint16_t>& vector() const { return v; }
};
private:
std::vector<uint16_t> v;
template <class DrawMode>
class IndexVector : public IndexVectorBase {
public:
static constexpr std::size_t groupSize = BufferGroupSizeOf<DrawMode>::value;
template <class... Args>
void emplace_back(Args&&... args) {
static_assert(sizeof...(args) == groupSize, "wrong buffer element count");
util::ignore({(v.emplace_back(std::forward<Args>(args)), 0)...});
}
};
} // namespace gfx

8
src/mbgl/gl/drawable_gl.cpp
View File

@@ -72,7 +72,7 @@ void DrawableGL::draw(PaintParameters& parameters) const {
unbindUniformBuffers();
}
void DrawableGL::setIndexData(std::vector<std::uint16_t> indexes, std::vector<UniqueDrawSegment> segments) {
void DrawableGL::setIndexData(gfx::IndexVectorBasePtr indexes, std::vector<UniqueDrawSegment> segments) {
impl->indexes = std::move(indexes);
impl->segments = std::move(segments);
}
@@ -151,9 +151,9 @@ void DrawableGL::upload(gfx::UploadPass& uploadPass) {
auto& glContext = static_cast<gl::Context&>(context);
constexpr auto usage = gfx::BufferUsageType::StaticDraw;
const auto indexBytes = impl->indexes.size() * sizeof(decltype(impl->indexes)::value_type);
auto indexBufferResource = uploadPass.createIndexBufferResource(impl->indexes.data(), indexBytes, usage);
auto indexBuffer = gfx::IndexBuffer{impl->indexes.size(), std::move(indexBufferResource)};
const auto indexBytes = impl->indexes->elements() * sizeof(gfx::IndexVectorBase::value_type);
auto indexBufferResource = uploadPass.createIndexBufferResource(impl->indexes->data(), indexBytes, usage);
auto indexBuffer = gfx::IndexBuffer{impl->indexes->elements(), std::move(indexBufferResource)};
// Apply drawable values to shader defaults
const auto& defaults = shader->getVertexAttributes();

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

@@ -35,9 +35,12 @@ void DrawableGLBuilder::init() {
drawableGL.setVertices(std::move(raw), verts.size(), gfx::AttributeDataType::Short2);
}
drawableGL.setIndexData(std::move(impl->indexes), std::move(impl->segments));
if (!impl->sharedIndexes && !impl->buildIndexes.empty()) {
impl->sharedIndexes = std::make_shared<gfx::IndexVectorBase>(std::move(impl->buildIndexes));
}
drawableGL.setIndexData(std::move(impl->sharedIndexes), std::move(impl->segments));
impl->indexes.clear();
impl->buildIndexes.clear();
impl->segments.clear();
impl->vertices.clear();
}

2
src/mbgl/gl/drawable_gl_impl.hpp
View File

@@ -32,7 +32,7 @@ public:
std::vector<TextureID> textures;
std::vector<std::uint16_t> indexes;
gfx::IndexVectorBasePtr indexes;
std::vector<std::uint8_t> vertexData;
std::size_t vertexCount = 0;

7
src/mbgl/renderer/buckets/circle_bucket.hpp
View File

@@ -31,10 +31,13 @@ public:
void update(const FeatureStates&, const GeometryTileLayer&, const std::string&, const ImagePositions&) override;
using VertexVector = gfx::VertexVector<CircleLayoutVertex>;
std::shared_ptr<VertexVector> sharedVertices = std::make_shared<VertexVector>();
const std::shared_ptr<VertexVector> sharedVertices = std::make_shared<VertexVector>();
VertexVector& vertices = *sharedVertices;
gfx::IndexVector<gfx::Triangles> triangles;
using TriangleIndexVector = gfx::IndexVector<gfx::Triangles>;
const std::shared_ptr<TriangleIndexVector> sharedTriangles = std::make_shared<TriangleIndexVector>();
TriangleIndexVector& triangles = *sharedTriangles;
SegmentVector<CircleAttributes> segments;
#if MLN_LEGACY_RENDERER

12
src/mbgl/renderer/buckets/fill_bucket.hpp
View File

@@ -41,11 +41,17 @@ public:
void update(const FeatureStates&, const GeometryTileLayer&, const std::string&, const ImagePositions&) override;
using VertexVector = gfx::VertexVector<FillLayoutVertex>;
std::shared_ptr<VertexVector> sharedVertices = std::make_shared<VertexVector>();
const std::shared_ptr<VertexVector> sharedVertices = std::make_shared<VertexVector>();
VertexVector& vertices = *sharedVertices;
gfx::IndexVector<gfx::Lines> lines;
gfx::IndexVector<gfx::Triangles> triangles;
using LineIndexVector = gfx::IndexVector<gfx::Lines>;
const std::shared_ptr<LineIndexVector> sharedLines = std::make_shared<LineIndexVector>();
LineIndexVector& lines = *sharedLines;
using TriangleIndexVector = gfx::IndexVector<gfx::Triangles>;
const std::shared_ptr<TriangleIndexVector> sharedTriangles = std::make_shared<TriangleIndexVector>();
TriangleIndexVector& triangles = *sharedTriangles;
SegmentVector<FillAttributes> lineSegments;
SegmentVector<FillAttributes> triangleSegments;

7
src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp
View File

@@ -40,10 +40,13 @@ public:
void update(const FeatureStates&, const GeometryTileLayer&, const std::string&, const ImagePositions&) override;
using VertexVector = gfx::VertexVector<FillExtrusionLayoutVertex>;
std::shared_ptr<VertexVector> sharedVertices = std::make_shared<VertexVector>();
const std::shared_ptr<VertexVector> sharedVertices = std::make_shared<VertexVector>();
VertexVector& vertices = *sharedVertices;
gfx::IndexVector<gfx::Triangles> triangles;
using TriangleIndexVector = gfx::IndexVector<gfx::Triangles>;
const std::shared_ptr<TriangleIndexVector> sharedTriangles = std::make_shared<TriangleIndexVector>();
TriangleIndexVector& triangles = *sharedTriangles;
SegmentVector<FillExtrusionAttributes> triangleSegments;
#if MLN_LEGACY_RENDERER

7
src/mbgl/renderer/buckets/heatmap_bucket.hpp
View File

@@ -31,10 +31,13 @@ public:
float getQueryRadius(const RenderLayer&) const override;
using VertexVector = gfx::VertexVector<HeatmapLayoutVertex>;
std::shared_ptr<VertexVector> sharedVertices = std::make_shared<VertexVector>();
const std::shared_ptr<VertexVector> sharedVertices = std::make_shared<VertexVector>();
VertexVector& vertices = *sharedVertices;
gfx::IndexVector<gfx::Triangles> triangles;
using TriangleIndexVector = gfx::IndexVector<gfx::Triangles>;
const std::shared_ptr<TriangleIndexVector> sharedTriangles = std::make_shared<TriangleIndexVector>();
TriangleIndexVector& triangles = *sharedTriangles;
SegmentVector<HeatmapAttributes> segments;
#if MLN_LEGACY_RENDERER

7
src/mbgl/renderer/buckets/line_bucket.hpp
View File

@@ -43,10 +43,13 @@ public:
PossiblyEvaluatedLayoutProperties layout;
using VertexVector = gfx::VertexVector<LineLayoutVertex>;
std::shared_ptr<VertexVector> sharedVertices = std::make_shared<VertexVector>();
const std::shared_ptr<VertexVector> sharedVertices = std::make_shared<VertexVector>();
VertexVector& vertices = *sharedVertices;
gfx::IndexVector<gfx::Triangles> triangles;
using TriangleIndexVector = gfx::IndexVector<gfx::Triangles>;
const std::shared_ptr<TriangleIndexVector> sharedTriangles = std::make_shared<TriangleIndexVector>();
TriangleIndexVector& triangles = *sharedTriangles;
SegmentVector<LineAttributes> segments;
#if MLN_LEGACY_RENDERER

10
src/mbgl/renderer/buckets/raster_bucket.hpp
View File

@@ -32,8 +32,14 @@ public:
// Bucket specific vertices are used for Image Sources only
// Raster Tile Sources use the default buffers from Painter
gfx::VertexVector<RasterLayoutVertex> vertices;
gfx::IndexVector<gfx::Triangles> indices;
using VertexVector = gfx::VertexVector<RasterLayoutVertex>;
const std::shared_ptr<VertexVector> sharedVertices = std::make_shared<VertexVector>();
VertexVector& vertices = *sharedVertices;
using TriangleIndexVector = gfx::IndexVector<gfx::Triangles>;
const std::shared_ptr<TriangleIndexVector> sharedTriangles = std::make_shared<TriangleIndexVector>();
TriangleIndexVector& indices = *sharedTriangles;
SegmentVector<RasterAttributes> segments;
#if MLN_LEGACY_RENDERER

5
src/mbgl/renderer/buckets/symbol_bucket.hpp
View File

@@ -158,7 +158,10 @@ public:
OpacityVertexVector& opacityVertices() { return *sharedOpacityVertices; }
const OpacityVertexVector& opacityVertices() const { return *sharedOpacityVertices; }
gfx::IndexVector<gfx::Triangles> triangles;
using TriangleIndexVector = gfx::IndexVector<gfx::Triangles>;
const std::shared_ptr<TriangleIndexVector> sharedTriangles = std::make_shared<TriangleIndexVector>();
TriangleIndexVector& triangles = *sharedTriangles;
SegmentVector<SymbolTextAttributes> segments;
std::vector<PlacedSymbol> placedSymbols;

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

@@ -403,7 +403,7 @@ void RenderCircleLayer::update(gfx::ShaderRegistry& shaders,
circleBuilder->setRawVertices({}, vertexCount, gfx::AttributeDataType::Short2);
circleBuilder->setSegments(
gfx::Triangles(), bucket.triangles.vector(), bucket.segments.data(), bucket.segments.size());
gfx::Triangles(), bucket.sharedTriangles, bucket.segments.data(), bucket.segments.size());
circleBuilder->flush();

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

@@ -458,14 +458,14 @@ void RenderFillExtrusionLayer::update(gfx::ShaderRegistry& shaders,
if (const auto& attr = vertexAttrs.getOrAdd(PosAttribName)) {
attr->setSharedRawData(bucket.sharedVertices,
offsetof(FillExtrusionLayoutVertex, a1),
0,
/*vertexOffset=*/0,
sizeof(FillExtrusionLayoutVertex),
gfx::AttributeDataType::Short2);
}
if (const auto& attr = vertexAttrs.getOrAdd(NormAttribName)) {
attr->setSharedRawData(bucket.sharedVertices,
offsetof(FillExtrusionLayoutVertex, a2),
0,
/*vertexOffset=*/0,
sizeof(FillExtrusionLayoutVertex),
gfx::AttributeDataType::Short4);
}
@@ -484,7 +484,7 @@ void RenderFillExtrusionLayer::update(gfx::ShaderRegistry& shaders,
const auto finish = [&](gfx::DrawableBuilder& builder) {
builder.setSegments(gfx::Triangles(),
bucket.triangles.vector(),
bucket.sharedTriangles,
bucket.triangleSegments.data(),
bucket.triangleSegments.size());

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

@@ -420,7 +420,7 @@ void RenderFillLayer::update(gfx::ShaderRegistry& shaders,
if (const auto& attr = vertexAttrs.add(PosAttribName)) {
attr->setSharedRawData(bucket.sharedVertices,
offsetof(FillLayoutVertex, a1),
0,
/*vertexOffset=*/0,
sizeof(FillLayoutVertex),
gfx::AttributeDataType::Short2);
}
@@ -484,7 +484,7 @@ void RenderFillLayer::update(gfx::ShaderRegistry& shaders,
}
fillBuilder->setRawVertices({}, vertexCount, gfx::AttributeDataType::Short2);
fillBuilder->setSegments(gfx::Triangles(),
bucket.triangles.vector(),
bucket.sharedTriangles,
bucket.triangleSegments.data(),
bucket.triangleSegments.size());
finish(*fillBuilder, tileID, interpolateUBO, tileProps);
@@ -494,7 +494,7 @@ void RenderFillLayer::update(gfx::ShaderRegistry& shaders,
outlineBuilder->setVertexAttributes(std::move(vertexAttrs));
outlineBuilder->setRawVertices({}, vertexCount, gfx::AttributeDataType::Short2);
outlineBuilder->setSegments(
gfx::Lines(2), bucket.lines.vector(), bucket.lineSegments.data(), bucket.lineSegments.size());
gfx::Lines(2), bucket.sharedLines, bucket.lineSegments.data(), bucket.lineSegments.size());
finish(*outlineBuilder, tileID, interpolateUBO, tileProps);
}
} else { // FillPattern is defined
@@ -565,7 +565,7 @@ void RenderFillLayer::update(gfx::ShaderRegistry& shaders,
}
patternBuilder->setRawVertices({}, vertexCount, gfx::AttributeDataType::Short2);
patternBuilder->setSegments(gfx::Triangles(),
bucket.triangles.vector(),
bucket.sharedTriangles,
bucket.triangleSegments.data(),
bucket.triangleSegments.size());
@@ -577,7 +577,7 @@ void RenderFillLayer::update(gfx::ShaderRegistry& shaders,
outlinePatternBuilder->setVertexAttributes(std::move(vertexAttrs));
outlinePatternBuilder->setRawVertices({}, vertexCount, gfx::AttributeDataType::Short2);
outlinePatternBuilder->setSegments(
gfx::Lines(2), bucket.lines.vector(), bucket.lineSegments.data(), bucket.lineSegments.size());
gfx::Lines(2), bucket.sharedLines, bucket.lineSegments.data(), bucket.lineSegments.size());
finish(*outlinePatternBuilder, tileID, interpolateUBO, tileProps);
}

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

@@ -391,7 +391,7 @@ void RenderHeatmapLayer::update(gfx::ShaderRegistry& shaders,
if (const auto& attr = heatmapVertexAttrs.add(VertexAttribName)) {
attr->setSharedRawData(bucket.sharedVertices,
offsetof(HeatmapLayoutVertex, a1),
0,
/*vertexOffset=*/0,
sizeof(HeatmapLayoutVertex),
gfx::AttributeDataType::Short2);
}
@@ -406,7 +406,7 @@ void RenderHeatmapLayer::update(gfx::ShaderRegistry& shaders,
heatmapBuilder->setVertexAttributes(std::move(heatmapVertexAttrs));
heatmapBuilder->setRawVertices({}, vertexCount, gfx::AttributeDataType::Short2);
heatmapBuilder->setSegments(
gfx::Triangles(), bucket.triangles.vector(), bucket.segments.data(), bucket.segments.size());
gfx::Triangles(), bucket.sharedTriangles, bucket.segments.data(), bucket.segments.size());
heatmapBuilder->flush();
@@ -451,7 +451,7 @@ void RenderHeatmapLayer::update(gfx::ShaderRegistry& shaders,
if (const auto& attr = textureVertexAttrs.add(VertexAttribName)) {
attr->setSharedRawData(sharedTextureVertices,
offsetof(HeatmapLayoutVertex, a1),
0,
/*vertexOffset=*/0,
sizeof(HeatmapLayoutVertex),
gfx::AttributeDataType::Short2);
}

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

@@ -471,7 +471,7 @@ void RenderHillshadeLayer::update(gfx::ShaderRegistry& shaders,
};
drawSegments.emplace_back(hillshadeBuilder->createSegment(gfx::Triangles(), std::move(segCopy)));
}
drawable.setIndexData(std::move(indices->vector()), std::move(drawSegments));
drawable.setIndexData(indices->vector(), std::move(drawSegments));
auto imageLocation = hillshadeShader->getSamplerLocation("u_image");
if (imageLocation.has_value()) {

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

@@ -485,7 +485,7 @@ void RenderLineLayer::update(gfx::ShaderRegistry& shaders,
if (const auto& attr = vertexAttrs.add(VertexAttribName)) {
attr->setSharedRawData(bucket.sharedVertices,
offsetof(LineLayoutVertex, a1),
0,
/*vertexOffset=*/0,
sizeof(LineLayoutVertex),
gfx::AttributeDataType::Short2);
}
@@ -493,7 +493,7 @@ void RenderLineLayer::update(gfx::ShaderRegistry& shaders,
if (const auto& attr = vertexAttrs.add(DataAttribName)) {
attr->setSharedRawData(bucket.sharedVertices,
offsetof(LineLayoutVertex, a2),
0,
/*vertexOffset=*/0,
sizeof(LineLayoutVertex),
gfx::AttributeDataType::UByte4);
}
@@ -502,8 +502,7 @@ void RenderLineLayer::update(gfx::ShaderRegistry& shaders,
};
auto setSegments = [&](std::unique_ptr<gfx::DrawableBuilder>& builder, const LineBucket& bucket) {
builder->setSegments(
gfx::Triangles(), bucket.triangles.vector(), bucket.segments.data(), bucket.segments.size());
builder->setSegments(gfx::Triangles(), bucket.sharedTriangles, bucket.segments.data(), bucket.segments.size());
};
for (const RenderTile& tile : *renderTiles) {

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

@@ -299,6 +299,12 @@ void RenderRasterLayer::update(gfx::ShaderRegistry& shaders,
std::vector<SegmentBase>& segments) {
constexpr const uint16_t vertexLength = 4;
if (vertices.empty()) {
vertices.reserve(mask.size() * vertexLength);
attributes.reserve(mask.size() * vertexLength);
indices.reserve(mask.size() * 6);
segments.reserve(mask.size());
}
// Create the vertex buffer for the specified tile mask.
for (const auto& id : mask) {
// Create a quad for every masked tile.
@@ -334,11 +340,12 @@ void RenderRasterLayer::update(gfx::ShaderRegistry& shaders,
// 0, 1, 2
// 1, 2, 3
indices.insert(indices.end(),
{offset, static_cast<uint16_t>(offset + 1), static_cast<uint16_t>(offset + 2u)});
indices.insert(indices.end(),
{static_cast<uint16_t>(offset + 1),
static_cast<uint16_t>(offset + 2),
static_cast<uint16_t>(offset + 3)});
{offset,
static_cast<uint16_t>(offset + 1u),
static_cast<uint16_t>(offset + 2u),
static_cast<uint16_t>(offset + 1u),
static_cast<uint16_t>(offset + 2u),
static_cast<uint16_t>(offset + 3u)});
segment.vertexLength += vertexLength;
segment.indexLength += 6;
@@ -350,14 +357,15 @@ void RenderRasterLayer::update(gfx::ShaderRegistry& shaders,
std::vector<SegmentBase> segments;
buildRenderData(bucket.mask, vertices, attributes, indices, segments);
builder->addVertices(vertices, 0, vertices.size());
builder->setSegments(gfx::Triangles(), indices, segments);
builder->setSegments(gfx::Triangles(), indices, segments.data(), segments.size());
// attributes
{
gfx::VertexAttributeArray vertexAttrs;
if (auto& attr = vertexAttrs.getOrAdd("a_texture_pos")) {
if (const auto& attr = vertexAttrs.getOrAdd("a_texture_pos")) {
attr->reserve(attributes.size());
std::size_t index{0};
for (auto& a : attributes) {
for (const auto& a : attributes) {
attr->set<gfx::VertexAttribute::int2>(index++, {a[0], a[1]});
}
}
@@ -369,18 +377,18 @@ void RenderRasterLayer::update(gfx::ShaderRegistry& shaders,
};
auto buildImageDrawables = [&setTextures](std::unique_ptr<gfx::DrawableBuilder>& builder, RasterBucket& bucket) {
std::vector<std::array<int16_t, 2>> vertices(bucket.vertices.vector().size());
std::transform(
bucket.vertices.vector().begin(), bucket.vertices.vector().end(), vertices.begin(), [](const auto& x) {
return x.a1;
});
builder->addVertices(vertices, 0, vertices.size());
builder->setSegments(gfx::Triangles(), bucket.indices.vector(), bucket.segments.data(), bucket.segments.size());
// attributes
{
gfx::VertexAttributeArray vertexAttrs;
if (auto& attr = vertexAttrs.add("a_pos")) {
attr->setSharedRawData(bucket.sharedVertices,
offsetof(RasterLayoutVertex, a1),
/*vertexOffset=*/0,
sizeof(RasterLayoutVertex),
gfx::AttributeDataType::Short2);
}
if (auto& attr = vertexAttrs.getOrAdd("a_texture_pos")) {
std::size_t index{0};
for (auto& v : bucket.vertices.vector()) {
@@ -390,6 +398,9 @@ void RenderRasterLayer::update(gfx::ShaderRegistry& shaders,
builder->setVertexAttributes(std::move(vertexAttrs));
}
builder->setRawVertices({}, bucket.vertices.elements(), gfx::AttributeDataType::Short2);
builder->setSegments(gfx::Triangles(), bucket.sharedTriangles, bucket.segments.data(), bucket.segments.size());
// textures
setTextures(builder, bucket);
};

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

@@ -1037,8 +1037,7 @@ void RenderSymbolLayer::update(gfx::ShaderRegistry& shaders,
// !partiallyEvaluatedTextSize.isZoomConstant; const auto filterType = linear ?
// gfx::TextureFilterType::Linear : gfx::TextureFilterType::Nearest;
auto indexes = buffer.triangles.vector();
builder->setSegments(gfx::Triangles(), std::move(indexes), &renderable.segment.get(), 1);
builder->setSegments(gfx::Triangles(), buffer.sharedTriangles, &renderable.segment.get(), 1);
builder->flush();