Merge branch 'main' into carbon

Author: MaxHwoy

src/hyperlib/streamer/sections.cpp

@@ -306,6 +306,11 @@ namespace hyper
         }
     }
 
+    void visible_section::manager::disable_all_groups()
+    {
+        ::memset(this->enabled_groups, 0, sizeof(this->enabled_groups));
+    }
+
     bool visible_section::manager::loader(chunk* block)
     {
         if (block->id() == block_id::visible_section_manager)
@@ -488,4 +493,21 @@ namespace hyper
 
         return extra_width;
     }
+
+    auto visible_section::manager::get_group_info(const char* group_name) -> const group_info*
+    {
+        size_t length = string::length(group_name);
+
+        for (size_t i = 0u; i < visible_section::manager::group_info_table.length(); ++i)
+        {
+            const group_info& info = visible_section::manager::group_info_table[i];
+
+            if (string::length(info.selection_set_name) == length && !::_strnicmp(info.selection_set_name, group_name, length))
+            {
+                return &info;
+            }
+        }
+
+        return nullptr;
+    }
 }

src/hyperlib/streamer/sections.hpp

@@ -325,6 +325,8 @@ namespace hyper
 
             void disable_group(std::uint32_t key);
 
+            void disable_all_groups();
+
             bool loader(chunk* block);
 
             bool unloader(chunk* block);
@@ -337,6 +339,8 @@ namespace hyper
         public:
             static auto get_distance_outside(const boundary* bound, const vector2& position, float extra_width) -> float;
 
+            static auto get_group_info(const char* group_name) -> const group_info*;
+
         public:
             linked_list<boundary> drivable_boundary_list;
             linked_list<boundary> non_drivable_boundary_list;
@@ -370,6 +374,8 @@ namespace hyper
             static inline std::uint32_t& current_zone_number = *reinterpret_cast<std::uint32_t*>(0x00A71C1C);
 
             static inline geometry::model*& zone_boundary_model = *reinterpret_cast<geometry::model**>(0x00B69BE8);
+
+            static inline array<group_info, 5u> group_info_table = array<group_info, 5u>(0x00A72C30);
         };
     };
 

src/hyperlib/streamer/track_path.cpp

@@ -2,6 +2,19 @@
 
 namespace hyper
 {
+    void track_path::manager::disable_all_barriers()
+    {
+        for (std::uint32_t i = 0u; i < this->barrier_count; ++i)
+        {
+            this->barriers[i].enabled = false;
+        }
+    }
+
+    void track_path::manager::enable_barriers(const char* barrier_name)
+    {
+        call_function<void(__thiscall*)(track_path::manager*, const char*)>(0x007A2390)(this, barrier_name);
+    }
+
     auto track_path::manager::find_zone(const vector2* position, zone::type type, const zone* prev) -> zone*
     {
         if (position == nullptr)

src/hyperlib/streamer/track_path.hpp

@@ -76,6 +76,10 @@ namespace hyper
         struct manager
         {
         public:
+            void disable_all_barriers();
+
+            void enable_barriers(const char* barrier_name);
+
             auto find_zone(const vector2* position, zone::type type, const zone* prev) -> zone*;
 
         public:

src/hyperlib/world/world.cpp

@@ -1,3 +1,6 @@
+#include <hyperlib/assets/scenery.hpp>
+#include <hyperlib/streamer/sections.hpp>
+#include <hyperlib/streamer/track_path.hpp>
 #include <hyperlib/world/world.hpp>
 
 namespace hyper
@@ -19,4 +22,45 @@ namespace hyper
     {
         call_function<void(__cdecl*)()>(0x007AF8F0)();
     }
+
+    void world::enable_barrier_scenery_group(const char* name, bool flip_artwork)
+    {
+        if (visible_section::manager::get_group_info(name) != nullptr)
+        {
+            std::uint32_t key = hashing::bin(name);
+
+            visible_section::manager::instance.enable_group(key);
+
+            scenery::group::enable(key, flip_artwork);
+
+            track_path::manager::instance.enable_barriers(name);
+        }
+    }
+
+    void world::disable_all_scenery_groups()
+    {
+        for (const scenery::group* i = scenery::group::list.begin(); i != scenery::group::list.end(); i = i->next())
+        {
+            if (scenery::group::enabled_table[i->group_number])
+            {
+                i->disable_rendering();
+
+                scenery::group::enabled_table[i->group_number] = 0;
+            }
+        }
+    }
+
+    void world::redo_topology_and_scenery_groups()
+    {
+        track_path::manager::instance.disable_all_barriers();
+
+        visible_section::manager::instance.disable_all_groups();
+        
+        world::disable_all_scenery_groups();
+
+        if (scenery::group::find(hashing::bin_const("SCENERY_GROUP_DOOR")) != nullptr)
+        {
+            world::enable_barrier_scenery_group("SCENERY_GROUP_DOOR", false);
+        }
+    }
 }

src/hyperlib/world/world.hpp

@@ -13,5 +13,11 @@ namespace hyper
         static void init_visible_zones(geometry::model*& boundary_model);
 
         static void notify_sky_loader();
+
+        static void enable_barrier_scenery_group(const char* name, bool flip_artwork);
+
+        static void disable_all_scenery_groups();
+
+        static void redo_topology_and_scenery_groups();
     };
 }

src/hyperlinked/patches.cpp

@@ -22,6 +22,7 @@
 #include <hyperlinked/patches/streamer/streamer.hpp>
 
 #include <hyperlinked/patches/world/collision.hpp>
+#include <hyperlinked/patches/world/world.hpp>
 
 namespace hyper
 {
@@ -49,5 +50,6 @@ namespace hyper
         streamer_patches::init();
 
         collision_patches::init();
+        world_patches::init();
     }
 }

src/hyperlinked/patches/world/world.cpp

@@ -0,0 +1,40 @@
+#include <hyperlib/world/world.hpp>
+#include <hyperlinked/patches/world/world.hpp>
+
+namespace hyper
+{
+    __declspec(naked) void detour_redo_topology_and_scenery_groups()
+    {
+        __asm
+        {
+            // [esp + 0x00] is 'return address'
+
+            // esp is auto-managed, non-incremental
+            // ebp is auto-managed, restored on function return
+
+            push eax; // 'return address' is now at [esp + 0x04]
+            push ebx; // 'return address' is now at [esp + 0x08]
+            push ecx; // 'return address' is now at [esp + 0x0C]
+            push edx; // 'return address' is now at [esp + 0x10]
+            push esi; // 'return address' is now at [esp + 0x14]
+            push edi; // 'return address' is now at [esp + 0x18]
+
+            call world::redo_topology_and_scenery_groups; // call custom redo_topology_and_scenery_groups
+
+            pop edi; // restore saved register
+            pop esi; // restore saved register
+            pop edx; // restore saved register
+            pop ecx; // restore saved register
+            pop ebx; // restore saved register
+            pop eax; // restore saved register
+
+            retn; // return immediately to caller function, not back to RedoTopologyAndSceneryGroups
+        }
+    }
+
+    void world_patches::init()
+    {
+        // RedoTopologyAndSceneryGroups
+        hook::jump(0x006A8AD0, &detour_redo_topology_and_scenery_groups);
+    }
+}

src/hyperlinked/patches/world/world.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+namespace hyper
+{
+    class world_patches final
+    {
+    public:
+        static void init();
+    };
+}