blam: Experimental BSP switching

Author: hbirchtree

examples/blam/cblam-testing/caching.cpp

@@ -32,8 +32,9 @@ BSPItem BSPCache<V>::predict_impl(const blam::bsp::info& bsp)
     auto const& section = *section_.value();
 
     BSPItem out;
-    out.mesh = &section;
-    out.tag  = &(*index.find(bsp.tag));
+    out.mesh        = &section;
+    out.tag         = &(*index.find(bsp.tag));
+    out.section_idx = next_section_idx++;
 
     if(!out.tag->valid())
         return {};

examples/blam/cblam-testing/caching.h

@@ -195,6 +195,9 @@ struct BSPCache
         vert_ptr = 0, element_ptr = 0, light_ptr = 0;
         evict_all();
 
+        bsp_switches.clear();
+        active_section   = 0;
+        next_section_idx = 0;
         sky_palette.clear();
         if(auto scen_opt = map.tags->scenario(map.map, map.magic))
         {
@@ -224,6 +227,19 @@ struct BSPCache
     blam::map_ptr                         magic;
     std::vector<blam::scn::skybox const*> sky_palette;
 
+    /* Structure BSP switching (scenario bsp_switch_triggers): crossing
+     * `volume` while `source` is the active section activates `destination`.
+     * Only the active section is culled/rendered. */
+    struct bsp_switch_t
+    {
+        blam::scn::trigger_volume const* volume;
+        libc_types::i16                  source;
+        libc_types::i16                  destination;
+    };
+    std::vector<bsp_switch_t> bsp_switches;
+    libc_types::i16           active_section{0};
+    libc_types::i16           next_section_idx{0}; /* predict_impl ordering */
+
     Span<byte_t>           vert_buffer;
     Span<byte_t>           light_buffer;
     Span<blam::vert::face> element_buffer;

examples/blam/cblam-testing/caching_item.h

@@ -218,8 +218,11 @@ struct BSPItem
 
     static_assert(sizeof(FlatSubcluster) == 32);
 
-    blam::bsp::header const*                                mesh{nullptr};
-    blam::tag_t const*                                      tag{nullptr};
+    blam::bsp::header const* mesh{nullptr};
+    blam::tag_t const*       tag{nullptr};
+    /* Index into the scenario's structure BSP list (bsp_info order); used to
+     * match against bsp_switch_trigger source/destination. */
+    libc_types::i16 section_idx{-1};
     std::vector<Group>                                      groups;
     std::vector<Cluster>                                    clusters;
     std::vector<FlatSubcluster>                             sorted_subclusters;

examples/blam/cblam-testing/loading.h

@@ -46,7 +46,8 @@ void load_scenario_bsp(
     auto trigger_vols = scenario->trigger_volumes.data(magic).value();
     for(blam::scn::trigger_volume const& trigger : trigger_vols)
     {
-        auto [origin, second] = trigger.box.points();
+        Vecf3 origin = trigger.position;
+        Vecf3 second = trigger.position + trigger.extents;
 
         auto           trig   = e.create_entity(trigger_obj);
         TriggerVolume& volume = trig.get<TriggerVolume>();
@@ -199,6 +200,29 @@ void load_scenario_bsp(
             Vecf3{0.5f, 1.f, 0});
     }
 
+    /* Structure BSP switching: collect the scenario's switch triggers so the
+     * occluder can track the active section, and start in the section the
+     * first player spawn belongs to. */
+    if(auto switches = scenario->bsp_switch_triggers.data(magic);
+       switches.has_value())
+    {
+        for(blam::scn::bsp_trigger const& sw : switches.value())
+        {
+            if(sw.trigger_volume < 0 ||
+               static_cast<size_t>(sw.trigger_volume) >= trigger_vols.size())
+                continue;
+            bsp_cache.bsp_switches.push_back({
+                .volume      = &trigger_vols[sw.trigger_volume],
+                .source      = sw.source,
+                .destination = sw.destination,
+            });
+            cDebug(
+                "BSP switch: {} → {} via volume '{}'",
+                sw.source,
+                sw.destination,
+                trigger_vols[sw.trigger_volume].name.str());
+        }
+    }
     std::vector<generation_idx_t> bsp_meshes;
     if(auto bsps = scenario->bsp_info.data(magic); bsps.has_value())
     {
@@ -210,6 +234,26 @@ void load_scenario_bsp(
         }
     }
 
+    /* Initial active section: trust the first spawn's bsp_index unless its
+     * position resolves into a different section's BSP tree (b40's first
+     * spawn claims section 0 but sits in section 3). */
+    {
+        auto locations = scenario->player_start.locations.data(magic);
+        if(locations.has_value() && !locations.value().empty())
+        {
+            auto const& loc          = locations.value()[0];
+            bsp_cache.active_section = static_cast<libc_types::i16>(
+                loc.bsp_index);
+            for(auto& [id, item] : bsp_cache.m_cache)
+                if(item.find_cluster_tree(loc.pos).has_value())
+                {
+                    bsp_cache.active_section = item.section_idx;
+                    break;
+                }
+        }
+        cDebug("Initial BSP section: {}", bsp_cache.active_section);
+    }
+
     gpu.bsp_buf->unmap();
     gpu.bsp_index->unmap();
     gpu.bsp_light_buf->unmap();

examples/blam/cblam-testing/occluder.cpp

@@ -104,23 +104,52 @@ struct Occluder : compo::RestrictedSubsystem<Occluder<V>, OccluderManifest<V>>
         u32              current_cluster{0};
         generation_idx_t current_bsp_id{};
 
-        for(auto& ent : p.select(ObjectBsp))
+        /* Structure BSP switching: the active section changes only when the
+         * camera crosses a bsp-switch trigger volume whose source is the
+         * active section — flying into another section's space without
+         * crossing one keeps that section hidden, exactly like the original
+         * engine. Everything below (cluster lookup, PVS, culling) is
+         * restricted to the active section, so inactive sections cost
+         * nothing per frame. */
+        for(auto const& sw : bsp_cache->bsp_switches)
         {
-            auto          ref     = p.template ref<Proxy>(ent);
-            BspReference& bsp_ref = ref.template get<BspReference>();
+            if(sw.source != bsp_cache->active_section)
+                continue;
+            if(!sw.volume->contains(camera_pos))
+                continue;
+            cDebug(
+                "BSP switch: section {} → {} ('{}')",
+                sw.source,
+                sw.destination,
+                sw.volume->name.str());
+            bsp_cache->active_section = sw.destination;
+            break;
+        }
+
+        BSPItem const*   active_bsp{nullptr};
+        generation_idx_t active_bsp_id{};
+        for(auto& [id, item] : bsp_cache->m_cache)
+            if(item.valid() && item.section_idx == bsp_cache->active_section)
+            {
+                active_bsp    = &item;
+                active_bsp_id = {id, bsp_cache->generation};
+                break;
+            }
 
-            BSPItem const& bsp = bsp_cache->find(bsp_ref.bsp)->second;
-            for(auto const& cluster : bsp.clusters)
+        if(active_bsp)
+        {
+            for(auto const& cluster : active_bsp->clusters)
                 for(auto const& sub : cluster.sub)
                     portal_colors[sub.debug_color_idx] = Vecf3(1, 0, 0);
 
-            if(auto cluster = bsp.find_cluster(camera_pos); cluster.has_value())
+            if(auto cluster = active_bsp->find_cluster(camera_pos);
+               cluster.has_value())
             {
                 auto [cluster_, sub_] = cluster.value();
-                current_bsp           = &bsp;
+                current_bsp           = active_bsp;
                 current_cluster       = cluster_;
-                current_bsp_id        = bsp_ref.bsp;
-                auto const& subs      = bsp.clusters.at(cluster_).sub;
+                current_bsp_id        = active_bsp_id;
+                auto const& subs      = active_bsp->clusters.at(cluster_).sub;
                 if(sub_ < subs.size())
                     portal_colors[subs.at(sub_).debug_color_idx] =
                         Vecf3(0, 1, 0);
@@ -132,24 +161,30 @@ struct Occluder : compo::RestrictedSubsystem<Occluder<V>, OccluderManifest<V>>
         /* When the camera enters a new cluster, recompute the portal-traversal
          * visible set. When between clusters, keep the last valid set so
          * culling doesn't snap to all-visible at cluster boundaries. */
-        bool cluster_changed = (current_bsp != nullptr) != last_found ||
+        bool section_changed = active_bsp != pvs_bsp;
+        bool cluster_changed = section_changed ||
+                               (current_bsp != nullptr) != last_found ||
                                current_cluster != last_cluster;
         last_found   = current_bsp != nullptr;
         last_cluster = current_cluster;
 
+        /* The active section is culled even while the camera is outside its
+         * clusters; other sections stay hidden wholesale. */
+        pvs_bsp    = active_bsp;
+        pvs_bsp_id = active_bsp_id;
+        if(section_changed)
+            pvs_visible.clear(); /* stale per-cluster bits of old section */
+
         if(current_bsp)
         {
-            pvs_bsp     = current_bsp;
             pvs_cluster = current_cluster;
-            pvs_bsp_id  = current_bsp_id;
             pvs_visible = pvs_bsp->portal_visible_set(
                 pvs_cluster, camera_pos, camera_mvp);
-        } else if(pvs_bsp)
-        {
-            /* Camera outside all clusters (noclip outside the map shell):
-             * keep the last valid visible set. Snapping to all-visible here
-             * is what used to flash far-off geometry into view. */
         }
+        /* else: camera outside the active section's clusters (noclip through
+         * rock) — keep the last valid set; empty set = all-visible within the
+         * active section. Snapping to all-visible across sections is what
+         * used to flash far-off geometry into view. */
 
         rendering->current_bsp_cluster = pvs_cluster;
 

src/coffee/blam/include/blam/volta/blam_scenario.h

@@ -458,11 +458,22 @@ struct device_group
     u32                unk[3];
 };
 
+/* "Structure BSP switch trigger volume": while `source` is the active
+ * structure BSP and the player enters `trigger_volume`, the engine makes
+ * `destination` the active BSP. Decoded from b40.map, where the referenced
+ * trigger volumes are named 'bsp <source>,<destination>' and entries come
+ * in bidirectional pairs. */
 struct bsp_trigger
 {
-    u32 unk[2];
+    i16 trigger_volume; /* index into scenario trigger_volumes */
+    i16 source;         /* index into scenario structure BSPs (bsp_info) */
+    i16 destination;    /* index into scenario structure BSPs (bsp_info) */
+    i16 unknown;        /* structured (paired like the volumes, -1 for
+                           script-only transitions) but undeciphered */
 };
 
+static_assert(sizeof(bsp_trigger) == 8);
+
 struct move_positions
 {
     bl_string unk1[32];
@@ -479,10 +490,28 @@ struct object_name
 
 struct trigger_volume
 {
-    u32          unk;
-    bl_string    name;
-    f32          unk2[9];
-    bounding_box box;
+    u32       unk;
+    bl_string name;
+    f32       unk2[9]; /* likely 3×Vecf3 orientation axes */
+    Vecf3     position;
+    Vecf3     extents; /* volume spans position .. position + extents
+                          (verified against b40 'null' and door volumes) */
+
+    inline bool contains(Vecf3 const& point) const
+    {
+        auto in = [](f32 v, f32 a, f32 b) {
+            if(a > b)
+            {
+                f32 t = a;
+                a     = b;
+                b     = t;
+            }
+            return v >= a && v <= b;
+        };
+        Vecf3 hi = position + extents;
+        return in(point.x, position.x, hi.x) &&
+               in(point.y, position.y, hi.y) && in(point.z, position.z, hi.z);
+    }
 };
 
 enum class actor_flags_t : u32