Tidy up

Author: floppyhammer

pathfinder/core/d3d9/data/alpha_tile_id.h

@@ -9,8 +9,8 @@
 
 namespace Pathfinder {
 
-const size_t ALPHA_TILE_LEVEL_COUNT = 2;
-const size_t ALPHA_TILES_PER_LEVEL = 1 << (32 - ALPHA_TILE_LEVEL_COUNT + 1);
+constexpr size_t ALPHA_TILE_LEVEL_COUNT = 2;
+constexpr size_t ALPHA_TILES_PER_LEVEL = 1 << (32 - ALPHA_TILE_LEVEL_COUNT + 1);
 
 struct AlphaTileId {
     /// A valid value means a solid tile. Default is invalid.

pathfinder/core/d3d9/scene_builder.h

@@ -47,7 +47,7 @@ class SceneBuilderD3D9 : public SceneBuilder {
     std::vector<Fill> pending_fills;
 
     // Tiles to draw.
-    std::vector<DrawTileBatchD3D9> tile_batches{};
+    std::vector<DrawTileBatchD3D9> tile_batches;
 
     // Metadata texture data.
     std::vector<TextureMetadataEntry> metadata;

pathfinder/core/d3d9/tiler.h

@@ -9,7 +9,7 @@ namespace Pathfinder {
 
 /// This might be the most important class for building on D3D9 level.
 /// One tiler for one outline.
-struct Tiler {
+class Tiler {
 public:
     Tiler(SceneBuilderD3D9& _scene_builder,
           uint32_t path_id,

pathfinder/core/data/dense_tile_map.h

@@ -59,33 +59,31 @@ struct DenseTileMap {
     }
 
     /// A quick way to build z buffer.
-    static inline DenseTileMap z_builder(const RectI &_rect) {
+    static DenseTileMap z_builder(const RectI &_rect) {
         return {std::vector<T>(_rect.width() * _rect.height(), 0), _rect};
     }
 
-    inline T *get(const Vec2I &coords) {
+    T *get(const Vec2I &coords) {
         auto index = coords_to_index(coords);
 
         // We have to make sure the index we get is valid.
         if (index) {
             return &data[*index];
-        } else {
-            return nullptr;
         }
+        return nullptr;
     }
 
     /// A safe call to find index by coordinates.
-    inline std::shared_ptr<size_t> coords_to_index(const Vec2I &coords) {
+    std::shared_ptr<size_t> coords_to_index(const Vec2I &coords) {
         if (rect.contains_point(coords)) {
             return std::make_shared<size_t>(coords_to_index_unchecked(coords));
-        } else {
-            return nullptr;
         }
+        return nullptr;
     }
 
     /// An unsafe call to index by coordinates.
     /// The tile map's top and bottom bounds are not considered.
-    inline int coords_to_index_unchecked(const Vec2I &coords) {
+    int coords_to_index_unchecked(const Vec2I &coords) const {
         return (coords.y - rect.min_y()) * rect.size().x + coords.x - rect.min_x();
     }
 };

pathfinder/core/paint/texture_allocator.cpp

@@ -6,7 +6,7 @@ namespace Pathfinder {
 
 // Invariant: `requested_size` must be a power of two.
 RectI TreeNode::allocate(Vec2I this_origin, uint32_t this_size, uint32_t requested_size) {
-    if (type == TreeNode::Type::FullLeaf) {
+    if (type == Type::FullLeaf) {
         // No room here.
         return RectI();
     }
@@ -16,15 +16,15 @@ RectI TreeNode::allocate(Vec2I this_origin, uint32_t this_size, uint32_t request
     }
 
     // Allocate here or split, as necessary.
-    if (type == TreeNode::Type::EmptyLeaf) {
+    if (type == Type::EmptyLeaf) {
         // Do we have a perfect fit?
         if (this_size == requested_size) {
-            type = TreeNode::Type::FullLeaf;
+            type = Type::FullLeaf;
             return RectI(this_origin, Vec2I(this_size, this_size));
         }
 
         // Split.
-        type = TreeNode::Type::Parent;
+        type = Type::Parent;
 
         for (int i = 0; i < 4; i++) {
             kids[i] = std::make_shared<TreeNode>();
@@ -33,7 +33,7 @@ RectI TreeNode::allocate(Vec2I this_origin, uint32_t this_size, uint32_t request
 
     // Recurse into children.
     switch (type) {
-        case TreeNode::Type::Parent: {
+        case Type::Parent: {
             uint32_t kid_size = this_size / 2;
 
             auto origin = kids[0]->allocate(this_origin, kid_size, requested_size);
@@ -69,7 +69,7 @@ RectI TreeNode::allocate(Vec2I this_origin, uint32_t this_size, uint32_t request
 void TreeNode::free(Vec2I this_origin, uint32_t this_size, Vec2I requested_origin, uint32_t requested_size) {
     if (this_size <= requested_size) {
         if (this_size == requested_size && this_origin == requested_origin) {
-            type = TreeNode::Type::EmptyLeaf;
+            type = Type::EmptyLeaf;
 
             for (int i = 0; i < 4; i++) {
                 kids[i] = nullptr;
@@ -101,7 +101,7 @@ void TreeNode::free(Vec2I this_origin, uint32_t this_size, Vec2I requested_origi
         }
     }
 
-    if (type == TreeNode::Type::Parent) {
+    if (type == Type::Parent) {
         kids[child_index]->free(child_origin, child_size, requested_origin, requested_size);
         merge_if_necessary();
     } else {
@@ -111,22 +111,22 @@ void TreeNode::free(Vec2I this_origin, uint32_t this_size, Vec2I requested_origi
 }
 
 void TreeNode::merge_if_necessary() {
-    if (type == TreeNode::Type::Parent) {
+    if (type == Type::Parent) {
         // Check if all kids are empty leaves.
         bool res = true;
         for (auto &k : kids) {
             if (k == nullptr) {
                 throw std::runtime_error("Parent tree node should not have null kids!");
             }
 
-            if (k->type != TreeNode::Type::EmptyLeaf) {
+            if (k->type != Type::EmptyLeaf) {
                 res = false;
                 break;
             }
         }
 
         if (res) {
-            type = TreeNode::Type::EmptyLeaf;
+            type = Type::EmptyLeaf;
 
             for (int i = 0; i < 4; i++) {
                 kids[i] = nullptr;
@@ -279,12 +279,12 @@ Vec2I TextureAllocator::page_size(uint32_t page_id) {
 
         if (page_allocator.type == TexturePageAllocator::Type::Atlas) {
             return Vec2I(page_allocator.allocator.size);
-        } else {
-            return Vec2I(page_allocator.image_size);
         }
-    } else {
-        throw std::runtime_error("No such texture page!");
+
+        return Vec2I(page_allocator.image_size);
     }
+
+    throw std::runtime_error("No such texture page!");
 }
 
 Vec2F TextureAllocator::page_scale(uint32_t page_id) {
@@ -294,9 +294,9 @@ Vec2F TextureAllocator::page_scale(uint32_t page_id) {
 bool TextureAllocator::page_is_new(uint32_t page_id) {
     if (pages[page_id]) {
         return pages[page_id]->is_new;
-    } else {
-        throw std::runtime_error("No such texture page!");
     }
+
+    throw std::runtime_error("No such texture page!");
 }
 
 void TextureAllocator::mark_all_pages_as_allocated() {
@@ -312,6 +312,7 @@ TexturePageIter TextureAllocator::page_ids() {
     while (first_index < pages.size() && pages[first_index] == nullptr) {
         first_index += 1;
     }
+
     return TexturePageIter{this, first_index};
 }
 
@@ -328,6 +329,7 @@ std::shared_ptr<uint32_t> TexturePageIter::next() {
             break;
         }
     }
+
     return next_id;
 }
 

pathfinder/core/paint/texture_allocator.h

@@ -11,7 +11,7 @@
 
 namespace Pathfinder {
 
-const uint32_t ATLAS_TEXTURE_LENGTH = 1024;
+constexpr uint32_t ATLAS_TEXTURE_LENGTH = 1024;
 
 struct TreeNode {
     enum class Type {