a

5 files changed, 84 insertions, 62 deletions

diff --git a/main/app.hpp b/main/app.hpp
index b64ce76f..07a64d2f 100644
--- a/main/app.hpp
+++ b/main/app.hpp
@@ -6,6 +6,7 @@
 #include "floor-mesh.hpp"
 #include "wall-mesh.hpp"
 #include "wireframe-mesh.hpp"
+#include "wireframe-quad.hpp"
 #include "compat/enum-bitset.hpp"
 #include <Magnum/Timeline.h>
 #include <Magnum/Platform/Sdl2Application.h>
@@ -52,7 +53,7 @@ struct app final : Platform::Application
     chunk _chunk = make_test_chunk();
     floor_mesh _floor_mesh;
     wall_mesh _wall_mesh;
-    wireframe_quad_mesh _wireframe_quad;
+    wireframe_mesh<wireframe::quad> _wireframe_quad;
 
     Vector2 camera_offset;
     enum_bitset<key> keys;
diff --git a/src/wireframe-mesh.cpp b/src/wireframe-mesh.cpp
index e03723bf..1425df60 100644
--- a/src/wireframe-mesh.cpp
+++ b/src/wireframe-mesh.cpp
@@ -1,7 +1,5 @@
 #include "wireframe-mesh.hpp"
 #include "shaders/tile-shader.hpp"
-#include "tile-atlas.hpp"
-#include "compat/assert.hpp"
 #include <Corrade/Containers/Array.h>
 #include <Magnum/GL/Renderer.h>
 #include <Magnum/GL/TextureFormat.h>
@@ -14,7 +12,7 @@
 namespace Magnum::Examples::wireframe
 {
 
-GL::RectangleTexture wireframe::null::make_constant_texture()
+GL::RectangleTexture mesh_base::make_constant_texture()
 {
     const Vector4ub data[] = { {255, 255, 255, 255} };
     Trade::ImageData2D img{PixelStorage{}.setImageHeight(1).setRowLength(1).setAlignment(1),
@@ -30,42 +28,20 @@ GL::RectangleTexture wireframe::null::make_constant_texture()
     return tex;
 }
 
-quad::vertex_array quad::make_vertex_array() const
+mesh_base::mesh_base(GL::MeshPrimitive primitive, std::size_t num_vertices) :
+    _texcoords_buffer{std::vector<Vector2>{num_vertices}}
 {
-    constexpr auto X = TILE_SIZE[0]*.5f, Y = TILE_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] },
-    }};
-}
-
-quad::quad(Vector3 center, Vector2 size) : center(center), size(size) {}
-
-} // namespace Magnum::Examples::wireframe
-
-namespace Magnum::Examples {
-
-template <wireframe::traits T> wireframe_mesh<T>::wireframe_mesh()
-{
-    _mesh.setCount((int)T::num_vertices)
-        .setPrimitive(T::primitive)
+    _mesh.setCount((int)num_vertices)
+        .setPrimitive(primitive)
         .addVertexBuffer(_vertex_buffer, 0, tile_shader::Position{})
         .addVertexBuffer(_texcoords_buffer, 0, tile_shader::TextureCoordinates{});
 }
 
-template <wireframe::traits T> void wireframe_mesh<T>::draw(tile_shader& shader, T x)
+void mesh_base::draw(tile_shader& shader)
 {
-    GL::Renderer::setLineWidth(3);
-    auto array = x.make_vertex_array();
-    _vertex_buffer.setSubData(0, array);
     _texture.bind(0);
     shader.draw(_mesh);
 }
 
-template struct wireframe_mesh<wireframe::null>;
-template struct wireframe_mesh<wireframe::quad>;
-
-} // namespace Magnum::Examples
 
+} // namespace Magnum::Examples::wireframe
diff --git a/src/wireframe-mesh.hpp b/src/wireframe-mesh.hpp
index 26dfb9ec..0ae122f5 100644
--- a/src/wireframe-mesh.hpp
+++ b/src/wireframe-mesh.hpp
@@ -20,51 +20,39 @@ template<typename T>
 concept traits = requires (const T& x) {
     {T::num_vertices} -> std::convertible_to<std::size_t>;
     {x.primitive} -> std::convertible_to<GL::MeshPrimitive>;
-    {x.make_vertex_array() } -> std::same_as<std::array<Vector3, T::num_vertices>>;
+    {x.make_vertex_array() } -> std::convertible_to<Containers::ArrayView<const void>>;
+    {x.on_draw()} -> std::same_as<void>;
 };
 
-struct null final
+struct mesh_base
 {
-    static constexpr auto primitive = GL::MeshPrimitive::Triangles;
-    static constexpr std::size_t num_vertices = 0;
     static GL::RectangleTexture make_constant_texture();
-    static std::array<Vector3, 0> make_vertex_array() { return {}; }
-};
-
-struct quad final
-{
-    quad(Vector3 center, Vector2 size);
-
-    static constexpr std::size_t num_vertices = 4;
-    static constexpr GL::MeshPrimitive primitive = GL::MeshPrimitive::LineLoop;
-
-    using vertex_array = std::array<Vector3, num_vertices>;
-
-    vertex_array make_vertex_array() const;
+    GL::Buffer _vertex_buffer, _texcoords_buffer;
+    GL::RectangleTexture _texture = make_constant_texture();
+    GL::Mesh _mesh;
 
-private:
-    Vector3 center;
-    Vector2 size;
+    mesh_base(GL::MeshPrimitive primitive, std::size_t num_vertices);
+    void draw(tile_shader& shader);
 };
 
 } // namespace wireframe
 
 template<wireframe::traits T>
-struct wireframe_mesh final
+struct wireframe_mesh final : private wireframe::mesh_base
 {
     wireframe_mesh();
     void draw(tile_shader& shader, T traits);
-
-private:
-    GL::Buffer _vertex_buffer{std::array<Vector3, T::num_vertices>{}, GL::BufferUsage::DynamicDraw},
-               _texcoords_buffer{std::array<Vector2, T::num_vertices>{}, GL::BufferUsage::DynamicDraw};
-    GL::RectangleTexture _texture = wireframe::null::make_constant_texture();
-    GL::Mesh _mesh;
 };
 
-extern template struct wireframe_mesh<wireframe::null>;
-extern template struct wireframe_mesh<wireframe::quad>;
+template<wireframe::traits T>
+wireframe_mesh<T>::wireframe_mesh() :
+      wireframe::mesh_base{T::primitive, T::num_vertices}
+{}
 
-using wireframe_quad_mesh = wireframe_mesh<wireframe::quad>;
+template <wireframe::traits T> void wireframe_mesh<T>::draw(tile_shader& shader, T x)
+{
+    _vertex_buffer.setData(x.make_vertex_array(), GL::BufferUsage::DynamicDraw);
+    mesh_base::draw(shader);
+}
 
 } // namespace Magnum::Examples
diff --git a/src/wireframe-quad.cpp b/src/wireframe-quad.cpp
new file mode 100644
index 00000000..18b49628
--- /dev/null
+++ b/src/wireframe-quad.cpp
@@ -0,0 +1,25 @@
+#include "wireframe-quad.hpp"
+#include <array>
+#include <Magnum/GL/Renderer.h>
+
+namespace Magnum::Examples::wireframe {
+
+quad::vertex_array quad::make_vertex_array() const
+{
+    const 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] },
+    }};
+}
+
+quad::quad(Vector3 center, Vector2 size) : center(center), size(size) {}
+
+void quad::on_draw() const
+{
+    GL::Renderer::setLineWidth(line_width);
+}
+
+} // namespace Magnum::Examples::wireframe
diff --git a/src/wireframe-quad.hpp b/src/wireframe-quad.hpp
new file mode 100644
index 00000000..062bf913
--- /dev/null
+++ b/src/wireframe-quad.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <Magnum/Math/Vector2.h>
+#include <Magnum/Math/Vector3.h>
+#include <Magnum/GL/Mesh.h>
+
+namespace Magnum::Examples::wireframe {
+
+template<typename T>
+struct wireframe_mesh;
+
+struct quad final
+{
+    quad(Vector3 center, Vector2 size);
+
+    static constexpr std::size_t num_vertices = 4;
+    static constexpr GL::MeshPrimitive primitive = GL::MeshPrimitive::LineLoop;
+
+    using vertex_array = std::array<Vector3, num_vertices>;
+
+    vertex_array make_vertex_array() const;
+    void on_draw() const;
+
+private:
+    Vector3 center;
+    Vector2 size;
+    float line_width = 2;
+};
+
+
+
+} // namespace Magnum::Examples::wireframe