a

3 files changed, 52 insertions, 6 deletions

diff --git a/src/chunk-scenery.cpp b/src/chunk-scenery.cpp
index c5b77241..7b4905dd 100644
--- a/src/chunk-scenery.cpp
+++ b/src/chunk-scenery.cpp
@@ -119,7 +119,7 @@ auto chunk::make_topo_sort_data(object& e, uint32_t mesh_idx) -> topo_sort_data
                 data.slope = (bb_max[1]-bb_min[1])/bb_len;
                 data.bb_min = Vector2s(bb_min - px_start);
                 data.bb_max = Vector2s(bb_max - px_start);
-                if (sc.sc_type != scenery_type::door)
+                if (sc.scenery_type() != scenery_type::door)
                     data.mode = topo_sort_data::mode_static;
             }
             break;
diff --git a/src/scenery.cpp b/src/scenery.cpp
index e80f6f68..c3c0b7c1 100644
--- a/src/scenery.cpp
+++ b/src/scenery.cpp
@@ -5,13 +5,14 @@
 #include "world.hpp"
 #include "shaders/shader.hpp"
 #include "src/rotation.inl"
+#include "compat/exception.hpp"
 #include <algorithm>
 
 namespace floormat {
 
 namespace {
 
-template<typename... Ts> struct overloaded : Ts... { using Ts::operator()...; };
+template<typename... Ts> struct [[maybe_unused]] overloaded : Ts... { using Ts::operator()...; };
 template<typename... Ts> overloaded(Ts...) -> overloaded<Ts...>;
 
 template<typename T> struct proto_to_scenery_;
@@ -34,25 +35,42 @@ scenery_proto::~scenery_proto() noexcept = default;
 scenery_proto::operator bool() const { return atlas != nullptr; }
 
 bool generic_scenery_proto::operator==(const generic_scenery_proto& p) const = default;
-bool door_scenery_proto::operator==(const door_scenery_proto& p) const = default;
+enum scenery_type generic_scenery_proto::scenery_type() const { return scenery_type::generic; }
+
 void generic_scenery::update(scenery&, size_t, float) {}
 Vector2 generic_scenery::ordinal_offset(const scenery&, Vector2b offset) const { return Vector2(offset); }
 bool generic_scenery::can_activate(const scenery&, size_t) const { return interactive; }
 bool generic_scenery::activate(floormat::scenery&, size_t) { return false; }
 object_type generic_scenery::type() const noexcept { return object_type::scenery; }
+enum scenery_type generic_scenery::scenery_type() const { return scenery_type::generic; }
+
+enum scenery_type scenery_proto::scenery_type() const
+{
+    return std::visit(
+        [&]<typename T>(const T& x) { return x.scenery_type(); },
+        subtype
+    );
+}
+
 generic_scenery::operator generic_scenery_proto() const { return { .active = active, .interactive = interactive, }; }
 
 generic_scenery::generic_scenery(object_id, struct chunk&, const generic_scenery_proto& p) :
     active{p.active}, interactive{p.interactive}
 {}
 
+bool door_scenery_proto::operator==(const door_scenery_proto& p) const = default;
+enum scenery_type door_scenery_proto::scenery_type() const { return scenery_type::door; }
+
+enum scenery_type door_scenery::scenery_type() const { return scenery_type::door; }
+door_scenery::operator door_scenery_proto() const { return { .active = active, .interactive = interactive, .closing = closing, }; }
+
 door_scenery::door_scenery(object_id, struct chunk&, const door_scenery_proto& p) :
     closing{p.closing}, active{p.active}, interactive{p.interactive}
 {}
 
 void door_scenery::update(scenery& s, size_t, float dt)
 {
-    if (!s.atlas || active)
+    if (!s.atlas || !active)
         return;
 
     fm_assert(s.atlas);
@@ -200,6 +218,14 @@ scenery::operator scenery_proto() const
     return ret;
 }
 
+enum scenery_type scenery::scenery_type() const
+{
+    return std::visit(
+        [&]<typename T>(const T& sc) { return sc.scenery_type(); },
+        subtype
+    );
+}
+
 scenery_variants scenery::subtype_from_proto(object_id id, struct chunk& c, const scenery_proto_variants& variant)
 {
     return std::visit(
@@ -210,6 +236,20 @@ scenery_variants scenery::subtype_from_proto(object_id id, struct chunk& c, cons
     );
 }
 
+scenery_variants scenery::subtype_from_scenery_type(object_id id, struct chunk& c, enum scenery_type type)
+{
+    switch (type)
+    {
+    case scenery_type::generic:
+        return generic_scenery{id, c, {}};
+    case scenery_type::door:
+        return door_scenery{id, c, {}};
+    case scenery_type::none:
+        break;
+    }
+    fm_throw("invalid scenery type"_cf, (int)type);
+}
+
 scenery::scenery(object_id id, struct chunk& c, const scenery_proto& proto) :
     object{id, c, proto}, subtype{ subtype_from_proto(id, c, proto.subtype) }
 {
diff --git a/src/scenery.hpp b/src/scenery.hpp
index 2c28d936..df5ac186 100644
--- a/src/scenery.hpp
+++ b/src/scenery.hpp
@@ -11,13 +11,15 @@
 
 namespace floormat {
 
+template<typename... Ts> struct [[maybe_unused]] overloaded : Ts... { using Ts::operator()...; };
+template<typename... Ts> overloaded(Ts...) -> overloaded<Ts...>;
+
 struct chunk;
 class anim_atlas;
 class world;
 
 enum class scenery_type : unsigned char {
-    none, generic,
-    door, // todo remove it
+    none, generic, door,
 };
 
 struct generic_scenery_proto
@@ -26,6 +28,7 @@ struct generic_scenery_proto
     unsigned char interactive : 1 = false;
 
     bool operator==(const generic_scenery_proto& p) const;
+    enum scenery_type scenery_type() const;
 };
 
 struct door_scenery_proto
@@ -35,6 +38,7 @@ struct door_scenery_proto
     unsigned char closing     : 1 = false;
 
     bool operator==(const door_scenery_proto& p) const;
+    enum scenery_type scenery_type() const;
 };
 
 using scenery_proto_variants = std::variant<generic_scenery_proto, door_scenery_proto>;
@@ -49,6 +53,7 @@ struct scenery_proto : object_proto
     scenery_proto& operator=(const scenery_proto&);
     bool operator==(const object_proto& proto) const override;
     explicit operator bool() const;
+    enum scenery_type scenery_type() const;
 };
 
 struct scenery;
@@ -106,6 +111,7 @@ struct scenery final : object
 
     static scenery_variants subtype_from_proto(object_id id, struct chunk& c,
                                                const scenery_proto_variants& variants);
+    static scenery_variants subtype_from_scenery_type(object_id id, struct chunk& c, enum scenery_type type);
 
 private:
     friend class world;