a

9 files changed, 424 insertions, 0 deletions

diff --git a/draw/CMakeLists.txt b/draw/CMakeLists.txt
new file mode 100644
index 00000000..9dd2e869
--- /dev/null
+++ b/draw/CMakeLists.txt
@@ -0,0 +1,9 @@
+set(self ${PROJECT_NAME}-draw)
+file(GLOB sources "*.cpp" CONFIGURE_ARGS)
+add_library(${self} STATIC "${sources}")
+target_link_libraries(${self} PUBLIC
+    Magnum::GL
+    Magnum::Magnum
+    Magnum::Shaders
+    ${PROJECT_NAME}
+)
diff --git a/draw/floor-mesh.cpp b/draw/floor-mesh.cpp
new file mode 100644
index 00000000..3698bc6e
--- /dev/null
+++ b/draw/floor-mesh.cpp
@@ -0,0 +1,78 @@
+#include "floor-mesh.hpp"
+#include "shaders/tile-shader.hpp"
+#include "tile.hpp"
+#include "chunk.hpp"
+#include "tile-atlas.hpp"
+#include <Magnum/GL/MeshView.h>
+
+namespace Magnum::Examples {
+
+constexpr auto quad_index_count = 6;
+
+floor_mesh::floor_mesh()
+{
+    _mesh.setCount((int)(quad_index_count * TILE_COUNT))
+         .addVertexBuffer(_positions_buffer, 0, tile_shader::Position{})
+         .addVertexBuffer(_vertex_buffer, 0, tile_shader::TextureCoordinates{})
+         .setIndexBuffer(_index_buffer, 0, GL::MeshIndexType::UnsignedShort);
+}
+
+void floor_mesh::set_tile(quad_data& data, tile& x)
+{
+    if (x.ground_image)
+    {
+        auto texcoords = x.ground_image.atlas->texcoords_for_id(x.ground_image.variant);
+        for (size_t i = 0; i < 4; i++)
+            data[i] = { texcoords[i] };
+    }
+    else
+        for (size_t i = 0; i < 4; i++)
+            data[i] = {};
+}
+
+void floor_mesh::draw(tile_shader& shader, chunk& c)
+{
+    std::array<quad_data, TILE_COUNT> data;
+    for (auto& [x, idx, pt] : c) {
+        set_tile(data[idx], x);
+    }
+    _vertex_buffer.setSubData(0, data);
+    Magnum::GL::MeshView mesh{_mesh};
+    mesh.setCount(quad_index_count);
+    const tile_atlas* last_tile_atlas = nullptr;
+    for (auto& [x, i, pt] : c) {
+      if (!x.ground_image)
+          continue;
+      mesh.setIndexRange((int)(i*quad_index_count), 0, quad_index_count*TILE_COUNT - 1);
+      if (auto* atlas = x.ground_image.atlas.get(); atlas != last_tile_atlas)
+      {
+          atlas->texture().bind(0);
+          last_tile_atlas = atlas;
+      }
+      shader.draw(mesh);
+    }
+}
+
+std::array<std::array<UnsignedShort, 6>, TILE_COUNT> floor_mesh::make_index_array()
+{
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+    std::array<std::array<UnsignedShort, quad_index_count>, TILE_COUNT> array;
+    for (std::size_t i = 0; i < std::size(array); i++)
+        array[i] = tile_atlas::indices(i);
+    return array;
+}
+
+std::array<std::array<Vector3, 4>, TILE_COUNT> floor_mesh::make_position_array()
+{
+    std::array<std::array<Vector3, 4>, TILE_COUNT> array;
+    constexpr float X = TILE_SIZE[0], Y = TILE_SIZE[1];
+    for (std::size_t j = 0, k = 0; j < TILE_MAX_DIM; j++)
+        for (std::size_t i = 0; i < TILE_MAX_DIM; i++, k++)
+        {
+            Vector3 center {(float)(X*i), (float)(Y*j), 0};
+            array[k] = { tile_atlas::floor_quad(center, {X, Y}) };
+        }
+    return array;
+}
+
+} // namespace Magnum::Examples
diff --git a/draw/floor-mesh.hpp b/draw/floor-mesh.hpp
new file mode 100644
index 00000000..fed5867c
--- /dev/null
+++ b/draw/floor-mesh.hpp
@@ -0,0 +1,39 @@
+#pragma once
+#include "tile-defs.hpp"
+#include <array>
+#include <Corrade/Containers/ArrayViewStl.h>
+#include <Magnum/Magnum.h>
+#include <Magnum/Math/Vector2.h>
+#include <Magnum/Math/Vector3.h>
+#include <Magnum/GL/Mesh.h>
+#include <Magnum/GL/Buffer.h>
+
+namespace Magnum::Examples {
+
+struct tile_shader;
+struct chunk;
+struct tile;
+
+struct floor_mesh final
+{
+    floor_mesh();
+    floor_mesh(floor_mesh&&) = delete;
+    floor_mesh(const floor_mesh&) = delete;
+
+    void draw(tile_shader& shader, chunk& c);
+
+private:
+    struct vertex_data final { Vector2 texcoords; };
+    using quad_data = std::array<vertex_data, 4>;
+
+    static std::array<std::array<UnsignedShort, 6>, TILE_COUNT> make_index_array();
+    static std::array<std::array<Vector3, 4>, TILE_COUNT> make_position_array();
+
+    GL::Mesh _mesh;
+    GL::Buffer _vertex_buffer{std::array<quad_data, TILE_COUNT>{}, Magnum::GL::BufferUsage::DynamicDraw},
+               _index_buffer{make_index_array()}, _positions_buffer{make_position_array()};
+
+    static void set_tile(quad_data& data, tile& x);
+};
+
+} // namespace Magnum::Examples
diff --git a/draw/wall-mesh.cpp b/draw/wall-mesh.cpp
new file mode 100644
index 00000000..d698b508
--- /dev/null
+++ b/draw/wall-mesh.cpp
@@ -0,0 +1,93 @@
+#include "wall-mesh.hpp"
+#include "tile-atlas.hpp"
+#include "shaders/tile-shader.hpp"
+#include "chunk.hpp"
+#include <Magnum/GL/RectangleTexture.h>
+#include <Magnum/GL/MeshView.h>
+
+namespace Magnum::Examples {
+
+constexpr auto quad_index_count = 6;
+
+wall_mesh::wall_mesh()
+{
+    _mesh.setCount((int)(quad_index_count * COUNT))
+         .addVertexBuffer(_vertex_buffer, 0, tile_shader::TextureCoordinates{})
+         .addVertexBuffer(_positions_buffer, 0, tile_shader::Position{})
+         .setIndexBuffer(_index_buffer, 0, GL::MeshIndexType::UnsignedShort);
+    CORRADE_INTERNAL_ASSERT(_mesh.isIndexed());
+}
+
+void wall_mesh::add_wall(vertex_array& data, texture_array& textures, tile_image& img, std::size_t pos)
+{
+    CORRADE_INTERNAL_ASSERT(pos < data.size());
+    auto texcoords = img.atlas->texcoords_for_id(img.variant);
+    for (std::size_t i = 0; i < 4; i++)
+    {
+        data[pos][i] = { texcoords[i] };
+        textures[pos] = &img.atlas->texture();
+    }
+}
+
+void wall_mesh::maybe_add_tile(vertex_array& data, texture_array& textures, tile& x, std::size_t pos)
+{
+    if (auto& wall = x.wall_north; wall.atlas)
+        add_wall(data, textures, wall, pos * 2 + 0);
+    if (auto& wall = x.wall_west; wall.atlas)
+        add_wall(data, textures, wall, pos * 2 + 1);
+}
+
+void wall_mesh::draw(tile_shader& shader, chunk& c)
+{
+    texture_array textures = {};
+    {
+        vertex_array data;
+        for (auto& [x, idx, pt] : c) {
+          maybe_add_tile(data, textures, x, idx);
+        }
+        _vertex_buffer.setSubData(0, data);
+    }
+
+    const GL::RectangleTexture* last_texture = nullptr;
+    Magnum::GL::MeshView mesh{_mesh};
+    for (std::size_t i = 0; i < COUNT; i++)
+    {
+        auto* const tex = textures[i];
+        if (!tex)
+            continue;
+        mesh.setCount(quad_index_count);
+        mesh.setIndexRange((int)(i*quad_index_count), 0, quad_index_count*COUNT - 1);
+        if (tex != last_texture)
+            tex->bind(0);
+        last_texture = tex;
+        shader.draw(mesh);
+    }
+}
+
+std::array<std::array<UnsignedShort, 6>, wall_mesh::COUNT> wall_mesh::make_index_array()
+{
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+    std::array<std::array<UnsignedShort, 6>, COUNT> array;
+
+    for (std::size_t i = 0; i < std::size(array); i++)
+        array[i] = tile_atlas::indices(i);
+    return array;
+}
+
+std::array<std::array<Vector3, 4>, wall_mesh::COUNT> wall_mesh::make_position_array()
+{
+    std::array<std::array<Vector3, 4>, COUNT> array;
+    constexpr float X = TILE_SIZE[0], Y = TILE_SIZE[1], Z = TILE_SIZE[2];
+    constexpr Vector3 size = {X, Y, Z};
+    for (std::size_t j = 0; j < TILE_MAX_DIM; j++)
+        for (std::size_t i = 0; i < TILE_MAX_DIM; i++)
+        {
+            const auto idx = (j*TILE_MAX_DIM + i) * 2;
+            Vector3 center{(float)(X*i), (float)(Y*j), 0};
+            array[idx + 0] = tile_atlas::wall_quad_N(center, size);
+            array[idx + 1] = tile_atlas::wall_quad_W(center, size);
+        }
+    return array;
+}
+
+} // namespace Magnum::Examples
diff --git a/draw/wall-mesh.hpp b/draw/wall-mesh.hpp
new file mode 100644
index 00000000..4a4e9615
--- /dev/null
+++ b/draw/wall-mesh.hpp
@@ -0,0 +1,43 @@
+#pragma once
+
+#include "tile.hpp"
+#include <array>
+#include <Corrade/Containers/ArrayViewStl.h>
+#include <Magnum/Math/Vector2.h>
+#include <Magnum/Math/Vector3.h>
+#include <Magnum/GL/Mesh.h>
+#include <Magnum/GL/Buffer.h>
+
+namespace Magnum::Examples {
+
+struct tile_shader;
+struct chunk;
+
+struct wall_mesh final
+{
+    wall_mesh();
+    void draw(tile_shader& shader, chunk& c);
+
+private:
+    static constexpr auto COUNT1 = TILE_MAX_DIM*2, COUNT = COUNT1 * COUNT1;
+
+    struct vertex final {
+        Vector2 texcoords;
+    };
+
+    using quad = std::array<vertex, 4>;
+    using vertex_array = std::array<quad, COUNT>;
+    using texture_array = std::array<GL::RectangleTexture*, COUNT>;
+
+    static void maybe_add_tile(vertex_array& data, texture_array& textures, tile& x, std::size_t pos);
+    static void add_wall(vertex_array& data, texture_array& textures, tile_image& img, std::size_t pos);
+
+    GL::Mesh _mesh;
+    GL::Buffer _vertex_buffer{vertex_array{}, Magnum::GL::BufferUsage::DynamicDraw},
+               _index_buffer{make_index_array()},
+                _positions_buffer{make_position_array()};
+    static std::array<std::array<UnsignedShort, 6>, COUNT> make_index_array();
+    static std::array<std::array<Vector3, 4>, COUNT> make_position_array();
+};
+
+} // namespace Magnum::Examples
diff --git a/draw/wireframe-mesh.cpp b/draw/wireframe-mesh.cpp
new file mode 100644
index 00000000..1425df60
--- /dev/null
+++ b/draw/wireframe-mesh.cpp
@@ -0,0 +1,47 @@
+#include "wireframe-mesh.hpp"
+#include "shaders/tile-shader.hpp"
+#include <Corrade/Containers/Array.h>
+#include <Magnum/GL/Renderer.h>
+#include <Magnum/GL/TextureFormat.h>
+#include <Magnum/ImageFlags.h>
+#include <Magnum/ImageView.h>
+#include <Magnum/PixelFormat.h>
+#include <Magnum/PixelStorage.h>
+#include <Magnum/Trade/ImageData.h>
+
+namespace Magnum::Examples::wireframe
+{
+
+GL::RectangleTexture mesh_base::make_constant_texture()
+{
+    const Vector4ub data[] = { {255, 255, 255, 255} };
+    Trade::ImageData2D img{PixelStorage{}.setImageHeight(1).setRowLength(1).setAlignment(1),
+                           PixelFormat::RGBA8Unorm, {1, 1}, {},
+                           Containers::arrayView(data, 1), {}, {}};
+    GL::RectangleTexture tex;
+    tex.setWrapping(GL::SamplerWrapping::ClampToEdge)
+       .setMagnificationFilter(GL::SamplerFilter::Nearest)
+       .setMinificationFilter(GL::SamplerFilter::Nearest)
+       .setMaxAnisotropy(1)
+       .setStorage(GL::textureFormat(img.format()), img.size())
+       .setSubImage({}, std::move(img));
+    return tex;
+}
+
+mesh_base::mesh_base(GL::MeshPrimitive primitive, std::size_t num_vertices) :
+    _texcoords_buffer{std::vector<Vector2>{num_vertices}}
+{
+    _mesh.setCount((int)num_vertices)
+        .setPrimitive(primitive)
+        .addVertexBuffer(_vertex_buffer, 0, tile_shader::Position{})
+        .addVertexBuffer(_texcoords_buffer, 0, tile_shader::TextureCoordinates{});
+}
+
+void mesh_base::draw(tile_shader& shader)
+{
+    _texture.bind(0);
+    shader.draw(_mesh);
+}
+
+
+} // namespace Magnum::Examples::wireframe
diff --git a/draw/wireframe-mesh.hpp b/draw/wireframe-mesh.hpp
new file mode 100644
index 00000000..0ae122f5
--- /dev/null
+++ b/draw/wireframe-mesh.hpp
@@ -0,0 +1,58 @@
+#pragma once
+
+#include "tile-defs.hpp"
+#include <array>
+#include <utility>
+#include <Corrade/Containers/ArrayViewStl.h>
+#include <Magnum/Math/Vector2.h>
+#include <Magnum/GL/Buffer.h>
+#include <Magnum/GL/Mesh.h>
+#include "Magnum/GL/RectangleTexture.h"
+
+namespace Magnum::Examples {
+
+struct tile_shader;
+
+namespace wireframe
+{
+
+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::convertible_to<Containers::ArrayView<const void>>;
+    {x.on_draw()} -> std::same_as<void>;
+};
+
+struct mesh_base
+{
+    static GL::RectangleTexture make_constant_texture();
+    GL::Buffer _vertex_buffer, _texcoords_buffer;
+    GL::RectangleTexture _texture = make_constant_texture();
+    GL::Mesh _mesh;
+
+    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 : private wireframe::mesh_base
+{
+    wireframe_mesh();
+    void draw(tile_shader& shader, T traits);
+};
+
+template<wireframe::traits T>
+wireframe_mesh<T>::wireframe_mesh() :
+      wireframe::mesh_base{T::primitive, T::num_vertices}
+{}
+
+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/draw/wireframe-quad.cpp b/draw/wireframe-quad.cpp
new file mode 100644
index 00000000..18b49628
--- /dev/null
+++ b/draw/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/draw/wireframe-quad.hpp b/draw/wireframe-quad.hpp
new file mode 100644
index 00000000..062bf913
--- /dev/null
+++ b/draw/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