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

fix variable shadowing

Browse Source
This commit is contained in:
Konstantin Käfer
2014-10-22 18:06:11 +02:00
parent 74387c54e3
commit 214f99673f
60 changed files with 276 additions and 278 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/clipper/clipper.cpp
View File

@@ -3242,7 +3242,7 @@ void Clipper::BuildResult(Paths &polys)
int cnt = PointCount(p);
if (cnt < 2) continue;
pg.reserve(cnt);
for (int i = 0; i < cnt; ++i)
for (int j = 0; j < cnt; ++j)
{
pg.push_back(p->Pt);
p = p->Prev;

8
src/geometry/debug_font.cpp
View File

@@ -98,10 +98,10 @@ const int8_t simplex_94[] = { 3, 6, 3, 8, 4, 11, 6, 12, 8, 12, 10, 11, 14, 8, 16
struct glyph {
glyph() : width(0), length(0), data(nullptr) { }
glyph(uint8_t width, uint8_t length, const int8_t *data)
: width(width),
length(length),
data(data) {}
glyph(uint8_t width_, uint8_t length_, const int8_t *data_)
: width(width_),
length(length_),
data(data_) {}
uint8_t width;
uint8_t length;
const int8_t *data;

10
src/geometry/glyph_atlas.cpp
View File

@@ -9,11 +9,11 @@
using namespace mbgl;
GlyphAtlas::GlyphAtlas(uint16_t width, uint16_t height)
: width(width),
height(height),
bin(width, height),
data(new char[width *height]),
GlyphAtlas::GlyphAtlas(uint16_t width_, uint16_t height_)
: width(width_),
height(height_),
bin(width_, height_),
data(new char[width_ *height_]),
dirty(true) {
}

12
src/geometry/sprite_atlas.cpp
View File

@@ -14,10 +14,10 @@
using namespace mbgl;
SpriteAtlas::SpriteAtlas(dimension width, dimension height)
: width(width),
height(height),
bin(width, height),
SpriteAtlas::SpriteAtlas(dimension width_, dimension height_)
: width(width_),
height(height_),
bin(width_, height_),
dirty(true) {
}
@@ -88,10 +88,10 @@ void copy_bitmap(const uint32_t *src, const int src_stride, const int src_x, con
}
}
Rect<SpriteAtlas::dimension> SpriteAtlas::allocateImage(size_t width, size_t height) {
Rect<SpriteAtlas::dimension> SpriteAtlas::allocateImage(size_t pixel_width, size_t pixel_height) {
// We have to allocate a new area in the bin, and store an empty image in it.
// Add a 1px border around every image.
Rect<dimension> rect = bin.allocate(width + 2 * buffer, height + 2 * buffer);
Rect<dimension> rect = bin.allocate(pixel_width + 2 * buffer, pixel_height + 2 * buffer);
if (rect.w == 0) {
return rect;
}

9
src/map/map.cpp
View File

@@ -30,17 +30,17 @@
using namespace mbgl;
Map::Map(View& view)
Map::Map(View& view_)
: loop(std::make_shared<uv::loop>()),
thread(std::make_unique<uv::thread>()),
async_terminate(new uv_async_t()),
async_render(new uv_async_t()),
async_cleanup(new uv_async_t()),
view(view),
view(view_),
#ifndef NDEBUG
main_thread(uv_thread_self()),
#endif
transform(view),
transform(view_),
glyphAtlas(std::make_shared<GlyphAtlas>(1024, 1024)),
spriteAtlas(std::make_shared<SpriteAtlas>(512, 512)),
texturepool(std::make_shared<Texturepool>()),
@@ -653,9 +653,6 @@ void Map::prepare() {
void Map::render() {
view.make_active();
#if defined(DEBUG)
std::vector<std::string> debug;
#endif
painter.clear();
painter.resize();

10
src/map/source.cpp
View File

@@ -20,8 +20,8 @@
namespace mbgl {
Source::Source(const util::ptr<SourceInfo>& info)
: info(info)
Source::Source(const util::ptr<SourceInfo>& info_)
: info(info_)
{
}
@@ -219,15 +219,15 @@ std::forward_list<Tile::ID> Source::coveringTiles(const TransformState& state) c
box points = state.cornersToBox(z);
const vec2<double>& center = points.center;
std::forward_list<Tile::ID> tiles = Tile::cover(z, points);
std::forward_list<Tile::ID> covering_tiles = Tile::cover(z, points);
tiles.sort([&center](const Tile::ID& a, const Tile::ID& b) {
covering_tiles.sort([&center](const Tile::ID& a, const Tile::ID& b) {
// Sorts by distance from the box center
return std::fabs(a.x - center.x) + std::fabs(a.y - center.y) <
std::fabs(b.x - center.x) + std::fabs(b.y - center.y);
});
return tiles;
return covering_tiles;
}
/**

28
src/map/sprite.cpp
View File

@@ -13,13 +13,13 @@
using namespace mbgl;
SpritePosition::SpritePosition(uint16_t x, uint16_t y, uint16_t width, uint16_t height, float pixelRatio, bool sdf)
: x(x),
y(y),
width(width),
height(height),
pixelRatio(pixelRatio),
sdf(sdf) {
SpritePosition::SpritePosition(uint16_t x_, uint16_t y_, uint16_t width_, uint16_t height_, float pixelRatio_, bool sdf_)
: x(x_),
y(y_),
width(width_),
height(height_),
pixelRatio(pixelRatio_),
sdf(sdf_) {
}
util::ptr<Sprite> Sprite::Create(const std::string& base_url, float pixelRatio, const util::ptr<FileSource> &fileSource) {
@@ -28,11 +28,11 @@ util::ptr<Sprite> Sprite::Create(const std::string& base_url, float pixelRatio,
return sprite;
}
Sprite::Sprite(const Key &, const std::string& base_url, float pixelRatio)
Sprite::Sprite(const Key &, const std::string& base_url, float pixelRatio_)
: valid(base_url.length() > 0),
pixelRatio(pixelRatio),
spriteURL(base_url + (pixelRatio > 1 ? "@2x" : "") + ".png"),
jsonURL(base_url + (pixelRatio > 1 ? "@2x" : "") + ".json"),
pixelRatio(pixelRatio_),
spriteURL(base_url + (pixelRatio_ > 1 ? "@2x" : "") + ".png"),
jsonURL(base_url + (pixelRatio_ > 1 ? "@2x" : "") + ".json"),
raster(),
loadedImage(false),
loadedJSON(false),
@@ -123,16 +123,16 @@ void Sprite::parseJSON() {
uint16_t y = 0;
uint16_t width = 0;
uint16_t height = 0;
float pixelRatio = 1.0f;
float spritePixelRatio = 1.0f;
bool sdf = false;
if (value.HasMember("x")) x = value["x"].GetInt();
if (value.HasMember("y")) y = value["y"].GetInt();
if (value.HasMember("width")) width = value["width"].GetInt();
if (value.HasMember("height")) height = value["height"].GetInt();
if (value.HasMember("pixelRatio")) pixelRatio = value["pixelRatio"].GetInt();
if (value.HasMember("pixelRatio")) spritePixelRatio = value["pixelRatio"].GetInt();
if (value.HasMember("sdf")) sdf = value["sdf"].GetBool();
pos.emplace(name, SpritePosition { x, y, width, height, pixelRatio, sdf });
pos.emplace(name, SpritePosition { x, y, width, height, spritePixelRatio, sdf });
}
}
} else {

4
src/map/tile.cpp
View File

@@ -7,8 +7,8 @@ using namespace mbgl;
#include <iostream>
Tile::Tile(const ID& id)
: id(id) {
Tile::Tile(const ID& id_)
: id(id_) {
}
Tile::ID Tile::ID::parent(int8_t parent_z) const {

10
src/map/tile_data.cpp
View File

@@ -9,14 +9,14 @@
using namespace mbgl;
TileData::TileData(Tile::ID id, Map &map, const util::ptr<SourceInfo> &source)
: id(id),
TileData::TileData(Tile::ID id_, Map &map_, const util::ptr<SourceInfo> &source_)
: id(id_),
state(State::initial),
map(map),
source(source),
map(map_),
source(source_),
debugBucket(debugFontBuffer) {
// Initialize tile debug coordinates
const std::string str = util::sprintf<32>("%d/%d/%d", id.z, id.x, id.y);
const std::string str = util::sprintf<32>("%d/%d/%d", id_.z, id_.x, id_.y);
debugFontBuffer.addText(str.c_str(), 50, 200, 5);
}

4
src/map/tile_parser.cpp
View File

@@ -37,14 +37,14 @@ namespace mbgl {
// its header file.
TileParser::~TileParser() = default;
TileParser::TileParser(const std::string &data, VectorTileData &tile,
TileParser::TileParser(const std::string &data, VectorTileData &tile_,
const util::ptr<const Style> &style_,
const util::ptr<GlyphAtlas> &glyphAtlas_,
const util::ptr<GlyphStore> &glyphStore_,
const util::ptr<SpriteAtlas> &spriteAtlas_,
const util::ptr<Sprite> &sprite_)
: vector_data(pbf((const uint8_t *)data.data(), data.size())),
tile(tile),
tile(tile_),
style(style_),
glyphAtlas(glyphAtlas_),
glyphStore(glyphStore_),

2
src/map/transform.cpp
View File

@@ -17,7 +17,7 @@ const double R2D = 180.0 / M_PI;
const double M2PI = 2 * M_PI;
const double MIN_ROTATE_SCALE = 8;
Transform::Transform(View &view) : view(view), mtx(std::make_unique<uv::rwlock>()) {
Transform::Transform(View &view_) : view(view_), mtx(std::make_unique<uv::rwlock>()) {
setScale(current.scale);
setAngle(current.angle);
}

4
src/map/transform_state.cpp
View File

@@ -96,8 +96,8 @@ float TransformState::lngX(float lon) const {
}
float TransformState::latY(float lat) const {
float y = 180 / M_PI * std::log(std::tan(M_PI / 4 + lat * M_PI / 360));
return (180 - y) * worldSize() / 360;
float latY = 180 / M_PI * std::log(std::tan(M_PI / 4 + lat * M_PI / 360));
return (180 - latY) * worldSize() / 360;
}
std::array<float, 2> TransformState::locationCoordinate(float lon, float lat) const {

12
src/map/vector_tile.cpp
View File

@@ -103,9 +103,9 @@ VectorTileLayer::VectorTileLayer(pbf layer) : data(layer) {
}
}
FilteredVectorTileLayer::FilteredVectorTileLayer(const VectorTileLayer& layer, const FilterExpression &filterExpression)
: layer(layer),
filterExpression(filterExpression) {
FilteredVectorTileLayer::FilteredVectorTileLayer(const VectorTileLayer& layer_, const FilterExpression &filterExpression_)
: layer(layer_),
filterExpression(filterExpression_) {
}
FilteredVectorTileLayer::iterator FilteredVectorTileLayer::begin() const {
@@ -116,10 +116,10 @@ FilteredVectorTileLayer::iterator FilteredVectorTileLayer::end() const {
return iterator(*this, pbf(layer.data.end, 0));
}
FilteredVectorTileLayer::iterator::iterator(const FilteredVectorTileLayer& parent, const pbf& data)
: parent(parent),
FilteredVectorTileLayer::iterator::iterator(const FilteredVectorTileLayer& parent_, const pbf& data_)
: parent(parent_),
feature(pbf()),
data(data) {
data(data_) {
operator++();
}

4
src/renderer/debug_bucket.cpp
View File

@@ -10,8 +10,8 @@ struct geometry_too_long_exception : std::exception {};
using namespace mbgl;
DebugBucket::DebugBucket(DebugFontBuffer& fontBuffer)
: fontBuffer(fontBuffer) {
DebugBucket::DebugBucket(DebugFontBuffer& fontBuffer_)
: fontBuffer(fontBuffer_) {
}
void DebugBucket::render(Painter& painter, util::ptr<StyleLayer> /*layer_desc*/, const Tile::ID& /*id*/, const mat4 &matrix) {

28
src/renderer/fill_bucket.cpp
View File

@@ -30,11 +30,11 @@ void FillBucket::free(void *, void *ptr) {
::free(ptr);
}
FillBucket::FillBucket(FillVertexBuffer &vertexBuffer,
TriangleElementsBuffer &triangleElementsBuffer,
LineElementsBuffer &lineElementsBuffer,
const StyleBucketFill &properties)
: properties(properties),
FillBucket::FillBucket(FillVertexBuffer &vertexBuffer_,
TriangleElementsBuffer &triangleElementsBuffer_,
LineElementsBuffer &lineElementsBuffer_,
const StyleBucketFill &properties_)
: properties(properties_),
allocator(new TESSalloc{&alloc, &realloc, &free, nullptr, // userData
64, // meshEdgeBucketSize
64, // meshVertexBucketSize
@@ -44,11 +44,11 @@ FillBucket::FillBucket(FillVertexBuffer &vertexBuffer,
128, // extraVertices allocated for the priority queue.
}),
tesselator(tessNewTess(allocator)),
vertexBuffer(vertexBuffer),
triangleElementsBuffer(triangleElementsBuffer),
lineElementsBuffer(lineElementsBuffer),
vertex_start(vertexBuffer.index()),
triangle_elements_start(triangleElementsBuffer.index()),
vertexBuffer(vertexBuffer_),
triangleElementsBuffer(triangleElementsBuffer_),
lineElementsBuffer(lineElementsBuffer_),
vertex_start(vertexBuffer_.index()),
triangle_elements_start(triangleElementsBuffer_.index()),
line_elements_start(lineElementsBuffer.index()) {
assert(tesselator);
}
@@ -123,10 +123,10 @@ void FillBucket::tessellate() {
const size_t group_count = polygon.size();
assert(group_count >= 3);
std::vector<TESSreal> line;
std::vector<TESSreal> clipped_line;
for (const ClipperLib::IntPoint& pt : polygon) {
line.push_back(pt.X);
line.push_back(pt.Y);
clipped_line.push_back(pt.X);
clipped_line.push_back(pt.Y);
vertexBuffer.add(pt.X, pt.Y);
}
@@ -137,7 +137,7 @@ void FillBucket::tessellate() {
lineIndex += group_count;
tessAddContour(tesselator, vertexSize, line.data(), stride, (int)line.size() / vertexSize);
tessAddContour(tesselator, vertexSize, clipped_line.data(), stride, (int)clipped_line.size() / vertexSize);
}
lineGroup.elements_length += total_vertex_count;

24
src/renderer/line_bucket.cpp
View File

@@ -17,17 +17,17 @@ struct geometry_too_long_exception : std::exception {};
using namespace mbgl;
LineBucket::LineBucket(LineVertexBuffer& vertexBuffer,
TriangleElementsBuffer& triangleElementsBuffer,
PointElementsBuffer& pointElementsBuffer,
const StyleBucketLine& properties)
: properties(properties),
vertexBuffer(vertexBuffer),
triangleElementsBuffer(triangleElementsBuffer),
pointElementsBuffer(pointElementsBuffer),
vertex_start(vertexBuffer.index()),
triangle_elements_start(triangleElementsBuffer.index()),
point_elements_start(pointElementsBuffer.index())
LineBucket::LineBucket(LineVertexBuffer& vertexBuffer_,
TriangleElementsBuffer& triangleElementsBuffer_,
PointElementsBuffer& pointElementsBuffer_,
const StyleBucketLine& properties_)
: properties(properties_),
vertexBuffer(vertexBuffer_),
triangleElementsBuffer(triangleElementsBuffer_),
pointElementsBuffer(pointElementsBuffer_),
vertex_start(vertexBuffer_.index()),
triangle_elements_start(triangleElementsBuffer_.index()),
point_elements_start(pointElementsBuffer_.index())
{
}
@@ -53,7 +53,7 @@ void LineBucket::addGeometry(pbf& geom) {
}
struct TriangleElement {
TriangleElement(uint16_t a, uint16_t b, uint16_t c) : a(a), b(b), c(c) {}
TriangleElement(uint16_t a_, uint16_t b_, uint16_t c_) : a(a_), b(b_), c(c_) {}
uint16_t a, b, c;
};

4
src/renderer/painter.cpp
View File

@@ -21,8 +21,8 @@ using namespace mbgl;
#define BUFFER_OFFSET(i) ((char *)nullptr + (i))
Painter::Painter(Map &map)
: map(map) {
Painter::Painter(Map &map_)
: map(map_) {
}
Painter::~Painter() {

4
src/renderer/prerendered_texture.cpp
View File

@@ -5,8 +5,8 @@
using namespace mbgl;
PrerenderedTexture::PrerenderedTexture(const StyleBucketRaster &properties)
: properties(properties) {
PrerenderedTexture::PrerenderedTexture(const StyleBucketRaster &properties_)
: properties(properties_) {
}
PrerenderedTexture::~PrerenderedTexture() {

10
src/renderer/raster_bucket.cpp
View File

@@ -3,9 +3,9 @@
using namespace mbgl;
RasterBucket::RasterBucket(const util::ptr<Texturepool> &texturepool, const StyleBucketRaster& properties)
: properties(properties),
texture(properties),
RasterBucket::RasterBucket(const util::ptr<Texturepool> &texturepool, const StyleBucketRaster& properties_)
: properties(properties_),
texture(properties_),
raster(texturepool) {
}
@@ -24,8 +24,8 @@ void RasterBucket::drawRaster(RasterShader& shader, StaticVertexBuffer &vertices
glDrawArrays(GL_TRIANGLES, 0, (GLsizei)vertices.index());
}
void RasterBucket::drawRaster(RasterShader& shader, StaticVertexBuffer &vertices, VertexArrayObject &array, GLuint texture) {
raster.bind(texture);
void RasterBucket::drawRaster(RasterShader& shader, StaticVertexBuffer &vertices, VertexArrayObject &array, GLuint texture_) {
raster.bind(texture_);
shader.u_image = 0;
array.bind(shader, vertices, BUFFER_OFFSET(0));
glDrawArrays(GL_TRIANGLES, 0, (GLsizei)vertices.index());

14
src/renderer/symbol_bucket.cpp
View File

@@ -19,8 +19,8 @@
namespace mbgl {
SymbolBucket::SymbolBucket(const StyleBucketSymbol &properties, Collision &collision)
: properties(properties), collision(collision) {}
SymbolBucket::SymbolBucket(const StyleBucketSymbol &properties_, Collision &collision_)
: properties(properties_), collision(collision_) {}
void SymbolBucket::render(Painter &painter, util::ptr<StyleLayer> layer_desc,
const Tile::ID &id, const mat4 &matrix) {
@@ -52,12 +52,12 @@ std::vector<SymbolFeature> SymbolBucket::processFeatures(const VectorTileLayer &
const FilterExpression &filter,
GlyphStore &glyphStore,
const Sprite &sprite) {
const bool text = properties.text.field.size();
const bool icon = properties.icon.image.size();
const bool has_text = properties.text.field.size();
const bool has_icon = properties.icon.image.size();
std::vector<SymbolFeature> features;
if (!text && !icon) {
if (!has_text && !has_icon) {
return features;
}
@@ -72,7 +72,7 @@ std::vector<SymbolFeature> SymbolBucket::processFeatures(const VectorTileLayer &
SymbolFeature ft;
if (text) {
if (has_text) {
std::string u8string = util::replaceTokens(properties.text.field, feature.properties);
if (properties.text.transform == TextTransformType::Uppercase) {
@@ -91,7 +91,7 @@ std::vector<SymbolFeature> SymbolBucket::processFeatures(const VectorTileLayer &
}
}
if (icon) {
if (has_icon) {
ft.sprite = util::replaceTokens(properties.icon.image, feature.properties);
}

4
src/shader/shader.cpp
View File

@@ -8,8 +8,8 @@
using namespace mbgl;
Shader::Shader(const char *name, const GLchar *vertSource, const GLchar *fragSource)
: name(name),
Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSource)
: name(name_),
valid(false),
program(0) {
util::timer timer("shader compilation", Event::Shader);

14
src/storage/http_request.cpp
View File

@@ -82,19 +82,19 @@ void HTTPRequest::startHTTPRequest(std::unique_ptr<Response> &&res) {
#else
uv_async_init(loop, http_baton->async, [](uv_async_t *async) {
#endif
util::ptr<HTTPRequestBaton> &http_baton = *(util::ptr<HTTPRequestBaton> *)async->data;
util::ptr<HTTPRequestBaton> &baton = *(util::ptr<HTTPRequestBaton> *)async->data;
if (http_baton->request) {
HTTPRequest *request = http_baton->request;
if (baton->request) {
HTTPRequest *request = baton->request;
request->http_baton.reset();
http_baton->request = nullptr;
request->handleHTTPResponse(http_baton->type, std::move(http_baton->response));
baton->request = nullptr;
request->handleHTTPResponse(baton->type, std::move(baton->response));
}
delete (util::ptr<HTTPRequestBaton> *)async->data;
uv_close((uv_handle_t *)async, [](uv_handle_t *handle) {
uv_async_t *async = (uv_async_t *)handle;
delete async;
uv_async_t *async_handle = (uv_async_t *)handle;
delete async_handle;
});
});
attempts++;

4
src/storage/sqlite_store.cpp
View File

@@ -68,8 +68,8 @@ SQLiteStore::~SQLiteStore() {
// Nothing to do. This function needs to be here because we're forward-declaring
// Database, so we need the actual definition here to be able to properly destruct it.
if (worker) {
uv_worker_close(worker, [](uv_worker_t *worker) {
delete worker;
uv_worker_close(worker, [](uv_worker_t *worker_handle) {
delete worker_handle;
});
}
}

8
src/style/applied_class_properties.cpp
View File

@@ -2,11 +2,11 @@
namespace mbgl {
AppliedClassProperty::AppliedClassProperty(ClassID class_id, timestamp begin, timestamp end, const PropertyValue &value)
AppliedClassProperty::AppliedClassProperty(ClassID class_id, timestamp begin_, timestamp end_, const PropertyValue &value_)
: name(class_id),
begin(begin),
end(end),
value(value) {}
begin(begin_),
end(end_),
value(value_) {}
// Returns thie ID of the most recent
ClassID AppliedClassProperties::mostRecent() const {

18
src/style/style_layer.cpp
View File

@@ -7,8 +7,8 @@
namespace mbgl {
StyleLayer::StyleLayer(const std::string &id, std::map<ClassID, ClassProperties> &&styles)
: id(id), styles(std::move(styles)) {}
StyleLayer::StyleLayer(const std::string &id_, std::map<ClassID, ClassProperties> &&styles_)
: id(id_), styles(std::move(styles_)) {}
bool StyleLayer::isBackground() const {
return type == StyleLayerType::Background;
@@ -70,8 +70,8 @@ void StyleLayer::applyClassProperties(const ClassID class_id,
// Loop through all the properties in this style, and add transitions to them, if they're
// not already the most recent transition.
const ClassProperties &properties = style_it->second;
for (const std::pair<PropertyKey, PropertyValue> &property_pair : properties) {
const ClassProperties &class_properties = style_it->second;
for (const std::pair<PropertyKey, PropertyValue> &property_pair : class_properties) {
PropertyKey key = property_pair.first;
if (already_applied.find(key) != already_applied.end()) {
// This property has already been set by a previous class.
@@ -87,7 +87,7 @@ void StyleLayer::applyClassProperties(const ClassID class_id,
AppliedClassProperties &appliedProperties = appliedStyle[key];
if (appliedProperties.mostRecent() != class_id) {
const PropertyTransition &transition =
properties.getTransition(key, defaultTransition);
class_properties.getTransition(key, defaultTransition);
const timestamp begin = now + transition.delay * 1_millisecond;
const timestamp end = begin + transition.duration * 1_millisecond;
const PropertyValue &value = property_pair.second;
@@ -99,7 +99,7 @@ void StyleLayer::applyClassProperties(const ClassID class_id,
template <typename T>
struct PropertyEvaluator {
typedef T result_type;
PropertyEvaluator(float z) : z(z) {}
PropertyEvaluator(float z_) : z(z_) {}
template <typename P, typename std::enable_if<std::is_convertible<P, T>::value, int>::type = 0>
T operator()(const P &value) const {
@@ -269,11 +269,11 @@ void StyleLayer::cleanupAppliedStyleProperties(timestamp now) {
auto it = appliedStyle.begin();
const auto end = appliedStyle.end();
while (it != end) {
AppliedClassProperties &properties = it->second;
properties.cleanup(now);
AppliedClassProperties &applied_properties = it->second;
applied_properties.cleanup(now);
// If the current properties object is empty, remove it from the map entirely.
if (properties.empty()) {
if (applied_properties.empty()) {
appliedStyle.erase(it++);
} else {
++it;

14
src/style/style_parser.cpp
View File

@@ -108,13 +108,13 @@ template<> bool StyleParser::parseRenderProperty(JSVal value, uint16_t &target,
if (value.HasMember(name)) {
JSVal property = replaceConstant(value[name]);
if (property.IsUint()) {
unsigned int value = property.GetUint();
if (value > std::numeric_limits<uint16_t>::max()) {
unsigned int int_value = property.GetUint();
if (int_value > std::numeric_limits<uint16_t>::max()) {
Log::Warning(Event::ParseStyle, "values for %s that are larger than %d are not supported", name, std::numeric_limits<uint16_t>::max());
return false;
}
target = value;
target = int_value;
return true;
} else {
Log::Warning(Event::ParseStyle, "%s must be an unsigned integer", name);
@@ -763,11 +763,11 @@ FilterExpression StyleParser::parseFilter(JSVal value, FilterExpression::Operato
FilterComparison comparison(name);
JSVal filterValue = replaceConstant(itr->value);
if (filterValue.IsObject()) {
rapidjson::Value::ConstMemberIterator itr = filterValue.MemberBegin();
for (; itr != filterValue.MemberEnd(); ++itr) {
rapidjson::Value::ConstMemberIterator filter_itr = filterValue.MemberBegin();
for (; filter_itr != filterValue.MemberEnd(); ++filter_itr) {
comparison.add(
parseFilterComparisonOperator({ itr->name.GetString(), itr->name.GetStringLength() }),
parseValues(replaceConstant(itr->value))
parseFilterComparisonOperator({ filter_itr->name.GetString(), filter_itr->name.GetStringLength() }),
parseValues(replaceConstant(filter_itr->value))
);
}
} else if (filterValue.IsArray()) {

6
src/text/collision.cpp
View File

@@ -19,11 +19,11 @@ Box getBox(const CollisionAnchor &anchor, const CollisionRect &bbox, float minSc
};
};
Collision::Collision(float zoom, float tileExtent, float tileSize, float placementDepth)
Collision::Collision(float zoom_, float tileExtent, float tileSize, float placementDepth)
// tile pixels per screen pixels at the tile's zoom level
: tilePixelRatio(tileExtent / tileSize),
zoom(zoom),
zoom(zoom_),
// Calculate the maximum scale we can go down in our fake-3d rtree so that
// placement still makes sense. This is calculated so that the minimum
@@ -33,7 +33,7 @@ Collision::Collision(float zoom, float tileExtent, float tileSize, float placeme
// We don't want to place labels all the way to 25.5. This lets too many
// glyphs be placed, slowing down collision checking. Only place labels if
// they will show up within the intended zoom range of the tile.
maxPlacementScale(std::exp(std::log(2) * util::min(3.0f, placementDepth, 25.5f - zoom))) {
maxPlacementScale(std::exp(std::log(2) * util::min(3.0f, placementDepth, 25.5f - zoom_))) {
const float m = 4096;
const float edge = m * tilePixelRatio * 2;

2
src/text/glyph_store.cpp
View File

@@ -228,7 +228,7 @@ void GlyphPBF::parse(FontStack &stack) {
data.clear();
}
GlyphStore::GlyphStore(const util::ptr<FileSource> &fileSource) : fileSource(fileSource) {}
GlyphStore::GlyphStore(const util::ptr<FileSource> &fileSource_) : fileSource(fileSource_) {}
void GlyphStore::setURL(const std::string &url) {
glyphURL = url;

8
src/text/placement.cpp
View File

@@ -12,10 +12,10 @@ namespace mbgl {
const float Placement::globalMinScale = 0.5; // underscale by 1 zoom level
struct GlyphInstance {
explicit GlyphInstance(const vec2<float> &anchor) : anchor(anchor) {}
explicit GlyphInstance(const vec2<float> &anchor, float offset, float minScale, float maxScale,
float angle)
: anchor(anchor), offset(offset), minScale(minScale), maxScale(maxScale), angle(angle) {}
explicit GlyphInstance(const vec2<float> &anchor_) : anchor(anchor_) {}
explicit GlyphInstance(const vec2<float> &anchor_, float offset_, float minScale_, float maxScale_,
float angle_)
: anchor(anchor_), offset(offset_), minScale(minScale_), maxScale(maxScale_), angle(angle_) {}
const vec2<float> anchor;
const float offset = 0.0f;

8
src/util/image.cpp
View File

@@ -30,8 +30,8 @@ std::string mbgl::util::compress_png(int width, int height, void *rgba, bool fli
}
std::string result;
png_set_write_fn(png_ptr, &result, [](png_structp png_ptr, png_bytep data, png_size_t length) {
std::string *out = static_cast<std::string *>(png_get_io_ptr(png_ptr));
png_set_write_fn(png_ptr, &result, [](png_structp png_ptr_, png_bytep data, png_size_t length) {
std::string *out = static_cast<std::string *>(png_get_io_ptr(png_ptr_));
out->append(reinterpret_cast<char *>(data), length);
}, NULL);
@@ -57,8 +57,8 @@ using namespace mbgl::util;
struct Buffer {
Buffer(const std::string& data)
: data(data.data()), length(data.size()) {}
Buffer(const std::string& data_)
: data(data_.data()), length(data_.size()) {}
const char *const data = 0;
const size_t length = 0;
size_t pos = 0;

30
src/util/raster.cpp
View File

@@ -13,8 +13,8 @@
using namespace mbgl;
Raster::Raster(const util::ptr<Texturepool> &texturepool)
: texturepool(texturepool)
Raster::Raster(const util::ptr<Texturepool> &texturepool_)
: texturepool(texturepool_)
{}
Raster::~Raster() {
@@ -59,32 +59,32 @@ void Raster::bind(bool linear) {
glBindTexture(GL_TEXTURE_2D, texture);
}
GLuint filter = linear ? GL_LINEAR : GL_NEAREST;
if (filter != this->filter) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
this->filter = filter;
GLuint new_filter = linear ? GL_LINEAR : GL_NEAREST;
if (new_filter != this->filter) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, new_filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, new_filter);
filter = new_filter;
}
}
// overload ::bind for prerendered raster textures
void Raster::bind(const GLuint texture) {
void Raster::bind(const GLuint custom_texture) {
if (img && !textured) {
glBindTexture(GL_TEXTURE_2D, texture);
glBindTexture(GL_TEXTURE_2D, custom_texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, img->getData());
img.reset();
textured = true;
} else if (textured) {
glBindTexture(GL_TEXTURE_2D, texture);
glBindTexture(GL_TEXTURE_2D, custom_texture);
}
GLuint filter = GL_LINEAR;
if (filter != this->filter) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
this->filter = filter;
GLuint new_filter = GL_LINEAR;
if (new_filter != this->filter) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, new_filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, new_filter);
filter = new_filter;
}
}

20
src/util/timer.cpp
View File

@@ -8,22 +8,22 @@
using namespace mbgl::util;
timer::timer(Event event)
: event(event), start(now()) {}
timer::timer(Event event_)
: event(event_), start(now()) {}
timer::timer(EventSeverity severity, Event event)
: severity(severity), event(event), start(now()) {}
timer::timer(EventSeverity severity_, Event event_)
: severity(severity_), event(event_), start(now()) {}
timer::timer(const std::string &name, Event event)
: name(name), event(event), start(now()) {}
timer::timer(const std::string &name_, Event event_)
: name(name_), event(event_), start(now()) {}
timer::timer(const std::string &name, EventSeverity severity, Event event)
: name(name), severity(severity), event(event), start(now()) {}
timer::timer(const std::string &name_, EventSeverity severity_, Event event_)
: name(name_), severity(severity_), event(event_), start(now()) {}
void timer::report(const std::string &name) {
void timer::report(const std::string &name_) {
timestamp duration = now() - start;
Log::Record(severity, event, name + ": " + std::to_string((double)(duration) / 1_millisecond) + "ms");
Log::Record(severity, event, name_ + ": " + std::to_string((double)(duration) / 1_millisecond) + "ms");
start += duration;
}