a

4 files changed, 77 insertions, 76 deletions

diff --git a/compat/assert.hpp b/compat/assert.hpp
index b2022231..23dfdf42 100644
--- a/compat/assert.hpp
+++ b/compat/assert.hpp
@@ -1,6 +1,8 @@
 #pragma once
 #include "defs.hpp"
+#include <cstdio>
 #include <limits>
+#include <type_traits>
 
 namespace Magnum::Examples {
 
@@ -21,46 +23,48 @@ struct out_of_range final : exception {
     ssize_t max = std::numeric_limits<ssize_t>::max();
 };
 
-struct key_error final : exception {
-    ssize_t value = 0;
-};
-
-#define KEY_ERROR(value) \
-    ::Magnum::Examples::key_error{{__FILE__, FUNCTION_NAME, __LINE__}, (value)}
-
-#define OUT_OF_RANGE(value, min, max)                           \
-    ::Magnum::Examples::out_of_range{                           \
-        {__FILE__, FUNCTION_NAME, __LINE__},                    \
-        ::Magnum::Examples::ssize_t((value)),                   \
-        ::Magnum::Examples::ssize_t((min)),                     \
-        ::Magnum::Examples::ssize_t((max))                      \
+#define OUT_OF_RANGE(value, min, max)                                       \
+    ::Magnum::Examples::out_of_range{                                       \
+        {__FILE__, FUNCTION_NAME, __LINE__},                                \
+        ::Magnum::Examples::ssize_t((value)),                               \
+        ::Magnum::Examples::ssize_t((min)),                                 \
+        ::Magnum::Examples::ssize_t((max))                                  \
     }
 
-#define ABORT_WITH(exc_type, ...) ([&]() {                      \
-    exc_type _e;                                                \
-    _e.line = __LINE__;                                         \
-    _e.file = __FILE__;                                         \
-    _e.function = FUNCTION_NAME;                                \
-    std::snprintf(_e.msg, sizeof(_e.msg), __VA_ARGS__);         \
-    throw _e;/*NOLINT(misc-throw-by-value-catch-by-reference)*/ \
+#define ABORT_WITH(exc_type, ...) ([&]() { \
+    if (std::is_constant_evaluated()) {                                     \
+        exc_type _e;                                                        \
+        _e.line = __LINE__;                                                 \
+        _e.file = __FILE__;                                                 \
+        _e.function = FUNCTION_NAME;                                        \
+        std::snprintf(_e.msg, sizeof(_e.msg), __VA_ARGS__);                 \
+        throw _e;/*NOLINT(misc-throw-by-value-catch-by-reference)*/         \
+    } else                                                                  \
+        throw "aborting";                                                   \
 }())
 
 #define ABORT(...) \
-    ABORT_WITH(::Magnum::Examples::assertion_failure, __VA_ARGS__)
+    do {                                                                    \
+        if (std::is_constant_evaluated())                                   \
+            throw "aborting";                                               \
+        else                                                                \
+            ABORT_WITH(::Magnum::Examples::assertion_failure, __VA_ARGS__); \
+    } while (false)
 
-#define ASSERT(expr)                                            \
-    do {                                                        \
-        if (!(expr))                                            \
-            ABORT("assertion failed: '%s' in %s:%d",            \
-                  #expr, __FILE__, __LINE__);                   \
+#define ASSERT(expr)                                                        \
+    do {                                                                    \
+        if (!(expr)) {                                                      \
+            ABORT("assertion failed: '%s' in %s:%d",                        \
+                  #expr, __FILE__, __LINE__);                               \
+        }                                                                   \
     } while(false)
 
-#define GAME_DEBUG_OUT(pfx, ...) ([&]() {                       \
-    if constexpr (sizeof((pfx)) > 1)                            \
-        std::fputs((pfx), stderr);                              \
-    std::fprintf(stderr, __VA_ARGS__);                          \
-    std::fputs("\n", stderr);                                   \
-    std::fflush(stderr);                                        \
+#define GAME_DEBUG_OUT(pfx, ...) ([&]() {                                   \
+    if constexpr (sizeof((pfx)) > 1)                                        \
+        std::fputs((pfx), stderr);                                          \
+    std::fprintf(stderr, __VA_ARGS__);                                      \
+    std::fputs("\n", stderr);                                               \
+    std::fflush(stderr);                                                    \
 }())
 
 #define WARN(...)   GAME_DEBUG_OUT("warning: ", __VA_ARGS__)
diff --git a/main.cpp b/main.cpp
index ece5f6ca..fec93cec 100644
--- a/main.cpp
+++ b/main.cpp
@@ -121,7 +121,7 @@ app::app(const Arguments& arguments):
     {
         constexpr auto N = TILE_MAX_DIM;
         Vector3 center{N/2.f*TILE_SIZE[0], N/2.f*TILE_SIZE[1], 0};
-        tile_atlas::vertex_array_type walls[] = {
+        tile_atlas::quad walls[] = {
             wall1->wall_quad_W(center, Vector3(X, Y, Z)),
             wall1->wall_quad_N(center, Vector3(X, Y, Z)),
             wall1->wall_quad_E(center, Vector3(X, Y, Z)),
diff --git a/tile-atlas.cpp b/tile-atlas.cpp
index 35aaddac..0d751e2c 100644
--- a/tile-atlas.cpp
+++ b/tile-atlas.cpp
@@ -24,7 +24,7 @@ std::array<Vector2, 4> tile_atlas::texcoords_for_id(std::size_t id2) const
 {
     const auto tile_size_ = tile_size();
     auto id_ = (int)id2;
-    CORRADE_INTERNAL_ASSERT(id_ >= 0 && id_ < dims_.product());
+    ASSERT(id_ >= 0 && id_ < dims_.product());
     Vector2i id = { id_ % dims_[0], id_ / dims_[0] };
     auto p0 = Vector2(id * tile_size_) / Vector2(size_);
     auto p1 = Vector2(tile_size_) / Vector2(size_);
@@ -37,39 +37,4 @@ std::array<Vector2, 4> tile_atlas::texcoords_for_id(std::size_t id2) const
     }};
 }
 
-using vertex_array_type = tile_atlas::vertex_array_type;
-
-vertex_array_type tile_atlas::floor_quad(const Vector3 center, const Vector2 size)
-{
-    float x = size[0]*.5f, y = size[1]*.5f;
-    return {{
-        { x + center[0], -y + center[1], center[2]},
-        { x + center[0],  y + center[1], center[2]},
-        {-x + center[0], -y + center[1], center[2]},
-        {-x + center[0],  y + center[1], center[2]},
-    }};
-}
-
-vertex_array_type tile_atlas::wall_quad_W(const Vector3 center, const Vector3 size)
-{
-    float x = size[0]*.5f, y = size[1]*.5f, z = size[2];
-    return {{
-        {-x + center[0],  y + center[1],     center[2] },
-        {-x + center[0],  y + center[1], z + center[2] },
-        {-x + center[0], -y + center[1],     center[2] },
-        {-x + center[0], -y + center[1], z + center[2] },
-    }};
-}
-
-vertex_array_type tile_atlas::wall_quad_N(const Vector3 center, const Vector3 size)
-{
-    float x = size[0]*.5f, y = size[1]*.5f, z = size[2];
-    return {{
-        { x + center[0], -y + center[1],     center[2] },
-        { x + center[0], -y + center[1], z + center[2] },
-        {-x + center[0], -y + center[1],     center[2] },
-        {-x + center[0], -y + center[1], z + center[2] },
-    }};
-}
-
 } // namespace Magnum::Examples
diff --git a/tile-atlas.hpp b/tile-atlas.hpp
index e1705d5f..1eb66c29 100644
--- a/tile-atlas.hpp
+++ b/tile-atlas.hpp
@@ -1,4 +1,5 @@
 #pragma once
+#include "compat/assert.hpp"
 #include <Magnum/Magnum.h>
 #include <Magnum/GL/Texture.h>
 #include <array>
@@ -7,21 +8,18 @@ namespace Magnum::Examples {
 
 struct tile_atlas final
 {
-    using vertex_array_type = std::array<Vector3, 4>;
+    using quad = std::array<Vector3, 4>;
 
     tile_atlas(const ImageView2D& img, Vector2i dims);
     std::array<Vector2, 4> texcoords_for_id(std::size_t id) const;
-    static vertex_array_type floor_quad(Vector3 center, Vector2 size);
-    static vertex_array_type wall_quad_N(Vector3 center, Vector3 size);
-    static vertex_array_type wall_quad_W(Vector3 center, Vector3 size);
+    static constexpr quad floor_quad(Vector3 center, Vector2 size);
+    static constexpr quad wall_quad_N(Vector3 center, Vector3 size);
+    static constexpr quad wall_quad_W(Vector3 center, Vector3 size);
     static constexpr std::array<UnsignedShort, 6> indices(std::size_t N);
     std::size_t size() const { return (std::size_t)dims_.product(); }
     Vector2i tile_size() const { return size_ / dims_; }
     GL::Texture2D& texture() { return tex_; }
 
-    tile_atlas() = default;
-    tile_atlas(const tile_atlas&) = delete;
-    tile_atlas& operator=(const tile_atlas&) = delete;
 private:
     GL::Texture2D tex_;
     Vector2i size_, dims_;
@@ -36,4 +34,38 @@ constexpr std::array<UnsignedShort, 6> tile_atlas::indices(std::size_t N)
     };                                              /* 2  2--0 */
 }
 
+constexpr tile_atlas::quad tile_atlas::floor_quad(const Vector3 center, const Vector2 size)
+{
+    ASSERT(size[0] > 0);
+    float x = size[0]*.5f, y = size[1]*.5f;
+    return {{
+        { x + center[0], -y + center[1], center[2]},
+        { x + center[0],  y + center[1], center[2]},
+        {-x + center[0], -y + center[1], center[2]},
+        {-x + center[0],  y + center[1], center[2]},
+    }};
+}
+
+constexpr tile_atlas::quad tile_atlas::wall_quad_W(const Vector3 center, const Vector3 size)
+{
+    float x = size[0]*.5f, y = size[1]*.5f, z = size[2];
+    return {{
+        {-x + center[0],  y + center[1],     center[2] },
+        {-x + center[0],  y + center[1], z + center[2] },
+        {-x + center[0], -y + center[1],     center[2] },
+        {-x + center[0], -y + center[1], z + center[2] },
+    }};
+}
+
+constexpr tile_atlas::quad tile_atlas::wall_quad_N(const Vector3 center, const Vector3 size)
+{
+    float x = size[0]*.5f, y = size[1]*.5f, z = size[2];
+    return {{
+        { x + center[0], -y + center[1],     center[2] },
+        { x + center[0], -y + center[1], z + center[2] },
+        {-x + center[0], -y + center[1],     center[2] },
+        {-x + center[0], -y + center[1], z + center[2] },
+    }};
+}
+
 } // namespace Magnum::Examples