Report effective visibility and stable GPU instance identity

src/editor/debug_overlay.cpp

@@ -17,6 +17,17 @@ struct CurrentContext {
         ImGui::SetCurrentContext(previous);
     }
 };
+const char* visibility_label(render::VisibilityMode mode) {
+    switch (mode) {
+    case render::VisibilityMode::Direct:
+        return "Direct";
+    case render::VisibilityMode::GpuFrustum:
+        return "GPU frustum";
+    case render::VisibilityMode::GpuOcclusion:
+        return "GPU occlusion";
+    }
+    return "Unknown";
+}
 ImGuiKey key(std::string_view name) {
     if (name.size() == 1 && name[0] >= 'A' && name[0] <= 'Z')
         return static_cast<ImGuiKey>(ImGuiKey_A + name[0] - 'A');
@@ -272,7 +283,10 @@ void DebugOverlay::append(render::Snapshot& output, render::Renderer& renderer,
                         stats.texture_count);
             ImGui::Separator();
             ImGui::TextUnformatted("GPU visibility");
-            ImGui::Text("Path: %s", stats.gpu_visibility_active ? "active" : "inactive");
+            ImGui::Text("Effective path: %s", visibility_label(stats.effective_visibility_mode));
+            if (stats.requested_visibility_mode != stats.effective_visibility_mode)
+                ImGui::TextDisabled("Fallback from %s",
+                                    visibility_label(stats.requested_visibility_mode));
             ImGui::Text("Indirect bins: %u", stats.gpu_bins);
             if (stats.gpu_visibility_active && stats.visibility_counters_valid) {
                 ImGui::Text("Visible: %u   Frustum rejected: %u",

src/render/renderer.cpp

@@ -1634,10 +1634,12 @@ struct Renderer::Impl {
             it = it->second.owner.expired() ? bounds_cache.erase(it) : std::next(it);
         for (auto it = opacity_cache.begin(); it != opacity_cache.end();)
             it = it->second.owner.expired() ? opacity_cache.erase(it) : std::next(it);
-        const bool gpu_active = scene.available &&
-            config.visibility_mode != VisibilityMode::Direct;
-        const bool occlusion = gpu_active && scene.hzb_supported && scene.hzb_mips &&
-            config.visibility_mode == VisibilityMode::GpuOcclusion;
+        statistics.requested_visibility_mode = config.visibility_mode;
+        statistics.effective_visibility_mode = select_effective_visibility_mode(
+            config.visibility_mode, scene.available, scene.hzb_supported && scene.hzb_mips);
+        const bool gpu_active = statistics.effective_visibility_mode != VisibilityMode::Direct;
+        const bool occlusion = statistics.effective_visibility_mode ==
+            VisibilityMode::GpuOcclusion;
         statistics.gpu_visibility_active = gpu_active;
         statistics.hzb_valid = false;
         bool can_present = surface != VK_NULL_HANDLE;
@@ -1831,7 +1833,7 @@ struct Renderer::Impl {
                     (previous.previous_bounds.max[axis] -
                      previous.previous_bounds.min[axis]) * .5f;
             }
-            instance.metadata[0] = previous.previous_valid && history_compatible ? 1 : 0;
+            instance.metadata = gpu_instance_metadata(previous, history_compatible);
             if (gpu_frame.instances.size() >= UINT32_MAX)
                 throw std::overflow_error("GPU scene instance capacity exceeded");
             bin_it->instances.push_back(static_cast<std::uint32_t>(gpu_frame.instances.size()));

src/render/visibility.cpp

@@ -14,6 +14,16 @@ void validate(const Bounds& bounds) {
 }
 } // namespace
 
+VisibilityMode select_effective_visibility_mode(VisibilityMode requested,
+                                                bool gpu_available,
+                                                bool hzb_available) noexcept {
+    if (!gpu_available || requested == VisibilityMode::Direct)
+        return VisibilityMode::Direct;
+    if (requested == VisibilityMode::GpuOcclusion && hzb_available)
+        return VisibilityMode::GpuOcclusion;
+    return VisibilityMode::GpuFrustum;
+}
+
 Bounds local_bounds(const Mesh& mesh) {
     if (mesh.vertices.empty())
         throw std::invalid_argument("Empty mesh has no bounds");