Merge branch 'beta' into faster-rebuilds

Author: uvcat7

src/Core/ByteStream.cpp

@@ -11,15 +11,15 @@ namespace Vortex {
 // WriteStream.
 
 WriteStream::WriteStream() {
-    buffer_ = (uint8_t*)malloc(128);
+    buffer_ = static_cast<uint8_t*>(malloc(128));
     current_size_ = 0;
     capacity_ = 128;
     is_external_buffer_ = false;
     is_write_successful_ = true;
 }
 
 WriteStream::WriteStream(void* out, int bytes) {
-    buffer_ = (uint8_t*)out;
+    buffer_ = static_cast<uint8_t*>(out);
     current_size_ = 0;
     capacity_ = bytes;
     is_external_buffer_ = true;
@@ -37,7 +37,7 @@ void WriteStream::write(const void* in, int bytes) {
         current_size_ = newSize;
     } else if (!is_external_buffer_) {
         capacity_ = max(capacity_ << 1, newSize);
-        buffer_ = (uint8_t*)realloc(buffer_, capacity_);
+        buffer_ = static_cast<uint8_t*>(realloc(buffer_, capacity_));
         memcpy(buffer_ + current_size_, in, bytes);
         current_size_ = newSize;
     } else {
@@ -47,12 +47,12 @@ void WriteStream::write(const void* in, int bytes) {
 
 void WriteStream::write8(const void* val) {
     if (current_size_ < capacity_) {
-        buffer_[current_size_] = *(const uint8_t*)val;
+        buffer_[current_size_] = *static_cast<const uint8_t*>(val);
         ++current_size_;
     } else if (!is_external_buffer_) {
         capacity_ <<= 1;
-        buffer_ = (uint8_t*)realloc(buffer_, capacity_);
-        buffer_[current_size_] = *(const uint8_t*)val;
+        buffer_ = static_cast<uint8_t*>(realloc(buffer_, capacity_));
+        buffer_[current_size_] = *static_cast<const uint8_t*>(val);
         ++current_size_;
     } else {
         is_write_successful_ = false;
@@ -62,12 +62,14 @@ void WriteStream::write8(const void* val) {
 void WriteStream::write16(const void* val) {
     int newSize = current_size_ + sizeof(uint16_t);
     if (newSize <= capacity_) {
-        *(uint16_t*)(buffer_ + current_size_) = *(const uint16_t*)val;
+        *reinterpret_cast<uint16_t*>(buffer_ + current_size_) =
+            *static_cast<const uint16_t*>(val);
         current_size_ = newSize;
     } else if (!is_external_buffer_) {
         capacity_ <<= 1;
-        buffer_ = (uint8_t*)realloc(buffer_, capacity_);
-        *(uint16_t*)(buffer_ + current_size_) = *(const uint16_t*)val;
+        buffer_ = static_cast<uint8_t*>(realloc(buffer_, capacity_));
+        *reinterpret_cast<uint16_t*>(buffer_ + current_size_) =
+            *static_cast<const uint16_t*>(val);
         current_size_ = newSize;
     } else {
         is_write_successful_ = false;
@@ -77,12 +79,14 @@ void WriteStream::write16(const void* val) {
 void WriteStream::write32(const void* val) {
     int newSize = current_size_ + sizeof(uint32_t);
     if (newSize <= capacity_) {
-        *(uint32_t*)(buffer_ + current_size_) = *(const uint32_t*)val;
+        *reinterpret_cast<uint32_t*>(buffer_ + current_size_) =
+            *static_cast<const uint32_t*>(val);
         current_size_ = newSize;
     } else if (!is_external_buffer_) {
         capacity_ <<= 1;
-        buffer_ = (uint8_t*)realloc(buffer_, capacity_);
-        *(uint32_t*)(buffer_ + current_size_) = *(const uint32_t*)val;
+        buffer_ = static_cast<uint8_t*>(realloc(buffer_, capacity_));
+        *reinterpret_cast<uint32_t*>(buffer_ + current_size_) =
+            *static_cast<const uint32_t*>(val);
         current_size_ = newSize;
     } else {
         is_write_successful_ = false;
@@ -92,12 +96,14 @@ void WriteStream::write32(const void* val) {
 void WriteStream::write64(const void* val) {
     int newSize = current_size_ + sizeof(uint64_t);
     if (newSize <= capacity_) {
-        *(uint64_t*)(buffer_ + current_size_) = *(const uint64_t*)val;
+        *reinterpret_cast<uint64_t*>(buffer_ + current_size_) =
+            *static_cast<const uint64_t*>(val);
         current_size_ = newSize;
     } else if (!is_external_buffer_) {
         capacity_ <<= 1;
-        buffer_ = (uint8_t*)realloc(buffer_, capacity_);
-        *(uint64_t*)(buffer_ + current_size_) = *(const uint64_t*)val;
+        buffer_ = static_cast<uint8_t*>(realloc(buffer_, capacity_));
+        *reinterpret_cast<uint64_t*>(buffer_ + current_size_) =
+            *static_cast<const uint64_t*>(val);
         current_size_ = newSize;
     } else {
         is_write_successful_ = false;
@@ -129,12 +135,12 @@ void WriteStream::writeStr(const std::string& str) {
 // ReadStream.
 
 ReadStream::ReadStream(const void* in, int bytes) {
-    read_position_ = (const uint8_t*)in;
+    read_position_ = static_cast<const uint8_t*>(in);
     end_position_ = read_position_ + bytes;
     is_read_successful_ = true;
 }
 
-ReadStream::~ReadStream() {}
+ReadStream::~ReadStream() = default;
 
 void ReadStream::skip(int bytes) {
     if (read_position_ + bytes <= end_position_) {
@@ -157,10 +163,10 @@ void ReadStream::read(void* out, int bytes) {
 
 void ReadStream::read8(void* out) {
     if (read_position_ != end_position_) {
-        *(uint8_t*)out = *read_position_;
+        *static_cast<uint8_t*>(out) = *read_position_;
         ++read_position_;
     } else {
-        *(uint8_t*)out = 0;
+        *static_cast<uint8_t*>(out) = 0;
         read_position_ = end_position_;
         is_read_successful_ = false;
     }
@@ -169,10 +175,11 @@ void ReadStream::read8(void* out) {
 void ReadStream::read16(void* out) {
     auto newPos = read_position_ + sizeof(uint16_t);
     if (newPos <= end_position_) {
-        *(uint16_t*)out = *(const uint16_t*)read_position_;
+        *static_cast<uint16_t*>(out) =
+            *reinterpret_cast<const uint16_t*>(read_position_);
         read_position_ = newPos;
     } else {
-        *(uint16_t*)out = 0;
+        *static_cast<uint16_t*>(out) = 0;
         read_position_ = end_position_;
         is_read_successful_ = false;
     }
@@ -181,10 +188,11 @@ void ReadStream::read16(void* out) {
 void ReadStream::read32(void* out) {
     auto newPos = read_position_ + sizeof(uint32_t);
     if (newPos <= end_position_) {
-        *(uint32_t*)out = *(const uint32_t*)read_position_;
+        *static_cast<uint32_t*>(out) =
+            *reinterpret_cast<const uint32_t*>(read_position_);
         read_position_ = newPos;
     } else {
-        *(uint32_t*)out = 0;
+        *static_cast<uint32_t*>(out) = 0;
         read_position_ = end_position_;
         is_read_successful_ = false;
     }
@@ -193,10 +201,11 @@ void ReadStream::read32(void* out) {
 void ReadStream::read64(void* out) {
     auto newPos = read_position_ + sizeof(uint64_t);
     if (newPos <= end_position_) {
-        *(uint64_t*)out = *(const uint64_t*)read_position_;
+        *static_cast<uint64_t*>(out) =
+            *reinterpret_cast<const uint64_t*>(read_position_);
         read_position_ = newPos;
     } else {
-        *(uint64_t*)out = 0;
+        *static_cast<uint64_t*>(out) = 0;
         read_position_ = end_position_;
         is_read_successful_ = false;
     }
@@ -241,7 +250,7 @@ std::string ReadStream::readStr() {
     if (newPos <= end_position_) {
         auto str = read_position_;
         read_position_ = newPos;
-        return std::string((const char*)str, len);
+        return std::string(reinterpret_cast<const char*>(str), len);
     }
     read_position_ = end_position_;
     is_read_successful_ = false;

src/Core/Canvas.cpp

@@ -61,16 +61,16 @@ struct GetLineDist : public DistanceFunc {
     GetLineDist(float ax, float ay, float bx, float by, float size)
         : ax(ax), ay(ay), bx(bx), by(by), size(size) {}
 
-    float Get(float px, float py) const {
+    float Get(float px, float py) const override {
         float num = (px - ax) * (bx - ax) + (py - ay) * (by - ay);
         float den = (bx - ax) * (bx - ax) + (by - ay) * (by - ay);
         float rdn = 1 / den, r = num * rdn;
         float s = ((ay - py) * (bx - ax) - (ax - px) * (by - ay)) * rdn;
-        if (r >= 0 && r <= 1) return (float)fabs(s * sqrt(den)) - size;
+        if (r >= 0 && r <= 1) return fabs(s * sqrt(den)) - size;
 
         float d1sq = (px - ax) * (px - ax) + (py - ay) * (py - ay);
         float d2sq = (px - bx) * (px - bx) + (py - by) * (py - by);
-        return (float)sqrt(d1sq < d2sq ? d1sq : d2sq) - size;
+        return sqrt(d1sq < d2sq ? d1sq : d2sq) - size;
     }
 };
 
@@ -80,9 +80,9 @@ struct GetCircleDist : public DistanceFunc {
 
     GetCircleDist(float x, float y, float r) : x(x), y(y), r(r) {}
 
-    float Get(float px, float py) const {
+    float Get(float px, float py) const override {
         float dx = px - x, dy = py - y;
-        return (float)sqrt(dx * dx + dy * dy) - r;
+        return sqrt(dx * dx + dy * dy) - r;
     }
 };
 
@@ -93,7 +93,7 @@ struct GetRoundRectDist : public DistanceFunc {
     GetRoundRectDist(float x1, float y1, float x2, float y2, float r)
         : x1(x1), y1(y1), x2(x2), y2(y2), r(r) {}
 
-    float Get(float px, float py) const {
+    float Get(float px, float py) const override {
         float x = min(max(px, x1 + r), x2 - r);
         float y = min(max(py, y1 + r), y2 - r);
         if (x == px && y == py) {
@@ -102,7 +102,7 @@ struct GetRoundRectDist : public DistanceFunc {
             return -min(dx, dy);
         } else {
             float dx = px - x, dy = py - y;
-            return (float)sqrt(dx * dx + dy * dy) - r;
+            return sqrt(dx * dx + dy * dy) - r;
         }
     }
 };
@@ -124,7 +124,7 @@ struct GetPolyDist : public DistanceFunc {
         return (numIntersects & 1);
     }
 
-    float Get(float px, float py) const {
+    float Get(float px, float py) const override {
         float d = 1e10;
         for (int i = 0, j = count - 1; i < count; j = i, ++i) {
             GetLineDist ld(x[i], y[i], x[j], y[j], 0);
@@ -163,28 +163,28 @@ void Canvas::Data::draw(float* buf, int w, int h, const areaf& area,
     if (blendMode == Canvas::BM_ALPHA) blendfunc = BlendAlpha;
     if (blendMode == Canvas::BM_ADD) blendfunc = BlendAdd;
 
-    int x1 = max(mask.l, (int)(area.l - outerGlow - 1 + 0.5f));
-    int y1 = max(mask.t, (int)(area.t - outerGlow - 1 + 0.5f));
-    int x2 = min(mask.r, (int)(area.r + outerGlow + 1 + 0.5f));
-    int y2 = min(mask.b, (int)(area.b + outerGlow + 1 + 0.5f));
+    int x1 = max(mask.l, static_cast<int>(area.l - outerGlow - 1 + 0.5f));
+    int y1 = max(mask.t, static_cast<int>(area.t - outerGlow - 1 + 0.5f));
+    int x2 = min(mask.r, static_cast<int>(area.r + outerGlow + 1 + 0.5f));
+    int y2 = min(mask.b, static_cast<int>(area.b + outerGlow + 1 + 0.5f));
 
     float rh = 1.f / max(1, y2 - y1);
     float rw = 1.f / max(1, x2 - x1);
     float ig = 1.f / (innerGlow + 1);
     float og = 1.f / (outerGlow + 1);
 
-    float yf = (float)y1 + 0.5f;
+    float yf = static_cast<float>(y1) + 0.5f;
     for (int y = y1; y < y2; ++y, yf += 1) {
         RGBA l = tl;
         BlendLinear(l, bl, yf * rh);
         RGBA r = tr;
         BlendLinear(r, br, yf * rh);
 
-        float xf = (float)x1 + 0.5f;
+        float xf = static_cast<float>(x1) + 0.5f;
         for (int x = x1; x < x2; ++x, xf += 1) {
             float dist = func->Get(xf, yf);
             if (dist >= outerGlow + 1) continue;
-            RGBA* dst = (RGBA*)(buf + ((y * w + x) * 4));
+            RGBA* dst = reinterpret_cast<RGBA*>(buf + ((y * w + x) * 4));
             RGBA src = l;
             BlendLinear(src, r, xf * rw);
             if (outline && dist < -0.5f) {
@@ -219,7 +219,7 @@ Canvas::Canvas(int w, int h, float lum)
       canvas_width_(w),
       canvas_height_(h),
       data_(new Canvas::Data) {
-    canvas_data_ = (float*)malloc(w * h * 4 * sizeof(float));
+    canvas_data_ = static_cast<float*>(malloc(w * h * 4 * sizeof(float)));
     data_->mask = {0, 0, canvas_width_, canvas_height_};
     clear(lum);
 }
@@ -303,21 +303,24 @@ void Canvas::box(float x1, float y1, float x2, float y2, float radius) {
 }
 
 void Canvas::box(int x1, int y1, int x2, int y2, float radius) {
-    box((float)x1, (float)y1, (float)x2, (float)y2, radius);
+    box(static_cast<float>(x1), static_cast<float>(y1), static_cast<float>(x2),
+        static_cast<float>(y2), radius);
 }
 
 void Canvas::polygon(const float* x, const float* y, int vertexCount) {
     if (vertexCount < 3) return;
     GetPolyDist func(x, y, vertexCount);
     data_->draw(canvas_data_, canvas_width_, canvas_height_,
-                {0, 0, (float)canvas_width_, (float)canvas_height_}, &func);
+                {0, 0, static_cast<float>(canvas_width_),
+                 static_cast<float>(canvas_height_)},
+                &func);
 }
 
 Texture Canvas::createTexture(bool mipmap) const {
-    uint8_t* dst =
-        (uint8_t*)malloc(canvas_width_ * canvas_height_ * 4 * sizeof(uint8_t));
+    uint8_t* dst = static_cast<uint8_t*>(
+        malloc(canvas_width_ * canvas_height_ * 4 * sizeof(uint8_t)));
     for (int i = 0; i < canvas_width_ * canvas_height_ * 4; ++i) {
-        int v = (int)(canvas_data_[i] * 255.f + 0.5f);
+        int v = static_cast<int>(canvas_data_[i] * 255.f + 0.5f);
         dst[i] = min(max(v, 0), 255);
     }
     Texture result(canvas_width_, canvas_height_, dst, mipmap);
@@ -331,8 +334,8 @@ Canvas& Canvas::operator=(const Canvas& other) {
     canvas_width_ = other.canvas_width_, canvas_height_ = other.canvas_height_,
     canvas_data_ = nullptr;
     if (other.canvas_data_)
-        canvas_data_ =
-            (float*)malloc(canvas_width_ * canvas_height_ * 4 * sizeof(float));
+        canvas_data_ = static_cast<float*>(
+            malloc(canvas_width_ * canvas_height_ * 4 * sizeof(float)));
     memcpy(canvas_data_, other.canvas_data_,
            canvas_width_ * canvas_height_ * 4 * sizeof(float));
     return *this;