wip

7 files changed, 84 insertions, 18 deletions

diff --git a/src/anim-atlas.cpp b/src/anim-atlas.cpp
index a4344946..6fb4a3c0 100644
--- a/src/anim-atlas.cpp
+++ b/src/anim-atlas.cpp
@@ -1,5 +1,6 @@
 #include "anim-atlas.hpp"
 #include "compat/assert.hpp"
+#include "shaders/tile.hpp"
 #include <Corrade/Containers/StringStlView.h>
 #include <Magnum/Math/Color.h>
 #include <Magnum/GL/TextureFormat.h>
@@ -66,12 +67,12 @@ auto anim_atlas::frame(rotation r, std::size_t frame) const noexcept -> const an
     return g.frames[frame];
 }
 
-auto anim_atlas::frame_texcoords(rotation r, std::size_t idx) const noexcept -> texcoords
+auto anim_atlas::texcoords_for_frame(rotation r, std::size_t i) const noexcept -> texcoords
 {
-    return frame_texcoords(frame(r, idx));
+    return texcoords_for_frame(frame(r, i));
 }
 
-auto anim_atlas::frame_texcoords(const anim_frame& frame) const noexcept -> texcoords
+auto anim_atlas::texcoords_for_frame(const anim_frame& frame) const noexcept -> texcoords
 {
     const Vector2 p0(frame.offset), p1(frame.offset + frame.size);
     const auto x0 = p0.x()+.5f, x1 = p1.x()-1, y0 = p0.y()+.5f, y1 = p1.y()-1;
@@ -84,6 +85,25 @@ auto anim_atlas::frame_texcoords(const anim_frame& frame) const noexcept -> texc
     }};
 }
 
+auto anim_atlas::frame_quad(const Vector3& center, rotation r, std::size_t i) const noexcept -> quad
+{
+    return frame_quad(center, frame(r, i));
+}
 
+auto anim_atlas::frame_quad(const Vector3& center, const anim_frame& frame) noexcept -> quad
+{
+    const auto size = Vector2d(frame.size) - Vector2d(frame.ground);
+    const auto bottom_right = Vector2(tile_shader::unproject({ size[0]*.5,  0 })),
+               top_right    = Vector2(tile_shader::unproject({ size[0]*.5,  -size[1] })),
+               bottom_left  = Vector2(tile_shader::unproject({ -size[0]*.5, 0 })),
+               top_left     = Vector2(tile_shader::unproject({ -size[0]*.5, -size[1] }));
+    const auto cx = center[0], cy = center[1], cz = center[2];
+    return {{
+        { cx + bottom_right[0], cy + bottom_right[1],   cz },
+        { cx + top_right[0],    cy + top_right[1],      cz },
+        { cx + bottom_left[0],  cy + bottom_left[1],    cz },
+        { cx + top_left[0],     cy + top_left[1],       cz },
+    }};
+}
 
 } // namespace floormat
diff --git a/src/anim-atlas.hpp b/src/anim-atlas.hpp
index a7553c5c..16e4825d 100644
--- a/src/anim-atlas.hpp
+++ b/src/anim-atlas.hpp
@@ -16,6 +16,7 @@ struct anim_atlas final
     using anim_group = Serialize::anim_group;
     using anim_frame = Serialize::anim_frame;
     using texcoords = std::array<Vector2, 4>;
+    using quad = std::array<Vector3, 4>;
 
     anim_atlas() noexcept;
     anim_atlas(StringView name, const ImageView2D& tex, anim_info info) noexcept;
@@ -30,8 +31,10 @@ struct anim_atlas final
 
     const anim_group& group(rotation r) const noexcept;
     const anim_frame& frame(rotation r, std::size_t frame) const noexcept;
-    texcoords frame_texcoords(rotation r, std::size_t frame) const noexcept;
-    texcoords frame_texcoords(const anim_frame& frame) const noexcept;
+    texcoords texcoords_for_frame(rotation r, std::size_t frame) const noexcept;
+    texcoords texcoords_for_frame(const anim_frame& frame) const noexcept;
+    quad frame_quad(const Vector3& center, rotation r, std::size_t frame) const noexcept;
+    static quad frame_quad(const Vector3& center, const anim_frame& frame) noexcept;
 
     fm_DECLARE_DELETED_COPY_ASSIGNMENT(anim_atlas);
 
diff --git a/src/chunk.hpp b/src/chunk.hpp
index 7967484c..14795de0 100644
--- a/src/chunk.hpp
+++ b/src/chunk.hpp
@@ -40,7 +40,8 @@ struct chunk final
 
 private:
     std::array<std::shared_ptr<tile_atlas>, TILE_COUNT> _ground_atlases, _wall_north_atlases, _wall_west_atlases;
-    std::array<std::shared_ptr<anim_atlas>, TILE_COUNT> _scenery;
+    std::array<std::shared_ptr<anim_atlas>, TILE_COUNT> _scenery_atlases;
+    std::array<scenery, TILE_COUNT> _scenery_variants = {};
     std::array<variant_t, TILE_COUNT> _ground_variants = {}, _wall_north_variants = {}, _wall_west_variants = {};
     std::bitset<TILE_COUNT*2> _passability = {};
     mutable bool _maybe_empty = true;
diff --git a/src/scenery.cpp b/src/scenery.cpp
index fde0cb56..620fb51e 100644
--- a/src/scenery.cpp
+++ b/src/scenery.cpp
@@ -2,6 +2,20 @@
 
 namespace floormat {
 
+scenery_proto::operator bool() const noexcept { return atlas != nullptr; }
 
+scenery_ref::scenery_ref(std::shared_ptr<anim_atlas>& atlas, scenery& frame) noexcept : atlas{atlas}, frame{frame} {}
+scenery_ref::scenery_ref(const scenery_ref&) noexcept = default;
+scenery_ref::scenery_ref(scenery_ref&&) noexcept = default;
+
+scenery_ref& scenery_ref::operator=(const scenery_proto& proto) noexcept
+{
+    atlas = proto.atlas;
+    frame = proto.frame;
+    return *this;
+}
+
+scenery_ref::operator scenery_proto() const noexcept { return { atlas, frame }; }
+scenery_ref::operator bool() const noexcept { return atlas != nullptr; };
 
 } // namespace floormat
diff --git a/src/scenery.hpp b/src/scenery.hpp
index 04c54c22..a59d6990 100644
--- a/src/scenery.hpp
+++ b/src/scenery.hpp
@@ -4,6 +4,8 @@
 
 namespace floormat {
 
+struct anim_atlas;
+
 enum class rotation : std::uint16_t {
     N, NE, E, SE, S, SW, W, NW,
     COUNT,
@@ -17,15 +19,26 @@ struct scenery final
 
     frame_t frame : 12 = NO_FRAME;
     rotation r    : 4  = rotation::N;
-
-    constexpr operator bool() const noexcept;
 };
 
 static_assert(sizeof(scenery) == sizeof(std::uint16_t));
 
-constexpr scenery::operator bool() const noexcept
-{
-    return frame == NO_FRAME;
-}
+struct scenery_proto final {
+    std::shared_ptr<anim_atlas> atlas;
+    scenery frame;
+    operator bool() const noexcept;
+};
+
+struct scenery_ref final {
+    std::shared_ptr<anim_atlas>& atlas;
+    scenery& frame;
+
+    scenery_ref(std::shared_ptr<anim_atlas>& atlas, scenery& frame) noexcept;
+    scenery_ref(const scenery_ref&) noexcept;
+    scenery_ref(scenery_ref&&) noexcept;
+    scenery_ref& operator=(const scenery_proto& proto) noexcept;
+    operator scenery_proto() const noexcept;
+    operator bool() const noexcept;
+};
 
 } // namespace floormat
diff --git a/src/tile.cpp b/src/tile.cpp
index 920ee2e5..6f329702 100644
--- a/src/tile.cpp
+++ b/src/tile.cpp
@@ -32,30 +32,36 @@ pass_mode_ref::operator pass_mode() const noexcept
 bool operator==(const tile_proto& a, const tile_proto& b) noexcept {
     return a.ground_image()     == b.ground_image() &&
            a.wall_north_image() == b.wall_north_image() &&
-           a.wall_west_image()  == b.wall_west_image();
+           a.wall_west_image()  == b.wall_west_image() &&
+           a.scenery_image()    == b.scenery_image();
 };
 
 tile_image_proto tile_proto::ground_image() const noexcept     { return { ground_atlas, ground_variant         }; }
 tile_image_proto tile_proto::wall_north_image() const noexcept { return { wall_north_atlas, wall_north_variant }; }
 tile_image_proto tile_proto::wall_west_image() const noexcept  { return { wall_west_atlas, wall_west_variant   }; }
+scenery_proto tile_proto::scenery_image() const noexcept       { return { scenery_atlas, scenery_frame         }; }
 
 tile_ref::tile_ref(struct chunk& c, std::uint8_t i) noexcept : _chunk{&c}, i{i} {}
 
-std::shared_ptr<tile_atlas> tile_ref::ground_atlas()                  noexcept { return _chunk->_ground_atlases[i]; }
-std::shared_ptr<tile_atlas> tile_ref::wall_north_atlas()              noexcept { return _chunk->_wall_north_atlases[i]; }
-std::shared_ptr<tile_atlas> tile_ref::wall_west_atlas()               noexcept { return _chunk->_wall_west_atlases[i]; }
+std::shared_ptr<tile_atlas> tile_ref::ground_atlas()     noexcept { return _chunk->_ground_atlases[i]; }
+std::shared_ptr<tile_atlas> tile_ref::wall_north_atlas() noexcept { return _chunk->_wall_north_atlases[i]; }
+std::shared_ptr<tile_atlas> tile_ref::wall_west_atlas()  noexcept { return _chunk->_wall_west_atlases[i]; }
+std::shared_ptr<anim_atlas> tile_ref::scenery_atlas()    noexcept { return _chunk->_scenery_atlases[i]; }
 
 std::shared_ptr<const tile_atlas> tile_ref::ground_atlas()      const noexcept { return _chunk->_ground_atlases[i]; }
 std::shared_ptr<const tile_atlas> tile_ref::wall_north_atlas()  const noexcept { return _chunk->_wall_north_atlases[i]; }
 std::shared_ptr<const tile_atlas> tile_ref::wall_west_atlas()   const noexcept { return _chunk->_wall_west_atlases[i]; }
+std::shared_ptr<const anim_atlas> tile_ref::scenery_atlas()     const noexcept { return _chunk->_scenery_atlases[i]; }
 
 tile_image_ref tile_ref::ground() noexcept     { return {_chunk->_ground_atlases[i],     _chunk->_ground_variants[i] };     }
 tile_image_ref tile_ref::wall_north() noexcept { return {_chunk->_wall_north_atlases[i], _chunk->_wall_north_variants[i] }; }
 tile_image_ref tile_ref::wall_west() noexcept  { return {_chunk->_wall_west_atlases[i],  _chunk->_wall_west_variants[i] };  }
+scenery_ref tile_ref::scenery() noexcept       { return {_chunk->_scenery_atlases[i],    _chunk->_scenery_variants[i] }; }
 
 tile_image_proto tile_ref::ground() const noexcept     { return { _chunk->_ground_atlases[i],     _chunk->_ground_variants[i] };     }
 tile_image_proto tile_ref::wall_north() const noexcept { return { _chunk->_wall_north_atlases[i], _chunk->_wall_north_variants[i] }; }
 tile_image_proto tile_ref::wall_west() const noexcept  { return { _chunk->_wall_west_atlases[i],  _chunk->_wall_west_variants[i] };  }
+scenery_proto tile_ref::scenery() const noexcept       { return {_chunk->_scenery_atlases[i],    _chunk->_scenery_variants[i] }; }
 
 pass_mode_ref tile_ref::pass_mode() noexcept { return { *_chunk, i }; }
 pass_mode tile_ref::pass_mode() const noexcept { return pass_mode_ref { *const_cast<struct chunk*>(_chunk), i }; }
@@ -63,8 +69,8 @@ pass_mode tile_ref::pass_mode() const noexcept { return pass_mode_ref { *const_c
 tile_ref::operator tile_proto() const noexcept
 {
     return {
-        _chunk->_ground_atlases[i],  _chunk->_wall_north_atlases[i],  _chunk->_wall_west_atlases[i],
-        _chunk->_ground_variants[i], _chunk->_wall_north_variants[i], _chunk->_wall_west_variants[i],
+        _chunk->_ground_atlases[i],  _chunk->_wall_north_atlases[i],  _chunk->_wall_west_atlases[i], _chunk->_scenery_atlases[i],
+        _chunk->_ground_variants[i], _chunk->_wall_north_variants[i], _chunk->_wall_west_variants[i], _chunk->_scenery_variants[i],
         pass_mode(),
     };
 }
diff --git a/src/tile.hpp b/src/tile.hpp
index b7bacc8d..6fad4b30 100644
--- a/src/tile.hpp
+++ b/src/tile.hpp
@@ -1,10 +1,12 @@
 #pragma once
 #include "compat/defs.hpp"
 #include "tile-image.hpp"
+#include "scenery.hpp"
 
 namespace floormat {
 
 struct chunk;
+struct anim_atlas;
 
 // zero is the default, see bitset in chunk.hpp
 enum pass_mode : std::uint8_t { pass_shoot_through, pass_ok, pass_blocked, };
@@ -24,12 +26,15 @@ private:
 struct tile_proto final
 {
     std::shared_ptr<tile_atlas> ground_atlas, wall_north_atlas, wall_west_atlas;
+    std::shared_ptr<anim_atlas> scenery_atlas;
     variant_t ground_variant = 0, wall_north_variant = 0, wall_west_variant = 0;
+    scenery scenery_frame;
     enum pass_mode pass_mode = pass_mode::pass_shoot_through;
 
     tile_image_proto ground_image() const noexcept;
     tile_image_proto wall_north_image() const noexcept;
     tile_image_proto wall_west_image() const noexcept;
+    scenery_proto scenery_image() const noexcept;
 
     friend bool operator==(const tile_proto& a, const tile_proto& b) noexcept;
 };
@@ -41,18 +46,22 @@ struct tile_ref final
     tile_image_ref ground() noexcept;
     tile_image_ref wall_north() noexcept;
     tile_image_ref wall_west() noexcept;
+    scenery_ref scenery() noexcept;
 
     tile_image_proto ground() const noexcept;
     tile_image_proto wall_north() const noexcept;
     tile_image_proto wall_west() const noexcept;
+    scenery_proto scenery() const noexcept;
 
     std::shared_ptr<tile_atlas> ground_atlas() noexcept;
     std::shared_ptr<tile_atlas> wall_north_atlas() noexcept;
     std::shared_ptr<tile_atlas> wall_west_atlas() noexcept;
+    std::shared_ptr<anim_atlas> scenery_atlas() noexcept;
 
     std::shared_ptr<const tile_atlas> ground_atlas() const noexcept;
     std::shared_ptr<const tile_atlas> wall_north_atlas() const noexcept;
     std::shared_ptr<const tile_atlas> wall_west_atlas() const noexcept;
+    std::shared_ptr<const anim_atlas> scenery_atlas() const noexcept;
 
     pass_mode_ref pass_mode() noexcept;
     enum pass_mode pass_mode() const noexcept;