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
Makefile
View File

@@ -98,5 +98,5 @@ clean: clear_xcode_cache
distclean: clean
-rm -rf ./mason_packages
.PHONY: mbgl test linux build/test/Makefile
.PHONY: mbgl test linux build/test/Makefile clean distclean
# DO NOT DELETE

2
common/glfw_view.cpp
View File

@@ -2,7 +2,7 @@
#include <mbgl/util/string.hpp>
GLFWView::GLFWView(bool fullscreen) : fullscreen(fullscreen) {
GLFWView::GLFWView(bool fullscreen_) : fullscreen(fullscreen_) {
#ifdef NVIDIA
glDiscardFramebufferEXT = (PFNGLDISCARDFRAMEBUFFEREXTPROC)glfwGetProcAddress("glDiscardFramebufferEXT");
#endif

4
include/csscolorparser/csscolorparser.hpp
View File

@@ -31,8 +31,8 @@ namespace CSSColorParser {
struct Color {
inline Color() {}
inline Color(unsigned char r, unsigned char g, unsigned char b, float a)
: r(r), g(g), b(b), a(a) {}
inline Color(unsigned char r_, unsigned char g_, unsigned char b_, float a_)
: r(r_), g(g_), b(b_), a(a_) {}
unsigned char r = 0, g = 0, b = 0;
float a = 1.0f;
};

8
include/mbgl/geometry/anchor.hpp
View File

@@ -12,10 +12,10 @@ struct Anchor {
float scale = 0.0f;
int segment = -1;
explicit Anchor(float x, float y, float angle, float scale)
: x(x), y(y), angle(angle), scale(scale) {}
explicit Anchor(float x, float y, float angle, float scale, int segment)
: x(x), y(y), angle(angle), scale(scale), segment(segment) {}
explicit Anchor(float x_, float y_, float angle_, float scale_)
: x(x_), y(y_), angle(angle_), scale(scale_) {}
explicit Anchor(float x_, float y_, float angle_, float scale_, int segment_)
: x(x_), y(y_), angle(angle_), scale(scale_), segment(segment_) {}
};
typedef std::vector<Anchor> Anchors;

6
include/mbgl/geometry/elements_buffer.hpp
View File

@@ -16,9 +16,9 @@ struct ElementGroup : public util::noncopyable {
uint32_t elements_length;
ElementGroup() : vertex_length(0), elements_length(0) {}
ElementGroup(uint32_t vertex_length, uint32_t elements_length)
: vertex_length(vertex_length),
elements_length(elements_length) {
ElementGroup(uint32_t vertex_length_, uint32_t elements_length_)
: vertex_length(vertex_length_),
elements_length(elements_length_) {
}
ElementGroup(ElementGroup &&rhs) noexcept

4
include/mbgl/geometry/geometry.hpp
View File

@@ -30,8 +30,8 @@ private:
int32_t ox, oy;
};
Geometry::Geometry(pbf& data)
: data(data),
Geometry::Geometry(pbf& data_)
: data(data_),
cmd(1),
length(0),
x(0), y(0),

4
include/mbgl/geometry/glyph_atlas.hpp
View File

@@ -18,8 +18,8 @@ public:
private:
struct GlyphValue {
GlyphValue(const Rect<uint16_t>& rect, uint64_t id)
: rect(rect), ids({ id }) {}
GlyphValue(const Rect<uint16_t>& rect_, uint64_t id)
: rect(rect_), ids({ id }) {}
Rect<uint16_t> rect;
std::set<uint64_t> ids;
};

4
include/mbgl/map/tile.hpp
View File

@@ -37,8 +37,8 @@ public:
const int8_t z = 0;
const int32_t x = 0, y = 0;
inline explicit ID(int8_t z, int32_t x, int32_t y)
: w((x < 0 ? x - (1 << z) + 1 : x) / (1 << z)), z(z), x(x), y(y) {}
inline explicit ID(int8_t z_, int32_t x_, int32_t y_)
: w((x_ < 0 ? x_ - (1 << z_) + 1 : x_) / (1 << z_)), z(z_), x(x_), y(y_) {}
inline uint64_t to_uint64() const {
return ((std::pow(2, z) * y + x) * 32) + z;

4
include/mbgl/map/view.hpp
View File

@@ -22,8 +22,8 @@ enum MapChange : uint8_t {
class View {
public:
virtual void initialize(Map *map) {
this->map = map;
virtual void initialize(Map *map_) {
map = map_;
}
// Called from the render (=GL) thread. Signals that the context should

2
include/mbgl/renderer/frame_history.hpp
View File

@@ -11,7 +11,7 @@
namespace mbgl {
struct FrameSnapshot {
explicit inline FrameSnapshot(timestamp t, float z) : t(t), z(z) {}
explicit inline FrameSnapshot(timestamp t_, float z_) : t(t_), z(z_) {}
float t;
float z;
};

8
include/mbgl/renderer/painter.hpp
View File

@@ -154,10 +154,10 @@ public:
// used to composite images and flips the geometry upside down
const mat4 flipMatrix = []{
mat4 flipMatrix;
matrix::ortho(flipMatrix, 0, 4096, -4096, 0, 0, 1);
matrix::translate(flipMatrix, flipMatrix, 0, -4096, 0);
return flipMatrix;
mat4 flip;
matrix::ortho(flip, 0, 4096, -4096, 0, 0, 1);
matrix::translate(flip, flip, 0, -4096, 0);
return flip;
}();
const mat4 identityMatrix = []{

4
include/mbgl/style/class_properties.hpp
View File

@@ -12,8 +12,8 @@ namespace mbgl {
class ClassProperties {
public:
inline ClassProperties() {}
inline ClassProperties(ClassProperties &&properties)
: properties(std::move(properties.properties)) {}
inline ClassProperties(ClassProperties &&properties_)
: properties(std::move(properties_.properties)) {}
inline void set(PropertyKey key, const PropertyValue &value) {
properties.emplace(key, value);

6
include/mbgl/style/filter_comparison.hpp
View File

@@ -24,8 +24,8 @@ public:
class Instance {
public:
Instance(Operator op, std::vector<Value> &&values)
: op(op), values(values) {}
Instance(Operator op_, std::vector<Value> &&values_)
: op(op_), values(values_) {}
bool compare(const std::vector<Value> &property_values) const;
@@ -37,7 +37,7 @@ public:
};
public:
FilterComparison(const std::string &field) : field(field) {};
FilterComparison(const std::string &field_) : field(field_) {};
const std::string &getField() const;
template <typename Extractor> inline bool compare(const Extractor &extractor) const;

2
include/mbgl/style/filter_expression.hpp
View File

@@ -28,7 +28,7 @@ public:
public:
FilterExpression() = default;
FilterExpression(Operator op) : op(op) {};
FilterExpression(Operator op_) : op(op_) {};
bool empty() const;

6
include/mbgl/style/function_properties.hpp
View File

@@ -9,7 +9,7 @@ namespace mbgl {
template <typename T>
struct ConstantFunction {
inline ConstantFunction(const T &value) : value(value) {}
inline ConstantFunction(const T &value_) : value(value_) {}
inline T evaluate(float) const { return value; }
private:
@@ -18,7 +18,7 @@ private:
template <typename T>
struct StopsFunction {
inline StopsFunction(const std::vector<std::pair<float, T>> &values, float base) : values(values), base(base) {}
inline StopsFunction(const std::vector<std::pair<float, T>> &values_, float base_) : values(values_), base(base_) {}
T evaluate(float z) const;
private:
@@ -36,7 +36,7 @@ using Function = mapbox::util::variant<
template <typename T>
struct FunctionEvaluator {
typedef T result_type;
inline FunctionEvaluator(float z) : z(z) {}
inline FunctionEvaluator(float z_) : z(z_) {}
inline result_type operator()(const std::false_type &) {
return result_type();

4
include/mbgl/style/style_source.hpp
View File

@@ -36,8 +36,8 @@ public:
bool enabled = false;
util::ptr<Source> source;
StyleSource(const util::ptr<SourceInfo> &info)
: info(info)
StyleSource(const util::ptr<SourceInfo> &info_)
: info(info_)
{}
};

1
include/mbgl/text/collision.hpp
View File

@@ -6,6 +6,7 @@
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-variable"
#pragma GCC diagnostic ignored "-Wshadow"
#ifdef __clang__
#pragma GCC diagnostic ignored "-Wdeprecated-register"
#else

10
include/mbgl/text/glyph.hpp
View File

@@ -30,9 +30,9 @@ struct GlyphMetrics {
struct Glyph {
inline explicit Glyph() : rect(0, 0, 0, 0), metrics() {}
inline explicit Glyph(const Rect<uint16_t> &rect,
const GlyphMetrics &metrics)
: rect(rect), metrics(metrics) {}
inline explicit Glyph(const Rect<uint16_t> &rect_,
const GlyphMetrics &metrics_)
: rect(rect_), metrics(metrics_) {}
operator bool() const {
return metrics || rect;
@@ -46,8 +46,8 @@ typedef std::map<uint32_t, Glyph> GlyphPositions;
class PositionedGlyph {
public:
inline explicit PositionedGlyph(uint32_t glyph, float x, float y)
: glyph(glyph), x(x), y(y) {}
inline explicit PositionedGlyph(uint32_t glyph_, float x_, float y_)
: glyph(glyph_), x(x_), y(y_) {}
uint32_t glyph = 0;
float x = 0;

56
include/mbgl/text/types.hpp
View File

@@ -28,24 +28,24 @@ struct CollisionRect {
CollisionPoint::Type bx,
CollisionPoint::Type by)
: tl(ax, ay), br(bx, by) {}
inline explicit CollisionRect(const CollisionPoint &tl,
const CollisionPoint &br)
: tl(tl), br(br) {}
inline explicit CollisionRect(const CollisionPoint &tl_,
const CollisionPoint &br_)
: tl(tl_), br(br_) {}
};
// These are the glyph boxes that we want to have placed.
struct GlyphBox {
explicit GlyphBox() {}
explicit GlyphBox(const CollisionRect &box,
const CollisionAnchor &anchor,
float minScale,
float maxScale,
float padding)
: box(box), anchor(anchor), minScale(minScale), maxScale(maxScale), padding(padding) {}
explicit GlyphBox(const CollisionRect &box,
float minScale,
float padding)
: box(box), minScale(minScale), padding(padding) {}
explicit GlyphBox(const CollisionRect &box_,
const CollisionAnchor &anchor_,
float minScale_,
float maxScale_,
float padding_)
: box(box_), anchor(anchor_), minScale(minScale_), maxScale(maxScale_), padding(padding_) {}
explicit GlyphBox(const CollisionRect &box_,
float minScale_,
float padding_)
: box(box_), minScale(minScale_), padding(padding_) {}
CollisionRect box;
CollisionAnchor anchor;
@@ -60,19 +60,19 @@ typedef std::vector<GlyphBox> GlyphBoxes;
// TODO: Transform the vec2<float>s to vec2<int16_t> to save bytes
struct PlacedGlyph {
explicit PlacedGlyph(const vec2<float> &tl, const vec2<float> &tr,
const vec2<float> &bl, const vec2<float> &br,
const Rect<uint16_t> &tex, float angle, const vec2<float> &anchor,
float minScale, float maxScale)
: tl(tl),
tr(tr),
bl(bl),
br(br),
tex(tex),
angle(angle),
anchor(anchor),
minScale(minScale),
maxScale(maxScale) {}
explicit PlacedGlyph(const vec2<float> &tl_, const vec2<float> &tr_,
const vec2<float> &bl_, const vec2<float> &br_,
const Rect<uint16_t> &tex_, float angle_, const vec2<float> &anchor_,
float minScale_, float maxScale_)
: tl(tl_),
tr(tr_),
bl(bl_),
br(br_),
tex(tex_),
angle(angle_),
anchor(anchor_),
minScale(minScale_),
maxScale(maxScale_) {}
vec2<float> tl, tr, bl, br;
Rect<uint16_t> tex;
@@ -96,8 +96,8 @@ struct PlacementBox {
struct PlacementProperty {
explicit PlacementProperty() {}
explicit PlacementProperty(float zoom, const PlacementRange &rotationRange)
: zoom(zoom), rotationRange(rotationRange) {}
explicit PlacementProperty(float zoom_, const PlacementRange &rotationRange_)
: zoom(zoom_), rotationRange(rotationRange_) {}
inline operator bool() const {
return !std::isnan(zoom) && zoom != std::numeric_limits<float>::infinity() &&

8
include/mbgl/util/enum.hpp
View File

@@ -21,11 +21,11 @@ private:
static constexpr inline bool compare(const char *a, const char *b) {
return *a == *b && (*a == '\0' || compare(a + 1, b + 1));
}
static constexpr inline const char *lookup_type(Type e, EnumValue<Type> const * const l, size_t r) {
return r == 0 ? "" : l->value == e ? l->name : lookup_type(e, l + 1, r - 1);
static constexpr inline const char *lookup_type(Type e, EnumValue<Type> const * const list, size_t r) {
return r == 0 ? "" : list->value == e ? list->name : lookup_type(e, list + 1, r - 1);
}
static constexpr inline Type lookup_name(const char *n, EnumValue<Type> const * const l, size_t r) {
return r == 0 ? Type(-1) : compare(l->name, n) ? l->value : lookup_name(n, l + 1, r - 1);
static constexpr inline Type lookup_name(const char *n, EnumValue<Type> const * const list, size_t r) {
return r == 0 ? Type(-1) : compare(list->name, n) ? list->value : lookup_name(n, list + 1, r - 1);
}
public:
inline constexpr Enum(const char *n) : value(lookup_name(n, names, length)) {}

2
include/mbgl/util/error.hpp
View File

@@ -8,7 +8,7 @@ namespace mbgl {
namespace error {
struct style_parse : std::exception {
inline style_parse(size_t offset, const char *msg) : offset(offset), msg(msg) {}
inline style_parse(size_t offset_, const char *msg_) : offset(offset_), msg(msg_) {}
inline const char* what() const noexcept { return msg.c_str(); }
const size_t offset;
const std::string msg;

6
include/mbgl/util/pbf.hpp
View File

@@ -49,9 +49,9 @@ struct pbf {
uint32_t tag = 0;
};
pbf::pbf(const unsigned char *data, size_t length)
: data(data),
end(data + length),
pbf::pbf(const unsigned char *data_, size_t length)
: data(data_),
end(data_ + length),
value(0),
tag(0) {
}

2
include/mbgl/util/rect.hpp
View File

@@ -6,7 +6,7 @@ namespace mbgl {
template <typename T>
struct Rect {
inline Rect() {}
inline Rect(T x, T y, T w, T h) : x(x), y(y), w(w), h(h) {}
inline Rect(T x_, T y_, T w_, T h_) : x(x_), y(y_), w(w_), h(h_) {}
T x = 0, y = 0;
T w = 0, h = 0;

20
include/mbgl/util/transition.hpp
View File

@@ -15,9 +15,9 @@ public:
complete
};
inline transition(timestamp start, timestamp duration)
: start(start),
duration(duration) {}
inline transition(timestamp start_, timestamp duration_)
: start(start_),
duration(duration_) {}
inline float progress(timestamp now) const {
if (duration == 0) return 1;
@@ -36,11 +36,11 @@ protected:
template <typename T>
class ease_transition : public transition {
public:
ease_transition(T from, T to, T& value, timestamp start, timestamp duration)
ease_transition(T from_, T to_, T& value_, timestamp start, timestamp duration)
: transition(start, duration),
from(from),
to(to),
value(value) {}
from(from_),
to(to_),
value(value_) {}
state update(timestamp now) const;
@@ -53,10 +53,10 @@ private:
template <typename T>
class timeout : public transition {
public:
timeout(T final_value, T& value, timestamp start, timestamp duration)
timeout(T final_value_, T& value_, timestamp start, timestamp duration)
: transition(start, duration),
final_value(final_value),
value(value) {}
final_value(final_value_),
value(value_) {}
state update(timestamp now) const {
if (progress(now) >= 1) {

16
include/mbgl/util/uv_detail.hpp
View File

@@ -68,7 +68,7 @@ private:
class lock {
public:
lock(mutex &mtx) : mtx(mtx) { mtx.lock(); }
lock(mutex &mtx_) : mtx(mtx_) { mtx.lock(); }
~lock() { mtx.unlock(); }
private:
@@ -94,8 +94,8 @@ private:
class readlock {
public:
inline readlock(rwlock &mtx) : mtx(mtx) { mtx.rdlock(); }
inline readlock(const std::unique_ptr<rwlock> &mtx) : mtx(*mtx) { mtx->rdlock(); }
inline readlock(rwlock &mtx_) : mtx(mtx_) { mtx.rdlock(); }
inline readlock(const std::unique_ptr<rwlock> &mtx_) : mtx(*mtx_) { mtx.rdlock(); }
inline ~readlock() { mtx.rdunlock(); }
private:
@@ -104,8 +104,8 @@ private:
class writelock {
public:
inline writelock(rwlock &mtx) : mtx(mtx) { mtx.wrlock(); }
inline writelock(const std::unique_ptr<rwlock> &mtx) : mtx(*mtx) { mtx->wrlock(); }
inline writelock(rwlock &mtx_) : mtx(mtx_) { mtx.wrlock(); }
inline writelock(const std::unique_ptr<rwlock> &mtx_) : mtx(*mtx_) { mtx.wrlock(); }
inline ~writelock() { mtx.wrunlock(); }
private:
@@ -148,10 +148,10 @@ public:
typedef void (*after_work_callback)(T &object);
template<typename... Args>
work(worker &worker, work_callback work_cb, after_work_callback after_work_cb, Args&&... args)
work(worker &worker, work_callback work_cb_, after_work_callback after_work_cb_, Args&&... args)
: data(std::forward<Args>(args)...),
work_cb(work_cb),
after_work_cb(after_work_cb) {
work_cb(work_cb_),
after_work_cb(after_work_cb_) {
worker.add(this, do_work, after_work);
}

6
include/mbgl/util/vec.hpp
View File

@@ -29,7 +29,7 @@ struct vec2 {
template<typename U>
inline vec2(const U& u) : x(u.x), y(u.y) {}
inline vec2(T x, T y) : x(x), y(y) {}
inline vec2(T x_, T y_) : x(x_), y(y_) {}
inline bool operator==(const vec2& rhs) const {
return x == rhs.x && y == rhs.y;
@@ -86,7 +86,7 @@ struct vec3 {
inline vec3() {}
inline vec3(const vec3& o) : x(o.x), y(o.y), z(o.z) {}
inline vec3(T x, T y, T z) : x(x), y(y), z(z) {}
inline vec3(T x_, T y_, T z_) : x(x_), y(y_), z(z_) {}
inline bool operator==(const vec3& rhs) const {
return x == rhs.x && y == rhs.y && z == rhs.z;
}
@@ -98,7 +98,7 @@ struct vec4 {
inline vec4() {}
inline vec4(const vec4& o) : x(o.x), y(o.y), z(o.z), w(o.w) {}
inline vec4(T x, T y, T z, T w) : x(x), y(y), z(z), w(w) {}
inline vec4(T x_, T y_, T z_, T w_) : x(x_), y(y_), z(z_), w(w_) {}
inline bool operator==(const vec4& rhs) const {
return x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w;
}

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;
}

2
test/comparisons.cpp
View File

@@ -10,7 +10,7 @@
class MockExtractor {
public:
inline MockExtractor(const std::multimap<std::string, mbgl::Value> &values) : values(values) {}
inline MockExtractor(const std::multimap<std::string, mbgl::Value> &values_) : values(values_) {}
inline MockExtractor() {}
inline std::vector<mbgl::Value> getValues(const std::string &key) const {

16
test/fixtures/fixture_log.hpp vendored
View File

@@ -13,14 +13,14 @@ namespace mbgl {
class FixtureLogBackend : public LogBackend, private util::noncopyable {
public:
struct LogMessage {
inline LogMessage(EventSeverity severity, Event event, int64_t code, const std::string &msg)
: severity(severity), event(event), code(code), msg(msg) {}
inline LogMessage(EventSeverity severity, Event event, int64_t code)
: severity(severity), event(event), code(code), msg() {}
inline LogMessage(EventSeverity severity, Event event, const std::string &msg)
: severity(severity), event(event), code(), msg(msg) {}
inline LogMessage(EventSeverity severity, Event event)
: severity(severity), event(event), code(), msg() {}
inline LogMessage(EventSeverity severity_, Event event_, int64_t code_, const std::string &msg_)
: severity(severity_), event(event_), code(code_), msg(msg_) {}
inline LogMessage(EventSeverity severity_, Event event_, int64_t code_)
: severity(severity_), event(event_), code(code_), msg() {}
inline LogMessage(EventSeverity severity_, Event event_, const std::string &msg_)
: severity(severity_), event(event_), code(), msg(msg_) {}
inline LogMessage(EventSeverity severity_, Event event_)
: severity(severity_), event(event_), code(), msg() {}
inline bool operator==(const LogMessage &rhs) const {
return (!severity || !rhs.severity || severity.get() == rhs.severity.get()) &&