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

refs #928: bookmarking working build of refactor

Browse Source
This commit is contained in:
Justin R. Miller
2015-03-04 13:37:03 -08:00
committed by John Firebaugh
parent 831264d530
commit 41c3b82d3e
13 changed files with 234 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/mbgl/geometry/geometry.hpp → src/mbgl/geometry/pbf_geometry.hpp
View File

@@ -1,5 +1,5 @@
#ifndef MBGL_GEOMETRY_GEOMETRY
#define MBGL_GEOMETRY_GEOMETRY
#ifndef MBGL_GEOMETRY_PBF_GEOMETRY
#define MBGL_GEOMETRY_PBF_GEOMETRY
#include <mbgl/util/pbf.hpp>
#include <mbgl/util/noncopyable.hpp>
@@ -8,10 +8,10 @@
namespace mbgl {
class Geometry : private util::noncopyable {
class PBFGeometry : private util::noncopyable {
public:
inline explicit Geometry(pbf& data);
inline explicit PBFGeometry(pbf& data);
enum command : uint8_t {
end = 0,
@@ -30,14 +30,14 @@ private:
int32_t ox, oy;
};
Geometry::Geometry(pbf& data_)
PBFGeometry::PBFGeometry(pbf& data_)
: data(data_),
cmd(1),
length(0),
x(0), y(0),
ox(0), oy(0) {}
Geometry::command Geometry::next(int32_t &rx, int32_t &ry) {
PBFGeometry::command PBFGeometry::next(int32_t &rx, int32_t &ry) {
if (data.data < data.end) {
if (length == 0) {
uint32_t cmd_length = static_cast<uint32_t>(data.varint());

36
src/mbgl/map/geometry_tile.cpp
View File

@@ -15,15 +15,39 @@ std::ostream& mbgl::operator<<(std::ostream& os, const GeometryFeatureType& type
}
}
GeometryTileFeature::GeometryTileFeature() {}
Geometry GeometryTileFeature::nextGeometry() {
Geometry result;
result.set<std::false_type>();
return result;
}
std::ostream& mbgl::operator<<(std::ostream& os, const GeometryTileFeature& feature) {
os << "Feature(" << feature.id << "): " << feature.type << std::endl;
for (const auto& prop : feature.properties) {
os << " - " << prop.first << ": " << prop.second << std::endl;
}
return os;
}
GeometryFilteredTileLayer::GeometryFilteredTileLayer(const GeometryTileLayer& layer_, const FilterExpression& filterExpression_)
: layer(layer_),
filterExpression(filterExpression_) {}
GeometryTileFeature GeometryFilteredTileLayer::nextMatchingFeature() {
GeometryTileFeature result;
result.type = GeometryFeatureType::Unknown;
return result;
}
GeometryTileFeature GeometryTileLayer::nextFeature() {
return GeometryTileFeature();
}
GeometryTile& GeometryTile::operator=(GeometryTile&& other) {
if (this != &other) {
layers.swap(other.layers);
}
return *this;
}
template <typename T>
GeometryFilteredTileLayer<T>::iterator::iterator(const GeometryFilteredTileLayer<T>& parent_)
: parent(parent_) {
operator++();
}

56
src/mbgl/map/geometry_tile.hpp
View File

@@ -5,18 +5,19 @@
#include <mbgl/style/value.hpp>
#include <mbgl/text/glyph.hpp>
#include <mbgl/util/optional.hpp>
#include <mbgl/util/variant.hpp>
#include <mbgl/util/vec.hpp>
#include <cstdint>
#include <iosfwd>
#include <map>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <vector>
namespace mbgl {
class GeometryTileLayer;
enum class GeometryFeatureType {
Unknown = 0,
Point = 1,
@@ -24,58 +25,54 @@ enum class GeometryFeatureType {
Polygon = 3
};
typedef Coordinate GeometryPoint;
typedef std::vector<GeometryPoint> GeometryLine;
typedef std::vector<GeometryLine> GeometryPolygon;
using Geometry = mapbox::util::variant<std::false_type, GeometryPoint, GeometryLine, GeometryPolygon>;
std::ostream& operator<<(std::ostream&, const GeometryFeatureType& type);
template <typename T>
class GeometryTileLayer;
class GeometryTileFeature {
public:
GeometryTileFeature();
virtual Geometry nextGeometry();
public:
uint64_t id = 0;
GeometryFeatureType type = GeometryFeatureType::Unknown;
std::map<std::string, Value> properties;
T geometries;
};
template <typename T>
std::ostream& operator<<(std::ostream&, const GeometryTileFeature<T>& feature);
std::ostream& operator<<(std::ostream&, const GeometryTileFeature& feature);
template <typename T>
class GeometryTileTagExtractor {
public:
GeometryTileTagExtractor(const GeometryTileLayer&);
void setTags(const T&);
virtual mapbox::util::optional<Value> getValue(const std::string &key) const;
inline void setTags(const T& tags_) { tags = tags_; }
mapbox::util::optional<Value> getValue(const std::string &key) const;
inline void setType(GeometryFeatureType type_) { type = type_; }
GeometryFeatureType getType() const { return type; }
inline GeometryFeatureType getType() const { return type; }
protected:
const GeometryTileLayer &layer;
const GeometryTileLayer& layer;
T tags;
GeometryFeatureType type = GeometryFeatureType::Unknown;
};
template <typename T>
class GeometryFilteredTileLayer {
public:
class iterator {
public:
iterator(const GeometryFilteredTileLayer&);
virtual void operator++();
virtual bool operator!=(const iterator& other) const;
virtual const T& operator*() const;
protected:
const GeometryFilteredTileLayer& parent;
bool valid = false;
};
public:
GeometryFilteredTileLayer(const GeometryTileLayer&, const FilterExpression&);
iterator begin() const;
iterator end() const;
virtual GeometryTileFeature nextMatchingFeature();
public:
protected:
const GeometryTileLayer& layer;
const FilterExpression& filterExpression;
};
@@ -83,6 +80,9 @@ public:
std::ostream& operator<<(std::ostream&, const PositionedGlyph&);
class GeometryTileLayer {
public:
virtual GeometryTileFeature nextFeature();
public:
std::string name;
uint32_t extent = 4096;

28
src/mbgl/map/tile_parser.cpp
View File

@@ -189,7 +189,7 @@ std::unique_ptr<Bucket> TileParser::createBucket(const StyleBucket &bucketDesc)
auto layer_it = vectorTile.layers.find(bucketDesc.source_layer);
if (layer_it != vectorTile.layers.end()) {
const VectorTileLayer &layer = layer_it->second;
const GeometryTileLayer &layer = layer_it->second;
if (bucketDesc.type == StyleLayerType::Fill) {
return createFillBucket(layer, bucketDesc);
} else if (bucketDesc.type == StyleLayerType::Line) {
@@ -213,24 +213,24 @@ std::unique_ptr<Bucket> TileParser::createBucket(const StyleBucket &bucketDesc)
}
template <class Bucket>
void TileParser::addBucketGeometries(Bucket& bucket, const VectorTileLayer& layer, const FilterExpression &filter) {
FilteredVectorTileLayer filtered_layer(layer, filter);
for (pbf feature : filtered_layer) {
void TileParser::addBucketGeometries(Bucket& bucket, const GeometryTileLayer& layer, const FilterExpression &filter) {
GeometryFilteredTileLayer filtered_layer(layer, filter);
GeometryTileFeature feature = filtered_layer.nextMatchingFeature();
while (feature.type != GeometryFeatureType::Unknown) {
if (obsolete())
return;
while (feature.next(4)) { // geometry
pbf geometry_pbf = feature.message();
if (geometry_pbf) {
bucket->addGeometry(geometry_pbf);
} else if (debug::tileParseWarnings) {
fprintf(stderr, "[WARNING] geometry is empty\n");
}
Geometry geometry = feature.nextGeometry();
while (!geometry.is<std::false_type>()) {
bucket->addGeometry(geometry);
geometry = feature.nextGeometry();
}
feature = filtered_layer.nextMatchingFeature();
}
}
std::unique_ptr<Bucket> TileParser::createFillBucket(const VectorTileLayer &layer,
std::unique_ptr<Bucket> TileParser::createFillBucket(const GeometryTileLayer &layer,
const StyleBucket &bucket_desc) {
auto fill = parseStyleLayoutFill(bucket_desc, tile.id.z);
auto bucket = util::make_unique<FillBucket>(std::move(fill),
@@ -241,7 +241,7 @@ std::unique_ptr<Bucket> TileParser::createFillBucket(const VectorTileLayer &laye
return obsolete() ? nullptr : std::move(bucket);
}
std::unique_ptr<Bucket> TileParser::createLineBucket(const VectorTileLayer &layer,
std::unique_ptr<Bucket> TileParser::createLineBucket(const GeometryTileLayer &layer,
const StyleBucket &bucket_desc) {
auto line = parseStyleLayoutLine(bucket_desc, tile.id.z);
auto bucket = util::make_unique<LineBucket>(std::move(line),
@@ -252,7 +252,7 @@ std::unique_ptr<Bucket> TileParser::createLineBucket(const VectorTileLayer &laye
return obsolete() ? nullptr : std::move(bucket);
}
std::unique_ptr<Bucket> TileParser::createSymbolBucket(const VectorTileLayer &layer,
std::unique_ptr<Bucket> TileParser::createSymbolBucket(const GeometryTileLayer &layer,
const StyleBucket &bucket_desc) {
auto symbol = parseStyleLayoutSymbol(bucket_desc, tile.id.z);
auto bucket = util::make_unique<SymbolBucket>(std::move(symbol), *collision);

9
src/mbgl/map/tile_parser.hpp
View File

@@ -1,6 +1,7 @@
#ifndef MBGL_MAP_TILE_PARSER
#define MBGL_MAP_TILE_PARSER
#include <mbgl/map/geometry_tile.hpp>
#include <mbgl/map/vector_tile.hpp>
#include <mbgl/style/filter_expression.hpp>
#include <mbgl/style/class_properties.hpp>
@@ -52,11 +53,11 @@ private:
void parseStyleLayers(util::ptr<const StyleLayerGroup> group);
std::unique_ptr<Bucket> createBucket(const StyleBucket& bucketDesc);
std::unique_ptr<Bucket> createFillBucket(const VectorTileLayer& layer, const StyleBucket& bucketDesc);
std::unique_ptr<Bucket> createLineBucket(const VectorTileLayer& layer, const StyleBucket& bucketDesc);
std::unique_ptr<Bucket> createSymbolBucket(const VectorTileLayer& layer, const StyleBucket& bucketDesc);
std::unique_ptr<Bucket> createFillBucket(const GeometryTileLayer& layer, const StyleBucket& bucketDesc);
std::unique_ptr<Bucket> createLineBucket(const GeometryTileLayer& layer, const StyleBucket& bucketDesc);
std::unique_ptr<Bucket> createSymbolBucket(const GeometryTileLayer& layer, const StyleBucket& bucketDesc);
template <class Bucket> void addBucketGeometries(Bucket& bucket, const VectorTileLayer& layer, const FilterExpression& filter);
template <class Bucket> void addBucketGeometries(Bucket& bucket, const GeometryTileLayer& layer, const FilterExpression& filter);
private:
const VectorTile vectorTile;

180
src/mbgl/map/vector_tile.cpp
View File

@@ -1,18 +1,20 @@
#include <mbgl/map/vector_tile.hpp>
#include <mbgl/geometry/pbf_geometry.hpp>
#include <mbgl/style/filter_expression_private.hpp>
#include <mbgl/util/variant_io.hpp>
#include <type_traits>
#include <ostream>
using namespace mbgl;
VectorTileFeature::VectorTileFeature(pbf feature, const VectorTileLayer& layer) {
while (feature.next()) {
if (feature.tag == 1) { // id
id = feature.varint<uint64_t>();
} else if (feature.tag == 2) { // tags
VectorTileFeature::VectorTileFeature(pbf feature_pbf, const GeometryTileLayer& layer) {
while (feature_pbf.next()) {
if (feature_pbf.tag == 1) { // id
id = feature_pbf.varint<uint64_t>();
} else if (feature_pbf.tag == 2) { // tags
// tags are packed varints. They should have an even length.
pbf tags = feature.message();
pbf tags = feature_pbf.message();
while (tags) {
uint32_t tag_key = tags.varint();
@@ -31,22 +33,64 @@ VectorTileFeature::VectorTileFeature(pbf feature, const VectorTileLayer& layer)
throw std::runtime_error("uneven number of feature tag ids");
}
}
} else if (feature.tag == 3) { // type
type = (GeometryFeatureType)feature.varint();
} else if (feature.tag == 4) { // geometry
geometries = feature.message();
} else if (feature_pbf.tag == 3) { // type
type = (GeometryFeatureType)feature_pbf.varint();
} else if (feature_pbf.tag == 4) { // geometry
geometry_pbf = feature_pbf.message();
} else {
feature.skip();
feature_pbf.skip();
}
}
}
std::ostream& mbgl::operator<<(std::ostream& os, const GeometryTileFeature<pbf>& feature) {
os << "Feature(" << feature.id << "): " << feature.type << std::endl;
for (const auto& prop : feature.properties) {
os << " - " << prop.first << ": " << prop.second << std::endl;
Geometry VectorTileFeature::nextGeometry() {
pbf current_geometry_pbf = geometry_pbf.message();
PBFGeometry current_geometry(current_geometry_pbf);
int32_t x, y;
Geometry result;
result.set<std::false_type>();
if (multigeometry || geometry_pbf.next(4)) {
if (type == GeometryFeatureType::Point) {
current_geometry.next(x, y);
GeometryPoint point(x, y);
result.set<GeometryPoint>(point);
} else if (type == GeometryFeatureType::LineString) {
GeometryLine line;
PBFGeometry::command cmd;
while ((cmd = current_geometry.next(x, y)) != PBFGeometry::end) {
if (cmd == PBFGeometry::move_to) {
multigeometry = true;
result.set<GeometryLine>(line);
break;
} else {
line.emplace_back(x, y);
}
}
if (!multigeometry) {
result.set<GeometryLine>(line);
}
} else if (type == GeometryFeatureType::Polygon) {
GeometryPolygon polygon;
PBFGeometry::command cmd;
while ((cmd = current_geometry.next(x, y)) != PBFGeometry::end) {
if (cmd == PBFGeometry::move_to) {
multigeometry = true;
result.set<GeometryPolygon>(polygon);
break;
} else {
// polygon.emplace_back(x, y);
}
}
if (!multigeometry) {
result.set<GeometryPolygon>(polygon);
}
} else {
throw std::runtime_error("unrecognized geometry type");
}
}
return os;
return std::move(result);
}
VectorTile::VectorTile(pbf tile) {
@@ -60,51 +104,34 @@ VectorTile::VectorTile(pbf tile) {
}
}
VectorTileLayer::VectorTileLayer(pbf layer) : layer_pbf(layer) {
while (layer.next()) {
if (layer.tag == 1) { // name
name = layer.string();
} else if (layer.tag == 3) { // keys
keys.emplace_back(layer.string());
VectorTileLayer::VectorTileLayer(pbf layer) : feature_pbf(layer) {
while (feature_pbf.next()) {
if (feature_pbf.tag == 1) { // name
name = feature_pbf.string();
} else if (feature_pbf.tag == 3) { // keys
keys.emplace_back(feature_pbf.string());
key_index.emplace(keys.back(), keys.size() - 1);
} else if (layer.tag == 4) { // values
values.emplace_back(std::move(parseValue(layer.message())));
} else if (layer.tag == 5) { // extent
extent = layer.varint();
} else if (feature_pbf.tag == 4) { // values
values.emplace_back(std::move(parseValue(feature_pbf.message())));
} else if (feature_pbf.tag == 5) { // extent
extent = feature_pbf.varint();
} else {
layer.skip();
feature_pbf.skip();
}
}
}
FilteredVectorTileLayer::FilteredVectorTileLayer(const VectorTileLayer& layer_, const FilterExpression& filterExpression_)
: GeometryFilteredTileLayer<pbf>(layer_, filterExpression_) {}
FilteredVectorTileLayer::iterator FilteredVectorTileLayer::begin() const {
const VectorTileLayer *layer_ = static_cast<const VectorTileLayer *>(&layer);
return FilteredVectorTileLayer::iterator(*this, layer_->layer_pbf);
: GeometryFilteredTileLayer(layer_, filterExpression_) {
feature_pbf = layer_.feature_pbf;
}
FilteredVectorTileLayer::iterator FilteredVectorTileLayer::end() const {
const VectorTileLayer *layer_ = static_cast<const VectorTileLayer *>(&layer);
template <>
GeometryTileTagExtractor<pbf>::GeometryTileTagExtractor(const GeometryTileLayer& layer_)
: layer(layer_) {}
return FilteredVectorTileLayer::iterator(*this, pbf(layer_->layer_pbf.end, 0));
}
FilteredVectorTileLayer::iterator::iterator(const FilteredVectorTileLayer& parent_, const pbf& data_pbf_)
: GeometryFilteredTileLayer<pbf>::iterator(parent_),
feature_pbf(pbf()),
data_pbf(data_pbf_) {}
VectorTileTagExtractor::VectorTileTagExtractor(const VectorTileLayer& layer_)
: GeometryTileTagExtractor(layer_) {}
void VectorTileTagExtractor::setTags(const pbf& pbf) {
tags_pbf = pbf;
}
mapbox::util::optional<Value> VectorTileTagExtractor::getValue(const std::string& key) const {
template <>
mapbox::util::optional<Value> GeometryTileTagExtractor<pbf>::getValue(const std::string& key) const {
if (key == "$type") {
return Value(uint64_t(type));
}
@@ -117,7 +144,7 @@ mapbox::util::optional<Value> VectorTileTagExtractor::getValue(const std::string
// Now loop through all the key/value pair tags.
// tags are packed varints. They should have an even length.
pbf tags_pbf_ = tags_pbf;
pbf tags_pbf_ = tags;
uint32_t tag_key, tag_val;
while (tags_pbf_) {
tag_key = tags_pbf_.varint();
@@ -143,43 +170,40 @@ mapbox::util::optional<Value> VectorTileTagExtractor::getValue(const std::string
return value;
}
template bool mbgl::evaluate(const FilterExpression&, const VectorTileTagExtractor&);
template bool mbgl::evaluate(const FilterExpression&, const GeometryTileTagExtractor<pbf>&);
void FilteredVectorTileLayer::iterator::operator++() {
valid = false;
GeometryTileFeature FilteredVectorTileLayer::nextMatchingFeature() {
GeometryTileFeature result;
const FilterExpression &expression = parent.filterExpression;
if (feature_pbf.next(2)) {
pbf current_feature_pbf = feature_pbf.message();
while (data_pbf.next(2)) { // feature
feature_pbf = data_pbf.message();
pbf feature_pbf_ = feature_pbf;
GeometryTileTagExtractor<pbf> extractor(layer);
GeometryTileTagExtractor<pbf> extractor(parent.layer);
// Retrieve the basic information
while (feature_pbf_.next()) {
if (feature_pbf_.tag == 2) { // tags
extractor.setTags(feature_pbf.message());
} else if (feature_pbf_.tag == 3) { // geometry type
extractor.setType(GeometryFeatureType(feature_pbf_.varint()));
while (current_feature_pbf.next()) {
if (current_feature_pbf.tag == 2) { // tags
extractor.setTags(current_feature_pbf);
} else if (current_feature_pbf.tag == 3) { // geometry type
extractor.setType(GeometryFeatureType(current_feature_pbf.varint()));
} else {
feature_pbf_.skip();
current_feature_pbf.skip();
}
}
if (evaluate(expression, extractor)) {
valid = true;
return; // data loop
} else {
valid = false;
if (evaluate(filterExpression, extractor)) {
result = VectorTileFeature(current_feature_pbf.message(), layer);
}
}
return std::move(result);
}
bool FilteredVectorTileLayer::iterator::operator!=(const iterator& other) const {
return !(data_pbf.data == other.data_pbf.data && data_pbf.end == other.data_pbf.end && valid == other.valid);
}
GeometryTileFeature VectorTileLayer::nextFeature() {
GeometryTileFeature result;
const pbf& FilteredVectorTileLayer::iterator:: operator*() const {
return feature_pbf;
if (feature_pbf.next(2)) {
result = VectorTileFeature(feature_pbf.message(), *this);
}
return std::move(result);
}

52
src/mbgl/map/vector_tile.hpp
View File

@@ -2,6 +2,7 @@
#define MBGL_MAP_VECTOR_TILE
#include <mbgl/map/geometry_tile.hpp>
#include <mbgl/geometry/pbf_geometry.hpp>
#include <mbgl/style/filter_expression.hpp>
#include <mbgl/util/pbf.hpp>
@@ -9,54 +10,37 @@ namespace mbgl {
class VectorTileLayer;
class VectorTileFeature : public GeometryTileFeature<pbf> {
class VectorTileFeature : public GeometryTileFeature {
public:
VectorTileFeature(pbf, const VectorTileLayer&);
VectorTileFeature(pbf, const GeometryTileLayer&);
Geometry nextGeometry();
private:
const pbf feature_pbf;
pbf geometry_pbf;
bool multigeometry = false;
};
std::ostream& operator<<(std::ostream&, const GeometryTileFeature<pbf>&);
class VectorTileTagExtractor : public GeometryTileTagExtractor<pbf> {
public:
VectorTileTagExtractor(const VectorTileLayer&);
void setTags(const pbf&);
mapbox::util::optional<Value> getValue(const std::string &key) const;
private:
pbf tags_pbf;
};
class FilteredVectorTileLayer : public GeometryFilteredTileLayer<pbf> {
public:
class iterator : public GeometryFilteredTileLayer<pbf>::iterator {
public:
iterator(const FilteredVectorTileLayer&, const pbf&);
void operator++();
bool operator!=(const iterator& other) const;
const pbf& operator*() const;
private:
pbf feature_pbf;
pbf data_pbf;
};
class FilteredVectorTileLayer : public GeometryFilteredTileLayer {
public:
FilteredVectorTileLayer(const VectorTileLayer&, const FilterExpression&);
iterator begin() const;
iterator end() const;
GeometryTileFeature nextMatchingFeature();
private:
pbf feature_pbf;
};
class VectorTileLayer : public GeometryTileLayer {
friend class FilteredVectorTileLayer;
public:
VectorTileLayer(pbf);
public:
const pbf layer_pbf;
GeometryTileFeature nextFeature();
private:
pbf feature_pbf;
};
class VectorTile : public GeometryTile {

26
src/mbgl/renderer/fill_bucket.cpp
View File

@@ -1,17 +1,12 @@
#include <mbgl/renderer/fill_bucket.hpp>
#include <mbgl/geometry/fill_buffer.hpp>
#include <mbgl/geometry/elements_buffer.hpp>
#include <mbgl/geometry/geometry.hpp>
#include <mbgl/renderer/painter.hpp>
#include <mbgl/style/style.hpp>
#include <mbgl/style/style_layout.hpp>
#include <mbgl/map/vector_tile.hpp>
#include <mbgl/util/std.hpp>
#include <mbgl/platform/gl.hpp>
#include <cassert>
struct geometry_too_long_exception : std::exception {};
@@ -69,24 +64,13 @@ FillBucket::~FillBucket() {
}
}
void FillBucket::addGeometry(pbf& geom) {
Geometry::command cmd;
void FillBucket::addGeometry(const Geometry& fill) {
const GeometryPolygon& polygon = fill.get<GeometryPolygon>();
Coordinate coord;
Geometry geometry(geom);
int32_t x, y;
while ((cmd = geometry.next(x, y)) != Geometry::end) {
if (cmd == Geometry::move_to) {
if (line.size()) {
clipper.AddPath(line, ClipperLib::ptSubject, true);
line.clear();
hasVertices = true;
}
for (auto line_it = polygon.begin(); line_it != polygon.end(); line_it++) {
for (auto point_it = line_it->begin(); point_it != line_it->end(); point_it++) {
line.emplace_back(point_it->x, point_it->y);
}
line.emplace_back(x, y);
}
if (line.size()) {
clipper.AddPath(line, ClipperLib::ptSubject, true);
line.clear();
hasVertices = true;

4
src/mbgl/renderer/fill_bucket.hpp
View File

@@ -2,6 +2,7 @@
#define MBGL_RENDERER_FILLBUCKET
#include <mbgl/renderer/bucket.hpp>
#include <mbgl/map/geometry_tile.hpp>
#include <mbgl/geometry/elements_buffer.hpp>
#include <mbgl/geometry/fill_buffer.hpp>
#include <mbgl/style/style_bucket.hpp>
@@ -27,7 +28,6 @@ class BucketDescription;
class OutlineShader;
class PlainShader;
class PatternShader;
struct pbf;
class FillBucket : public Bucket {
@@ -49,7 +49,7 @@ public:
const mat4 &matrix) override;
bool hasData() const override;
void addGeometry(pbf& data);
void addGeometry(const Geometry& fill);
void tessellate();
void drawElements(PlainShader& shader);

31
src/mbgl/renderer/line_bucket.cpp
View File

@@ -1,12 +1,9 @@
#include <mbgl/renderer/line_bucket.hpp>
#include <mbgl/geometry/elements_buffer.hpp>
#include <mbgl/geometry/geometry.hpp>
#include <mbgl/geometry/elements_buffer.hpp>
#include <mbgl/renderer/painter.hpp>
#include <mbgl/style/style.hpp>
#include <mbgl/style/style_layout.hpp>
#include <mbgl/map/vector_tile.hpp>
#include <mbgl/util/math.hpp>
#include <mbgl/util/std.hpp>
#include <mbgl/platform/gl.hpp>
@@ -37,28 +34,6 @@ LineBucket::~LineBucket() {
// Do not remove. header file only contains forward definitions to unique pointers.
}
void LineBucket::addGeometry(pbf& geom) {
std::vector<Coordinate> line;
Geometry::command cmd;
Coordinate coord;
Geometry geometry(geom);
int32_t x, y;
while ((cmd = geometry.next(x, y)) != Geometry::end) {
if (cmd == Geometry::move_to) {
if (!line.empty()) {
addGeometry(line);
line.clear();
}
}
line.emplace_back(x, y);
}
if (line.size()) {
addGeometry(line);
}
}
struct TriangleElement {
TriangleElement(uint16_t a_, uint16_t b_, uint16_t c_) : a(a_), b(b_), c(c_) {}
uint16_t a, b, c;
@@ -66,7 +41,9 @@ struct TriangleElement {
typedef uint16_t PointElement;
void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
void LineBucket::addGeometry(const Geometry &line) {
const GeometryLine& vertices = line.get<GeometryLine>();
auto &layout = *styleLayout;
// TODO: use roundLimit
// const float roundLimit = geometry.round_limit;

5
src/mbgl/renderer/line_bucket.hpp
View File

@@ -2,6 +2,7 @@
#define MBGL_RENDERER_LINEBUCKET
#include <mbgl/renderer/bucket.hpp>
#include <mbgl/map/geometry_tile.hpp>
#include <mbgl/geometry/vao.hpp>
#include <mbgl/geometry/elements_buffer.hpp>
#include <mbgl/geometry/line_buffer.hpp>
@@ -20,7 +21,6 @@ class LineShader;
class LinejoinShader;
class LineSDFShader;
class LinepatternShader;
struct pbf;
class LineBucket : public Bucket {
typedef ElementGroup<3> triangle_group_type;
@@ -37,8 +37,7 @@ public:
const mat4 &matrix) override;
bool hasData() const override;
void addGeometry(pbf& data);
void addGeometry(const std::vector<Coordinate>& line);
void addGeometry(const Geometry& line);
bool hasPoints() const;

29
src/mbgl/renderer/symbol_bucket.cpp
View File

@@ -1,10 +1,10 @@
#include <mbgl/style/style_layout.hpp>
#include <mbgl/renderer/symbol_bucket.hpp>
#include <mbgl/map/geometry_tile.hpp>
#include <mbgl/style/style_layout.hpp>
#include <mbgl/geometry/text_buffer.hpp>
#include <mbgl/geometry/icon_buffer.hpp>
#include <mbgl/geometry/glyph_atlas.hpp>
#include <mbgl/geometry/sprite_atlas.hpp>
#include <mbgl/geometry/geometry.hpp>
#include <mbgl/geometry/anchor.hpp>
#include <mbgl/geometry/resample.hpp>
#include <mbgl/renderer/painter.hpp>
@@ -47,7 +47,7 @@ void SymbolBucket::addGlyphsToAtlas(uint64_t tileid, const std::string stackname
glyphAtlas.addGlyphs(tileid, text, stackname, fontStack,face);
}
std::vector<SymbolFeature> SymbolBucket::processFeatures(const VectorTileLayer &layer,
std::vector<SymbolFeature> SymbolBucket::processFeatures(const GeometryTileLayer &layer,
const FilterExpression &filter,
GlyphStore &glyphStore,
const Sprite &sprite) {
@@ -64,9 +64,9 @@ std::vector<SymbolFeature> SymbolBucket::processFeatures(const VectorTileLayer &
// Determine and load glyph ranges
std::set<GlyphRange> ranges;
FilteredVectorTileLayer filtered_layer(layer, filter);
for (const pbf &feature_pbf : filtered_layer) {
const VectorTileFeature feature{feature_pbf, layer};
GeometryFilteredTileLayer filtered_layer(layer, filter);
GeometryTileFeature feature = filtered_layer.nextMatchingFeature();
while (feature.type != GeometryFeatureType::Unknown) {
SymbolFeature ft;
@@ -97,22 +97,21 @@ std::vector<SymbolFeature> SymbolBucket::processFeatures(const VectorTileLayer &
auto &multiline = ft.geometry;
// Decode line
Geometry::command cmd;
pbf geom(feature.geometry);
Geometry geometry(geom);
Geometry geometry = feature.nextGeometry();
const GeometryLine& line = geometry.get<GeometryLine>();
bool first = true;
int32_t x, y;
while ((cmd = geometry.next(x, y)) != Geometry::end) {
if (first || cmd == Geometry::move_to) {
for (auto point_it = line.begin(); point_it != line.end(); point_it++) {
if (first) {
multiline.emplace_back();
first = false;
}
multiline.back().emplace_back(x, y);
multiline.back().emplace_back(point_it->x, point_it->y);
}
features.push_back(std::move(ft));
}
feature = filtered_layer.nextMatchingFeature();
}
if (layout.placement == PlacementType::Line) {
@@ -125,7 +124,7 @@ std::vector<SymbolFeature> SymbolBucket::processFeatures(const VectorTileLayer &
return features;
}
void SymbolBucket::addFeatures(const VectorTileLayer &layer, const FilterExpression &filter,
void SymbolBucket::addFeatures(const GeometryTileLayer &layer, const FilterExpression &filter,
const Tile::ID &id, SpriteAtlas &spriteAtlas, Sprite &sprite,
GlyphAtlas & glyphAtlas, GlyphStore &glyphStore) {
auto &layout = *styleLayout;

10
src/mbgl/renderer/symbol_bucket.hpp
View File

@@ -2,11 +2,11 @@
#define MBGL_RENDERER_SYMBOLBUCKET
#include <mbgl/renderer/bucket.hpp>
#include <mbgl/map/geometry_tile.hpp>
#include <mbgl/geometry/vao.hpp>
#include <mbgl/geometry/elements_buffer.hpp>
#include <mbgl/geometry/text_buffer.hpp>
#include <mbgl/geometry/icon_buffer.hpp>
#include <mbgl/map/vector_tile.hpp>
#include <mbgl/text/types.hpp>
#include <mbgl/text/glyph.hpp>
#include <mbgl/style/style_bucket.hpp>
@@ -64,7 +64,7 @@ public:
bool hasTextData() const;
bool hasIconData() const;
void addFeatures(const VectorTileLayer &layer, const FilterExpression &filter,
void addFeatures(const GeometryTileLayer &layer, const FilterExpression &filter,
const Tile::ID &id, SpriteAtlas &spriteAtlas, Sprite &sprite,
GlyphAtlas &glyphAtlas, GlyphStore &glyphStore);
@@ -77,11 +77,9 @@ public:
private:
std::vector<SymbolFeature> processFeatures(const VectorTileLayer &layer, const FilterExpression &filter, GlyphStore &glyphStore, const Sprite &sprite);
void addFeature(const std::vector<Coordinate> &line, const Shaping &shaping, const GlyphPositions &face, const Rect<uint16_t> &image);
std::vector<SymbolFeature> processFeatures(const GeometryTileLayer &layer, const FilterExpression &filter, GlyphStore &glyphStore, const Sprite &sprite);
void addFeature(const GeometryLine &line, const Shaping &shaping, const GlyphPositions &face, const Rect<uint16_t> &image);
// Adds placed items to the buffer.
template <typename Buffer, typename GroupType>