Record final combined P1 Release reference and memory miss

.github/workflows/ci.yml

@@ -68,6 +68,12 @@ jobs:
       - name: Test Linux
         if: runner.os == 'Linux'
         run: ctest --preset linux-debug
+      - name: Verify Lua-free native build
+        if: runner.os == 'Linux'
+        run: |
+          cmake -S . -B build/no-lua -G Ninja -DCMAKE_BUILD_TYPE=Debug -DFASET_ENABLE_LUA=OFF -DFASET_BUILD_RENDERER=OFF -DFASET_BUILD_EDITOR=OFF
+          cmake --build build/no-lua --target faset_schema_exporter faset_runtime_tests --parallel 2
+          ctest --test-dir build/no-lua --output-on-failure -R '^(runtime_contracts|lua_cli_contracts)$'
       - name: Test Windows
         if: runner.os == 'Windows'
         run: ctest --preset windows-debug -LE gpu
@@ -90,3 +96,4 @@ jobs:
           python-version: '3.12'
       - run: python -m pip install -r docs/requirements.txt
       - run: python -m mkdocs build --strict
+      - run: python tests/verify_playable_exports_test.py

.github/workflows/windows-graphics.yml

@@ -71,9 +71,9 @@ jobs:
           VK_LOADER_DEBUG: error,warn,driver
         run: ctest --preset windows-debug --timeout 180
       - name: Real Release exports, 2D and 3D execution, incremental Debug rebuild
-        run: build/windows-debug/faset_build_service_tests.exe --integration .cache/windows-export-e2e
-      - name: Export and relocate both checked-in playable games
-        run: python tools/verify_playable_exports.py --editor build/windows-debug/faset_editor.exe --output .cache/windows-playable-exports
+        run: build/windows-debug/faset_build_service_tests.exe --integration "${{ runner.temp }}/faset-windows-export-e2e"
+      - name: Export and relocate C++ and Lua playable games
+        run: python tools/verify_playable_exports.py --editor build/windows-debug/faset_editor.exe --output .cache/windows-playable-exports --include-lua
       - name: Preserve graphics and export evidence
         if: always()
         uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
@@ -89,8 +89,8 @@ jobs:
             .cache/windows-graphics/sdk/source-identity.json
             build/windows-debug/Testing/Temporary/LastTest.log
             build/windows-debug/*test.ppm
-            .cache/windows-export-e2e/result-*.json
-            .cache/windows-export-e2e/export-*/generations/*/manifest.json
-            .cache/windows-export-e2e/export-*/generations/*/verification.ppm
+            ${{ runner.temp }}/faset-windows-export-e2e/result-*.json
+            ${{ runner.temp }}/faset-windows-export-e2e/export-*/generations/*/manifest.json
+            ${{ runner.temp }}/faset-windows-export-e2e/export-*/generations/*/verification.ppm
             .cache/windows-playable-exports/report.json
             .cache/windows-playable-exports/evidence/*

CMakeLists.txt

@@ -10,6 +10,7 @@ option(FASET_BUILD_RENDERER "Build the SDL3/Vulkan renderer and graphical applic
 option(FASET_SANITIZERS "Enable address and undefined behavior sanitizers" OFF)
 option(FASET_DEBUG_IMGUI "Build optional Dear ImGui diagnostics library" OFF)
 option(FASET_BUILD_RUNTIME "Build ECS and physics runtime" ON)
+option(FASET_ENABLE_LUA "Build the optional sandboxed Lua scripting module" ON)
 option(FASET_BUILD_ASSETS "Build asset import tools" ON)
 option(FASET_BUILD_AUTHORING "Build scene authoring and metadata" ON)
 option(FASET_BUILD_EDITOR "Build retained UI and editor applications" ON)
@@ -32,6 +33,12 @@ target_include_directories(faset_core PUBLIC include)
 target_link_libraries(faset_core PUBLIC nlohmann_json::nlohmann_json Threads::Threads)
 target_compile_definitions(faset_core PUBLIC FASET_VERSION="${PROJECT_VERSION}")
 
+# Manifest/snapshot support is independent of the Lua VM and available to tooling
+# even when the selected game is C++-only.
+add_library(faset_scripting_project STATIC src/scripting/project.cpp)
+target_include_directories(faset_scripting_project PUBLIC include)
+target_link_libraries(faset_scripting_project PUBLIC faset_core)
+
 # Modules are independent targets; Player never links authoring, editor or MCP.
 foreach(module Authoring Runtime Assets)
   if(module STREQUAL "Authoring" AND NOT FASET_BUILD_AUTHORING)
@@ -47,8 +54,14 @@ foreach(module Authoring Runtime Assets)
     include(cmake/${module}.cmake)
   endif()
 endforeach()
+if(FASET_ENABLE_LUA AND TARGET faset_runtime)
+  include(cmake/Lua.cmake)
+endif()
 if(FASET_BUILD_RENDERER AND EXISTS "${PROJECT_SOURCE_DIR}/cmake/Renderer.cmake")
   include(cmake/Renderer.cmake)
+  include(cmake/Visibility.cmake)
+  include(cmake/GpuVisibility.cmake)
+  include(cmake/GpuVisibilityAcceptance.cmake)
 endif()
 if(TARGET faset_gameplay AND EXISTS "${PROJECT_SOURCE_DIR}/cmake/Player.cmake")
   include(cmake/Player.cmake)
@@ -61,13 +74,16 @@ if(TARGET faset_assets AND TARGET faset_authoring AND EXISTS "${PROJECT_SOURCE_D
 endif()
 if(TARGET faset_editor_commands AND TARGET faset_build_service)
   include(cmake/Plugins.cmake)
-  add_library(faset_editor_session STATIC src/editor/session.cpp)
+  add_library(faset_editor_session STATIC src/editor/session.cpp src/editor/autosave.cpp)
   target_link_libraries(faset_editor_session PUBLIC faset_editor_commands faset_build_service faset_assets faset_editor_plugins)
   if(BUILD_TESTING)
     add_executable(faset_editor_session_tests tests/editor_session_tests.cpp)
     target_link_libraries(faset_editor_session_tests PRIVATE faset_editor_session)
     target_compile_definitions(faset_editor_session_tests PRIVATE FASET_TEST_ENGINE="${PROJECT_SOURCE_DIR}")
     add_test(NAME editor_session_settings COMMAND faset_editor_session_tests)
+    add_executable(faset_editor_autosave_tests tests/editor_autosave_tests.cpp)
+    target_link_libraries(faset_editor_autosave_tests PRIVATE faset_editor_session)
+    add_test(NAME editor_autosave COMMAND faset_editor_autosave_tests)
   endif()
 endif()
 foreach(module UI EditorUI Editor Applications)

PLAN.md

@@ -1,8 +1,8 @@
 # План разработки Faset Engine
 
-Версия 1.2 · 18 сентября 2026 года.
+Версия 1.3 · 23 сентября 2026 года.
 
-**Статус:** C++ MVP реализован и принят; первый tag — **v0.1.0-mvp**. Исходники движка проверены на `4cb82556de31268d2bde73948dd1ff1b6c02f162`; финальная публикация добавляет документацию и свидетельства, сохраняя код движка. [Досье M0–M9](docs/validation/mvp-acceptance.md) связывает каждый этап с проверками и точными revisions. Linux проверен на RTX 2080 Ti, Windows — в native CI через SwiftShader; это не сертификация всех GPU/драйверов. Системный IME и физические переходы между мониторами не проверены, native Wayland restore имеет явный skip; XWayland и Windows lifecycle прошли. Текст/DPI проверены на уровне widgets и SDL. Эти границы покрытия сохраняются открыто и не выдаются за пройденные сценарии. Контракты находятся в [ARCHITECTURE.md](docs/ARCHITECTURE.md), история — в [журнале реализации](docs/IMPLEMENTATION.md).
+**Статус:** C++ MVP реализован и принят; первый tag — **v0.1.0-mvp**. Его исходники проверены на `4cb82556de31268d2bde73948dd1ff1b6c02f162`; [досье M0–M9](docs/validation/mvp-acceptance.md) связывает этапы с проверками и revisions. После MVP реализованы Lua-модуль и P2 GPU visibility/mesh LOD. Для P2 сохранён direct-эталон; [досье Linux-проверок](docs/validation/p2-gpu-visibility-2026-09-23/README.md), [проверка Windows SwiftShader](docs/validation/p2-swiftshader-2026-09-23/README.md), [протокол приёмки](docs/studies/19-p2-gpu-visibility-acceptance.md), [первое измерение](docs/studies/20-p2-gpu-visibility-benchmark-2026-09-23.md) и [повтор после оптимизации](docs/studies/21-p2-gpu-visibility-optimization-2026-09-23.md) фиксируют функциональную и измерительную область. Первый Debug-профиль обнаружил дорогой MainCull; перенос GPU-выходов в device-local память и bounded atomic append устранили эту стоимость в повторном синтетическом тесте. Это не доказывает ускорение любой игры. Windows P2 функционально проверен в native CI через SwiftShader; физический Windows GPU и другие семейства драйверов остаются без проверки. Для MVP Linux проверен на RTX 2080 Ti, Windows — в native CI через SwiftShader; это не сертификация всех GPU/драйверов. Системный IME и физические переходы между мониторами не проверены, native Wayland restore имеет явный skip; XWayland и Windows lifecycle прошли. Контракты находятся в [ARCHITECTURE.md](docs/ARCHITECTURE.md), история — в [журнале реализации](docs/IMPLEMENTATION.md).
 
 ## 1. Результат MVP
 
@@ -179,15 +179,36 @@ Lua, C++ hot reload, Blender live link, встроенное изображен
 
 Начальные бюджеты отслеживания для конкретных демо и Linux reference host: frame p95 ≤ 4 мс, GPU/readback p95 ≤ 1 мс, simulation/snapshot p95 ≤ 0,5 мс, явные Vulkan allocations ≤ 20 MiB, startup от `main()` ≤ 500 мс. [Методика и исходные измерения](docs/validation/linux-release-2026-09-18/README.md) ограничивают область этих чисел; для других сцен/ОС нужны отдельные baselines. Это бюджеты P1, а не обещание такой производительности любой игры.
 
-Добавить Lua runtime/editor пакет поверх публичного API, проверяемых handles и схем. Предусмотреть диагностику, отладку, Inspector и явный lifecycle перезагрузки. Сохранение состояния при reload проектируется отдельно. Проверка: C++ и Lua используют одни данные/фазы; C++-only export не включает Lua.
-
-Улучшать schema/build cache, сообщения компилятора, шаблоны проектов, переход к коду, autosave и измеренное время «изменение → результат». Dynamic gameplay loading рассматривать при подтверждённой проблеме линковки.
+Реализованы необязательный Lua runtime/editor модуль, development reload без
+сохранения runtime-состояния, проверяемые schema/package cache и snapshots C++
+исходников, структурированная диагностика, переход к исходнику, четыре C++/Lua
+2D/3D starter-проекта и безопасный autosave именованных сцен. [Датированный
+отчёт P1](docs/validation/p1-iteration-2026-09-24/README.md) содержит raw
+повторные измерения Debug-итераций, 3000 кадров без роста явных GPU allocations,
+синтетическую расширенную сцену и реальные найденные ограничения. [Lua Release
+пакет](docs/validation/lua-release-2026-09-24/README.md) на Linux проверен после
+переноса и скрытия исходного проекта. Windows native/manual, 61 SwiftShader
+CTest и перенос всех трёх Release-игр, включая Lua-only, прошли на
+[чистой ревизии `4ac02ee`](https://github.com/emil28092005/Faset_Engine/actions/runs/35937433040).
+Это функциональная проверка software Vulkan без активного validation layer.
+Исторический Release benchmark точных демо нельзя
+подменять новым Debug workflow; свежий Release reference и физический Windows GPU
+остаются отдельным покрытием. Dynamic gameplay loading рассматривать при
+подтверждённой проблеме линковки, без обещания C++ hot reload в P1.
 
 ### P2. GPU-driven visibility и LOD
 
-Сохранить direct renderer как эталон. Порядок: GPU instance IDs → GPU frustum culling → fixed indirect batches → current HZB/debug view → two-pass occlusion с контролем истории → подготовленный mesh LOD с hysteresis.
+**Реализовано для opaque static meshes; проверено на Linux reference GPU и функционально на Windows SwiftShader. Физический Windows GPU и другие драйверы требуют отдельной проверки.** Direct renderer остался выбираемым эталоном. Реализованы устойчивые instance IDs с generation, GPU frustum culling, фиксированные indirect bins, current HZB и его редакторский preview, main/post occlusion с проверяемой историей, выбор заранее подготовленного mesh LOD по проецируемому размеру и hysteresis. Редактор переключает режимы через diagnostics, Player — через явный флаг `--visibility direct|gpu-frustum|gpu-occlusion`; по умолчанию остаётся Direct. Прозрачные meshes, спрайты, UI и shadow pass сохраняют свои упорядоченные/независимые пути. Система не генерирует LOD-модели из исходного mesh автоматически.
 
-Проверять пустую сцену, рост/переполнение буферов, массовое удаление, открывающуюся дверь, исчезновение заслона, camera cut, teleport и resize. Не требовать синхронного GPU readback. Сравнивать полный кадр на закрытых и открытых сценах: HZB может быть дороже эталона. Основа — [исследование 15](docs/studies/15-renderer-implementation-notes.md).
+GPU instance record содержит стабильные slot/generation; плотный индекс кандидата остаётся адресом в буфере текущего кадра. Диагностика отдельно показывает запрошенный и фактический режим: при отсутствии HZB запрос occlusion явно исполняется как frustum, при отсутствии GPU culling — как Direct. Проверка этих контрактов добавлена после независимого ревью.
+
+- [x] GPU instance records, frustum culling и fixed indirect draws без CPU feedback для решения видимости.
+- [x] Current HZB, двухпроходное исправление ошибочной previous-frame occlusion и инвалидация истории при cut, resize, смене view/projection/instance.
+- [x] Подготовленные LOD с hysteresis и диагностикой LOD counts; direct reference остаётся доступен.
+- [x] Автоматические adversarial-сценарии: пустота, граница ёмкости, дверь/телепорт, тени, near plane, resize, несколько views, lifecycle, прозрачность и открытая сцена.
+- [x] Профиль direct/frustum/occlusion на закрытой и открытой сценах с raw samples и без обещания универсального ускорения.
+
+Основой проектирования было [исследование 15](docs/studies/15-renderer-implementation-notes.md); фактическая проверка — в [Linux-досье](docs/validation/p2-gpu-visibility-2026-09-23/README.md), [Windows SwiftShader CI](docs/validation/p2-swiftshader-2026-09-23/README.md) и [P2 acceptance](docs/studies/19-p2-gpu-visibility-acceptance.md), методика и значения — в [исходном benchmark](docs/studies/20-p2-gpu-visibility-benchmark-2026-09-23.md) и [повторе после оптимизации](docs/studies/21-p2-gpu-visibility-optimization-2026-09-23.md), реализация — в [журнале](docs/IMPLEMENTATION.md). Счётчики GPU и HZB preview включаются только для диагностики; существующий framebuffer capture по-прежнему синхронен, поэтому end-to-end benchmark отражает этот путь. В первом измерении MainCull оказался дорогим; device-local выходные буферы и atomic add уменьшили его p50 до 0,030–0,042 мс в повторном Debug/validation тесте на reference GPU. Direct остаётся начальным режимом: до изменения default нужны Release-профиль и реальные игровые сцены. Открытые сцены и дополнительная стоимость HZB публикуются наравне с закрытыми.
 
 ### P3. Освещение, тени и temporal reconstruction
 

README.md

@@ -2,7 +2,7 @@
 
 Faset is an independent engine project for desktop **2D and 3D games on Linux and Windows**. Its priorities are a custom editor that is comfortable to use by hand and through MCP, integration with Blender, and a path toward advanced graphics.
 
-**Current status: the C++ MVP is implemented and accepted for the recorded Linux and Windows test profiles.** It includes the native Editor, shared GUI/MCP authoring, gameplay builds, Vulkan Player, Blender import and standalone export. Both playable games passed Release export and relocated execution on both operating systems. Windows graphics acceptance used software Vulkan; physical Windows GPUs, system IME and mixed-monitor transitions need additional coverage. See the [acceptance dossier](docs/validation/mvp-acceptance.md) for exact revisions, checks and limits, and the [implementation checkpoints](docs/IMPLEMENTATION.md) for the development record.
+**Current status: the C++ MVP is accepted for the recorded Linux and Windows test profiles; Lua and P2 GPU visibility were added afterward.** The MVP includes the native Editor, shared GUI/MCP authoring, gameplay builds, Vulkan Player, Blender import and standalone export. Both playable games passed Release export and relocated execution on both operating systems. P2 adds optional GPU frustum and two-pass HZB occlusion modes, fixed indirect mesh bins, prepared mesh LOD selection, and an Editor HZB diagnostic view. Direct remains the default and comparison reference; an exported Player can explicitly select a mode with `--visibility direct|gpu-frustum|gpu-occlusion`. P2 GPU acceptance and measurements cover the Linux reference device, with a separate software-Vulkan functional check; Windows P2 functional checks passed on pinned SwiftShader; physical Windows GPUs and broader driver families remain untested. The first Debug/validation benchmark exposed slow GPU culling; device-local outputs and a bounded atomic append improved the same synthetic workloads in the repeat. Neither run establishes a general game-speed benefit. Windows MVP graphics acceptance used software Vulkan. See the [MVP acceptance dossier](docs/validation/mvp-acceptance.md), [P2 Linux evidence](docs/validation/p2-gpu-visibility-2026-09-23/README.md), [P2 SwiftShader compatibility](docs/validation/p2-swiftshader-2026-09-23/README.md), [P2 acceptance protocol](docs/studies/19-p2-gpu-visibility-acceptance.md), [initial benchmark](docs/studies/20-p2-gpu-visibility-benchmark-2026-09-23.md), [optimized benchmark](docs/studies/21-p2-gpu-visibility-optimization-2026-09-23.md), and [implementation checkpoints](docs/IMPLEMENTATION.md) for exact scope and limits.
 
 ## Start here
 
@@ -29,7 +29,7 @@ This README is in English. The current planning documents, studies, and research
 
 ## Accepted foundation
 
-- **C++** for the core and the first gameplay implementation. **Lua** will follow as a separate module and will be optional for individual games.
+- **C++** for the core and native gameplay. **Lua 5.4** is an optional sandboxed gameplay module, with Inspector schemas, development reload, and standalone export. See the [Lua guide](docs/manual/scripting/lua.md).
 - Objects, components, and nested scene templates for authoring; **EnTT** for the runtime ECS. JSON authoring data, stable IDs, and cooked binary assets for export.
 - A custom **Vulkan 1.3** backend, RenderGraph, and renderer. The backend calls Vulkan directly; gameplay uses Faset APIs. **Slang** compiles shaders, including compatible HLSL, to SPIR-V. The baseline renderer does not require ray tracing.
 - **SDL3** behind Faset's platform API; **Box2D** and **Box3D** for physics.
@@ -39,7 +39,7 @@ This README is in English. The current planning documents, studies, and research
 - **Editor-only MCP:** authoring, assets, import, builds, export, Play/Stop, and editor diagnostics. MCP is absent from the Player and exported games.
 - Standard, **unmodified Blender**, glTF/GLB import, and an optional add-on for convenient export and stable IDs.
 
-The MVP provides two small games, one 2D and one 3D, with scene editing, C++ behavior, physics, Play and standalone export. Lua, GPU-driven rendering, HZB, advanced shadows, temporal reconstruction and dynamic global illumination follow this baseline.
+The MVP provides two small games, one 2D and one 3D, with scene editing, C++ behavior, physics, Play and standalone export. A [Lua-only example](examples/lua) demonstrates the optional scripting module. P2 GPU visibility applies to opaque static meshes; ordered sprites/UI and the shadow pass keep their separate rendering paths. Its LOD policy chooses among meshes supplied by the project; the Editor and Player report the effective visibility mode if device capabilities force a fallback. Automatic LOD generation, advanced shadows, temporal reconstruction and dynamic global illumination remain future work. See [profiling guidance](docs/manual/editor/profiling.md) before interpreting full-frame measurements.
 
 ## Run the research map
 

apps/editor_main.cpp

@@ -4,6 +4,7 @@
 #include <faset/editor/mcp.hpp>
 #include <faset/editor/session.hpp>
 #include <iostream>
+#include <memory>
 #include <thread>
 #ifdef FASET_HAS_EDITOR_UI
 #include <faset/editor/editor_ui.hpp>
@@ -40,7 +41,7 @@ void help() {
     std::cout
         << "Faset Editor\n"
            "  faset_editor                         Open the project launcher\n"
-           "  faset_editor --project PATH [--new NAME --dimension 2|3] [--scene RELATIVE_PATH]\n"
+           "  faset_editor --project PATH [--new NAME --dimension 2|3 [--language cpp|lua]] [--scene RELATIVE_PATH]\n"
            "  faset_editor --project PATH --mcp [--gui]\n"
            "  faset_editor --project PATH --command JSON [--wait]\n"
            "Options: --engine SDK_SOURCE, --headless, --frames N, --capture PATH.ppm\n"
@@ -52,9 +53,10 @@ int editor_main(int argc, char** argv) {
     using namespace faset::editor;
     try {
         std::filesystem::path project, engine = path_from_utf8(FASET_ENGINE_SOURCE), scene, capture;
-        std::string new_name, command;
+        std::string new_name, command, language = "cpp";
         int dimension = 3;
         bool mcp = false, gui = true, explicit_gui = false, wait = false;
+        bool explicit_language = false;
         std::uint64_t frames = 0;
         for (int i = 1; i < argc; ++i) {
             const std::string arg = argv[i];
@@ -74,6 +76,10 @@ int editor_main(int argc, char** argv) {
                 new_name = value();
             else if (arg == "--dimension")
                 dimension = std::stoi(value());
+            else if (arg == "--language") {
+                language = value();
+                explicit_language = true;
+            }
             else if (arg == "--scene")
                 scene = path_from_utf8(value());
             else if (arg == "--mcp")
@@ -100,30 +106,65 @@ int editor_main(int argc, char** argv) {
                 throw Error("cli.option", "Unknown option: " + arg);
         }
         require(!(mcp && !command.empty()), "cli.mode", "Choose MCP or a single command");
+        require(!explicit_language || !new_name.empty(), "cli.language",
+                "--language requires --new NAME");
+        require(language == "cpp" || language == "lua", "cli.language",
+                "Language must be cpp or lua");
         if (mcp && !explicit_gui)
             gui = false;
         require(!project.empty() || (gui && !mcp && new_name.empty()), "cli.project",
                 "Use --project PATH for command, MCP, or --new modes");
         auto previous_project = project;
+#ifdef FASET_HAS_EDITOR_UI
+        std::optional<ProjectSelection> retry_create;
+        std::string creation_error;
+#endif
         for (;;) {
             if (project.empty()) {
 #ifdef FASET_HAS_EDITOR_UI
                 const auto selection =
-                    run_project_launcher(engine, previous_project, frames, capture);
+                    run_project_launcher(engine, previous_project, frames, capture,
+                                         retry_create, creation_error);
+                retry_create.reset();
+                creation_error.clear();
                 if (!selection)
                     return 0;
                 project = selection->path;
                 new_name = selection->create ? selection->name : std::string();
                 dimension = selection->dimension;
+                language = selection->language;
+                explicit_language = selection->create;
 #else
                 throw Error("editor.gui_unavailable",
                             "This build has no graphical project launcher; use --project PATH");
 #endif
             }
-            Session session({std::filesystem::absolute(project), std::filesystem::absolute(engine),
-                             executable_directory(argv[0])});
-            if (!new_name.empty())
-                session.scaffold(new_name, dimension);
+            std::unique_ptr<Session> session_holder;
+            try {
+                session_holder = std::make_unique<Session>(SessionConfig{
+                    std::filesystem::absolute(project), std::filesystem::absolute(engine),
+                    executable_directory(argv[0])});
+                if (!new_name.empty()) {
+                    if (explicit_language)
+                        session_holder->scaffold(new_name, dimension, language);
+                    else
+                        session_holder->scaffold(new_name, dimension);
+                }
+            } catch (const std::exception& error) {
+#ifdef FASET_HAS_EDITOR_UI
+                if (gui && !new_name.empty()) {
+                    retry_create = ProjectSelection{std::filesystem::absolute(project),
+                                                    new_name, dimension, true, language};
+                    creation_error = error.what();
+                    project.clear();
+                    new_name.clear();
+                    scene.clear();
+                    continue;
+                }
+#endif
+                throw;
+            }
+            Session& session = *session_holder;
             const auto settings = session.project();
 #ifdef FASET_HAS_EDITOR_UI
             if (gui && std::filesystem::exists(project / "project.faset.json"))
@@ -167,6 +208,8 @@ int editor_main(int argc, char** argv) {
                 project.clear();
                 scene.clear();
                 new_name.clear();
+                explicit_language = false;
+                language = "cpp";
                 continue;
 #else
                 throw Error(

apps/player_main.cpp

@@ -7,8 +7,13 @@
 #include <faset/player/SceneView.hpp>
 #include <faset/runtime/Runtime.hpp>
 #include <faset/runtime/schema.hpp>
+#include <faset/scripting/project.hpp>
+#if defined(FASET_HAS_LUA)
+#include <faset/scripting/LuaModule.hpp>
+#endif
 #include <filesystem>
 #include <iostream>
+#include <memory>
 #include <set>
 #include <stdexcept>
 #include <vector>
@@ -23,6 +28,17 @@ using Json = nlohmann::json;
 double milliseconds(Clock::time_point begin, Clock::time_point end) {
     return std::chrono::duration<double, std::milli>(end - begin).count();
 }
+const char* visibility_mode_name(faset::render::VisibilityMode mode) {
+    switch (mode) {
+    case faset::render::VisibilityMode::Direct:
+        return "direct";
+    case faset::render::VisibilityMode::GpuFrustum:
+        return "gpu-frustum";
+    case faset::render::VisibilityMode::GpuOcclusion:
+        return "gpu-occlusion";
+    }
+    return "unknown";
+}
 struct ProfileSample {
     double wall{}, simulation{}, snapshot{}, render{}, rendererCpu{}, gpu{}, readbackCpu{};
     faset::runtime::FrameStats runtime;
@@ -30,6 +46,8 @@ struct ProfileSample {
     std::uint64_t gpuAllocatedBytes{};
     std::uint32_t textureCount{};
     bool physicsDebug{};
+    bool gpuVisibilityActive{};
+    faset::render::VisibilityMode effectiveVisibilityMode{faset::render::VisibilityMode::Direct};
 };
 Json distribution(std::vector<double> values) {
     if (values.empty())
@@ -75,7 +93,10 @@ Json profileFrames(const std::vector<ProfileSample>& samples) {
                           {"vertices", sample.vertices},
                           {"gpu_allocated_bytes", sample.gpuAllocatedBytes},
                           {"texture_count", sample.textureCount},
-                          {"physics_debug", sample.physicsDebug}});
+                          {"physics_debug", sample.physicsDebug},
+                          {"gpu_visibility_active", sample.gpuVisibilityActive},
+                          {"effective_visibility_mode",
+                           visibility_mode_name(sample.effectiveVisibilityMode)}});
     }
     return {{"samples", std::move(frames)},
             {"summary_ms",
@@ -162,7 +183,8 @@ faset::runtime::RuntimeConfig simulationConfig(const nlohmann::json& scene) {
     }
     return config;
 }
-void validatePackagedShaders(const std::filesystem::path& directory) {
+void validatePackagedShaders(const std::filesystem::path& directory,
+                             faset::render::VisibilityMode visibilityMode) {
     const auto shaders = directory / "shaders";
     for (const auto* entry : {"vertexMain", "fragmentMain", "shadowMain"})
         for (const auto* extension : {".spv", ".reflection.json"}) {
@@ -172,33 +194,47 @@ void validatePackagedShaders(const std::filesystem::path& directory) {
                                          faset::path_to_utf8(path));
         }
     faset::render::validate_shader_bundle(shaders);
+    if (visibilityMode != faset::render::VisibilityMode::Direct)
+        faset::render::validate_gpu_shader_bundle(shaders);
 }
 } // namespace
 int player_main(int argc, char** argv) {
     const auto started = Clock::now();
     try {
-        std::filesystem::path scenePath, assetsPath, capturePath, controlPath, profilePath;
-        bool headless = false, validateOnly = false, debugPhysics = false;
+        std::filesystem::path scenePath, assetsPath, capturePath, controlPath, profilePath,
+            projectRoot;
+        bool headless = false, validateOnly = false, debugPhysics = false, watchLua = false;
+        auto visibilityMode = faset::render::VisibilityMode::Direct;
+        std::string visibilityName = "direct";
         std::uint64_t maximumFrames = 0;
         std::set<std::string> options;
         for (int i = 1; i < argc; ++i) {
             const std::string arg = argv[i];
             if (arg == "--help") {
-                std::cout << "faset_player [--scene PATH] [--assets CACHE] [--frames N] "
-                             "[--headless] [--capture PATH.ppm] [--validate] [--control PATH] "
-                             "[--profile PATH.json] [--debug-physics]\n"
-                             "No --scene: open scene.fscene beside the executable. CACHE contains "
-                             "assets/<id>/.\n"
-                             "Headless uses offscreen Vulkan; --frames uses the configured fixed "
-                             "simulation delta.\n"
-                             "--validate checks scene/resources on CPU without gameplay callbacks "
-                             "or Vulkan initialization.\n"
-                             "--control is an optional editor mailbox for pause/resume/step/stop, "
-                             "without world queries.\n"
-                             "--profile requires explicit --frames 1..100000; measured durations "
-                             "include the first frame and renderer GPU waits/readback.\n"
-                             "Keys: A/D horizontal, W/S vertical, Space jump, E interact, P pause, "
-                             "N single-step, F3 physics boxes, Escape quit.\n";
+                std::cout
+                    << "faset_player [--scene PATH] [--assets CACHE] [--frames N] "
+                       "[--headless] [--capture PATH.ppm] [--validate] [--control PATH] "
+                       "[--profile PATH.json] [--debug-physics] [--project ROOT] "
+                       "[--watch-lua] [--visibility direct|gpu-frustum|gpu-occlusion]\n"
+                       "No --scene: open scene.fscene beside the executable. CACHE contains "
+                       "assets/<id>/.\n"
+                       "Headless uses offscreen Vulkan; --frames uses the configured fixed "
+                       "simulation delta.\n"
+                       "--validate checks scene/resources on CPU without gameplay callbacks "
+                       "or Vulkan initialization.\n"
+                       "--control is an optional editor mailbox for pause/resume/step/stop, "
+                       "without world queries.\n"
+                       "--project loads Lua declared in project.faset.json; packaged projects "
+                       "are discovered beside the scene or executable.\n"
+                       "--watch-lua enables development-only script reload (or control "
+                       "reload-lua): the scene restarts, runtime state is not preserved.\n"
+                       "--profile requires explicit --frames 1..100000; measured durations "
+                       "include the first frame and renderer GPU waits/readback.\n"
+                       "--visibility selects the renderer for this Player run; Direct is "
+                       "the default. GPU modes require their packaged shader bundle and "
+                       "device capabilities.\n"
+                       "Keys: A/D horizontal, W/S vertical, Space jump, E interact, P pause, "
+                       "N single-step, F3 physics boxes, Escape quit.\n";
                 return 0;
             }
             if (!options.insert(arg).second)
@@ -218,7 +254,20 @@ int player_main(int argc, char** argv) {
                 controlPath = faset::path_from_utf8(value());
             else if (arg == "--profile")
                 profilePath = faset::path_from_utf8(value());
-            else if (arg == "--frames")
+            else if (arg == "--project")
+                projectRoot = faset::path_from_utf8(value());
+            else if (arg == "--visibility") {
+                visibilityName = value();
+                if (visibilityName == "direct")
+                    visibilityMode = faset::render::VisibilityMode::Direct;
+                else if (visibilityName == "gpu-frustum")
+                    visibilityMode = faset::render::VisibilityMode::GpuFrustum;
+                else if (visibilityName == "gpu-occlusion")
+                    visibilityMode = faset::render::VisibilityMode::GpuOcclusion;
+                else
+                    throw std::invalid_argument("--visibility must be direct, gpu-frustum, "
+                                                "or gpu-occlusion");
+            } else if (arg == "--frames")
                 maximumFrames = count(value());
             else if (arg == "--headless")
                 headless = true;
@@ -226,6 +275,8 @@ int player_main(int argc, char** argv) {
                 validateOnly = true;
             else if (arg == "--debug-physics")
                 debugPhysics = true;
+            else if (arg == "--watch-lua")
+                watchLua = true;
             else
                 throw std::invalid_argument("Unknown option: " + arg);
         }
@@ -234,9 +285,22 @@ int player_main(int argc, char** argv) {
              validateOnly))
             throw std::invalid_argument("--profile requires an output path and explicit --frames "
                                         "1..100000, without --validate");
+        if (options.contains("--project") && projectRoot.empty())
+            throw std::invalid_argument("--project requires a nonempty root path");
         if (scenePath.empty())
             scenePath = executableDirectory(argv[0]) / "scene.fscene";
         scenePath = std::filesystem::absolute(scenePath).lexically_normal();
+        const auto executableRoot = executableDirectory(argv[0]);
+        if (projectRoot.empty()) {
+            if (std::filesystem::is_regular_file(scenePath.parent_path() / "project.faset.json"))
+                projectRoot = scenePath.parent_path();
+            else if (std::filesystem::is_regular_file(executableRoot / "project.faset.json"))
+                projectRoot = executableRoot;
+        }
+        if (!projectRoot.empty())
+            projectRoot = std::filesystem::absolute(projectRoot).lexically_normal();
+        if (watchLua && (projectRoot.empty() || validateOnly))
+            throw std::invalid_argument("--watch-lua requires a project, without --validate");
         if (assetsPath.empty())
             assetsPath = scenePath.parent_path();
         if (!std::filesystem::is_directory(assetsPath))
@@ -246,13 +310,34 @@ int player_main(int argc, char** argv) {
             maximumFrames = 1;
         const auto sceneReadStarted = Clock::now();
         const auto document = faset::player::readScene(scenePath);
-        faset::runtime::validate_scene_schemas(document, faset::gameplay::schema());
+        const auto nativeSchema = faset::gameplay::schema();
+        if (!nativeSchema.is_array())
+            throw std::runtime_error("Gameplay schema() must return a type array");
+        const auto luaProject = projectRoot.empty() ? faset::scripting::LuaProject{}
+                                                    : faset::scripting::loadLuaProject(projectRoot);
+        auto schema = nativeSchema;
+#if defined(FASET_HAS_LUA)
+        std::unique_ptr<faset::scripting::LuaModule> lua;
+        if (luaProject.enabled()) {
+            lua = std::make_unique<faset::scripting::LuaModule>(luaProject);
+            for (const auto& type : lua->schema())
+                schema.push_back(type);
+        }
+#else
+        if (luaProject.enabled() || watchLua)
+            throw std::runtime_error("This Player was built without Lua support; configure "
+                                     "FASET_ENABLE_LUA=ON for this project");
+#endif
+        faset::runtime::validate_scene_schemas(document, schema);
+#if defined(FASET_HAS_LUA)
+        if (lua)
+            lua->validateScene(document);
+#endif
         const auto config = simulationConfig(document);
         const auto sceneReadFinished = Clock::now();
-        const auto executableRoot = executableDirectory(argv[0]);
         if (scenePath.extension() == ".fscene" &&
             std::filesystem::equivalent(scenePath.parent_path(), executableRoot))
-            validatePackagedShaders(executableRoot);
+            validatePackagedShaders(executableRoot, visibilityMode);
         if (validateOnly) {
             if (!capturePath.empty() || !controlPath.empty())
                 throw std::invalid_argument("--validate cannot capture or control a running game");
@@ -272,13 +357,34 @@ int player_main(int argc, char** argv) {
             return 0;
         }
         const auto worldStarted = Clock::now();
-        faset::runtime::Runtime world(config);
-        faset::gameplay::registerGameplay(world);
-        world.load(document);
+        auto world = std::make_unique<faset::runtime::Runtime>(config);
+        faset::gameplay::registerGameplay(*world);
+#if defined(FASET_HAS_LUA)
+        if (lua)
+            lua->registerBehaviors(*world);
+#endif
+        world->load(document);
+        std::size_t logCursor = 0;
+        auto printGameplayLogs = [&]() {
+            while (logCursor < world->diagnostics().size())
+                std::cerr << world->diagnostics()[logCursor++] << '\n';
+#if defined(FASET_HAS_LUA)
+            if (lua)
+                for (const auto& message : lua->takeLogs())
+                    std::cerr << message << '\n';
+#endif
+        };
+        printGameplayLogs();
         faset::player::SceneView view(assetsPath);
         const auto rendererStarted = Clock::now();
-        faset::render::Renderer renderer(
-            {1280, 720, document.value("name", std::string("Faset Player")), headless, true});
+        faset::render::RendererConfig renderConfig;
+        renderConfig.width = 1280;
+        renderConfig.height = 720;
+        renderConfig.title = document.value("name", std::string("Faset Player"));
+        renderConfig.headless = headless;
+        renderConfig.validation = true;
+        renderConfig.visibility_mode = visibilityMode;
+        faset::render::Renderer renderer(renderConfig);
         const auto rendererReady = Clock::now();
         std::vector<ProfileSample> profile;
         if (!profilePath.empty())
@@ -287,16 +393,78 @@ int player_main(int argc, char** argv) {
         std::set<std::string> held;
         bool stop = false;
         std::uint64_t frames = 0;
-        std::size_t logCursor = 0;
         std::set<std::string> reported;
         std::uint64_t controlSequence = 0;
         std::string previousControl;
         auto previous = std::chrono::steady_clock::now();
+#if defined(FASET_HAS_LUA)
+        auto lastLuaCheck = Clock::now();
+        std::string lastLuaFingerprint = luaProject.fingerprint;
+        std::string lastLuaReloadError;
+        auto reloadLua = [&](bool force) {
+            if (!watchLua)
+                return;
+            const auto now = Clock::now();
+            if (!force && now - lastLuaCheck < std::chrono::milliseconds(500))
+                return;
+            lastLuaCheck = now;
+            std::string candidateFingerprint;
+            try {
+                const auto candidateProject = faset::scripting::loadLuaProject(projectRoot);
+                candidateFingerprint = candidateProject.fingerprint;
+                if (!force && candidateProject.fingerprint == lastLuaFingerprint)
+                    return;
+                // Do not repeatedly execute a broken candidate every half-second.
+                // A corrected source or manifest produces a new fingerprint.
+                lastLuaFingerprint = candidateProject.fingerprint;
+                auto candidateSchema = nativeSchema;
+                std::unique_ptr<faset::scripting::LuaModule> candidateLua;
+                if (candidateProject.enabled()) {
+                    candidateLua = std::make_unique<faset::scripting::LuaModule>(candidateProject);
+                    for (const auto& type : candidateLua->schema())
+                        candidateSchema.push_back(type);
+                }
+                faset::runtime::validate_scene_schemas(document, candidateSchema);
+                if (candidateLua)
+                    candidateLua->validateScene(document);
+                auto candidateWorld = std::make_unique<faset::runtime::Runtime>(config);
+                faset::gameplay::registerGameplay(*candidateWorld);
+                if (candidateLua)
+                    candidateLua->registerBehaviors(*candidateWorld);
+                candidateWorld->load(document);
+                // Runtime isolates callback exceptions into diagnostics. A bad
+                // on_start must not replace the currently running scene.
+                if (!candidateWorld->diagnostics().empty())
+                    throw std::runtime_error(candidateWorld->diagnostics().front());
+                candidateWorld->setPaused(world->paused());
+                world->clear();
+                printGameplayLogs();
+                world = std::move(candidateWorld);
+                lua = std::move(candidateLua);
+                logCursor = 0;
+                printGameplayLogs();
+                lastLuaReloadError.clear();
+                // Compilation and initialization are not simulation wall time.
+                previous = Clock::now();
+                std::cerr << "Lua reloaded: scene restarted; runtime state reset\n";
+            } catch (const std::exception& error) {
+                const std::string message =
+                    std::string("Lua reload rejected; previous scene retained: ") + error.what();
+                // Bad/missing manifests may fail before a fingerprint exists.
+                // Retry them on the next poll but report an unchanged failure once.
+                const auto failure = candidateFingerprint + "\n" + message;
+                if (force || failure != lastLuaReloadError)
+                    std::cerr << message << '\n';
+                lastLuaReloadError = failure;
+            }
+        };
+#endif
         while (!stop && !renderer.should_close() &&
                (maximumFrames == 0 || frames < maximumFrames)) {
             const auto frameStarted = Clock::now();
             faset::runtime::InputState input;
             bool singleStep = false;
+            bool requestLuaReload = false;
             if (!controlPath.empty() && std::filesystem::is_regular_file(controlPath)) {
                 try {
                     if (std::filesystem::file_size(controlPath) > 65536)
@@ -314,14 +482,16 @@ int player_main(int argc, char** argv) {
                         if (value > controlSequence) {
                             const auto command = message.at("command").get<std::string>();
                             if (command == "pause")
-                                world.setPaused(true);
+                                world->setPaused(true);
                             else if (command == "resume")
-                                world.setPaused(false);
+                                world->setPaused(false);
                             else if (command == "step") {
-                                world.setPaused(true);
+                                world->setPaused(true);
                                 singleStep = true;
                             } else if (command == "stop")
                                 stop = true;
+                            else if (command == "reload-lua" && watchLua)
+                                requestLuaReload = true;
                             else
                                 throw std::invalid_argument("unsupported control command");
                             controlSequence = value;
@@ -355,7 +525,7 @@ int player_main(int argc, char** argv) {
                         if (key == "E")
                             input.interactPressed = true;
                         if (key == "P")
-                            world.setPaused(!world.paused());
+                            world->setPaused(!world->paused());
                         if (key == "N")
                             singleStep = true;
                         if (key == "F3")
@@ -365,6 +535,11 @@ int player_main(int argc, char** argv) {
             }
             if (stop)
                 break;
+#if defined(FASET_HAS_LUA)
+            reloadLua(requestLuaReload);
+#else
+            (void)requestLuaReload;
+#endif
             input.horizontal = float(held.contains("D") || held.contains("RIGHT")) -
                                float(held.contains("A") || held.contains("LEFT"));
             input.vertical = float(held.contains("W") || held.contains("UP")) -
@@ -375,14 +550,15 @@ int player_main(int argc, char** argv) {
                                        : std::chrono::duration<double>(now - previous).count();
             previous = now;
             const auto simulationStarted = Clock::now();
-            const auto runtimeStats = singleStep && world.paused() ? world.singleStep(input)
-                                                                   : world.advance(elapsed, input);
+            const auto runtimeStats = singleStep && world->paused()
+                                          ? world->singleStep(input)
+                                          : world->advance(elapsed, input);
             const auto simulationFinished = Clock::now();
-            const auto presentation = world.snapshotJson();
+            const auto presentation = world->snapshotJson();
             auto snapshot = view.build(presentation, static_cast<float>(renderer.width()) /
                                                          std::max(1u, renderer.height()));
             if (debugPhysics)
-                view.appendPhysicsDebug(snapshot, physicsScene(world, presentation));
+                view.appendPhysicsDebug(snapshot, physicsScene(*world, presentation));
             const auto snapshotFinished = Clock::now();
             for (const auto& diagnostic : view.diagnostics()) {
                 if (diagnostic.starts_with("error:"))
@@ -390,10 +566,15 @@ int player_main(int argc, char** argv) {
                 if (reported.insert(diagnostic).second)
                     std::cerr << diagnostic << '\n';
             }
-            while (logCursor < world.diagnostics().size())
-                std::cerr << world.diagnostics()[logCursor++] << '\n';
+            printGameplayLogs();
             const auto renderStarted = Clock::now();
             renderer.render(snapshot);
+            if (frames == 0 &&
+                visibilityMode != renderer.stats().effective_visibility_mode)
+                std::cerr << "Requested " << visibilityName << " visibility is unavailable; "
+                          << "using "
+                          << visibility_mode_name(renderer.stats().effective_visibility_mode)
+                          << " rendering.\n";
             const auto frameFinished = Clock::now();
             if (frames == 0)
                 firstFrameMs = milliseconds(started, frameFinished);
@@ -405,16 +586,16 @@ int player_main(int argc, char** argv) {
                      milliseconds(simulationFinished, snapshotFinished),
                      milliseconds(renderStarted, frameFinished), measured.cpu_ms, measured.gpu_ms,
                      measured.readback_cpu_ms, runtimeStats, measured.draw_calls, measured.vertices,
-                     measured.gpu_allocated_bytes, measured.texture_count, debugPhysics});
+                     measured.gpu_allocated_bytes, measured.texture_count, debugPhysics,
+                     measured.gpu_visibility_active, measured.effective_visibility_mode});
             }
             ++frames;
         }
-        const auto completedTicks = world.snapshot().tick;
+        const auto completedTicks = world->snapshot().tick;
         // Run normal shutdown while diagnostics are still observable. Runtime's
         // destructor is a fallback and cannot print messages after this scope ends.
-        world.clear();
-        while (logCursor < world.diagnostics().size())
-            std::cerr << world.diagnostics()[logCursor++] << '\n';
+        world->clear();
+        printGameplayLogs();
         if (!capturePath.empty()) {
             if (frames == 0)
                 throw std::runtime_error("No frame was rendered for capture");
@@ -435,6 +616,9 @@ int player_main(int argc, char** argv) {
                  {"validation_enabled", stats.validation_enabled},
                  {"validation_errors", stats.validation_errors},
                  {"presentation_mode", headless ? "offscreen" : "windowed"},
+                 {"visibility_mode", visibilityName},
+                 {"effective_visibility_mode",
+                  visibility_mode_name(stats.effective_visibility_mode)},
                  {"simulation_mode", "synthetic_fixed_timestep"},
                  {"fixed_delta_seconds", config.fixedDelta},
                  {"percentile_method", "nearest_rank_all_completed_frames_no_warmup_exclusion"},
@@ -460,6 +644,10 @@ int player_main(int argc, char** argv) {
                                     {"ticks", completedTicks},
                                     {"dimension", document.value("dimension", 3)},
                                     {"device", stats.device},
+                                    {"visibility_mode", visibilityName},
+                                    {"effective_visibility_mode",
+                                     visibility_mode_name(stats.effective_visibility_mode)},
+                                    {"gpu_visibility_active", stats.gpu_visibility_active},
                                     {"validation_errors", stats.validation_errors}}
                          .dump()
                   << '\n';

apps/project_launcher.cpp

@@ -10,6 +10,7 @@
 namespace faset::editor {
 namespace {
 namespace fs = std::filesystem;
+using ui::Appearance;
 using ui::Kind;
 using ui::Widget;
 fs::path user_home() {
@@ -74,6 +75,22 @@ ProjectSelection open_project(const fs::path& path) {
         throw std::runtime_error("Project name or scene type is invalid.");
     return {path, std::move(name), dimension, false};
 }
+bool fresh_destination(const fs::path& path) {
+    if (!fs::exists(path))
+        return true;
+    if (!fs::is_directory(path) || fs::is_symlink(path))
+        return false;
+    for (const auto& entry : fs::directory_iterator(path)) {
+        if (entry.path().filename() != ".faset" || !entry.is_directory() ||
+            entry.is_symlink())
+            return false;
+        for (const auto& internal : fs::directory_iterator(entry.path()))
+            if (internal.path().filename() != "cache" || !internal.is_directory() ||
+                internal.is_symlink() || !fs::is_empty(internal.path()))
+                return false;
+    }
+    return true;
+}
 Json recent_records(const fs::path& file) {
     try {
         auto j = read_json(file);
@@ -123,29 +140,47 @@ struct ProjectLauncher::Impl {
     std::optional<ProjectSelection> selected;
     bool create = false, cancelled = false, browsing = false, browser_valid = false;
     int dimension = 3;
+    std::string language = "cpp";
     std::string error;
     Impl(render::Renderer& r, const fs::path& engine, const fs::path& initial,
-         const fs::path& recents)
+         const fs::path& recents, const std::optional<ProjectSelection>& retry,
+         std::string creation_error)
         : renderer(r), ui(engine / "assets/fonts/NotoSans.ttf"),
           recents_file(recents.empty() ? recent_path() : recents) {
         auto theme = ui::Theme::load(engine / "assets/ui/dark.json");
-        theme.font_size = 15;
-        theme.row_height = 30;
+        theme.font_size = 14;
+        theme.row_height = 28;
         ui.set_theme(theme);
         ui.apply_layout(read_json(engine / "assets/ui/project-launcher-layout.json"));
+        for (const auto* id : {"launcher-heading-rule", "launcher-recent-rule",
+                               "launcher-actions-rule"})
+            ui.find(id)->appearance = Appearance::Section;
+        for (const auto* id : {"launcher-browse", "launcher-cancel"})
+            ui.find(id)->appearance = Appearance::Quiet;
+        ui.find("launcher-submit")->appearance = Appearance::Primary;
+        for (const auto* id : {"launcher-recent-title", "launcher-hint", "launcher-shortcuts"})
+            ui.find(id)->enabled = false;
         ui.set_clipboard([this] { return renderer.clipboard(); },
                          [this](const std::string& value) { renderer.set_clipboard(value); });
         ui.set_ime(
             [this](bool enabled) { renderer.set_text_input(enabled); },
             [this](ui::Rect r) { renderer.set_text_input_area(r.x, r.y, r.width, r.height); });
-        const auto start = initial.empty() ? user_home() / "FasetProjects/MyGame" : initial;
+        const auto start = retry ? retry->path
+                                 : initial.empty() ? user_home() / "FasetProjects/MyGame" : initial;
         ui.update_text("launcher-path", path_to_utf8(start));
-        create = initial.empty();
+        create = retry ? retry->create : initial.empty();
+        if (retry) {
+            ui.update_text("launcher-name", retry->name);
+            dimension = retry->dimension;
+            language = retry->language;
+            error = std::move(creation_error);
+        }
         ui.find("launcher-open")->on_click = [this](Widget&) { set_mode(false); };
         ui.find("launcher-create")->on_click = [this](Widget&) { set_mode(true); };
         ui.find("launcher-2d")->on_click = [this](Widget&) { dimension = 2; };
         ui.find("launcher-3d")->on_click = [this](Widget&) { dimension = 3; };
-        ui.find("launcher-submit")->selected = true;
+        ui.find("launcher-cpp")->on_click = [this](Widget&) { language = "cpp"; };
+        ui.find("launcher-lua")->on_click = [this](Widget&) { language = "lua"; };
         ui.find("launcher-submit")->on_click = [this](Widget&) { submit(); };
         ui.find("launcher-cancel")->on_click = [this](Widget&) { cancelled = true; };
         ui.find("launcher-name")->on_preview = [this](Widget&) { error.clear(); };
@@ -177,7 +212,7 @@ struct ProjectLauncher::Impl {
                     continue;
                 const auto id = "launcher-recent-" + std::to_string(i++);
                 auto& item = list.add(Kind::TreeRow, id, selection.name);
-                item.layout.height = 40;
+                item.layout.height = 38;
                 item.tooltip = path_to_utf8(selection.path);
                 item.on_click = [this, path = selection.path](Widget&) {
                     ui.update_text("launcher-path", path_to_utf8(path), true);
@@ -187,7 +222,7 @@ struct ProjectLauncher::Impl {
             }
         }
         if (i == 0)
-            list.add(Kind::Label, "launcher-recents-empty", "No recent projects");
+            list.add(Kind::Label, "launcher-recents-empty", "No recent projects").enabled = false;
     }
     void submit() {
         ui.clear_focus();
@@ -201,14 +236,14 @@ struct ProjectLauncher::Impl {
                     throw std::runtime_error("Enter a project name.");
                 if (name.size() > 256 || name.find_first_of("\r\n\t") != std::string::npos)
                     throw std::runtime_error("Use a short project name on one line.");
-                if (fs::exists(path) && (!fs::is_directory(path) || !fs::is_empty(path)))
+                if (!fresh_destination(path))
                     throw std::runtime_error("Create requires a new or empty directory.");
                 auto parent = path.parent_path();
                 while (!parent.empty() && !fs::exists(parent))
                     parent = parent.parent_path();
                 if (parent.empty() || !fs::is_directory(parent))
                     throw std::runtime_error("Project parent directory is unavailable.");
-                selected = ProjectSelection{path, name, dimension, true};
+                selected = ProjectSelection{path, name, dimension, true, language};
             } else
                 selected = open_project(path);
             error.clear();
@@ -223,18 +258,22 @@ struct ProjectLauncher::Impl {
     void build_browser() {
         auto& panel = ui.root().add(Kind::Panel, "launcher-browser");
         panel.layout.absolute = true;
-        panel.layout.padding = 16;
-        panel.layout.gap = 10;
+        panel.layout.padding = 20;
+        panel.layout.gap = 8;
         panel.visible = false;
         auto& title = panel.add(Kind::Label, "browser-heading", "Choose project directory");
         title.font_size = 20;
-        title.layout.height = 35;
+        title.layout.height = 44;
         auto& nav = panel.add(Kind::Row, "browser-navigation");
-        nav.layout.height = 36;
-        button(nav, "browser-up", "Up", [this] {
+        nav.layout.height = 38;
+        auto& up = button(nav, "browser-up", "Up", [this] {
             browse_to(browse_path.parent_path());
-        }).layout.width = 60;
-        button(nav, "browser-home", "Home", [this] { browse_to(user_home()); }).layout.width = 76;
+        });
+        up.appearance = Appearance::Quiet;
+        up.layout.width = 60;
+        auto& home = button(nav, "browser-home", "Home", [this] { browse_to(user_home()); });
+        home.appearance = Appearance::Quiet;
+        home.layout.width = 76;
         auto& path = nav.add(Kind::TextField, "browser-path");
         path.layout.flex = 1;
         path.on_preview = [this](Widget&) { browser_valid = false; };
@@ -250,14 +289,18 @@ struct ProjectLauncher::Impl {
         list.layout.scroll = true;
         list.layout.gap = 2;
         auto& actions = panel.add(Kind::Row, "browser-actions");
-        actions.layout.height = 36;
-        button(actions, "browser-choose", "Choose directory", [this] {
+        actions.layout.height = 42;
+        auto& choose = button(actions, "browser-choose", "Choose directory", [this] {
             if (browser_valid) {
                 ui.update_text("launcher-path", path_to_utf8(browse_path), true);
                 close_browser();
             }
-        }).layout.width = 180;
-        button(actions, "browser-cancel", "Cancel", [this] { close_browser(); }).layout.width = 90;
+        });
+        choose.appearance = Appearance::Primary;
+        choose.layout.width = 180;
+        auto& cancel = button(actions, "browser-cancel", "Cancel", [this] { close_browser(); });
+        cancel.appearance = Appearance::Quiet;
+        cancel.layout.width = 90;
         panel.add(Kind::Label, "browser-error");
     }
     void browse_to(const fs::path& path) {
@@ -285,14 +328,14 @@ struct ProjectLauncher::Impl {
             for (const auto& child : children) {
                 auto& row = list.add(Kind::TreeRow, "browser-entry-" + std::to_string(index++),
                                      "[Folder]  " + path_to_utf8(child.filename()));
-                row.layout.height = 34;
+                row.layout.height = 36;
                 row.on_click = [this, child](Widget&) {
                     ui.clear_focus();
                     browse_to(child);
                 };
             }
             if (children.empty())
-                list.add(Kind::Label, "browser-empty", "No subdirectories");
+                list.add(Kind::Label, "browser-empty", "No subdirectories").enabled = false;
         } catch (const fs::filesystem_error&) {
             error = "Cannot access this directory.";
         } catch (const std::exception& e) {
@@ -335,8 +378,24 @@ struct ProjectLauncher::Impl {
         ui.find("launcher-create")->selected = create;
         ui.find("launcher-2d")->selected = dimension == 2;
         ui.find("launcher-3d")->selected = dimension == 3;
+        ui.find("launcher-cpp")->selected = language == "cpp";
+        ui.find("launcher-lua")->selected = language == "lua";
+        ui.find("launcher-2d")->appearance =
+            dimension == 2 ? Appearance::Quiet : Appearance::Default;
+        ui.find("launcher-3d")->appearance =
+            dimension == 3 ? Appearance::Quiet : Appearance::Default;
+        ui.find("launcher-cpp")->appearance =
+            language == "cpp" ? Appearance::Quiet : Appearance::Default;
+        ui.find("launcher-lua")->appearance =
+            language == "lua" ? Appearance::Quiet : Appearance::Default;
+        ui.find("launcher-language-hint")->text =
+            language == "cpp" ? "Compiled gameplay. Add Lua later if you need quick reloads."
+                              : "Lua gameplay reloads during development without a C++ rebuild.";
         for (const auto* id : {"launcher-name-label", "launcher-name", "launcher-dimension-label",
-                               "launcher-dimensions"})
+                               "launcher-dimensions", "launcher-name-group",
+                               "launcher-name-space", "launcher-path-space",
+                               "launcher-dimension-group", "launcher-language-group",
+                               "launcher-language-space"})
             ui.find(id)->visible = create;
         ui.find("launcher-heading")->text = create ? "Create project" : "Open project";
         ui.find("launcher-submit")->text = create ? "Create project" : "Open project";
@@ -352,9 +411,13 @@ struct ProjectLauncher::Impl {
         dialog->layout.height = std::max(300.f, std::min(540.f, logical_height() - 40));
         dialog->layout.x = (logical_width() - dialog->layout.width) * .5f;
         dialog->layout.y = (logical_height() - dialog->layout.height) * .5f;
-        ui.find("launcher-sidebar")->layout.width =
-            std::clamp(logical_width() * .24f, 180.f, 235.f);
-        ui.find("launcher-main")->layout.padding = logical_width() < 850 ? 16 : 32;
+        const auto sidebar_width = std::clamp(logical_width() * .24f, 180.f, 235.f);
+        const auto main_padding = logical_width() < 850 ? 20.f : 36.f;
+        ui.find("launcher-sidebar")->layout.width = sidebar_width;
+        ui.find("launcher-sidebar")->layout.padding = logical_width() < 850 ? 14.f : 18.f;
+        ui.find("launcher-main")->layout.padding = main_padding;
+        ui.find("launcher-form")->layout.width =
+            std::min(720.f, std::max(0.f, logical_width() - sidebar_width - main_padding * 2));
     }
     void frame(const std::vector<render::Event>& events) {
         refresh();
@@ -398,8 +461,11 @@ struct ProjectLauncher::Impl {
     }
 };
 ProjectLauncher::ProjectLauncher(render::Renderer& r, const fs::path& engine,
-                                 const fs::path& initial, const fs::path& recents)
-    : impl_(std::make_unique<Impl>(r, engine, initial, recents)) {}
+                                 const fs::path& initial, const fs::path& recents,
+                                 const std::optional<ProjectSelection>& retry,
+                                 std::string creation_error)
+    : impl_(std::make_unique<Impl>(r, engine, initial, recents, retry,
+                                   std::move(creation_error))) {}
 ProjectLauncher::~ProjectLauncher() = default;
 void ProjectLauncher::frame(const std::vector<render::Event>& events) {
     impl_->frame(events);
@@ -419,9 +485,11 @@ bool ProjectLauncher::cancelled() const {
 std::optional<ProjectSelection> run_project_launcher(const fs::path& engine,
                                                      const fs::path& initial,
                                                      std::uint64_t max_frames,
-                                                     const fs::path& capture) {
+                                                     const fs::path& capture,
+                                                     const std::optional<ProjectSelection>& retry,
+                                                     std::string creation_error) {
     render::Renderer renderer({1100, 720, "Faset Engine — Projects", false, true});
-    ProjectLauncher launcher(renderer, engine, initial);
+    ProjectLauncher launcher(renderer, engine, initial, {}, retry, std::move(creation_error));
     std::uint64_t frames = 0;
     while (!renderer.should_close() && !launcher.cancelled() && !launcher.selection() &&
            (max_frames == 0 || frames < max_frames)) {

apps/schema_exporter_main.cpp

@@ -1,27 +1,51 @@
 #include "Gameplay.hpp"
 #include <faset/core/io.hpp>
+#include <faset/runtime/schema.hpp>
+#include <faset/scripting/project.hpp>
+#if defined(FASET_HAS_LUA)
+#include <faset/scripting/LuaModule.hpp>
+#endif
 #include <iostream>
 #include <stdexcept>
 
 int schema_main(int argc, char** argv) {
     try {
-        std::filesystem::path output;
+        std::filesystem::path output, projectRoot;
         for (int i = 1; i < argc; ++i) {
             const std::string argument = argv[i];
             if (argument == "--help") {
-                std::cout << "faset_schema_exporter [--output PATH]\nExports declarative gameplay "
-                             "schemas without creating a world.\n";
+                std::cout << "faset_schema_exporter [--output PATH] [--project ROOT]\n"
+                             "Exports C++ and declared Lua gameplay schemas without creating a "
+                             "world or invoking lifecycle callbacks.\n";
                 return 0;
             }
             if (argument == "--output" && i + 1 < argc && output.empty())
                 output = faset::path_from_utf8(argv[++i]);
+            else if (argument == "--project" && i + 1 < argc && projectRoot.empty())
+                projectRoot = faset::path_from_utf8(argv[++i]);
             else
                 throw std::invalid_argument("Unknown, repeated or incomplete argument: " +
                                             argument);
         }
-        const auto types = faset::gameplay::schema();
+        auto types = faset::gameplay::schema();
         if (!types.is_array())
             throw std::runtime_error("Gameplay schema() must return a type array");
+        if (!projectRoot.empty()) {
+            const auto project = faset::scripting::loadLuaProject(projectRoot);
+            if (project.enabled()) {
+#if defined(FASET_HAS_LUA)
+                faset::scripting::LuaModule lua(project);
+                for (const auto& type : lua.schema())
+                    types.push_back(type);
+#else
+                throw std::runtime_error("This schema exporter was built without Lua support; "
+                                         "configure FASET_ENABLE_LUA=ON for this project");
+#endif
+            }
+        }
+        // Check all IDs, including unused types, before publishing a manifest.
+        // This player-side boundary intentionally has no authoring dependency.
+        faset::runtime::validate_scene_schemas({{"entities", nlohmann::json::array()}}, types);
         const nlohmann::json manifest{{"format", "faset.schema"}, {"version", 1}, {"types", types}};
         if (output.empty())
             std::cout << manifest.dump(2) << '\n';

assets/ui/dark.json

@@ -1,14 +1,14 @@
 {
-  "background": [0.073, 0.078, 0.090, 1],
-  "surface": [0.102, 0.108, 0.122, 1],
-  "raised": [0.145, 0.151, 0.169, 1],
-  "hover": [0.19, 0.197, 0.219, 1],
-  "border": [0.24, 0.25, 0.278, 1],
-  "text": [0.88, 0.889, 0.91, 1],
-  "muted": [0.59, 0.61, 0.65, 1],
-  "accent": [0.65, 0.60, 0.88, 1],
-  "selection": [0.26, 0.245, 0.35, 1],
-  "danger": [0.92, 0.39, 0.38, 1],
+  "background": [0.078, 0.078, 0.078, 1],
+  "surface": [0.110, 0.110, 0.114, 1],
+  "raised": [0.153, 0.153, 0.161, 1],
+  "hover": [0.196, 0.196, 0.204, 1],
+  "border": [0.227, 0.227, 0.239, 1],
+  "text": [0.878, 0.878, 0.886, 1],
+  "muted": [0.604, 0.604, 0.624, 1],
+  "accent": [0.659, 0.627, 0.761, 1],
+  "selection": [0.220, 0.212, 0.251, 1],
+  "danger": [0.835, 0.431, 0.420, 1],
   "font_size": 14,
   "row_height": 28,
   "padding": 8,

assets/ui/editor-layout.json

@@ -2,18 +2,18 @@
   "root": {
     "id": "root", "kind": "column", "layout": {"gap": 1},
     "children": [
-      {"id": "menubar", "kind": "panel", "layout": {"height": 34, "padding": 3}},
-      {"id": "toolbar", "kind": "panel", "layout": {"height": 40, "padding": 5}},
+      {"id": "menubar", "kind": "panel", "layout": {"height": 36, "padding": 3}},
+      {"id": "toolbar", "kind": "panel", "layout": {"height": 44, "padding": 7}},
       {"id": "workspace", "kind": "row", "layout": {"flex": 1, "gap": 1}, "children": [
-        {"id": "scene_panel", "kind": "panel", "layout": {"width": 224, "min_width": 150, "gap": 0}},
+        {"id": "scene_panel", "kind": "panel", "layout": {"width": 238, "min_width": 150, "gap": 0}},
         {"id": "left_divider", "kind": "divider", "layout": {"width": 5}},
         {"id": "viewport", "kind": "viewport", "layout": {"flex": 1, "min_width": 180}},
         {"id": "right_divider", "kind": "divider", "layout": {"width": 5}},
-        {"id": "inspector_panel", "kind": "panel", "layout": {"width": 300, "min_width": 210, "gap": 0}}
+        {"id": "inspector_panel", "kind": "panel", "layout": {"width": 312, "min_width": 210, "gap": 0}}
       ]},
       {"id": "bottom_divider", "kind": "divider", "layout": {"height": 5}},
-      {"id": "bottom_panel", "kind": "panel", "layout": {"height": 184, "min_height": 90, "gap": 0}},
-      {"id": "statusbar", "kind": "panel", "layout": {"height": 26, "padding": 0}}
+      {"id": "bottom_panel", "kind": "panel", "layout": {"height": 190, "min_height": 90, "gap": 0}},
+      {"id": "statusbar", "kind": "panel", "layout": {"height": 25, "padding": 0}}
     ]
   }
 }

assets/ui/project-launcher-layout.json

@@ -5,34 +5,63 @@
     "children": [{
       "id": "launcher-body", "kind": "row", "layout": {"flex": 1, "gap": 0},
       "children": [
-        {"id": "launcher-sidebar", "kind": "panel", "layout": {"width": 235, "padding": 16, "gap": 8}, "children": [
-          {"id": "launcher-wordmark", "kind": "label", "text": "Faset", "font_size": 26, "layout": {"height": 66}},
-          {"id": "launcher-open", "kind": "tree_row", "text": "Open project", "layout": {"height": 40}},
-          {"id": "launcher-create", "kind": "tree_row", "text": "Create project", "layout": {"height": 40}},
-          {"id": "launcher-recent-title", "kind": "label", "text": "Recent projects", "layout": {"height": 54}},
-          {"id": "launcher-recents", "kind": "column", "layout": {"flex": 1, "scroll": true, "gap": 6}}
+        {"id": "launcher-sidebar", "kind": "panel", "layout": {"width": 235, "padding": 18, "gap": 0}, "children": [
+          {"id": "launcher-wordmark", "kind": "label", "text": "Faset", "font_size": 24, "layout": {"height": 70}},
+          {"id": "launcher-nav", "kind": "column", "layout": {"gap": 4}, "children": [
+            {"id": "launcher-open", "kind": "tree_row", "text": "Open project", "layout": {"height": 38}},
+            {"id": "launcher-create", "kind": "tree_row", "text": "Create project", "layout": {"height": 38}}
+          ]},
+          {"id": "launcher-sidebar-space", "kind": "row", "layout": {"height": 22}},
+          {"id": "launcher-recent-rule", "kind": "row", "layout": {"height": 1}},
+          {"id": "launcher-recent-title", "kind": "label", "text": "Recent projects", "font_size": 13, "layout": {"height": 48}},
+          {"id": "launcher-recents", "kind": "column", "layout": {"flex": 1, "scroll": true, "gap": 4}}
         ]},
-        {"id": "launcher-main", "kind": "column", "layout": {"flex": 1, "padding": 32, "gap": 12, "scroll": true}, "children": [
+        {"id": "launcher-main", "kind": "column", "layout": {"flex": 1, "padding": 36, "gap": 0, "scroll": true}, "children": [
           {"id": "launcher-heading", "kind": "label", "text": "Open project", "font_size": 26, "layout": {"height": 64}},
-          {"id": "launcher-name-label", "kind": "label", "text": "Project name"},
-          {"id": "launcher-name", "kind": "text_field", "text": "My Game", "layout": {"height": 40}},
-          {"id": "launcher-path-label", "kind": "label", "text": "Project directory"},
-          {"id": "launcher-path-row", "kind": "row", "layout": {"height": 40, "gap": 8}, "children": [
-            {"id": "launcher-path", "kind": "text_field", "layout": {"flex": 1}},
-            {"id": "launcher-browse", "kind": "button", "text": "Browse", "layout": {"width": 84}}
+          {"id": "launcher-heading-rule", "kind": "row", "layout": {"height": 1}},
+          {"id": "launcher-form", "kind": "column", "layout": {"width": 720, "gap": 0}, "children": [
+            {"id": "launcher-form-top", "kind": "row", "layout": {"height": 24}},
+            {"id": "launcher-name-group", "kind": "column", "layout": {"gap": 6}, "children": [
+              {"id": "launcher-name-label", "kind": "label", "text": "Project name", "layout": {"height": 24}},
+              {"id": "launcher-name", "kind": "text_field", "text": "My Game", "layout": {"height": 42}}
+            ]},
+            {"id": "launcher-name-space", "kind": "row", "layout": {"height": 20}},
+            {"id": "launcher-path-group", "kind": "column", "layout": {"gap": 6}, "children": [
+              {"id": "launcher-path-label", "kind": "label", "text": "Project directory", "layout": {"height": 24}},
+              {"id": "launcher-path-row", "kind": "row", "layout": {"height": 42, "gap": 8}, "children": [
+                {"id": "launcher-path", "kind": "text_field", "layout": {"flex": 1}},
+                {"id": "launcher-browse", "kind": "button", "text": "Browse", "layout": {"width": 88}}
+              ]}
+            ]},
+            {"id": "launcher-path-space", "kind": "row", "layout": {"height": 20}},
+            {"id": "launcher-dimension-group", "kind": "column", "layout": {"gap": 6}, "children": [
+              {"id": "launcher-dimension-label", "kind": "label", "text": "Initial scene type", "layout": {"height": 24}},
+              {"id": "launcher-dimensions", "kind": "row", "layout": {"height": 42, "gap": 4}, "children": [
+                {"id": "launcher-2d", "kind": "button", "text": "2D", "layout": {"width": 116}},
+                {"id": "launcher-3d", "kind": "button", "text": "3D", "layout": {"width": 116}}
+              ]}
+            ]},
+            {"id": "launcher-language-space", "kind": "row", "layout": {"height": 18}},
+            {"id": "launcher-language-group", "kind": "column", "layout": {"gap": 6}, "children": [
+              {"id": "launcher-language-label", "kind": "label", "text": "Gameplay language", "layout": {"height": 24}},
+              {"id": "launcher-languages", "kind": "row", "layout": {"height": 42, "gap": 4}, "children": [
+                {"id": "launcher-cpp", "kind": "button", "text": "C++", "layout": {"width": 116}},
+                {"id": "launcher-lua", "kind": "button", "text": "Lua", "layout": {"width": 116}}
+              ]},
+              {"id": "launcher-language-hint", "kind": "label", "text": "Compiled gameplay. Add Lua later if you need quick reloads.", "font_size": 12, "layout": {"height": 30}}
+            ]},
+            {"id": "launcher-hint", "kind": "label", "text": "Open a directory containing project.faset.json.", "font_size": 13, "layout": {"height": 36}},
+            {"id": "launcher-actions-space", "kind": "row", "layout": {"height": 22}},
+            {"id": "launcher-actions-rule", "kind": "row", "layout": {"height": 1}},
+            {"id": "launcher-actions-top", "kind": "row", "layout": {"height": 18}},
+            {"id": "launcher-actions", "kind": "row", "layout": {"height": 42, "gap": 10}, "children": [
+              {"id": "launcher-submit", "kind": "button", "text": "Open project", "layout": {"width": 176}},
+              {"id": "launcher-cancel", "kind": "button", "text": "Cancel", "layout": {"width": 90}}
+            ]},
+            {"id": "launcher-error", "kind": "label", "layout": {"height": 36}}
           ]},
-          {"id": "launcher-dimension-label", "kind": "label", "text": "Initial scene type"},
-          {"id": "launcher-dimensions", "kind": "row", "layout": {"height": 40, "gap": 0}, "children": [
-            {"id": "launcher-2d", "kind": "tab", "text": "2D", "layout": {"width": 120}},
-            {"id": "launcher-3d", "kind": "tab", "text": "3D", "layout": {"width": 120}}
-          ]},
-          {"id": "launcher-hint", "kind": "label", "text": "Open a directory containing project.faset.json.", "layout": {"height": 36}},
-          {"id": "launcher-actions", "kind": "row", "layout": {"height": 40, "gap": 8}, "children": [
-            {"id": "launcher-submit", "kind": "button", "text": "Open project", "layout": {"width": 180}},
-            {"id": "launcher-cancel", "kind": "button", "text": "Cancel", "layout": {"width": 90}}
-          ]},
-          {"id": "launcher-error", "kind": "label", "layout": {"height": 30}},
-          {"id": "launcher-shortcuts", "kind": "label", "text": "Tab: next field   Ctrl+Enter: continue   Escape: cancel"}
+          {"id": "launcher-main-spacer", "kind": "row", "layout": {"flex": 1}},
+          {"id": "launcher-shortcuts", "kind": "label", "text": "Tab: next field   Ctrl+Enter: continue   Escape: cancel", "font_size": 12, "layout": {"height": 24}}
         ]}
       ]
     }]

cmake/BuildService.cmake

@@ -1,8 +1,18 @@
-add_library(faset_build_service STATIC ${PROJECT_SOURCE_DIR}/src/editor/build_service.cpp)
+add_library(faset_build_service STATIC
+  ${PROJECT_SOURCE_DIR}/src/editor/build_service.cpp
+  ${PROJECT_SOURCE_DIR}/src/editor/build_cache.cpp
+  ${PROJECT_SOURCE_DIR}/src/editor/build_diagnostics.cpp)
 target_include_directories(faset_build_service PUBLIC ${PROJECT_SOURCE_DIR}/include)
 target_compile_features(faset_build_service PUBLIC cxx_std_20)
-target_link_libraries(faset_build_service PUBLIC faset_core PRIVATE faset_assets faset_authoring Threads::Threads)
+target_link_libraries(faset_build_service PUBLIC faset_core faset_scripting_project PRIVATE faset_assets faset_authoring Threads::Threads)
 if(BUILD_TESTING)
+  add_executable(faset_build_diagnostics_tests ${PROJECT_SOURCE_DIR}/tests/build_diagnostics_tests.cpp)
+  target_link_libraries(faset_build_diagnostics_tests PRIVATE faset_build_service)
+  add_test(NAME build_diagnostics COMMAND faset_build_diagnostics_tests)
+  add_executable(faset_build_cache_tests ${PROJECT_SOURCE_DIR}/tests/build_cache_tests.cpp)
+  target_link_libraries(faset_build_cache_tests PRIVATE faset_build_service)
+  target_compile_definitions(faset_build_cache_tests PRIVATE FASET_ENGINE_SOURCE="${PROJECT_SOURCE_DIR}")
+  add_test(NAME build_cache COMMAND faset_build_cache_tests)
   add_executable(faset_build_service_tests ${PROJECT_SOURCE_DIR}/tests/build_service_tests.cpp)
   target_link_libraries(faset_build_service_tests PRIVATE faset_build_service faset_assets)
   target_compile_definitions(faset_build_service_tests PRIVATE FASET_ENGINE_SOURCE="${PROJECT_SOURCE_DIR}")
@@ -13,5 +23,12 @@ if(BUILD_TESTING)
   target_link_libraries(faset_build_schema_tests PRIVATE faset_build_service faset_authoring faset_editor_commands)
   add_dependencies(faset_build_schema_tests faset_build_schema_tool)
   add_test(NAME build_schema_publication COMMAND faset_build_schema_tests $<TARGET_FILE:faset_build_schema_tool> ${PROJECT_SOURCE_DIR})
-  set_tests_properties(build_schema_publication PROPERTIES TIMEOUT 60)
+  # This fixture performs many full cache invalidations and process launches.
+  # Windows runner startup and antivirus overhead exceed 60 seconds even when
+  # individual native fixture commands finish normally.
+  if(WIN32)
+    set_tests_properties(build_schema_publication PROPERTIES TIMEOUT 240)
+  else()
+    set_tests_properties(build_schema_publication PROPERTIES TIMEOUT 60)
+  endif()
 endif()

cmake/EditorUI.cmake

@@ -47,5 +47,8 @@ if(TARGET faset_ui AND TARGET faset_editor_session AND TARGET faset_scene_view)
         set_tests_properties(editor_ui_gizmos PROPERTIES LABELS "gpu")
         add_test(NAME editor_ui_authoring COMMAND faset_editor_ui_tests)
         set_tests_properties(editor_ui_authoring PROPERTIES LABELS "gpu")
+        add_executable(faset_editor_ui_latency ${PROJECT_SOURCE_DIR}/tests/editor_ui_latency.cpp)
+        target_link_libraries(faset_editor_ui_latency PRIVATE faset_editor_ui)
+        target_compile_definitions(faset_editor_ui_latency PRIVATE FASET_TEST_ENGINE="${PROJECT_SOURCE_DIR}")
     endif()
 endif()

cmake/GpuVisibility.cmake

@@ -0,0 +1,13 @@
+if(TARGET faset_render)
+  add_executable(faset_p2_visibility_example
+    "${PROJECT_SOURCE_DIR}/examples/renderer/p2_visibility.cpp")
+  target_link_libraries(faset_p2_visibility_example PRIVATE faset_render)
+endif()
+
+if(TARGET faset_render AND BUILD_TESTING)
+  add_executable(faset_render_gpu_visibility_tests
+    "${PROJECT_SOURCE_DIR}/tests/render_gpu_visibility_tests.cpp")
+  target_link_libraries(faset_render_gpu_visibility_tests PRIVATE faset_render)
+  add_test(NAME gpu_visibility COMMAND faset_render_gpu_visibility_tests)
+  set_tests_properties(gpu_visibility PROPERTIES LABELS "gpu;p2")
+endif()

cmake/GpuVisibilityAcceptance.cmake

@@ -0,0 +1,14 @@
+# P2's image-equivalence tests use the real offscreen Vulkan renderer. Keep the benchmark
+# executable available without making performance thresholds part of CTest.
+if(BUILD_TESTING AND TARGET faset_render)
+  add_executable(faset_render_gpu_acceptance_tests
+    "${PROJECT_SOURCE_DIR}/tests/render_gpu_acceptance_tests.cpp")
+  target_link_libraries(faset_render_gpu_acceptance_tests PRIVATE faset_render)
+  foreach(FASET_VISIBILITY_CASE empty capacity dense door shadow cut resize lod
+      teleport near lifecycle views projection open_sequence transparent)
+    add_test(NAME "render_gpu_${FASET_VISIBILITY_CASE}"
+      COMMAND faset_render_gpu_acceptance_tests --case "${FASET_VISIBILITY_CASE}")
+    set_tests_properties("render_gpu_${FASET_VISIBILITY_CASE}"
+      PROPERTIES LABELS "gpu;p2" TIMEOUT 120)
+  endforeach()
+endif()

cmake/Lua.cmake

@@ -0,0 +1,38 @@
+# Official Lua sources are checksum-pinned in dependencies.lock.json. Build only
+# the VM and libraries, never the standalone lua/luac executables or a system ABI.
+faset_dependency(lua)
+set(lua_src "${FASET_lua_SOURCE_DIR}/src")
+add_library(faset_lua_vendor STATIC
+    ${lua_src}/lapi.c ${lua_src}/lcode.c ${lua_src}/lctype.c
+    ${lua_src}/ldebug.c ${lua_src}/ldo.c ${lua_src}/ldump.c
+    ${lua_src}/lfunc.c ${lua_src}/lgc.c ${lua_src}/llex.c
+    ${lua_src}/lmem.c ${lua_src}/lobject.c ${lua_src}/lopcodes.c
+    ${lua_src}/lparser.c ${lua_src}/lstate.c ${lua_src}/lstring.c
+    ${lua_src}/ltable.c ${lua_src}/ltm.c ${lua_src}/lundump.c
+    ${lua_src}/lvm.c ${lua_src}/lzio.c ${lua_src}/lauxlib.c
+    ${lua_src}/lbaselib.c ${lua_src}/lmathlib.c ${lua_src}/lstrlib.c
+    ${lua_src}/ltablib.c ${lua_src}/lutf8lib.c)
+target_include_directories(faset_lua_vendor SYSTEM PUBLIC "${lua_src}")
+if(NOT MSVC)
+    # Upstream intentionally uses compiler-supported computed gotos in the VM.
+    target_compile_options(faset_lua_vendor PRIVATE -Wno-pedantic)
+endif()
+if(UNIX)
+    target_link_libraries(faset_lua_vendor PUBLIC m)
+endif()
+add_library(faset_lua STATIC ${PROJECT_SOURCE_DIR}/src/scripting/LuaModule.cpp)
+add_library(Faset::Lua ALIAS faset_lua)
+target_include_directories(faset_lua PUBLIC ${PROJECT_SOURCE_DIR}/include)
+target_link_libraries(faset_lua PUBLIC faset_runtime faset_scripting_project PRIVATE faset_lua_vendor)
+
+if(BUILD_TESTING)
+    add_executable(faset_lua_tests ${PROJECT_SOURCE_DIR}/tests/lua_tests.cpp)
+    target_link_libraries(faset_lua_tests PRIVATE faset_lua)
+    target_compile_definitions(faset_lua_tests PRIVATE FASET_SOURCE_DIR="${PROJECT_SOURCE_DIR}")
+    add_test(NAME lua_contracts COMMAND faset_lua_tests)
+    set_tests_properties(lua_contracts PROPERTIES TIMEOUT 30)
+    add_executable(faset_lua_safety_tests ${PROJECT_SOURCE_DIR}/tests/lua_safety_tests.cpp)
+    target_link_libraries(faset_lua_safety_tests PRIVATE faset_lua)
+    add_test(NAME lua_safety_contracts COMMAND faset_lua_safety_tests)
+    set_tests_properties(lua_safety_contracts PROPERTIES TIMEOUT 30)
+endif()

cmake/Player.cmake

@@ -1,6 +1,10 @@
 if(TARGET faset_gameplay)
     add_executable(faset_schema_exporter ${PROJECT_SOURCE_DIR}/apps/schema_exporter_main.cpp)
-    target_link_libraries(faset_schema_exporter PRIVATE faset_core faset_gameplay)
+    target_link_libraries(faset_schema_exporter PRIVATE faset_core faset_gameplay faset_scripting_project)
+    if(TARGET faset_lua)
+        target_link_libraries(faset_schema_exporter PRIVATE faset_lua)
+        target_compile_definitions(faset_schema_exporter PRIVATE FASET_HAS_LUA=1)
+    endif()
 endif()
 
 if(TARGET faset_runtime AND TARGET faset_render AND TARGET faset_assets)
@@ -14,7 +18,11 @@ if(TARGET faset_runtime AND TARGET faset_render AND TARGET faset_assets)
         target_compile_definitions(faset_scene_view PRIVATE FASET_HAS_STB=1)
     endif()
     add_executable(faset_player ${PROJECT_SOURCE_DIR}/apps/player_main.cpp)
-    target_link_libraries(faset_player PRIVATE faset_scene_view faset_runtime faset_gameplay)
+    target_link_libraries(faset_player PRIVATE faset_scene_view faset_runtime faset_gameplay faset_scripting_project)
+    if(TARGET faset_lua)
+        target_link_libraries(faset_player PRIVATE faset_lua)
+        target_compile_definitions(faset_player PRIVATE FASET_HAS_LUA=1)
+    endif()
     install(TARGETS faset_player RUNTIME DESTINATION .)
     if(BUILD_TESTING)
         add_executable(faset_player_tests ${PROJECT_SOURCE_DIR}/tests/runtime_player_tests.cpp)
@@ -28,7 +36,11 @@ if(TARGET faset_runtime AND TARGET faset_render AND TARGET faset_assets)
             ${PROJECT_SOURCE_DIR}/tests/player_diagnostics/Gameplay.cpp)
         target_include_directories(faset_player_diagnostics PRIVATE
             ${PROJECT_SOURCE_DIR}/tests/player_diagnostics)
-        target_link_libraries(faset_player_diagnostics PRIVATE faset_scene_view faset_runtime)
+        target_link_libraries(faset_player_diagnostics PRIVATE faset_scene_view faset_runtime faset_scripting_project)
+        if(TARGET faset_lua)
+            target_link_libraries(faset_player_diagnostics PRIVATE faset_lua)
+            target_compile_definitions(faset_player_diagnostics PRIVATE FASET_HAS_LUA=1)
+        endif()
         find_package(Python3 COMPONENTS Interpreter REQUIRED)
         add_test(NAME player_shutdown_diagnostics COMMAND ${Python3_EXECUTABLE}
             ${PROJECT_SOURCE_DIR}/tests/player_diagnostics_test.py
@@ -36,3 +48,22 @@ if(TARGET faset_runtime AND TARGET faset_render AND TARGET faset_assets)
         set_tests_properties(player_shutdown_diagnostics PROPERTIES LABELS "gpu" TIMEOUT 60)
     endif()
 endif()
+
+if(BUILD_TESTING AND TARGET faset_schema_exporter)
+    find_package(Python3 COMPONENTS Interpreter REQUIRED)
+    set(FASET_LUA_CLI_TEST_ARGS --exporter $<TARGET_FILE:faset_schema_exporter>)
+    if(TARGET faset_player)
+        list(APPEND FASET_LUA_CLI_TEST_ARGS --player $<TARGET_FILE:faset_player>)
+    endif()
+    if(NOT TARGET faset_lua)
+        list(APPEND FASET_LUA_CLI_TEST_ARGS --disabled)
+    endif()
+    add_test(NAME lua_cli_contracts COMMAND ${Python3_EXECUTABLE}
+        ${PROJECT_SOURCE_DIR}/tests/lua_cli_test.py ${FASET_LUA_CLI_TEST_ARGS})
+    set_tests_properties(lua_cli_contracts PROPERTIES TIMEOUT 90)
+    if(TARGET faset_lua AND TARGET faset_player)
+        add_test(NAME lua_player_reload COMMAND ${Python3_EXECUTABLE}
+            ${PROJECT_SOURCE_DIR}/tests/lua_player_reload_test.py $<TARGET_FILE:faset_player>)
+        set_tests_properties(lua_player_reload PROPERTIES LABELS "gpu" TIMEOUT 90)
+    endif()
+endif()

cmake/Renderer.cmake

@@ -17,6 +17,23 @@ foreach(FASET_ENTRY vertexMain fragmentMain shadowMain)
     DEPENDS "${PROJECT_SOURCE_DIR}/shaders/baseline.slang" "${PROJECT_SOURCE_DIR}/tools/compile_shader.py" VERBATIM)
   list(APPEND FASET_SHADER_OUTPUTS "${FASET_SHADER_OUTPUT}" "${FASET_SHADER_DIRECTORY}/${FASET_ENTRY}.reflection.json")
 endforeach()
+foreach(FASET_ENTRY gpuVertexMain gpuShadowMain gpuCullMain gpuHzbMain gpuPostCullMain)
+  if(FASET_ENTRY STREQUAL "gpuVertexMain" OR FASET_ENTRY STREQUAL "gpuShadowMain")
+    set(FASET_GPU_DEFINE FASET_GPU_GRAPHICS=1)
+  elseif(FASET_ENTRY STREQUAL "gpuHzbMain")
+    set(FASET_GPU_DEFINE FASET_GPU_HZB=1)
+  else()
+    set(FASET_GPU_DEFINE FASET_GPU_CULL=1)
+  endif()
+  set(FASET_SHADER_OUTPUT "${FASET_SHADER_DIRECTORY}/${FASET_ENTRY}.spv")
+  add_custom_command(OUTPUT "${FASET_SHADER_OUTPUT}" "${FASET_SHADER_DIRECTORY}/${FASET_ENTRY}.reflection.json"
+    COMMAND "${Python3_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/tools/compile_shader.py"
+            --compiler "${SLANGC_EXECUTABLE}" --source "${PROJECT_SOURCE_DIR}/shaders/gpu_scene.slang"
+            --entry "${FASET_ENTRY}" --define "${FASET_GPU_DEFINE}" --output "${FASET_SHADER_DIRECTORY}"
+    BYPRODUCTS "${FASET_SHADER_DIRECTORY}/${FASET_ENTRY}.slang-reflection.json"
+    DEPENDS "${PROJECT_SOURCE_DIR}/shaders/gpu_scene.slang" "${PROJECT_SOURCE_DIR}/tools/compile_shader.py" VERBATIM)
+  list(APPEND FASET_SHADER_OUTPUTS "${FASET_SHADER_OUTPUT}" "${FASET_SHADER_DIRECTORY}/${FASET_ENTRY}.reflection.json")
+endforeach()
 add_custom_command(OUTPUT "${FASET_SHADER_DIRECTORY}/compatibility.spv"
   COMMAND "${SLANGC_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/shaders/compatibility.hlsl"
           -entry compatibilityMain -stage compute -target spirv -profile spirv_1_6
@@ -49,6 +66,14 @@ if(BUILD_TESTING)
     FASET_PYTHON_EXECUTABLE="${Python3_EXECUTABLE}")
   add_test(NAME render_shader_reload COMMAND faset_render_reload_tests)
   set_tests_properties(render_shader_reload PROPERTIES LABELS "gpu")
+  add_executable(faset_render_gpu_shader_contract_tests "${PROJECT_SOURCE_DIR}/tests/render_gpu_shader_contract_tests.cpp")
+  target_include_directories(faset_render_gpu_shader_contract_tests PRIVATE "${PROJECT_SOURCE_DIR}/src/render")
+  target_link_libraries(faset_render_gpu_shader_contract_tests PRIVATE faset_render faset_core)
+  target_compile_definitions(faset_render_gpu_shader_contract_tests PRIVATE FASET_TEST_SHADER_DIRECTORY="${FASET_SHADER_DIRECTORY}")
+  add_test(NAME render_gpu_shader_contract COMMAND faset_render_gpu_shader_contract_tests)
+  add_test(NAME render_shader_reflection COMMAND "${CMAKE_COMMAND}" -E env
+    "FASET_TEST_SLANGC=${SLANGC_EXECUTABLE}"
+    "${Python3_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/tests/test_shader_reflection.py")
   add_executable(faset_render_window_tests "${PROJECT_SOURCE_DIR}/tests/render_window_tests.cpp")
   target_link_libraries(faset_render_window_tests PRIVATE faset_render SDL3::SDL3)
   add_test(NAME render_window_lifecycle COMMAND faset_render_window_tests "${CMAKE_BINARY_DIR}/window-test")

cmake/Runtime.cmake

@@ -7,8 +7,11 @@ target_include_directories(faset_runtime PUBLIC ${CMAKE_CURRENT_LIST_DIR}/../inc
 target_link_libraries(faset_runtime PUBLIC nlohmann_json::nlohmann_json PRIVATE EnTT::EnTT box2d box3d)
 
 set(FASET_GAMEPLAY_SOURCE_DIR "${PROJECT_SOURCE_DIR}/examples/gameplay" CACHE PATH "Directory containing the game's Gameplay.cpp and Gameplay.hpp")
-if(NOT EXISTS "${FASET_GAMEPLAY_SOURCE_DIR}/Gameplay.cpp" OR NOT EXISTS "${FASET_GAMEPLAY_SOURCE_DIR}/Gameplay.hpp")
-    message(FATAL_ERROR "FASET_GAMEPLAY_SOURCE_DIR must contain Gameplay.cpp and Gameplay.hpp")
+if(NOT EXISTS "${FASET_GAMEPLAY_SOURCE_DIR}/Gameplay.cpp" AND NOT EXISTS "${FASET_GAMEPLAY_SOURCE_DIR}/Gameplay.hpp" AND FASET_ENABLE_LUA)
+    # A Lua-only game needs the same stable native entry points, but no user C++.
+    set(FASET_GAMEPLAY_SOURCE_DIR "${PROJECT_SOURCE_DIR}/src/scripting/empty_gameplay")
+elseif(NOT EXISTS "${FASET_GAMEPLAY_SOURCE_DIR}/Gameplay.cpp" OR NOT EXISTS "${FASET_GAMEPLAY_SOURCE_DIR}/Gameplay.hpp")
+    message(FATAL_ERROR "Provide both Gameplay.cpp and Gameplay.hpp, or enable Lua for a Lua-only project")
 endif()
 add_library(faset_gameplay STATIC "${FASET_GAMEPLAY_SOURCE_DIR}/Gameplay.cpp")
 add_library(Faset::Gameplay ALIAS faset_gameplay)

cmake/Visibility.cmake

@@ -0,0 +1,9 @@
+if(TARGET faset_render)
+  target_sources(faset_render PRIVATE "${PROJECT_SOURCE_DIR}/src/render/visibility.cpp")
+endif()
+if(TARGET faset_render AND BUILD_TESTING)
+  add_executable(faset_render_visibility_policy_tests
+    "${PROJECT_SOURCE_DIR}/tests/render_visibility_policy_tests.cpp")
+  target_link_libraries(faset_render_visibility_policy_tests PRIVATE faset_render)
+  add_test(NAME visibility_policy COMMAND faset_render_visibility_policy_tests)
+endif()

dependencies.lock.json

@@ -1,6 +1,14 @@
 {
   "format": 1,
   "dependencies": {
+    "lua": {
+      "repository": "https://www.lua.org",
+      "version": "5.4.9",
+      "commit": "5.4.9",
+      "url": "https://www.lua.org/ftp/lua-5.4.9.tar.gz",
+      "sha256": "2335b6c582a52654f94612bf10d2f4672805d05329aa6568b1d8cd9e5c6fb8e6",
+      "license": "MIT"
+    },
     "sdl3": {
       "repository": "https://github.com/libsdl-org/SDL",
       "version": "release-3.2.20",

design/references/editor-redesign-2026-09-23.md

@@ -0,0 +1,24 @@
+# Editor visual direction — 2026-09-23
+
+![Editor redesign prototype](editor-redesign-2026-09-23.png)
+
+Generated with the built-in image generation tool before changing the native editor UI. This is a visual reference, not a working Faset screenshot or a feature specification. The generated scene, icons, asset columns, FPS counter, tag/layer controls and viewport shading are illustrative. The implemented controls must reflect real Faset behavior.
+
+## Implemented native UI
+
+![Editor integration test capture](editor-redesign-implemented.png)
+
+![Project launcher integration test capture](project-launcher-redesign-implemented.png)
+
+These are Vulkan captures from the Linux UI integration tests after the redesign. Their test project data and viewport contents are examples; the interaction model is defined by the native UI and editor code.
+
+## Design brief
+
+- A quiet graphics workbench: the rendered scene is the focal point; tool chrome recedes.
+- Near-black neutral surfaces: background `#141414`, panels `#1c1c1d`, raised controls `#272729`, hairline borders `#3a3a3d`.
+- Light text `#e0e0e2`, secondary text `#9a9a9f`, restrained lavender `#a8a0c2` for focus, selection and the primary Play action.
+- Keep Noto Sans for the native editor's single-font Unicode pipeline; use size and spacing for hierarchy. Compact 14 px controls and 28 px rows.
+- Retain the real Scene / viewport / Inspector / bottom dock layout, stable widget IDs, keyboard focus, editor commands and MCP parity. Use no raster screenshot as an interactive background.
+- Make secondary actions quiet; keep explicit input fields and modal actions legible. Show file names first and preserve full asset paths in tooltips. Keep import freshness visible at the start of imported asset rows.
+
+The generated prototype was requested with the current editor's real regions and actions, a simple greybox scene and flat retained-mode controls. The visual hierarchy, palette and density are the reference; the repository's UI code and authoring contract determine functionality.

design/references/p2-visibility-diagnostics-prototype.md

@@ -0,0 +1,21 @@
+# P2 visibility diagnostics visual reference
+
+![Generated visibility diagnostics prototype](p2-visibility-diagnostics-prototype.png)
+
+Generated with the built-in image generation tool before implementing the developer overlay. This is a visual prototype, not a Faset screenshot or a feature specification. The greybox scene, values, metrics, and viewport controls in the generated image are illustrative. In particular, Faset does not report the prototype's triangle-visibility, HZB texture-size, or history-length numbers.
+
+The implementation uses the prototype's compact three-mode visibility selector, near-black surfaces, restrained lavender selection, simple dividers, and grouping. It only reports actual `Renderer::FrameStats` fields and retains the existing ImGui diagnostics behavior. The runtime renderer and source code define functionality.
+
+![Implemented diagnostics in the headless Vulkan test](p2-visibility-diagnostics-implemented.png)
+
+The second image is the actual 640 × 420 test capture with a deliberately empty scene. It verifies the selected GPU frustum button and the real counters, with the panel scrolling on a small viewport.
+
+## Current-HZB preview extension
+
+![Updated prototype with HZB thumbnail](p2-visibility-diagnostics-hzb-prototype.png)
+
+The updated prototype was made with the built-in image editing tool before adding the preview control. Its HZB thumbnail and status values are illustrative. The actual overlay exposes **Show HZB** only as an on-demand diagnostic, offers a mip selector, and uses a real GPU depth-pyramid readback. It does not read back HZB while the preview is off.
+
+![Implemented current-HZB preview in the Vulkan test](p2-visibility-diagnostics-hzb-implemented.png)
+
+This 640 × 700 capture is the real developer overlay drawing mip 3 of a cube scene's current HZB. The first frame has already completed, so the displayed visibility counters are actual GPU-read values. The default panel grows when the preview is enabled; on a shorter display it remains scrollable.

docs/ARCHITECTURE.md

@@ -1,6 +1,6 @@
 # Faset Engine — архитектура
 
-Редакция 1.1 · 18 сентября 2026 · **принятый проект, реализация MVP в процессе**.
+Редакция 1.3 · 24 сентября 2026 · **MVP принят; реализация P1/P2 описана отдельно от исходных решений**.
 
 Этот файл фиксирует решения пользователя. **Принято** означает выбранное направление реализации, а не автоматически завершённую возможность движка. Работающий код, выполненные проверки и текущие ограничения перечислены в [журнале реализации](IMPLEMENTATION.md). Этапы до MVP и после него, зависимости работ и критерии готовности находятся в [PLAN.md](../PLAN.md).
 
@@ -83,12 +83,18 @@ Catch-up ограничен числом ticks за проход главног
 
 2D и 3D имеют отдельные миры и spatial-типы. Для динамического тела итоговым transform владеет физика; teleport и кинематическое управление — отдельные операции. Физическое тело связано с entity через проверяемый handle. Миры 2D и 3D не сталкиваются автоматически. Внутренние substeps solver настраиваются отдельно от частоты gameplay ticks; начальная настройка — четыре substeps с проверкой на сценах проекта.
 
-Собственный Vulkan 1.3 renderer получает подготовленный snapshot, не обходит изменяемый EnTT registry с render thread. RenderGraph описывает reads/writes ресурсов, порядок проходов, barriers и lifetimes. Первым нужен проверяемый raster-путь 2D/3D без обязательных RT/mesh shaders; GPU-driven visibility и другие передовые механизмы добавляются по измеримым этапам из [плана](../PLAN.md).
+Собственный Vulkan 1.3 renderer получает подготовленный snapshot, не обходит изменяемый EnTT registry с render thread. RenderGraph описывает reads/writes ресурсов, порядок проходов, barriers и lifetimes. MVP создал проверяемый raster-путь 2D/3D без обязательных RT/mesh shaders. P2 добавил выбираемые GPU frustum и GPU occlusion режимы для opaque static meshes; Direct остаётся начальным режимом и эталоном. Scene extraction задаёт устойчивые keys для постоянных объектов; renderer отслеживает generation и консервативные bounds. GPU instance record несёт стабильные slot и generation, а компактный индекс в candidate/visible буферах служит адресом записи только текущего кадра. `DrawItem` может содержать заранее подготовленные LOD meshes. CPU формирует фиксированные совместимые bins, GPU заполняет visible IDs и `instanceCount` для indirect draws. В occlusion-режиме previous HZB даёт предварительное решение, а current HZB и PostCull возвращают объекты, которые открылись в этом кадре. Camera cut, несовместимые view/projection/extent и смена instance generation инвалидируют историю. Тени, прозрачные meshes, спрайты и UI не теряют независимый порядок из-за camera culling. Точная реализованная область и проверка приведены в [P2 acceptance](studies/19-p2-gpu-visibility-acceptance.md).
 
 **Vulkan API вызывается напрямую внутри собственного backend Faset.** Он владеет Vulkan handles, созданием GPU-ресурсов и pipelines, записью команд, синхронизацией и отправкой в очереди. Renderer и RenderGraph используют небольшой внутренний интерфейс ресурсов и команд Faset; Vulkan-типы и вызовы `vk*` не входят в gameplay API или команды редактора. SDL3 обеспечивает окно и создание Vulkan surface, но не заменяет графический backend; Slang отвечает за компиляцию шейдеров. Универсальная абстракция нескольких графических API не является задачей MVP.
 
 Slang компилирует шейдеры в SPIR-V и выдаёт сведения для согласования CPU/GPU данных. Совместимый HLSL проходит выбранный pipeline; поддержка любого существующего HLSL-кода не обещается. Cook учитывает compiler/version, includes, defines и GPU profile. Nanite/Lumen-подобные системы остаются исследовательскими направлениями, не готовыми возможностями MVP.
 
+Граница зависимости проходит через **готовый пакет SPIR-V + нормализованную reflection-метаинформацию Faset**. В текущей реализации CMake требует `slangc` для сборки этого пакета, а `compile_shader.py` преобразует Slang reflection в формат `faset.shader-reflection` с hash и layout fingerprint. Сам Vulkan backend создаёт pipelines из SPIR-V и проверяет этот контракт; он не вызывает Slang во время игры и не линкует его runtime. Однако структура descriptor sets, push constants, входов вершин и соглашение о матрицах сейчас явно согласованы с существующими Slang-шейдерами. Поэтому новый компилятор возможен без переписывания команд Vulkan, если он выдаёт эквивалентный SPIR-V и тот же проверяемый контракт. При появлении второго компилятора отдельным шагом вводится интерфейс shader package producer и тесты эквивалентности ABI; преждевременная абстракция компиляторов в MVP/P2 не нужна.
+
+P2 не требует синхронного чтения GPU-счётчиков для решения видимости: readback включается редакторской диагностикой. Current HZB preview также читается только по запросу. Существующий путь полного framebuffer capture всё ещё ждёт GPU, поэтому измерения полной длительности кадра включают эту стоимость; `gpu_ms` и времена отдельных проходов не заменяют полную CPU/GPU-профилировку. [Первое измерение](studies/20-p2-gpu-visibility-benchmark-2026-09-23.md) обнаружило дорогой MainCull на Linux reference GPU в Debug/validation. [Повтор после оптимизации](studies/21-p2-gpu-visibility-optimization-2026-09-23.md) отдельно измерил эффект device-local выходных буферов и замены CAS-цикла на atomic add: MainCull p50 уменьшился до 0,030–0,042 мс в тех же синтетических сценах. Direct остаётся performance default до проверки Release-сборки и игровых нагрузок. Mesh LOD выбирается среди заранее подготовленных вариантов с hysteresis; генерация LOD, streaming и cluster geometry пока не реализованы. GPU-режимы дополнительно проверяют необходимые limits/formats устройства и не считаются доступными на любом Vulkan 1.3 GPU без такой проверки.
+
+Диагностика различает запрошенный и фактически выполненный visibility mode в каждом кадре. Если GPU culling недоступен, фактический режим Direct; если доступен frustum, но нет подходящего HZB, запрос GPU occlusion явно понижается до GPU frustum. Player записывает оба режима в профиль и сообщает о fallback в stderr, редактор показывает Effective path и факт расхождения с выбранным режимом.
+
 ## 8. Blender и ассеты — принято
 
 Используется **обычный Blender**, без обязательного форка или установленного MCP-плагина. Базовый обмен — **GLB и manifest со стабильными asset/subasset IDs**. Обычный экспорт принимается движком; удобный add-on для публикации, UUID и повторного экспорта остаётся необязательным помощником. Если источник не предоставляет устойчивые subasset IDs, importer не обещает надёжно угадать соответствие после произвольного rename/reparent: сохраняет mapping и показывает конфликты.
@@ -105,11 +111,48 @@ Development и release Player содержат runtime, выбранные иг
 
 Критерии [плана](../PLAN.md) включают цикл сцена → Inspector → MCP authoring edit → Undo → save → build → отдельный Player, повторный импорт GLB с сохранением overrides, lifecycle/handle tests и запуск на обеих ОС без Editor/Blender/MCP/SDK. Выполненные проверки и незакрытые условия перечислены в [журнале реализации](IMPLEMENTATION.md); наличие теста само по себе не означает прохождения на обеих ОС.
 
+## 10. P1 — проверяемая итерация gameplay
+
+Для native-сборки источником истины остаются CMake/Ninja и их dependency graph.
+BuildService сохраняет проверяемую копию `Scripts` по хешу содержимого,
+отделяет Debug от Release и
+запоминает версионированный fingerprint рецепта, исходников, Lua-деклараций,
+toolchain, шейдерных и runtime-входов. Повторное использование schema/package
+разрешено лишь после проверки полного manifest и схемы; испорченная или устаревшая
+генерация не выдаётся за cache hit. Переключение указателя на успешную генерацию
+атомарно; сбой сборки оставляет предыдущую доступной, но Inspector помечает
+метаданные устаревшими. Исходный каталог и копия повторно хешируются после native
+build и перед повторным использованием кэша или публикацией. Это обнаруживает сохранившееся изменение;
+запись и восстановление прежних байтов другим процессом того же пользователя во
+время чтения компилятором не исключены. Экспорт отдельно проверяет asset generations.
+
+Структурированные сообщения компилятора/Lua дополняют сырой лог. Для исходников
+проекта Editor и MCP вызывают один `faset_source_open` с относительным путём и
+позициями; внешний редактор запускается аргументами без shell. Четыре стартовых
+проекта комбинируют C++/Lua и 2D/3D. C++ остаётся rebuild-and-restart, а Lua
+development reload проверяет candidate и перезапускает script/world state, не
+сохраняя произвольное runtime-состояние.
+
+Autosave относится только к именованным dirty сценам Editor после двух секунд
+покоя. Он использует ревизию документа и прежний disk-hash conflict check, не
+перезаписывает внешний файл и не создаёт Undo-операцию. Неназванная сцена требует
+Save As; recovery journal работает независимо от autosave. Статусы видны в UI и
+через Editor MCP. Player и экспортная игра по-прежнему не имеют MCP.
+
+Измерения P1 разделяют Debug-время итераций, offscreen первый кадр и старый
+Release reference baseline точных демо. Исходный отчёт, raw-профили и отдельное
+дополнение о версиях/хешах исполняемых инструментов находятся в
+[датированном dossier](validation/p1-iteration-2026-09-24/README.md). Большая
+синтетическая сцена выявляет стоимость CPU simulation/snapshot; её время нельзя
+переносить на 2D/3D демо или выдавать за обещание кадровой частоты.
+
 ## История решений
 
 - **17.09.2026:** выбраны имя Faset Engine, Linux/Windows desktop 2D/3D, ручная работа и MCP, интеграция с Blender, Box2D и Box3D; подготовлены исследования.
 - **18.09.2026:** принят порядок C++ → Lua, затем EnTT, собственный retained UI, SDL3, Vulkan 1.3/RenderGraph/Slang и CMake/Ninja/Clang.
 - **18.09.2026:** утверждены процессы и linkage, явная metadata registration/schema export, JSON/binary formats, вложенные шаблоны/sparse overrides, lifecycle, фиксированный tick и последовательный scheduler; граница MCP ограничена Editor/headless authoring services.
 - **18.09.2026:** английский принят основным языком интерфейса, диагностик и публичного API; уточнена граница прямых Vulkan-вызовов внутри собственного backend.
+- **23.09.2026:** после принятого MVP выполнен P2 GPU visibility/LOD на Linux reference GPU; direct renderer сохранён как начальный режим и эталон, ограничения и измерения вынесены в отдельный [протокол](studies/19-p2-gpu-visibility-acceptance.md).
+- **24.09.2026:** P1 итерация фиксирует проверяемое повторное использование schema/package, структурированную диагностику, стартовые C++/Lua проекты, безопасный autosave и измерительный протокол без C++ hot reload.
 
 Реализация идёт по [PLAN.md](../PLAN.md). Последующие изменения принятых контрактов фиксируются здесь с причиной и способом проверки.

docs/IMPLEMENTATION.md

@@ -327,9 +327,195 @@ production build, 318 local Markdown links, retained Windows evidence hashes, al
 validation JSON records and `git diff --check`. The engine-source diff from the
 accepted commit is empty; no untested engine changes were bundled into publication.
 
+The post-publication documentation check also verified hashes against Git blobs,
+which normalize Windows JSON line endings to LF. Evidence indices now identify both
+the retained repository bytes and original CRLF artifacts explicitly. This follow-up
+changes only documentation metadata and preserves the first MVP tag and engine code.
+
 Known coverage limits remain: real OS IME composition, movement between physical
 monitors with different scales, native Wayland programmatic restore and additional
 GPU/driver families. Widget composition/DPI, SDL text-input boundaries, XWayland and
 Windows window lifecycle have their own passing evidence. The narrow static-mesh,
 root-level box-physics, one-window/C++ MVP profile remains explicit. Lua and advanced
 graphics are later work. UI references guide appearance; they do not define behavior.
+
+## Post-MVP checkpoint — P2 GPU visibility and prepared mesh LOD
+
+The historical MVP statement above describes the `v0.1.0-mvp` scope. Subsequent
+work added the optional Lua module and the P2 visibility path. The P2 renderer keeps
+`VisibilityMode::Direct` as its default and reference. Scene extraction supplies
+stable per-primitive keys and view metadata. `DrawItem` accepts optional prepared
+coarse meshes. The renderer tracks generation-checked temporal identity and previous
+rendered transforms, derives conservative bounds, and selects a prepared LOD by
+projected size with hysteresis. There is no automatic mesh
+decimator or cluster/streaming geometry system.
+
+For opaque static meshes, `GpuFrustum` groups compatible geometry/material into
+fixed bins and fills indirect instance counts/visible IDs on the GPU. `GpuOcclusion`
+adds previous-frame HZB classification, Main raster, a current forward-Z furthest-depth
+HZB, and Post culling/raster so a newly revealed object can appear in the same final
+frame. History resets on camera cut, changed view/extent/projection, and incompatible
+instance identity. Shadow casters, transparent meshes, sprites and UI remain on their
+independent paths; they are not hidden by the camera's opaque HZB. The GPU modes are
+lazy-initialized and require the checked Vulkan capabilities and shader bundle.
+Shader reload rebuilds both direct and GPU scene pipelines, preserving the working
+pipelines on failure.
+
+The Editor's ImGui diagnostics can select Direct, GPU frustum or GPU occlusion,
+inspect pass timings/counters and request a current-HZB preview. A Player run can
+choose `--visibility direct|gpu-frustum|gpu-occlusion`; Direct remains its default.
+The profile records the requested mode and per-frame `gpu_visibility_active` so a
+silent fallback is not mistaken for measured GPU work. The Release Player CLI test
+checks all three modes and rejects an invalid value. Counter and HZB readback are
+opt-in diagnostics; the visibility decision itself stays on the GPU.
+The existing framebuffer capture still waits for completion and reads back each
+frame. Consequently, full-frame benchmark times include that path and must not be
+presented as isolated culling costs.
+
+At renderer checkpoint `ae537c0`, the Linux reference build's full CTest suite
+reported 57 registered tests, zero failures and one existing native-window lifecycle
+skip. Fifteen offscreen P2 acceptance cases passed with Vulkan validation active and
+zero reported errors, including capacity boundaries, door reveal, camera changes,
+multi-view history, LOD hysteresis, shadow independence and transparency. Shader
+reflection/export and GPU shader reload have focused tests. The
+[P2 acceptance protocol](studies/19-p2-gpu-visibility-acceptance.md) contains the
+command, tolerance and scene definitions. The
+[initial three-run benchmark report](studies/20-p2-gpu-visibility-benchmark-2026-09-23.md)
+retains all 810 raw frame records, device/build details, p50/p95 values and limits.
+At that pre-optimization checkpoint, GPU `MainCull` took about 3.9–18.2 ms p50 in
+three synthetic Debug/validation scenes, far above the direct path's 0.24–0.50 ms
+whole-GPU p50. This was an actionable regression, not the final P2 performance.
+
+Optimization checkpoint `3be3d0d` moves GPU-written indirect arguments, visible IDs
+and deferred buffers into device-local memory, uses staging copies for initialization
+and optional diagnostics, and replaces contended CAS loops with bounded atomic add.
+The [three-variant follow-up](studies/21-p2-gpu-visibility-optimization-2026-09-23.md)
+isolates memory placement and then the shader change. With the same Debug/validation
+scenes, `MainCull` p50 fell to 0.030–0.042 ms. Full GPU-command p50 for the open
+GPU-frustum scene was 0.139 ms versus 0.498 ms direct; the occluded GPU-occlusion
+scene was 0.188 ms versus 0.496 ms direct. All 2,430 sampled frames across variants
+reported zero Vulkan validation errors; the final focused suite passed 18/18 and
+both culling shaders passed `spirv-val`. These synthetic results do not establish
+a shipping-frame speedup, especially on another device or game scene. These checks
+establish the tested Linux configuration; they do not
+establish P2 behavior on a physical Windows GPU or a broad driver matrix. The
+[profiling manual](manual/editor/profiling.md) explains how to interpret the timings.
+
+The independent Linux Release build completed all targets, including the prepared
+LOD example. Its full CTest run reported 57 registered tests, zero failures and
+one existing native-window lifecycle skip. The focused Release Player CLI test
+selected all three visibility modes, verified active GPU status in the profile,
+and rejected an invalid mode. Release build/test success establishes functional
+coverage; at that checkpoint, Windows P2 was still unverified.
+
+As an additional Linux software-Vulkan check, Lavapipe ran all 15 labelled P2
+acceptance cases plus the standalone GPU visibility test and both example modes.
+The GPU route was active and Vulkan validation reported zero errors. This adds a
+second implementation for functional checks; Lavapipe timings are not physical-GPU
+performance evidence.
+
+The [P2 Linux evidence dossier](validation/p2-gpu-visibility-2026-09-23/README.md)
+retains the exact Release builds, labelled GPU cases and relocated standalone Player
+checks. Both sample games passed a fresh Release export, Unicode relocation away
+from the SDK and 120 headless frames with validation and zero errors. Their packages
+also ran six frames in each GPU visibility mode with an active GPU path and zero
+validation errors. The 2D Direct/GPU captures matched pixel-for-pixel. The 3D GPU
+modes matched each other; each differed from Direct at 7 of 921,600 raster-edge
+pixels, with no missing geometry. Direct CPU vertex transformation and GPU shader
+vertex transformation round differently at subpixel triangle boundaries. The
+Debug benchmarks above and this Release functional record have different purposes;
+neither establishes physical Windows GPU coverage.
+
+Compatibility checkpoint `433bce0` followed the first red Windows P2 CI run. The
+pinned SwiftShader device does not expose `shaderDrawParameters`; the Slang
+`SV_InstanceID` builtin had emitted a SPIR-V `DrawParameters` capability, so the
+renderer rejected the GPU route. Both GPU vertex entries now use raw
+`SV_VulkanInstanceID` while their fixed indirect commands keep `firstInstance = 0`.
+The renderer no longer requests that optional feature. The GPU smoke case now has
+the `gpu;p2` CTest labels, so CPU-only native checks exclude it. A reflection test
+rejects `DrawParameters` in the two generated vertex modules. On matching Linux
+SwiftShader, all 16 P2 cases passed with the GPU path active; a deliberately
+driverless CPU-only selection passed 26/26.
+
+At this revision, [Windows graphics CI](https://github.com/emil28092005/Faset_Engine/actions/runs/35918597688)
+passed all 58 tests on pinned SwiftShader, including the P2 route and Windows
+window/editor tests. Its two relocated Release example games each rendered 120
+frames in the default Direct mode. [Native/manual CI](https://github.com/emil28092005/Faset_Engine/actions/runs/35918597686)
+also passed. The [SwiftShader compatibility dossier](validation/p2-swiftshader-2026-09-23/README.md)
+records the cause, local commands, CI run and export report. Windows did not have
+the Khronos validation layer, and no physical Windows GPU or driver-family
+performance claim follows from this software-Vulkan result.
+
+Independent P2 source review then found two contract gaps. Requested GPU occlusion
+could silently run GPU frustum when HZB was unavailable, and stable instance
+slot/generation lived only in the CPU tracker while GPU candidates used dense
+frame-local indices. Follow-up `22012c1` records the requested and effective
+visibility mode per frame in renderer statistics, Player profiles/output and
+Editor diagnostics, with a CPU capability-policy regression. GPU instance records
+now carry stable slot and all 64 generation bits in previously reserved metadata;
+dense indices remain addresses into the current frame's instance buffer. A focused
+reorder/replacement/anonymous-instance test covers the metadata packing. The
+reviewer rechecked both fixes and found no remaining load-bearing issue in those
+paths. On this revision, full Linux Debug and Release CTest each reported 57
+registered tests, zero failures and one existing native-window lifecycle skip. The dedicated ImGui overlay test passed
+1/1; pinned Linux SwiftShader passed all 16 P2 cases and Player diagnostics; a
+driverless CPU-only Release selection passed 26/26. The final
+[Windows graphics CI run](https://github.com/emil28092005/Faset_Engine/actions/runs/35922643226)
+passed all 58 tests without skips on SwiftShader; both relocated Release games
+rendered 120 frames in Direct mode. The corresponding
+[native/manual CI run](https://github.com/emil28092005/Faset_Engine/actions/runs/35922643004)
+passed on Linux and Windows. Unsupported-HZB integration and physical Windows
+GPU coverage remain untested.
+
+## Post-MVP checkpoint — P1 gameplay iteration
+
+P1 adds a complete-input native build stamp and a content-addressed `Scripts` copy.
+The package key binds configuration, recipe, source, Lua declaration, toolchain,
+shader and runtime artifacts. A second unchanged build reuses a verified schema
+and package generation without invoking SchemaExporter; CMake/Ninja still verify
+the native graph. Malformed/corrupt generations, modified headers/tools and
+detected source mismatches cannot publish a false hit. The live tree and staged
+copy are rehashed after native build and before reuse/publication; a same-user
+write-and-restore during compiler reads remains outside this check. Failed jobs
+preserve the previous successful pointer, while Inspector metadata becomes stale.
+
+Compiler and Lua output now produce bounded structured Console diagnostics with
+raw logs retained. Source opening accepts only project `Scripts` files and passes
+literal file/line/column arguments to the configured external editor. A real
+compile failure revealed that compiler paths pointed to the staged copy;
+`d7a7a7c` maps only the verified snapshot subtree back to project-relative
+source. The same correction retains a later actionable error after 250 unrelated
+warnings. Four runnable C++/Lua × 2D/3D starters are available in launcher and
+CLI; the existing scaffold default remains compatible. Named dirty scenes
+autosave after two idle seconds by default; unnamed scenes require Save As, and
+disk/revision conflicts retain the journal and never overwrite external edits.
+
+The [P1 dated dossier](validation/p1-iteration-2026-09-24/README.md) retains a
+clean-revision `6c2e8fa` Debug workflow with every raw command/profile. On the
+Ryzen 7 1700/RTX 2080 Ti Linux host, five unchanged builds had median 11.53 s,
+five changed-C++ builds 28.16 s, five changed-header builds 23.89 s, and five
+watched Lua reloads 0.502 s. All five unchanged builds reported a verified
+generation reuse. The 3,000-frame profile showed no growth in the explicit
+Vulkan allocation counter (15,787,008 bytes). A seeded 527-object synthetic
+scene reached 149.39 ms p95 wall time, dominated by CPU simulation/snapshot;
+this is a visible scalability issue, not a tiny-demo Release budget comparison.
+The historical exact-scene Release budgets were met in the earlier 2026-09-18
+record, but that evolving working-tree baseline does not certify the current
+revision. A quiet-host current Release rerun is pending.
+
+Linux focused cache, diagnostics, schema and workflow-math tests pass; a real
+failed-build replay now reports navigable `Scripts/Gameplay.cpp:73:2`. The
+[Lua-only Release result](validation/lua-release-2026-09-24/README.md) validated
+and rendered after source-hidden relocation on the physical Linux GPU. At
+`6c2e8fa`, [native/manual CI](https://github.com/emil28092005/Faset_Engine/actions/runs/35936310287)
+passed on Linux and Windows. Its Windows graphics job passed all 61 CTests on
+SwiftShader, then hit an invalid integration fixture under the engine checkout;
+`4ac02ee` moved the fixture to runner temporary storage. The subsequent
+[Windows graphics run](https://github.com/emil28092005/Faset_Engine/actions/runs/35937433040)
+passed all 61 CTests and the real export integration. Two C++ and one Lua-only
+Release package validated and rendered 120 frames each after relocation with
+source paths unavailable; the [raw Windows report](validation/p1-iteration-2026-09-24/windows-4ac02ee/playable-report.json)
+records hashes and software Vulkan device identity. The later `d7a7a7c`
+real-diagnostic-navigation assertion still awaits its Windows CI result.
+Windows had no active Khronos validation layer, and no physical Windows GPU
+performance result is claimed.

docs/design/README.md

@@ -0,0 +1,17 @@
+# P1 editor visual references
+
+These image prototypes were generated from the recorded native editor screenshot in
+`docs/validation/checkpoint5-linux-2026-09-18/editor-blender.png` before changing the
+P1 interface. They are visual references for the existing compact dark treatment,
+not specifications of behavior, layout measurements, copy, or platform paths.
+
+- `p1-iteration-console-reference.png` explores structured build diagnostics,
+  source navigation, a cache indicator, and autosave status in the existing editor.
+- `p1-project-template-reference.png` explores a compact 2D/3D and C++/Lua project
+  chooser. Its example Windows path is illustrative; the implementation must use
+  native paths on Linux and Windows.
+
+Both were created with the built-in image generation tool using the cited screenshot
+as the edit reference. The accepted behavior and validation criteria are in the
+[P1 design](../superpowers/specs/2026-09-24-p1-iteration-design.md) and
+[`PLAN.md`](../../PLAN.md).

docs/licenses/Lua.txt

@@ -0,0 +1,23 @@
+Lua 5.4.9 — MIT License
+https://www.lua.org/license.html
+
+Copyright (C) 1994-2026 Lua.org, PUC-Rio.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

docs/manual/editor/diagnostics.md

@@ -1,5 +1,28 @@
 # Developer diagnostics
 
+## Build errors and source navigation
+
+Build and export jobs report compiler, clang-cl/MSVC, and Lua errors as structured
+Console rows. Each row shows severity, message, and a one-based source location.
+Choose **Open source** to open a file under the current project's `Scripts/`
+directory at that line and column. Diagnostics from engine or external files remain
+visible but have no source action. The **Jobs** tab shows whether a verified build
+generation was reused, the elapsed phases, and an expandable raw process log;
+**Copy full log** retains the complete available output for troubleshooting.
+
+The same action is available over Editor MCP:
+
+```json
+{"command":"faset_source_open","arguments":{"path":"Scripts/Gameplay.cpp","line":17,"column":4}}
+```
+
+`faset_script_open` remains Lua-only. Both commands use the project's optional
+`editor.script_editor` argv array, or Zed by default. The tokens `{file}`,
+`{line}`, `{column}`, and `{project}` may appear within one argument, for
+example `["zed", "{file}:{line}:{column}"]`. Faset passes each argument
+literally to the editor process without shell expansion. An invalid editor
+command produces a source-editor error without changing the build result.
+
 The optional Dear ImGui overlay shows renderer counters inside the Editor. The Editor's normal interface remains the retained Faset UI. Enable the diagnostic build explicitly:
 
 ```sh
@@ -10,7 +33,11 @@ build/linux-debug/faset_editor --project examples/projects/collect-3d --gui
 
 On Windows, use `windows-debug` for both presets and `build/windows-debug/faset_editor.exe`. Press **F12** to show or hide the panel. Drag its title bar to move it; **Freeze counters** holds a completed-frame sample for inspection. Closing the panel does not stop rendering. Pointer gestures inside the overlay are kept out of the authoring UI.
 
-The panel reports the previous completed frame: renderer wall time, GPU timestamp time where available, synchronous readback time, draw calls, packed vertices, culled meshes, textures, explicit Vulkan allocation sizes, actual validation availability/errors, and GPU pass-label count. Renderer wall time includes waiting for GPU work; it is not thread CPU usage. Memory excludes driver-internal allocations. The overlay itself adds drawing work, so hide it for a baseline performance measurement.
+Use the **Visibility** selector to compare **Direct**, **GPU frustum**, and **GPU occlusion** on the same open scene. This is a live renderer setting for the Editor viewport; it does not change the scene or exported game. The selected mode is independent of **Freeze counters**. The counters describe the previous completed frame, so render one more frame after changing modes before reading them. **Effective path** names the algorithm that actually ran. A **Fallback from** line appears when device or target capabilities prevent the selected mode; for example, GPU occlusion may use GPU frustum if HZB is unavailable.
+
+The panel reports the previous completed frame: renderer wall time, GPU timestamp time where available, synchronous readback time, draw calls, packed vertices, culled meshes, textures, explicit Vulkan allocation sizes, actual validation availability/errors, and GPU pass-label count. It also shows whether GPU visibility ran, submitted indirect bins, visible instances, frustum rejects, deferred and post-pass visible instances, HZB history validity, counts per prepared LOD level, and GPU pass timings where available. GPU counts are explicitly marked unavailable until the first frame rendered with diagnostics open; only a displayed zero is a measured zero. **Previous HZB history: invalid** is expected after a camera cut or resize until compatible depth history is available. A current HZB preview can still exist after that first frame because it was built from the current depth. Renderer wall time includes waiting for GPU work; it is not thread CPU usage. Memory excludes driver-internal allocations. The overlay itself adds drawing work, so hide it for a baseline performance measurement.
+
+In **GPU occlusion** mode, enable **Show HZB** to inspect the current grayscale depth pyramid. The **Mip** slider selects a pyramid level; the preview starts at mip 3 to keep its readback small. A larger mip number shows coarser depth. The preview reads the HZB only while the panel and toggle are open, and only once per completed frame or mip change. Switching it off or closing the panel releases the preview; its GPU texture retires when the next frame begins. Opening diagnostics also enables readback of GPU visibility counters, which is disabled again when the panel closes. Disable the HZB preview for performance comparisons: its diagnostic copy and texture upload add GPU and CPU work. **Freeze counters** does not freeze the HZB image.
 
 The Vulkan backend emits `VK_EXT_debug_utils` labels for `ShadowMap`, `ForwardAndUI`, `Readback`, and, when presenting, `Presentation`. A graphics capture tool that supports this extension can identify those command-buffer regions. Labels remain available without the Khronos validation layer when the extension is exposed; unsupported systems continue rendering and report labels unavailable. A submitted-label count confirms calls were emitted, not that an external capture tool was tested.
 

docs/manual/editor/export.md

@@ -9,8 +9,10 @@ Player process. **Stop** leaves the authoring document unchanged.
 
 1. Edit `Scripts/Gameplay.cpp` and its explicit schema declarations.
 2. Stop the running Player.
-3. Choose **Build C++**. The compiler and SchemaExporter run outside the Editor.
-4. Read compiler errors in the Console. A failed build retains the previous schema
+3. Choose **Build**. CMake/Ninja build native gameplay and the separate
+   SchemaExporter refreshes the Inspector schema when inputs changed.
+4. Read compiler errors in the Console. Select a project-source diagnostic to open
+   its line in your external editor. A failed build retains the previous schema
    and binary; the schema status reports that it is stale.
 5. After a successful build, edit the behavior's exposed fields in the Inspector.
 6. Choose **Play**. It builds if necessary and launches the captured scene.
@@ -23,6 +25,22 @@ The Player supports pause and single-step. Editor controls use a private session
 control file; they do not expose runtime entity queries through MCP. Closing the
 Player is observed by the Editor, which keeps its logs and authoring state.
 
+An unchanged second build still asks CMake/Ninja to verify their dependency graph.
+When the native outputs, gameplay sources, toolchain, shaders and runtime inputs
+match the validated package, **Jobs** reports `schema_cache_hit` and
+`generation_reused` as true and returns the same verified generation without a
+second SchemaExporter run or package copy. A changed `.cpp`, header, Lua declaration,
+build recipe or relevant tool invalidates that reuse. A damaged cached package is
+not treated as a hit. The job also exposes elapsed phases and a build fingerprint;
+see [Developer diagnostics](diagnostics.md) for structured errors and raw logs.
+
+If a build fails, correct the listed source and build again. The prior playable
+generation remains available, but stale Inspector metadata is not evidence that
+the failed edit built successfully. Save the scene separately: named dirty scenes
+autosave after two idle seconds by default, while an unnamed scene needs **Save As**.
+External file changes produce a visible conflict instead of an overwrite; the
+[workspace guide](workspace.md#create-and-save-a-scene) explains recovery.
+
 ## Export a standalone game
 
 Use **Export** in the Editor for the current scene. Resolve template conflicts and
@@ -46,9 +64,10 @@ Development builds use **Debug**. Exports default to **Release** and use a separ
 CMake cache. The BuildService API also accepts `RelWithDebInfo` for exports. Exporting
 does not change the configuration of your development Player.
 
-Each successful export creates an immutable directory under
+Each successful export creates a versioned directory under
 `Exports/MyGame/generations/<generation>`. `current.json` points to the active
-generation. Distribute the **whole generation directory**, not just the executable.
+generation. The Editor leaves published generations untouched. Distribute the
+**whole generation directory**, not just the executable.
 If building, cooking or verification fails, the previous pointer and package remain
 available. Cancelling a job does not delete earlier exports.
 

docs/manual/editor/mcp.md

@@ -67,6 +67,20 @@ resume and single-step process controls; it cannot read or modify game entities.
 scenes that have never been saved. Restoring an already open document requires its
 current revision. Recovery refuses to overwrite an externally changed scene file.
 
+Long-lived headless and graphical Editor sessions also poll the same autosave
+controller. With `editor.autosave` enabled (the default), a named dirty scene is
+saved after two seconds idle. `faset_autosave_status {}` reports `enabled` and each
+open document's `state`, `revision`, `path`, and `error`. States include `saved`,
+`pending`, `saving`, `conflict`, `failed`, `save_as_required`, and `disabled`.
+An unnamed scene remains in recovery until you give it an explicit path. An
+external disk edit produces `conflict` without overwriting that edit. For scripted
+workflows, use `faset_document_save` with `expected_revision` when you need a
+definite save boundary instead of waiting for idle autosave. If a conflict occurs,
+save to a new project-relative path and compare the two files. Change the
+preference through `faset_project_settings_get` and `faset_project_settings_set`
+with the returned project revision and `{"editor":{"autosave":false}}`; the
+new value applies to the current session and persists for the next Editor launch.
+
 ## Single-command CLI
 
 The CLI is useful for scripts that do not need an MCP session:

docs/manual/editor/profiling.md

@@ -39,39 +39,121 @@ Use `--debug-physics` or press **F3** to show current physics box colliders. Deb
 geometry increases draw count, so record whether it was enabled. The collider view
 uses simulation poses; normal visuals can use interpolated poses.
 
-## Measure Editor and C++ workflows
+## Measure Editor, C++ and Lua iteration
 
 From the engine repository:
 
 ```sh
+cmake --build --preset linux-debug --target faset_editor faset_editor_ui_latency --parallel 2
 python3 tools/measure_workflows.py \
   --editor build/linux-debug/faset_editor \
   --project examples/projects/collect-3d \
-  --output .cache/my-workflow-measurement
+  --output /tmp/faset-workflow-measurement
 ```
 
-Use a new output directory. The tool copies the project, preserving your original,
-and records command startup, two-frame GUI startup/shutdown, first/cached Blender
-bundle import, initial/no-change/changed Debug builds and a subsequent Player frame.
-It checks that editing gameplay makes the schema stale and successful building
-clears that state. The initial build uses available dependency archives and OS
-caches; it is not a measurement of internet download speed.
+The UI probe must be built beside the Editor first. The default Lua input is
+`examples/lua`; use `--lua-project` to select another declared Lua project and
+`--ui-latency-binary` when the probe is elsewhere. Use a **new** output directory;
+the tool refuses to overwrite evidence. It copies both projects and never edits
+the checked-in examples.
+
+`report.json` version 2 separates the initial cold project configure/build,
+unchanged builds, changed `.cpp` builds, changed-header builds, deliberate compile
+failure/recovery, Lua edit-to-reload, first offscreen Player frame and synthetic
+Editor input-to-visible-state. Each warm/changed case has one warm-up and five
+measured repetitions. Each sample remains in `raw/` with command, stdout/stderr,
+duration and, on Linux, peak RSS; the report includes median and nearest-rank p95.
+The file hashes identify every changed source variant. Five unchanged builds must
+return a verified schema/package cache hit. The cold case begins with empty project
+`.faset` caches, **not** a cold OS file cache, newly downloaded dependencies or a
+fresh engine toolchain. It is a development `Debug` workflow.
+
+The first-frame value comes from the Player's `main_to_first_frame` profile after
+five one-frame offscreen runs. It excludes OS process loading and says nothing about
+window presentation latency. The separate UI probe applies keyboard input through
+the retained Editor UI, then measures 100 post-warm-up offscreen frames; it is not
+native desktop input-to-photon latency. A watched Lua Player records five
+edit-to-successful-reload times, including its polling and log notification. A
+3,000-frame Player profile compares explicit Vulkan allocation and texture maxima
+in frames 101–200 with frames 2901–3000. Zero growth over that interval is useful
+but does not prove the absence of all leaks. The tool also adds 512 deterministic
+objects to a disposable scene and profiles 240 frames; this stresses scene
+simulation/snapshot work, not representative game content.
 
 On Linux, GNU `time` records peak RSS for each command and its waited-for children.
 This is a maximum, not the sum of simultaneous compiler processes. Other platforms
-report this field as null unless equivalent measurement support is added. The tool
-keeps raw stdout/stderr, durations, hardware and revision information alongside its
-report. A dirty source checkout is explicitly identified.
+report this field as null unless equivalent measurement support is added. The report
+keeps raw stdout/stderr, profiles, hardware, driver, build setting, source hashes,
+Git revision and dirty-tree state. New runs also hash the exact CMake, Ninja, C/C++
+compiler, Slang, Editor and UI-probe binaries selected by the disposable project's
+`CMakeCache.txt`. Compare profiles only with the same scene, configuration,
+resolution, validation/readback settings and hardware class. The
+[dated P1 workflow record](https://github.com/emil28092005/Faset_Engine/blob/main/docs/validation/p1-iteration-2026-09-24/README.md)
+retains a successful Debug run and its exact raw files. Its post-run binary
+provenance supplement is explicitly separate from the original report.
 
 `tools/verify_playable_exports.py` separately verifies the two sample games in
 relocated Release packages and records their Player profiles. Its assertions test
 correct execution, not a frame-time threshold.
 
+## Compare P2 GPU visibility modes
+
+The Editor diagnostics panel (**F12**) can switch its current viewport between
+**Direct**, **GPU frustum**, and **GPU occlusion**. Direct is the default reference.
+The selector is an Editor viewport setting; it does not change the saved scene or
+automatically change an exported Player. An exported Player can select a mode for a
+bounded run:
+
+```sh
+./faset_player --headless --frames 240 --profile gpu-frustum.json --visibility gpu-frustum
+```
+
+Accepted values are `direct`, `gpu-frustum`, and `gpu-occlusion`; Direct is the
+default. The profile records the requested `visibility_mode`, the run's and each
+frame's `effective_visibility_mode`, and each frame's `gpu_visibility_active` state.
+Compare requested and effective modes before interpreting a GPU run: a missing GPU
+profile falls back to Direct, while missing HZB can reduce GPU occlusion to GPU
+frustum. The Editor shows the **Effective path** and any **Fallback from** line. See
+[Diagnostics](diagnostics.md) for the counters and HZB preview.
+
+For a repeatable offscreen comparison, build and run the P2 benchmark harness:
+
+```sh
+build/linux-debug/faset_render_gpu_acceptance_tests --benchmark /tmp/faset-p2.csv
+```
+
+It records 10 warm-up and 30 measured frames for Direct, GPU frustum and GPU
+occlusion in fixed frustum-heavy, open and occluded scenes. Run it three times and
+compare median/p95 by scene and mode. Keep the raw CSV, hardware/driver, resolution,
+shader bundle, validation state and source revision with any published result. The
+[P2 acceptance protocol](https://github.com/emil28092005/Faset_Engine/blob/main/docs/studies/19-p2-gpu-visibility-acceptance.md)
+documents the scenes and CSV columns. The
+[first measured report](https://github.com/emil28092005/Faset_Engine/blob/main/docs/studies/20-p2-gpu-visibility-benchmark-2026-09-23.md)
+is a **pre-optimization baseline**: its Debug/validation profile found GPU MainCull
+substantially more expensive than direct GPU work. The
+[optimized follow-up](https://github.com/emil28092005/Faset_Engine/blob/main/docs/studies/21-p2-gpu-visibility-optimization-2026-09-23.md)
+retains three additional raw runs and isolates the effects of device-local output
+buffers and bounded atomic append. MainCull p50 fell to 0.030–0.042 ms in those
+synthetic scenes. That comparison is useful for diagnosis, not a guarantee that
+GPU visibility speeds up a particular game or device.
+
+The harness enables GPU visibility counters, so diagnostic readback is part of its
+timings. In the Editor, opening diagnostics likewise enables these counters, and
+**Show HZB** adds an on-demand image copy and preview upload. Close the panel and
+disable the HZB preview for ordinary gameplay timing. GPU pass timestamps separate
+MainCull, MainRaster, HZB, PostCull and PostRaster when supported; they are not a
+measure of CPU extraction/upload. The renderer still waits for frame completion
+and reads back the full image, so `cpu_ms` is wall time including waits, not CPU
+utilization. An open scene can run slower with HZB; visibility correctness and
+full-frame speed are separate findings.
+
 ## Current performance scope
 
-The MVP renderer is intentionally conservative: direct draws, CPU culling, one
-graphics queue and synchronous capture/readback. Use the measurements to find the
-next bottleneck before introducing parallel jobs or GPU-driven rendering. Neither
-an offscreen capture benchmark nor a tiny demo is a promise of a production frame
-budget. Observed measurements and follow-up targets belong in the implementation
-acceptance report with their source revision and method.
+The accepted MVP path uses direct draws and CPU culling; P2 adds optional GPU
+visibility for opaque static meshes, with prepared LODs supplied by the project.
+Both paths currently use one graphics queue and synchronous full-image
+capture/readback. Use measurements to find the next bottleneck before introducing
+parallel jobs or expanding GPU-driven rendering. Neither an offscreen capture
+benchmark nor a tiny demo is a promise of a production frame budget. Observed
+measurements and follow-up targets belong in the implementation acceptance report
+with their source revision and method.

docs/manual/editor/visibility-lod.md

@@ -0,0 +1,90 @@
+# GPU visibility and prepared mesh LOD
+
+Faset can draw opaque static triangle meshes through GPU frustum culling and,
+optionally, two-pass HZB occlusion. The original direct renderer remains available
+for comparison. In the Editor, build with `FASET_DEBUG_IMGUI=ON`, press **F12**,
+and choose **Direct**, **GPU frustum**, or **GPU occlusion** in Diagnostics. **Path:
+active** confirms that the selected GPU path actually ran. See
+[developer diagnostics](diagnostics.md) for the HZB preview and counters.
+
+The current GPU path groups instances with the same mesh and texture into fixed
+indirect draw bins. A previous-frame HZB can defer an object, but the current-frame
+post pass checks it again before the final image. Sprites, editor UI, transparent
+meshes, and shadow casters keep their existing ordered or shadow paths. This option
+does not require ray tracing or mesh shaders.
+
+## Supply prepared LODs from C++
+
+`DrawItem::mesh` is LOD 0. Set `lod_meshes[0]` to a prepared LOD 1 mesh,
+`lod_meshes[1]` to LOD 2, and so on. These are actual `Mesh` objects with a
+complete triangle list; Faset does not simplify a source mesh automatically.
+Keep a stable `instance_key` across frames. Give different scene objects different
+keys, and retain the same shared mesh objects instead of rebuilding them every
+frame. For a manually constructed `Snapshot`, supply both `projection` and
+`view_projection`; set `view_id` for each camera and `camera_cut` when switching
+shots. The Player's scene extraction fills the camera fields and instance keys.
+
+```cpp
+faset::render::DrawItem draw;
+draw.mesh = prepared_high_detail;
+draw.lod_meshes = {prepared_medium_detail, prepared_low_detail};
+draw.instance_key = "scene/object-id/primitive-id";
+draw.model = faset::render::transform({0, 0, 0});
+snapshot.draws.push_back(std::move(draw));
+```
+
+LOD selection uses projected screen size. The first transition is 192 pixels;
+each additional level halves that threshold. A 12% hysteresis band avoids
+switching back and forth near a boundary. Missing levels fall back to an available
+mesh. Changing level invalidates that instance's temporal occlusion state while
+preserving its logical key. `FrameStats::lod_counts` reports selected levels 0–3
+(higher levels are included in the final bucket).
+
+For a runnable C++ example, build `faset_p2_visibility_example` and capture the
+same scene in any mode:
+
+```sh
+cmake --build --preset linux-debug --target faset_p2_visibility_example
+build/linux-debug/faset_p2_visibility_example occlusion /tmp/p2-visibility.ppm
+build/linux-debug/faset_p2_visibility_example direct /tmp/p2-direct.ppm
+```
+
+The example creates a fine cube and a prepared coarse tetrahedron in
+[`examples/renderer/p2_visibility.cpp`](https://github.com/emil28092005/Faset_Engine/blob/main/examples/renderer/p2_visibility.cpp).
+Its near object selects LOD 0 and the eight smaller objects select LOD 1;
+the program prints those counts and reports Vulkan validation errors.
+Imported GLB geometry can be supplied as prepared levels by C++ integration,
+but automatic LOD generation and assigning a GLB's alternate meshes as LODs in
+the Inspector are not implemented yet.
+
+## Measure before choosing a mode
+
+The GPU route saves per-instance CPU vertex transformation and direct draw
+submission, but its compute passes and indirect rendering have a cost. Keep the
+same scene, resolution and camera path when comparing modes. Hide Diagnostics for
+an ordinary Player measurement: opening it enables GPU counter readback, while
+**Show HZB** adds a separate image copy. The renderer currently captures and
+waits for every frame even without this overlay. Read
+[profiling and measurements](profiling.md) and the
+[P2 acceptance study](https://github.com/emil28092005/Faset_Engine/blob/main/docs/studies/19-p2-gpu-visibility-acceptance.md)
+for the measured scope and limitations.
+
+## Select a mode in the Player
+
+The exported Player uses Direct by default. Choose a GPU mode for one run with
+`--visibility`; the same option works for a development Player and a relocated
+standalone game:
+
+```sh
+./faset_player --visibility gpu-frustum
+./faset_player --visibility gpu-occlusion --headless --frames 120 \
+  --profile visibility-profile.json
+```
+
+Accepted values are `direct`, `gpu-frustum`, and `gpu-occlusion`. The profile
+records the requested `visibility_mode` and each frame's
+`gpu_visibility_active` status. If the device lacks the GPU path, the Player
+reports a Direct fallback; selecting a mode alone does not prove that it ran.
+The Editor's Diagnostics selector changes only its viewport and does not save a
+Player setting. An exported game contains the P2 shader bundle and does not need
+the Slang compiler at runtime.

docs/manual/editor/workspace.md

@@ -14,7 +14,8 @@ process; stopping it leaves the authoring scene unchanged.
 Launch `faset_editor` without arguments to open the project launcher.
 
 1. Choose **Create project**, enter a name and a new or empty project directory,
-   then select **2D** or **3D** for the initial scene.
+   then select **C++** or **Lua** and **2D** or **3D**. Each combination creates a
+   runnable start scene and a small behavior for that language.
 2. Choose **Create project** to create the project files and open the Editor.
 3. To return later, choose **Open project**, select its directory with **Browse**,
    and confirm **Open project**. The directory must contain `project.faset.json`.
@@ -33,6 +34,12 @@ was launched in MCP mode so the connection keeps a single project context.
 
 For a direct launch, use `faset_editor --project /path/to/MyGame` on Linux or
 `faset_editor.exe --project C:\Projects\MyGame` on Windows.
+For scripted project creation, pass `--new MyGame --dimension 2|3
+--language cpp|lua` with `--project` pointing to the new directory. Omitting
+`--language` retains the earlier C++ scaffold without a runnable start scene;
+select a language explicitly for a complete starter.
+The [C++ first behavior](../scripting/first-behavior.md) and
+[Lua gameplay](../scripting/lua.md) guides show the first editing steps.
 
 ## Create and save a scene
 
@@ -50,6 +57,19 @@ outside the Editor, ordinary Save reports a conflict instead of overwriting it.
 Save your in-memory work to a new path and compare the two versions before replacing
 anything.
 
+Autosave is enabled by default. After a named scene has been idle for two seconds,
+the Editor saves its current revision to that scene file. The status bar shows
+**Pending autosave**, **Saving**, or **Saved**. An unnamed scene shows **Save As
+required** until you choose its path. The status bar's **Save As...** action opens
+an editable, new project-relative path; it never overwrites the conflicting file.
+
+If the disk file changes outside Faset, autosave stops for that revision and shows
+**Save conflict**. Use **Save As...** to keep both versions, then compare or reload
+the original. **Save failed** preserves the unsaved scene in the recovery journal;
+correct the write error or use Save As. Autosave does not clear Undo history or
+replace the [recovery journal](#recover-unsaved-work). Recovery still protects
+unnamed scenes and edits before the idle deadline.
+
 ## Navigate and transform
 
 - **Right drag:** orbit the 3D view; pan in a 2D scene.
@@ -97,15 +117,16 @@ Read the fresh value and retry; the stale edit does not silently replace the new
 
 ## Refresh C++ metadata
 
-**Build C++ !** and the status message indicate stale gameplay metadata, for example
-after changing gameplay sources or after a failed build. Choose **Build C++**, then
-check **Jobs** and **Console**. A successful build and schema export refresh the
-Inspector. A failed build retains the previous metadata and reports the failure.
+The status message indicates stale gameplay metadata, for example after changing
+gameplay sources or after a failed build. Hover over **Build** for details, then
+choose **Build** and check **Jobs** and **Console**. A successful build and schema
+export refresh the Inspector. A failed build retains the previous metadata and
+reports the failure.
 
 A missing schema or unsupported component version appears as read-only raw fields
 with **Copy raw fields**. Restore a missing module to make its schema available.
 For an older component, declare [data migration rules](../scripting/api.md#editor-data-migrations),
-choose **Build C++**, then **Migrate to v…** in the Inspector. This is one undoable
+choose **Build**, then **Migrate to v…** in the Inspector. This is one undoable
 authoring edit; save explicitly afterward. Inherited components show **Open source
 to migrate** instead. Top-level local additions migrate in their owning instance.
 Missing rules or conversion errors preserve the data and appear in Console.
@@ -118,13 +139,16 @@ for the C++ iteration loop.
 ## Project settings
 
 Open **File → Project settings** to change the project name, initial **2D / 3D** type,
-and start-scene path. Save a scene first, then choose it from the saved-scene list or
-enter its project-relative path. Choose **Save project** to update
-`project.faset.json` explicitly. A missing start scene is rejected and the dialog
-stays open.
+start-scene path, or **Autosave named scenes** preference. Save a scene first, then
+choose it from the saved-scene list or enter its project-relative path. Choose
+**Save project** to update `project.faset.json` explicitly. A missing start scene is
+rejected and the dialog stays open. The Autosave preference applies immediately;
+when disabled, the status bar says **Autosave off** and you can still use Ctrl+S or
+Save As. The project file stores it as `editor.autosave`; omitting it means enabled.
 
-These settings are used when the project opens again; they do not convert the active
-scene, switch its dimension, restart the Player, or add a scene Undo entry.
+The project name, default dimension, and start scene are used when the project opens
+again; they do not convert the active scene, switch its dimension, restart the Player,
+or add a scene Undo entry.
 **Cancel** or **Escape** discards this form's draft. If another writer changes the
 project settings while the dialog is open, Save reports a revision conflict and
 keeps your draft. **Reload saved** deliberately discards it and reloads the latest
@@ -151,6 +175,11 @@ messages and diagnostics. **Jobs** shows build/import/export progress and cancel
 drag panel dividers to resize the Scene, Inspector, and bottom areas. These choices
 are stored per project in `.faset/editor-layout.json`.
 
+File rows put the filename before its directory; hover to see the full project-relative
+path. Long generated hexadecimal filenames are shortened in the list, while the
+path and underlying asset identity remain intact. The search field filters by the
+full project-relative path.
+
 The current layout supports these panel sizes and bottom-tab ordering. It does not
 provide floating panels or multiple Editor windows. Theme and base layout JSON live
 in the engine's `assets/ui/dark.json` and `assets/ui/editor-layout.json`. The Editor

docs/manual/getting-started/build.md

@@ -31,22 +31,51 @@ cmake --build --preset linux-debug --parallel
 ctest --preset linux-debug
 ```
 
-Create a project and open the native Editor:
+Create a runnable C++ or Lua starter and open the native Editor:
 
 ```sh
-build/linux-debug/faset_editor --project "$PWD/MyGame" --new MyGame --dimension 3
+build/linux-debug/faset_editor --project "$PWD/MyGame" --new MyGame --dimension 3 --language cpp
+build/linux-debug/faset_editor --project "$PWD/LuaGame" --new LuaGame --dimension 2 --language lua
 ```
 
 You can also run `build/linux-debug/faset_editor` without arguments to open the
-project launcher and create or select a project using the native interface.
+project launcher. Its Create view offers C++ 2D, C++ 3D, Lua 2D, and Lua 3D.
+Each explicit starter includes `Scenes/main.scene.json` with a player, ground,
+and a behavior bound to `Scripts/Gameplay.cpp` or `Scripts/main.lua`. 3D starters
+also include a camera and light. Existing files in a destination directory are
+never replaced by starter creation. The older `--new NAME --dimension 2|3`
+command without `--language` retains its original scene-free C++ scaffold.
 
-Use **Build C++** after changing `MyGame/Scripts/Gameplay.cpp`, then **Play**.
+Use **Build** after changing `MyGame/Scripts/Gameplay.cpp`, then **Play**.
 The Player runs separately. Stop it before changing and rebuilding C++ gameplay.
+Lua starters declare their entry script in `project.faset.json`, install LuaLS
+annotations/configuration, and need no `Gameplay.cpp`. Use **Refresh Lua** after
+editing a Lua behavior declaration; development **Reload Lua** can apply a valid
+script edit to a running Player without recompiling C++.
 See [MCP and CLI](../editor/mcp.md) for headless authoring and automation.
 
 For an optimized build use `linux-release`. The `linux-sanitize` preset enables
 AddressSanitizer and UndefinedBehaviorSanitizer for tests without the graphics backend.
 
+## Optional Lua module
+
+Engine development builds enable `FASET_ENABLE_LUA` by default. Lua 5.4.9 is compiled
+from its checksum-pinned source archive; no system Lua installation is required.
+Pass `-DFASET_ENABLE_LUA=OFF` to omit the VM and bindings. The Editor's project
+build/export service selects this flag from `scripting.lua.scripts` in
+`project.faset.json`, so C++-only games do not link Lua.
+
+See the [Lua guide](../scripting/lua.md) for the manifest, a Lua-only project,
+hot reload, and external-editor/LuaLS setup. Headless CPU checks can be run with:
+
+```sh
+cmake --preset linux-debug -DFASET_BUILD_RENDERER=OFF -DFASET_BUILD_EDITOR=OFF
+cmake --build --preset linux-debug --parallel
+ctest --preset linux-debug
+```
+
+These checks do not verify the graphical Player or renderer.
+
 ## Dependencies and offline builds
 
 Dependency source URLs, commits, and archive SHA-256 values are stored in

docs/manual/index.md

@@ -9,10 +9,13 @@ and how those functions interact with scenes, physics, and the editor.
     Blender import and standalone Linux/Windows export. Acceptance used a physical
     Linux GPU and software Vulkan on Windows. See the
     [acceptance dossier](https://github.com/emil28092005/Faset_Engine/blob/main/docs/validation/mvp-acceptance.md)
-    for exact source revisions and coverage limits. Lua and advanced graphics remain
-    later milestones.
+    for exact source revisions and coverage limits. The optional Lua module is
+    documented separately; those historical acceptance results do not certify later
+    changes. GPU visibility and prepared mesh LOD arrived after that MVP; see the
+    [visibility guide](editor/visibility-lod.md). Advanced lighting and geometry
+    systems remain later milestones.
 
-Start with [how C++ gameplay works](scripting/index.md), then read
+Start with [how gameplay works](scripting/index.md), then read
 [frame and physics updates](scripting/lifecycle.md). See
 [Build from source](getting-started/build.md) for the toolchain and build commands.
 
@@ -30,7 +33,9 @@ The manual grows alongside tested engine capabilities, in this order:
 5. Work with scene templates, assets, and references.
 6. Import from Blender and export a standalone game.
 
-Lua is planned after the C++ foundation. It is not a current scripting option.
+For interpreted gameplay, follow [Lua gameplay](scripting/lua.md): declare component
+fields, write callbacks, and reload scripts during development Play. The Lua-only
+example in `examples/lua` uses the same physics and scene model as the C++ tutorials.
 
 ## Preview this manual
 

docs/manual/scripting/first-behavior.md

@@ -56,14 +56,26 @@ The example scene is a complete, loadable document:
 
 The sprite is visible because it has `faset.sprite`. It moves because it also has `tutorial.move_x`. The configuration field is `speed`; the type string must match the registration exactly. `rotation` uses radians, and the default coordinate system is Y-up.
 
-After **Build C++** succeeds in the Editor, choose **Add component** in the Inspector
+After **Build** succeeds in the Editor, choose **Add component** in the Inspector
 and select the registered type. Its schema supplies editable fields, defaults and
 constraints. The direct Player command above is useful for testing the same behavior
 independently of an editor session.
 
 ## Make a change and verify it
 
-Change the scene's `speed` to `-2`: the object moves left. Change the C++ callback or schema: stop the Player, rebuild, regenerate the schema, then launch a new session. There is no automatic C++ hot reload.
+Change the scene's `speed` to `-2`: the object moves left. Change the C++ callback
+or schema: stop the Player, choose **Build**, then launch a new Play session. The
+Build job regenerates metadata when its inputs changed; an unchanged second build
+can reuse the verified schema/package generation. It still asks CMake/Ninja to check
+the native dependency graph. There is no automatic C++ hot reload.
+
+To try compiler navigation in a project opened by the Editor, add
+`#error Check navigation` to its `Scripts/Gameplay.cpp`, choose **Build**, and
+select the resulting Console diagnostic. **Open source** passes the file and
+one-based location to the configured external editor. Remove the line and build
+again; the failed attempt keeps the previous valid generation. See
+[Developer diagnostics](../editor/diagnostics.md) for editor command setup and
+[Build, Play, and export](../editor/export.md) for the full iteration loop.
 
 The `tutorial_moving` CTest checks that both 30 Hz and 60 Hz frame sequences move the object two metres in one second. It checks the resulting pose, rather than only checking that the program starts.
 

docs/manual/scripting/index.md

@@ -1,8 +1,12 @@
-# C++ gameplay
+# Gameplay scripting
 
-In Faset, a gameplay script is **C++ compiled into the Player**. You write ordinary functions and register the callbacks an object needs. There is no C++ interpreter or live replacement of compiled classes. Stop Play, rebuild, export the schema, and start a new Player session.
+Faset supports **C++ compiled into the Player** and optional [Lua gameplay](lua.md).
+Both languages register component schemas and callbacks on the same runtime.
+For C++, there is no interpreter or live replacement of compiled classes: stop Play,
+rebuild, export the schema, and start a new Player session.
 
-Lua is planned for a later stage. The APIs and tutorials in this section describe the C++ implementation available now.
+The following tutorials describe C++. See [Lua gameplay](lua.md) for Lua-only or
+mixed projects, the Lua API, source reload, and external-editor completion.
 
 ## Start here
 

docs/manual/scripting/lua.md

@@ -0,0 +1,271 @@
+# Lua gameplay
+
+Faset embeds **Lua 5.4.9** as an optional gameplay module. Lua and compiled C++
+behaviors share the same runtime lifecycle, typed entity operations, scene components,
+and Inspector metadata. The Editor does not run gameplay code in its own process.
+There is no built-in script editor: edit `.lua` files in Zed or another external editor.
+
+## Start with a runnable Lua project
+
+Choose **Create project → Lua → 2D or 3D** in the native launcher, or run:
+
+```sh
+build/linux-debug/faset_editor --project "$PWD/LuaGame" --new LuaGame --dimension 2 --language lua
+```
+
+The starter creates `Scripts/main.lua`, a scene with a player and ground, and a
+manifest entry for that script. The player moves horizontally and jumps with the
+default input actions. The 3D choice also provides a camera and directional light.
+Open `Scripts/main.lua` in your external editor and change `speed` or
+`fixed_update`. **Refresh Lua** updates declared Inspector fields; **Reload Lua**
+updates a development Player after a valid edit without rebuilding native gameplay.
+The starter installs LuaLS declarations and `.luarc.json`; reopening it in Zed or
+another LuaLS-enabled editor provides completions for the Faset API.
+
+## Enable Lua in a project
+
+Add explicit entry scripts to `project.faset.json`:
+
+```json
+"scripting": {
+  "lua": {
+    "scripts": ["Scripts/player.lua", "Scripts/beacon.lua"]
+  }
+}
+```
+
+This is a manifest fragment, not a complete project file. Each entry must return one
+`faset.behavior` table with a unique custom TypeId. All sources live beneath `Scripts`
+and are copied into a content-verified build/export snapshot. Paths must be project-relative;
+symlinks and paths outside `Scripts` are rejected. Auxiliary modules do not need to
+appear in the entry list.
+
+A Lua-only project can omit both `Scripts/Gameplay.cpp` and `Scripts/Gameplay.hpp`.
+A mixed project keeps that pair and adds the Lua declaration. TypeIds must be unique
+across both languages, and the `faset.*` namespace is reserved for native components.
+
+The engine developer option `FASET_ENABLE_LUA` defaults to `ON`. Project builds select
+it from the manifest, so a C++-only game does not link the Lua VM. Lua is pinned and
+built from source; no system Lua installation is required.
+
+The complete `examples/lua` project includes a playable
+2D controller, a non-physical animated beacon, and a shared module. Its scripts are
+also loaded by the Lua contract test.
+
+## Write a behavior
+
+```lua
+local Player = faset.behavior {
+    id = "game.player",
+    version = 1,
+    name = "Player",
+    fields = {
+        speed = {
+            name = "Move speed", type = "number", default = 5,
+            min = 0, max = 30, units = "m/s"
+        }
+    }
+}
+
+function Player:on_start()
+    self.state.elapsed = 0
+end
+
+function Player:fixed_update(delta)
+    self.state.elapsed = self.state.elapsed + delta
+    local velocity = self.entity:velocity()
+    velocity.x = faset.input().horizontal * self.fields.speed
+    self.entity:set_velocity(velocity)
+end
+
+return Player
+```
+
+Attach a component with `type: "game.player"`, `version: 1`, and the desired field
+overrides to an entity with a 2D or 3D rigid body. Refresh schemas to expose the
+behavior in **Add Component** and its `speed` field in the Inspector. Saved scenes
+store the stable TypeId and data, not an instance of a Lua object.
+
+Each entity/component gets its own instance:
+
+- `self.entity`: an opaque runtime handle, checked on every call.
+- `self.fields`: a configuration copy, combining schema defaults and scene overrides.
+- `self.state`: a fresh mutable table for counters, timers, and retained handles.
+
+Changing either table does not modify the saved scene or create an Undo operation.
+Module-local variables are shared by instances of that module; put per-entity state
+in `self.state`. Lua tables returned by getters are copies, not native pointers.
+
+## Lifecycle
+
+Use colon definitions so Lua supplies `self`:
+
+| Callback | When it runs |
+|---|---|
+| `on_start()` | Once after the instance and initial scene objects exist |
+| `fixed_update(delta)` | Before each fixed physics step; delta is seconds |
+| `on_collision(event)` | After physics, for contact begin/end |
+| `update(delta)` | Once per rendered frame after fixed steps |
+| `late_update(delta)` | After presentation interpolation |
+| `on_destroy()` | Before component/entity removal, while the handle is still valid |
+
+Omit unused callbacks. The same [timing rules](lifecycle.md) as C++ apply, including
+input edges, fixed-tick catch-up, deferred structural changes, pause and single-step.
+Do not multiply velocity by delta; multiply a manually calculated displacement.
+
+An error is reported with source location/traceback and disables the offending
+instance for that generation and releases its instance state. Other instances can continue.
+The VM quota is shared: allocations retained by module-level variables can still
+affect other behaviors. A restart/reload creates
+fresh instances; disabled instances are not automatically retried every frame.
+Changes already made or queued by a failing callback are not rolled back.
+
+## Runtime API
+
+`faset.find("scene-id")` returns an entity handle or `nil`. Handles support equality
+and `:valid()`. Retained handles become invalid after destruction or scene restart;
+calling other methods on a stale handle reports an error.
+
+| Entity method | Contract |
+|---|---|
+| `:transform()` / `:presentation()` | Copy of simulation/display transform |
+| `:set_transform(pose)` | Non-physical objects only |
+| `:set_presentation(pose)` | Display-only write during `late_update` |
+| `:teleport(pose)` | Explicit discontinuous pose change; preserves velocity |
+| `:fields(type_id)` | Copy of the named component's stored fields |
+| `:velocity()` / `:set_velocity(v)` | Linear velocity, rigid bodies only |
+| `:apply_impulse(v)` | Impulse at the rigid body's centre |
+| `:is_grounded()` | Support from completed native physics contacts |
+| `:destroy()` | Queue entity/descendant removal |
+| `:add_component(record)` | Queue a complete component record |
+| `:remove_component(type_id)` | Queue component removal |
+
+Typed vectors are `{x = 1, y = 2, z = 0}`. Transforms contain `position`, `rotation`,
+and `scale`, each a named vector. Positions use metres; rotations use XYZ Euler
+radians. In contrast, **scene/component JSON arrays** are represented as ordinary
+1-based Lua arrays, such as `fields.position = {1, 2, 0}`. Use `faset.null` to retain
+an explicit JSON null; Lua `nil` removes a table key.
+An empty Lua table converts to a JSON object; an empty schema default with
+`type = "array"` is normalized to an empty JSON array.
+
+`faset.input()` returns `horizontal`, `vertical`, `jump_pressed`, and
+`interact_pressed`. Player mappings are A/D or arrows, W/S or arrows, Space, and E.
+`faset.log(...)` sends a bounded message to Player logs and the Editor Console.
+
+Collision events contain `first`, `second`, `other` (the opposite entity), and `began`.
+They are copied for Lua, but retained entity handles still need validity checks.
+
+`faset.spawn(record)` queues a full scene entity record. It returns **no handle**:
+use `faset.find(id)` after the next fixed-tick barrier. Spawn, destroy, add and remove
+operations follow FIFO order and do not mutate Editor documents. For example:
+
+```lua
+faset.spawn {
+    id = "effect-1", name = "Effect", parent = faset.null,
+    components = {
+        {
+            id = "effect-transform", type = "faset.transform", version = 1,
+            fields = { position = {0, 2, 0} }
+        }
+    }
+}
+```
+
+## Shared modules and sandbox
+
+`require("util.motion")` resolves `Scripts/util/motion.lua`, then
+`Scripts/util/motion/init.lua`, inside the captured source snapshot. A module is
+evaluated once and its result cached within the VM. Missing modules, cycles, and
+path-like names are errors. There is no native module search, package installation,
+network access, or arbitrary file access.
+
+Basic Lua operations and the `math`, `string`, `table`, and `utf8` libraries are
+available. `io`, `os`, `debug`, dynamic `load`, `loadfile`, `dofile`, `pcall`, `xpcall`,
+`setmetatable`, `collectgarbage`, `string.dump`, and coroutines are not exposed.
+Engine-owned metatables are locked; arbitrary finalizers cannot run during shutdown.
+The restricted API intentionally prevents scripts
+from catching execution-limit errors and continuing indefinitely.
+
+The VM has memory and instruction budgets (`LuaLimits`, default 16 MiB and one
+million instructions per protected entry/callback). These are gameplay reliability
+limits, not a promise that executing untrusted code is equivalent to OS isolation.
+JSON conversion also limits nesting, node count and expanded string/key bytes
+(16 MiB), including repeated references to the same Lua string. Structural commands
+are limited to 1,024 operations and 16 MiB of marshaled payload per callback.
+The Player already runs separately from the Editor; only trusted local game projects
+should be opened and built. C++ gameplay is native code and is not sandboxed.
+
+Schema extraction evaluates entry scripts in the bounded VM but does not create a
+world or invoke lifecycle callbacks. Keep top-level code declarative: calling runtime
+operations there is an error. Metadata supports the same fields, constraints and
+declarative [migration rules](api.md#editor-data-migrations) as C++ schemas. Runtime
+loading does not migrate saved data automatically.
+
+## Edit, reload, and export
+
+The Editor command palette exposes:
+
+| Command | Purpose |
+|---|---|
+| `faset_lua_refresh` | Build if needed, extract schemas, refresh Inspector metadata |
+| `faset_lua_reload` | Request a Lua reload in a development Player |
+| `faset_lua_setup` | Install Faset LuaLS declarations/configuration |
+| `faset_source_open` | Open a C++, header or Lua source at a one-based line/column |
+| `faset_script_open` | Lua-only compatibility alias for source opening |
+
+The external-editor default is `zed`. Set `editor.script_editor` in
+`project.faset.json` to an argument array such as
+`["zed", "{file}:{line}:{column}"]`, or pass an `editor` argument array to
+`faset_source_open`. `{file}`, `{line}`, `{column}` and `{project}` are substituted
+inside arguments; a missing file argument is appended. The command launches the
+executable directly, without a shell. Only regular source files under this
+project's `Scripts` can be opened. The Assets panel lists those files and the
+Console's structured Lua error can open its source location. A missing external
+editor is an actionable navigation error, not a failed gameplay build.
+
+Development Play watches Lua changes. The Player's `--watch-lua` option enables this
+for direct development runs. A candidate source generation is loaded and validated
+before replacement; an invalid candidate leaves the preceding generation running.
+Successful reload **restarts the scene**, invalidates old handles, and resets all
+script state. This is not state-preserving hot swapping. C++ source changes still
+require a rebuild and a new Player process.
+
+For a short iteration, change `speed` in `Scripts/main.lua`, save it, and watch the
+Console for **Lua reloaded**. The running development Player picks up a valid
+snapshot without native recompilation. Change a field declaration or TypeId, then
+choose **Refresh Lua** to validate metadata and update Inspector choices. If the
+candidate has a syntax/schema error, the previous running generation remains in
+place; use the structured diagnostic to return to the source, correct it and retry.
+Lua module declaration, gameplay source, compiler/toolchain or shader changes can
+invalidate a later build's verified schema/package cache. The **Jobs** result
+distinguishes `schema_cache_hit` and `generation_reused`; those flags do not imply
+that the native build graph was skipped. See the [build loop](../editor/export.md)
+and [profiling guide](../editor/profiling.md).
+
+Export captures the declared entry list and Lua modules with the game. The exported
+Player runs without the Editor or a separate Lua installation; development watching
+is not enabled by ordinary exported-game launch. Exported Lua remains readable source,
+not encrypted code. A C++-only project continues to export without the Lua VM.
+
+## Zed and LuaLS
+
+Run `faset_lua_setup`. It copies annotation-only declarations to
+`.faset/lua/faset.lua` and creates `.luarc.json` **only if it does not already exist**.
+It also creates `Scripts/.luarc.json` for editors that open an individual Lua file
+with `Scripts` as the workspace root. Existing configuration files are preserved.
+For an existing LuaLS configuration, merge these settings yourself:
+
+```json
+{
+  "runtime.version": "Lua 5.4",
+  "runtime.path": ["Scripts/?.lua", "Scripts/?/init.lua"],
+  "workspace.library": [".faset/lua"],
+  "workspace.checkThirdParty": false,
+  "diagnostics.globals": ["faset"]
+}
+```
+
+Use an editor with LuaLS integration and open the project directory. Annotations
+describe the Faset API for completion and diagnostics; they are not runtime code and
+must not be `require`d. The engine does not embed an LSP client, code editor, or a
+breakpoint debugger. Player logs/tracebacks are the first debugging surface.

docs/studies/15-renderer-implementation-notes.md

@@ -1,12 +1,12 @@
 # 15. Первый GPU-driven renderer Faset: данные, порядок проходов и проверка корректности
 
-Исследование от 17 сентября 2026; проектные решения обновлены 18 сентября 2026. Это продолжение [обзора UE](07-unreal-graphics-source-study.md): здесь разобран контракт одного будущего GPU-driven прототипа. **Принято, реализация запланирована:** собственные Vulkan 1.3 backend и Render Graph, Slang → SPIR-V, SDL3, Linux/Windows desktop 2D/3D, базовый путь без обязательного RT. Поддерживаемые модели GPU и проверенная матрица драйверов ещё не определены. Актуальные границы — в [архитектуре](../ARCHITECTURE.md) и [плане до/после MVP](../../PLAN.md).
+Исследование от 17 сентября 2026; проектные решения обновлены 18 сентября 2026. Это продолжение [обзора UE](07-unreal-graphics-source-study.md): здесь разобран контракт тогда ещё будущего GPU-driven прототипа. **Исторический проектный материал:** собственные Vulkan 1.3 backend и Render Graph, Slang → SPIR-V, SDL3, Linux/Windows desktop 2D/3D, базовый путь без обязательного RT. Ниже сохранены гипотезы и предложения в том виде, в каком они предшествовали реализации; они не доказывают свойства кода. Фактически реализованный P2 и измерения от 23 сентября 2026 описаны в [отдельной приёмке](19-p2-gpu-visibility-acceptance.md) и [журнале](../IMPLEMENTATION.md). Актуальные границы — в [архитектуре](../ARCHITECTURE.md) и [плане](../../PLAN.md).
 
-**Место в плане:** M2 (базовая графика MVP) использует direct renderer с CPU frustum culling, простым PBR/тенями и отдельным упорядоченным 2D-путём; обе демки должны собираться в самостоятельный Player. GPU culling, indirect draws, HZB и LOD из этого исследования начинаются **после MVP, в P2**, с сохранением direct reference. Сначала fixed indirect bins и frustum, затем two-pass HZB, затем обычный mesh LOD с hysteresis. Кластерный LOD и streaming — дальнейшее исследование. Минимальный Render Graph с одной очередью и корректными barriers/lifetime нужен уже MVP; pass culling, aliasing и async compute не обязательны.
+**Место в плане на момент исследования:** M2 (базовая графика MVP) использует direct renderer с CPU frustum culling, простым PBR/тенями и отдельным упорядоченным 2D-путём; обе демки должны собираться в самостоятельный Player. GPU culling, indirect draws, HZB и LOD были намечены **после MVP, в P2**, с сохранением direct reference. Порядок: fixed indirect bins и frustum, затем two-pass HZB, затем обычный mesh LOD с hysteresis. Кластерный LOD и streaming — дальнейшее исследование. Минимальный Render Graph с одной очередью и корректными barriers/lifetime нужен уже MVP; pass culling, aliasing и async compute не обязательны.
 
 **Граница инструментов:** MCP работает только в редакторе, включая headless authoring/import/build, Play/Stop и логи редактора. Player — отдельный процесс с отдельным окном, без MCP; чтение/изменение runtime worlds и игровых сессий через MCP исключено. Диагностика renderer и ручной GPU capture не превращаются в канал MCP-доступа к Player.
 
-Источники привязаны к [source-manifest.json](source-manifest.json): UE 5.8.2, commit `16d75d84714512edfb744e1fd0a59e9c74d57873`; Godot 4.8-dev, commit `9c776068d6ed23acd0c78bfe534272d1d2a3a619`. Прочитаны выбранные тела C++ и shader-функций, затем официальные Vulkan/D3D12 документы. Репозитории не изменялись. Движки и GPU-прототип не запускались; ускорения, совместимость конкретных карт и качество culling измерениями не подтверждены. **«Факт»** ниже относится к просмотренному коду/документу; **«предложение»** — к нашему проекту; гипотезы отмечены отдельно.
+Источники привязаны к [source-manifest.json](source-manifest.json): UE 5.8.2, commit `16d75d84714512edfb744e1fd0a59e9c74d57873`; Godot 4.8-dev, commit `9c776068d6ed23acd0c78bfe534272d1d2a3a619`. Прочитаны выбранные тела C++ и shader-функций, затем официальные Vulkan/D3D12 документы. Репозитории не изменялись. **На момент исследования** сторонние движки и GPU-прототип Faset не запускались; ускорения, совместимость конкретных карт и качество culling измерениями не подтверждались. **«Факт»** ниже относится к просмотренному коду/документу; **«предложение»** — к нашему проекту; гипотезы отмечены отдельно.
 
 ## 1. Полезный результат не требует полного GPU command processor
 
@@ -129,4 +129,8 @@ D3D12 подтверждает переносимость самой идеи,
 
 Главное дополнение к 07: фиксированные CPU draw templates совместимы с GPU instance visibility; velocity target не требуется для первого HZB; history extraction — output/lifetime контракт; camera reset заменяет весь previous-view набор; indirect и vertex reads требуют разных зависимостей; неполный Main HZB может быть начальным вариантом истории с измеряемой ценой в эффективности.
 
-Прочитаны тела UE `FInstanceCullingContext` создания buffers/submission, `InstanceCullBuildInstanceIdBufferCS`, `ClearIndirectArgInstanceCountCS`, Nanite `FBoxCull::HZB`, `WriteOccludedInstance` и main/HZB/post orchestration; `BuildHZB`, `HZBBuildCS` и HZB parameter helpers; previous-view setup/reset в SceneVisibility; RDG import/extraction, barrier compile/collection и resource reference handling. В Godot — indirect draw validation/tracking и named render-buffer creation/configuration/cleanup. В интернете — официальные Vulkan indirect/features/synchronization и Microsoft D3D12 indirect signatures. В этом исследовании не проверялись формат/driver capability matrix и runtime-поведение. Позднейшие проверки базового Faset renderer публикуются отдельно в [docs/validation](../validation/README.md); они не подтверждают GPU-driven техники этого раздела.
+Прочитаны тела UE `FInstanceCullingContext` создания buffers/submission, `InstanceCullBuildInstanceIdBufferCS`, `ClearIndirectArgInstanceCountCS`, Nanite `FBoxCull::HZB`, `WriteOccludedInstance` и main/HZB/post orchestration; `BuildHZB`, `HZBBuildCS` и HZB parameter helpers; previous-view setup/reset в SceneVisibility; RDG import/extraction, barrier compile/collection и resource reference handling. В Godot — indirect draw validation/tracking и named render-buffer creation/configuration/cleanup. В интернете — официальные Vulkan indirect/features/synchronization и Microsoft D3D12 indirect signatures. В этом исследовании не проверялись формат/driver capability matrix и runtime-поведение. Позднейшие проверки базового Faset renderer опубликованы в [docs/validation](../validation/README.md); отдельные P2 GPU-проверки опубликованы в [приёмке P2](19-p2-gpu-visibility-acceptance.md) и [измерении P2](20-p2-gpu-visibility-benchmark-2026-09-23.md). Эти результаты не превращают исторические гипотезы исследования в доказанные свойства всех GPU.
+
+## Примечание к реализации P2 · 23.09.2026
+
+P2 реализован для opaque static meshes с fixed bins, GPU frustum/indirect, HZB main/post и prepared mesh LOD. Реальный debug view показывает current HZB и счётчики; отдельного instance-ID attachment, предполагавшегося в проектном разборе, пока нет. Приёмка сравнивает финальные RGB-кадры с direct-эталоном и проверяет конкретные adversarial-пиксели и счётчики. Diagnostics readback включается по запросу, но существующий framebuffer capture в тестовом renderer всё ещё синхронен; исходное предложение о полностью асинхронном profiler/readback пока не выполнено. На Linux reference GPU первый Debug/validation benchmark выявил дорогой GPU MainCull, поэтому реализация не заявлена как универсальное ускорение. Детальные ограничения и числа находятся в [отчёте P2](20-p2-gpu-visibility-benchmark-2026-09-23.md), а не в проектных предположениях выше.

docs/studies/19-p2-gpu-visibility-acceptance.md

@@ -0,0 +1,51 @@
+# P2 GPU visibility: acceptance and benchmark protocol
+
+This protocol exercises the post-MVP GPU-driven renderer against the retained direct path. It is an implementation and measurement checklist, not a performance claim. The prototype architecture and failure scenarios are described in [study 15](15-renderer-implementation-notes.md).
+
+## Correctness gate
+
+`cmake/GpuVisibilityAcceptance.cmake` registers fifteen offscreen Vulkan cases. Each renders a controlled `Snapshot` through `VisibilityMode::Direct` and a GPU mode, compares the expected final RGB image with a small tolerance for floating-point raster differences, and requires zero Vulkan validation errors. GPU cases also require `FrameStats::gpu_visibility_active`; a silent direct fallback cannot pass. Acceptance enables `RendererConfig::visibility_diagnostics`, which reads GPU counters back for assertions.
+
+| Case | Regression caught |
+| --- | --- |
+| `empty` | A previous frame's indirect count leaks into an empty scene. |
+| `capacity` | Instance ID / indirect-count allocation drops an instance at 64→65 candidates or after shrinking. |
+| `dense` | GPU frustum rejects visible objects or fails to reject offscreen objects; bins degenerate to one CPU draw per instance. |
+| `door` | Previous-frame HZB hides an object after its occluder moves; post-cull must reveal it in the same final frame. |
+| `shadow` | Camera-frustum rejection incorrectly removes an offscreen shadow caster. The fixture first proves the caster's shadow affects the reference image. |
+| `cut` | A camera cut reuses incompatible HZB history. |
+| `resize` | Odd-sized target recreation retains stale HZB extents or reads out of bounds. |
+| `lod` | A prepared coarse mesh is not selected at distance, small scale jitter switches it back, or a large scale change fails to restore the fine mesh. The direct reference explicitly renders the expected prepared mesh at each level. |
+| `teleport` | A sudden camera move without an explicit cut marker leaves an object hidden; post-cull must recover it with the previous HZB still valid. |
+| `near` | Frustum/HZB wrongly rejects bounds crossing the near plane or containing the camera. |
+| `lifecycle` | Mass spawn/despawn, buffer growth, reused stable key, or replacement mesh reuses stale indirect counts or temporal bounds. |
+| `views` | Two viewport IDs incorrectly share temporal HZB history. |
+| `projection` | FOV/projection changes retain incompatible HZB history despite an unchanged view ID. |
+| `open_sequence` | A long camera pan over an open scene loses otherwise visible instances or leaks stale history. |
+| `transparent` | A transparent foreground draw contaminates the HZB and hides opaque geometry behind it. |
+
+Run all acceptance tests after building:
+
+```sh
+ctest --test-dir build/linux-debug --output-on-failure -L p2
+```
+
+The pixel comparison allows at most 0.5% of pixels to differ by more than 16 RGB levels and a mean RGB error of at most 2. Capacity checks also inspect each cube center; the shadow case compares every pixel affected by the reference shadow. These targeted checks catch small omissions that a whole-frame tolerance could miss. A failing scene should be inspected by saving both full frames and a difference image before relaxing a threshold.
+
+These cases are the automatic minimum. Manual follow-up should cover newly imported meshes, overlapping material bins, shader reloads, and final color plus depth/ID debug views where available. Assert no indirect buffer overflow or validation errors at the advertised capacity. Stable IDs must survive reordering; reused slots need a generation change. 2D sprites and editor UI retain their authored order.
+
+## Benchmark command and interpretation
+
+The standalone executable writes per-frame CSV without declaring a speedup:
+
+```sh
+build/linux-debug/faset_render_gpu_acceptance_tests --benchmark /tmp/faset-p2-dense.csv
+```
+
+It warms each mode for 10 frames, then records 30 frames for each of three fixed scenes: a frustum-heavy grid, an open scene with almost all instances visible, and a wall hiding a dense group. It repeats these workloads for direct, GPU frustum, and GPU occlusion. All benchmark objects disable shadows so shadow draw submission does not dominate the visibility comparison. The harness enables visibility diagnostics so that GPU counters are observable; this adds host mapping/readback overhead. Columns include whole-render-call CPU time, GPU command time, CPU readback time, pass-level GPU times (main cull/raster, HZB, post cull/raster), live Vulkan allocation bytes, submitted draw calls, visibility counters, LOD counts, and validation errors. Summarize median and p95 per scene/mode; retain the raw CSV. Run each configuration at least three times and report run-to-run variation. The harness intentionally has no performance assertion because gains depend on GPU, driver, scene and capture overhead.
+
+The current renderer performs a full-image readback and waits for frame completion every frame. `cpu_ms` measures the whole synchronous `Renderer::render` call, including that wait and the host copy. `gpu_ms` measures the timestamp interval around GPU commands, including the image-to-buffer copy but excluding the later host map/copy. `readback_cpu_ms` measures only the host map/copy. Pass-level timestamps expose the cost of `MainCull`, `MainRaster`, `HZB`, `PostCull`, and `PostRaster`, but CPU extraction/upload/submission are not individually timed. The benchmark's diagnostic counter readback adds host work beyond a normal Player frame. Compare a closed, heavily occluded scene **and** an open scene in which most instances remain visible. Record identical geometry, camera path, window extent, shader bundle, validation setting and capture mode. Avoid benchmarking during shader compilation, texture uploads, first-use allocations or GPU frequency transitions.
+
+Keep data from software Vulkan implementations separate from physical GPU data. A visibility feature is accepted by image correctness and lifecycle tests even if it is slower in a particular scene; retain the measured regression and decide whether to use the direct path there.
+
+The first recorded three-run result, including source hashes, device metadata, p50/p95 tables, counter values, limitations, and links to all 810 raw frame records, is in [the 2026-09-23 benchmark report](20-p2-gpu-visibility-benchmark-2026-09-23.md). The GPU cull pass is much slower than the direct path's GPU work in this Debug/validation configuration, even as CPU submission time falls. Treat the result as a profiling lead, not a shipping performance verdict.

docs/studies/20-p2-gpu-visibility-benchmark-2026-09-23.md

@@ -0,0 +1,65 @@
+# P2 GPU visibility: first measured run (2026-09-23)
+
+The [acceptance protocol](19-p2-gpu-visibility-acceptance.md) passed all 15 offscreen Vulkan cases on this source state. Three benchmark repetitions then produced 810 measured frames and zero Vulkan validation errors. GPU visibility reduced CPU render-call time in these synthetic scenes, but its GPU command time was substantially higher than the direct path. The compute `MainCull` pass accounts for almost all of that GPU cost. This is a Debug build with validation and diagnostic counter readback, so the numbers identify work to profile; they do not establish Release-build throughput.
+
+## Reproduction and scope
+
+| Field | Value |
+| --- | --- |
+| Source commit | `ae537c0a4b28e6033a6db045d3401f8d8e96f2ee` |
+| Acceptance executable SHA-256 | `8eba12dab776ee64a2edcdf743f3bad83b91a991608578ee136c072566ab4751` |
+| `src/render/renderer.cpp` SHA-256 | `d650718b78cb757d322586aef3ebfc97cb412dd36ac29d3071886f59d045752e` |
+| `shaders/gpu_scene.slang` SHA-256 | `8fb7460ebcabc87a844fa2774f3bdad1d1f594a8d3b84d0a6881c9e439a35d98` |
+| Compiled SPIR-V manifest SHA-256 | `307a13cf30c8211703224072d7d730035dea2f8eaf0e66f0a70e01737ce72238` (SHA-256 of lexically sorted `sha256sum build/linux-debug/shaders/*.spv` output) |
+| Build | CMake Debug, Ubuntu Clang 21.1.8, Linux 7.0.0-31-generic x86_64 |
+| GPU / driver | NVIDIA GeForce RTX 2080 Ti / 595.84; Vulkan device API 1.4.329 |
+| Capture | Headless 320 × 240 RGBA, synchronous image readback every frame |
+| Diagnostics | Vulkan validation and `visibility_diagnostics` enabled; zero reported validation errors |
+| Workload | Deterministic geometry, no random seed; 1,024 grid instances plus scene-specific occluder; shadows disabled for benchmark objects |
+| Sampling | Sequential direct → GPU frustum → GPU occlusion for each scene; 10 warmup + 30 sampled frames per scene/mode/run; three sequential runs |
+
+The three raw, unmodified per-frame captures are [run 1](data/p2-2026-09-23-run-1.csv), [run 2](data/p2-2026-09-23-run-2.csv), and [run 3](data/p2-2026-09-23-run-3.csv). Each contains 270 rows: 30 frames for each of three scenes and three visibility modes. Source, shader and executable hashes were the same before and after all three runs. The CSV `frame` field resets to zero for each scene/mode. The SPIR-V manifest hash above includes file names and hashes in sorted order.
+
+Values below pool 90 frames per scene/mode. P50 is the median and p95 is linearly interpolated at rank `(n - 1) × 0.95` after sorting. The run range is the minimum–maximum of the three *individual-run p50* values, making run-to-run variation visible. Times are milliseconds.
+
+| Scene | Mode | CPU render p50 / p95 | CPU run-p50 range | GPU commands p50 / p95 | GPU run-p50 range |
+| --- | --- | ---: | ---: | ---: | ---: |
+| Frustum-heavy | Direct | 73.60 / 90.94 | 71.37–81.42 | 0.241 / 0.268 | 0.240–0.242 |
+| Frustum-heavy | GPU frustum | 14.58 / 23.04 | 13.48–15.23 | 4.00 / 4.69 | 3.89–4.12 |
+| Frustum-heavy | GPU occlusion | 15.01 / 22.14 | 14.00–15.67 | 3.99 / 4.60 | 3.96–4.02 |
+| Open | Direct | 70.34 / 89.71 | 68.70–71.51 | 0.502 / 0.531 | 0.500–0.503 |
+| Open | GPU frustum | 29.52 / 37.88 | 28.98–30.67 | 18.08 / 19.21 | 17.87–18.25 |
+| Open | GPU occlusion | 30.82 / 38.47 | 29.11–33.36 | 18.36 / 19.18 | 18.03–18.63 |
+| Occluded | Direct | 68.00 / 84.26 | 67.45–68.64 | 0.499 / 0.554 | 0.496–0.500 |
+| Occluded | GPU frustum | 29.63 / 40.42 | 28.49–30.71 | 18.26 / 19.23 | 18.15–18.36 |
+| Occluded | GPU occlusion | 30.39 / 37.37 | 29.16–31.10 | 18.24 / 19.32 | 17.86–18.47 |
+
+`cpu_ms` spans the synchronous `Renderer::render` call, including CPU preparation, submission, GPU completion wait, and host image copy; it excludes renderer construction and the ten warmup frames. `gpu_ms` is the Vulkan timestamp interval around recorded GPU commands, including the image-to-buffer capture copy, but excludes later host mapping and copying. The median isolated host `readback_cpu_ms` is 0.05–0.06 ms in these runs. Neither column is a Player frame rate, and subtracting them does not isolate CPU culling cost.
+
+## Passes, work saved, and memory
+
+The table shows pass-level GPU p50 / p95, in milliseconds. A dash means the pass is absent in that mode. These timestamp spans include work recorded under the named pass and are not interchangeable with the whole-frame GPU interval.
+
+| Scene | Mode | MainCull | MainRaster | HZB | PostCull | PostRaster |
+| --- | --- | ---: | ---: | ---: | ---: | ---: |
+| Frustum-heavy | Direct | — | 0.195 / 0.198 | — | — | — |
+| Frustum-heavy | GPU frustum | 3.917 / 4.624 | 0.029 / 0.050 | — | — | — |
+| Frustum-heavy | GPU occlusion | 3.869 / 4.484 | 0.026 / 0.046 | 0.033 / 0.040 | 0.005 / 0.006 | 0.006 / 0.007 |
+| Open | Direct | — | 0.455 / 0.464 | — | — | — |
+| Open | GPU frustum | 17.956 / 19.120 | 0.046 / 0.084 | — | — | — |
+| Open | GPU occlusion | 18.230 / 19.036 | 0.046 / 0.083 | 0.033 / 0.036 | 0.005 / 0.005 | 0.006 / 0.007 |
+| Occluded | Direct | — | 0.453 / 0.511 | — | — | — |
+| Occluded | GPU frustum | 18.174 / 19.142 | 0.047 / 0.085 | — | — | — |
+| Occluded | GPU occlusion | 18.115 / 19.202 | 0.018 / 0.019 | 0.033 / 0.035 | 0.024 / 0.028 | 0.006 / 0.007 |
+
+The visibility counters are stable across the 90 sampled frames of each GPU scene/mode:
+
+| Scene | Candidate count | GPU main-visible | Frustum rejected | HZB deferred | Post-visible | Direct / GPU-frustum / GPU-occlusion draw calls |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: |
+| Frustum-heavy | 1,024 | 416 | 608 | 0 | 0 | 416 / 1 / 2 |
+| Open | 1,024 | 1,024 | 0 | 0 | 0 | 1,024 / 1 / 2 |
+| Occluded | 1,026 | 1 in occlusion mode | 0 | 1,025 in occlusion mode | 0 | 1,026 / 1 / 2 |
+
+The direct path does not produce GPU visibility counters; zeros in its CSV rows mean “not measured,” not zero visible objects. Peak `FrameStats::gpu_allocated_bytes` was about 7.45 MiB for direct, 5.17 MiB for GPU frustum, and 6.50 MiB for GPU occlusion in this harness. This counter is the renderer's tracked allocations, not whole-process GPU memory.
+
+The frustum fixture removes 608 main-view candidates and cuts main raster time, while the occluded fixture defers 1,025 candidates and cuts its main raster time. Yet the current `MainCull` cost exceeds those savings by an order of magnitude on this device/configuration. The next performance investigation should isolate compute dispatches, transfer/barrier and indirect-buffer work inside `MainCull`, then repeat in Release with validation and diagnostic counter readback disabled. The fixed mode order and GPU clock/thermal state may affect absolute values; a randomized or interleaved follow-up would reduce order bias. The existing acceptance tests verify image agreement in memory, but this benchmark does not store reference images or measure visual quality over real game content.

docs/studies/21-p2-gpu-visibility-optimization-2026-09-23.md

@@ -0,0 +1,58 @@
+# P2 GPU visibility: device-local outputs and bounded atomic append (2026-09-23)
+
+The [first P2 benchmark](20-p2-gpu-visibility-benchmark-2026-09-23.md) found that `MainCull` took about 4 ms with 416 visible candidates and 18 ms with 1,024 candidates in one bin on an RTX 2080 Ti. The camera-visible raster pass was under 0.1 ms. We isolated two causes and measured them separately: GPU-written counters and IDs lived in host-cached system memory, and each contender retried a compare-and-exchange loop on one counter. With device-local outputs and one atomic fetch-add per valid append, the corresponding `MainCull` medians are 0.030 and 0.030 ms. These are measurements of the synthetic Debug/validation harness, not a general engine performance claim.
+
+## Reproduction and provenance
+
+| Field | Value |
+| --- | --- |
+| Baseline | Commit `ae537c0a4b28e6033a6db045d3401f8d8e96f2ee`; source/executable hashes and methodology in [study 20](20-p2-gpu-visibility-benchmark-2026-09-23.md) |
+| Optimized implementation | Commit `3be3d0de5f54c7a9afcab48f6e969ad56273a6a4` |
+| Optimized `src/render/renderer.cpp` SHA-256 | `0ebd863ff44fd7916244fb7b340407b27f50c048849c5df6c6f1f950b1d5dd1c` |
+| Original/staged-CAS `shaders/gpu_scene.slang` SHA-256 | `8fb7460ebcabc87a844fa2774f3bdad1d1f594a8d3b84d0a6881c9e439a35d98` |
+| Optimized `shaders/gpu_scene.slang` SHA-256 | `f58e86bfa8106364c70f26751f276793ca1dc02b34bab142c7ebea258e6102b3` |
+| Staged/final acceptance executable SHA-256 | `4750257d8c6484ece781578f9275bd9e8eeadb487d6a6527693f08f36c80c9d8` (the shader is loaded separately at runtime) |
+| Final SPIR-V manifest SHA-256 | `cac0fc853f106a2d15e15bf89b1b29136656e3936174369b91d61159cef023f2` (SHA-256 of lexically sorted `sha256sum build/linux-debug/shaders/*.spv` output) |
+| Machine | Ubuntu Linux 7.0.0-31-generic, Clang 21.1.8, NVIDIA GeForce RTX 2080 Ti, driver 595.84 |
+| Harness | CMake Debug, Vulkan validation and visibility diagnostics enabled, 320 × 240 synchronous capture; fixed direct → GPU-frustum → GPU-occlusion mode order |
+| Samples | Three sequential runs per variant; 10 warmup + 30 measured frames per scene/mode/run; 810 measured rows per variant |
+
+The device-local-only intermediate variant uses the optimized renderer source and the original compare-and-exchange shader. It therefore isolates memory placement before the final shader change. The raw, unmodified CSV captures are:
+
+- Baseline: [run 1](data/p2-2026-09-23-run-1.csv), [run 2](data/p2-2026-09-23-run-2.csv), [run 3](data/p2-2026-09-23-run-3.csv).
+- Device-local outputs with original CAS loop: [run 1](data/p2-2026-09-23-device-local-run-1.csv), [run 2](data/p2-2026-09-23-device-local-run-2.csv), [run 3](data/p2-2026-09-23-device-local-run-3.csv).
+- Device-local outputs with atomic add: [run 1](data/p2-2026-09-23-optimized-run-1.csv), [run 2](data/p2-2026-09-23-optimized-run-2.csv), [run 3](data/p2-2026-09-23-optimized-run-3.csv).
+
+P50 and p95 below pool 90 frames per scene/mode and use linear interpolation at sorted rank `(n - 1) × quantile`. All times are milliseconds. `gpu_ms` spans GPU commands, including the image-to-buffer capture copy; `cpu_ms` is the synchronous `Renderer::render` call, including submission and completion wait. Neither is a Player frame rate.
+
+| Scene | Mode | Baseline GPU p50 / p95 | Device-local CAS GPU p50 / p95 | Final GPU p50 / p95 | Final CPU p50 |
+| --- | --- | ---: | ---: | ---: | ---: |
+| Frustum-heavy | Direct | 0.241 / 0.268 | 0.235 / 0.271 | 0.235 / 0.300 | 68.57 |
+| Frustum-heavy | GPU frustum | 3.998 / 4.694 | 0.229 / 0.256 | 0.124 / 0.155 | 10.16 |
+| Frustum-heavy | GPU occlusion | 3.986 / 4.597 | 0.292 / 0.314 | 0.187 / 0.196 | 9.62 |
+| Open | Direct | 0.502 / 0.531 | 0.497 / 0.719 | 0.498 / 0.643 | 66.51 |
+| Open | GPU frustum | 18.081 / 19.207 | 0.477 / 0.508 | 0.139 / 0.158 | 10.18 |
+| Open | GPU occlusion | 18.359 / 19.183 | 0.544 / 0.558 | 0.204 / 0.238 | 9.39 |
+| Occluded | Direct | 0.499 / 0.554 | 0.496 / 0.528 | 0.496 / 0.531 | 66.96 |
+| Occluded | GPU frustum | 18.259 / 19.226 | 0.477 / 0.503 | 0.138 / 0.143 | 9.86 |
+| Occluded | GPU occlusion | 18.237 / 19.320 | 0.532 / 0.539 | 0.188 / 0.212 | 10.61 |
+
+The isolated `MainCull` pass provides a closer A/B for the two changes:
+
+| Scene and mode | Baseline p50 / p95 | Device-local CAS p50 / p95 | Final p50 / p95 |
+| --- | ---: | ---: | ---: |
+| Frustum-heavy, GPU frustum (416 visible) | 3.917 / 4.624 | 0.135 / 0.140 | 0.030 / 0.047 |
+| Open, GPU frustum (1,024 visible) | 17.956 / 19.120 | 0.368 / 0.373 | 0.030 / 0.032 |
+| Occluded, GPU occlusion (1,025 deferred) | 18.115 / 19.202 | 0.385 / 0.391 | 0.042 / 0.044 |
+
+All sampled visibility counts matched across the three variants: 416 frustum-visible, 1,024 open-visible, and 1,025 deferred with one main-visible in the occluded scene. All 2,430 measured frames across the three variants reported zero Vulkan validation errors. The final focused shader/reflection and GPU suite passed 18/18 tests, and `spirv-val --target-env vulkan1.3` accepted both culling shaders.
+
+## Cause and implementation
+
+The original `upload_scene_buffer` chose `HOST_VISIBLE | HOST_COHERENT` memory and preferred `HOST_CACHED` for every scene buffer. On this GPU, Vulkan memory type 4 has those flags on a non-device-local system-memory heap. The indirect command counters, deferred counter and visible-ID arrays were written by the GPU there. The shader also used a CAS retry loop to append into one bin: many invocations could read the same old count, one would advance it and the rest would retry. The occluded case spent about 18 ms in `MainCull` even though only one instance reached main raster, because 1,025 candidates contended on `deferredCount` instead.
+
+The renderer now allocates GPU-written indirect args, visible IDs and deferred buffers with `DEVICE_LOCAL` memory. Host-visible staging buffers supply the two indirect templates and zeroed deferred count through transfer copies before compute. An explicit transfer-to-compute/indirect barrier makes those copies visible. Diagnostic counts are copied back to the same staging buffers after culling and raster, with compute/transfer and transfer/host barriers; ordinary rendering still avoids counter readback. This path does not require a host-visible device-local BAR heap. Tracked allocation size for this one-bin fixture increased by just 48 bytes for the three minimum-size staging buffers; the important change is memory placement.
+
+The shader now uses one `InterlockedAdd` for each append. The host constructs each bin with capacity equal to its candidate count; each candidate index is dispatched once and can append at most once to main IDs. The separate post buffer receives only deferred candidates, also at most once each, and deferred capacity equals total candidate count. Thus valid generated input cannot overflow. A defensive overflow branch undoes the speculative increment before any draw consumes the count, retaining the bounded final indirect/deferred count if an invalid table is supplied.
+
+These timings are from one NVIDIA GPU, one small synthetic workload and a Debug build with validation, diagnostics and synchronous image capture. The fixed mode order, clock state and driver scheduling can affect p95 values. The full Release build and other desktop GPUs remain separate validation; the direct path remains the runtime fallback. GPU occlusion adds HZB/post overhead in an open scene with nothing to hide, so applications should select it based on workload rather than treating this synthetic GPU-frustum gain as universal.

docs/studies/README.md

@@ -1,6 +1,6 @@
 # Исследования для Faset Engine
 
-Обновлено 18.09.2026. Исходники и официальная документация исследовались прежде всего 17.09.2026; затем результаты согласованы с принятой архитектурой.
+Обновлено 23.09.2026. Исходники и официальная документация исследовались прежде всего 17.09.2026; затем результаты согласованы с принятой архитектурой. P2 implementation/acceptance добавлены позже и отделены от исходного статического исследования.
 
 **Актуальные решения — в [ARCHITECTURE.md](../ARCHITECTURE.md), порядок реализации — в [PLAN.md](../../PLAN.md).** Реализация MVP и проверки идут отдельно: [журнал реализации](../IMPLEMENTATION.md), [результаты проверок](../validation/README.md), [пользовательский Manual](../manual/index.md). Исследования дают обоснования и проверочные сценарии; их статический анализ не является измерением Faset.
 
@@ -34,16 +34,19 @@ Linux/Windows, десктопные 2D/3D, C++ сначала и Lua следу
 
 ## Углублённые технические материалы
 
-- [15 — GPU-driven renderer](15-renderer-implementation-notes.md): visibility, HZB, синхронизация и управление историей; этап после MVP.
+- [15 — GPU-driven renderer](15-renderer-implementation-notes.md): исходный проектный разбор visibility, HZB, синхронизации и управления историей для P2.
 - [16 — C++ gameplay и метаданные](16-native-gameplay-and-metadata.md): схемы, ABI, сериализация и будущий Lua.
 - [17 — Asset pipeline и Blender](17-asset-pipeline-and-blender-roundtrip.md): IDs, зависимости, reimport, overrides и физическая геометрия.
 - [18 — Сборка и доставка](18-build-cook-and-delivery.md): инкрементальность, cache, состав Player и единый BuildService.
+- [19 — P2 GPU visibility: протокол приёмки](19-p2-gpu-visibility-acceptance.md): GPU-сценарии, допуски сравнения и методика измерений; отделяет проверку реализации от предложений исследования 15.
+- [20 — P2 GPU visibility: первый benchmark](20-p2-gpu-visibility-benchmark-2026-09-23.md): три запуска, raw CSV, p50/p95 и границы интерпретации на Linux reference GPU.
+- [21 — P2 GPU visibility: оптимизация MainCull](21-p2-gpu-visibility-optimization-2026-09-23.md): отдельные измерения переноса выходных буферов в память GPU и замены CAS-цикла на atomic add.
 
 ## Происхождение и воспроизводимость
 
 [Манифест источников](source-manifest.json) фиксирует изученные версии и commits. Основные source-ссылки ведут на upstream-файлы конкретного commit с указанием строки; доступ к Unreal требует соответствующих прав Epic. Исходники сторонних движков не включены в этот репозиторий.
 
-Исследование статическое и выборочное: читались отдельные реализации и официальные документы. Движки не собирались, пользовательские UX-тесты и GPU-бенчмарки не выполнялись. UnityCsReference содержит C# reference source и bindings, а не весь native движок. Blender изучался через sparse checkout и выбранные удалённые файлы.
+Исходное сравнительное исследование статическое и выборочное: читались отдельные реализации и официальные документы. Сторонние движки не собирались, пользовательские UX-тесты и их GPU-бенчмарки не выполнялись. Позднейшие GPU-тесты и измерения **Faset P2** находятся отдельно в [протоколе 19](19-p2-gpu-visibility-acceptance.md), [исходном benchmark 20](20-p2-gpu-visibility-benchmark-2026-09-23.md) и [повторных измерениях 21](21-p2-gpu-visibility-optimization-2026-09-23.md); они не являются benchmark Unreal/Godot/Unity. UnityCsReference содержит C# reference source и bindings, а не весь native движок. Blender изучался через sparse checkout и выбранные удалённые файлы.
 
 [Карта](map/README.md) запускается на обычном clone Faset. Соседние checkout из manifest необязательны и нужны только для дополнительного локального просмотра исходников. Пути manifest считаются от корня проекта, а относительные Markdown-ссылки — от документа.
 

docs/studies/data/p2-2026-09-23-device-local-run-1.csv

@@ -0,0 +1,271 @@
+scenario,mode,frame,device,cpu_ms,gpu_ms,readback_cpu_ms,gpu_main_cull_ms,gpu_main_raster_ms,gpu_hzb_ms,gpu_post_cull_ms,gpu_post_raster_ms,gpu_bytes,draw_calls,gpu_bins,gpu_visible,gpu_frustum_rejected,gpu_deferred,gpu_post_visible,lod0,lod1,lod2,lod3,hzb_valid,gpu_visibility_active,visibility_diagnostics,visibility_counters_valid,validation_errors
+frustum,direct,0,"NVIDIA GeForce RTX 2080 Ti",64.7369,0.2504,0.054402,0,0.192576,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,1,"NVIDIA GeForce RTX 2080 Ti",63.368,0.23456,0.038002,0,0.19312,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,2,"NVIDIA GeForce RTX 2080 Ti",68.7446,0.234496,0.048792,0,0.193888,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,3,"NVIDIA GeForce RTX 2080 Ti",88.6936,0.235552,0.076023,0,0.193248,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,4,"NVIDIA GeForce RTX 2080 Ti",83.385,0.23472,0.046698,0,0.193344,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,5,"NVIDIA GeForce RTX 2080 Ti",94.1805,0.232992,0.048552,0,0.192128,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,6,"NVIDIA GeForce RTX 2080 Ti",93.3547,0.234208,0.07407,0,0.192512,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,7,"NVIDIA GeForce RTX 2080 Ti",88.7156,0.234656,0.036709,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,8,"NVIDIA GeForce RTX 2080 Ti",71.2425,0.234592,0.063289,0,0.192288,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,9,"NVIDIA GeForce RTX 2080 Ti",65.5611,0.273152,0.065132,0,0.194656,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,10,"NVIDIA GeForce RTX 2080 Ti",70.6167,0.236032,0.082916,0,0.194816,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,11,"NVIDIA GeForce RTX 2080 Ti",70.9857,0.35568,0.059061,0,0.313472,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,12,"NVIDIA GeForce RTX 2080 Ti",62.9898,0.235488,0.057709,0,0.194464,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,13,"NVIDIA GeForce RTX 2080 Ti",62.7431,0.233824,0.050105,0,0.193664,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,14,"NVIDIA GeForce RTX 2080 Ti",66.6032,0.234464,0.045456,0,0.194144,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,15,"NVIDIA GeForce RTX 2080 Ti",63.6998,0.235424,0.044263,0,0.19472,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,16,"NVIDIA GeForce RTX 2080 Ti",67.3859,0.237984,0.0428,0,0.19344,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,17,"NVIDIA GeForce RTX 2080 Ti",74.4489,0.234112,0.064631,0,0.192448,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,18,"NVIDIA GeForce RTX 2080 Ti",63.6063,0.235392,0.07947,0,0.193984,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,19,"NVIDIA GeForce RTX 2080 Ti",64.6958,0.233888,0.045556,0,0.193152,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,20,"NVIDIA GeForce RTX 2080 Ti",73.6784,0.23456,0.050055,0,0.193888,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,21,"NVIDIA GeForce RTX 2080 Ti",74.9121,0.236288,0.055936,0,0.195008,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,22,"NVIDIA GeForce RTX 2080 Ti",73.1098,0.235808,0.040657,0,0.194688,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,23,"NVIDIA GeForce RTX 2080 Ti",77.3535,0.233856,0.075092,0,0.192608,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,24,"NVIDIA GeForce RTX 2080 Ti",79.1919,0.235392,0.055315,0,0.194272,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,25,"NVIDIA GeForce RTX 2080 Ti",62.4817,0.26864,0.049633,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,26,"NVIDIA GeForce RTX 2080 Ti",99.6139,0.234144,0.046428,0,0.193664,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,27,"NVIDIA GeForce RTX 2080 Ti",82.3882,0.233664,0.054944,0,0.192544,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,28,"NVIDIA GeForce RTX 2080 Ti",78.9223,0.233568,0.047109,0,0.19232,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,29,"NVIDIA GeForce RTX 2080 Ti",69.8094,0.247936,0.055374,0,0.196032,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",11.3878,0.22704,0.052209,0.132672,0.027072,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",10.0089,0.227232,0.043762,0.131904,0.028096,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",8.79895,0.227136,0.061266,0.132896,0.026848,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",10.614,0.230016,0.062888,0.133184,0.029472,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",9.94614,0.226432,0.039584,0.133056,0.026624,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",7.97747,0.22752,0.039244,0.132768,0.028,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",10.45,0.22768,0.054172,0.132864,0.027968,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",15.4813,0.228064,0.051798,0.132864,0.02864,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",19.1343,0.227584,0.067537,0.13232,0.027456,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",10.5612,0.228672,0.051387,0.13168,0.028672,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",9.25929,0.22768,0.043152,0.133088,0.026848,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",8.61202,0.22752,0.054403,0.131968,0.027776,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",9.49408,0.2272,0.044293,0.1328,0.026944,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",9.41893,0.227712,0.056958,0.133024,0.027104,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",8.75524,0.227168,0.041859,0.132512,0.027232,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",8.34356,0.226592,0.03172,0.132128,0.027616,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",9.65642,0.226656,0.038502,0.132544,0.0272,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",13.3711,0.2264,0.056146,0.13264,0.027104,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",15.465,0.227648,0.297992,0.133024,0.02816,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",11.8874,0.225792,0.045256,0.131232,0.027296,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",10.6097,0.227488,0.067969,0.132768,0.028416,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",10.1786,0.258976,0.048421,0.15008,0.040544,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",10.3399,0.227776,0.059563,0.132864,0.027104,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",10.8591,0.227808,0.145585,0.132992,0.028224,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",15.4076,0.227232,0.050565,0.132448,0.02864,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",19.435,0.251008,0.049082,0.141152,0.027616,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",11.4523,0.227296,0.056957,0.132192,0.027552,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",10.047,0.226496,0.056437,0.131104,0.0272,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",11.0989,0.226208,0.051296,0.132288,0.027424,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",9.08145,0.22624,0.048632,0.132192,0.027104,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",9.28272,0.328608,0.057308,0.163104,0.0376,0.04656,0.00544,0.007392,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",13.3575,0.289984,0.05322,0.142176,0.027808,0.042304,0.004736,0.006208,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",11.2017,0.288864,0.052078,0.142464,0.026816,0.041664,0.005248,0.006592,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",12.8998,0.289248,0.065103,0.141856,0.02608,0.042848,0.0048,0.00704,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",12.2266,0.290368,0.067627,0.142496,0.026624,0.041824,0.005024,0.007264,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",10.9485,0.290368,0.06858,0.142432,0.0264,0.042688,0.0048,0.00576,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",14.1092,0.292704,0.078528,0.14336,0.02832,0.041312,0.005216,0.006656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",12.1819,0.289504,0.058791,0.142464,0.026944,0.041536,0.005248,0.006752,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",11.33,0.288672,0.051627,0.142368,0.026784,0.041568,0.004768,0.00672,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",11.8178,0.289504,0.043251,0.143296,0.026624,0.041024,0.005472,0.006816,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",10.4058,0.331424,0.383844,0.162976,0.038976,0.046176,0.00608,0.007808,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",14.9896,0.29136,0.050125,0.1432,0.02688,0.04256,0.004768,0.006304,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",14.1634,0.290944,0.066596,0.142336,0.027264,0.041504,0.00576,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",13.259,0.292256,0.044735,0.142464,0.028352,0.04224,0.004768,0.006432,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",11.3007,0.290016,0.072327,0.143008,0.02672,0.041216,0.005696,0.006592,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",11.2246,0.291296,0.056858,0.143328,0.026784,0.041664,0.004768,0.007104,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",9.65399,0.290048,0.056176,0.142464,0.027424,0.042112,0.004736,0.006464,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",10.6734,0.2912,0.063049,0.142816,0.027168,0.042816,0.0048,0.007072,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",9.75997,0.291392,0.065534,0.143392,0.028064,0.04144,0.005472,0.006784,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",12.1279,0.291232,0.050967,0.143264,0.02656,0.041824,0.005376,0.006912,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",8.97511,0.287776,0.041578,0.141632,0.026528,0.04128,0.005152,0.006592,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",13.2647,0.293184,0.046147,0.140896,0.027232,0.04288,0.00544,0.006976,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",19.9757,0.29088,0.055525,0.142176,0.027232,0.041536,0.005568,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",11.1957,0.289792,0.052108,0.14176,0.026464,0.043008,0.005088,0.00656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",10.7553,0.289696,0.047459,0.141536,0.026688,0.043008,0.0048,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",10.7883,0.312192,0.043602,0.166048,0.026464,0.042176,0.004768,0.006304,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",10.4271,0.289024,0.044023,0.141888,0.027232,0.041856,0.004736,0.00656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",11.4354,0.299488,0.179438,0.142464,0.02752,0.042944,0.0048,0.00656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",11.8168,0.290944,0.058931,0.1424,0.0264,0.043008,0.005568,0.00672,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",10.7853,0.288864,0.038302,0.141664,0.026784,0.042272,0.0048,0.006176,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+open,direct,0,"NVIDIA GeForce RTX 2080 Ti",60.6186,0.495552,0.051106,0,0.454656,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,1,"NVIDIA GeForce RTX 2080 Ti",60.407,0.494176,0.05302,0,0.452608,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,2,"NVIDIA GeForce RTX 2080 Ti",75.2325,0.499616,0.06923,0,0.456704,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,3,"NVIDIA GeForce RTX 2080 Ti",57.7167,0.499424,0.046328,0,0.458752,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,4,"NVIDIA GeForce RTX 2080 Ti",69.319,0.49504,0.106641,0,0.45376,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,5,"NVIDIA GeForce RTX 2080 Ti",70.6653,0.515456,0.093356,0,0.468416,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,6,"NVIDIA GeForce RTX 2080 Ti",76.4978,0.776224,0.057158,0,0.73376,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,7,"NVIDIA GeForce RTX 2080 Ti",80.5693,0.499776,0.052028,0,0.45872,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,8,"NVIDIA GeForce RTX 2080 Ti",82.8471,0.66272,0.053872,0,0.620544,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,9,"NVIDIA GeForce RTX 2080 Ti",66.3484,0.498592,0.047169,0,0.458336,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,10,"NVIDIA GeForce RTX 2080 Ti",71.2127,0.493728,0.046888,0,0.452608,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,11,"NVIDIA GeForce RTX 2080 Ti",71.7612,0.498336,0.046197,0,0.455808,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,12,"NVIDIA GeForce RTX 2080 Ti",72.9155,0.497696,0.044524,0,0.455648,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,13,"NVIDIA GeForce RTX 2080 Ti",78.4236,0.497024,0.039645,0,0.456352,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,14,"NVIDIA GeForce RTX 2080 Ti",75.2765,0.494496,0.053591,0,0.453792,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,15,"NVIDIA GeForce RTX 2080 Ti",68.2154,0.498752,0.070353,0,0.457152,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,16,"NVIDIA GeForce RTX 2080 Ti",66.636,0.529408,0.040216,0,0.458208,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,17,"NVIDIA GeForce RTX 2080 Ti",62.7475,0.493056,0.038072,0,0.449536,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,18,"NVIDIA GeForce RTX 2080 Ti",57.2225,0.495744,0.042149,0,0.453152,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,19,"NVIDIA GeForce RTX 2080 Ti",67.089,0.498208,0.037771,0,0.456704,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,20,"NVIDIA GeForce RTX 2080 Ti",66.4552,0.497632,0.065594,0,0.456352,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,21,"NVIDIA GeForce RTX 2080 Ti",62.5136,0.497792,0.054623,0,0.456704,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,22,"NVIDIA GeForce RTX 2080 Ti",69.6982,0.494816,0.058972,0,0.452736,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,23,"NVIDIA GeForce RTX 2080 Ti",69.7756,0.497024,0.147558,0,0.45504,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,24,"NVIDIA GeForce RTX 2080 Ti",60.633,0.49872,0.039875,0,0.458432,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,25,"NVIDIA GeForce RTX 2080 Ti",77.2821,0.497376,0.044734,0,0.454656,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,26,"NVIDIA GeForce RTX 2080 Ti",69.4411,0.49632,0.056446,0,0.45456,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,27,"NVIDIA GeForce RTX 2080 Ti",63.1202,0.535808,0.045747,0,0.46256,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,28,"NVIDIA GeForce RTX 2080 Ti",73.1914,0.49824,0.059101,0,0.456704,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,29,"NVIDIA GeForce RTX 2080 Ti",65.5302,0.764576,0.04238,0,0.722624,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",10.3939,0.475168,0.077767,0.366368,0.041344,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",10.8594,0.476544,0.052038,0.36848,0.041088,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",10.4828,0.474944,0.050475,0.367296,0.041184,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",10.7749,0.476,0.056036,0.36784,0.041088,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",13.5022,0.473824,0.094568,0.366112,0.040832,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",17.3703,0.48144,0.060554,0.373856,0.040992,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",10.5529,0.478368,0.050816,0.368928,0.041952,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",15.6407,0.47904,0.061797,0.370144,0.04144,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",10.7748,0.477664,0.070913,0.368352,0.041792,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",9.76799,0.47744,0.054513,0.367584,0.040128,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",9.42063,0.47776,0.059002,0.370176,0.041312,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",9.44758,0.476288,0.061656,0.367424,0.042176,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",11.5227,0.469056,0.041769,0.3608,0.040608,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",8.94197,0.475712,0.038192,0.368448,0.040928,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",10.4662,0.476768,0.051437,0.368736,0.040896,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",18.9526,0.476672,0.051978,0.368352,0.04112,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",11.2872,0.475552,0.039074,0.368032,0.041152,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",11.6188,0.477056,0.044775,0.36896,0.041024,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",11.9754,0.475456,0.065163,0.36672,0.040864,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",9.64002,0.47088,0.038803,0.362464,0.04128,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",9.02811,0.476832,0.033143,0.368768,0.040832,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",13.4991,0.476992,0.048622,0.369568,0.040032,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",14.6902,0.47296,0.192823,0.364672,0.040928,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",10.1379,0.47968,0.050385,0.371776,0.041408,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",8.5759,0.523296,0.046688,0.382976,0.069696,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",8.12712,0.474304,0.030979,0.366272,0.041056,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",8.39928,0.476512,0.045005,0.367904,0.0416,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",8.69837,0.500544,0.03693,0.365728,0.058048,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",8.41133,0.46624,0.055034,0.358016,0.041184,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",9.02985,0.4752,0.044093,0.367168,0.040576,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",9.2217,0.577696,0.045296,0.383808,0.05232,0.063488,0.005632,0.00656,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",8.81264,0.543904,0.05816,0.38032,0.041568,0.043008,0.005152,0.00704,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",8.44976,0.543328,0.040677,0.382752,0.040608,0.041536,0.005568,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",13.7218,0.541248,0.045566,0.37952,0.041216,0.04224,0.004736,0.006336,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",17.2713,0.554912,0.100559,0.382592,0.042432,0.043296,0.005216,0.007744,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",11.9484,0.546624,0.056317,0.38432,0.041184,0.041504,0.005504,0.006784,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",9.01832,0.54336,0.034776,0.382272,0.040192,0.04288,0.004736,0.005632,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",8.76038,0.53936,0.095801,0.376576,0.041216,0.043008,0.00496,0.006592,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",8.59985,0.544448,0.03699,0.383232,0.040704,0.042752,0.004736,0.00576,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",8.82441,0.542112,0.043492,0.38096,0.040768,0.042176,0.004736,0.006496,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",8.22824,0.560704,0.035357,0.383968,0.040832,0.042784,0.004768,0.005696,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",10.9933,0.544192,0.049814,0.38256,0.040608,0.041888,0.004896,0.006752,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",22.6801,0.539744,0.074992,0.379008,0.040512,0.04128,0.005664,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",11.129,0.548288,0.042029,0.386656,0.041216,0.041504,0.00544,0.006592,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",8.9006,0.543488,0.082365,0.382944,0.0408,0.042464,0.004736,0.006176,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",8.4634,0.543168,0.035788,0.382816,0.040512,0.041568,0.005152,0.00656,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",8.55644,0.544928,0.05284,0.382592,0.041344,0.04272,0.004832,0.005696,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",10.6859,0.543744,0.051307,0.382016,0.041248,0.041632,0.005536,0.006592,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",10.6034,0.54544,0.059462,0.384096,0.041184,0.041664,0.005504,0.00656,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",10.5554,0.54224,0.043382,0.38032,0.041088,0.04144,0.005024,0.007264,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",9.47453,0.536256,0.04757,0.375744,0.040992,0.041984,0.005216,0.006592,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",11.9249,0.542496,0.03712,0.381088,0.040864,0.041344,0.005728,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",10.17,0.543424,0.037501,0.383168,0.040736,0.040992,0.005696,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",11.4037,0.54464,0.062879,0.382208,0.041568,0.041312,0.005344,0.006944,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",10.0585,0.54592,0.038202,0.384256,0.040896,0.041792,0.00528,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",7.93333,0.541952,0.034284,0.38112,0.040736,0.041088,0.005696,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",8.71938,0.57744,0.085101,0.380576,0.041312,0.042272,0.007456,0.01376,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",8.67038,0.539392,0.041167,0.377248,0.0408,0.042528,0.004704,0.006016,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",8.96206,0.545408,0.050745,0.383168,0.040928,0.042112,0.00496,0.006176,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",8.98123,0.544864,0.053621,0.382784,0.041248,0.041888,0.005056,0.006752,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+occluded,direct,0,"NVIDIA GeForce RTX 2080 Ti",62.7887,0.494112,0.067427,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,1,"NVIDIA GeForce RTX 2080 Ti",71.2959,0.497792,0.044814,0,0.456704,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,2,"NVIDIA GeForce RTX 2080 Ti",68.7389,0.496,0.04228,0,0.454976,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,3,"NVIDIA GeForce RTX 2080 Ti",69.895,0.494656,0.033503,0,0.453024,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,4,"NVIDIA GeForce RTX 2080 Ti",71.9031,0.526496,0.061556,0,0.4608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,5,"NVIDIA GeForce RTX 2080 Ti",72.2054,0.49392,0.044263,0,0.452704,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,6,"NVIDIA GeForce RTX 2080 Ti",60.6895,0.497376,0.046187,0,0.456288,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,7,"NVIDIA GeForce RTX 2080 Ti",69.7308,0.497088,0.062047,0,0.454848,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,8,"NVIDIA GeForce RTX 2080 Ti",61.1452,0.49456,0.042159,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,9,"NVIDIA GeForce RTX 2080 Ti",62.0544,0.495104,0.041068,0,0.453824,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,10,"NVIDIA GeForce RTX 2080 Ti",65.4676,0.498496,0.034495,0,0.457728,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,11,"NVIDIA GeForce RTX 2080 Ti",65.3146,0.49488,0.048592,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,12,"NVIDIA GeForce RTX 2080 Ti",64.8816,0.4952,0.078649,0,0.45424,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,13,"NVIDIA GeForce RTX 2080 Ti",64.5143,0.495968,0.034535,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,14,"NVIDIA GeForce RTX 2080 Ti",60.3862,0.49776,0.046298,0,0.456608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,15,"NVIDIA GeForce RTX 2080 Ti",78.1539,0.494336,0.040426,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,16,"NVIDIA GeForce RTX 2080 Ti",73.6354,0.492224,0.054803,0,0.45056,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,17,"NVIDIA GeForce RTX 2080 Ti",67.193,0.495904,0.049103,0,0.454432,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,18,"NVIDIA GeForce RTX 2080 Ti",59.0953,0.498208,0.040075,0,0.45696,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,19,"NVIDIA GeForce RTX 2080 Ti",73.2946,0.495648,0.063169,0,0.45424,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,20,"NVIDIA GeForce RTX 2080 Ti",66.2624,0.495328,0.044845,0,0.4544,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,21,"NVIDIA GeForce RTX 2080 Ti",60.5294,0.496544,0.053211,0,0.456704,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,22,"NVIDIA GeForce RTX 2080 Ti",66.6714,0.493984,0.041539,0,0.452352,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,23,"NVIDIA GeForce RTX 2080 Ti",63.6081,0.496448,0.04788,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,24,"NVIDIA GeForce RTX 2080 Ti",65.3215,0.496992,0.051136,0,0.456512,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,25,"NVIDIA GeForce RTX 2080 Ti",70.3609,0.498144,0.038172,0,0.456704,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,26,"NVIDIA GeForce RTX 2080 Ti",62.9826,0.495808,0.067708,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,27,"NVIDIA GeForce RTX 2080 Ti",62.0386,0.498624,0.062418,0,0.458176,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,28,"NVIDIA GeForce RTX 2080 Ti",65.4245,0.528992,0.037009,0,0.458688,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,29,"NVIDIA GeForce RTX 2080 Ti",57.2899,0.496224,0.04233,0,0.4544,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",10.8556,0.483776,0.051727,0.3728,0.042944,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",10.4682,0.526304,0.059923,0.383776,0.071776,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",9.92771,0.479168,0.042059,0.36784,0.04384,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",9.82401,0.47616,0.053331,0.3688,0.040768,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",18.0177,0.476736,0.046688,0.367072,0.041088,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",15.1037,0.480128,0.061456,0.367872,0.044192,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",8.81297,0.477952,0.040036,0.366816,0.044672,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",9.66996,0.480256,0.03704,0.370016,0.04304,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",9.38014,0.474816,0.039805,0.364992,0.042688,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",11.399,0.478112,0.040537,0.366048,0.044512,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",8.47033,0.504928,0.040437,0.394688,0.04224,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",11.4359,0.47936,0.061997,0.36848,0.043168,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",13.9495,0.477728,0.04768,0.36608,0.04464,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",18.0044,0.475328,0.047319,0.36704,0.0416,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",10,0.475232,0.053261,0.363456,0.044384,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",10.9689,0.4728,0.045556,0.364704,0.040992,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",7.75412,0.476672,0.034415,0.365824,0.043904,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",9.24324,0.476416,0.060083,0.365984,0.043488,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",8.995,0.477088,0.038533,0.367008,0.042912,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",9.27244,0.477632,0.039384,0.366944,0.043392,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",7.73096,0.478912,0.038232,0.366752,0.045152,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",7.83677,0.474912,0.031198,0.36448,0.04304,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",11.1474,0.475904,0.049704,0.365632,0.043872,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",19.9123,0.47664,0.085702,0.365632,0.042016,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",10.7275,0.475744,0.031479,0.365984,0.042176,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",9.24285,0.477248,0.038623,0.367744,0.043456,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",9.16257,0.521984,0.060664,0.380768,0.072192,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",9.19834,0.475808,0.032481,0.364896,0.04336,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",8.29114,0.476448,0.043693,0.364896,0.044704,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",8.96529,0.478496,0.040246,0.3672,0.044448,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",8.03895,0.531904,0.043092,0.38544,0.018016,0.042912,0.012608,0.00592,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",7.60839,0.529888,0.029405,0.384032,0.01888,0.041504,0.012992,0.006528,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",9.51517,0.535296,0.090852,0.387296,0.01888,0.042784,0.012512,0.006144,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",10.9287,0.55728,0.056427,0.408736,0.019104,0.041312,0.013088,0.006688,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",8.24349,0.531008,0.040286,0.384256,0.018848,0.041696,0.012128,0.007456,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",9.11451,0.531904,0.042741,0.3856,0.019264,0.0416,0.012832,0.0056,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",8.38955,0.53056,0.039865,0.383552,0.018336,0.043008,0.012352,0.00608,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",8.283,0.532448,0.041027,0.386752,0.018688,0.042144,0.01248,0.006528,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",12.2057,0.533408,0.040897,0.38656,0.018784,0.042464,0.012448,0.006624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",12.5381,0.534016,0.067417,0.383904,0.019712,0.042656,0.01264,0.007456,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",12.464,0.529568,0.045836,0.382016,0.018336,0.042816,0.012224,0.0064,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",10.9873,0.565024,0.053521,0.40064,0.0192,0.042784,0.02448,0.006464,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",10.1212,0.537248,0.044764,0.38848,0.0192,0.042112,0.012384,0.006752,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",10.0635,0.53232,0.049804,0.384352,0.01936,0.042208,0.012384,0.006528,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",8.37142,0.529184,0.039244,0.382176,0.018848,0.041344,0.013344,0.006528,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",9.09023,0.534688,0.055835,0.386816,0.018688,0.043008,0.012672,0.006912,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",11.6111,0.532224,0.043041,0.385472,0.01904,0.041952,0.012512,0.00592,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",13.9289,0.532864,0.045265,0.38608,0.019392,0.042496,0.012416,0.006528,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",12.422,0.530048,0.057359,0.382592,0.019136,0.04144,0.013056,0.006624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",10.0768,0.529824,0.049032,0.382624,0.018784,0.04096,0.013088,0.0072,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",8.39461,0.539648,0.032992,0.388928,0.022624,0.04176,0.012576,0.005856,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",9.73943,0.531296,0.059702,0.38352,0.019488,0.041408,0.013248,0.006752,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",8.51903,0.53248,0.034986,0.385792,0.019328,0.041344,0.01344,0.006592,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",8.4197,0.530016,0.03719,0.383168,0.01824,0.042752,0.012416,0.006272,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",8.00373,0.531648,0.035457,0.384544,0.018912,0.041888,0.012832,0.006624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",8.2458,0.531168,0.043983,0.383904,0.01824,0.043008,0.012032,0.0064,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",10.0695,0.532992,0.041989,0.38528,0.01856,0.042784,0.012608,0.006048,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",12.4824,0.52944,0.048752,0.383968,0.0184,0.041984,0.012512,0.00592,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",11.1743,0.534944,0.061466,0.38736,0.019232,0.04192,0.012928,0.006624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",11.4361,0.533824,0.038673,0.386368,0.019232,0.04176,0.013024,0.00656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0

docs/studies/data/p2-2026-09-23-device-local-run-2.csv

@@ -0,0 +1,271 @@
+scenario,mode,frame,device,cpu_ms,gpu_ms,readback_cpu_ms,gpu_main_cull_ms,gpu_main_raster_ms,gpu_hzb_ms,gpu_post_cull_ms,gpu_post_raster_ms,gpu_bytes,draw_calls,gpu_bins,gpu_visible,gpu_frustum_rejected,gpu_deferred,gpu_post_visible,lod0,lod1,lod2,lod3,hzb_valid,gpu_visibility_active,visibility_diagnostics,visibility_counters_valid,validation_errors
+frustum,direct,0,"NVIDIA GeForce RTX 2080 Ti",71.0127,0.311872,0.04248,0,0.270336,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,1,"NVIDIA GeForce RTX 2080 Ti",78.8508,0.235392,0.248779,0,0.194528,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,2,"NVIDIA GeForce RTX 2080 Ti",89.1687,0.2728,0.068139,0,0.196608,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,3,"NVIDIA GeForce RTX 2080 Ti",70.5527,0.235936,0.059021,0,0.194464,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,4,"NVIDIA GeForce RTX 2080 Ti",68.7177,0.269248,0.052199,0,0.198144,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,5,"NVIDIA GeForce RTX 2080 Ti",84.3036,0.234688,0.041949,0,0.192864,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,6,"NVIDIA GeForce RTX 2080 Ti",69.2441,0.232384,0.076214,0,0.191616,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,7,"NVIDIA GeForce RTX 2080 Ti",74.6042,0.235232,0.050846,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,8,"NVIDIA GeForce RTX 2080 Ti",74.2708,0.23584,0.048051,0,0.193504,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,9,"NVIDIA GeForce RTX 2080 Ti",74.8286,0.234272,0.048231,0,0.193728,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,10,"NVIDIA GeForce RTX 2080 Ti",77.2897,0.234752,0.061296,0,0.192896,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,11,"NVIDIA GeForce RTX 2080 Ti",81.6145,0.233632,0.049333,0,0.192512,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,12,"NVIDIA GeForce RTX 2080 Ti",77.6506,0.236416,0.058109,0,0.19488,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,13,"NVIDIA GeForce RTX 2080 Ti",81.1084,0.235296,0.071344,0,0.19424,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,14,"NVIDIA GeForce RTX 2080 Ti",87.1548,0.233536,0.052218,0,0.193568,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,15,"NVIDIA GeForce RTX 2080 Ti",85.0074,0.23488,0.068419,0,0.192832,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,16,"NVIDIA GeForce RTX 2080 Ti",75.7102,0.234912,0.056046,0,0.192512,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,17,"NVIDIA GeForce RTX 2080 Ti",83.8865,0.233696,0.059062,0,0.193728,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,18,"NVIDIA GeForce RTX 2080 Ti",69.5082,0.233312,0.039965,0,0.192608,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,19,"NVIDIA GeForce RTX 2080 Ti",68.2242,0.234048,0.044393,0,0.192928,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,20,"NVIDIA GeForce RTX 2080 Ti",72.7151,0.234464,0.041258,0,0.193248,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,21,"NVIDIA GeForce RTX 2080 Ti",82.0281,0.236736,0.034976,0,0.194432,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,22,"NVIDIA GeForce RTX 2080 Ti",86.2229,0.235264,0.046397,0,0.194304,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,23,"NVIDIA GeForce RTX 2080 Ti",90.2785,0.235744,0.062478,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,24,"NVIDIA GeForce RTX 2080 Ti",93.2652,0.235008,0.05822,0,0.193248,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,25,"NVIDIA GeForce RTX 2080 Ti",77.9207,0.235264,0.044304,0,0.193248,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,26,"NVIDIA GeForce RTX 2080 Ti",78.4134,0.235616,0.050585,0,0.194304,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,27,"NVIDIA GeForce RTX 2080 Ti",72.4479,0.236288,0.063129,0,0.194784,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,28,"NVIDIA GeForce RTX 2080 Ti",82.6376,0.252672,0.051898,0,0.19392,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,29,"NVIDIA GeForce RTX 2080 Ti",70.9828,0.235168,0.034926,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",8.78598,0.228672,0.046217,0.135232,0.026432,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",10.4128,0.228096,0.055014,0.133952,0.027008,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",13.7304,0.23024,0.06367,0.136032,0.027104,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",12.3014,0.228096,0.047209,0.134528,0.02576,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",12.8145,0.2288,0.07994,0.135232,0.026464,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",8.61497,0.227936,0.038233,0.134208,0.025888,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",10.3034,0.227968,0.049824,0.134496,0.02576,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",12.0394,0.228864,0.057308,0.135136,0.026656,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",15.1018,0.228,0.052869,0.135424,0.026368,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",12.3695,0.228768,0.060444,0.134528,0.026944,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",10.5688,0.230592,0.135205,0.135232,0.027008,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",9.59937,0.229408,0.054603,0.135264,0.026528,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",9.23911,0.229888,0.039574,0.135936,0.026272,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",7.36684,0.22768,0.041969,0.134272,0.026176,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",7.34062,0.227392,0.046298,0.133952,0.026176,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",9.12895,0.2272,0.038032,0.134336,0.02592,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",8.00057,0.227232,0.043272,0.134528,0.025504,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",12.3728,0.226944,0.044504,0.133728,0.026112,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",14.1646,0.227904,0.045796,0.134976,0.026208,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",10.9364,0.234368,0.040416,0.133792,0.026784,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",8.38385,0.227552,0.183396,0.133632,0.026784,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",10.9046,0.227136,0.047479,0.133792,0.02592,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",7.19849,0.226656,0.039003,0.134336,0.025408,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",8.56135,0.22784,0.049343,0.134688,0.02608,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",7.7272,0.259744,0.047229,0.151136,0.039264,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",8.20558,0.226944,0.044093,0.134464,0.026432,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",13.3389,0.228544,0.053931,0.135648,0.026144,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",18.6329,0.2304,0.056376,0.135456,0.026336,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",9.99333,0.228448,0.049754,0.135424,0.025952,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",8.18819,0.228192,0.044113,0.134368,0.025952,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",9.70103,0.292448,0.03675,0.144576,0.027456,0.042592,0.004768,0.005888,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",11.0291,0.2968,0.051778,0.145824,0.028288,0.042432,0.00528,0.006496,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",11.91,0.308704,0.04737,0.144256,0.027872,0.042752,0.004896,0.006048,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",10.1297,0.293792,0.045045,0.145088,0.028672,0.04128,0.005536,0.006592,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",11.8952,0.29152,0.056066,0.144128,0.027552,0.041312,0.005184,0.007104,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",12.7625,0.32688,0.046337,0.1432,0.028576,0.041216,0.016576,0.01824,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",11.9295,0.291776,0.040386,0.143424,0.027488,0.042592,0.004736,0.00592,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",12.953,0.293248,0.046809,0.143712,0.028128,0.042336,0.0048,0.006368,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",10.4498,0.293312,0.054533,0.145312,0.027936,0.041792,0.005312,0.006688,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",11.6785,0.293824,0.04233,0.144416,0.02784,0.042912,0.004736,0.0056,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",10.6663,0.293216,0.061035,0.144128,0.027904,0.042272,0.0048,0.006176,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",9.51515,0.292224,0.033002,0.144,0.027872,0.041248,0.005664,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",8.97953,0.293248,0.046728,0.144448,0.027712,0.04208,0.005056,0.006112,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",9.20476,0.294784,0.045606,0.14544,0.02864,0.04288,0.004736,0.005632,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",13.0593,0.293056,0.048161,0.144192,0.0288,0.04096,0.005664,0.00656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",12.0821,0.292576,0.05812,0.143616,0.026944,0.043008,0.004992,0.006656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",16.3491,0.295104,0.073378,0.144576,0.02896,0.041568,0.005824,0.006464,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",17.9732,0.294944,0.067768,0.14544,0.028416,0.041952,0.004992,0.006912,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",12.7518,0.295712,0.054664,0.145568,0.028672,0.041632,0.006016,0.006272,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",12.1551,0.293984,0.079981,0.14448,0.02784,0.042496,0.004864,0.007328,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",11.1806,0.294592,0.050516,0.145984,0.028288,0.041344,0.005344,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",12.7806,0.291616,0.045977,0.14304,0.027392,0.04144,0.00576,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",10.869,0.293504,0.0373,0.1448,0.027232,0.042848,0.004736,0.005664,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",12.829,0.30736,0.046528,0.143232,0.036832,0.045536,0.005536,0.006752,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",10.4788,0.294784,0.046527,0.145696,0.029376,0.041952,0.004864,0.006624,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",9.58928,0.295776,0.045325,0.144192,0.028,0.043392,0.005024,0.006912,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",8.68274,0.292576,0.05284,0.144256,0.027776,0.042976,0.004864,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",8.50438,0.315872,0.046107,0.166816,0.02848,0.041024,0.005696,0.006592,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",8.34061,0.291648,0.039535,0.14352,0.027392,0.04256,0.0048,0.005888,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",8.48612,0.292256,0.049263,0.144,0.027872,0.0424,0.0048,0.006208,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+open,direct,0,"NVIDIA GeForce RTX 2080 Ti",71.8804,0.521184,0.108655,0,0.462464,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,1,"NVIDIA GeForce RTX 2080 Ti",68.4413,0.49472,0.037431,0,0.454656,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,2,"NVIDIA GeForce RTX 2080 Ti",75.9111,0.49488,0.071094,0,0.453984,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,3,"NVIDIA GeForce RTX 2080 Ti",73.8367,0.49536,0.044995,0,0.454816,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,4,"NVIDIA GeForce RTX 2080 Ti",66.1784,0.529024,0.060093,0,0.45824,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,5,"NVIDIA GeForce RTX 2080 Ti",69.3696,0.538592,0.046297,0,0.467904,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,6,"NVIDIA GeForce RTX 2080 Ti",71.7722,0.49808,0.076985,0,0.455872,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,7,"NVIDIA GeForce RTX 2080 Ti",66.1807,0.496512,0.044734,0,0.456608,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,8,"NVIDIA GeForce RTX 2080 Ti",62.9343,0.493024,0.043071,0,0.451584,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,9,"NVIDIA GeForce RTX 2080 Ti",69.4768,0.49648,0.056877,0,0.455872,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,10,"NVIDIA GeForce RTX 2080 Ti",73.0257,0.493408,0.045125,0,0.453024,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,11,"NVIDIA GeForce RTX 2080 Ti",70.748,0.4928,0.071585,0,0.452608,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,12,"NVIDIA GeForce RTX 2080 Ti",75.1762,0.795744,0.048581,0,0.753664,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,13,"NVIDIA GeForce RTX 2080 Ti",63.2562,0.49408,0.054943,0,0.45424,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,14,"NVIDIA GeForce RTX 2080 Ti",62.1229,0.495808,0.039695,0,0.45456,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,15,"NVIDIA GeForce RTX 2080 Ti",69.3232,0.764192,0.050906,0,0.721152,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,16,"NVIDIA GeForce RTX 2080 Ti",66.662,0.495136,0.052188,0,0.455872,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,17,"NVIDIA GeForce RTX 2080 Ti",59.3466,0.493088,0.035948,0,0.45248,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,18,"NVIDIA GeForce RTX 2080 Ti",70.8032,0.537024,0.03159,0,0.458272,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,19,"NVIDIA GeForce RTX 2080 Ti",64.5934,0.514528,0.041428,0,0.465312,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,20,"NVIDIA GeForce RTX 2080 Ti",67.1224,0.497792,0.035106,0,0.457792,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,21,"NVIDIA GeForce RTX 2080 Ti",67.8875,0.49392,0.049513,0,0.452192,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,22,"NVIDIA GeForce RTX 2080 Ti",62.0733,0.494336,0.049023,0,0.454016,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,23,"NVIDIA GeForce RTX 2080 Ti",62.1564,0.49392,0.059843,0,0.453856,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,24,"NVIDIA GeForce RTX 2080 Ti",68.4279,0.496192,0.039995,0,0.454848,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,25,"NVIDIA GeForce RTX 2080 Ti",60.9137,0.496672,0.049864,0,0.456288,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,26,"NVIDIA GeForce RTX 2080 Ti",76.188,0.498272,0.048291,0,0.457408,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,27,"NVIDIA GeForce RTX 2080 Ti",68.4783,0.4928,0.039515,0,0.452512,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,28,"NVIDIA GeForce RTX 2080 Ti",67.126,0.495712,0.050045,0,0.455008,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,29,"NVIDIA GeForce RTX 2080 Ti",59.9943,0.491712,0.039584,0,0.450752,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",11.011,0.475136,0.038353,0.366496,0.041472,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",11.1128,0.477568,0.049333,0.368416,0.041504,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",13.1614,0.477184,0.061636,0.368448,0.041248,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",15.6951,0.51232,0.057378,0.371904,0.071136,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",10.4804,0.477408,0.050575,0.368992,0.040608,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",9.01791,0.476672,0.056737,0.368512,0.041088,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",8.78346,0.478048,0.050525,0.369376,0.041664,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",10.8859,0.478752,0.050786,0.369696,0.041728,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",10.839,0.47968,0.05308,0.370432,0.041696,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",10.9418,0.477056,0.060374,0.368064,0.041792,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",10.6136,0.478112,0.038963,0.369152,0.041984,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",13.9552,0.476512,0.051477,0.367744,0.041696,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",10.3934,0.476704,0.050686,0.368192,0.041312,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",14.6375,0.480352,0.077526,0.37008,0.041568,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",9.79507,0.476416,0.03713,0.367904,0.0416,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",8.57517,0.478976,0.040747,0.370208,0.041792,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",10.81,0.47776,0.040246,0.369344,0.041728,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",8.45036,0.478048,0.038543,0.369344,0.04192,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",7.65562,0.48064,0.039955,0.371616,0.041792,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",8.60097,0.478304,0.059782,0.369664,0.041952,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",10.4293,0.50864,0.043953,0.37072,0.063168,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",10.7301,0.478624,0.159691,0.37024,0.041408,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",11.9545,0.478848,0.089589,0.370016,0.041664,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",13.2706,0.475968,0.048311,0.367136,0.040768,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",7.66326,0.476608,0.051267,0.369056,0.040544,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",7.66469,0.476992,0.039875,0.368192,0.041408,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",9.82757,0.479424,0.050625,0.370592,0.041504,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",7.76783,0.477088,0.034676,0.368384,0.04176,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",8.26084,0.475936,0.047639,0.366368,0.041792,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",8.82446,0.47904,0.054213,0.370368,0.04128,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",11.7547,0.54416,0.073158,0.382432,0.041216,0.041664,0.0048,0.006688,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",10.2699,0.5448,0.051196,0.383808,0.040192,0.042144,0.0048,0.006304,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",11.2933,0.543232,0.040948,0.382784,0.03968,0.04256,0.004704,0.005984,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",9.87866,0.5432,0.052319,0.38208,0.039808,0.04272,0.004768,0.00576,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",9.64366,0.561376,0.042491,0.386432,0.053952,0.04176,0.004864,0.007424,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",9.37896,0.546432,0.061125,0.384576,0.041184,0.041728,0.004896,0.00672,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",13.315,0.544672,0.065764,0.382176,0.04096,0.041696,0.004928,0.00672,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",11.9395,0.544896,0.04239,0.383424,0.040672,0.041536,0.005056,0.006784,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",17.2652,0.544928,0.07952,0.382624,0.041088,0.042112,0.004928,0.006944,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",10.323,0.541536,0.049864,0.38048,0.03984,0.042656,0.004736,0.005856,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",9.91962,0.54432,0.063149,0.382688,0.040832,0.041376,0.005184,0.006656,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",11.2208,0.544288,0.040416,0.382016,0.040384,0.042848,0.004832,0.005568,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",9.86151,0.543232,0.038883,0.382656,0.040544,0.042016,0.004928,0.006912,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",9.03577,0.544352,0.05307,0.382144,0.041216,0.04192,0.005248,0.006688,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",16.7594,0.5456,0.048551,0.384576,0.040448,0.04192,0.005376,0.006912,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",12.971,0.543744,0.045195,0.38272,0.04064,0.041536,0.005344,0.006944,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",13.1388,0.547264,0.049674,0.38528,0.040704,0.042656,0.004736,0.005856,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",10.454,0.544928,0.049794,0.383072,0.040704,0.041568,0.005504,0.006784,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",10.0701,0.547392,0.034365,0.38256,0.039328,0.042688,0.004768,0.005792,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",10.4174,0.545056,0.034856,0.383776,0.040256,0.041248,0.005664,0.006624,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",10.9952,0.541472,0.038883,0.381824,0.040064,0.042272,0.004736,0.00624,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",13.0438,0.54384,0.116881,0.383488,0.040448,0.042208,0.004736,0.006304,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",17.3474,0.542624,0.056076,0.379456,0.041664,0.041728,0.005184,0.007104,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",26.2324,0.544768,0.09517,0.3824,0.041152,0.041344,0.005824,0.006464,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",12.1699,0.544768,0.056848,0.38336,0.040576,0.04096,0.005824,0.006464,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",9.37042,0.546304,0.052399,0.383872,0.040192,0.043008,0.004832,0.007328,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",11.3721,0.547328,0.490224,0.384512,0.041088,0.042176,0.00512,0.006432,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",10.1461,0.54512,0.065052,0.383808,0.040608,0.041152,0.005824,0.006464,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",11.6359,0.54256,0.057719,0.380768,0.040928,0.041504,0.004928,0.006752,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",10.7501,0.552192,0.059973,0.383488,0.040512,0.04608,0.005472,0.00768,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+occluded,direct,0,"NVIDIA GeForce RTX 2080 Ti",66.5645,0.494496,0.040526,0,0.453888,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,1,"NVIDIA GeForce RTX 2080 Ti",66.5236,0.494944,0.048842,0,0.454144,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,2,"NVIDIA GeForce RTX 2080 Ti",69.7988,0.49456,0.064151,0,0.453312,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,3,"NVIDIA GeForce RTX 2080 Ti",71.0163,0.49744,0.082045,0,0.45632,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,4,"NVIDIA GeForce RTX 2080 Ti",68.6753,0.496064,0.049754,0,0.45504,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,5,"NVIDIA GeForce RTX 2080 Ti",62.9101,0.526784,0.035176,0,0.459264,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,6,"NVIDIA GeForce RTX 2080 Ti",65.7585,0.532544,0.041498,0,0.460832,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,7,"NVIDIA GeForce RTX 2080 Ti",68.3156,0.495168,0.040957,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,8,"NVIDIA GeForce RTX 2080 Ti",63.9311,0.524384,0.04261,0,0.462848,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,9,"NVIDIA GeForce RTX 2080 Ti",68.1388,0.488192,0.043512,0,0.446528,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,10,"NVIDIA GeForce RTX 2080 Ti",72.5859,0.498624,0.044744,0,0.457632,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,11,"NVIDIA GeForce RTX 2080 Ti",80.3614,0.496896,0.071505,0,0.455456,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,12,"NVIDIA GeForce RTX 2080 Ti",75.1705,0.49328,0.059582,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,13,"NVIDIA GeForce RTX 2080 Ti",71.5779,0.494112,0.073087,0,0.452928,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,14,"NVIDIA GeForce RTX 2080 Ti",73.3457,0.495968,0.058901,0,0.454528,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,15,"NVIDIA GeForce RTX 2080 Ti",72.9389,0.4928,0.055455,0,0.451456,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,16,"NVIDIA GeForce RTX 2080 Ti",76.6228,0.498016,0.046969,0,0.456864,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,17,"NVIDIA GeForce RTX 2080 Ti",70.0784,0.494688,0.053982,0,0.452896,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,18,"NVIDIA GeForce RTX 2080 Ti",79.0739,0.495776,0.056156,0,0.454688,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,19,"NVIDIA GeForce RTX 2080 Ti",72.9877,0.494688,0.037892,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,20,"NVIDIA GeForce RTX 2080 Ti",72.1311,0.495232,0.046788,0,0.454624,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,21,"NVIDIA GeForce RTX 2080 Ti",62.4365,0.496864,0.040246,0,0.455552,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,22,"NVIDIA GeForce RTX 2080 Ti",68.6746,0.4912,0.033383,0,0.448512,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,23,"NVIDIA GeForce RTX 2080 Ti",59.8844,0.496,0.041298,0,0.455232,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,24,"NVIDIA GeForce RTX 2080 Ti",60.8796,0.49536,0.044714,0,0.454592,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,25,"NVIDIA GeForce RTX 2080 Ti",64.8914,0.495552,0.061436,0,0.454592,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,26,"NVIDIA GeForce RTX 2080 Ti",59.59,0.533312,0.036539,0,0.460096,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,27,"NVIDIA GeForce RTX 2080 Ti",70.0369,0.497792,0.046658,0,0.45712,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,28,"NVIDIA GeForce RTX 2080 Ti",66.5867,0.49456,0.120056,0,0.4544,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,29,"NVIDIA GeForce RTX 2080 Ti",60.4937,0.495008,0.045957,0,0.453536,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",11.0849,0.476352,0.057048,0.36944,0.039424,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",10.4238,0.480192,0.035837,0.372576,0.039104,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",10.0898,0.478336,0.039966,0.370528,0.039584,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",10.9098,0.482368,0.048662,0.371904,0.043136,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",9.08452,0.47904,0.036348,0.372192,0.039456,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",9.41131,0.475488,0.045355,0.369024,0.039616,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",13.4197,0.48096,0.049353,0.370112,0.043712,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",20.9784,0.479872,0.154752,0.369216,0.043072,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",11.7974,0.481888,0.064562,0.370112,0.043744,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",8.12464,0.478496,0.030848,0.368576,0.043072,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",7.63899,0.477088,0.032872,0.367904,0.041696,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",10.0212,0.481056,0.036689,0.370112,0.043488,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",8.12974,0.478848,0.041929,0.36896,0.042688,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",7.97515,0.479808,0.041389,0.3704,0.042048,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",10.704,0.480064,0.065995,0.37072,0.042944,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",14.0462,0.501472,0.05321,0.37728,0.042304,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",16.5454,0.477952,0.041108,0.369376,0.040928,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",11.8254,0.482784,0.055094,0.372928,0.042816,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",10.2441,0.480352,0.033924,0.370272,0.043424,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",8.54205,0.510592,0.049022,0.368608,0.072192,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",8.60497,0.478048,0.040136,0.367296,0.042944,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",11.5378,0.468064,0.053181,0.358112,0.043296,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",9.95857,0.480704,0.033854,0.370272,0.043424,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",8.19659,0.47664,0.03739,0.368576,0.040896,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",7.89861,0.478304,0.038222,0.371424,0.039008,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",11.973,0.478016,0.057759,0.368736,0.042624,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",18.9519,0.48096,0.045285,0.370656,0.04304,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",12.0451,0.471616,0.062909,0.360928,0.042656,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",10.9205,0.47664,0.034075,0.369472,0.040192,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",10.1355,0.471968,0.06902,0.361184,0.044256,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",11.1203,0.538624,0.07379,0.389312,0.019648,0.041856,0.01312,0.006656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",10.7094,0.535488,0.040056,0.388064,0.019648,0.0416,0.012512,0.00592,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",12.0782,0.536544,0.170552,0.390432,0.01888,0.041248,0.013152,0.00688,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",15.0542,0.5328,0.073208,0.386784,0.01872,0.042016,0.012192,0.00672,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",12.261,0.532864,0.032121,0.386112,0.017888,0.042976,0.012224,0.00624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",9.84738,0.5384,0.055815,0.38048,0.01888,0.043008,0.012256,0.006176,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",10.9202,0.535008,0.043342,0.387552,0.018528,0.042496,0.012384,0.00656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",9.89454,0.528128,0.059121,0.38096,0.018816,0.0424,0.012224,0.006624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",10.4093,0.53488,0.036018,0.3872,0.019072,0.042144,0.012736,0.006592,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",8.36614,0.53808,0.040276,0.39072,0.01888,0.043008,0.012288,0.006144,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",12.8487,0.56784,0.051938,0.411104,0.020672,0.045824,0.013408,0.007072,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",19.2762,0.533088,0.088777,0.386208,0.0192,0.042336,0.012288,0.006592,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",12.2209,0.536992,0.055295,0.38896,0.01904,0.042528,0.012288,0.006624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",10.2118,0.538048,0.051768,0.391232,0.018688,0.042528,0.012,0.00656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",11.6706,0.536736,0.060895,0.38784,0.019712,0.042944,0.012256,0.00624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",11.3352,0.535168,0.054253,0.387232,0.018272,0.042816,0.012416,0.006208,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",9.05475,0.53648,0.048892,0.389216,0.018976,0.042304,0.012192,0.006592,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",9.41794,0.535008,0.039294,0.386688,0.019136,0.042624,0.012384,0.006432,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",8.45,0.536864,0.04803,0.390432,0.018976,0.042208,0.012224,0.006496,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",13.7081,0.53552,0.054452,0.389024,0.018528,0.042976,0.012032,0.006432,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",19.5372,0.53328,0.037702,0.38672,0.018784,0.042848,0.012224,0.006368,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",12.425,0.536384,0.070393,0.3888,0.01872,0.041344,0.01264,0.007232,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",12.0341,0.536384,0.042951,0.388768,0.01904,0.04224,0.01264,0.006752,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",10.2125,0.534368,0.038683,0.387968,0.018784,0.041952,0.012224,0.006208,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",9.8623,0.535168,0.060444,0.388192,0.019232,0.04256,0.012352,0.00656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",10.9939,0.538656,0.061837,0.391808,0.017792,0.043008,0.012544,0.005888,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",10.028,0.534432,0.047209,0.386784,0.019424,0.042464,0.012224,0.006624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",16.655,0.53344,0.046898,0.3856,0.018688,0.042592,0.012544,0.006304,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",10.5594,0.537888,0.045947,0.391008,0.018944,0.04224,0.012224,0.006656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",9.99491,0.536704,0.078778,0.389216,0.0184,0.042944,0.012256,0.00624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0

docs/studies/data/p2-2026-09-23-device-local-run-3.csv

@@ -0,0 +1,271 @@
+scenario,mode,frame,device,cpu_ms,gpu_ms,readback_cpu_ms,gpu_main_cull_ms,gpu_main_raster_ms,gpu_hzb_ms,gpu_post_cull_ms,gpu_post_raster_ms,gpu_bytes,draw_calls,gpu_bins,gpu_visible,gpu_frustum_rejected,gpu_deferred,gpu_post_visible,lod0,lod1,lod2,lod3,hzb_valid,gpu_visibility_active,visibility_diagnostics,visibility_counters_valid,validation_errors
+frustum,direct,0,"NVIDIA GeForce RTX 2080 Ti",68.4785,0.234304,0.056086,0,0.192512,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,1,"NVIDIA GeForce RTX 2080 Ti",65.9328,0.233376,0.033653,0,0.192608,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,2,"NVIDIA GeForce RTX 2080 Ti",69.3577,0.234208,0.049524,0,0.192512,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,3,"NVIDIA GeForce RTX 2080 Ti",71.9818,0.234208,0.037781,0,0.193312,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,4,"NVIDIA GeForce RTX 2080 Ti",57.265,0.236224,0.049814,0,0.195584,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,5,"NVIDIA GeForce RTX 2080 Ti",66.4298,0.235808,0.05331,0,0.194784,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,6,"NVIDIA GeForce RTX 2080 Ti",66.5939,0.2344,0.04817,0,0.192928,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,7,"NVIDIA GeForce RTX 2080 Ti",65.2286,0.234304,0.052189,0,0.193984,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,8,"NVIDIA GeForce RTX 2080 Ti",68.5535,0.233088,0.039635,0,0.19088,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,9,"NVIDIA GeForce RTX 2080 Ti",69.6112,0.236128,0.071745,0,0.193312,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,10,"NVIDIA GeForce RTX 2080 Ti",66.6386,0.23312,0.04243,0,0.191168,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,11,"NVIDIA GeForce RTX 2080 Ti",78.1614,0.255168,0.049263,0,0.198176,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,12,"NVIDIA GeForce RTX 2080 Ti",72.0562,0.235104,0.048451,0,0.193248,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,13,"NVIDIA GeForce RTX 2080 Ti",63.6805,0.234208,0.104387,0,0.193984,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,14,"NVIDIA GeForce RTX 2080 Ti",61.9377,0.23488,0.036479,0,0.193408,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,15,"NVIDIA GeForce RTX 2080 Ti",64.2762,0.235744,0.035216,0,0.195712,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,16,"NVIDIA GeForce RTX 2080 Ti",66.9261,0.233504,0.040116,0,0.192128,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,17,"NVIDIA GeForce RTX 2080 Ti",61.0661,0.235136,0.04207,0,0.19408,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,18,"NVIDIA GeForce RTX 2080 Ti",65.299,0.23392,0.040056,0,0.192672,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,19,"NVIDIA GeForce RTX 2080 Ti",65.5292,0.23488,0.044343,0,0.193888,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,20,"NVIDIA GeForce RTX 2080 Ti",63.2204,0.362816,0.061566,0,0.319488,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,21,"NVIDIA GeForce RTX 2080 Ti",71.8915,0.234272,0.03716,0,0.194048,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,22,"NVIDIA GeForce RTX 2080 Ti",77.3235,0.235776,0.046047,0,0.19264,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,23,"NVIDIA GeForce RTX 2080 Ti",67.8365,0.232544,0.047509,0,0.19168,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,24,"NVIDIA GeForce RTX 2080 Ti",77.2039,0.236,0.053221,0,0.193696,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,25,"NVIDIA GeForce RTX 2080 Ti",69.3318,0.234048,0.067457,0,0.192672,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,26,"NVIDIA GeForce RTX 2080 Ti",59.9847,0.23552,0.041558,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,27,"NVIDIA GeForce RTX 2080 Ti",70.1507,0.235008,0.054473,0,0.193536,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,28,"NVIDIA GeForce RTX 2080 Ti",63.5918,0.235168,0.043262,0,0.19408,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,29,"NVIDIA GeForce RTX 2080 Ti",61.6097,0.234304,0.07448,0,0.192512,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",20.6243,0.23152,0.047079,0.138048,0.0272,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",14.4267,0.259776,0.058811,0.137728,0.041824,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",10.3846,0.24544,0.049163,0.14592,0.032256,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",11.0997,0.231488,0.076895,0.137152,0.02672,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",10.6573,0.26016,0.05797,0.136736,0.0312,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",10.9875,0.230656,0.064943,0.136736,0.02656,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",11.2594,0.23184,0.060024,0.1376,0.026624,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",9.93987,0.2312,0.071525,0.137312,0.02656,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",11.533,0.229504,0.053932,0.135712,0.026752,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",10.4659,0.228704,0.044003,0.135296,0.026624,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",12.5764,0.230048,0.049624,0.136224,0.026272,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",13.4199,0.22976,0.052739,0.13728,0.026272,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",10.8869,0.230752,0.072397,0.136768,0.026496,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",10.4181,0.23168,0.064541,0.137088,0.026912,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",10.5278,0.2304,0.054734,0.135936,0.027264,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",9.63723,0.230592,0.051567,0.136352,0.026208,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",9.01626,0.262592,0.04245,0.140864,0.054624,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",9.39782,0.230464,0.044965,0.13616,0.027072,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",9.95979,0.228832,0.048852,0.13616,0.025632,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",10.759,0.228896,0.051748,0.135808,0.026112,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",10.9753,0.253248,0.045205,0.137344,0.029952,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",10.6281,0.230976,0.075272,0.136704,0.026528,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",10.0208,0.22976,0.048251,0.136256,0.026368,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",12.3332,0.231136,0.055034,0.136608,0.027264,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",10.8965,0.231424,0.045004,0.136352,0.027712,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",8.6148,0.230496,0.044313,0.136288,0.02608,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",8.85869,0.229888,0.064321,0.135936,0.026944,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",10.371,0.229792,0.231858,0.136416,0.026464,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",15.0848,0.228704,0.055414,0.13696,0.025888,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",18.8212,0.233056,0.06889,0.137568,0.02688,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",10.3272,0.29184,0.04731,0.143744,0.027296,0.041952,0.005024,0.007008,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",11.232,0.291328,0.082897,0.14368,0.026304,0.042752,0.004832,0.00688,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",9.56429,0.289632,0.04257,0.142208,0.026912,0.041888,0.004768,0.006592,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",8.48152,0.2896,0.041629,0.141664,0.0264,0.042528,0.004864,0.005856,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",9.08971,0.290016,0.042711,0.142656,0.027392,0.041504,0.005056,0.006848,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",9.61352,0.290432,0.044775,0.142048,0.02768,0.041952,0.004992,0.00672,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",9.42087,0.289536,0.039054,0.142464,0.026336,0.042784,0.004736,0.005728,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",10.2745,0.295968,0.046949,0.143936,0.027392,0.041664,0.005216,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",20.0217,0.291008,0.066194,0.142752,0.027232,0.04272,0.004864,0.005664,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",13.5483,0.292928,0.05844,0.143936,0.02784,0.04144,0.004992,0.006688,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",11.63,0.29184,0.059111,0.144448,0.02736,0.041184,0.005792,0.006496,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",9.36151,0.289792,0.037791,0.143136,0.026848,0.04096,0.005664,0.00656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",9.79621,0.29088,0.034905,0.143008,0.027488,0.04128,0.005536,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",9.07658,0.29136,0.05822,0.142176,0.027808,0.043008,0.004992,0.00672,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",9.54872,0.290304,0.038222,0.143584,0.0264,0.042432,0.004736,0.00608,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",10.3873,0.29088,0.061486,0.143136,0.026848,0.0424,0.004992,0.007008,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",16.027,0.293792,0.058811,0.143776,0.027712,0.041504,0.00592,0.006368,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",14.6296,0.290112,0.071114,0.142752,0.027232,0.041984,0.004736,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",11.2966,0.292256,0.066676,0.143744,0.027744,0.041472,0.005472,0.006816,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",11.6844,0.292736,0.072607,0.144608,0.027424,0.042112,0.004832,0.006304,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",11.0806,0.29472,0.049233,0.14496,0.027072,0.042944,0.00512,0.00656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",11.3335,0.292416,0.057108,0.14416,0.027808,0.041984,0.0048,0.006624,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",11.4639,0.294144,0.055134,0.144352,0.027584,0.041888,0.005152,0.006944,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",9.80644,0.290432,0.054673,0.143296,0.026592,0.042272,0.004736,0.00624,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",17.5667,0.290176,0.038592,0.14304,0.026944,0.041344,0.005312,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",10.6748,0.292352,0.044484,0.143968,0.027616,0.041472,0.005376,0.006912,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",14.4168,0.291296,0.203043,0.143072,0.027008,0.041792,0.005216,0.00704,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",9.61146,0.32416,0.036488,0.14336,0.03072,0.071424,0.004832,0.005664,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",11.3439,0.29056,0.040166,0.14272,0.02704,0.041536,0.005312,0.006656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",9.55479,0.304672,0.056657,0.148128,0.02736,0.041504,0.005728,0.00656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+open,direct,0,"NVIDIA GeForce RTX 2080 Ti",68.63,0.496224,0.050275,0,0.456576,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,1,"NVIDIA GeForce RTX 2080 Ti",62.4592,0.497056,0.039344,0,0.455168,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,2,"NVIDIA GeForce RTX 2080 Ti",66.3106,0.498592,0.055234,0,0.457088,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,3,"NVIDIA GeForce RTX 2080 Ti",61.2164,0.498944,0.045155,0,0.458752,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,4,"NVIDIA GeForce RTX 2080 Ti",71.6603,0.494208,0.043843,0,0.453664,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,5,"NVIDIA GeForce RTX 2080 Ti",71.4574,0.492512,0.081554,0,0.452608,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,6,"NVIDIA GeForce RTX 2080 Ti",72.0269,0.49392,0.049794,0,0.453824,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,7,"NVIDIA GeForce RTX 2080 Ti",67.7714,0.500768,0.130686,0,0.459392,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,8,"NVIDIA GeForce RTX 2080 Ti",76.1415,0.499648,0.052629,0,0.459104,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,9,"NVIDIA GeForce RTX 2080 Ti",78.1573,0.750624,0.070253,0,0.70864,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,10,"NVIDIA GeForce RTX 2080 Ti",95.7163,0.4968,0.061687,0,0.456544,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,11,"NVIDIA GeForce RTX 2080 Ti",78.9684,0.505824,0.082085,0,0.454656,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,12,"NVIDIA GeForce RTX 2080 Ti",78.4559,0.497952,0.077676,0,0.457312,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,13,"NVIDIA GeForce RTX 2080 Ti",72.1784,0.496032,0.046297,0,0.455104,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,14,"NVIDIA GeForce RTX 2080 Ti",85.2738,0.49712,0.059903,0,0.456448,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,15,"NVIDIA GeForce RTX 2080 Ti",89.1637,0.497344,0.102012,0,0.45648,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,16,"NVIDIA GeForce RTX 2080 Ti",76.5471,0.679328,0.076524,0,0.63744,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,17,"NVIDIA GeForce RTX 2080 Ti",82.4952,0.497696,0.057558,0,0.455264,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,18,"NVIDIA GeForce RTX 2080 Ti",75.4858,0.49632,0.057308,0,0.454784,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,19,"NVIDIA GeForce RTX 2080 Ti",76.1648,0.539232,0.043523,0,0.462848,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,20,"NVIDIA GeForce RTX 2080 Ti",73.4384,0.49728,0.094368,0,0.45664,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,21,"NVIDIA GeForce RTX 2080 Ti",83.0048,0.49536,0.038913,0,0.454688,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,22,"NVIDIA GeForce RTX 2080 Ti",68.0038,0.493856,0.048982,0,0.452608,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,23,"NVIDIA GeForce RTX 2080 Ti",65.381,0.51184,0.039855,0,0.462848,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,24,"NVIDIA GeForce RTX 2080 Ti",75.839,0.504544,0.037711,0,0.456,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,25,"NVIDIA GeForce RTX 2080 Ti",68.2006,0.494464,0.038583,0,0.454016,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,26,"NVIDIA GeForce RTX 2080 Ti",64.9307,0.4952,0.04262,0,0.454656,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,27,"NVIDIA GeForce RTX 2080 Ti",66.7801,0.494048,0.045075,0,0.45312,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,28,"NVIDIA GeForce RTX 2080 Ti",69.8776,0.493632,0.048271,0,0.453824,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,29,"NVIDIA GeForce RTX 2080 Ti",65.2059,0.494688,0.053361,0,0.453056,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",10.2345,0.477344,0.050585,0.36864,0.04096,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",7.9007,0.476608,0.05306,0.368608,0.040992,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",8.0089,0.52544,0.061536,0.385568,0.07072,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",10.1803,0.478816,0.038072,0.371136,0.040512,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",10.1246,0.473216,0.056887,0.36608,0.040864,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",10.4391,0.475488,0.039575,0.368384,0.040704,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",11.9564,0.476704,0.045606,0.369152,0.040448,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",12.6543,0.47936,0.072266,0.36944,0.042176,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",10.7411,0.475968,0.048532,0.368096,0.040992,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",8.26957,0.47584,0.038833,0.367552,0.040896,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",8.57898,0.49872,0.06375,0.3848,0.046912,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",8.94825,0.47472,0.042961,0.366368,0.041184,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",7.86686,0.475872,0.034856,0.368,0.040128,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",7.37803,0.473376,0.037401,0.365856,0.040992,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",8.63711,0.475712,0.041388,0.368352,0.040832,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",10.3743,0.476672,0.043462,0.368256,0.041152,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",17.086,0.475552,0.051687,0.367744,0.039808,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",12.5928,0.476672,0.045927,0.368128,0.041248,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",9.45106,0.503808,0.08502,0.370016,0.0648,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",9.72384,0.476032,0.033614,0.367616,0.040448,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",8.99572,0.47776,0.078478,0.369088,0.040512,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",7.74263,0.471776,0.042059,0.36432,0.04064,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",8.88856,0.510016,0.051607,0.401696,0.040704,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",7.61282,0.47536,0.033844,0.368512,0.040736,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",7.34422,0.473824,0.034385,0.36672,0.040832,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",7.15337,0.479296,0.033433,0.371808,0.040288,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",10.8052,0.476064,0.05287,0.368128,0.03984,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",17.892,0.507072,0.053681,0.366944,0.069952,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",12.9523,0.507488,0.069781,0.368416,0.069856,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",9.0035,0.482272,0.033012,0.368736,0.03968,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",9.25141,0.541696,0.038623,0.381184,0.039264,0.042912,0.004768,0.005568,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",7.60991,0.545568,0.030778,0.383904,0.040384,0.042368,0.004736,0.0064,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",8.13966,0.543904,0.041498,0.382976,0.04064,0.042304,0.004736,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",9.96139,0.544096,0.038813,0.383584,0.040384,0.040992,0.0056,0.006688,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",8.19841,0.542016,0.04277,0.380928,0.039616,0.042848,0.004736,0.006912,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",9.1988,0.542176,0.035166,0.381824,0.040064,0.042368,0.004736,0.006144,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",8.81583,0.544992,0.037711,0.384672,0.039648,0.042496,0.004736,0.006016,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",9.74805,0.547104,0.044153,0.38672,0.039232,0.043008,0.005152,0.006656,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",20.5496,0.543328,0.045055,0.382816,0.040448,0.041632,0.005216,0.006688,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",15.6501,0.543424,0.045365,0.382176,0.039808,0.042976,0.004736,0.00656,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",10.4535,0.545184,0.043532,0.384,0.04032,0.04128,0.00544,0.00672,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",13.0267,0.545696,0.070943,0.38336,0.040416,0.041984,0.005248,0.00704,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",9.45919,0.542752,0.054774,0.38128,0.040736,0.041216,0.005888,0.0064,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",12.6842,0.54656,0.081864,0.383616,0.04032,0.043008,0.004864,0.006976,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",11.9114,0.546272,0.051097,0.384704,0.040448,0.042144,0.005056,0.006784,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",13.2283,0.54384,0.056296,0.382528,0.03952,0.043008,0.00496,0.006784,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",14.7844,0.548896,0.051217,0.385344,0.04064,0.042656,0.005056,0.006976,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",14.2867,0.560576,0.077827,0.384896,0.041088,0.043008,0.004992,0.007296,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",14.5502,0.54224,0.066455,0.38016,0.040352,0.042144,0.005088,0.006144,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",10.133,0.543392,0.041749,0.382048,0.040416,0.04096,0.005536,0.006752,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",10.0108,0.545312,0.062107,0.38304,0.0408,0.041856,0.005312,0.006912,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",10.1604,0.542688,0.039765,0.382784,0.04048,0.0416,0.005344,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",15.2738,0.543232,0.05319,0.382848,0.040064,0.041984,0.004768,0.00656,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",21.0409,0.543776,0.078739,0.382784,0.040352,0.04176,0.005504,0.006784,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",10.4779,0.543168,0.046267,0.382432,0.039456,0.042784,0.004704,0.006848,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",9.9946,0.541056,0.048511,0.380544,0.040032,0.042464,0.004736,0.006048,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",8.46936,0.541312,0.038493,0.381568,0.040192,0.041088,0.005664,0.006432,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",10.3236,0.54656,0.513478,0.384544,0.039584,0.042816,0.004832,0.006944,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",12.6494,0.543136,0.045626,0.38256,0.040128,0.042304,0.004736,0.006208,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",9.53242,0.550816,0.037171,0.38272,0.040256,0.04192,0.005632,0.006592,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+occluded,direct,0,"NVIDIA GeForce RTX 2080 Ti",73.8445,0.493952,0.055274,0,0.452,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,1,"NVIDIA GeForce RTX 2080 Ti",74.6376,0.497088,0.054643,0,0.455648,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,2,"NVIDIA GeForce RTX 2080 Ti",86.7788,0.525344,0.135505,0,0.456704,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,3,"NVIDIA GeForce RTX 2080 Ti",79.7037,0.491264,0.043192,0,0.448864,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,4,"NVIDIA GeForce RTX 2080 Ti",81.5134,0.496448,0.050635,0,0.45488,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,5,"NVIDIA GeForce RTX 2080 Ti",86.2006,0.49216,0.061546,0,0.451616,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,6,"NVIDIA GeForce RTX 2080 Ti",75.4095,0.494432,0.048191,0,0.453856,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,7,"NVIDIA GeForce RTX 2080 Ti",70.0489,0.52832,0.050846,0,0.460544,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,8,"NVIDIA GeForce RTX 2080 Ti",73.386,0.493024,0.061686,0,0.450816,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,9,"NVIDIA GeForce RTX 2080 Ti",76.7645,0.495808,0.056497,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,10,"NVIDIA GeForce RTX 2080 Ti",67.6413,0.493632,0.058771,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,11,"NVIDIA GeForce RTX 2080 Ti",78.5323,0.776288,0.048702,0,0.732672,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,12,"NVIDIA GeForce RTX 2080 Ti",96.2979,0.492896,0.149111,0,0.45168,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,13,"NVIDIA GeForce RTX 2080 Ti",88.5007,0.490944,0.0531,0,0.450368,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,14,"NVIDIA GeForce RTX 2080 Ti",73.6967,0.49296,0.04769,0,0.452448,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,15,"NVIDIA GeForce RTX 2080 Ti",86.3092,0.497728,0.06889,0,0.45472,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,16,"NVIDIA GeForce RTX 2080 Ti",71.8694,0.493824,0.049584,0,0.452416,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,17,"NVIDIA GeForce RTX 2080 Ti",65.6974,0.49216,0.044214,0,0.450592,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,18,"NVIDIA GeForce RTX 2080 Ti",60.4234,0.497408,0.035146,0,0.456544,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,19,"NVIDIA GeForce RTX 2080 Ti",67.8371,0.493664,0.060074,0,0.452384,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,20,"NVIDIA GeForce RTX 2080 Ti",64.5827,0.49216,0.045957,0,0.451872,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,21,"NVIDIA GeForce RTX 2080 Ti",65.686,0.496064,0.038553,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,22,"NVIDIA GeForce RTX 2080 Ti",74.1536,0.520864,0.052068,0,0.45488,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,23,"NVIDIA GeForce RTX 2080 Ti",71.1269,0.496288,0.0477,0,0.454272,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,24,"NVIDIA GeForce RTX 2080 Ti",83.3638,0.495584,0.051777,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,25,"NVIDIA GeForce RTX 2080 Ti",81.7074,0.491904,0.040166,0,0.45056,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,26,"NVIDIA GeForce RTX 2080 Ti",76.7724,0.49376,0.191531,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,27,"NVIDIA GeForce RTX 2080 Ti",73.1233,0.49504,0.039234,0,0.454624,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,28,"NVIDIA GeForce RTX 2080 Ti",63.0425,0.49136,0.046918,0,0.450144,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,29,"NVIDIA GeForce RTX 2080 Ti",77.6648,0.521376,0.042861,0,0.456032,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",14.4774,0.4648,0.044975,0.355488,0.043424,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",17.185,0.455968,0.045506,0.349312,0.040448,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",11.4543,0.46208,0.061025,0.352672,0.04272,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",9.62447,0.463232,0.04248,0.353984,0.042112,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",8.6052,0.461696,0.046077,0.355392,0.039872,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",10.2419,0.463648,0.056156,0.354656,0.041408,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",11.1707,0.464,0.052609,0.352288,0.044704,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",10.6159,0.459712,0.04257,0.350912,0.042464,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",15.6276,0.459936,0.065935,0.349856,0.043584,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",28.8169,0.464544,0.05302,0.354144,0.044384,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",11.2826,0.463104,0.089559,0.35312,0.043936,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",8.6756,0.460128,0.036609,0.35088,0.042752,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",8.44459,0.4544,0.04244,0.348064,0.040704,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",7.61272,0.462656,0.039074,0.35408,0.04288,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",8.16355,0.463424,0.064462,0.3536,0.043296,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",8.75887,0.460288,0.038062,0.350624,0.04336,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",9.43202,0.45136,0.046949,0.344672,0.040192,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",10.1467,0.463872,0.048311,0.354368,0.043072,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",9.94169,0.46336,0.0423,0.35408,0.043232,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",10.4227,0.464768,0.041628,0.355296,0.042464,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",9.87489,0.458784,0.052509,0.352448,0.040384,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",8.63709,0.461664,0.039044,0.3512,0.044448,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",7.8951,0.460512,0.041929,0.352576,0.042368,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",9.25643,0.461792,0.064962,0.35296,0.042144,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",9.41982,0.461312,0.043472,0.351456,0.043808,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",11.6268,0.460736,0.043472,0.351616,0.042432,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",9.6367,0.457152,0.041147,0.347744,0.043424,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",12.7255,0.46528,0.040707,0.35728,0.041952,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",16.8869,0.506912,0.058059,0.368352,0.068576,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",11.5638,0.461312,0.05288,0.352128,0.043136,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",11.1048,0.516576,0.043312,0.37152,0.019488,0.039872,0.012576,0.005856,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",8.00563,0.510944,0.032862,0.368992,0.01808,0.040448,0.011744,0.006368,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",9.25465,0.51504,0.037521,0.371104,0.018208,0.040736,0.012128,0.0064,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",8.92057,0.514112,0.048141,0.370176,0.01888,0.04096,0.012224,0.006208,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",9.00081,0.51344,0.031971,0.37008,0.018432,0.040704,0.011936,0.006624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",10.0041,0.512096,0.044223,0.36832,0.018624,0.039648,0.0128,0.005632,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",10.0069,0.513216,0.034575,0.36928,0.017792,0.04096,0.012832,0.006624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",10.9418,0.513664,0.04767,0.37072,0.0184,0.040768,0.012096,0.006496,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",11.0964,0.563808,0.048502,0.391328,0.042624,0.04336,0.013152,0.006336,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",13.5784,0.511712,0.047019,0.367904,0.017728,0.04096,0.012608,0.005824,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",11.3898,0.516096,0.051006,0.370912,0.018208,0.04096,0.013344,0.006816,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",10.753,0.513024,0.072907,0.3688,0.018592,0.040864,0.012032,0.00656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",13.3959,0.519776,0.056216,0.37296,0.018208,0.042304,0.012384,0.006752,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",11.0135,0.517184,0.067978,0.370752,0.018368,0.042368,0.011968,0.00688,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",10.8774,0.51552,0.051006,0.371104,0.018016,0.041408,0.012192,0.005792,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",10.9503,0.51568,0.041769,0.37296,0.018208,0.04096,0.011904,0.0064,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",11.1678,0.512256,0.047219,0.368608,0.01872,0.040384,0.012096,0.006368,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",11.1245,0.51088,0.06394,0.36624,0.018816,0.040992,0.011904,0.006496,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",12.2906,0.514656,0.036869,0.370528,0.018592,0.04096,0.012192,0.00624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",15.3416,0.51408,0.050395,0.370912,0.018112,0.040704,0.011904,0.006784,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",15.1337,0.519904,0.050345,0.371488,0.01792,0.042368,0.012736,0.007552,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",11.4232,0.51328,0.048943,0.36912,0.018784,0.040512,0.012128,0.006656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",9.20194,0.516,0.03726,0.372256,0.018464,0.040384,0.012192,0.006688,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",8.23455,0.513216,0.045345,0.369632,0.018656,0.039744,0.0128,0.005632,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",8.71596,0.512928,0.044434,0.369632,0.01872,0.039872,0.012384,0.006048,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",12.179,0.508512,0.054523,0.365504,0.018912,0.03952,0.0128,0.005632,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",18.8849,0.5096,0.047409,0.367584,0.01744,0.04096,0.01248,0.005952,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",14.213,0.513056,0.044293,0.36896,0.018688,0.04096,0.012,0.006432,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",10.6119,0.510816,0.040857,0.366912,0.018656,0.040928,0.011904,0.006368,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",9.88502,0.512032,0.0481,0.368384,0.01856,0.040512,0.011904,0.006464,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0

docs/studies/data/p2-2026-09-23-optimized-run-1.csv

@@ -0,0 +1,271 @@
+scenario,mode,frame,device,cpu_ms,gpu_ms,readback_cpu_ms,gpu_main_cull_ms,gpu_main_raster_ms,gpu_hzb_ms,gpu_post_cull_ms,gpu_post_raster_ms,gpu_bytes,draw_calls,gpu_bins,gpu_visible,gpu_frustum_rejected,gpu_deferred,gpu_post_visible,lod0,lod1,lod2,lod3,hzb_valid,gpu_visibility_active,visibility_diagnostics,visibility_counters_valid,validation_errors
+frustum,direct,0,"NVIDIA GeForce RTX 2080 Ti",84.8358,0.233696,0.040606,0,0.192512,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,1,"NVIDIA GeForce RTX 2080 Ti",89.8912,0.235008,0.037311,0,0.194528,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,2,"NVIDIA GeForce RTX 2080 Ti",68.5656,0.235648,0.045986,0,0.193344,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,3,"NVIDIA GeForce RTX 2080 Ti",72.8402,0.274336,0.054242,0,0.198592,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,4,"NVIDIA GeForce RTX 2080 Ti",75.3926,0.235936,0.044724,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,5,"NVIDIA GeForce RTX 2080 Ti",76.7995,0.23568,0.04771,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,6,"NVIDIA GeForce RTX 2080 Ti",72.286,0.235168,0.066125,0,0.193504,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,7,"NVIDIA GeForce RTX 2080 Ti",70.7688,0.234304,0.062678,0,0.19344,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,8,"NVIDIA GeForce RTX 2080 Ti",76.7221,0.234304,0.049303,0,0.194432,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,9,"NVIDIA GeForce RTX 2080 Ti",79.533,0.233664,0.040747,0,0.192512,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,10,"NVIDIA GeForce RTX 2080 Ti",71.6348,0.235072,0.050586,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,11,"NVIDIA GeForce RTX 2080 Ti",64.9955,0.236032,0.039264,0,0.194464,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,12,"NVIDIA GeForce RTX 2080 Ti",64.1696,0.262752,0.039735,0,0.195712,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,13,"NVIDIA GeForce RTX 2080 Ti",76.5181,0.324864,0.057108,0,0.282496,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,14,"NVIDIA GeForce RTX 2080 Ti",66.9228,0.26624,0.035337,0,0.19616,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,15,"NVIDIA GeForce RTX 2080 Ti",67.2406,0.234112,0.041528,0,0.194048,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,16,"NVIDIA GeForce RTX 2080 Ti",81.9708,0.235296,0.046388,0,0.194528,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,17,"NVIDIA GeForce RTX 2080 Ti",80.1792,0.234272,0.057198,0,0.193568,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,18,"NVIDIA GeForce RTX 2080 Ti",64.157,0.23456,0.038503,0,0.194464,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,19,"NVIDIA GeForce RTX 2080 Ti",68.3469,0.232544,0.039375,0,0.190464,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,20,"NVIDIA GeForce RTX 2080 Ti",73.6137,0.23376,0.064592,0,0.19296,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,21,"NVIDIA GeForce RTX 2080 Ti",67.4191,0.233664,0.046407,0,0.192512,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,22,"NVIDIA GeForce RTX 2080 Ti",67.5046,0.236032,0.044744,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,23,"NVIDIA GeForce RTX 2080 Ti",73.4016,0.231776,0.04788,0,0.190816,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,24,"NVIDIA GeForce RTX 2080 Ti",79.6889,0.236384,0.054252,0,0.194688,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,25,"NVIDIA GeForce RTX 2080 Ti",62.8455,0.234464,0.03723,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,26,"NVIDIA GeForce RTX 2080 Ti",67.8715,0.23232,0.033152,0,0.191744,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,27,"NVIDIA GeForce RTX 2080 Ti",66.4796,0.234656,0.054974,0,0.193344,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,28,"NVIDIA GeForce RTX 2080 Ti",64.9506,0.23472,0.042821,0,0.193824,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,29,"NVIDIA GeForce RTX 2080 Ti",65.3765,0.234464,0.03743,0,0.1944,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",7.98005,0.122624,0.035397,0.030304,0.024992,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",14.9003,0.122848,0.051918,0.02992,0.02544,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",22.5974,0.176864,0.06366,0.066624,0.038432,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",9.03565,0.122816,0.039524,0.029888,0.025568,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",8.36763,0.122912,0.045887,0.029856,0.025824,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",8.02071,0.146752,0.038293,0.030944,0.0264,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",9.32975,0.123936,0.043321,0.03056,0.026656,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",8.19152,0.122432,0.032842,0.029664,0.026048,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",8.48955,0.12304,0.050064,0.030592,0.026336,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",8.2961,0.1232,0.044845,0.0304,0.026112,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",9.78385,0.123392,0.047069,0.030208,0.025408,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",9.34487,0.122304,0.04235,0.029696,0.025696,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",11.2182,0.12304,0.052048,0.029696,0.026208,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",10.252,0.124128,0.059562,0.031136,0.026208,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",7.59079,0.149472,0.031099,0.034848,0.048768,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",7.59643,0.122496,0.030337,0.029824,0.02592,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",8.36693,0.124096,0.056506,0.029952,0.027328,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",10.2115,0.123648,0.058581,0.030112,0.025824,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",8.0874,0.123552,0.046799,0.030176,0.026528,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",10.4539,0.123488,0.043121,0.029696,0.02608,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",7.34845,0.12304,0.051747,0.030048,0.026272,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",10.5867,0.12352,0.040566,0.030688,0.026464,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",13.2325,0.122912,0.049233,0.029632,0.026144,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",12.5845,0.123808,0.039715,0.029824,0.027104,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",9.41096,0.124288,0.045416,0.0304,0.026816,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",7.22408,0.122624,0.047269,0.029856,0.025952,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",9.6291,0.124064,0.05846,0.030048,0.027104,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",8.8691,0.124608,0.041929,0.03008,0.0272,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",7.45915,0.122592,0.042711,0.02976,0.025536,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",7.27659,0.124224,0.032812,0.029792,0.026432,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",8.42512,0.186976,0.040867,0.037984,0.02832,0.042048,0.005216,0.005984,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",9.13706,0.186112,0.055685,0.03792,0.027616,0.042016,0.004928,0.006304,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",10.0261,0.185056,0.045446,0.038176,0.02736,0.04096,0.005568,0.00672,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",9.99471,0.185504,0.045286,0.038496,0.028288,0.04176,0.004928,0.006592,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",9.63832,0.18544,0.051998,0.036704,0.027168,0.04256,0.004736,0.0072,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",10.8693,0.188992,0.374867,0.038784,0.028864,0.041888,0.00512,0.006624,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",9.27457,0.193312,0.0421,0.037472,0.028064,0.04224,0.004896,0.006112,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",8.32481,0.185184,0.042069,0.037824,0.026432,0.042656,0.004928,0.005664,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",8.24735,0.190016,0.055905,0.038848,0.028992,0.042752,0.005152,0.006784,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",11.1272,0.197696,0.047309,0.037952,0.028,0.042304,0.004992,0.005952,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",7.762,0.18672,0.032812,0.038624,0.02848,0.04144,0.005536,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",10.8607,0.18576,0.072127,0.03792,0.027616,0.0416,0.005184,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",11.4079,0.18672,0.166685,0.037824,0.028256,0.041088,0.006016,0.006272,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",12.0623,0.189728,0.055444,0.038464,0.02864,0.042112,0.005216,0.006784,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",10.8561,0.18592,0.054944,0.037504,0.028448,0.041248,0.005248,0.00656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",7.57558,0.184672,0.031089,0.037536,0.027168,0.041664,0.005056,0.006592,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",8.85736,0.185216,0.036088,0.037728,0.027712,0.041088,0.005504,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",8.94327,0.188672,0.067327,0.038752,0.027616,0.042752,0.005056,0.006688,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",10.4701,0.185152,0.041098,0.036768,0.02832,0.041408,0.005568,0.006688,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",11.258,0.187744,0.053722,0.0392,0.027648,0.041664,0.005536,0.006752,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",8.64531,0.186304,0.033713,0.037888,0.02816,0.04208,0.004928,0.00624,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",14.7746,0.18432,0.043482,0.037504,0.026496,0.042784,0.004896,0.005568,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",16.4399,0.188288,0.039244,0.03808,0.028928,0.042592,0.004928,0.006304,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",10.5205,0.187552,0.055766,0.038144,0.028576,0.041824,0.005408,0.006752,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",8.22939,0.2136,0.034224,0.037472,0.02832,0.045408,0.009152,0.015776,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",7.98071,0.184576,0.033533,0.037344,0.026208,0.042912,0.004896,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",8.70835,0.18864,0.050595,0.037152,0.028864,0.041472,0.005408,0.006816,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",8.53598,0.185408,0.049874,0.037728,0.027808,0.04096,0.005728,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",7.91662,0.185824,0.041328,0.037536,0.028096,0.041056,0.005792,0.006496,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",9.39885,0.18624,0.045035,0.037888,0.027712,0.042304,0.004928,0.006016,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+open,direct,0,"NVIDIA GeForce RTX 2080 Ti",69.0551,0.4976,0.051898,0,0.454976,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,1,"NVIDIA GeForce RTX 2080 Ti",72.5655,0.494112,0.058129,0,0.453216,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,2,"NVIDIA GeForce RTX 2080 Ti",62.2109,0.497088,0.042931,0,0.456704,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,3,"NVIDIA GeForce RTX 2080 Ti",65.8325,0.496576,0.045486,0,0.455168,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,4,"NVIDIA GeForce RTX 2080 Ti",63.6476,0.500064,0.064231,0,0.45936,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,5,"NVIDIA GeForce RTX 2080 Ti",70.0405,0.495008,0.035858,0,0.454144,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,6,"NVIDIA GeForce RTX 2080 Ti",73.6604,0.49888,0.046167,0,0.456608,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,7,"NVIDIA GeForce RTX 2080 Ti",76.7897,0.499232,0.102924,0,0.458208,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,8,"NVIDIA GeForce RTX 2080 Ti",65.6745,0.528096,0.045456,0,0.461184,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,9,"NVIDIA GeForce RTX 2080 Ti",70.39,0.496064,0.052028,0,0.454752,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,10,"NVIDIA GeForce RTX 2080 Ti",66.969,0.496608,0.035347,0,0.455328,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,11,"NVIDIA GeForce RTX 2080 Ti",61.1673,0.498016,0.043062,0,0.457984,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,12,"NVIDIA GeForce RTX 2080 Ti",66.277,0.49088,0.070383,0,0.446464,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,13,"NVIDIA GeForce RTX 2080 Ti",76.6583,0.497184,0.054944,0,0.456064,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,14,"NVIDIA GeForce RTX 2080 Ti",61.576,0.531552,0.051918,0,0.454464,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,15,"NVIDIA GeForce RTX 2080 Ti",67.8576,0.51472,0.037251,0,0.455424,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,16,"NVIDIA GeForce RTX 2080 Ti",67.0659,0.499168,0.066666,0,0.458592,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,17,"NVIDIA GeForce RTX 2080 Ti",61.9121,0.498752,0.05269,0,0.458752,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,18,"NVIDIA GeForce RTX 2080 Ti",66.7569,0.495456,0.060474,0,0.455936,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,19,"NVIDIA GeForce RTX 2080 Ti",67.4733,0.495808,0.056757,0,0.454656,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,20,"NVIDIA GeForce RTX 2080 Ti",65.5331,0.496864,0.041949,0,0.454656,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,21,"NVIDIA GeForce RTX 2080 Ti",68.636,0.525312,0.057158,0,0.469376,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,22,"NVIDIA GeForce RTX 2080 Ti",67.1153,0.498656,0.063209,0,0.456704,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,23,"NVIDIA GeForce RTX 2080 Ti",65.0043,0.502144,0.05849,0,0.454656,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,24,"NVIDIA GeForce RTX 2080 Ti",70.9417,0.497696,0.075733,0,0.457152,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,25,"NVIDIA GeForce RTX 2080 Ti",66.4817,0.492992,0.04764,0,0.452448,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,26,"NVIDIA GeForce RTX 2080 Ti",69.8114,0.497152,0.055915,0,0.455424,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,27,"NVIDIA GeForce RTX 2080 Ti",71.4839,0.498848,0.076985,0,0.456704,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,28,"NVIDIA GeForce RTX 2080 Ti",66.0849,0.513696,0.050616,0,0.464896,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,29,"NVIDIA GeForce RTX 2080 Ti",75.5549,0.499392,0.059783,0,0.458592,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",18.5607,0.137728,0.05313,0.03152,0.04016,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",12.5255,0.188608,0.041729,0.048832,0.069888,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",10.0809,0.137952,0.059523,0.030496,0.040576,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",7.84954,0.137856,0.036469,0.030304,0.03984,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",8.22552,0.13808,0.036078,0.030528,0.040704,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",10.1264,0.138624,0.088978,0.030464,0.041184,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",8.40914,0.137792,0.048281,0.03104,0.040576,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",11.0082,0.138464,0.056677,0.030688,0.039584,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",8.53442,0.137504,0.038112,0.029792,0.040416,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",8.44042,0.139136,0.039524,0.030528,0.041152,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",14.1365,0.137408,0.054754,0.031104,0.040256,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",12.9593,0.13824,0.04233,0.030432,0.03968,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",12.0358,0.138208,0.062367,0.030528,0.040768,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",9.92836,0.139712,0.086583,0.031904,0.039776,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",9.64748,0.137664,0.068329,0.030336,0.039808,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",10.4127,0.138144,0.039905,0.030304,0.041024,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",7.41973,0.13808,0.038112,0.03056,0.04048,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",8.94168,0.138368,0.057218,0.030464,0.04,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",8.73272,0.1384,0.042771,0.031168,0.040512,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",10.8108,0.138016,0.051307,0.031072,0.040352,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",11.2231,0.138016,0.037671,0.030688,0.039936,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",10.0337,0.138048,0.045476,0.030368,0.03984,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",11.4823,0.137952,0.04763,0.030368,0.039808,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",13.9335,0.138048,0.050595,0.030624,0.039616,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",9.29238,0.137888,0.038913,0.030688,0.039328,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",10.5871,0.140224,0.052249,0.031392,0.040832,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",10.7878,0.139968,0.053662,0.032448,0.04096,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",10.9381,0.139456,0.055014,0.031232,0.040608,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",8.00041,0.137984,0.04248,0.030208,0.040128,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",7.38412,0.13744,0.035167,0.029888,0.040288,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",12.3338,0.20368,0.077135,0.043584,0.039872,0.041952,0.005152,0.006656,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",9.352,0.202336,0.033964,0.042304,0.039616,0.042496,0.0048,0.005952,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",8.09758,0.202016,0.03159,0.042368,0.039552,0.041728,0.00528,0.00624,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",10.7041,0.2056,0.097213,0.042912,0.041248,0.041728,0.005504,0.006144,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",10.0423,0.206816,0.044824,0.044928,0.039904,0.042112,0.004928,0.006208,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",10.2633,0.203712,0.041418,0.043968,0.04,0.04144,0.00512,0.006688,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",10.5094,0.203424,0.037871,0.04336,0.040064,0.04176,0.005472,0.006496,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",8.57102,0.20304,0.044594,0.043072,0.040512,0.04128,0.004896,0.006752,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",12.4202,0.221408,0.04231,0.042816,0.039872,0.041248,0.005024,0.00656,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",11.0533,0.20288,0.0474,0.042688,0.039232,0.04208,0.004832,0.006336,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",10.1613,0.20352,0.051588,0.043296,0.039456,0.042112,0.005152,0.005984,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",9.9876,0.202208,0.055865,0.043008,0.038912,0.042272,0.004832,0.006144,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",8.4274,0.201888,0.03207,0.042656,0.039264,0.042208,0.004832,0.006208,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",8.57586,0.202816,0.038142,0.043488,0.04,0.041664,0.005088,0.006688,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",10.8099,0.20256,0.039304,0.042944,0.04032,0.04144,0.004832,0.005632,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",8.73306,0.202848,0.039835,0.042624,0.039744,0.041568,0.005536,0.006144,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",8.28309,0.20192,0.034746,0.04224,0.039936,0.041664,0.004992,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",9.52823,0.2016,0.043221,0.04192,0.040288,0.041152,0.005024,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",12.4941,0.26336,0.046818,0.066432,0.068736,0.045056,0.006368,0.007584,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",14.6017,0.203488,0.057669,0.043168,0.039776,0.041536,0.005152,0.00752,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",10.8673,0.202208,0.055514,0.042432,0.039776,0.04144,0.005024,0.006688,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",7.99268,0.201632,0.033393,0.042656,0.039264,0.041536,0.005088,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",9.16843,0.201504,0.046348,0.042208,0.038688,0.0424,0.004832,0.006016,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",8.43381,0.208,0.05334,0.0448,0.040736,0.042176,0.005568,0.00704,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",9.05219,0.201696,0.041589,0.042048,0.039904,0.041312,0.005024,0.006656,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",9.43528,0.202208,0.048902,0.042784,0.039744,0.04128,0.005152,0.00656,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",9.04983,0.201568,0.034014,0.042592,0.039328,0.0416,0.005152,0.006496,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",9.08282,0.201472,0.040316,0.043328,0.038592,0.042144,0.004832,0.006272,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",12.649,0.202912,0.05833,0.04256,0.03936,0.04272,0.004864,0.005664,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",10.7353,0.2024,0.047309,0.04336,0.039904,0.041408,0.004832,0.006752,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+occluded,direct,0,"NVIDIA GeForce RTX 2080 Ti",68.8403,0.496096,0.055975,0,0.455072,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,1,"NVIDIA GeForce RTX 2080 Ti",63.9436,0.496128,0.05812,0,0.455904,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,2,"NVIDIA GeForce RTX 2080 Ti",72.3147,0.495776,0.056797,0,0.453536,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,3,"NVIDIA GeForce RTX 2080 Ti",65.6657,0.496128,0.055975,0,0.45504,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,4,"NVIDIA GeForce RTX 2080 Ti",59.0524,0.497312,0.050626,0,0.458656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,5,"NVIDIA GeForce RTX 2080 Ti",64.8322,0.51728,0.046097,0,0.470976,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,6,"NVIDIA GeForce RTX 2080 Ti",59.0104,0.497472,0.046287,0,0.457632,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,7,"NVIDIA GeForce RTX 2080 Ti",61.4887,0.49568,0.040777,0,0.455392,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,8,"NVIDIA GeForce RTX 2080 Ti",67.2787,0.49728,0.033343,0,0.457792,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,9,"NVIDIA GeForce RTX 2080 Ti",62.5564,0.5312,0.049173,0,0.462816,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,10,"NVIDIA GeForce RTX 2080 Ti",76.4275,0.496352,0.035557,0,0.454208,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,11,"NVIDIA GeForce RTX 2080 Ti",75.3528,0.529088,0.039014,0,0.462112,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,12,"NVIDIA GeForce RTX 2080 Ti",61.2523,0.498592,0.045616,0,0.458752,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,13,"NVIDIA GeForce RTX 2080 Ti",63.0935,0.496,0.050455,0,0.45568,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,14,"NVIDIA GeForce RTX 2080 Ti",65.798,0.498432,0.052398,0,0.4568,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,15,"NVIDIA GeForce RTX 2080 Ti",70.4662,0.496448,0.043502,0,0.4552,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,16,"NVIDIA GeForce RTX 2080 Ti",66.6487,0.498848,0.035748,0,0.458752,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,17,"NVIDIA GeForce RTX 2080 Ti",65.2278,0.497536,0.039154,0,0.456704,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,18,"NVIDIA GeForce RTX 2080 Ti",62.0441,0.497056,0.053591,0,0.456096,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,19,"NVIDIA GeForce RTX 2080 Ti",63.6593,0.497792,0.050876,0,0.456672,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,20,"NVIDIA GeForce RTX 2080 Ti",75.6206,0.496864,0.067227,0,0.456352,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,21,"NVIDIA GeForce RTX 2080 Ti",71.1253,0.496768,0.043853,0,0.4552,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,22,"NVIDIA GeForce RTX 2080 Ti",73.0983,0.49808,0.052509,0,0.456704,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,23,"NVIDIA GeForce RTX 2080 Ti",64.8811,0.493056,0.048562,0,0.451968,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,24,"NVIDIA GeForce RTX 2080 Ti",58.6158,0.523232,0.048111,0,0.466432,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,25,"NVIDIA GeForce RTX 2080 Ti",66.1309,0.495136,0.061616,0,0.4536,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,26,"NVIDIA GeForce RTX 2080 Ti",67.6235,0.496032,0.1962,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,27,"NVIDIA GeForce RTX 2080 Ti",70.0381,0.528096,0.050485,0,0.458944,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,28,"NVIDIA GeForce RTX 2080 Ti",61.6391,0.4952,0.146055,0,0.454528,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,29,"NVIDIA GeForce RTX 2080 Ti",63.9159,0.496,0.039875,0,0.456288,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",9.86681,0.13952,0.040977,0.030048,0.042208,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",8.18392,0.136736,0.035698,0.029952,0.03968,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",9.87609,0.137376,0.04251,0.029632,0.04112,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",16.2261,0.163424,0.049173,0.03024,0.04064,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",18.0433,0.141984,0.055495,0.0304,0.043328,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",10.016,0.136192,0.03153,0.029888,0.03856,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",8.30434,0.136128,0.032261,0.029984,0.039424,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",8.87967,0.139136,0.057809,0.029024,0.043168,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",8.39916,0.137216,0.041969,0.031104,0.040064,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",9.84957,0.136288,0.039294,0.029824,0.038752,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",9.58889,0.18784,0.15352,0.048032,0.07072,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",9.34888,0.139136,0.054052,0.029888,0.041792,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",15.882,0.136864,0.042089,0.03056,0.039072,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",17.5434,0.138048,0.05811,0.030432,0.040608,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",13.3317,0.139072,0.060264,0.029792,0.042048,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",9.85365,0.138048,0.051838,0.030688,0.040032,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",10.6854,0.142528,0.070162,0.0328,0.041088,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",10.0043,0.137664,0.039234,0.029216,0.040512,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",9.03373,0.137184,0.046318,0.029888,0.03936,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",10.5422,0.13824,0.033673,0.030016,0.040064,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",9.16648,0.136608,0.048752,0.030304,0.039328,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",12.4294,0.1376,0.051007,0.030528,0.039712,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",12.0825,0.136,0.040947,0.029632,0.039232,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",13.2394,0.139232,0.052278,0.030272,0.041408,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",9.26593,0.13552,0.033964,0.029504,0.038272,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",9.65316,0.138688,0.124735,0.030176,0.040256,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",11.026,0.139872,0.059462,0.030976,0.040704,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",9.83545,0.13728,0.061546,0.030112,0.03952,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",9.27993,0.136384,0.039174,0.02992,0.039712,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",24.2924,0.138592,0.045686,0.03088,0.040704,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",10.6152,0.18736,0.049734,0.040416,0.01904,0.041664,0.012672,0.006496,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",11.2771,0.187712,0.089729,0.041472,0.01904,0.04176,0.012544,0.006016,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",9.75047,0.189248,0.07933,0.042496,0.018816,0.041536,0.01248,0.006816,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",9.48813,0.189216,0.070934,0.042624,0.019072,0.041216,0.012512,0.00592,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",9.96128,0.187904,0.036448,0.041664,0.017728,0.042272,0.012576,0.006592,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",9.65084,0.188096,0.083958,0.04128,0.018592,0.042272,0.01232,0.006656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",8.54836,0.189952,0.036799,0.04384,0.019296,0.041472,0.012768,0.006528,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",8.79947,0.188992,0.042019,0.043168,0.018272,0.04224,0.012256,0.006464,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",8.12835,0.187584,0.038994,0.04176,0.01904,0.041312,0.012608,0.006016,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",11.7155,0.190464,0.060454,0.042848,0.018784,0.042048,0.012512,0.00672,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",21.1644,0.187488,0.042049,0.042016,0.01872,0.041312,0.012896,0.005888,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",13.9463,0.18816,0.054633,0.041024,0.019712,0.041536,0.012288,0.006272,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",13.2591,0.189664,0.053451,0.042848,0.018592,0.04256,0.012576,0.006304,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",11.1836,0.189728,0.055615,0.042176,0.019072,0.041568,0.012512,0.007168,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",10.9075,0.188416,0.038593,0.0424,0.01904,0.041728,0.012448,0.006688,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",9.85021,0.190016,0.140365,0.043776,0.018944,0.041728,0.012928,0.006816,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",10.0282,0.226976,0.034315,0.040864,0.018848,0.081472,0.012352,0.006528,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",9.61147,0.19008,0.046698,0.043936,0.0192,0.041312,0.012672,0.00576,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",12.6934,0.186688,0.050956,0.040864,0.019296,0.04112,0.012352,0.00608,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",13.5272,0.18768,0.045887,0.041632,0.01888,0.041504,0.012512,0.006304,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",11.6951,0.187936,0.041739,0.042144,0.019072,0.04128,0.012704,0.005632,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",8.86532,0.18784,0.040066,0.041664,0.01824,0.042208,0.01232,0.006656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",8.34804,0.18832,0.057037,0.04272,0.01872,0.041984,0.01248,0.006496,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",11.058,0.189056,0.059382,0.041312,0.01888,0.042496,0.012512,0.006432,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",9.48892,0.187936,0.03696,0.041984,0.019072,0.041344,0.012288,0.006144,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",9.41008,0.189408,0.038653,0.042784,0.018752,0.04096,0.013184,0.006848,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",9.81329,0.1872,0.044684,0.041472,0.018976,0.041312,0.01248,0.006464,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",11.4672,0.188768,0.04249,0.043232,0.018464,0.04096,0.012928,0.006624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",15.5826,0.187008,0.060204,0.041696,0.018976,0.041472,0.012288,0.0064,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",12.9027,0.188,0.067187,0.041472,0.019296,0.041344,0.01248,0.00624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0

docs/studies/data/p2-2026-09-23-optimized-run-2.csv

@@ -0,0 +1,271 @@
+scenario,mode,frame,device,cpu_ms,gpu_ms,readback_cpu_ms,gpu_main_cull_ms,gpu_main_raster_ms,gpu_hzb_ms,gpu_post_cull_ms,gpu_post_raster_ms,gpu_bytes,draw_calls,gpu_bins,gpu_visible,gpu_frustum_rejected,gpu_deferred,gpu_post_visible,lod0,lod1,lod2,lod3,hzb_valid,gpu_visibility_active,visibility_diagnostics,visibility_counters_valid,validation_errors
+frustum,direct,0,"NVIDIA GeForce RTX 2080 Ti",66.7005,0.233312,0.041498,0,0.192384,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,1,"NVIDIA GeForce RTX 2080 Ti",63.7382,0.235936,0.062669,0,0.19328,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,2,"NVIDIA GeForce RTX 2080 Ti",75.2129,0.363328,0.054813,0,0.31968,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,3,"NVIDIA GeForce RTX 2080 Ti",67.7748,0.234976,0.060584,0,0.193856,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,4,"NVIDIA GeForce RTX 2080 Ti",60.4237,0.235072,0.045746,0,0.193248,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,5,"NVIDIA GeForce RTX 2080 Ti",75.672,0.235232,0.049183,0,0.192832,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,6,"NVIDIA GeForce RTX 2080 Ti",74.7586,0.23184,0.057027,0,0.190592,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,7,"NVIDIA GeForce RTX 2080 Ti",79.9626,0.23472,0.054243,0,0.192832,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,8,"NVIDIA GeForce RTX 2080 Ti",79.629,0.232128,0.044774,0,0.190464,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,9,"NVIDIA GeForce RTX 2080 Ti",71.7576,0.234368,0.038933,0,0.1936,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,10,"NVIDIA GeForce RTX 2080 Ti",70.1824,0.275456,0.067658,0,0.20128,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,11,"NVIDIA GeForce RTX 2080 Ti",91.5564,0.235616,0.094949,0,0.193344,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,12,"NVIDIA GeForce RTX 2080 Ti",70.5926,0.234912,0.056337,0,0.192544,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,13,"NVIDIA GeForce RTX 2080 Ti",67.0058,0.234496,0.042991,0,0.194048,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,14,"NVIDIA GeForce RTX 2080 Ti",68.5199,0.233056,0.054152,0,0.191328,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,15,"NVIDIA GeForce RTX 2080 Ti",63.8844,0.233856,0.055284,0,0.19136,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,16,"NVIDIA GeForce RTX 2080 Ti",70.1615,0.231808,0.044163,0,0.190624,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,17,"NVIDIA GeForce RTX 2080 Ti",68.5638,0.234048,0.037791,0,0.194016,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,18,"NVIDIA GeForce RTX 2080 Ti",72.512,0.235168,0.046818,0,0.194336,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,19,"NVIDIA GeForce RTX 2080 Ti",74.3427,0.25984,0.039044,0,0.194304,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,20,"NVIDIA GeForce RTX 2080 Ti",88.4309,0.233632,0.041448,0,0.192448,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,21,"NVIDIA GeForce RTX 2080 Ti",70.7703,0.235232,0.055495,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,22,"NVIDIA GeForce RTX 2080 Ti",70.2475,0.234464,0.044944,0,0.192512,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,23,"NVIDIA GeForce RTX 2080 Ti",65.063,0.234208,0.038403,0,0.19328,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,24,"NVIDIA GeForce RTX 2080 Ti",66.9359,0.234976,0.045306,0,0.194368,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,25,"NVIDIA GeForce RTX 2080 Ti",67.6814,0.2344,0.050997,0,0.19424,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,26,"NVIDIA GeForce RTX 2080 Ti",86.3749,0.232768,0.050195,0,0.1912,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,27,"NVIDIA GeForce RTX 2080 Ti",94.8621,0.236064,0.055535,0,0.19584,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,28,"NVIDIA GeForce RTX 2080 Ti",85.9054,0.319936,0.075472,0,0.27712,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,29,"NVIDIA GeForce RTX 2080 Ti",76.1057,0.236,0.047089,0,0.194688,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",12.3398,0.124032,0.041598,0.030496,0.026464,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",11.4442,0.123776,0.04766,0.029856,0.026336,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",10.9857,0.125472,0.054473,0.030304,0.02704,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",11.1582,0.124608,0.05824,0.031392,0.025856,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",13.0445,0.12448,0.064692,0.032032,0.026272,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",14.1908,0.124576,0.058921,0.03056,0.026432,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",18.0479,0.12464,0.059141,0.030496,0.026624,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",16.2661,0.125376,0.056777,0.031168,0.027264,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",16.5833,0.124224,0.044114,0.030624,0.026496,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",22.5695,0.12464,0.046878,0.03072,0.02656,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",11.9563,0.125152,0.062338,0.03104,0.026368,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",23.4212,0.124448,0.077246,0.030976,0.026272,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",15.1145,0.127008,0.067266,0.033056,0.026336,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",17.5413,0.12624,0.062868,0.031776,0.026592,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",16.9894,0.124704,0.04727,0.031008,0.026272,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",10.5089,0.124064,0.045786,0.030464,0.026496,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",11.1135,0.12384,0.059122,0.030432,0.026368,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",11.2476,0.125632,0.071445,0.031232,0.027552,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",11.6336,0.124224,0.068449,0.030752,0.026208,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",11.0582,0.124256,0.063049,0.030304,0.02688,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",13.341,0.1248,0.055705,0.030528,0.026816,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",26.5157,0.154496,0.047159,0.04592,0.038624,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",11.1959,0.124928,0.060063,0.030752,0.027296,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",13.0607,0.126624,0.097584,0.0312,0.027072,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",13.3403,0.12368,0.056306,0.030944,0.0264,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",12.1688,0.123392,0.054052,0.030016,0.02576,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",11.4347,0.122624,0.056156,0.029696,0.025952,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",11.6937,0.124512,0.055384,0.030656,0.026912,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",19.5952,0.12368,0.043943,0.030528,0.025728,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",13.5768,0.155008,0.068139,0.046912,0.03888,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",10.3616,0.186112,0.052499,0.039392,0.027648,0.04128,0.004864,0.00672,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",9.32786,0.186784,0.05299,0.037984,0.027712,0.0424,0.004832,0.006016,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",10.0321,0.188736,0.066034,0.038528,0.029056,0.042112,0.005056,0.007264,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",10.0553,0.186592,0.036028,0.03904,0.027968,0.041344,0.004832,0.006656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",8.81469,0.186688,0.049013,0.038272,0.0272,0.04224,0.005024,0.007104,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",12.5002,0.186112,0.044784,0.03824,0.028384,0.041632,0.004832,0.005696,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",15.7961,0.186816,0.049604,0.037952,0.027584,0.042272,0.005024,0.005952,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",11.6553,0.1864,0.037751,0.038304,0.028608,0.041632,0.005024,0.006624,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",9.10932,0.187104,0.039485,0.037504,0.028736,0.04192,0.005024,0.006464,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",10.1925,0.188416,0.054212,0.039296,0.028288,0.04224,0.005056,0.005952,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",9.01017,0.18656,0.044774,0.038464,0.027072,0.04256,0.005024,0.005664,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",10.12,0.18544,0.049784,0.037184,0.028384,0.041408,0.005088,0.006656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",9.78974,0.186432,0.053931,0.037664,0.028704,0.04144,0.005056,0.006592,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",10.6888,0.187392,0.038523,0.037664,0.028384,0.043008,0.005088,0.006624,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",11.3016,0.18688,0.038493,0.038144,0.027392,0.043008,0.005376,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",14.1208,0.188032,0.055475,0.039072,0.02736,0.042944,0.005024,0.006624,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",9.49592,0.188256,0.03719,0.039008,0.028576,0.04256,0.005088,0.006752,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",9.22754,0.185984,0.05272,0.037472,0.027712,0.042016,0.005248,0.006496,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",9.89965,0.221312,0.06353,0.039744,0.028032,0.045152,0.008384,0.018144,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",12.1165,0.204,0.143301,0.041664,0.027968,0.043328,0.005248,0.00672,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",10.0231,0.186624,0.041969,0.038432,0.027104,0.042816,0.005184,0.00672,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",10.1389,0.187392,0.053951,0.038848,0.02672,0.042912,0.005056,0.006656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",8.79264,0.186752,0.043913,0.038944,0.027904,0.041664,0.005472,0.00656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",10.0527,0.187232,0.041578,0.038016,0.02816,0.042208,0.004864,0.0064,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",10.9321,0.187648,0.050335,0.03856,0.028288,0.041504,0.005024,0.006688,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",10.1327,0.185952,0.049163,0.037728,0.027552,0.04192,0.005088,0.006656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",8.75544,0.185984,0.040967,0.038816,0.028192,0.041472,0.004992,0.00672,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",8.59143,0.210944,0.034555,0.046624,0.044576,0.041888,0.005216,0.006592,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",8.09417,0.187136,0.044664,0.038336,0.028608,0.0416,0.005344,0.006592,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",10.8794,0.192512,0.045656,0.038368,0.027168,0.042624,0.005248,0.006752,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+open,direct,0,"NVIDIA GeForce RTX 2080 Ti",70.0076,0.498848,0.05263,0,0.458336,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,1,"NVIDIA GeForce RTX 2080 Ti",72.6421,0.497056,0.039184,0,0.456672,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,2,"NVIDIA GeForce RTX 2080 Ti",75.5324,0.497088,0.040497,0,0.455104,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,3,"NVIDIA GeForce RTX 2080 Ti",66.2998,0.498912,0.056536,0,0.45808,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,4,"NVIDIA GeForce RTX 2080 Ti",69.4064,0.498976,0.039435,0,0.458752,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,5,"NVIDIA GeForce RTX 2080 Ti",66.5362,0.498656,0.034394,0,0.458144,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,6,"NVIDIA GeForce RTX 2080 Ti",66.2836,0.496704,0.044544,0,0.455168,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,7,"NVIDIA GeForce RTX 2080 Ti",58.3216,0.768352,0.041849,0,0.726784,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,8,"NVIDIA GeForce RTX 2080 Ti",65.6714,0.496064,0.060885,0,0.45312,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,9,"NVIDIA GeForce RTX 2080 Ti",75.7523,0.500896,0.072066,0,0.46,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,10,"NVIDIA GeForce RTX 2080 Ti",72.9653,0.521216,0.042871,0,0.465952,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,11,"NVIDIA GeForce RTX 2080 Ti",71.5952,0.507552,0.048802,0,0.45824,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,12,"NVIDIA GeForce RTX 2080 Ti",69.3442,0.497024,0.067327,0,0.456128,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,13,"NVIDIA GeForce RTX 2080 Ti",62.833,0.511392,0.048612,0,0.45664,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,14,"NVIDIA GeForce RTX 2080 Ti",65.9509,0.495328,0.066506,0,0.453312,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,15,"NVIDIA GeForce RTX 2080 Ti",66.0841,0.530752,0.054693,0,0.464896,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,16,"NVIDIA GeForce RTX 2080 Ti",65.6416,0.499136,0.049103,0,0.456896,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,17,"NVIDIA GeForce RTX 2080 Ti",70.6312,0.49792,0.038072,0,0.457216,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,18,"NVIDIA GeForce RTX 2080 Ti",68.2836,0.497152,0.034115,0,0.456192,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,19,"NVIDIA GeForce RTX 2080 Ti",62.8091,0.495296,0.047199,0,0.454656,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,20,"NVIDIA GeForce RTX 2080 Ti",64.8648,0.799232,0.053872,0,0.75568,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,21,"NVIDIA GeForce RTX 2080 Ti",70.6488,0.49696,0.032902,0,0.456704,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,22,"NVIDIA GeForce RTX 2080 Ti",66.2623,0.499008,0.049754,0,0.458752,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,23,"NVIDIA GeForce RTX 2080 Ti",63.1523,0.515872,0.03709,0,0.473088,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,24,"NVIDIA GeForce RTX 2080 Ti",66.441,0.496032,0.034124,0,0.45568,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,25,"NVIDIA GeForce RTX 2080 Ti",83.2142,0.495552,0.055845,0,0.454752,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,26,"NVIDIA GeForce RTX 2080 Ti",72.8758,0.49664,0.058571,0,0.454656,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,27,"NVIDIA GeForce RTX 2080 Ti",76.8311,0.498912,0.050295,0,0.458016,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,28,"NVIDIA GeForce RTX 2080 Ti",79.5977,0.500512,0.052519,0,0.458752,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,29,"NVIDIA GeForce RTX 2080 Ti",101.698,0.500352,0.13773,0,0.458656,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",8.95913,0.137952,0.067387,0.0304,0.04128,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",8.34064,0.137568,0.038202,0.030304,0.041152,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",8.46145,0.138816,0.041989,0.029792,0.04048,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",9.44575,0.137248,0.052169,0.030336,0.040768,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",10.9972,0.137312,0.106932,0.029984,0.040896,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",10.6868,0.138496,0.049323,0.03024,0.041184,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",10.5217,0.138496,0.073699,0.030848,0.040832,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",10.0089,0.137632,0.039474,0.029888,0.040832,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",7.88794,0.137856,0.046898,0.029856,0.041056,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",8.76643,0.137344,0.03712,0.030144,0.040928,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",8.16545,0.16992,0.045776,0.030592,0.070464,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",8.38907,0.137664,0.045136,0.029472,0.04064,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",7.80729,0.13856,0.048392,0.029696,0.040672,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",10.1708,0.13808,0.045506,0.030112,0.04048,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",12.4691,0.137664,0.054413,0.030016,0.040832,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",10.4292,0.140192,0.041609,0.032192,0.041216,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",9.96744,0.138528,0.050815,0.030976,0.040704,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",9.02957,0.14384,0.10077,0.032992,0.042592,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",11.8813,0.142272,0.07947,0.031936,0.04032,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",11.0134,0.139424,0.038443,0.031488,0.040192,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",7.52869,0.13744,0.041679,0.029728,0.039904,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",9.41294,0.138912,0.058531,0.029856,0.0416,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",8.55357,0.138688,0.070293,0.030592,0.0408,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",8.55697,0.13824,0.038102,0.030112,0.041056,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",10.6812,0.13728,0.044404,0.029632,0.040608,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",13.9002,0.138304,0.04277,0.030496,0.041184,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",10.5238,0.138784,0.046799,0.030176,0.041472,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",10.3655,0.1384,0.050165,0.030016,0.04048,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",8.51982,0.138112,0.047108,0.029952,0.04112,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",9.2843,0.1392,0.072847,0.030176,0.0416,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",8.4629,0.203808,0.041458,0.043712,0.04016,0.0424,0.005088,0.005856,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",7.80593,0.201824,0.035457,0.042656,0.039744,0.041344,0.0048,0.0056,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",9.69801,0.204928,0.048061,0.04336,0.040608,0.04256,0.00528,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",12.8397,0.2568,0.043883,0.070592,0.064384,0.041376,0.005248,0.006784,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",15.4456,0.202496,0.042249,0.0424,0.039808,0.04144,0.005024,0.007104,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",9.64483,0.202784,0.057318,0.042592,0.039776,0.04096,0.005536,0.006752,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",8.79102,0.203968,0.048792,0.043328,0.0392,0.042528,0.004896,0.005824,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",8.52589,0.202336,0.033323,0.0432,0.03872,0.042304,0.005088,0.005856,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",8.282,0.2032,0.046958,0.043456,0.040096,0.041376,0.005056,0.00656,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",8.32458,0.202976,0.043823,0.04272,0.040064,0.041024,0.005568,0.006592,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",8.26022,0.203168,0.049344,0.04368,0.039968,0.04128,0.004896,0.006592,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",10.0599,0.202624,0.058099,0.043488,0.039872,0.041568,0.005216,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",9.30114,0.202784,0.041267,0.043328,0.039776,0.041824,0.005024,0.00656,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",9.06214,0.202464,0.041458,0.042784,0.039904,0.04096,0.0056,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",10.8207,0.232128,0.04252,0.042624,0.053952,0.0576,0.005088,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",10.9049,0.2024,0.045235,0.042816,0.039232,0.04096,0.005888,0.0064,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",10.9397,0.20464,0.082085,0.042784,0.039648,0.042592,0.005216,0.006976,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",9.05887,0.202848,0.033884,0.042912,0.04032,0.041664,0.0048,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",8.51492,0.203264,0.03718,0.042816,0.03984,0.042208,0.004832,0.006208,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",10.3224,0.205248,0.043623,0.043808,0.04016,0.042304,0.004832,0.007488,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",8.94971,0.203552,0.044895,0.043488,0.04016,0.041312,0.005056,0.006592,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",8.98899,0.203136,0.038443,0.04288,0.039232,0.042496,0.004832,0.00592,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",9.26466,0.202752,0.035186,0.042848,0.039328,0.04256,0.0048,0.005888,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",9.04568,0.202752,0.053111,0.04288,0.040064,0.041824,0.004832,0.005568,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",14.1947,0.202752,0.061326,0.043648,0.040224,0.04112,0.005024,0.006592,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",17.6869,0.20576,0.060774,0.044384,0.039584,0.04208,0.005344,0.005824,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",11.3059,0.202688,0.041458,0.042816,0.039104,0.042016,0.004832,0.0064,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",8.60399,0.2344,0.061185,0.057536,0.056544,0.041568,0.005408,0.00656,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",8.09649,0.203008,0.045255,0.043072,0.040544,0.041312,0.005152,0.00672,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",9.14007,0.204736,0.070563,0.043168,0.040192,0.041696,0.005376,0.006912,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+occluded,direct,0,"NVIDIA GeForce RTX 2080 Ti",67.9203,0.49616,0.045866,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,1,"NVIDIA GeForce RTX 2080 Ti",63.9858,0.496288,0.052629,0,0.455232,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,2,"NVIDIA GeForce RTX 2080 Ti",53.3949,0.494656,0.038362,0,0.45392,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,3,"NVIDIA GeForce RTX 2080 Ti",65.0744,0.495296,0.036208,0,0.452864,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,4,"NVIDIA GeForce RTX 2080 Ti",63.4083,0.499264,0.04782,0,0.4576,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,5,"NVIDIA GeForce RTX 2080 Ti",66.6435,0.496192,0.059342,0,0.454784,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,6,"NVIDIA GeForce RTX 2080 Ti",73.2405,0.539328,0.058921,0,0.462848,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,7,"NVIDIA GeForce RTX 2080 Ti",69.8945,0.495584,0.045846,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,8,"NVIDIA GeForce RTX 2080 Ti",64.2085,0.502496,0.045977,0,0.4576,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,9,"NVIDIA GeForce RTX 2080 Ti",73.6065,0.49664,0.05267,0,0.455968,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,10,"NVIDIA GeForce RTX 2080 Ti",68.9732,0.497184,0.045917,0,0.456608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,11,"NVIDIA GeForce RTX 2080 Ti",63.9363,0.5304,0.037681,0,0.459744,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,12,"NVIDIA GeForce RTX 2080 Ti",69.4305,0.528224,0.060094,0,0.458752,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,13,"NVIDIA GeForce RTX 2080 Ti",65.4904,0.497088,0.045195,0,0.455552,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,14,"NVIDIA GeForce RTX 2080 Ti",73.3385,0.497472,0.044174,0,0.456288,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,15,"NVIDIA GeForce RTX 2080 Ti",69.4333,0.522112,0.053852,0,0.461824,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,16,"NVIDIA GeForce RTX 2080 Ti",60.9449,0.497952,0.046247,0,0.457536,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,17,"NVIDIA GeForce RTX 2080 Ti",64.5763,0.495488,0.052259,0,0.4536,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,18,"NVIDIA GeForce RTX 2080 Ti",61.0378,0.51904,0.034064,0,0.466944,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,19,"NVIDIA GeForce RTX 2080 Ti",63.1849,0.494656,0.048982,0,0.452896,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,20,"NVIDIA GeForce RTX 2080 Ti",73.5758,0.497984,0.050365,0,0.45712,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,21,"NVIDIA GeForce RTX 2080 Ti",71.5768,0.498976,0.079099,0,0.457888,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,22,"NVIDIA GeForce RTX 2080 Ti",67.6747,0.494304,0.059432,0,0.454176,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,23,"NVIDIA GeForce RTX 2080 Ti",73.4275,0.498656,0.159682,0,0.458208,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,24,"NVIDIA GeForce RTX 2080 Ti",80.4729,0.500576,0.065935,0,0.458752,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,25,"NVIDIA GeForce RTX 2080 Ti",65.3781,0.499584,0.050365,0,0.458752,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,26,"NVIDIA GeForce RTX 2080 Ti",70.5348,0.496544,0.051587,0,0.454784,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,27,"NVIDIA GeForce RTX 2080 Ti",82.9748,0.494912,0.042921,0,0.45344,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,28,"NVIDIA GeForce RTX 2080 Ti",67.384,0.49536,0.033192,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,29,"NVIDIA GeForce RTX 2080 Ti",59.4325,0.496416,0.046227,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",8.43271,0.140032,0.061696,0.030496,0.041344,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",10.0304,0.141248,0.03715,0.030848,0.041536,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",10.2362,0.140896,0.046087,0.031072,0.042656,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",7.56024,0.137696,0.050475,0.03088,0.039936,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",8.91844,0.140032,0.07945,0.030592,0.042912,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",10.2508,0.137088,0.046868,0.030496,0.04032,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",22.7088,0.137088,0.050105,0.030272,0.03936,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",10.6919,0.138336,0.044604,0.03072,0.04096,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",10.1306,0.138496,0.047009,0.030496,0.041024,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",10.9794,0.141056,0.070253,0.031232,0.042336,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",11.5434,0.139648,0.049323,0.029984,0.042784,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",7.9976,0.137888,0.05316,0.029664,0.040608,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",9.51853,0.140192,0.047379,0.02992,0.0432,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",7.85251,0.138432,0.043953,0.030304,0.041248,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",11.7782,0.137504,0.060735,0.029824,0.040512,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",17.0224,0.137376,0.064853,0.029952,0.040384,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",17.0039,0.143296,0.05864,0.030528,0.043872,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",8.50052,0.139104,0.039074,0.02928,0.042464,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",10.3271,0.138368,0.062397,0.030048,0.04048,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",8.19447,0.139776,0.041017,0.030496,0.04256,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",9.29536,0.138464,0.062097,0.030464,0.040064,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",10.4491,0.138432,0.036819,0.030176,0.041504,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",7.26475,0.139104,0.03734,0.0312,0.041888,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",9.25864,0.137472,0.047249,0.02992,0.040256,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",9.80198,0.139712,0.045796,0.030464,0.041216,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",10.8398,0.137504,0.051136,0.030272,0.040416,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",9.50964,0.142272,0.045586,0.030624,0.043232,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",8.77134,0.136992,0.044764,0.029696,0.040032,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",7.26273,0.138752,0.049874,0.030304,0.041376,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",8.8978,0.137824,0.040416,0.030112,0.040032,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",9.75437,0.191072,0.050806,0.04256,0.01888,0.044032,0.012288,0.006656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",8.62357,0.18688,0.044734,0.040032,0.019328,0.042208,0.012416,0.00656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",9.23613,0.18832,0.057429,0.04144,0.019072,0.041888,0.012704,0.005728,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",12.8332,0.189824,0.059652,0.041888,0.018208,0.043168,0.012672,0.0056,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",14.9023,0.1896,0.045025,0.041568,0.019456,0.041952,0.012704,0.0072,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",10.645,0.187808,0.047088,0.041184,0.018336,0.042304,0.012416,0.006528,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",10.2168,0.189888,0.072357,0.042656,0.01904,0.042336,0.012192,0.00688,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",12.1338,0.190176,0.049383,0.042336,0.019296,0.04176,0.012864,0.006688,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",9.38212,0.189536,0.03733,0.041344,0.020096,0.041632,0.012352,0.006112,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",9.42421,0.189504,0.045626,0.041952,0.018336,0.043008,0.012736,0.005696,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",9.11712,0.188224,0.059662,0.04208,0.019008,0.041312,0.012768,0.006848,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",10.7603,0.190112,0.03686,0.042944,0.018496,0.042688,0.012576,0.006176,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",12.7976,0.188736,0.05301,0.041472,0.019296,0.041632,0.012448,0.005984,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",10.8626,0.188928,0.050786,0.042656,0.01872,0.042688,0.012416,0.006336,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",11.5001,0.188064,0.039695,0.040896,0.018624,0.04256,0.012416,0.006464,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",10.7848,0.216032,0.050165,0.045056,0.032832,0.051488,0.013376,0.00656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",9.35389,0.188928,0.053952,0.04288,0.018528,0.042752,0.012416,0.006272,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",9.39643,0.191744,0.053091,0.042016,0.020512,0.04192,0.0128,0.005632,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",11.2917,0.21504,0.050625,0.060864,0.020608,0.045024,0.013216,0.007552,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",11.3609,0.223424,0.049043,0.04208,0.018752,0.076352,0.013024,0.00736,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",11.0247,0.187584,0.048712,0.041984,0.018944,0.041472,0.012576,0.005856,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",10.8042,0.188896,0.046779,0.042304,0.019072,0.042048,0.012384,0.00656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",11.0857,0.187648,0.036729,0.041888,0.018912,0.0416,0.012288,0.006144,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",12.7266,0.188576,0.054553,0.041568,0.019424,0.041408,0.012864,0.006624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",11.586,0.186688,0.036609,0.041632,0.017728,0.042304,0.012448,0.00656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",10.3779,0.189376,0.064271,0.041184,0.019008,0.042528,0.012288,0.006624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",9.70681,0.187872,0.045847,0.0416,0.019072,0.041728,0.012416,0.006016,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",7.90455,0.188864,0.039455,0.04112,0.018784,0.04256,0.012256,0.006528,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",8.77106,0.189472,0.044614,0.041504,0.019776,0.041152,0.013024,0.006976,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",7.87348,0.188288,0.045245,0.041248,0.018816,0.042752,0.012192,0.006496,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0

docs/studies/data/p2-2026-09-23-optimized-run-3.csv

@@ -0,0 +1,271 @@
+scenario,mode,frame,device,cpu_ms,gpu_ms,readback_cpu_ms,gpu_main_cull_ms,gpu_main_raster_ms,gpu_hzb_ms,gpu_post_cull_ms,gpu_post_raster_ms,gpu_bytes,draw_calls,gpu_bins,gpu_visible,gpu_frustum_rejected,gpu_deferred,gpu_post_visible,lod0,lod1,lod2,lod3,hzb_valid,gpu_visibility_active,visibility_diagnostics,visibility_counters_valid,validation_errors
+frustum,direct,0,"NVIDIA GeForce RTX 2080 Ti",67.4901,0.233888,0.041528,0,0.192736,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,1,"NVIDIA GeForce RTX 2080 Ti",73.2334,0.236128,0.065003,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,2,"NVIDIA GeForce RTX 2080 Ti",69.5331,0.235712,0.044323,0,0.193408,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,3,"NVIDIA GeForce RTX 2080 Ti",74.6512,0.233472,0.058621,0,0.19216,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,4,"NVIDIA GeForce RTX 2080 Ti",72.2372,0.236096,0.07457,0,0.193504,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,5,"NVIDIA GeForce RTX 2080 Ti",94.5613,0.235392,0.055555,0,0.194336,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,6,"NVIDIA GeForce RTX 2080 Ti",62.8423,0.234208,0.070744,0,0.192512,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,7,"NVIDIA GeForce RTX 2080 Ti",70.1894,0.235104,0.032421,0,0.194528,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,8,"NVIDIA GeForce RTX 2080 Ti",66.8636,0.234208,0.05304,0,0.192576,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,9,"NVIDIA GeForce RTX 2080 Ti",87.9378,0.250592,0.043272,0,0.202144,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,10,"NVIDIA GeForce RTX 2080 Ti",68.1154,0.234464,0.041759,0,0.192864,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,11,"NVIDIA GeForce RTX 2080 Ti",67.8036,0.234528,0.042269,0,0.193888,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,12,"NVIDIA GeForce RTX 2080 Ti",66.4518,0.234944,0.07953,0,0.192416,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,13,"NVIDIA GeForce RTX 2080 Ti",56.6188,0.234624,0.035937,0,0.194144,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,14,"NVIDIA GeForce RTX 2080 Ti",69.0979,0.360512,0.06902,0,0.317376,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,15,"NVIDIA GeForce RTX 2080 Ti",67.6927,0.235616,0.055435,0,0.192512,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,16,"NVIDIA GeForce RTX 2080 Ti",63.5543,0.232544,0.046898,0,0.191808,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,17,"NVIDIA GeForce RTX 2080 Ti",67.343,0.233152,0.044945,0,0.19232,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,18,"NVIDIA GeForce RTX 2080 Ti",67.3328,0.36368,0.072276,0,0.321536,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,19,"NVIDIA GeForce RTX 2080 Ti",59.6678,0.234208,0.044224,0,0.193024,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,20,"NVIDIA GeForce RTX 2080 Ti",69.3874,0.274688,0.042761,0,0.233472,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,21,"NVIDIA GeForce RTX 2080 Ti",64.5704,0.235104,0.06888,0,0.193792,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,22,"NVIDIA GeForce RTX 2080 Ti",61.3201,0.234336,0.040346,0,0.193856,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,23,"NVIDIA GeForce RTX 2080 Ti",66.7304,0.233664,0.032351,0,0.193536,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,24,"NVIDIA GeForce RTX 2080 Ti",66.7892,0.23712,0.053702,0,0.19568,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,25,"NVIDIA GeForce RTX 2080 Ti",57.9125,0.233504,0.038182,0,0.192288,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,26,"NVIDIA GeForce RTX 2080 Ti",65.4209,0.234976,0.049443,0,0.192896,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,27,"NVIDIA GeForce RTX 2080 Ti",66.9875,0.236096,0.067708,0,0.195936,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,28,"NVIDIA GeForce RTX 2080 Ti",59.9511,0.234688,0.048942,0,0.194144,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,29,"NVIDIA GeForce RTX 2080 Ti",64.6067,0.231616,0.040777,0,0.190784,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",8.23725,0.155648,0.043683,0.046752,0.039168,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",8.23789,0.14816,0.032251,0.030432,0.031168,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",7.82935,0.12352,0.03722,0.03104,0.02608,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",13.6248,0.123232,0.06327,0.029632,0.025728,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",19.8977,0.126144,0.065213,0.030464,0.027168,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",10.1094,0.123136,0.050024,0.029728,0.026016,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",7.88657,0.123616,0.039234,0.029632,0.025664,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",8.41917,0.123712,0.047159,0.030176,0.025792,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",7.32443,0.124096,0.040656,0.030432,0.025376,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",8.47618,0.123328,0.043402,0.030048,0.02624,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",7.99181,0.122944,0.038192,0.030112,0.025472,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",14.3706,0.123328,0.049814,0.030304,0.02624,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",22.9687,0.123488,0.053892,0.031104,0.02624,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",9.87975,0.124832,0.043131,0.031392,0.0264,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",9.71613,0.123584,0.046678,0.029888,0.026944,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",8.14497,0.123104,0.034315,0.03056,0.026048,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",10.0349,0.155904,0.069922,0.047392,0.038624,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",8.16716,0.122624,0.048823,0.030304,0.026112,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",10.5119,0.123744,0.053712,0.030528,0.025984,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",9.55845,0.123936,0.049503,0.02944,0.026496,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",8.31607,0.122912,0.058671,0.029856,0.025504,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",9.82402,0.156064,0.038753,0.04784,0.0384,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",12.12,0.122784,0.054633,0.030752,0.026016,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",8.52745,0.123168,0.040256,0.02992,0.025536,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",8.91408,0.122752,0.03181,0.029824,0.025888,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",8.5806,0.12288,0.048832,0.030656,0.026048,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",7.1309,0.123488,0.036109,0.030304,0.026912,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",9.27608,0.123552,0.042711,0.030304,0.025664,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",7.61348,0.156384,0.04233,0.046848,0.039488,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",8.36717,0.123392,0.052679,0.030432,0.026208,0,0,0,5417552,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",9.28164,0.186048,0.04239,0.038848,0.027808,0.041888,0.004992,0.006784,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",16.1595,0.186272,0.051186,0.037344,0.028256,0.04192,0.005408,0.006784,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",15.9498,0.185376,0.052359,0.037856,0.02736,0.04176,0.005216,0.006592,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",14.276,0.19136,0.054122,0.038432,0.029504,0.042944,0.005216,0.007136,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",8.04813,0.185888,0.048842,0.037792,0.026176,0.042656,0.00496,0.00752,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",7.60166,0.186272,0.033833,0.03888,0.02816,0.041504,0.005376,0.00656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",8.75918,0.185824,0.055434,0.037184,0.027936,0.041728,0.005088,0.006848,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",7.93254,0.185728,0.034294,0.037568,0.027968,0.042048,0.004768,0.006432,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",9.08583,0.185376,0.06889,0.038208,0.027328,0.042432,0.004768,0.006048,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",8.93284,0.186592,0.040837,0.038784,0.028032,0.041728,0.005216,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",8.03943,0.186592,0.043913,0.037888,0.028,0.041376,0.005696,0.006592,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",9.39525,0.183712,0.035577,0.037152,0.026944,0.042016,0.004928,0.006304,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",10.1584,0.184896,0.036028,0.037568,0.027456,0.04176,0.005056,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",12.0164,0.18672,0.051387,0.038048,0.027488,0.04288,0.004896,0.006592,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",10.8602,0.185888,0.038603,0.03776,0.027936,0.041536,0.005248,0.006624,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",8.00995,0.185248,0.030137,0.037824,0.026336,0.042752,0.004896,0.0056,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",8.05685,0.184384,0.038683,0.037408,0.026176,0.042656,0.004896,0.005696,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",9.0658,0.186144,0.047039,0.037888,0.027552,0.04192,0.005088,0.006624,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",9.59719,0.188288,0.060754,0.03856,0.027296,0.042976,0.005088,0.007136,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",10.8581,0.18768,0.061736,0.038496,0.02704,0.042784,0.00512,0.007392,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",8.86519,0.187552,0.054924,0.038592,0.027328,0.042784,0.004992,0.006816,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",10.7128,0.186656,0.042911,0.038528,0.028288,0.042112,0.005152,0.00656,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",14.6907,0.187424,0.051287,0.03776,0.028032,0.04224,0.005248,0.00576,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",10.0629,0.185792,0.051306,0.03824,0.027296,0.042304,0.004896,0.006048,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",8.91609,0.186176,0.050255,0.0376,0.027936,0.04256,0.004928,0.00576,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",9.25932,0.184352,0.039965,0.037184,0.026976,0.042272,0.004896,0.00608,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",8.42078,0.186464,0.054262,0.037792,0.029312,0.04144,0.005088,0.006528,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",9.23474,0.187072,0.039474,0.037696,0.028192,0.042144,0.00496,0.006304,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",9.98286,0.185376,0.043412,0.038688,0.026848,0.042528,0.004896,0.005824,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",9.04403,0.186912,0.045596,0.03856,0.026976,0.042624,0.004864,0.006944,6819408,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+open,direct,0,"NVIDIA GeForce RTX 2080 Ti",64.4396,0.49648,0.04737,0,0.456192,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,1,"NVIDIA GeForce RTX 2080 Ti",58.0176,0.495328,0.05311,0,0.455136,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,2,"NVIDIA GeForce RTX 2080 Ti",59.9502,0.496384,0.03711,0,0.4552,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,3,"NVIDIA GeForce RTX 2080 Ti",67.3886,0.730176,0.060614,0,0.688544,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,4,"NVIDIA GeForce RTX 2080 Ti",56.4472,0.498496,0.044785,0,0.458752,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,5,"NVIDIA GeForce RTX 2080 Ti",66.2251,0.500224,0.044694,0,0.459072,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,6,"NVIDIA GeForce RTX 2080 Ti",68.0461,0.52704,0.049523,0,0.46112,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,7,"NVIDIA GeForce RTX 2080 Ti",60.2179,0.498144,0.032361,0,0.4576,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,8,"NVIDIA GeForce RTX 2080 Ti",65.268,0.497056,0.061966,0,0.456192,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,9,"NVIDIA GeForce RTX 2080 Ti",64.3224,0.735392,0.054052,0,0.692224,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,10,"NVIDIA GeForce RTX 2080 Ti",61.3496,0.499264,0.043252,0,0.45872,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,11,"NVIDIA GeForce RTX 2080 Ti",64.5657,0.49824,0.034716,0,0.457536,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,12,"NVIDIA GeForce RTX 2080 Ti",62.4987,0.497248,0.045686,0,0.456704,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,13,"NVIDIA GeForce RTX 2080 Ti",66.1241,0.501472,0.037981,0,0.454656,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,14,"NVIDIA GeForce RTX 2080 Ti",66.4261,0.495488,0.041929,0,0.454656,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,15,"NVIDIA GeForce RTX 2080 Ti",68.2954,0.495328,0.054984,0,0.45568,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,16,"NVIDIA GeForce RTX 2080 Ti",69.2105,0.497184,0.056446,0,0.456416,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,17,"NVIDIA GeForce RTX 2080 Ti",68.8537,0.536608,0.045866,0,0.464896,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,18,"NVIDIA GeForce RTX 2080 Ti",64.8945,0.495808,0.052288,0,0.456,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,19,"NVIDIA GeForce RTX 2080 Ti",76.0082,0.496256,0.055124,0,0.45664,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,20,"NVIDIA GeForce RTX 2080 Ti",74.2833,0.49632,0.056236,0,0.4544,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,21,"NVIDIA GeForce RTX 2080 Ti",72.3056,0.497088,0.044945,0,0.456256,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,22,"NVIDIA GeForce RTX 2080 Ti",60.9426,0.496384,0.038763,0,0.455936,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,23,"NVIDIA GeForce RTX 2080 Ti",64.2515,0.49472,0.036468,0,0.454432,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,24,"NVIDIA GeForce RTX 2080 Ti",60.9964,0.746976,0.054253,0,0.7064,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,25,"NVIDIA GeForce RTX 2080 Ti",67.4297,0.517056,0.069792,0,0.465536,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,26,"NVIDIA GeForce RTX 2080 Ti",70.3453,0.49712,0.044484,0,0.456704,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,27,"NVIDIA GeForce RTX 2080 Ti",57.5937,0.497088,0.046618,0,0.456768,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,28,"NVIDIA GeForce RTX 2080 Ti",65.3587,0.529568,0.03686,0,0.463936,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,29,"NVIDIA GeForce RTX 2080 Ti",64.4943,0.501056,0.035837,0,0.45952,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",8.6352,0.13904,0.05836,0.029632,0.042144,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",9.05267,0.187584,0.04768,0.048032,0.070752,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",8.65342,0.139488,0.056887,0.029984,0.041888,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",19.2678,0.1384,0.072226,0.030432,0.042464,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",14.3476,0.13984,0.071165,0.030048,0.04256,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",11.3512,0.140128,0.06355,0.0296,0.04272,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",11.213,0.139552,0.053742,0.029632,0.04272,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",11.5847,0.13936,0.062307,0.029824,0.042464,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",10.643,0.13952,0.064913,0.030592,0.042624,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",12.2985,0.140384,0.076283,0.029696,0.043456,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",11.0792,0.13952,0.054253,0.030528,0.042656,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",11.3426,0.139072,0.057849,0.030656,0.042336,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",9.90738,0.1392,0.046357,0.030048,0.041632,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",18.989,0.139328,0.061706,0.030112,0.041792,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",11.276,0.139904,0.059402,0.03056,0.042656,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",10.8583,0.140768,0.081494,0.030304,0.042304,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",9.70736,0.139712,0.059742,0.030336,0.042528,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",10.3601,0.13984,0.062959,0.029728,0.042144,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",9.41402,0.139456,0.06343,0.029792,0.041952,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",9.73082,0.14464,0.060424,0.029504,0.042528,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",10.2232,0.139488,0.044994,0.030592,0.042464,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",11.342,0.163936,0.043032,0.030176,0.053792,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",12.4635,0.139072,0.053641,0.02944,0.042624,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",10.7382,0.138528,0.041889,0.02992,0.04176,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",11.4175,0.14032,0.054172,0.03008,0.042304,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",10.1806,0.139936,0.056346,0.030592,0.042784,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",10.1526,0.171712,0.06919,0.031104,0.056864,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",11.6436,0.13968,0.047299,0.030112,0.042304,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",9.98992,0.139776,0.072687,0.029632,0.04272,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",8.98136,0.150432,0.045035,0.040384,0.04208,0,0,0,5417552,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",15.4406,0.208256,0.060675,0.046656,0.041408,0.042336,0.005024,0.005888,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",16.9006,0.205024,0.053551,0.043392,0.040864,0.041504,0.00512,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",14.9356,0.20496,0.058431,0.04272,0.04128,0.0416,0.00512,0.006784,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",9.69331,0.203072,0.046227,0.041536,0.04208,0.041312,0.004864,0.006592,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",7.67454,0.20464,0.03144,0.043104,0.040864,0.042048,0.004832,0.006368,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",8.91389,0.240064,0.049473,0.042944,0.04128,0.076416,0.005504,0.006144,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",8.41653,0.204288,0.041979,0.042976,0.040992,0.042336,0.0048,0.006112,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",7.85512,0.26832,0.055044,0.069504,0.070496,0.044768,0.006144,0.007616,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",8.08804,0.204064,0.037861,0.043584,0.040384,0.0424,0.00496,0.005888,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",8.16941,0.203808,0.045956,0.043136,0.040832,0.042048,0.004832,0.006368,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",12.6278,0.20304,0.057929,0.042656,0.041312,0.041568,0.005024,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",12.9564,0.204448,0.041519,0.043072,0.04128,0.041408,0.005088,0.006624,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",12.8892,0.204704,0.059122,0.043552,0.04192,0.041504,0.004832,0.006688,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",9.84178,0.205696,0.04239,0.043392,0.041472,0.04224,0.004832,0.006176,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",8.49582,0.255776,0.031079,0.04688,0.053472,0.060096,0.005152,0.006432,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",9.14433,0.206624,0.055004,0.044256,0.041696,0.042432,0.004992,0.007072,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",11.326,0.204672,0.04798,0.042688,0.04128,0.042496,0.004896,0.005856,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",8.86254,0.204672,0.038933,0.043008,0.041184,0.0424,0.004896,0.005952,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",8.03203,0.203552,0.035297,0.04352,0.040448,0.0424,0.004832,0.006016,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",8.25494,0.20448,0.033513,0.043008,0.041408,0.041312,0.004832,0.007136,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",7.51362,0.203712,0.035297,0.042656,0.041632,0.041312,0.004832,0.006528,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",9.89206,0.204704,0.050986,0.043008,0.041472,0.041184,0.005216,0.006816,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",22.9562,0.217344,0.053631,0.0416,0.042112,0.041568,0.005088,0.006624,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",10.6307,0.205632,0.06405,0.043328,0.04192,0.041568,0.004896,0.006784,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",12.4421,0.20352,0.050595,0.043264,0.041632,0.041344,0.004864,0.006016,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",9.48528,0.204448,0.037431,0.043744,0.042112,0.041408,0.005024,0.00656,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",9.44922,0.204256,0.045666,0.042976,0.041536,0.041376,0.005024,0.00656,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",8.78257,0.204192,0.033113,0.043488,0.041856,0.041248,0.0048,0.006912,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",9.16427,0.203296,0.037461,0.042496,0.041504,0.041216,0.004864,0.00608,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",13.5869,0.204352,0.04809,0.042848,0.04112,0.041664,0.00512,0.006464,6819408,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+occluded,direct,0,"NVIDIA GeForce RTX 2080 Ti",72.0395,0.493824,0.069381,0,0.454208,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,1,"NVIDIA GeForce RTX 2080 Ti",63.9924,0.493344,0.055735,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,2,"NVIDIA GeForce RTX 2080 Ti",70.1858,0.494432,0.044984,0,0.453056,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,3,"NVIDIA GeForce RTX 2080 Ti",69.0933,0.492736,0.037891,0,0.452416,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,4,"NVIDIA GeForce RTX 2080 Ti",69.3276,0.493696,0.087234,0,0.453664,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,5,"NVIDIA GeForce RTX 2080 Ti",58.6939,0.49344,0.043322,0,0.453696,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,6,"NVIDIA GeForce RTX 2080 Ti",64.9665,0.49152,0.036649,0,0.45184,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,7,"NVIDIA GeForce RTX 2080 Ti",58.7955,0.53232,0.039946,0,0.460512,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,8,"NVIDIA GeForce RTX 2080 Ti",71.5945,0.493632,0.291701,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,9,"NVIDIA GeForce RTX 2080 Ti",74.2933,0.522944,0.054122,0,0.456992,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,10,"NVIDIA GeForce RTX 2080 Ti",67.4207,0.494624,0.045396,0,0.454592,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,11,"NVIDIA GeForce RTX 2080 Ti",69.9245,0.495648,0.057008,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,12,"NVIDIA GeForce RTX 2080 Ti",78.8739,0.49456,0.112503,0,0.454016,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,13,"NVIDIA GeForce RTX 2080 Ti",76.0727,0.49408,0.044093,0,0.452736,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,14,"NVIDIA GeForce RTX 2080 Ti",70.7361,0.495424,0.050385,0,0.454368,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,15,"NVIDIA GeForce RTX 2080 Ti",64.616,0.493632,0.051627,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,16,"NVIDIA GeForce RTX 2080 Ti",67.4304,0.565536,0.051988,0,0.523232,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,17,"NVIDIA GeForce RTX 2080 Ti",70.1538,0.494656,0.046908,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,18,"NVIDIA GeForce RTX 2080 Ti",57.7371,0.518432,0.042841,0,0.456672,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,19,"NVIDIA GeForce RTX 2080 Ti",64.522,0.493824,0.036539,0,0.453728,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,20,"NVIDIA GeForce RTX 2080 Ti",65.9956,0.495136,0.051898,0,0.454496,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,21,"NVIDIA GeForce RTX 2080 Ti",58.7591,0.49696,0.041589,0,0.446752,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,22,"NVIDIA GeForce RTX 2080 Ti",69.3101,0.525056,0.035958,0,0.460064,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,23,"NVIDIA GeForce RTX 2080 Ti",80.0559,0.491904,0.081023,0,0.449088,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,24,"NVIDIA GeForce RTX 2080 Ti",63.8609,0.525824,0.04787,0,0.461504,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,25,"NVIDIA GeForce RTX 2080 Ti",70.8083,0.496512,0.090501,0,0.45536,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,26,"NVIDIA GeForce RTX 2080 Ti",65.0395,0.495424,0.045085,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,27,"NVIDIA GeForce RTX 2080 Ti",72.6645,0.514176,0.04792,0,0.464608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,28,"NVIDIA GeForce RTX 2080 Ti",76.5585,0.533536,0.058521,0,0.458752,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,29,"NVIDIA GeForce RTX 2080 Ti",64.427,0.493984,0.059602,0,0.452672,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",11.5289,0.137696,0.03199,0.030464,0.039424,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",8.77561,0.136416,0.054192,0.030176,0.039104,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",9.44827,0.137152,0.03166,0.03056,0.04048,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",9.44359,0.13696,0.045986,0.0304,0.039232,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",8.42381,0.135616,0.048532,0.029536,0.038912,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",9.49471,0.140608,0.043522,0.03104,0.04112,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",7.82336,0.138944,0.041979,0.031712,0.039424,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",9.29054,0.136736,0.041579,0.02992,0.039776,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",16.1594,0.13792,0.054563,0.02976,0.040288,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",16.6257,0.135904,0.049513,0.030784,0.038848,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",9.42571,0.187936,0.036148,0.047488,0.070656,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",7.99912,0.136384,0.042881,0.029376,0.040128,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",7.44392,0.135744,0.034686,0.03008,0.039008,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",11.6971,0.139072,0.048452,0.030112,0.04144,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",10.9917,0.13552,0.048381,0.029568,0.038912,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",11.2683,0.13712,0.067407,0.029792,0.03984,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",9.21603,0.137536,0.037741,0.02976,0.040608,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",9.75108,0.137024,0.048983,0.029856,0.040256,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",10.6004,0.138016,0.04241,0.029568,0.040256,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",11.998,0.13712,0.043442,0.030784,0.040192,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",16.0927,0.13904,0.164521,0.030784,0.040768,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",11.4503,0.138784,0.044714,0.02992,0.040704,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",11.1066,0.136448,0.039865,0.029632,0.039744,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",9.78753,0.136928,0.04219,0.030688,0.04032,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",7.80913,0.135872,0.033403,0.030432,0.038912,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",8.51336,0.137152,0.03687,0.030048,0.040896,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",9.89724,0.135456,0.039775,0.029984,0.037696,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",12.0487,0.136256,0.05315,0.030368,0.038208,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",11.5522,0.156512,0.048972,0.03504,0.039232,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",11.6254,0.138016,0.15921,0.030848,0.04048,0,0,0,5418080,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",8.52137,0.194784,0.046768,0.041632,0.01872,0.04096,0.013152,0.006592,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",11.3129,0.188896,0.060374,0.040896,0.018784,0.04176,0.013056,0.006624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",11.457,0.18736,0.050455,0.04048,0.018944,0.041984,0.012416,0.006592,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",12.0558,0.189504,0.04764,0.042848,0.018592,0.042368,0.012416,0.006528,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",11.0588,0.188864,0.060915,0.04256,0.018816,0.041248,0.01264,0.007136,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",16.9926,0.187584,0.0525,0.041856,0.019264,0.041216,0.012704,0.005728,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",11.4371,0.18688,0.047339,0.040544,0.019104,0.041664,0.01248,0.0056,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",10.5963,0.185536,0.035317,0.040416,0.018688,0.041184,0.012416,0.00608,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",10.2081,0.188352,0.057328,0.042528,0.018848,0.041632,0.01248,0.006784,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",9.21582,0.187232,0.044153,0.040608,0.018784,0.042016,0.01248,0.00656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",8.43438,0.187872,0.039655,0.041376,0.018912,0.04176,0.012576,0.006592,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",11.3257,0.186752,0.036879,0.040928,0.018912,0.041312,0.012288,0.006144,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",8.20408,0.188096,0.084759,0.041664,0.019264,0.041408,0.012416,0.0064,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",12.0968,0.187104,0.056146,0.041344,0.018432,0.041696,0.012416,0.00656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",21.321,0.20752,0.038964,0.041408,0.019264,0.060768,0.012736,0.00672,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",13.1759,0.1872,0.043652,0.03968,0.018496,0.042464,0.01248,0.006496,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",8.75432,0.188032,0.055265,0.0408,0.019072,0.042368,0.012512,0.006528,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",9.69946,0.18768,0.086353,0.041376,0.019136,0.041472,0.012704,0.006144,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",9.9436,0.221056,0.041168,0.055488,0.019264,0.0424,0.01296,0.00608,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",10.8525,0.20224,0.068169,0.041728,0.020032,0.041344,0.024928,0.007232,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",10.1771,0.191808,0.038302,0.044768,0.01984,0.041376,0.01232,0.006624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",8.72859,0.189664,0.043041,0.04176,0.019872,0.041792,0.012896,0.00656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",9.45092,0.188704,0.04209,0.041376,0.019072,0.041952,0.012448,0.005984,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",13.7873,0.186784,0.037771,0.040576,0.019072,0.041632,0.012096,0.005664,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",11.2646,0.187264,0.041258,0.04256,0.0184,0.041344,0.012416,0.006112,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",14.4215,0.188352,0.06395,0.041024,0.0192,0.041536,0.012608,0.006528,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",9.60467,0.188224,0.037921,0.040256,0.019392,0.042176,0.012864,0.0064,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",9.34017,0.187584,0.052529,0.041792,0.01904,0.04144,0.012288,0.006176,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",9.13302,0.188096,0.045686,0.041728,0.019712,0.04144,0.012512,0.006656,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",10.2,0.186496,0.038994,0.040448,0.018528,0.0416,0.01248,0.00624,6819936,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0

docs/studies/data/p2-2026-09-23-run-1.csv

@@ -0,0 +1,271 @@
+scenario,mode,frame,device,cpu_ms,gpu_ms,readback_cpu_ms,gpu_main_cull_ms,gpu_main_raster_ms,gpu_hzb_ms,gpu_post_cull_ms,gpu_post_raster_ms,gpu_bytes,draw_calls,gpu_bins,gpu_visible,gpu_frustum_rejected,gpu_deferred,gpu_post_visible,lod0,lod1,lod2,lod3,hzb_valid,gpu_visibility_active,visibility_diagnostics,visibility_counters_valid,validation_errors
+frustum,direct,0,"NVIDIA GeForce RTX 2080 Ti",74.0692,0.240032,0.035046,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,1,"NVIDIA GeForce RTX 2080 Ti",67.3058,0.240576,0.054443,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,2,"NVIDIA GeForce RTX 2080 Ti",66.7667,0.239456,0.04795,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,3,"NVIDIA GeForce RTX 2080 Ti",69.6725,0.240128,0.043583,0,0.19488,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,4,"NVIDIA GeForce RTX 2080 Ti",66.9348,0.239392,0.038142,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,5,"NVIDIA GeForce RTX 2080 Ti",68.7339,0.240832,0.05866,0,0.195872,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,6,"NVIDIA GeForce RTX 2080 Ti",73.6867,0.240288,0.040356,0,0.194688,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,7,"NVIDIA GeForce RTX 2080 Ti",74.0007,0.23872,0.050455,0,0.193184,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,8,"NVIDIA GeForce RTX 2080 Ti",73.1515,0.238496,0.047429,0,0.192864,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,9,"NVIDIA GeForce RTX 2080 Ti",76.679,0.241024,0.043853,0,0.195104,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,10,"NVIDIA GeForce RTX 2080 Ti",66.3907,0.240256,0.050755,0,0.195712,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,11,"NVIDIA GeForce RTX 2080 Ti",87.0981,0.240992,0.06356,0,0.195104,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,12,"NVIDIA GeForce RTX 2080 Ti",90.8851,0.239744,0.083237,0,0.194208,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,13,"NVIDIA GeForce RTX 2080 Ti",78.9936,0.378144,0.045476,0,0.329792,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,14,"NVIDIA GeForce RTX 2080 Ti",77.1545,0.239072,0.056967,0,0.194336,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,15,"NVIDIA GeForce RTX 2080 Ti",69.9802,0.24064,0.046418,0,0.195968,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,16,"NVIDIA GeForce RTX 2080 Ti",67.8533,0.241856,0.03711,0,0.197216,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,17,"NVIDIA GeForce RTX 2080 Ti",68.5841,0.240544,0.049193,0,0.195168,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,18,"NVIDIA GeForce RTX 2080 Ti",63.6544,0.241376,0.048983,0,0.194912,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,19,"NVIDIA GeForce RTX 2080 Ti",73.707,0.23856,0.037321,0,0.194368,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,20,"NVIDIA GeForce RTX 2080 Ti",71.3519,0.370848,0.044955,0,0.323584,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,21,"NVIDIA GeForce RTX 2080 Ti",67.7002,0.238656,0.054913,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,22,"NVIDIA GeForce RTX 2080 Ti",72.1913,0.238528,0.033714,0,0.192896,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,23,"NVIDIA GeForce RTX 2080 Ti",70.2099,0.23904,0.043873,0,0.193888,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,24,"NVIDIA GeForce RTX 2080 Ti",72.6693,0.240576,0.051457,0,0.19616,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,25,"NVIDIA GeForce RTX 2080 Ti",68.3818,0.2368,0.045456,0,0.192256,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,26,"NVIDIA GeForce RTX 2080 Ti",89.9903,0.238624,0.044664,0,0.194432,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,27,"NVIDIA GeForce RTX 2080 Ti",89.151,0.238528,0.055715,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,28,"NVIDIA GeForce RTX 2080 Ti",68.6403,0.240832,0.066766,0,0.195584,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,29,"NVIDIA GeForce RTX 2080 Ti",79.7181,0.264736,0.044183,0,0.197184,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",13.8567,3.59251,0.052358,3.50557,0.043136,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",13.6739,3.61104,0.055554,3.52506,0.041568,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",15.9272,4.53514,0.04777,4.46058,0.029472,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",24.2343,4.17952,0.081233,4.10822,0.028736,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",15.6138,4.90038,0.045967,4.82803,0.02912,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",15.5077,3.71494,0.062328,3.64602,0.025792,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",15.9432,4.05062,0.064783,3.97859,0.027872,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",20.4135,3.59376,0.052539,3.49229,0.057088,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",15.6531,4.21523,0.05289,4.14458,0.027328,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",15.2208,3.7824,0.060183,3.69629,0.04336,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",13.0337,3.9097,0.034144,3.83936,0.027264,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",11.8926,4.15763,0.052129,4.08659,0.02784,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",12.9166,4.48611,0.040145,4.38317,0.060832,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",12.6122,3.60944,0.201671,3.54198,0.025152,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",12.1218,3.5911,0.036298,3.52294,0.0256,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",15.1862,3.64659,0.061216,3.56122,0.041728,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",22.0867,4.0689,0.056858,4.00051,0.02768,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",13.1842,4.18413,0.061977,4.11619,0.026656,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",16.3947,4.41875,0.062728,4.35082,0.02688,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",12.9027,4.58195,0.053231,4.51424,0.026496,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",12.1724,4.07098,0.060234,3.98544,0.043296,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",10.7979,3.45997,0.040877,3.38394,0.035584,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",15.4973,3.94048,0.052459,3.87338,0.025952,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",15.0207,3.65946,0.041609,3.59603,0.022784,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",13.2827,3.892,0.062829,3.81098,0.039744,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",11.3938,3.59715,0.039865,3.5216,0.0352,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",12.0599,4.09907,0.056667,4.03242,0.026048,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",11.9462,4.46182,0.0422,4.39446,0.025568,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",11.6719,3.61667,0.040807,3.55229,0.02352,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",12.2197,3.60854,0.043502,3.52326,0.044352,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",19.4239,4.38106,0.058851,4.2744,0.026272,0.033408,0.004608,0.005632,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",16.1382,3.91712,0.044544,3.81181,0.025984,0.033152,0.004608,0.005248,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",14.603,3.91005,0.046387,3.80413,0.025696,0.033056,0.004704,0.005248,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",12.0357,4.0721,0.047159,3.9663,0.025248,0.034304,0.00448,0.005728,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",12.0385,4.2384,0.044263,4.13261,0.02544,0.03312,0.004736,0.005152,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",13.4353,3.59712,0.05308,3.49421,0.023424,0.033344,0.004576,0.005664,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",17.8825,4.21082,0.050866,4.07024,0.029408,0.064192,0.004736,0.00512,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",15.189,4.47322,0.048101,4.36781,0.026304,0.032896,0.004512,0.005696,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",12.5033,3.96762,0.044955,3.86128,0.026176,0.03312,0.004672,0.005216,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",13.0891,3.64861,0.096993,3.54413,0.02464,0.032736,0.004416,0.006464,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",12.4221,3.95744,0.048652,3.83494,0.025856,0.033472,0.004768,0.005888,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",11.1876,3.49571,0.044134,3.36397,0.024352,0.038912,0.0088,0.017824,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",16.8877,3.87779,0.04247,3.77213,0.026144,0.032768,0.00464,0.005984,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",21.5329,3.70755,0.072888,3.60134,0.023872,0.034016,0.004768,0.006272,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",14.7119,4.40576,0.078939,4.29926,0.026368,0.033216,0.004672,0.005472,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",11.5023,3.94323,0.044194,3.83763,0.026144,0.033152,0.004512,0.005632,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",12.6379,4.24384,0.046007,4.13696,0.02672,0.032928,0.00464,0.0056,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",11.6211,3.70246,0.046799,3.57923,0.043392,0.032768,0.005248,0.004992,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",12.9379,4.34646,0.070674,4.23978,0.026528,0.033024,0.004832,0.005152,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",15.5539,4.41859,0.044144,4.31216,0.025504,0.033568,0.004736,0.006432,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",21.7802,4.51933,0.054953,4.39811,0.028768,0.033632,0.005024,0.006624,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",14.5108,4.05936,0.051507,3.95277,0.026336,0.032992,0.004544,0.005888,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",11.5666,3.43882,0.047049,3.33219,0.0272,0.0328,0.004544,0.0056,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",14.7028,3.62282,0.058881,3.51638,0.024864,0.034048,0.004608,0.006176,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",12.7464,3.48211,0.049624,3.36176,0.039968,0.033184,0.00464,0.005184,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",13.4874,4.04717,0.050665,3.94179,0.025184,0.033824,0.004672,0.00576,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",15.4448,3.67616,0.057839,3.53482,0.056832,0.035552,0.005472,0.006304,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",16.7768,3.75709,0.081904,3.65226,0.023904,0.03344,0.004832,0.006176,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",14.5581,4.07581,0.047339,3.96976,0.026176,0.033056,0.004672,0.00528,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",11.4402,4.26435,0.046047,4.15664,0.02832,0.03312,0.004512,0.005984,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+open,direct,0,"NVIDIA GeForce RTX 2080 Ti",64.2224,0.491776,0.050205,0,0.448224,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,1,"NVIDIA GeForce RTX 2080 Ti",69.9009,0.496192,0.065814,0,0.452608,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,2,"NVIDIA GeForce RTX 2080 Ti",84.9538,0.493248,0.054814,0,0.450144,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,3,"NVIDIA GeForce RTX 2080 Ti",65.9806,0.496448,0.056838,0,0.45296,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,4,"NVIDIA GeForce RTX 2080 Ti",71.8666,0.525632,0.065795,0,0.4608,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,5,"NVIDIA GeForce RTX 2080 Ti",66.6741,0.49392,0.05268,0,0.450432,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,6,"NVIDIA GeForce RTX 2080 Ti",77.1584,0.495392,0.04761,0,0.452448,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,7,"NVIDIA GeForce RTX 2080 Ti",69.9233,0.49552,0.045195,0,0.452416,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,8,"NVIDIA GeForce RTX 2080 Ti",65.3531,0.496832,0.058671,0,0.453632,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,9,"NVIDIA GeForce RTX 2080 Ti",64.8595,0.501696,0.051587,0,0.452992,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,10,"NVIDIA GeForce RTX 2080 Ti",58.9757,0.500896,0.044113,0,0.452672,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,11,"NVIDIA GeForce RTX 2080 Ti",69.3062,0.51248,0.058981,0,0.458464,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,12,"NVIDIA GeForce RTX 2080 Ti",89.677,0.517088,0.04765,0,0.454016,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,13,"NVIDIA GeForce RTX 2080 Ti",77.2645,0.500672,0.046037,0,0.452992,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,14,"NVIDIA GeForce RTX 2080 Ti",73.1794,0.526624,0.056196,0,0.462592,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,15,"NVIDIA GeForce RTX 2080 Ti",89.7382,0.53856,0.051106,0,0.468992,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,16,"NVIDIA GeForce RTX 2080 Ti",71.2718,0.501248,0.050866,0,0.453952,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,17,"NVIDIA GeForce RTX 2080 Ti",73.1617,0.499872,0.055695,0,0.452096,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,18,"NVIDIA GeForce RTX 2080 Ti",72.7174,0.500192,0.054764,0,0.45376,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,19,"NVIDIA GeForce RTX 2080 Ti",67.101,0.501088,0.047931,0,0.453664,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,20,"NVIDIA GeForce RTX 2080 Ti",63.5622,0.503232,0.035136,0,0.455168,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,21,"NVIDIA GeForce RTX 2080 Ti",65.3194,0.50208,0.035086,0,0.454656,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,22,"NVIDIA GeForce RTX 2080 Ti",63.9591,0.501888,0.046689,0,0.454528,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,23,"NVIDIA GeForce RTX 2080 Ti",71.2482,0.522688,0.050545,0,0.45552,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,24,"NVIDIA GeForce RTX 2080 Ti",69.9222,0.502976,0.046357,0,0.455328,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,25,"NVIDIA GeForce RTX 2080 Ti",64.344,0.503104,0.050155,0,0.456224,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,26,"NVIDIA GeForce RTX 2080 Ti",78.2206,0.501376,0.041668,0,0.4528,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,27,"NVIDIA GeForce RTX 2080 Ti",69.5483,0.502112,0.044875,0,0.45456,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,28,"NVIDIA GeForce RTX 2080 Ti",70.6912,0.502976,0.054793,0,0.454912,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,29,"NVIDIA GeForce RTX 2080 Ti",59.5799,0.506144,0.054182,0,0.459072,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",28.95,19.0675,0.090671,18.9777,0.046176,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",30.1903,19.0265,0.055985,18.9312,0.045632,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",29.528,17.7257,0.05839,17.6361,0.04608,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",37.1126,17.7724,0.082345,17.6819,0.047072,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",32.7784,17.9287,0.074441,17.8387,0.046496,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",27.6314,18.546,0.040025,18.4577,0.045504,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",28.1386,16.5328,0.05282,16.4442,0.046016,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",39.3953,17.5788,0.068609,17.4893,0.045856,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",33.6281,18.3301,0.057739,18.2407,0.045888,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",26.884,17.4571,0.081564,17.3646,0.045152,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",27.706,18.2631,0.067808,18.1392,0.078112,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",31.3403,19.0904,0.124896,19.0016,0.0448,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",31.2898,18.0163,0.053331,17.9268,0.045632,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",29.5633,17.4606,0.055475,17.3705,0.045952,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",30.9779,18.326,0.062017,18.2369,0.045632,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",28.9766,18.2192,0.049303,18.1311,0.044896,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",39.4051,17.8111,0.138211,17.7086,0.045536,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",29.2116,18.1303,0.086103,18.0403,0.045568,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",28.3562,18.4117,0.050225,18.322,0.044864,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",25.9879,18.8113,0.057979,18.7227,0.045632,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",27.5498,17.4982,0.062798,17.409,0.045632,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",31.5507,17.4853,0.059472,17.3964,0.045728,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",26.4812,17.3325,0.07939,17.2421,0.045728,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",25.9898,17.5309,0.051908,17.4409,0.045984,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",27.3971,17.781,0.050025,17.6911,0.045888,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",28.9852,18.1281,0.07442,18.0382,0.04672,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",25.6142,17.1462,0.054883,17.0576,0.045504,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",25.9652,17.5127,0.044695,17.4246,0.0448,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",25.8046,17.1183,0.057358,17.0306,0.045312,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",33.0322,19.1989,0.060193,19.1099,0.04544,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",41.7078,18.7039,0.099958,18.5698,0.045984,0.033504,0.00496,0.006304,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",29.8563,17.9899,0.053691,17.8579,0.044352,0.033888,0.004672,0.00576,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",29.4706,17.9535,0.062357,17.822,0.044736,0.032896,0.004832,0.00528,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",32.8318,18.6156,0.063479,18.4673,0.044512,0.03296,0.004544,0.005696,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",25.7447,17.5505,0.051797,17.4204,0.044448,0.032672,0.00448,0.006336,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",33.5728,18.0636,0.09504,17.9313,0.044544,0.034272,0.004544,0.005984,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",28.4606,17.7085,0.072898,17.5756,0.045056,0.033536,0.004672,0.006816,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",28.4747,18.2442,0.07937,18.1121,0.045312,0.032736,0.004736,0.005696,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",28.2865,18.0632,0.072467,17.9026,0.072608,0.033408,0.005152,0.0064,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",27.376,17.707,0.047339,17.5769,0.044096,0.033248,0.00464,0.00512,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",33.5824,18.0599,0.069071,17.9285,0.0448,0.032768,0.004608,0.005632,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",30.6338,18.9726,0.07912,18.8394,0.046336,0.033216,0.004672,0.005664,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",29.8219,18.3131,0.050085,18.1818,0.044832,0.033088,0.00448,0.005696,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",26.9429,19.0889,0.083728,18.9567,0.044736,0.033024,0.004704,0.005536,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",28.7635,18.001,0.05843,17.8698,0.044672,0.033088,0.004512,0.00576,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",35.0194,18.4051,0.311407,18.2721,0.045216,0.032768,0.00512,0.00512,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",34.8701,18.5402,0.122802,18.3664,0.064416,0.034816,0.006528,0.0096,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",35.1234,19.6287,0.061356,19.4973,0.04464,0.033088,0.005024,0.00592,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",29.0683,18.096,0.057759,17.9647,0.044736,0.032832,0.004672,0.005696,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",32.5114,18.3869,0.056988,18.2545,0.044704,0.033344,0.00448,0.00576,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",31.4406,18.4908,0.566239,18.3587,0.045056,0.032896,0.0048,0.005696,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",37.7439,18.3917,0.135075,18.2604,0.04448,0.032928,0.004544,0.005728,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",34.613,19.0891,0.061285,18.9574,0.043936,0.033504,0.004704,0.006112,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",30.6351,17.8327,0.062939,17.7,0.044576,0.033376,0.004992,0.006368,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",48.9926,17.3412,0.055194,17.2095,0.043648,0.034688,0.004672,0.005664,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",30.326,19.0691,0.083077,18.9365,0.045408,0.033216,0.004704,0.006048,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",36.8077,19.0332,1.40424,18.9014,0.044512,0.032768,0.00544,0.006368,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",34.0379,19.2326,0.152708,19.0999,0.045344,0.032896,0.00512,0.004992,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",30.7649,18.2679,0.13259,18.1358,0.044608,0.03312,0.0048,0.005696,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",32.7112,17.9475,0.067297,17.8169,0.0448,0.032896,0.004832,0.005696,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+occluded,direct,0,"NVIDIA GeForce RTX 2080 Ti",76.1931,0.493024,0.050425,0,0.44912,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,1,"NVIDIA GeForce RTX 2080 Ti",68.5893,0.49552,0.052158,0,0.452,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,2,"NVIDIA GeForce RTX 2080 Ti",66.0354,0.495872,0.041799,0,0.453344,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,3,"NVIDIA GeForce RTX 2080 Ti",62.1102,0.496448,0.752088,0,0.45264,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,4,"NVIDIA GeForce RTX 2080 Ti",101.252,0.497792,0.088387,0,0.452832,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,5,"NVIDIA GeForce RTX 2080 Ti",94.6413,0.49712,0.054032,0,0.453056,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,6,"NVIDIA GeForce RTX 2080 Ti",80.445,0.509344,0.056286,0,0.456544,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,7,"NVIDIA GeForce RTX 2080 Ti",65.6563,0.495776,0.067367,0,0.452352,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,8,"NVIDIA GeForce RTX 2080 Ti",70.7713,0.492352,0.03724,0,0.448512,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,9,"NVIDIA GeForce RTX 2080 Ti",69.5214,0.499424,0.032882,0,0.452064,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,10,"NVIDIA GeForce RTX 2080 Ti",65.0521,0.518176,0.059372,0,0.463776,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,11,"NVIDIA GeForce RTX 2080 Ti",61.2619,0.5088,0.034745,0,0.442528,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,12,"NVIDIA GeForce RTX 2080 Ti",76.8997,0.499744,0.049113,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,13,"NVIDIA GeForce RTX 2080 Ti",67.881,0.500672,0.052439,0,0.451552,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,14,"NVIDIA GeForce RTX 2080 Ti",66.5388,0.499168,0.052469,0,0.451232,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,15,"NVIDIA GeForce RTX 2080 Ti",66.9611,0.50032,0.051407,0,0.452416,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,16,"NVIDIA GeForce RTX 2080 Ti",68.6982,0.518368,0.050816,0,0.461504,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,17,"NVIDIA GeForce RTX 2080 Ti",68.4052,0.501504,0.046207,0,0.454464,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,18,"NVIDIA GeForce RTX 2080 Ti",67.5584,0.501056,0.035788,0,0.452736,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,19,"NVIDIA GeForce RTX 2080 Ti",63.4503,0.500928,0.03137,0,0.453024,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,20,"NVIDIA GeForce RTX 2080 Ti",58.6131,0.53168,0.045556,0,0.45856,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,21,"NVIDIA GeForce RTX 2080 Ti",66.8696,0.500192,0.060004,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,22,"NVIDIA GeForce RTX 2080 Ti",70.3105,0.498368,0.060344,0,0.45056,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,23,"NVIDIA GeForce RTX 2080 Ti",67.8161,0.499488,0.040166,0,0.451232,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,24,"NVIDIA GeForce RTX 2080 Ti",74.8262,0.503008,0.114936,0,0.456384,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,25,"NVIDIA GeForce RTX 2080 Ti",70.4877,0.498752,0.044854,0,0.45056,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,26,"NVIDIA GeForce RTX 2080 Ti",77.6733,0.499328,0.050515,0,0.45056,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,27,"NVIDIA GeForce RTX 2080 Ti",69.4743,0.502112,0.038622,0,0.45456,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,28,"NVIDIA GeForce RTX 2080 Ti",71.1859,0.500288,0.038753,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,29,"NVIDIA GeForce RTX 2080 Ti",72.204,0.544224,0.041959,0,0.495552,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",30.027,18.2252,0.157086,18.1366,0.047264,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",27.2397,18.5654,0.043883,18.4792,0.044928,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",27.9147,19.3856,0.049444,19.298,0.047136,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",29.0567,17.4974,0.049163,17.4086,0.046944,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",28.6719,18.2787,0.0582,18.1921,0.046368,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",27.5111,17.3768,0.170672,17.288,0.047744,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",27.403,18.7724,0.049704,18.6848,0.046528,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",37.4615,18.1988,0.054643,18.1084,0.0488,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",27.5264,18.1369,0.064652,18.0496,0.046176,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",26.8143,17.4664,0.041378,17.3796,0.046592,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",28.9701,18.4421,0.067347,18.3543,0.046944,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",31.0049,18.8785,0.066516,18.79,0.0472,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",28.9493,18.6696,0.072667,18.5677,0.046912,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",28.7397,16.9495,0.051497,16.8614,0.04688,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",28.3134,17.6847,0.041869,17.5972,0.046368,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",28.1837,17.9915,0.064662,17.9031,0.046432,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",26.7178,17.903,0.04767,17.8164,0.046048,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",25.1679,16.8469,0.045526,16.759,0.046752,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",36.3074,18.1494,0.085111,18.0612,0.047072,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",26.5862,18.1494,0.041769,18.0644,0.045024,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",25.9622,18.0638,0.049533,17.9773,0.045408,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",27.4616,17.2983,0.051437,17.2115,0.045984,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",33.3683,18.3685,0.141206,18.2802,0.046944,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",30.6567,18.3387,0.06357,18.2497,0.04784,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",29.1121,17.1729,0.049894,17.0859,0.046496,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",39.7285,18.7929,0.066706,18.7049,0.047808,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",29.8697,18.9138,0.045596,18.7881,0.08272,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",25.2412,16.7205,0.039574,16.6338,0.045728,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",26.9274,17.2279,0.055295,17.1404,0.046368,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",40.9795,19.6298,0.054843,19.5404,0.048064,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",28.5883,17.8362,0.05306,17.7115,0.01808,0.035392,0.02384,0.00624,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",27.7322,17.566,0.052459,17.4453,0.016608,0.0336,0.02368,0.005632,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",42.1017,18.8188,0.128082,18.6742,0.018528,0.03712,0.03984,0.006816,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",30.2072,17.4621,0.056807,17.3419,0.01696,0.033344,0.023744,0.005664,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",32.7593,19.2904,0.152788,19.1657,0.019136,0.033248,0.023872,0.006816,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",31.2117,19.4538,0.064642,19.3306,0.018816,0.033248,0.023712,0.005152,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",32.8475,18.1724,0.046477,18.0502,0.017856,0.03296,0.023712,0.006464,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",32.6473,19.1206,0.151506,18.995,0.016704,0.034496,0.025344,0.00688,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",30.1001,18.0559,0.062568,17.9337,0.017728,0.03328,0.02416,0.005984,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",31.5778,19.3441,0.066195,19.2231,0.017472,0.033632,0.024064,0.005632,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",30.838,19.4191,0.070153,19.2963,0.01792,0.033312,0.02384,0.006208,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",32.769,17.3356,0.049684,17.2144,0.016288,0.032768,0.025024,0.005696,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",45.0191,18.129,0.33952,18.0069,0.017504,0.033312,0.024032,0.006144,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",36.6621,19.6666,0.058149,19.5448,0.017696,0.032896,0.02368,0.005408,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",27.7215,18.5221,0.070934,18.3996,0.018048,0.033376,0.023744,0.005056,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",28.611,18.5088,0.059091,18.3865,0.018304,0.033088,0.024,0.00624,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",30.0473,17.5453,0.058069,17.4224,0.017952,0.03344,0.024,0.00496,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",35.7001,18.4428,0.060404,18.321,0.017376,0.033888,0.023776,0.005824,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",33.8689,18.407,0.072116,18.2854,0.017792,0.033024,0.023712,0.005152,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",31.1593,18.6534,0.072556,18.5312,0.016416,0.0336,0.024512,0.006432,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",31.0397,18.3658,0.080672,18.2432,0.018048,0.033024,0.024064,0.006208,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",30.0133,18.5009,0.068689,18.3795,0.017184,0.033088,0.023968,0.006304,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",30.0481,18.4971,0.141938,18.3733,0.018752,0.033856,0.023776,0.005856,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",30.9812,18.9874,0.140765,18.8642,0.017376,0.033536,0.024224,0.006784,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",29.5908,17.5829,0.076425,17.4613,0.017792,0.032768,0.023968,0.005632,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",30.4352,18.2353,0.06888,18.1125,0.018272,0.033152,0.02384,0.005184,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",30.5196,18.0447,0.12167,17.9219,0.0184,0.032992,0.024032,0.006624,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",44.3519,18.8445,0.066335,18.7222,0.01744,0.033024,0.024128,0.005824,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",31.4541,18.0633,0.074511,17.9404,0.01648,0.03392,0.02448,0.005088,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",34.4574,19.1689,0.086323,19.0465,0.018112,0.032992,0.023904,0.005824,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0

docs/studies/data/p2-2026-09-23-run-2.csv

@@ -0,0 +1,271 @@
+scenario,mode,frame,device,cpu_ms,gpu_ms,readback_cpu_ms,gpu_main_cull_ms,gpu_main_raster_ms,gpu_hzb_ms,gpu_post_cull_ms,gpu_post_raster_ms,gpu_bytes,draw_calls,gpu_bins,gpu_visible,gpu_frustum_rejected,gpu_deferred,gpu_post_visible,lod0,lod1,lod2,lod3,hzb_valid,gpu_visibility_active,visibility_diagnostics,visibility_counters_valid,validation_errors
+frustum,direct,0,"NVIDIA GeForce RTX 2080 Ti",66.1609,0.242784,0.075262,0,0.192512,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,1,"NVIDIA GeForce RTX 2080 Ti",68.3263,0.242272,0.036999,0,0.195872,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,2,"NVIDIA GeForce RTX 2080 Ti",68.5854,0.24224,0.043843,0,0.194464,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,3,"NVIDIA GeForce RTX 2080 Ti",61.0177,0.241088,0.074972,0,0.193504,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,4,"NVIDIA GeForce RTX 2080 Ti",75.1802,0.241536,0.046448,0,0.194048,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,5,"NVIDIA GeForce RTX 2080 Ti",67.1904,0.241984,0.050064,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,6,"NVIDIA GeForce RTX 2080 Ti",69.1559,0.242112,0.048682,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,7,"NVIDIA GeForce RTX 2080 Ti",73.2458,0.240576,0.038663,0,0.192608,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,8,"NVIDIA GeForce RTX 2080 Ti",76.4015,0.241888,0.065804,0,0.19312,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,9,"NVIDIA GeForce RTX 2080 Ti",79.865,0.243456,0.060113,0,0.195008,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,10,"NVIDIA GeForce RTX 2080 Ti",66.7561,0.242368,0.087365,0,0.194528,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,11,"NVIDIA GeForce RTX 2080 Ti",71.2419,0.243552,0.03716,0,0.194784,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,12,"NVIDIA GeForce RTX 2080 Ti",74.0436,0.241696,0.07411,0,0.193024,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,13,"NVIDIA GeForce RTX 2080 Ti",69.8803,0.24128,0.052088,0,0.192608,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,14,"NVIDIA GeForce RTX 2080 Ti",67.6187,0.244096,0.04203,0,0.194368,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,15,"NVIDIA GeForce RTX 2080 Ti",71.5013,0.242368,0.041719,0,0.196096,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,16,"NVIDIA GeForce RTX 2080 Ti",76.1721,0.243328,0.053792,0,0.196544,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,17,"NVIDIA GeForce RTX 2080 Ti",66.9329,0.240384,0.055365,0,0.192736,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,18,"NVIDIA GeForce RTX 2080 Ti",90.9824,0.243072,0.054824,0,0.194976,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,19,"NVIDIA GeForce RTX 2080 Ti",74.168,0.241024,0.058751,0,0.192928,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,20,"NVIDIA GeForce RTX 2080 Ti",77.8858,0.242304,0.054693,0,0.194496,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,21,"NVIDIA GeForce RTX 2080 Ti",71.9848,0.241312,0.211349,0,0.194432,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,22,"NVIDIA GeForce RTX 2080 Ti",70.2748,0.242784,0.040877,0,0.196096,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,23,"NVIDIA GeForce RTX 2080 Ti",73.3592,0.241824,0.050305,0,0.193504,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,24,"NVIDIA GeForce RTX 2080 Ti",75.369,0.243552,0.056216,0,0.196256,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,25,"NVIDIA GeForce RTX 2080 Ti",75.5086,0.241184,0.06409,0,0.194112,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,26,"NVIDIA GeForce RTX 2080 Ti",76.409,0.242816,0.055304,0,0.194912,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,27,"NVIDIA GeForce RTX 2080 Ti",70.5823,0.244608,0.067166,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,28,"NVIDIA GeForce RTX 2080 Ti",70.7893,0.270944,0.045887,0,0.200512,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,29,"NVIDIA GeForce RTX 2080 Ti",67.5317,0.2416,0.038242,0,0.193536,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",12.2652,3.66669,0.056416,3.59363,0.029088,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",13.0303,3.64883,0.049213,3.57485,0.028224,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",14.7693,3.75651,0.055224,3.66861,0.04272,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",14.57,3.9831,0.054543,3.89037,0.047936,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",12.8408,4.20621,0.071605,4.1304,0.031136,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",13.8355,4.53206,0.054202,4.45549,0.031872,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",14.5372,3.8039,0.059372,3.72947,0.028608,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",12.2308,3.64522,0.060264,3.57187,0.028544,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",12.8853,4.10477,0.044243,4.03078,0.0304,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",12.2396,4.3184,0.049915,4.2431,0.031072,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",17.6088,3.8769,0.04756,3.77546,0.049664,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",16.3436,4.63565,0.059683,4.56442,0.027776,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",12.0509,3.65834,0.056156,3.58963,0.02688,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",13.9493,4.38125,0.048051,4.31101,0.028544,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",14.6877,4.69514,0.056567,4.62403,0.028832,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",12.2102,3.76861,0.080261,3.69914,0.026176,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",14.1855,3.79494,0.044774,3.7271,0.02544,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",16.0333,3.89805,0.045235,3.82592,0.030016,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",15.0521,3.79693,0.070724,3.71594,0.039392,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",14.3517,3.55882,0.054884,3.45366,0.062752,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",14.3495,4.27942,0.046207,4.21005,0.028288,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",12.0303,4.0281,0.081163,3.93693,0.04848,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",14.3333,4.45747,0.051958,4.38669,0.029216,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",12.2754,3.52659,0.051968,3.45802,0.02704,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",23.4937,3.83741,0.065203,3.75542,0.04128,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",16.516,4.63072,0.057408,4.56326,0.026304,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",15.3843,3.78736,0.074992,3.69926,0.046304,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",16.3565,4.46115,0.06935,4.39171,0.02784,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",12.3977,4.69267,0.048742,4.62451,0.027552,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",16.4187,3.6647,0.051106,3.5993,0.023616,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",16.8839,4.3735,0.065734,4.26205,0.02656,0.033376,0.004832,0.005408,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",14.9948,3.88058,0.065584,3.77171,0.023232,0.033312,0.005152,0.00624,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",14.4652,4.00362,0.07989,3.89229,0.023232,0.033408,0.004576,0.005376,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",16.5989,4.59565,0.062909,4.48339,0.027552,0.033248,0.004736,0.005824,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",14.7896,4.38035,0.066596,4.26858,0.02608,0.032992,0.004896,0.00624,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",15.1495,3.79091,0.059733,3.68483,0.022048,0.033504,0.004512,0.004992,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",13.8677,3.76458,0.046428,3.63843,0.023392,0.033088,0.004512,0.005408,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",22.0606,4.24832,0.062648,4.13648,0.025952,0.033536,0.004736,0.005888,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",14.9021,3.91434,0.061987,3.80598,0.023104,0.033344,0.004672,0.005504,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",13.7153,3.79104,0.049494,3.68333,0.022944,0.032992,0.004576,0.005888,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",15.3138,4.56838,0.094569,4.45328,0.027008,0.033504,0.005216,0.00688,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",12.7674,4.34733,0.044634,4.2376,0.026016,0.032992,0.004704,0.005504,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",14.4036,4.26525,0.04276,4.15539,0.024992,0.034112,0.00448,0.005632,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",28.5979,4.58384,0.069351,4.47178,0.027392,0.033056,0.004544,0.005792,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",21.8617,4.65187,0.057418,4.53837,0.027232,0.033312,0.005248,0.00624,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",13.8758,4.30333,0.076975,4.19098,0.026528,0.032768,0.005856,0.006208,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",14.2286,3.82544,0.048392,3.71549,0.02512,0.032768,0.005472,0.004768,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",12.9851,3.94019,0.06865,3.80829,0.046304,0.033472,0.004512,0.005024,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",14.5844,3.5375,0.062878,3.42928,0.023296,0.033344,0.004672,0.00544,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",16.9018,4.0472,0.296309,3.93488,0.026336,0.033184,0.005024,0.006784,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",14.3215,3.70998,0.049152,3.60323,0.022272,0.033792,0.004384,0.004832,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",15.4161,4.24403,0.057078,4.10294,0.026368,0.037504,0.009312,0.018688,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",17.2157,3.79514,0.066496,3.67322,0.036384,0.033568,0.004832,0.006112,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",13.9644,3.67958,0.055515,3.57117,0.023072,0.034016,0.004576,0.00608,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",13.3739,3.56653,0.046638,3.4585,0.023104,0.034176,0.00448,0.005856,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",15.3203,4.02573,0.050696,3.91597,0.0248,0.033888,0.004576,0.005696,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",24.1009,4.64227,0.057238,4.5313,0.026048,0.03296,0.004896,0.006176,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",13.371,4.28486,0.055595,4.17245,0.027168,0.033344,0.0048,0.005696,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",12.5154,3.79654,0.063029,3.68909,0.0232,0.03328,0.004384,0.00576,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",16.5618,3.52202,0.053,3.39971,0.038848,0.032992,0.004768,0.005248,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+open,direct,0,"NVIDIA GeForce RTX 2080 Ti",72.4653,0.525856,0.076093,0,0.456672,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,1,"NVIDIA GeForce RTX 2080 Ti",70.7023,0.49504,0.062467,0,0.454112,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,2,"NVIDIA GeForce RTX 2080 Ti",81.3127,0.495392,0.080652,0,0.454208,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,3,"NVIDIA GeForce RTX 2080 Ti",77.4199,0.52416,0.060243,0,0.461472,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,4,"NVIDIA GeForce RTX 2080 Ti",61.8899,0.498176,0.049884,0,0.456704,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,5,"NVIDIA GeForce RTX 2080 Ti",64.482,0.494112,0.049713,0,0.453184,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,6,"NVIDIA GeForce RTX 2080 Ti",65.8003,0.492416,0.040296,0,0.450752,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,7,"NVIDIA GeForce RTX 2080 Ti",55.3772,0.494208,0.043923,0,0.453152,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,8,"NVIDIA GeForce RTX 2080 Ti",64.7034,0.51328,0.061946,0,0.46384,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,9,"NVIDIA GeForce RTX 2080 Ti",70.0662,0.501888,0.043963,0,0.45712,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,10,"NVIDIA GeForce RTX 2080 Ti",61.0657,0.497984,0.049013,0,0.453696,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,11,"NVIDIA GeForce RTX 2080 Ti",62.9217,0.536032,0.045155,0,0.463008,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,12,"NVIDIA GeForce RTX 2080 Ti",62.8878,0.500384,0.035817,0,0.456256,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,13,"NVIDIA GeForce RTX 2080 Ti",65.4875,0.497568,0.057649,0,0.45344,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,14,"NVIDIA GeForce RTX 2080 Ti",65.4235,0.497312,0.056957,0,0.452608,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,15,"NVIDIA GeForce RTX 2080 Ti",61.4875,0.51936,0.049073,0,0.466944,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,16,"NVIDIA GeForce RTX 2080 Ti",79.2119,0.50368,0.055856,0,0.458752,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,17,"NVIDIA GeForce RTX 2080 Ti",70.6097,0.499072,0.072026,0,0.45376,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,18,"NVIDIA GeForce RTX 2080 Ti",62.8699,0.500544,0.049543,0,0.456416,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,19,"NVIDIA GeForce RTX 2080 Ti",58.4991,0.50224,0.046578,0,0.456928,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,20,"NVIDIA GeForce RTX 2080 Ti",64.0851,0.501248,0.034044,0,0.456192,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,21,"NVIDIA GeForce RTX 2080 Ti",67.3253,0.501536,0.045747,0,0.456704,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,22,"NVIDIA GeForce RTX 2080 Ti",89.302,0.498528,0.086152,0,0.453696,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,23,"NVIDIA GeForce RTX 2080 Ti",101.67,0.49904,0.056597,0,0.4536,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,24,"NVIDIA GeForce RTX 2080 Ti",94.5509,0.499584,0.059602,0,0.454944,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,25,"NVIDIA GeForce RTX 2080 Ti",70.8627,0.50048,0.043262,0,0.456448,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,26,"NVIDIA GeForce RTX 2080 Ti",81.6516,0.499872,0.071996,0,0.45504,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,27,"NVIDIA GeForce RTX 2080 Ti",78.6317,0.497696,0.065924,0,0.453632,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,28,"NVIDIA GeForce RTX 2080 Ti",80.6076,0.501344,0.050605,0,0.45776,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,29,"NVIDIA GeForce RTX 2080 Ti",72.6452,0.50064,0.067588,0,0.456064,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",29.245,17.8214,0.064943,17.736,0.04464,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",31.3521,18.7652,0.064462,18.6796,0.045088,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",34.7003,19.2139,0.06859,19.1284,0.044704,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",30.0787,18.7535,0.065123,18.6476,0.063104,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",27.6475,18.3723,0.119826,18.2861,0.046464,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",31.285,18.8391,0.062538,18.7534,0.045056,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",37.9713,17.3197,0.057118,17.2342,0.045088,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",30.8541,17.7554,0.066796,17.6676,0.045792,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",31.4572,18.0148,0.076956,17.9286,0.045216,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",29.3802,17.7023,0.083968,17.6158,0.04544,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",32.8623,18.7766,0.061085,18.6908,0.044832,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",40.3662,17.988,0.073709,17.9023,0.04432,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",32.6503,17.889,0.059843,17.8035,0.043776,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",29.2223,17.9782,0.085682,17.8699,0.067424,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",32.553,18.421,0.051838,18.3345,0.0448,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",32.6268,17.116,0.092504,17.0359,0.038592,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",29.6657,18.0403,0.07458,17.9531,0.04528,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",30.0886,18.0092,0.089899,17.9228,0.045312,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",29.5011,18.0414,0.054994,17.9353,0.048704,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",37.2712,17.8837,0.074921,17.7968,0.045184,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",27.381,16.7135,0.044945,16.6272,0.045376,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",27.68,18.2506,0.18016,18.1619,0.047168,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",27.1979,17.1442,0.045045,17.0587,0.044128,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",32.1824,18.376,0.19084,18.289,0.044768,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",35.9684,19.6251,0.072497,19.5382,0.044992,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",28.3108,18.1039,0.075964,18.0177,0.045696,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",25.7986,17.8082,0.04234,17.7229,0.04496,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",28.4042,18.3007,0.054834,18.2148,0.044544,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",35.3444,18.0331,0.154822,17.9473,0.044544,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",30.4851,18.0803,0.075763,17.9934,0.04512,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",25.6151,17.2506,0.063139,17.1197,0.046272,0.033408,0.004544,0.005728,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",26.4576,17.2634,0.042881,17.1339,0.044416,0.034208,0.004544,0.0056,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",35.303,18.5771,0.05302,18.4471,0.045632,0.033472,0.004672,0.005568,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",26.8731,17.8981,0.05333,17.7676,0.045952,0.032928,0.004736,0.005504,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",28.0724,17.4549,0.051106,17.3233,0.04576,0.034016,0.004928,0.006112,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",31.1932,17.8851,0.051607,17.7552,0.046016,0.032768,0.00496,0.00528,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",29.659,18.5768,0.188776,18.4443,0.046688,0.033408,0.00512,0.006048,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",27.9955,18.6248,0.040146,18.4945,0.044928,0.03408,0.004544,0.005728,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",25.784,17.7532,0.054383,17.623,0.045504,0.033344,0.004672,0.004992,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",33.2763,17.187,0.052549,17.0571,0.0456,0.033344,0.004512,0.005728,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",33.4845,18.8791,0.066596,18.7452,0.04768,0.03328,0.004896,0.006528,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",27.7019,16.9263,0.06339,16.796,0.045792,0.033664,0.004544,0.005792,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",27.7323,17.5782,0.066956,17.4152,0.072448,0.03664,0.00544,0.006752,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",31.2446,17.2717,0.051888,17.1416,0.045504,0.033088,0.004512,0.0056,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",30.0714,18.3229,0.077737,18.192,0.046656,0.033312,0.00464,0.0056,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",27.9889,18.9183,0.046127,18.7876,0.045728,0.032768,0.005312,0.004928,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",26.9597,18.0464,0.083999,17.9147,0.04624,0.034112,0.004704,0.005824,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",30.473,18.0955,0.12724,17.965,0.045664,0.033312,0.004672,0.005024,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",36.0596,19.7913,0.050134,19.6605,0.0456,0.033888,0.004544,0.005888,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",29.3395,18.682,0.062508,18.5511,0.045824,0.033248,0.004544,0.006944,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",28.5117,18.3156,0.081845,18.1831,0.045984,0.034048,0.004704,0.006144,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",30.0566,18.3983,0.047139,18.2688,0.044384,0.033984,0.004512,0.005632,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",33.5899,18.7714,0.14269,18.6402,0.047008,0.033376,0.004704,0.005696,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",28.5571,17.7053,0.13783,17.5736,0.04688,0.033152,0.004576,0.005888,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",30.1274,18.0992,0.073378,17.9682,0.04576,0.033504,0.004864,0.005824,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",28.8706,17.6903,0.052449,17.5603,0.046368,0.033312,0.004832,0.004864,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",29.4792,18.1158,0.059031,17.9844,0.046144,0.032768,0.005504,0.00592,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",28.4486,18.0173,0.052769,17.8855,0.045728,0.033952,0.004768,0.006016,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",29.3532,17.5242,0.074831,17.3932,0.046592,0.033312,0.004544,0.005952,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",27.5402,17.3059,0.056536,17.1766,0.044992,0.03392,0.004512,0.00592,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+occluded,direct,0,"NVIDIA GeForce RTX 2080 Ti",59.3118,0.494336,0.045526,0,0.450944,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,1,"NVIDIA GeForce RTX 2080 Ti",68.4237,0.496704,0.052459,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,2,"NVIDIA GeForce RTX 2080 Ti",69.8323,0.49632,0.070112,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,3,"NVIDIA GeForce RTX 2080 Ti",58.6022,0.496192,0.044424,0,0.4536,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,4,"NVIDIA GeForce RTX 2080 Ti",68.6386,0.493664,0.04226,0,0.450208,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,5,"NVIDIA GeForce RTX 2080 Ti",70.3443,0.498432,0.048251,0,0.453056,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,6,"NVIDIA GeForce RTX 2080 Ti",75.7748,0.495776,0.050034,0,0.452224,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,7,"NVIDIA GeForce RTX 2080 Ti",67.7425,0.787424,0.070763,0,0.741376,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,8,"NVIDIA GeForce RTX 2080 Ti",67.2227,0.49664,0.04765,0,0.451296,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,9,"NVIDIA GeForce RTX 2080 Ti",61.9873,0.497344,0.048111,0,0.453344,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,10,"NVIDIA GeForce RTX 2080 Ti",69.7143,0.503136,0.075963,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,11,"NVIDIA GeForce RTX 2080 Ti",66.0564,0.499968,0.032291,0,0.452672,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,12,"NVIDIA GeForce RTX 2080 Ti",60.2812,0.499136,0.055294,0,0.452512,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,13,"NVIDIA GeForce RTX 2080 Ti",66.9893,0.500224,0.051346,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,14,"NVIDIA GeForce RTX 2080 Ti",75.2515,0.504672,0.252627,0,0.456608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,15,"NVIDIA GeForce RTX 2080 Ti",67.1819,0.500576,0.041368,0,0.453056,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,16,"NVIDIA GeForce RTX 2080 Ti",64.3475,0.504064,0.047781,0,0.456608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,17,"NVIDIA GeForce RTX 2080 Ti",69.0903,0.501952,0.039975,0,0.45456,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,18,"NVIDIA GeForce RTX 2080 Ti",65.2047,0.513408,0.042049,0,0.4608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,19,"NVIDIA GeForce RTX 2080 Ti",65.3647,0.501248,0.04232,0,0.453856,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,20,"NVIDIA GeForce RTX 2080 Ti",67.6695,0.503328,0.061295,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,21,"NVIDIA GeForce RTX 2080 Ti",64.7599,0.500256,0.057228,0,0.452,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,22,"NVIDIA GeForce RTX 2080 Ti",70.1995,0.500928,0.067697,0,0.453888,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,23,"NVIDIA GeForce RTX 2080 Ti",65.6527,0.501792,0.038723,0,0.453216,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,24,"NVIDIA GeForce RTX 2080 Ti",59.455,0.499904,0.04797,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,25,"NVIDIA GeForce RTX 2080 Ti",68.5474,0.501856,0.041268,0,0.454528,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,26,"NVIDIA GeForce RTX 2080 Ti",74.7478,0.49872,0.072086,0,0.45056,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,27,"NVIDIA GeForce RTX 2080 Ti",70.2172,0.738016,0.066305,0,0.688544,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,28,"NVIDIA GeForce RTX 2080 Ti",66.2711,0.503872,0.065183,0,0.455776,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,29,"NVIDIA GeForce RTX 2080 Ti",72.4094,0.5024,0.033653,0,0.454944,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",29.4074,17.7684,0.056657,17.6803,0.047232,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",27.681,17.5781,0.079099,17.4894,0.047616,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",29.9062,18.5249,0.115969,18.4381,0.046592,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",30.8325,18.0383,0.070543,17.9507,0.04624,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",32.8241,19.0072,0.06875,18.9191,0.046304,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",31.9167,18.3397,0.082646,18.2509,0.047456,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",28.0415,17.4767,0.054252,17.3888,0.045792,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",28.7951,17.0943,0.064031,17.0079,0.045472,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",30.1276,19.5859,0.047239,19.4636,0.058048,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",27.4857,18.4978,0.055925,18.4103,0.04624,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",26.7085,17.3482,0.044874,17.2604,0.047104,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",28.9901,18.1116,0.060113,18.024,0.047008,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",28.9482,18.9477,0.056476,18.86,0.046752,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",28.0518,18.5903,0.048111,18.504,0.044704,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",35.1882,18.8958,0.053841,18.8077,0.046176,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",41.5527,18.3833,0.064201,18.2944,0.045984,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",29.4888,18.1247,0.046317,18.0372,0.046336,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",27.1293,18.1766,0.057849,18.0879,0.04768,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",29.3715,17.2684,0.050936,17.1801,0.04736,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",41.1616,18.4478,0.059963,18.3596,0.046592,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",30.7117,18.8622,0.101561,18.7739,0.046688,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",28.0277,18.7782,0.078919,18.6874,0.049472,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",33.5102,18.3076,0.070402,18.2191,0.046976,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",45.6373,17.5671,0.066796,17.4797,0.046784,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",28.7209,18.035,0.074651,17.9484,0.045312,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",31.6408,18.6111,0.054673,18.481,0.08768,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",28.4236,18.321,0.083367,18.2011,0.077696,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",29.587,18.0164,0.049052,17.9292,0.046144,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",43.2576,18.0742,0.081224,17.947,0.085504,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",34.3899,18.373,0.130446,18.2849,0.045728,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",27.3069,18.3138,0.082315,18.1906,0.017792,0.033376,0.024064,0.005888,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",31.8759,19.0241,0.044124,18.8998,0.0184,0.033536,0.024416,0.005536,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",27.6391,16.7698,0.06887,16.6253,0.018784,0.0376,0.040288,0.00608,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",30.335,18.4741,0.051247,18.3538,0.016768,0.034144,0.023712,0.005632,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",29.0454,19.0139,0.078949,18.8906,0.017536,0.03392,0.023872,0.006752,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",28.6342,17.7767,0.080301,17.6547,0.017472,0.03312,0.024128,0.005728,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",28.9265,17.6885,0.135596,17.5683,0.017344,0.033088,0.023328,0.005664,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",33.8068,18.4788,0.086684,18.3546,0.018368,0.033152,0.02448,0.0072,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",29.6926,18.4138,0.064191,18.2916,0.017536,0.034016,0.02432,0.005152,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",28.5787,17.4874,0.077416,17.3657,0.017568,0.033696,0.02384,0.005888,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",32.4026,19.2327,0.060063,19.1113,0.017056,0.03328,0.024128,0.006048,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",32.3829,17.1625,0.055765,17.0414,0.017184,0.03312,0.024128,0.005824,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",30.5328,18.1117,0.244651,17.9874,0.018016,0.033728,0.024896,0.00672,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",30.6542,18.5373,0.058872,18.416,0.017408,0.033184,0.023456,0.00544,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",26.8597,18.8081,0.056165,18.6877,0.016704,0.03344,0.023936,0.005664,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",30.9608,18.2385,0.059392,18.1172,0.017792,0.032768,0.024864,0.005856,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",41.101,17.4621,0.075723,17.3332,0.018528,0.03424,0.029856,0.006144,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",32.2826,19.3706,0.05832,19.2484,0.01824,0.033056,0.024192,0.005152,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",32.5615,18.6187,0.068329,18.4956,0.017792,0.033568,0.023936,0.006368,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",28.4861,18.9286,0.346313,18.8054,0.017728,0.03344,0.024352,0.005696,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",27.3125,17.8936,0.064252,17.7717,0.017216,0.034272,0.024,0.005216,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",27.7025,17.3756,0.050815,17.2564,0.01648,0.033216,0.023936,0.005696,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",34.3059,18.599,0.061987,18.4546,0.018752,0.036832,0.039936,0.006784,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",27.5462,18.3532,0.081053,18.2315,0.017664,0.033248,0.02416,0.005696,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",29.9655,18.9615,0.049203,18.839,0.018112,0.033088,0.023936,0.005344,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",25.4532,17.4165,0.166063,17.2967,0.016896,0.032864,0.024,0.00592,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",37.9467,18.9785,0.088637,18.8561,0.017568,0.033696,0.023872,0.005792,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",29.9581,18.687,0.050004,18.5662,0.017152,0.033344,0.02384,0.00608,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",25.9481,18.1282,0.044304,18.0061,0.018304,0.03312,0.023808,0.005952,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",27.4058,17.4194,0.044544,17.2987,0.01696,0.033472,0.023936,0.005632,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0

docs/studies/data/p2-2026-09-23-run-3.csv

@@ -0,0 +1,271 @@
+scenario,mode,frame,device,cpu_ms,gpu_ms,readback_cpu_ms,gpu_main_cull_ms,gpu_main_raster_ms,gpu_hzb_ms,gpu_post_cull_ms,gpu_post_raster_ms,gpu_bytes,draw_calls,gpu_bins,gpu_visible,gpu_frustum_rejected,gpu_deferred,gpu_post_visible,lod0,lod1,lod2,lod3,hzb_valid,gpu_visibility_active,visibility_diagnostics,visibility_counters_valid,validation_errors
+frustum,direct,0,"NVIDIA GeForce RTX 2080 Ti",93.8725,0.23984,0.05314,0,0.195616,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,1,"NVIDIA GeForce RTX 2080 Ti",72.6142,0.239936,0.049743,0,0.19584,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,2,"NVIDIA GeForce RTX 2080 Ti",88.0211,0.239584,0.065223,0,0.192832,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,3,"NVIDIA GeForce RTX 2080 Ti",78.2073,0.276736,0.044924,0,0.198656,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,4,"NVIDIA GeForce RTX 2080 Ti",73.1667,0.239328,0.049514,0,0.193184,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,5,"NVIDIA GeForce RTX 2080 Ti",90.6366,0.240736,0.0374,0,0.196064,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,6,"NVIDIA GeForce RTX 2080 Ti",73.5559,0.240096,0.060124,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,7,"NVIDIA GeForce RTX 2080 Ti",73.644,0.239296,0.057929,0,0.1944,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,8,"NVIDIA GeForce RTX 2080 Ti",74.2932,0.239008,0.041298,0,0.194208,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,9,"NVIDIA GeForce RTX 2080 Ti",87.3979,0.24064,0.070012,0,0.194752,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,10,"NVIDIA GeForce RTX 2080 Ti",84.099,0.240992,0.07401,0,0.195904,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,11,"NVIDIA GeForce RTX 2080 Ti",90.7987,0.240192,0.065093,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,12,"NVIDIA GeForce RTX 2080 Ti",81.6204,0.240416,0.04769,0,0.196576,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,13,"NVIDIA GeForce RTX 2080 Ti",94.9211,0.241088,0.063129,0,0.196096,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,14,"NVIDIA GeForce RTX 2080 Ti",77.274,0.240672,0.044113,0,0.196192,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,15,"NVIDIA GeForce RTX 2080 Ti",94.9484,0.240928,0.08437,0,0.196416,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,16,"NVIDIA GeForce RTX 2080 Ti",72.684,0.239264,0.050044,0,0.194784,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,17,"NVIDIA GeForce RTX 2080 Ti",70.9211,0.241056,0.054253,0,0.196064,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,18,"NVIDIA GeForce RTX 2080 Ti",81.2235,0.238656,0.057729,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,19,"NVIDIA GeForce RTX 2080 Ti",71.7002,0.23872,0.051828,0,0.19456,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,20,"NVIDIA GeForce RTX 2080 Ti",85.7993,0.275072,0.063861,0,0.198848,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,21,"NVIDIA GeForce RTX 2080 Ti",71.1468,0.239136,0.054613,0,0.194464,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,22,"NVIDIA GeForce RTX 2080 Ti",80.3144,0.24224,0.046518,0,0.196736,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,23,"NVIDIA GeForce RTX 2080 Ti",90.3626,0.23792,0.080562,0,0.192512,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,24,"NVIDIA GeForce RTX 2080 Ti",79.6581,0.23872,0.069952,0,0.194368,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,25,"NVIDIA GeForce RTX 2080 Ti",86.7153,0.237568,0.073338,0,0.192928,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,26,"NVIDIA GeForce RTX 2080 Ti",105.535,0.239808,0.048983,0,0.19488,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,27,"NVIDIA GeForce RTX 2080 Ti",90.4653,0.239424,0.067317,0,0.194656,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,28,"NVIDIA GeForce RTX 2080 Ti",82.4022,0.246176,0.057298,0,0.19712,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,direct,29,"NVIDIA GeForce RTX 2080 Ti",69.9484,0.24688,0.059452,0,0.19712,0,0,0,7811584,416,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+frustum,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",19.3669,4.39968,0.072576,4.3257,0.030208,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",15.7535,3.9465,0.059572,3.87264,0.030752,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",15.2249,3.83805,0.055485,3.76752,0.027072,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",16.4207,4.83411,0.05318,4.76048,0.030432,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",18.089,4.42224,0.237638,4.3489,0.029568,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",16.4043,4.16947,0.059382,4.09533,0.031168,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",26.3979,4.01258,0.319733,3.93216,0.038304,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",20.4476,4.63619,0.059282,4.5624,0.031008,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",18.2016,3.86666,0.060254,3.77907,0.044544,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",14.964,4.21133,0.055304,4.13994,0.029152,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",13.6549,4.32074,0.046377,4.23382,0.044672,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",12.5237,3.74387,0.053551,3.65994,0.042848,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",31.3421,5.13533,0.080532,5.06534,0.028032,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",14.5948,3.78154,0.063369,3.71475,0.024896,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",15.2246,4.31379,0.091132,4.24256,0.027616,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",16.0754,5.05866,0.070483,4.988,0.029504,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",13.9159,3.64512,0.057568,3.57869,0.025792,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",15.1862,4.1081,0.066205,4.0215,0.043776,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",14.419,4.22557,0.052269,4.1551,0.02896,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",22.4779,4.31062,0.05836,4.23917,0.03008,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",16.1069,3.8457,0.06354,3.7599,0.043232,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",14.3488,3.93782,0.075252,3.86992,0.02608,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",12.9291,3.82083,0.05832,3.73139,0.049568,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",13.2736,3.90512,0.078608,3.82621,0.038368,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",12.6893,3.96976,0.051677,3.90218,0.027936,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",13.6491,3.53974,0.052059,3.46147,0.038496,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",24.5044,4.49805,0.056106,4.41584,0.040832,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",15.0732,4.21635,0.093036,4.148,0.02832,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",15.1523,4.12198,0.068419,4.05331,0.02848,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",16.2747,4.04384,0.062488,3.95376,0.049856,0,0,0,5417504,1,1,416,608,0,0,1024,0,0,0,0,1,1,1,0
+frustum,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",16.1367,3.89664,0.056957,3.78477,0.02432,0.033408,0.005376,0.006016,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",19.5531,3.93331,0.056867,3.8129,0.033248,0.032768,0.005568,0.006048,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",16.1321,4.36762,0.055695,4.25536,0.024896,0.03392,0.004768,0.005952,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",13.9535,3.63126,0.064131,3.52253,0.022336,0.034144,0.004416,0.005888,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",13.1434,4.4961,0.050485,4.38173,0.025824,0.033184,0.004704,0.007168,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",16.2221,4.42038,0.049483,4.30858,0.025408,0.033248,0.004672,0.005088,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",22.8249,3.82531,0.048361,3.68829,0.022688,0.043264,0.00928,0.019104,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",17.8131,4.22666,0.052609,4.1143,0.025984,0.033216,0.004544,0.005728,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",15.2164,3.92509,0.062157,3.79622,0.023648,0.033408,0.00512,0.005952,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",16.8552,4.00406,0.061586,3.87715,0.039104,0.03328,0.004768,0.005376,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",15.9779,3.90365,0.046668,3.79267,0.02336,0.033216,0.005024,0.006048,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",13.6492,4.2559,0.059703,4.11997,0.043616,0.036384,0.005152,0.006816,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",21.7755,3.89962,0.048111,3.76205,0.046016,0.037984,0.004832,0.005696,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",22.2044,4.25507,0.081845,4.1392,0.028,0.033472,0.004768,0.005248,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",14.6486,3.84714,0.05804,3.73795,0.022176,0.033632,0.004512,0.005952,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",14.1162,3.90032,0.081283,3.792,0.022944,0.032992,0.004416,0.005632,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",15.0207,4.06464,0.085512,3.9225,0.047168,0.041248,0.004896,0.005056,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",15.4038,4.62122,0.054523,4.50896,0.025312,0.03344,0.004672,0.005952,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",14.684,3.95261,0.066255,3.80032,0.053472,0.042688,0.005152,0.007456,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",15.4262,4.13955,0.05816,4.02643,0.025856,0.033184,0.004512,0.006016,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",21.3651,3.9159,0.043593,3.79853,0.031232,0.033792,0.004384,0.004832,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",17.3423,3.96237,0.052178,3.81568,0.050912,0.040416,0.004768,0.006176,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",14.6369,4.39661,0.061166,4.28288,0.02704,0.033184,0.004512,0.005952,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",15.4981,4.59818,0.07943,4.48384,0.02608,0.03408,0.004928,0.005664,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",17.4442,3.91299,0.072446,3.8025,0.02304,0.03424,0.004416,0.00608,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",15.6137,4.1815,0.067377,4.03248,0.026912,0.033312,0.004576,0.011488,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",15.7201,3.68115,0.049905,3.57171,0.022592,0.033216,0.004768,0.005024,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",25.2425,4.96784,0.042881,4.85472,0.025888,0.033344,0.004672,0.005024,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",15.0285,4.25296,0.065073,4.13866,0.026368,0.033664,0.004576,0.005664,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+frustum,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",14.0565,3.90509,0.053081,3.79514,0.02304,0.03312,0.004704,0.005344,6819360,2,1,416,608,0,0,1024,0,0,0,1,1,1,1,0
+open,direct,0,"NVIDIA GeForce RTX 2080 Ti",75.4159,0.508224,0.105619,0,0.46112,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,1,"NVIDIA GeForce RTX 2080 Ti",71.9423,0.495904,0.054683,0,0.452544,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,2,"NVIDIA GeForce RTX 2080 Ti",72.1826,0.49408,0.055505,0,0.450176,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,3,"NVIDIA GeForce RTX 2080 Ti",70.6288,0.498816,0.077135,0,0.454528,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,4,"NVIDIA GeForce RTX 2080 Ti",64.3715,0.497312,0.04744,0,0.45376,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,5,"NVIDIA GeForce RTX 2080 Ti",64.6311,0.519136,0.037631,0,0.463712,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,6,"NVIDIA GeForce RTX 2080 Ti",66.4933,0.495104,0.056857,0,0.451168,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,7,"NVIDIA GeForce RTX 2080 Ti",63.3715,0.497344,0.054283,0,0.453856,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,8,"NVIDIA GeForce RTX 2080 Ti",82.412,0.506464,0.052018,0,0.45872,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,9,"NVIDIA GeForce RTX 2080 Ti",67.0274,0.504928,0.039174,0,0.45712,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,10,"NVIDIA GeForce RTX 2080 Ti",73.8591,0.501952,0.054402,0,0.4544,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,11,"NVIDIA GeForce RTX 2080 Ti",66.3768,0.5,0.038142,0,0.45248,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,12,"NVIDIA GeForce RTX 2080 Ti",70.3189,0.50464,0.064662,0,0.456704,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,13,"NVIDIA GeForce RTX 2080 Ti",65.2081,0.643744,0.056717,0,0.59552,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,14,"NVIDIA GeForce RTX 2080 Ti",63.5455,0.5048,0.054894,0,0.456928,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,15,"NVIDIA GeForce RTX 2080 Ti",80.4749,0.503264,0.101531,0,0.455008,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,16,"NVIDIA GeForce RTX 2080 Ti",75.2705,0.50176,0.052669,0,0.4536,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,17,"NVIDIA GeForce RTX 2080 Ti",80.0808,0.50208,0.045095,0,0.454368,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,18,"NVIDIA GeForce RTX 2080 Ti",93.9014,0.745664,0.064411,0,0.698336,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,19,"NVIDIA GeForce RTX 2080 Ti",73.3681,0.503296,0.053902,0,0.454656,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,20,"NVIDIA GeForce RTX 2080 Ti",67.2312,0.501632,0.051327,0,0.454016,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,21,"NVIDIA GeForce RTX 2080 Ti",80.4576,0.503776,0.068249,0,0.456704,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,22,"NVIDIA GeForce RTX 2080 Ti",86.3815,0.502624,0.050736,0,0.454656,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,23,"NVIDIA GeForce RTX 2080 Ti",70.3502,0.502176,0.046908,0,0.454656,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,24,"NVIDIA GeForce RTX 2080 Ti",78.2226,0.504288,0.062368,0,0.456704,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,25,"NVIDIA GeForce RTX 2080 Ti",71.0836,0.501952,0.078839,0,0.454176,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,26,"NVIDIA GeForce RTX 2080 Ti",67.9296,0.503904,0.054853,0,0.456384,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,27,"NVIDIA GeForce RTX 2080 Ti",68.8549,0.520544,0.046027,0,0.452608,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,28,"NVIDIA GeForce RTX 2080 Ti",92.9701,0.500672,0.06391,0,0.452608,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,direct,29,"NVIDIA GeForce RTX 2080 Ti",79.0998,0.533728,0.04765,0,0.464896,0,0,0,7811584,1024,0,0,0,0,0,1024,0,0,0,0,0,1,0,0
+open,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",29.988,18.3438,0.071275,18.2524,0.047168,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",27.8357,18.0194,0.058,17.9242,0.048544,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",24.3574,16.846,0.077016,16.7574,0.04576,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",28.6013,17.984,0.053962,17.893,0.045472,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",37.7658,18.3212,0.057167,18.2322,0.046016,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",30.6567,18.6845,0.076464,18.5544,0.084416,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",28.5088,17.7775,0.06891,17.6895,0.045536,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",28.324,18.5474,0.053451,18.4579,0.045568,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",26.4022,18.0869,0.057268,17.9586,0.083968,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",35.8476,18.6815,0.059493,18.592,0.045696,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",29.5405,18.4589,0.128041,18.369,0.04544,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",28.9524,18.6512,0.050174,18.5228,0.084736,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",29.4448,17.5729,0.117241,17.4833,0.045856,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",42.3364,17.4876,0.058019,17.398,0.045664,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",28.2529,18.3513,0.075352,18.2618,0.04576,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",29.0273,18.2315,0.061897,18.1417,0.046464,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",29.9301,18.7874,0.05258,18.6876,0.055968,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",37.164,18.2667,0.04814,18.1759,0.047072,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",29.4363,18.7093,0.065414,18.6178,0.046656,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",29.6403,19.8892,0.067768,19.7987,0.046464,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",32.7416,19.4688,0.082456,19.3375,0.085696,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",29.5868,18.1427,0.05328,18.0532,0.04656,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",28.8153,16.8258,0.068049,16.7443,0.038752,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",28.9586,17.5112,0.064301,17.3821,0.08528,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",29.1362,19.4576,0.054944,19.3681,0.046944,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",24.577,16.4695,0.048311,16.3804,0.045536,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",27.0231,17.7367,0.051758,17.6471,0.046304,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",35.9085,19.1104,0.053551,19.0206,0.046304,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",31.4475,18.1968,0.06851,18.1075,0.045888,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",29.3173,18.081,0.088197,17.9485,0.084096,0,0,0,5417504,1,1,1024,0,0,0,1024,0,0,0,0,1,1,1,0
+open,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",34.1327,17.7203,0.04757,17.5952,0.045248,0.033344,0.00448,0.00576,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",37.526,18.9227,0.439369,18.7964,0.045504,0.03312,0.004544,0.005344,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",27.7994,17.2956,0.048281,17.168,0.045408,0.033568,0.004896,0.005952,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",27.7663,18.1303,0.070653,18.0015,0.046464,0.033408,0.005088,0.005984,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",31.5291,18.8135,0.043692,18.6844,0.04656,0.033088,0.004768,0.00544,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",33.5083,18.5115,0.048842,18.3816,0.046272,0.033472,0.005376,0.005984,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",38.1542,19.8109,0.050365,19.6849,0.045152,0.033152,0.004832,0.005408,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",40.3854,18.8748,0.07424,18.7441,0.046752,0.033088,0.005312,0.00592,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",29.4444,18.5252,0.071395,18.3971,0.04656,0.0336,0.004992,0.005088,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",34.2684,18.9979,0.061316,18.8686,0.046752,0.034048,0.00464,0.00608,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",36.2919,18.6141,0.061305,18.4867,0.046048,0.033152,0.0048,0.00544,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",38.7246,18.8321,0.055154,18.6632,0.082688,0.036736,0.005184,0.006656,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",29.287,18.0387,1.77014,17.9113,0.045248,0.03472,0.004576,0.00576,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",30.3873,18.9993,0.065523,18.8549,0.046496,0.03392,0.00496,0.0056,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",37.0305,19.4941,0.064923,19.3242,0.085088,0.035648,0.005024,0.00624,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",30.6531,18.7176,0.069391,18.5455,0.08512,0.036352,0.005312,0.007008,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",31.3,18.7644,0.077326,18.6372,0.045408,0.032896,0.005024,0.00656,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",44.8168,17.4992,0.053391,17.3733,0.04512,0.032864,0.004512,0.006176,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",35.6551,18.4565,0.06363,18.3302,0.045568,0.033312,0.00448,0.006048,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",37.8271,18.6476,0.082887,18.52,0.045056,0.033952,0.0048,0.006304,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",33.2102,18.8188,0.062848,18.6911,0.0456,0.033152,0.004512,0.006176,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",33.6445,18.4574,0.088477,18.3308,0.045664,0.03296,0.005088,0.00496,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",31.2976,18.6736,0.159961,18.5472,0.045696,0.03312,0.00448,0.006304,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",31.9702,18.3362,0.062177,18.2091,0.0456,0.033248,0.0048,0.006048,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",36.1229,17.8715,0.057569,17.696,0.085344,0.036864,0.005792,0.006496,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",30.8702,18.3402,0.069341,18.17,0.084096,0.036224,0.00496,0.00592,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",31.6967,18.9345,0.057719,18.8092,0.044672,0.03392,0.004512,0.005696,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",32.5823,18.3771,0.06853,18.2506,0.04464,0.03392,0.004576,0.005888,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",37.1916,19.1221,0.076965,18.9511,0.084704,0.035936,0.005472,0.007008,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+open,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",30.1716,18.4681,0.060484,18.3419,0.045312,0.033024,0.004512,0.005984,6819360,2,1,1024,0,0,0,1024,0,0,0,1,1,1,1,0
+occluded,direct,0,"NVIDIA GeForce RTX 2080 Ti",63.3464,0.492128,0.041188,0,0.45408,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,1,"NVIDIA GeForce RTX 2080 Ti",64.5729,0.530432,0.047049,0,0.457184,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,2,"NVIDIA GeForce RTX 2080 Ti",68.0189,0.604768,0.074941,0,0.566656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,3,"NVIDIA GeForce RTX 2080 Ti",64.9456,0.492864,0.045907,0,0.45536,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,4,"NVIDIA GeForce RTX 2080 Ti",65.5335,0.5616,0.046518,0,0.523104,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,5,"NVIDIA GeForce RTX 2080 Ti",76.4501,0.49296,0.045866,0,0.45504,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,6,"NVIDIA GeForce RTX 2080 Ti",80.3929,0.489472,0.048441,0,0.451424,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,7,"NVIDIA GeForce RTX 2080 Ti",78.6841,0.49408,0.057879,0,0.45536,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,8,"NVIDIA GeForce RTX 2080 Ti",68.9975,0.489632,0.108535,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,9,"NVIDIA GeForce RTX 2080 Ti",66.42,0.495232,0.043572,0,0.45264,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,10,"NVIDIA GeForce RTX 2080 Ti",60.8563,0.498656,0.034074,0,0.456704,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,11,"NVIDIA GeForce RTX 2080 Ti",66.8851,0.497504,0.04204,0,0.455968,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,12,"NVIDIA GeForce RTX 2080 Ti",60.9754,0.494656,0.043452,0,0.453376,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,13,"NVIDIA GeForce RTX 2080 Ti",62.6399,0.493984,0.040506,0,0.452576,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,14,"NVIDIA GeForce RTX 2080 Ti",66.5386,0.654048,0.062768,0,0.610848,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,15,"NVIDIA GeForce RTX 2080 Ti",61.5022,0.49696,0.037961,0,0.45552,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,16,"NVIDIA GeForce RTX 2080 Ti",74.3849,0.49584,0.068489,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,17,"NVIDIA GeForce RTX 2080 Ti",67.9715,0.496128,0.056016,0,0.454752,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,18,"NVIDIA GeForce RTX 2080 Ti",93.7392,0.495936,0.051838,0,0.454656,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,19,"NVIDIA GeForce RTX 2080 Ti",85.0805,0.49744,0.060254,0,0.455328,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,20,"NVIDIA GeForce RTX 2080 Ti",83.2493,0.507008,0.050896,0,0.459776,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,21,"NVIDIA GeForce RTX 2080 Ti",89.0997,0.497152,0.060053,0,0.455136,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,22,"NVIDIA GeForce RTX 2080 Ti",62.5398,0.494464,0.047049,0,0.45328,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,23,"NVIDIA GeForce RTX 2080 Ti",67.3232,0.497504,0.055846,0,0.456128,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,24,"NVIDIA GeForce RTX 2080 Ti",70.2749,0.498336,0.05866,0,0.45776,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,25,"NVIDIA GeForce RTX 2080 Ti",65.115,0.49552,0.052349,0,0.45408,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,26,"NVIDIA GeForce RTX 2080 Ti",68.924,0.49584,0.042169,0,0.45312,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,27,"NVIDIA GeForce RTX 2080 Ti",69.8577,0.497632,0.203183,0,0.456256,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,28,"NVIDIA GeForce RTX 2080 Ti",81.2869,0.495392,0.055514,0,0.452608,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,direct,29,"NVIDIA GeForce RTX 2080 Ti",75.7277,0.495552,0.048752,0,0.454336,0,0,0,7816768,1026,0,0,0,0,0,1026,0,0,0,0,0,1,0,0
+occluded,gpu_frustum,0,"NVIDIA GeForce RTX 2080 Ti",30.8317,17.6516,0.052519,17.5672,0.04816,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,1,"NVIDIA GeForce RTX 2080 Ti",27.3587,18.3679,0.051978,18.2836,0.048128,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,2,"NVIDIA GeForce RTX 2080 Ti",30.9536,17.4843,0.051818,17.3997,0.048064,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,3,"NVIDIA GeForce RTX 2080 Ti",28.9336,18.2879,0.173617,18.2031,0.048224,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,4,"NVIDIA GeForce RTX 2080 Ti",27.911,17.8547,0.048942,17.7709,0.047392,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,5,"NVIDIA GeForce RTX 2080 Ti",29.6767,19.311,0.066926,19.2266,0.048288,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,6,"NVIDIA GeForce RTX 2080 Ti",36.6422,18.3951,0.048481,18.3143,0.045632,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,7,"NVIDIA GeForce RTX 2080 Ti",30.7874,18.5284,0.059773,18.446,0.046304,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,8,"NVIDIA GeForce RTX 2080 Ti",31.8146,18.6606,0.056547,18.5762,0.048288,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,9,"NVIDIA GeForce RTX 2080 Ti",30.2338,17.9315,0.066546,17.848,0.047168,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,10,"NVIDIA GeForce RTX 2080 Ti",27.3433,18.1383,0.072967,18.0144,0.086112,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,11,"NVIDIA GeForce RTX 2080 Ti",33.028,17.9224,0.056266,17.8391,0.046656,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,12,"NVIDIA GeForce RTX 2080 Ti",39.2899,19.1367,0.05811,19.0528,0.047488,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,13,"NVIDIA GeForce RTX 2080 Ti",30.933,18.9442,0.070082,18.8217,0.08544,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,14,"NVIDIA GeForce RTX 2080 Ti",32.4794,17.9719,0.062277,17.8875,0.048224,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,15,"NVIDIA GeForce RTX 2080 Ti",27.2453,18.2206,0.050325,18.1364,0.047776,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,16,"NVIDIA GeForce RTX 2080 Ti",29.5202,18.8119,0.056036,18.7284,0.046592,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,17,"NVIDIA GeForce RTX 2080 Ti",33.3184,18.3911,0.058831,18.3066,0.047648,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,18,"NVIDIA GeForce RTX 2080 Ti",29.3055,17.9568,0.065153,17.8725,0.047488,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,19,"NVIDIA GeForce RTX 2080 Ti",30.5783,18.734,0.228321,18.6199,0.062656,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,20,"NVIDIA GeForce RTX 2080 Ti",31.8372,17.7959,0.073308,17.7122,0.047712,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,21,"NVIDIA GeForce RTX 2080 Ti",36.5122,18.3571,0.049273,18.2325,0.086848,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,22,"NVIDIA GeForce RTX 2080 Ti",37.6488,18.9845,0.06362,18.8996,0.047424,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,23,"NVIDIA GeForce RTX 2080 Ti",30.5148,18.4183,0.062197,18.3331,0.048704,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,24,"NVIDIA GeForce RTX 2080 Ti",30.0404,18.2389,0.073289,18.1562,0.046432,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,25,"NVIDIA GeForce RTX 2080 Ti",30.5177,18.6789,0.076935,18.5652,0.076896,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,26,"NVIDIA GeForce RTX 2080 Ti",32.4181,18.086,0.122861,17.9997,0.048256,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,27,"NVIDIA GeForce RTX 2080 Ti",35.8143,19.1104,0.062188,18.9879,0.084992,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,28,"NVIDIA GeForce RTX 2080 Ti",30.6415,19.2991,0.062518,19.2154,0.047872,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_frustum,29,"NVIDIA GeForce RTX 2080 Ti",27.3059,17.7803,0.057869,17.6977,0.046944,0,0,0,5418032,1,1,1026,0,0,0,1026,0,0,0,0,1,1,1,0
+occluded,gpu_occlusion,0,"NVIDIA GeForce RTX 2080 Ti",28.5581,18.5991,0.07449,18.4815,0.016864,0.034176,0.023936,0.005376,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,1,"NVIDIA GeForce RTX 2080 Ti",28.4824,17.1929,0.058661,17.077,0.017344,0.032992,0.023872,0.006048,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,2,"NVIDIA GeForce RTX 2080 Ti",34.9814,19.1306,0.072908,19.0125,0.018304,0.033344,0.024288,0.005984,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,3,"NVIDIA GeForce RTX 2080 Ti",32.3468,17.8426,0.059703,17.7237,0.018272,0.033344,0.024256,0.005888,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,4,"NVIDIA GeForce RTX 2080 Ti",28.7413,18.7033,0.056997,18.5849,0.017504,0.033984,0.024064,0.006528,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,5,"NVIDIA GeForce RTX 2080 Ti",25.4956,17.1483,0.055134,17.0333,0.016192,0.034016,0.023744,0.005728,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,6,"NVIDIA GeForce RTX 2080 Ti",31.2985,19.291,0.04754,19.1754,0.016896,0.0328,0.024032,0.005984,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,7,"NVIDIA GeForce RTX 2080 Ti",30.6246,17.6645,0.061867,17.5465,0.017248,0.033344,0.024064,0.005792,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,8,"NVIDIA GeForce RTX 2080 Ti",28.1205,18.1701,0.067918,18.0516,0.018208,0.033216,0.024352,0.005984,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,9,"NVIDIA GeForce RTX 2080 Ti",27.3062,17.9326,0.045415,17.8162,0.0176,0.033216,0.023872,0.005024,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,10,"NVIDIA GeForce RTX 2080 Ti",32.6151,19.0294,0.055615,18.914,0.01712,0.033088,0.023904,0.005312,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,11,"NVIDIA GeForce RTX 2080 Ti",31.0474,17.7137,0.065063,17.5972,0.017216,0.033376,0.024192,0.005984,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,12,"NVIDIA GeForce RTX 2080 Ti",27.9083,17.0977,0.049053,16.9817,0.016448,0.034656,0.023744,0.005088,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,13,"NVIDIA GeForce RTX 2080 Ti",26.5257,17.5348,0.052709,17.4188,0.017376,0.033312,0.023808,0.005152,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,14,"NVIDIA GeForce RTX 2080 Ti",30.9145,17.2025,0.050766,17.0868,0.0176,0.033344,0.023776,0.0048,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,15,"NVIDIA GeForce RTX 2080 Ti",31.1376,17.9252,0.077677,17.8076,0.017824,0.033184,0.02432,0.006048,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,16,"NVIDIA GeForce RTX 2080 Ti",28.9649,18.1055,0.060294,17.9881,0.017824,0.033536,0.023968,0.005888,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,17,"NVIDIA GeForce RTX 2080 Ti",31.0883,18.5147,0.057368,18.3985,0.017152,0.03344,0.02384,0.005696,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,18,"NVIDIA GeForce RTX 2080 Ti",28.6956,17.7632,0.044995,17.6459,0.01744,0.033984,0.024064,0.006112,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,19,"NVIDIA GeForce RTX 2080 Ti",31.811,17.8688,0.046437,17.7501,0.018432,0.033152,0.023904,0.006496,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,20,"NVIDIA GeForce RTX 2080 Ti",29.399,18.8337,0.064522,18.7163,0.016768,0.034368,0.024192,0.004928,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,21,"NVIDIA GeForce RTX 2080 Ti",28.268,18.285,0.050094,18.169,0.016928,0.034112,0.023584,0.005696,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,22,"NVIDIA GeForce RTX 2080 Ti",29.3513,17.5258,0.044794,17.4092,0.017216,0.033536,0.023904,0.005632,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,23,"NVIDIA GeForce RTX 2080 Ti",32.4829,18.6526,0.067237,18.5358,0.017568,0.033216,0.024064,0.005824,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,24,"NVIDIA GeForce RTX 2080 Ti",28.8413,17.4774,0.045286,17.3376,0.017984,0.037472,0.040288,0.006208,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,25,"NVIDIA GeForce RTX 2080 Ti",24.1706,16.2484,0.045967,16.1326,0.01696,0.033312,0.023712,0.00544,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,26,"NVIDIA GeForce RTX 2080 Ti",31.6643,18.1406,0.052038,18.0234,0.017472,0.033312,0.023904,0.00592,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,27,"NVIDIA GeForce RTX 2080 Ti",30.7269,17.392,0.070453,17.276,0.017376,0.033216,0.023936,0.005632,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,28,"NVIDIA GeForce RTX 2080 Ti",28.1413,17.5251,0.049734,17.4092,0.017184,0.033152,0.023744,0.005792,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0
+occluded,gpu_occlusion,29,"NVIDIA GeForce RTX 2080 Ti",26.4721,17.5592,0.049724,17.4434,0.01728,0.032992,0.023616,0.00544,6819888,2,1,1,0,1025,0,1026,0,0,0,1,1,1,1,0

docs/superpowers/plans/2026-09-23-p2-gpu-visibility.md

@@ -0,0 +1,124 @@
+# P2 GPU Visibility and Mesh LOD Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Deliver all of PLAN P2: stable GPU instance IDs, GPU frustum culling, fixed indirect bins, a visible HZB debug mode, conservative two-pass occlusion, prepared mesh LOD with hysteresis, and measured comparisons to the direct renderer.
+
+**Architecture:** Keep the current direct path as a selectable reference. Add an opaque instanced path with local mesh geometry, instance/visible-ID storage buffers and compute-authored indirect instance counts. Split opaque rasterization around an ordinary-Z max-depth HZB; repair previous-frame occlusion guesses in a current-frame post pass. Keep shadows and ordered sprites/UI independent.
+
+**Tech Stack:** C++20, Vulkan 1.3, Slang/SPIR-V, CMake/Ninja, SDL3, CPU contract tests and GPU validation/image tests.
+
+**Spec:** `docs/superpowers/specs/2026-09-23-p2-gpu-visibility-design.md`
+
+## Global Constraints
+
+- Preserve the existing direct renderer and a runtime switch that selects it.
+- Player/export contain cooked SPIR-V and metadata; no Slang compiler is required at runtime.
+- MCP remains editor-only and never exposes the live Player world.
+- Forward Z uses max-depth HZB, depth clear 1, and `LESS_OR_EQUAL`.
+- No camera-frustum decision may remove a shadow caster; sprites and UI remain ordered.
+- No required ray tracing, mesh shader, multi-draw-indirect, `drawIndirectFirstInstance`, or synchronous GPU visibility readback.
+- Check actual Vulkan feature/format/limit support and retain a direct fallback if the P2 profile is unavailable.
+
+## Review Focus
+
+- Empty scene and exact bin capacity: indirect counts reset to zero and cannot address outside reserved ID ranges; Task 3 pins this.
+- Door opens or disappears: a previously hidden object appears in the same final frame through Post; Task 5 pins this.
+- Odd and resized viewports: HZB padding is far depth and stale history cannot be sampled; Tasks 4–5 pin this.
+- Offscreen shadow caster: camera visibility leaves shadow generation intact; Task 3 pins this.
+- Mesh/key reuse and LOD changes: previous transforms and occlusion are invalidated; Tasks 1 and 6 pin this.
+
+---
+
+**Implementation note, 23 September 2026:** this checklist records the proposed execution sequence. A checked item has direct code/test/commit evidence; an unchecked item may be an unrecorded test-first step or a narrower validation/documentation gap, even where the corresponding P2 feature works. The [acceptance protocol](../../studies/19-p2-gpu-visibility-acceptance.md), [initial benchmark](../../studies/20-p2-gpu-visibility-benchmark-2026-09-23.md), [optimized repeat](../../studies/21-p2-gpu-visibility-optimization-2026-09-23.md) and [SwiftShader compatibility record](../../validation/p2-swiftshader-2026-09-23/README.md) report their tested configurations. Real-game performance and physical Windows GPUs require separate evidence.
+
+### Task 1: Stable instances, conservative bounds, and LOD policy
+
+**Files:** Modify `include/faset/render/renderer.hpp`, `src/player/SceneView.cpp`, `cmake/Renderer.cmake`; create `include/faset/render/visibility.hpp`, `src/render/visibility.cpp`, `tests/render_visibility_policy_tests.cpp`.
+
+**Interfaces:** Produce `InstanceTracker::update(key, meshIdentity, model, bounds, viewId)` returning slot, generation, previous bounds and `previousValid`; `select_lod(projectedPixels, previousLevel, thresholds, hysteresis)`; `transformed_bounds(mesh, model)`. Add optional `DrawItem::instance_key`, `DrawItem::lod_meshes`, `Snapshot::view_id`, `Snapshot::camera_cut` without changing existing aggregate initialization order.
+
+- [x] **Step 1: Write failing CPU tests.** Assert transformed bounds for rotated, negative/nonuniform scaled meshes; stable slot through reorder; generation change after removal/reuse or mesh replacement; no previous state on camera cut; LOD hysteresis on both sides of a threshold; fallback when a level is absent. Include this core assertion:
+  ```cpp
+  auto first = tracker.update("object/primitive", meshA, identity, box, "game");
+  auto second = tracker.update("object/primitive", meshA, moved, box, "game");
+  require(first.slot == second.slot && second.previous_valid);
+  tracker.finish_frame();
+  require(!tracker.update("object/primitive", meshB, moved, box, "game").previous_valid);
+  ```
+- [ ] **Step 2: Run the focused test target and record the expected missing-interface failure.** `cmake --build --preset linux-debug --target faset_render_visibility_policy_tests -j 6` must fail before implementation because the new interfaces/target do not exist.
+- [x] **Step 3: Implement the policy and extraction keys.** Derive keys from persistent scene object and imported primitive identity; anonymous draws remain renderable without temporal state. Use all eight local AABB corners and finite-value checks. Define an explicit LOD threshold/hysteresis contract in the header.
+- [x] **Step 4: Rebuild/run the focused CPU test, then the existing scene-view tests.** `ctest --test-dir build/linux-debug --output-on-failure -R 'visibility_policy|player_scene_contracts'` must pass.
+- [x] **Step 5: Commit** `Introduce stable render instances and prepared LOD policy`.
+
+### Task 2: P2 Slang bundle and checked shader metadata
+
+**Files:** Create `shaders/gpu_scene.slang`; modify `tools/compile_shader.py`, `cmake/Renderer.cmake`, `src/render/shader_contract.cpp`, `src/render/shader_contract.hpp`, `src/editor/build_service.cpp`, relevant shader/build tests.
+
+**Interfaces:** Compile and validate `gpuVertexMain`, `gpuShadowMain`, `gpuCullMain`, `gpuHzbMain`, `gpuPostCullMain` with documented set/binding layouts. Baseline `vertexMain`, `fragmentMain`, `shadowMain` and their hot-reload fingerprint contract remain valid. Export includes each new `.spv` and `.reflection.json` pair.
+
+- [x] **Step 1: Write failing reflection/package tests.** A storage-buffer/storage-image Slang reflection fixture must normalize to a typed descriptor; missing or tampered P2 SPIR-V/metadata must fail validation; a packaged Player must contain all required P2 shaders.
+- [ ] **Step 2: Run focused tests and verify the expected rejection or missing-artifact failure.** `ctest --test-dir build/linux-debug --output-on-failure -R 'render_shader_reload|build_schema_publication'` plus the new reflection test target.
+- [x] **Step 3: Extend the compiler's descriptor normalization and add the P2 shader entries.** Vertex resolves `visibleIds[binBase + SV_VulkanInstanceID]`; compute writes bounded per-bin IDs/counts; HZB computes max of valid children and far depth for padding. Keep C++/Slang record strides explicit and checked.
+- [x] **Step 4: Validate generated reflection and package.** Rebuild `faset_shaders`, run the focused tests and inspect each generated metadata stage/binding/fingerprint.
+- [x] **Step 5: Commit** `Add checked Slang shaders for GPU visibility and HZB`.
+
+### Task 3: GPU frustum culling and fixed indirect bins
+
+**Files:** Modify `src/render/renderer.cpp`, `include/faset/render/renderer.hpp`, `tests/render_tests.cpp`; create `tests/render_gpu_visibility_tests.cpp`.
+
+**Interfaces:** `RendererConfig::visibility_mode` selects direct/auto/GPU; `FrameStats` exposes submitted bin and frustum-visible counts. Renderer-owned buffers hold local vertices, instance records, candidate/bin tables, visible IDs and `VkDrawIndirectCommand` templates. One draw per bin uses `firstInstance=0`.
+
+- [ ] **Step 1: Write GPU integration tests.** Direct/GPU images must agree on the same opaque cube/plane scene; empty and one-instance scenes have zero/one visible instances; over-capacity growth and all-six-plane rejects remain validation-clean; an offscreen caster continues to affect a visible receiver.
+- [ ] **Step 2: Run the new GPU test and verify that GPU mode is absent/fails for the intended reason.** Use `ctest --test-dir build/linux-debug --output-on-failure -R '^render_gpu_visibility$'`.
+- [x] **Step 3: Add checked device capability selection and distinct GPU scene resources.** Build mesh+texture bins, upload local vertices once per unique mesh each frame, reserve one ID range per bin, create/update descriptors, dispatch frustum cull, barrier compute writes to indirect and vertex-storage reads, and issue fixed indirect draws. Keep the direct path byte-for-byte selectable.
+- [x] **Step 4: Run the focused GPU test with Khronos validation and the existing offscreen renderer tests.** No Vulkan errors, no visible image holes, and no shadow regression.
+- [x] **Step 5: Commit** `Render opaque meshes through GPU culling and fixed indirect bins`.
+
+### Task 4: Current HZB and diagnostic view
+
+**Files:** Modify `src/render/renderer.cpp`, `include/faset/render/renderer.hpp`, `shaders/gpu_scene.slang`, `tests/render_gpu_visibility_tests.cpp`; add a focused HZB CPU oracle test if the reduction/projection contract needs isolation.
+
+**Interfaces:** `RendererConfig` or `Snapshot` selects HZB visualization; `FrameStats` records HZB extent, levels and build time. The current depth attachment is stored and sampled; a per-mip `R32_SFLOAT` image stores max-depth reduction.
+
+- [ ] **Step 1: Write failing tests.** Assert odd 319×241 extent, a far-depth hole, mip chain dimensions/padding, resized target recreation and an HZB debug image with non-uniform depth.
+- [ ] **Step 2: Run the tests and confirm the missing HZB/debug capability is the failure.** `ctest --test-dir build/linux-debug --output-on-failure -R '^render_gpu_visibility$'`.
+- [x] **Step 3: Split Main opaque raster from sprites/UI, store depth, allocate sampled/storage HZB mip views, dispatch each reduction with explicit depth→compute and mip→mip barriers, and draw a selectable debug visualization.** Preserve existing forward-Z convention.
+- [x] **Step 4: Run focused GPU tests and baseline image tests under validation; compare HZB-off output with direct mode.**
+- [x] **Step 5: Commit** `Build and visualize current-frame max-depth HZB`.
+
+### Task 5: Previous-HZB main pass and same-frame post repair
+
+**Files:** Modify `src/render/renderer.cpp`, `src/render/visibility.cpp`, `shaders/gpu_scene.slang`, `tests/render_gpu_visibility_tests.cpp`.
+
+**Interfaces:** View history contains view identity, extent/viewport/projection, frame epoch, previous VP and HZB handle. MainCull may defer only a candidate with valid previous instance/view history; PostCull retests deferred candidates against current HZB and writes separate post args/IDs. PostRaster loads existing color and depth.
+
+- [ ] **Step 1: Write failing frame-sequence tests.** A wall hides an object in frame N; opening/deleting/teleporting it in N+1 reveals that object in the final N+1 image. Camera cut, projection change, view ID change and resize force history invalid; near-plane crossing fails open. Compare every frame against HZB-disabled output.
+- [ ] **Step 2: Run the tests and observe the missing deferral/post behavior.** `ctest --test-dir build/linux-debug --output-on-failure -R '^render_gpu_visibility$'`.
+- [x] **Step 3: Implement previous/current projection tests, bounded deferred/post buffers, history ping-pong and invalidation, explicit compute→indirect/vertex barriers and Main/CurrentHZB/Post pass order.** Use ordinary-Z max-depth comparison with precision bias and full projected rectangle.
+- [x] **Step 4: Run the sequence and full GPU render suites with validation; confirm no same-frame holes.**
+- [x] **Step 5: Commit** `Repair temporal occlusion with current-frame post pass`.
+
+### Task 6: Prepared mesh LOD, editor controls and profiling
+
+**Files:** Modify `src/player/SceneView.cpp`, `src/editor/editor_ui.cpp`, `include/faset/render/renderer.hpp`, `src/render/renderer.cpp`, `tests/render_gpu_visibility_tests.cpp`; add a prepared-LOD example asset/scene and manual page under `docs/manual/editor/`.
+
+**Interfaces:** Imported or C++-supplied prepared LOD meshes are selected by projected size and Task 1 hysteresis. Changing level changes the bin but keeps the logical instance key and invalidates previous occlusion. Editor can switch direct/GPU/HZB modes and inspect culling/LOD counters without adding MCP access to the Player.
+
+- [x] **Step 1: Write failing tests.** Jitter around both thresholds must retain the previous LOD; moving well across a threshold selects a different mesh/bin; missing levels fall back; both modes keep a valid image through level changes.
+- [ ] **Step 2: Run focused tests and verify the missing selection/control behavior.**
+- [ ] **Step 3: Hook prepared LODs into extraction and GPU binning, expose compact editor controls/statistics and a documented C++/asset authoring path.** Keep source scene IDs unchanged.
+- [x] **Step 4: Run CPU/GPU/editor UI suites and capture a representative debug screenshot.**
+- [x] **Step 5: Commit** `Expose prepared mesh LOD and GPU visibility diagnostics`.
+
+### Task 7: Adversarial validation, baselines and publication
+
+**Files:** Add `docs/validation/p2-gpu-visibility/README.md` and capture artifacts; update `PLAN.md`, `docs/manual/editor/profiling.md`, `docs/ARCHITECTURE.md`, CI GPU test registration as appropriate.
+
+**Interfaces:** Close P2 only with exact revision, compiler/driver/GPU/OS, scene/camera paths, commands, full-frame direct/GPU timings, pass counters, image comparison and stated coverage limits.
+
+- [ ] **Step 1: Add adversarial fixtures for mass deletion/reuse, near-plane, camera inside bounds, odd/offset viewport, door/wall, open scene and offscreen shadow caster; confirm at least one fails before its corresponding fix.**
+- [x] **Step 2: Run Debug and Release build/test suites, GPU validation, shader reload, two sample-game export/relaunch checks, and available Windows CI.** Record exact outputs; a platform without executed GPU coverage remains explicitly unverified.
+- [x] **Step 3: Profile the same closed and open scenes in direct and GPU modes.** Record CPU extraction/upload/submission, GPU pass and full-frame time, readback conditions, memory and culling counters. Do not turn a scene-specific result into a universal performance claim.
+- [x] **Step 4: Review all PLAN P2 criteria against evidence, update docs, run `graphify update .`, request independent code review and fix load-bearing findings.**
+- [x] **Step 5: Commit** `Validate and document P2 GPU visibility milestone`; publish only after all checks are green.

docs/superpowers/plans/2026-09-24-p1-iteration.md

@@ -0,0 +1,253 @@
+# P1 Gameplay Iteration Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Close PLAN P1 with reliable build/schema reuse, useful diagnostics and source navigation, four runnable project starters, safe scene autosave, repeatable iteration evidence, and Linux/Windows Lua validation.
+
+**Architecture:** Keep CMake/Ninja responsible for native dependency analysis and retain immutable last-good build generations. Add a content-checked schema/package cache after native build, normalize diagnostics into the existing job API, run revision-aware autosave in `Session::poll`, and expose all new state through Editor commands shared by GUI and MCP.
+
+**Tech Stack:** C++20, CMake/Ninja, Clang/clang-cl, optional Lua 5.4, SDL3/Vulkan 1.3 for graphical tests, Python 3 for workflow measurements, MkDocs Material.
+
+**Spec:** `docs/superpowers/specs/2026-09-24-p1-iteration-design.md`
+
+## Global Constraints
+
+- Linux and Windows x86-64 desktop 2D/3D are the supported P1 targets; all user-facing Editor copy and Manual pages are English.
+- C++ is compiled into the Player; Lua is optional and development reload resets state. No C++ hot reload or dynamic gameplay loading is required.
+- MCP addresses Editor authoring/build services, never the live Player world.
+- Build and export failures preserve the last successful generation and schema; Debug and Release native trees stay separate.
+- CMake/Ninja always run for a requested native build; cache reuse starts only after their success and artifact verification.
+- The existing recovery journal protects every authoring transaction; autosave never overwrites a disk conflict or gives an unnamed scene an implicit path.
+- The two `docs/design/p1-*-reference.png` images guide visual quality only; `PLAN.md` and the spec define behavior. Paths are cross-platform.
+- Keep `BuildService::scaffold(name, dimension)` and `faset_script_open` working for existing callers.
+- Before every RED CTest run, register a new named test if needed, reconfigure and rebuild its executable; `ctest --no-tests=error` prevents an empty match from passing.
+
+## Review Focus
+
+- An included project header changes while a build runs: reject the mixed candidate and keep the last-good pointer; Tasks 1–2 pin this.
+- A toolchain executable changes in place while its path remains the same: invalidate the native build tree/package key; Task 1 pins this.
+- A valid cached manifest points to a truncated schema or shader: do not return a hit; Task 2 pins this.
+- An external editor or another MCP client changes a scene before autosave: never overwrite it or a newer revision; Task 6 pins this.
+- A Windows diagnostic contains a drive colon, Unicode directories and a line/column: parse the right location and reject navigation outside `Scripts`; Tasks 3–4 pin this.
+
+---
+
+### Task 1: Capture complete gameplay inputs and toolchain identity
+
+**Files:** Create `include/faset/editor/build_cache.hpp`, `src/editor/build_cache.cpp`, `tests/build_cache_tests.cpp`; modify `cmake/BuildService.cmake`, `src/editor/build_service.cpp`, `src/editor/session.cpp`.
+
+**Interfaces:** `BuildInputs capture_build_inputs(const BuildConfig&, const scripting::LuaProject&)` records `source_hash` over all regular files under project `Scripts` plus Lua declaration/fingerprint, and separate recipe/toolchain hashes over normalized configure args and executables. `BuildInputs::fingerprint()` combines these fields deterministically. `ensure_native_toolchain_stamp(native_directory, inputs)` forces a fresh native tree if the compiler/CMake/Slang identity changed in place. Extract the common Scripts snapshot so `Session::source_signature()` and `BuildService` use the same content set, while allowing their intended extra fields to differ.
+
+- [ ] **Step 1: Write failing source/identity tests.** In `tests/build_cache_tests.cpp`, construct a temporary project with `Gameplay.cpp`, `Gameplay.hpp` and `Scripts/Extensions/Extra.hpp`; change only the nested header, Lua declaration and then bytes of a fake compiler at the same path. Each change must alter the corresponding fingerprint. A symlink escaping `Scripts` must be rejected. Test the toolchain stamp with a disposable build directory. Register `faset_build_cache_tests` and CTest name `build_cache` in `cmake/BuildService.cmake` before the red run.
+  ```cpp
+  const auto before = capture_build_inputs(config, lua);
+  atomic_write(root / "Scripts/Extensions/Extra.hpp", "#define SPEED 2\n");
+  require(capture_build_inputs(config, lua).fingerprint() != before.fingerprint(),
+          "Nested gameplay header invalidates the source snapshot");
+  ```
+- [ ] **Step 2: Build the red test.** Run `cmake --preset linux-debug`, then `cmake --build --preset linux-debug --target faset_build_cache_tests --parallel 4`. The test target is registered; compilation must fail specifically on the missing `capture_build_inputs` interface, not on an unknown target.
+- [ ] **Step 3: Implement the input scanner and toolchain stamp.** Sort project-relative UTF-8 paths, hash file bytes, reject escaping symlinks, include explicit recipe/version values, and hash resolved tool executables. Do not use modification time alone. Compare/persist the stamp before native configure; on a changed stamp clear only the generated native tree for that configuration, never published generations or source files. Replace the narrower two-file post-build race check with the captured complete Scripts snapshot.
+  ```cpp
+  const auto submitted = capture_build_inputs(config, job.lua);
+  ensure_native_toolchain_stamp(native_directory, submitted);
+  // After native build and schema extraction, before publication:
+  if (capture_build_inputs(config, scripting::loadLuaProject(config.project_root))
+          .source_hash != submitted.source_hash)
+      throw std::runtime_error("Gameplay sources changed during the build; build again");
+  ```
+- [ ] **Step 4: Rebuild and run focused tests.** Build `faset_build_cache_tests faset_build_schema_tests faset_editor_session_tests`, then run `ctest --test-dir build/linux-debug --no-tests=error --output-on-failure -R '^(build_cache|build_schema_publication|editor_session_settings)$'`. All three named tests pass; a changed nested header during the fixture build rejects publication.
+- [ ] **Step 5: Commit** `Capture complete gameplay and toolchain build inputs`.
+
+### Task 2: Reuse only verified schema/package generations
+
+**Files:** Modify `include/faset/editor/build_service.hpp`, `src/editor/build_cache.cpp`, `src/editor/build_service.cpp`, `tests/build_cache_tests.cpp`, `tests/build_schema_tests.cpp`, `tests/build_service_tests.cpp`.
+
+**Interfaces:** `build_package_key(inputs, native_directory, configuration)` hashes the post-build Player, SchemaExporter, required SPIR-V/reflection files, runtime libraries and CMake cache. `validate_build_generation(directory, key)` verifies every recorded file hash and validates the schema. Successful `BuildService::build()` returns `schema_cache_hit`, `generation_reused`, `fingerprint`, and phase times without changing existing result paths.
+
+- [ ] **Step 1: Write failing cache and invalidation tests.** The fixture `tests/build_schema_tests.cpp` must count SchemaExporter invocations: two unchanged builds return the same generation and count one export; a changed C++ header, Lua source, configure option, shader bytes or runtime artifact produces a new generation; corrupt or missing cached schema/shader is never a hit. Extend `tests/build_service_tests.cpp` so a failed compile preserves `last_build.json`, and export after changed asset source fails until reimport, then packages the new asset generation despite a gameplay cache hit.
+  ```cpp
+  const auto first = builds.wait(builds.start_build());
+  const auto again = builds.wait(builds.start_build());
+  check(again.result.at("generation") == first.result.at("generation") &&
+            again.result.at("schema_cache_hit") == true &&
+            again.result.at("generation_reused") == true,
+        "Unchanged build reuses a verified generation");
+  ```
+- [ ] **Step 2: Run rebuilt red tests.** Build `faset_build_cache_tests faset_build_schema_tests faset_build_service_tests`, then run `ctest --test-dir build/linux-debug --no-tests=error --output-on-failure -R '^(build_cache|build_schema_publication|process_and_cook)$'`. At least the newly added cache assertion must fail on missing flags or duplicate schema export; an old binary passing does not count.
+- [ ] **Step 3: Implement post-native cache lookup and manifest hashes.** Continue to run configure/build first. Compute the package key, verify the previous generation's manifest/files/schema, then return it without SchemaExporter/copy if valid. Otherwise export schema into staging from the captured Lua snapshot, copy files, write per-file hashes and key, recheck source snapshot, and atomically update `last_build.json`. Never return a damaged generation. Keep the raw job log and phase timing for a hit as well as a miss.
+  ```cpp
+  if (auto previous = verified_generation(config.cache_root, key))
+      return result_for(*previous, /*schema_cache_hit=*/true,
+                        /*generation_reused=*/true);
+  // Only a fully validated staging directory may become last_build.json.
+  ```
+- [ ] **Step 4: Rebuild and run focused/integration tests.** Build `faset_build_cache_tests faset_build_schema_tests faset_build_service_tests faset_editor_session_tests`, then run `ctest --test-dir build/linux-debug --no-tests=error --output-on-failure -R '^(build_cache|build_schema_publication|process_and_cook|editor_session_settings)$'`. All four pass. Inspect one real no-op build's log: Ninja does no native compile/link; SchemaExporter is absent on the second request. Do not call this a native cache hit unless the log confirms it.
+- [ ] **Step 5: Commit** `Reuse verified gameplay schema and build generations`.
+
+### Task 3: Parse structured compiler and Lua diagnostics
+
+**Files:** Create `include/faset/editor/build_diagnostics.hpp`, `src/editor/build_diagnostics.cpp`, `tests/build_diagnostics_tests.cpp`; modify `cmake/BuildService.cmake`, `include/faset/editor/build_service.hpp`, `src/editor/build_service.cpp`.
+
+**Interfaces:** `parse_build_diagnostics(raw_log, phase, project_root)` returns a bounded JSON array of `{severity, phase, message, file?, line?, column?, code?}`. `JobStatus::diagnostics` is serialized by `JobStatus::json()` and returned by `faset_job`; `log` and `error` remain unchanged for old clients.
+
+- [ ] **Step 1: Write failing parser fixtures.** Cover `/project/Scripts/Game.cpp:17:4: error:`, `C:\\Café\\Scripts\\Game.cpp(17,4): error`, `C:\\Café\\Scripts\\Game.cpp:17:4: warning:`, `Scripts/player.lua:6: unexpected symbol`, ANSI escapes, multiline note/caret output, an engine/external path, and a nonzero process with only unparseable text. Assert one-based positive locations and normalized project-relative files only for files under `Scripts`. Register `faset_build_diagnostics_tests` and CTest name `build_diagnostics` in `cmake/BuildService.cmake`.
+  ```cpp
+  const auto rows = parse_build_diagnostics(
+      "Scripts/Game.cpp:17:4: error: bad field\n", "compile", project);
+  require(rows.size() == 1 && rows[0].at("file") == "Scripts/Game.cpp" &&
+              rows[0].at("line") == 17 && rows[0].at("severity") == "error",
+          "Clang location is structured");
+  ```
+- [ ] **Step 2: Build the red parser test.** Run `cmake --preset linux-debug`, then `cmake --build --preset linux-debug --target faset_build_diagnostics_tests --parallel 4`. Compilation must fail on the missing parser API, not an unknown test target.
+- [ ] **Step 3: Implement incremental job collection.** Parse completed log lines as process output arrives, cap row count/message size, strip ANSI, and preserve every raw line in the bounded existing log. Use phase names from `BuildService` checkpoints. On a failed process with no parsed error, add a generic diagnostic with the exit code and `see job log`; never fabricate a navigable file.
+  ```cpp
+  job.status.diagnostics = parse_build_diagnostics(job.status.log, job.status.stage,
+                                                    config.project_root);
+  if (exit_code != 0 && job.status.diagnostics.empty())
+      job.status.diagnostics.push_back(generic_process_error(exit_code));
+  ```
+- [ ] **Step 4: Run parser and real failure tests.** Build `faset_build_diagnostics_tests faset_build_service_tests faset_build_schema_tests`, then run `ctest --test-dir build/linux-debug --no-tests=error --output-on-failure -R '^(build_diagnostics|process_and_cook|build_schema_publication)$'`. All three pass; a deliberate `#error` in `Gameplay.cpp` yields both a structured row and the original log, with previous build retained.
+- [ ] **Step 5: Commit** `Expose structured gameplay build diagnostics`.
+
+### Task 4: Open project source at a diagnostic location
+
+**Files:** Modify `src/editor/session.cpp`, `src/editor/editor_ui.cpp`, `tests/editor_session_tests.cpp`, `tests/editor_ui_tests.cpp`, `docs/manual/editor/diagnostics.md`.
+
+**Interfaces:** New command `faset_source_open({path, line?, column?, editor?})` validates project code source and opens it with an argv template. Existing `faset_script_open` delegates to the same safe launcher while retaining Lua-only validation. `editor.script_editor` accepts `{file}`, `{line}`, `{column}` and `{project}` tokens. The Console uses Task 3 `diagnostics` and displays cache/timing fields from Task 2.
+
+- [ ] **Step 1: Write failing command/UI tests.** A valid `.cpp` and `.lua` under `Scripts` produce the configured argv with line/column; use a disposable probe executable to record arguments without launching a real editor. A drive/Unicode project path stays one argv element; `../`, symlink escape, directory, `.exe` and nonexistent targets fail with structured `source.*` errors. Clicking a parsed diagnostic issues `faset_source_open` with its location; an external diagnostic has no enabled Open action. Existing `faset_script_open` rejects `.cpp` as before.
+  ```cpp
+  const auto opened = commands.call("faset_source_open",
+      {{"path", "Scripts/Gameplay.cpp"}, {"line", 17}, {"column", 4},
+       {"editor", {path_to_utf8(probe_executable), "{file}:{line}:{column}"}}});
+  require(opened.at("line") == 17 && opened.at("path") == "Scripts/Gameplay.cpp",
+          "Project source opens at the diagnostic position");
+  ```
+- [ ] **Step 2: Run rebuilt red command/UI tests.** Build `faset_editor_session_tests faset_editor_ui_tests`, then run `ctest --test-dir build/linux-debug --no-tests=error --output-on-failure -R '^(editor_session_settings|editor_ui_authoring)$'` with the configured Vulkan ICD. At least the new source-open assertion must fail; a missing GPU or old binary is not the intended red result.
+- [ ] **Step 3: Implement the safe source launcher and Console action.** Use `project_path` and extension/regular-file checks, exact argv substitution with no shell, and Zed's verified `path:line:column` default. Keep raw output expandable, show severity/file/line first, and expose a clear editor-launch error without changing build state. Make rows keyboard reachable and update the English diagnostics Manual.
+  ```cpp
+  commands_.add("faset_source_open", description, source_schema,
+                [&](const Json& args) { return open_project_source(args, /*lua_only=*/false); });
+  // UI: call("faset_source_open", {{"path", row.at("file")},
+  //                                {"line", row.value("line", 1)}});
+  ```
+- [ ] **Step 4: Run focused tests with software Vulkan for UI.** Rebuild `faset_editor_session_tests faset_editor_ui_tests`, then run `ctest --test-dir build/linux-debug --no-tests=error --output-on-failure -R '^(editor_session_settings|editor_ui_authoring)$'` on an equipped GPU/software ICD. Both pass; `faset_job` JSON still exposes raw log and normalized rows headlessly.
+- [ ] **Step 5: Commit** `Navigate from build diagnostics to project source`.
+
+### Task 5: Four runnable C++/Lua new-project choices
+
+**Files:** Modify `include/faset/editor/build_service.hpp`, `src/editor/build_service.cpp`, `include/faset/editor/project_launcher.hpp`, `src/editor/project_launcher.cpp`, `apps/editor_main.cpp`, `tests/build_service_tests.cpp`, `tests/editor_ui_launcher.cpp`; create `tools/project_templates/lua-main.lua`; update `docs/manual/getting-started/build.md`.
+
+**Interfaces:** New overload `BuildService::scaffold(name, dimension, language)` accepts `cpp|lua` and creates a runnable template; the legacy two-argument call retains its existing C++ scaffold behavior without implicitly creating a scene. `ProjectSelection::language` and `faset_editor --new NAME --dimension 2|3 --language cpp|lua` select the same templates. Explicit template creation adds a minimal `Scenes/main.scene.json`; Lua-only templates receive a declared `Scripts/main.lua` without `Gameplay.cpp/.hpp`.
+
+- [ ] **Step 1: Write failing scaffold/launcher tests.** Create all four explicit combinations under disposable Unicode project paths. Assert dimension/language, scene validity, declared Lua schemas, no C++ stub in Lua projects, ability to `--validate` or launch a built Player, and that existing files are never overwritten. Test legacy `scaffold(name, dimension)` still creates C++ without unexpectedly creating a scene.
+  ```cpp
+  builds.scaffold("Lua 2D", 2, "lua");
+  require(fs::exists(root / "Scripts/main.lua") &&
+              !fs::exists(root / "Scripts/Gameplay.cpp"),
+          "Lua starter is genuinely Lua-only");
+  ```
+- [ ] **Step 2: Run rebuilt red tests.** Build `faset_build_service_tests faset_project_launcher_tests`, then run `ctest --test-dir build/linux-debug --no-tests=error --output-on-failure -R '^(process_and_cook|editor_ui_launcher)$'` with the configured Vulkan ICD. Compilation or a new assertion must fail specifically on language selection; old binaries or a missing GPU do not establish red.
+- [ ] **Step 3: Add starter files and cross-platform chooser.** Generate the start scene from authoring schema helpers; use source templates for behavior text and LuaLS defaults; reject an existing conflicting destination before writing any starter file. Maintain the dark Editor style, keyboard selection and platform-native path display. The PNG reference guides layout only. Extend CLI help and Manual with exact commands.
+  ```cpp
+  void BuildService::scaffold(const std::string& name, int dimension,
+                              std::string_view language);
+  // Existing two-argument overload keeps the legacy scaffold without a scene.
+  ```
+- [ ] **Step 4: Run focused and real template builds.** Rebuild `faset_build_service_tests faset_project_launcher_tests faset_player`, then run `ctest --test-dir build/linux-debug --no-tests=error --output-on-failure -R '^(process_and_cook|editor_ui_launcher|lua_cli_contracts)$'` with the configured Vulkan ICD. All three pass; build/validate one generated C++ and one generated Lua project for each dimension.
+- [ ] **Step 5: Commit** `Offer runnable C++ and Lua project starters`.
+
+### Task 6: Revision-aware autosave controller and MCP status
+
+**Files:** Create `include/faset/editor/autosave.hpp`, `src/editor/autosave.cpp`, `tests/editor_autosave_tests.cpp`; modify `CMakeLists.txt`, `include/faset/authoring/service.hpp`, `src/authoring/service.cpp`, `src/editor/commands.cpp`, `include/faset/editor/session.hpp`, `src/editor/session.cpp`.
+
+**Interfaces:** `AuthoringService::save(document, path={}, expected_revision=std::nullopt)` rejects a stale expected revision. `AutosaveController` takes `SaveFn = std::function<Json(const std::string&, std::uint64_t)>` in its constructor; `observe(documents, now, enabled)` tracks each document's revision/idle deadline and invokes that callback after 2 seconds. `Session::poll()` calls it in both GUI and long-lived MCP modes. Read-only `faset_autosave_status` returns per-document `state`, `revision`, `path`, `error` and enabled flag.
+
+- [ ] **Step 1: Write failing fake-clock and authoring tests.** Coalesce three edits within 2 seconds into one save; unnamed dirty scene stays in recovery; disabling autosave leaves only recovery; an external disk edit fails with `save.disk_conflict`; a newer revision fails with `revision.conflict` then gets a new deadline; a permission/write error remains visible without frame-by-frame retries; Undo after save still restores the prior scene; a Play snapshot captured before autosave remains byte-identical. Register `faset_editor_autosave_tests` and CTest name `editor_autosave` in `CMakeLists.txt`.
+  ```cpp
+  service.transact(id, revision, rename_ops);
+  controller.observe(service.documents(), start + 1900ms, true);
+  require(read_json(scene_path).at("name") == "Before", "Idle timer has not fired");
+  controller.observe(service.documents(), start + 2100ms, true);
+  require(read_json(scene_path).at("name") == "After", "Named scene autosaved once");
+  ```
+- [ ] **Step 2: Build the red autosave test.** Run `cmake --preset linux-debug`, then `cmake --build --preset linux-debug --target faset_editor_autosave_tests --parallel 4`. Compilation must fail on the missing controller/revision-aware save API, not an unknown target.
+- [ ] **Step 3: Implement deterministic scheduling and status.** Use monotonic time injected into the controller, reset deadline only when revision changes, save with expected revision, suppress identical failure repeats until another edit or explicit retry, and never assign a path to an unnamed scene. Keep recovery journaling and disk-hash guard unchanged. Add `expected_revision` as an optional JSON field to `faset_document_save`; preserve existing callers.
+  ```cpp
+  if (summary.at("dirty") && !summary.at("path").get<std::string>().empty() &&
+      now >= state.deadline)
+      authoring.save(id, {}, state.observed_revision);
+  ```
+- [ ] **Step 4: Run authoring/session/MCP tests.** Rebuild `faset_authoring_tests faset_editor_autosave_tests faset_editor_session_tests faset_mcp_tests faset_editor`, then run `ctest --test-dir build/linux-debug --no-tests=error --output-on-failure -R '^(authoring|editor_autosave|editor_session_settings|editor_mcp|editor_mcp_stdio)$'`. All five pass; a headless MCP session that stays open autosaves a named scene after idle.
+- [ ] **Step 5: Commit** `Autosave named scenes with revision and disk conflict safety`.
+
+### Task 7: Autosave settings and visible Editor state
+
+**Files:** Modify `src/editor/session.cpp`, `src/editor/editor_ui.cpp`, `tests/editor_session_tests.cpp`, `tests/editor_ui_project_settings.cpp`, `tests/editor_ui_tests.cpp`, `docs/manual/editor/workspace.md`, `docs/manual/editor/mcp.md`.
+
+**Interfaces:** `project.faset.json` may contain `editor.autosave: bool`, defaulting to `true`; `faset_project_settings_set` updates that property with its existing project revision check, applies it immediately to the current session and preserves `editor.script_editor`. Project settings provide an Autosave toggle. Status bar maps `faset_autosave_status` to Saved, Pending autosave, Saving, Save conflict, Save failed and Save As required. `Session` caches the setting and updates it on the command rather than rereading the project file every polling frame.
+
+- [ ] **Step 1: Write failing settings/UI tests.** Missing setting reads as enabled; toggling off/on survives project reopen and does not change `editor.script_editor`; stale settings revision is rejected; UI shows pending then saved after a deterministic tick, conflict persists with Save As/reload guidance, unnamed dirty scene shows Save As required. Keyboard focus reaches the toggle and conflict action.
+  ```cpp
+  auto settings = commands.call("faset_project_settings_get", Json::object());
+  auto changed = commands.call("faset_project_settings_set",
+      {{"revision", settings.at("revision")},
+       {"settings", {{"editor", {{"autosave", false}}}}}});
+  require(changed.at("settings").at("editor").at("autosave") == false,
+          "Project autosave preference persists");
+  ```
+- [ ] **Step 2: Run rebuilt red tests.** Build `faset_editor_session_tests faset_editor_project_settings_ui_tests faset_editor_ui_tests`, then run `ctest --test-dir build/linux-debug --no-tests=error --output-on-failure -R '^(editor_session_settings|editor_ui_project_settings|editor_ui_authoring)$'` with the configured Vulkan ICD. At least the new settings/status assertion must fail for the expected behavior.
+- [ ] **Step 3: Implement settings validation and UI.** Merge only the `editor.autosave` field into existing `editor` settings; reject non-Boolean values. Poll the read-only status instead of inferring save from dirty flags. Keep the dark compact reference style while making actual status and actions correct; document autosave vs recovery and MCP explicit save.
+  ```cpp
+  require(changes["editor"]["autosave"].is_boolean(), "project.autosave",
+          "Autosave must be enabled or disabled");
+  value["editor"]["autosave"] = changes["editor"]["autosave"];
+  ```
+- [ ] **Step 4: Run UI and Manual checks.** Rebuild `faset_editor_session_tests faset_editor_project_settings_ui_tests faset_editor_ui_tests`, then run `ctest --test-dir build/linux-debug --no-tests=error --output-on-failure -R '^(editor_session_settings|editor_ui_project_settings|editor_ui_authoring)$'` with the configured Vulkan ICD; all three pass. `python3 -m mkdocs build --strict` from the documentation virtual environment passes. Capture one Editor screenshot to inspect legibility; the image reference is not a pixel-perfect target.
+- [ ] **Step 5: Commit** `Show and configure safe Editor autosave`.
+
+### Task 8: Windows and Release Lua execution evidence
+
+**Files:** Create `tools/verify_lua_release_export.py`, `tests/verify_lua_release_export_test.py`; modify `.github/workflows/ci.yml`, `.github/workflows/windows-graphics.yml`; update `docs/validation/lua-module.md` after results exist. `lua_player_reload` is already registered in `cmake/Player.cmake`.
+
+**Interfaces:** The verifier copies `examples/lua` to a disposable Unicode project path, exports a Release Lua-only package with the real Editor, relocates the generation, hides the source project, runs `--validate` and 120 headless rendered frames, and writes a JSON report containing exact revision/build profile/VM presence/source hashes/device/driver/capture hash. It never modifies the checked-in sample.
+
+- [ ] **Step 1: Write failing verifier contract tests.** In `tests/verify_lua_release_export_test.py`, import the verifier's package/report validator and test that it rejects a package containing project `Gameplay.cpp`, a missing declared Lua source, a package that only works with the source project present, or fewer than 120 rendered frames. Its report must distinguish physical GPU and software Vulkan.
+  ```python
+  assert report["configuration"] == "Release"
+  assert report["lua_enabled"] is True
+  assert report["relocated"] is True
+  assert report["rendered_frames"] == 120
+  ```
+- [ ] **Step 2: Run and implement the verifier.** Run `python3 -m unittest discover -s tests -p 'verify_lua_release_export_test.py' -v`; confirm it discovers at least four tests and fails on the absent verifier API. Implement the disposable-project export/relocation/validation/frame runner and report validator in `tools/verify_lua_release_export.py`, then rerun the same test until it passes. Run the verifier on Linux with the real Release Editor and record its exact output. A deliberately incomplete disposable package must still be rejected.
+  ```sh
+  python3 tools/verify_lua_release_export.py --editor build/linux-release/faset_editor --output .cache/p1-lua-release-check
+  ```
+- [ ] **Step 3: Run actual platform jobs.** Linux native CI runs existing Lua CPU tests; Windows native CI runs them without a GPU. Windows graphics CI runs `lua_player_reload` under its pinned SwiftShader ICD and the Release export verifier. Run the same verifier on Linux with a real GPU when available; exact commands and environment go in the report. A failed CI job is not described as covered. Keep `FASET_ENABLE_LUA=OFF` for C++-only projects, preserve Lua source snapshot hashing, and package required notices; any observed integration defect gets a failing regression before its fix.
+  ```sh
+  ctest --test-dir build/linux-release --no-tests=error --output-on-failure -R '^(lua_contracts|lua_safety_contracts|lua_cli_contracts|lua_player_reload|build_schema_publication)$'
+  ```
+- [ ] **Step 4: Store exact evidence and update the Lua record.** Include CI run links, `ctest` totals, report JSON, renderer/driver details and honest unsupported-hardware notes. A functional Windows SwiftShader result is not a physical-Windows-GPU claim.
+- [ ] **Step 5: Commit** `Validate Lua gameplay in Windows and Release exports`.
+
+### Task 9: Measure iteration and close P1 documentation
+
+**Files:** Modify `tools/measure_workflows.py`, `docs/manual/editor/export.md`, `docs/manual/editor/profiling.md`, `docs/manual/scripting/lua.md`, `docs/manual/scripting/first-behavior.md`, `docs/ARCHITECTURE.md`, `docs/IMPLEMENTATION.md`, `PLAN.md`; create `tests/measure_workflows_test.py`, `docs/validation/p1-iteration-2026-09-24/README.md` and raw evidence files.
+
+**Interfaces:** Workflow report version 2 retains raw samples with labels and adds median/nearest-rank p95, exact host/toolchain/driver/revision/source-hash metadata, separate cold and warm paths, changed C++ and Lua-to-reload time, Play-to-first-rendered-frame, synthetic Editor input-to-visible-state latency, and a larger generated scene. Timing values are observations, not CI pass/fail thresholds.
+
+- [ ] **Step 1: Write failing report/math tests.** With sample durations `[1, 2, 3, 4, 5]`, median is 3 and nearest-rank p95 is 5; the report rejects an absent revision, mixed Debug/Release samples under one label, missing source hashes, and a sample labeled windowed first frame when the Player profile says `presentation_mode=offscreen`. Fixture generation must be deterministic from a seed.
+  ```python
+  assert summarize([1, 2, 3, 4, 5]) == {"median": 3, "p95": 5}
+  assert len(report["samples"]["warm_unchanged_build"]) >= 5
+  ```
+- [ ] **Step 2: Run the red Python test.** `python3 -m unittest discover -s tests -p 'measure_workflows_test.py' -v` discovers at least four tests and fails on the missing summary/report behavior before implementation; a zero-test run does not count.
+- [ ] **Step 3: Extend the disposable-project workflow and Manual.** Keep raw stdout/stderr and per-run JSON, warm up then repeat each warm/changed case at least five times, record toolchain/GPU/driver and validation/readback settings, and compare reference budgets only for the exact checked-in sample scenes. Measure a 3,000-frame resource-lifecycle run and report explicit memory growth. Document C++/Lua iteration, cache flags, source navigation, templates, autosave/conflict recovery and profile interpretation in English.
+  ```python
+  def summarize(values):
+      ordered = sorted(values)
+      return {"median": statistics.median(ordered),
+              "p95": ordered[math.ceil(0.95 * len(ordered)) - 1]}
+  ```
+- [ ] **Step 4: Run full validation and record dated evidence.** `ctest --preset linux-debug --no-tests=error --output-on-failure`, `ctest --test-dir build/linux-release --no-tests=error --output-on-failure`, available Linux GPU tests, Windows native/SwiftShader CI, `python3 -m mkdocs build --strict` from the documentation virtual environment and the workflow script pass or have exact documented failures. Update `PLAN.md` to P1 complete only after every acceptance-matrix row in the spec has evidence; physical Windows GPU remains marked unverified if unavailable. Run `graphify update .` after code changes where `graphify-out/graph.json` exists, then request independent review and fix load-bearing findings.
+- [ ] **Step 5: Commit** `Measure and document P1 gameplay iteration`; publish only after required checks and review are complete.

docs/superpowers/plans/2026-09-24-p3-lighting.md

@@ -0,0 +1,213 @@
+# P3 Lighting and Shadows Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Deliver PLAN P3's multi-light shading, four-cascade sun shadows, bounded point/spot shadow atlas, independent shadow-view visibility, explicit budgets and diagnostics, and a measured Forward+ decision.
+
+**Architecture:** An immutable `Snapshot` carries one sun, local lights, and an unjittered camera frustum from scene extraction. Both Direct and P2 GPU graphics paths use the existing material set 0 and shared `fragmentMain`, a new lighting set 1, and, only for P2 GPU vertices, scene set 2. CPU shadow planning produces atomic sun/spot/point views and caster lists; Vulkan renders those views into two bounded D32 atlases before forward shading. Temporal reconstruction has a separate plan.
+
+**Tech Stack:** C++20, Vulkan 1.3 dynamic rendering, Slang/SPIR-V and Faset reflection v1, CMake/Ninja, SDL3, Catch-style existing C++ test executables, Python measurement scripts, MkDocs Material.
+
+**Spec:** `docs/superpowers/specs/2026-09-24-p3-lighting-design.md`
+
+## Global Constraints
+
+- Linux and Windows desktop 3D; exported Player remains independent of Slang, Editor, and MCP.
+- Preserve selectable Direct, GPU frustum, and GPU occlusion paths and their equivalent opaque lighting.
+- Preserve material descriptor set 0 bindings 0–3; add lighting set 1; move GPU graphics scene bindings to set 2; leave GPU compute sets unchanged.
+- Preserve 96-byte baseline and 112-byte GPU graphics push constants; no optional Vulkan feature may be assumed without a capability check.
+- Sun atlas: four 1024² tiles in 2048² D32; local atlas: sixteen 512² tiles in 2048² D32; fallback to half resolution or explicitly unshadowed lighting.
+- At most 128 submitted local lights, sixteen local shadow faces, and 4096 caster draws per frame. Overflow is deterministic and visible; a skipped view is entirely unshadowed.
+- Shadow caster selection is independent of camera/P2 culling and camera-selected mesh LOD. No incomplete point-light cubemap.
+- Sun shadows use unjittered camera data; lighting work must not mutate velocity/TAA history owned by the temporal plan.
+- Register each new CTest case before its red run; verify it appears in `ctest --test-dir build/linux-debug -N`, use `--no-tests=error` with exact `-R` names, and treat an absent build target as a failed setup rather than a passing test.
+
+## Review Focus
+
+- A distant, offscreen caster overlapping a visible receiver's sun cascade must still cast a shadow; Task 3's CPU test and Task 4's GPU fixture pin this.
+- A point light with fewer than six free atlas tiles must be fully unshadowed, never show partial faces; Task 3's scheduler test and Task 5's image case pin this.
+- A view exceeding the caster draw budget must not render only some casters; Task 3's budget test and Task 5's overflow image pin this.
+- A material with no local lights, including UI/sprite pixels, must not read an uninitialized storage descriptor or change tint; Tasks 2 and 4 pin this.
+- Shader hot reload with a changed light-buffer stride/binding must reject the candidate and retain the displayed frame; Task 2 pins this.
+
+---
+
+## File map and integration order
+
+`include/faset/render/renderer.hpp` owns public light/camera snapshot fields and statistics. New `include/faset/render/lighting.hpp` and `src/render/lighting.cpp` own pure CPU split, shadow-view, tile-allocation, caster-culling, and budget policy, independently testable without Vulkan. `src/player/SceneView.cpp` and `src/authoring/schema.cpp` translate version-1 authoring fields into those typed records. `shaders/baseline.slang`, `shaders/gpu_scene.slang`, `src/render/shader_contract.cpp`, and `src/render/renderer.cpp` own the exact graphics ABI and Vulkan implementation. `src/editor/debug_overlay.cpp`, Player diagnostics, the Manual, and validation studies consume statistics after rendering.
+
+Tasks 1–3 define the shared interfaces. Integrate Task 2's descriptor ABI before concurrent temporal shader changes; Tasks 4–5 then implement Vulkan shadow rendering. The temporal plan may proceed independently in its own files, but `renderer.hpp`, `renderer.cpp`, and `baseline.slang` changes must be sequenced or reconciled with a focused Direct/P2/temporal regression pass. Make a checkpoint commit after every green task; do not mark P3 complete until the acceptance record exists.
+
+### Task 1: Authoring schema and typed light extraction
+
+**Files:** Modify `include/faset/render/renderer.hpp`, `src/authoring/schema.cpp`, `src/player/SceneView.cpp`, `tests/authoring_tests.cpp`, `tests/runtime_player_tests.cpp`, and relevant Manual authoring examples.
+
+**Interfaces:** Introduce `SunLight { stable_id, direction, color, intensity, casts_shadow }`, `LocalLight { Kind::Point|Spot, stable_id, position, direction, color, intensity, range, inner_angle, outer_angle, casts_shadow, shadow_priority }`, and `CameraFrustum { view, projection, near_plane, far_plane, perspective }`. Add `std::optional<SunLight> Snapshot::sun`, `std::vector<LocalLight> Snapshot::local_lights`, and `std::optional<CameraFrustum> Snapshot::camera_frustum` after existing aggregate fields; retain `Snapshot::light_direction`. `SceneView::build` fills camera data for 3D scenes and picks the first enabled directional by stable ID.
+
+- [ ] **Step 1: Write failing schema/extraction tests.** Construct a version-1 scene with directional, point, and spot entities in one order and reversed order. Assert all local IDs/properties agree; authored sun color/intensity are preserved; no-light scene retains the default legacy sun; extra directionals emit a diagnostic; invalid `range <= 0`, `inner_angle > outer_angle`, nonfinite color/transform, and unknown kind identify the entity/field. An essential assertion is:
+  ```cpp
+  auto a = view.build(scene_with_three_lights(), 16.f / 9.f);
+  auto b = view.build(reordered_scene_with_three_lights(), 16.f / 9.f);
+  check(a.local_lights.size() == 2 && b.local_lights.size() == 2,
+        "Point and spot lights survive scene extraction");
+  check(a.local_lights[0].stable_id == b.local_lights[0].stable_id,
+        "Light ordering follows stable IDs, not entity array order");
+  ```
+- [ ] **Step 2: Run the focused tests red.** Run `cmake --preset linux-debug` and `cmake --build --preset linux-debug --target faset_authoring_tests faset_player_tests --parallel 4`; missing typed fields should fail compilation. If compilation succeeds, `ctest --test-dir build/linux-debug --output-on-failure --no-tests=error -R '^(authoring|player_scene_contracts)$'` must fail on a new behavioral assertion. Record the expected failure rather than assuming the build itself must be red.
+- [ ] **Step 3: Add schema defaults and extraction.** Keep builtin version 1; use `fields.value` for additive fields, normalize directions after the world transform, validate finite/color/range/cone values, sort by stable ID, and preserve the legacy fallback. Set `camera_frustum` from the same unjittered view/projection used to form `view_projection`. Update direct C++ API examples to construct one point and one spot light.
+  ```cpp
+  struct CameraFrustum {
+      Mat4 view{identity}, projection{identity};
+      float near_plane{0.1f}, far_plane{1000.f};
+      bool perspective{true};
+  };
+  // Snapshot::light_direction remains available to callers without Snapshot::sun.
+  ```
+- [ ] **Step 4: Run focused tests green.** `ctest --test-dir build/linux-debug --output-on-failure -R '^(authoring|player_scene_contracts)$'` passes, including old version-1 scenes and exported-scene decoding.
+- [ ] **Step 5: Commit** `Expose authored sun, point, and spot lights in render snapshots`.
+
+### Task 2: Shared lighting shader ABI and unshadowed local PBR
+
+**Files:** Modify `shaders/baseline.slang`, `shaders/gpu_scene.slang`, `src/render/shader_contract.cpp`, `src/render/renderer.cpp`, `include/faset/render/renderer.hpp`, `tests/test_shader_reflection.py`, `tests/render_gpu_shader_contract_tests.cpp`, `tests/render_reload_tests.cpp`, `tests/render_tests.cpp`, `cmake/Renderer.cmake` if a new CPU-only ABI target is useful.
+
+**Interfaces:** Keep set 0 bindings 0–3 and `Push`/`ScenePush` sizes. Define set 1 bindings 0=`StructuredBuffer<LightingHeader>` (one record), 1=`StructuredBuffer<LocalLightGpu>` (minimum one allocated record even when count zero), 2=`StructuredBuffer<ShadowViewGpu>` (minimum one record), 3=`Texture2D<float>` local atlas. `LightingHeader` is five 16-byte lanes (counts/flags, sun direction+intensity, sun color, camera forward+shadow distance, four split depths); `LocalLightGpu` is five 16-byte lanes (position+range, direction+cosOuter, color+intensity, cone/type/shadow-view indices, reserved); `ShadowViewGpu` is seven 16-byte lanes (matrix, tile scale/offset, guarded clamp, bias/flags). GPU vertex buffers move to set 2 bindings 0–2. Put host mirrors in `src/render/renderer.cpp` with exact `static_assert` size/offsets and validate Slang element strides in reflection. These 80/80/112-byte records are renderer ABI, not scene-file schema.
+
+- [ ] **Step 1: Write failing ABI and image tests.** Extend the existing registered `render_shader_reflection`, `render_gpu_shader_contract`, `render_shader_reload`, and `render_offscreen` cases; do not rely on an unregistered new test. Assert exact set/binding/type/stride for baseline fragment and GPU vertex entries; corrupt a lighting stride or GPU set number in a copied reflection file and require validation rejection. Render a zero-local-light scene with unchanged sprite/UI tint; place red and blue point lights at different ranges and assert the correct receiver regions brighten without NaNs. Run in Direct and GPU frustum modes.
+  ```python
+  fragment = json.loads((shader_dir / "fragmentMain.reflection.json").read_text())
+  gpu_vertex = json.loads((shader_dir / "gpuVertexMain.reflection.json").read_text())
+  assert next(d for d in fragment["layout"]["descriptors"]
+              if (d["set"], d["binding"]) == (1, 1))["element_stride"] == 80
+  assert next(d for d in gpu_vertex["layout"]["descriptors"]
+              if (d["set"], d["binding"]) == (2, 0))["element_stride"] == 224
+  ```
+- [ ] **Step 2: Run focused tests red.** Reconfigure and build the modified test targets, then run `ctest --test-dir build/linux-debug --output-on-failure --no-tests=error -R '^(render_shader_reflection|render_gpu_shader_contract|render_shader_reload|render_offscreen)$'`. The new ABI assertion or the point/spot fixture inside `render_offscreen` must reject missing set 1/2 behavior. Confirm all four expected cases in `ctest --test-dir build/linux-debug -N`.
+- [ ] **Step 3: Implement the checked ABI and shading.** Allocate/bind one frame lighting set in Direct and GPU graphics pipelines; update shader contracts and P2 graphics set indices only. Accumulate each direct-light BRDF in linear RGB before tone mapping; keep the zero-normal UI/sprite early return. Use finite-safe inverse-square-like distance attenuation with smooth range cutoff and a smooth spot cone. Keep sun/default image reference close to the old baseline. Reject incompatible runtime shader reload while preserving previous pipelines.
+  ```slang
+  [[vk::binding(0,1)]] StructuredBuffer<LightingHeader> lightingFrame;
+  [[vk::binding(1,1)]] StructuredBuffer<LocalLightGpu> localLights;
+  [[vk::binding(2,1)]] StructuredBuffer<ShadowViewGpu> shadowViews;
+  [[vk::binding(3,1)]] Texture2D<float> localShadowAtlas;
+  // GPU scene vertex descriptors change from binding(*,1) to binding(*,2).
+  ```
+- [ ] **Step 4: Rebuild shaders and run reflection, reload, offscreen, and Direct/P2 image tests green.** `cmake --build --preset linux-debug --target faset_shaders faset_render_tests faset_render_gpu_shader_contract_tests faset_render_reload_tests --parallel 4`; then the focused `ctest` regex above and `ctest --test-dir build/linux-debug -L p2 --output-on-failure`. Check zero Vulkan validation errors.
+- [ ] **Step 5: Commit** `Share typed multi-light shading across Direct and GPU paths`.
+
+### Task 3: Pure CPU shadow planning, caster visibility, and capacity policy
+
+**Files:** Create `include/faset/render/lighting.hpp`, `src/render/lighting.cpp`, `tests/render_lighting_policy_tests.cpp`; modify `cmake/Renderer.cmake` and `src/render/renderer.cpp` only to call the policy after it is tested.
+
+**Interfaces:** `build_shadow_plan(const Snapshot&, std::span<const ShadowCasterBounds>, ShadowBudget) -> ShadowPlan` returns ordered `ShadowView` records (sun cascade 0–3, spot one, point six), stable tile indices, caster indices, per-view update reason, requested/effective counts, and dropped-reason counters. `ShadowBudget` defaults to four sun views, sixteen local tiles, 4096 caster draws, 128 local lights, and 2048² atlas dimensions. `ShadowCasterBounds` contains source-mesh world AABB and draw index. No Vulkan handle enters this module.
+
+- [ ] **Step 1: Write and register failing policy tests.** Add `faset_render_lighting_policy_tests` and `add_test(NAME render_lighting_policy ...)` in `cmake/Renderer.cmake`. Assert practical split endpoints are increasing and end at `min(far,80)`; translating a camera by less than one cascade texel keeps the snapped projection origin fixed; a caster outside camera view but upstream of a receiver is included; a caster outside the shadow XY footprint is excluded. Fill 15 local tiles, then request one point light and assert no faces are scheduled while the light remains in the submitted lighting list with shadow validity false. Give a shadow view 4097 casters and assert it is skipped whole. Reverse input light order and assert allocations are unchanged.
+  ```cpp
+  auto plan = build_shadow_plan(snapshot, casters, ShadowBudget{});
+  require(plan.sun_views.size() == 4, "Explicit camera gets four cascades");
+  require(plan.local_faces_used <= 16 && plan.caster_draws <= 4096,
+          "Shadow work stays within the configured budget");
+  require(plan.dropped_point_faces == 6 || plan.dropped_point_faces == 0,
+          "Point shadow allocation is all-or-none");
+  ```
+- [ ] **Step 2: Run policy test red.** Reconfigure, verify `render_lighting_policy` appears in `ctest --test-dir build/linux-debug -N`, build `faset_render_lighting_policy_tests`, then run `ctest --test-dir build/linux-debug --output-on-failure --no-tests=error -R '^render_lighting_policy$'` if compilation succeeds. Expected failure is the absent `lighting.hpp` interface or the first failing new assertion.
+- [ ] **Step 3: Implement the planner.** Use unjittered frustum corners and fixed λ=0.5 splits, enclosing-sphere square extents, two-texel guard, texel-snapped light XY, and conservative caster-derived light Z. Sort by explicit priority, projected influence, and stable ID. Choose entire views under tile/draw limits; never reuse an old tile if its owner/generation changes. Legacy Snapshot without `CameraFrustum` produces one reported sun view. If no atlas profile is usable, return an unshadowed plan with a reason.
+  ```cpp
+  ShadowPlan build_shadow_plan(const Snapshot& frame,
+                              std::span<const ShadowCasterBounds> casters,
+                              const ShadowBudget& budget);
+  ```
+- [ ] **Step 4: Run focused policy and P2 visibility tests green.** `ctest --test-dir build/linux-debug --output-on-failure -R 'render_lighting_policy|visibility_policy|render_gpu_shadow'`. Preserve P2's offscreen caster fixture.
+- [ ] **Step 5: Commit** `Plan stable cascades and bounded shadow views independently of camera culling`.
+
+### Task 4: Vulkan sun atlas and cascade sampling
+
+**Files:** Modify `src/render/renderer.cpp`, `shaders/baseline.slang`, `tests/render_tests.cpp`, `tests/render_gpu_acceptance_tests.cpp`; create `tests/render_lighting_gpu_tests.cpp` and register `render_lighting_sun` as `gpu;p3` in `cmake/Renderer.cmake` or a focused `cmake/LightingAcceptance.cmake`.
+
+**Interfaces:** `ShadowPlan::sun_views` supplies four 1024² tile viewports and matrices to one `ShadowAtlases` RenderGraph pass. `LightingHeader` and `ShadowViewGpu` provide split depths, tile transforms, and valid flags to `fragmentMain`; set 0 binding 0 points to the sun atlas. `FrameStats` reports requested/effective cascade count, sun tiles, caster draws, atlas bytes, and aggregated `gpu_sun_shadow_ms`.
+
+- [ ] **Step 1: Write and register failing sun image tests.** Register `render_lighting_sun` with `LABELS "gpu;p3"` in CMake before its red run. Make a receiver cross the first two split distances; require shadow continuity across the blend band. Move the camera by subtexel and whole-texel steps; require stable then updated shadow edges. Move/disable an upstream offscreen caster and require affected receiver pixels to change. Assert four effective cascades for explicit camera and one reported fallback for a legacy low-level Snapshot. Run Direct and GPU frustum; compare the final frames within the existing P2 image tolerance.
+  ```cpp
+  require(renderer.stats().effective_sun_cascades == 4,
+          "Explicit 3D camera uses four sun cascades");
+  std::size_t darker = 0;
+  for (std::size_t i = 0; i < with_caster.size(); i += 4)
+      darker += without_caster[i] > with_caster[i] + 12;
+  require(darker > 20, "Offscreen caster affects a visible cascade receiver");
+  ```
+- [ ] **Step 2: Run new GPU test red.** Reconfigure, verify `render_lighting_sun` appears in `ctest --test-dir build/linux-debug -N`, and build its test executable. Run `ctest --test-dir build/linux-debug --output-on-failure --no-tests=error -R '^render_lighting_sun$'`; an old single fixed shadow projection must fail the new count/image assertions. A missing target is setup failure, not green.
+- [ ] **Step 3: Render and sample the sun atlas.** Check D32 sampled/depth-attachment format support and image limits; allocate 2048² or 1024² fallback. Transition to depth attachment once, loop tile rendering with per-tile `renderArea`, clear, viewport and scissor, push each matrix, draw only that view's caster list; transition once to depth read-only. Map projected XY into guarded tile UV, clamp every PCF tap, apply slope-aware bias, choose/blend cascades from unjittered depth. When recreating the atlas, rewrite set-0 binding 0 for every live material descriptor before retiring the old image view. Increase the fixed timestamp query capacity before adding pass labels so aggregate timing does not silently disappear.
+  ```cpp
+  graph.add("ShadowAtlases", {}, {"sun_shadow", "local_shadow"}, [&] {
+      // For each scheduled view: clear only its renderArea, set tile viewport/scissor,
+      // push its view_projection, draw exactly plan.caster_indices.
+  });
+  ```
+- [ ] **Step 4: Run sun, existing shadow, reload, P2, and Vulkan validation tests green.** `ctest --test-dir build/linux-debug --output-on-failure -R 'render_lighting_sun|render_offscreen|render_shader_reload|render_gpu_shadow'` and the full `-L p2` suite. Save difference frames before adjusting any threshold.
+- [ ] **Step 5: Commit** `Render stable cascaded sun shadows into a bounded atlas`.
+
+### Task 5: Point/spot atlas, face scheduling, and observability
+
+**Files:** Modify `src/render/renderer.cpp`, `shaders/baseline.slang`, `src/editor/debug_overlay.cpp`, Player profile/diagnostics source, `include/faset/render/renderer.hpp`, `tests/render_lighting_gpu_tests.cpp`, `tests/editor_debug_overlay.cpp`, `tests/player_diagnostics_test.py`, and acceptance CMake registration.
+
+**Interfaces:** `ShadowPlan::local_views` supplies one spot or six point faces per assigned light. The shader resolves a point face from the dominant light-to-fragment axis and samples only a valid assigned tile. `FrameStats`/Player/editor expose submitted and omitted local lights, requested and effective faces, tile occupancy, dropped-reason counts, caster draws, atlas bytes, shadow GPU time, and actual lighting path. The common fallback is unshadowed local lighting.
+
+- [ ] **Step 1: Write and register failing image/diagnostic tests.** Register `render_lighting_local` with `LABELS "gpu;p3"`; extend existing Player diagnostics assertions. A spotlight lights inside its outer cone but not outside; a point light lights six cube-face directions and has no seam-caused bright leak at a face boundary. A caster darkens a nearby receiver; disabling its `casts_shadow` restores light. Fill all local tiles and verify the overflow light still contributes unshadowed. Exercise 15 occupied tiles plus one point; assert six faces are dropped and no stale tile is sampled. Verify editor/Player labels use actual effective counts and explicit reasons.
+  ```cpp
+  require(stats.local_shadow_faces <= 16 && stats.shadow_caster_draws <= 4096,
+          "Rendered local shadow work obeys both budgets");
+  require(stats.dropped_shadow_faces == 6,
+          "Insufficient atlas room disables a whole point shadow");
+  require(over_capacity_point_pixels[receiver_pixel] > no_point_pixels[receiver_pixel] + 12,
+          "Unshadowed point light still illuminates its receiver");
+  ```
+- [ ] **Step 2: Run the registered GPU and Player cases red.** Reconfigure and verify `render_lighting_local` appears in `ctest --test-dir build/linux-debug -N`; build the test executable and run `ctest --test-dir build/linux-debug --output-on-failure --no-tests=error -R '^(render_lighting_local|player_shutdown_diagnostics)$'`. For the optional overlay, which is absent from the default `linux-debug` preset, configure `cmake -S . -B build/p3-debug-overlay -G Ninja -DFASET_DEBUG_IMGUI=ON -DBUILD_TESTING=ON -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++`, build `faset_debug_overlay_tests`, verify it appears in that build's `ctest -N`, then run `ctest --test-dir build/p3-debug-overlay --output-on-failure --no-tests=error -R '^editor_debug_overlay$'`. Red must come from the new assertions, not from an absent optional target.
+- [ ] **Step 3: Render local faces and sample them.** Allocate/clear local atlas tiles as in Task 4; assign six 90° views atomically for point lights and one cone view for spots. Bind the local atlas at set 1 binding 3. Apply per-tile PCF guard/clamp and correct face projection; skip sampling on `valid=false`. Report fallback when optional sampled D32 or atlas allocation is unavailable. Record conservative redraw reasons rather than claiming cached depth without invalidation proof.
+  ```slang
+  if (light.shadowFaceCount == 6 && light.shadowValid != 0)
+      visibility = samplePointAtlas(light, worldPosition, normal);
+  // An unassigned light always uses visibility = 1, but still illuminates.
+  ```
+- [ ] **Step 4: Run local image and diagnostics tests under Khronos validation.** `ctest --test-dir build/linux-debug --output-on-failure --no-tests=error -R '^(render_lighting_local|player_shutdown_diagnostics|render_shader_reload)$'`; `ctest --test-dir build/p3-debug-overlay --output-on-failure --no-tests=error -R '^editor_debug_overlay$'`; then `ctest --test-dir build/linux-debug -L p3 --no-tests=error --output-on-failure`. Run the point-face seam fixture on Linux physical GPU and pinned SwiftShader.
+- [ ] **Step 5: Commit** `Add bounded point and spot shadows with explicit fallback diagnostics`.
+
+### Task 6: Release measurement and conditional Forward+
+
+**Files:** Create `examples/renderer/p3_lighting_benchmark.cpp`, `tools/benchmark_p3_lighting.py`, `tests/test_p3_lighting_benchmark.py`, raw CSV under `docs/studies/data/`, and `docs/studies/22-p3-lighting-benchmark-2026-09-24.md`; modify `cmake/Renderer.cmake` and, only if the gate triggers, `shaders/gpu_scene.slang` or a focused new Slang file, `src/render/renderer.cpp`, `src/render/shader_contract.cpp`, `src/editor/build_service.cpp`, shader/package tests, and `tests/render_lighting_gpu_tests.cpp`.
+
+**Interfaces:** Benchmark `--lights 0|4|16|32|64|128 --shadows on|off --visibility direct|gpu-frustum|gpu-occlusion --csv PATH` at 1920×1080, fixed scene/camera, ten warm-up and thirty measured frames, three independent runs. The Python wrapper has `--list-runs` for a fast configuration-contract test and `--sweep` for the full offline measurement; the registered CTest schema smoke invokes one 64×64, one-frame benchmark, not the full sweep. CSV includes commit, device/driver, mode, light count, GPU forward/shadow/total milliseconds, CPU render/readback milliseconds, atlas use, draw counts, validation errors. If the spec threshold triggers, tiled Forward+ uses 16×16 screen tiles with an overflow flag; an overflowing tile evaluates all submitted lights.
+
+- [ ] **Step 1: Write and register benchmark/overflow contract checks.** Register `render_lighting_benchmark_schema` in CMake to run `tests/test_p3_lighting_benchmark.py` against the benchmark executable. Use `--list-runs` to verify the 0/4/16/32/64/128 sweep yields 18 mode×light configurations and 54 independent runs per shadow setting; use one 64×64 frame to verify every CSV row includes the effective lighting path. If tiled mode is needed, write an image case with more than the per-tile index capacity and compare against the full-light reference to ensure no missing illumination.
+  ```cpp
+  double absolute_error = 0;
+  std::size_t large_error = 0;
+  for (std::size_t i = 0; i < tiled_pixels.size(); i += 4)
+      for (std::size_t channel = 0; channel < 3; ++channel) {
+          const auto delta = std::abs(int(tiled_pixels[i + channel]) -
+                                      int(full_scan_pixels[i + channel]));
+          absolute_error += delta;
+          large_error += delta > 16;
+      }
+  const double samples = 3.0 * (tiled_pixels.size() / 4);
+  require(absolute_error / samples <= 2.0 && large_error / samples <= 0.005,
+          "Forward+ overflow scans all local lights instead of dropping any");
+  ```
+- [ ] **Step 2: Run the new checks red.** Reconfigure; verify `render_lighting_benchmark_schema` appears in `ctest --test-dir build/linux-debug -N`; build `faset_p3_lighting_benchmark` and run `ctest --test-dir build/linux-debug --output-on-failure --no-tests=error -R '^render_lighting_benchmark_schema$'`. Expected failure is a missing benchmark interface/output or effective-path CSV column, never an empty CTest selection.
+- [ ] **Step 3: Implement and run the fixed-scene benchmark.** Record Linux Release physical GPU and pinned SwiftShader functional runs separately. Do not use whole-render CPU time as a proxy for fragment cost because `Renderer::render` always performs synchronous framebuffer readback.
+- [ ] **Step 4: Apply the objective gate.** If at 32, 64, or 128 local lights the median main-raster overhead versus zero lights is at least 1.0 ms or at least 15% of the light-free GPU frame on the Linux reference GPU, implement and verify depth-free 16×16 tiled Forward+ from conservative projected light volumes and record before/after *build + raster* time. If the threshold is not reached, keep the simple path, record the measured reason, and keep the CSV harness. New compute shader entries require exact reflection validation, CMake outputs, Editor build-service copy lists, and exported Player bundle tests.
+  ```text
+  gate = max_over_32_64_128(Δmain_raster_p50 >= 1.0 ms
+                           OR Δmain_raster_p50 >= 0.15 × gpu_frame_zero_lights_p50)
+  ```
+- [ ] **Step 5: Re-run both paths on the same frames.** Compare image output, zero validation errors, and measured GPU construction+raster cost. Keep Direct and P2 modes correct regardless of chosen default. Retain all raw CSV and methodology in the study; never claim universal speedup from one device.
+- [ ] **Step 6: Commit** `Measure P3 light scaling and select a verified lighting path`.
+
+### Task 7: End-to-end acceptance, Manual, and public evidence
+
+**Files:** Modify `docs/manual/editor/diagnostics.md`, `docs/manual/editor/profiling.md`, `mkdocs.yml`, `PLAN.md`, `docs/IMPLEMENTATION.md`, `docs/validation/README.md`; create `docs/manual/editor/lighting.md`, `docs/validation/p3-lighting-2026-09-24/README.md`, raw test logs/report files. Update Windows CI files only if the existing GPU-labeled suite does not pick up P3 cases.
+
+**Interfaces:** The Manual explains light kinds/properties, sun shadow distance, atlas face cost and overflow, shadow/camera behavior, editor and MCP authoring examples, and how to read actual diagnostics. The validation dossier names commit, exact Linux/Windows platform and driver, test counts, benchmark raw CSV paths, known limitations, and links to CI. P3 acceptance is an evidence claim, not a checkbox based only on compiling code.
+
+- [ ] **Step 1: Write acceptance cases before the final run.** Use fixed scenes for 0/1/many lights, moving sun/caster, camera pan/cut/resize, a thin receiver at a cascade split, offscreen caster, six point faces, 16-tile and 4096-draw capacity, an unsupported-atlas fallback, Direct/GPU frustum/occlusion equivalence, shader reload, and independent 2D/UI output.
+- [ ] **Step 2: Run Linux Debug and Release checks.** `cmake --build --preset linux-debug --parallel 4`; `ctest --preset linux-debug --output-on-failure`; `cmake --build --preset linux-release --parallel 4`; `ctest --test-dir build/linux-release --output-on-failure`. Run pinned Linux SwiftShader `ctest -L p3` and the same cases on a physical Vulkan GPU with validation enabled; record actual skips and layer availability.
+- [ ] **Step 3: Run Windows native and software-Vulkan CI.** Verify every `gpu;p3` test executes on pinned SwiftShader, shader reflection/package tests pass, and relocated 2D/3D exported Release Players run at least 120 frames. Publish the exact GitHub Actions run links, test logs, and exported-game report. Do not describe this as physical Windows-GPU validation unless that device was run.
+- [ ] **Step 4: Finish the English Manual and evidence.** Link `docs/manual/editor/lighting.md` in `mkdocs.yml`; include authoring JSON/Inspector and script examples, priorities, budgets, actual fallback and default path. Run `python -m mkdocs build --strict`, `git diff --check`, and the updated validation index link check. Update `PLAN.md` only for features whose stated acceptance evidence is present.
+- [ ] **Step 5: Review and commit** `Validate and document P3 lighting and shadows`; after independent code review, publish the completed checkpoint to GitHub and Gitea as previously authorized.

docs/superpowers/plans/2026-09-24-p3-temporal.md

@@ -0,0 +1,202 @@
+# P3 Temporal Reconstruction Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Deliver selectable 1:1 TAA and, after it passes moving-image acceptance, output-resolution-history temporal upscaling for Direct and P2 visibility paths, with explicit fallback and measurable image quality.
+
+**Architecture:** Keep the existing Off render branch as a reference. Add independent temporal history and per-instance previous transforms; raster the scene to internal color/depth/velocity, resolve against output-resolution history, then composite sharp UI into the existing final color image. HZB and temporal history share no validity flag, while using the same current scene depth and jittered raster projection.
+
+**Tech Stack:** C++20, Vulkan 1.3 dynamic rendering and synchronization2, Slang/SPIR-V, CMake/Ninja, SDL3, headless GPU image tests, Khronos validation, Linux/Windows software-Vulkan CI.
+
+**Spec:** `docs/superpowers/specs/2026-09-24-p3-temporal-design.md`
+
+**Prerequisite checkpoint:** Complete Task 2 of `docs/superpowers/plans/2026-09-24-p3-lighting.md` through the green commit `Share typed multi-light shading across Direct and GPU paths` before the temporal plan changes `renderer.hpp`, `renderer.cpp`, `baseline.slang`, `gpu_scene.slang` or shader-contract validation. Pure temporal policy/test drafting can happen earlier; shared renderer integration cannot. Re-run Direct/P2 lighting reflection, hot-reload and image tests after each temporal shader or pipeline change.
+
+## Global Constraints
+
+- `TemporalMode::Off` and output-resolution `color` remain the defaults and reference output; Direct visibility must work with TAA and Upscale.
+- Preserve the lighting graphics ABI: material set 0 bindings 0–3, frame-lighting set 1, GPU graphics scene set 2 bindings 0–2, unchanged 96/112-byte graphics push blocks; P2 compute sets remain set 0.
+- `Snapshot::view_projection`, projection, `scene_rect`, picking and UI coordinates remain unjittered and in output pixels.
+- HZB history and temporal color history have independent validity; GPU occlusion remains correct through temporal mode/scale switches.
+- A missing previous transform, anonymous draw, mesh/LOD identity change, camera cut, changed view/projection/scene rectangle, resize or incompatible shader generation cannot reuse stale color history.
+- World transparency/sprites retain depth and order, but their composited pixels reject temporal color history; UI is rendered at output resolution after resolve.
+- Shadow views and light-space matrices are never jittered or scaled by temporal rendering.
+- Player bundles contain complete checked SPIR-V and reflection metadata; no Slang compiler or Editor/MCP service is required at runtime.
+- Unsupported temporal capabilities must use Off with an exposed effective mode and reason, never a silent path change.
+- Every new pass receives a GPU label and timing; full-frame measurements include the existing synchronous readback cost unless explicitly excluded in a matched experiment.
+
+## Review Focus
+
+- Direct mode while TAA is enabled: a stable opaque instance must gain a valid prior transform on frame two without requiring HZB; Task 1 and Task 4 test this.
+- GPU PostRaster after an object emerges from occlusion: its color and velocity must exist before temporal resolve so the same final frame shows it; Tasks 3 and 4 test this.
+- Editor scene rectangle and UI: an offset/odd-sized scene viewport may scale internally, but text and buttons must remain pixel-exact in final output; Tasks 3 and 5 test this.
+- A translucent object moving across an opaque surface: its pixels must not borrow the underlying opaque motion/history; Tasks 3 and 4 test this.
+- Shader reload, format fallback and relocated exports: a partial bundle or unsupported format cannot produce a half-active temporal path; Task 6 tests this.
+
+---
+
+### Task 1: Independent temporal history policy and public mode
+
+**Files:** Create `include/faset/render/temporal.hpp`, `src/render/temporal.cpp`, `tests/render_temporal_policy_tests.cpp`; modify `include/faset/render/renderer.hpp`, `src/render/renderer.cpp`, `cmake/Renderer.cmake`.
+
+**Interfaces:** Add `enum class TemporalMode { Off, TAA, Upscale };`, `RendererConfig::temporal_mode`, `RendererConfig::render_scale`, `Renderer::set_temporal_mode(TemporalMode, float)`, `Renderer::temporal_mode()`, `FrameStats::requested_temporal_mode`, `effective_temporal_mode`, `temporal_history_valid`, `temporal_reset_reason`, and `temporal_internal_width/height`. Define `TemporalResetReason { None, FirstFrame, CameraCut, CameraDiscontinuity, ViewChanged, ViewportChanged, ProjectionChanged, Resize, ModeChanged, ScaleChanged, ShaderReload, Unsupported }` and `TemporalCapabilities { bool compute, formats, extent; }`. A pure `evaluate_temporal_history(previous, current) -> TemporalHistoryDecision` compares `TemporalHistoryKey` values containing view ID, output/internal extent, scene rectangle, unjittered projection, mode, shader generation, camera eye/current VP and explicit cut. `temporal_jitter(frameIndex, viewportWidth, viewportHeight)` returns a deterministic Halton(2,3) clip offset. Add `select_effective_temporal_mode(requested, capabilities)` as a pure policy function. Shared graphics descriptors remain material set 0, lighting set 1, GPU scene set 2; this task does not reallocate those bindings.
+
+- [ ] **Step 1: Write failing policy tests and register their CMake target.** In a Direct visibility configuration, a same-view second frame returns `valid=true` even when HZB is absent. Test first frame, cut, view switch, changed projection, odd scene rectangle, resize, mode/scale change, shader generation, a camera teleport and unsupported format/compute capabilities. Add `faset_render_temporal_policy_tests` / `render_temporal_policy` to `cmake/Renderer.cmake` before the RED build. Example contract:
+  ```cpp
+  auto decision = evaluate_temporal_history(previous, current);
+  require(decision.valid && decision.reason == TemporalResetReason::None);
+  current.camera_cut = true;
+  require(!evaluate_temporal_history(previous, current).valid);
+  require(select_effective_temporal_mode(TemporalMode::TAA, {false, true}) == TemporalMode::Off);
+  ```
+- [ ] **Step 2: Run the focused target and record the intended missing-interface failure.** Reconfigure with `cmake --preset linux-debug`, then run `cmake --build --preset linux-debug --target faset_render_temporal_policy_tests -j 4`; it must fail compiling the new test against the absent temporal API, not with `unknown target`. After implementation, `ctest --test-dir build/linux-debug --no-tests=error -R '^render_temporal_policy$'` runs its behavioral assertions.
+- [ ] **Step 3: Implement the pure policy and attach it to rendered-frame completion.** Keep `scene.hzb_history_valid` and temporal history fields separate; do not call `InstanceTracker::invalidate_view()` merely because P2 occlusion is inactive. Reject invalid scale (`TAA` requires `1`, `Upscale` requires `[0.5, 1)`) with `std::invalid_argument`. Define camera teleport conservatively using eye displacement and an unjittered VP discontinuity, and expose the reason through `FrameStats`.
+  ```cpp
+  const bool hzb_compatible = evaluate_hzb_history(...);
+  const auto temporal = evaluate_temporal_history(previous_temporal, current_temporal);
+  gpu_frame.view.flags[0] = hzb_compatible ? 1u : 0u;
+  statistics.temporal_history_valid = temporal.valid;
+  ```
+- [ ] **Step 4: Run the CPU tests and existing P2 policy tests.** `ctest --test-dir build/linux-debug --output-on-failure -R 'render_temporal_policy|render_visibility_policy|render_gpu_shader_contract'` must pass. Check that the default constructor still selects Off.
+- [ ] **Step 5: Commit.** `git add include/faset/render/temporal.hpp src/render/temporal.cpp tests/render_temporal_policy_tests.cpp include/faset/render/renderer.hpp src/render/renderer.cpp cmake/Renderer.cmake && git commit -m "Define independent temporal history and mode policy"`.
+
+### Task 2: Previous transforms and checked motion-vector shaders
+
+**Files:** Modify `src/render/renderer.cpp`, `include/faset/render/visibility.hpp`, `shaders/baseline.slang`, `shaders/gpu_scene.slang`, `cmake/Renderer.cmake`, `src/render/shader_contract.hpp`, `src/render/shader_contract.cpp`, `tests/test_shader_reflection.py`, `tests/render_gpu_shader_contract_tests.cpp`; create `tests/render_temporal_motion_tests.cpp`.
+
+**Interfaces:** Extend the GPU `SceneInstance/InstanceRecord` from 224 to 288 bytes by appending `previousModel` at offset 224; retain slot/generation metadata at offsets 208–223. `metadata.x & 1` means prior HZB eligibility; `metadata.x & 2` means prior temporal transform eligibility. A temporal Direct vertex carries `previousClip` and validity alongside existing current clip and material data. Temporal Direct/GPU vertex entries feed one temporal fragment entry that writes scene color and an `R16G16B16A16_SFLOAT` target: `.xy = currentUV - previousUV`, `.z = previous clip depth`, `.w = 1` for valid opaque motion and `0` for reactive/invalid pixels. Add a pure `project_motion(current_clip, previous_clip) -> Vec2` CPU oracle with the same sign/space convention. Preserve the post-lighting baseline Off shader entry points and their layout fingerprints; GPU P2 fingerprints change with the checked record stride. Temporal fragment binds material set 0 and lighting set 1; temporal GPU vertex reads instance/visible-ID/view from set 2. Do not move cull/HZB compute off set 0 or increase 96/112-byte graphics push constants.
+
+- [ ] **Step 1: Write failing shader and motion tests and register their target.** Assert the reflected 288-byte storage stride, current/previous clip varyings, velocity attachment output, lighting set 1/GPU scene set 2, and rejection of a tampered SPIR-V/reflection pair. Add `faset_render_temporal_motion_tests` / `render_temporal_motion` to `cmake/Renderer.cmake`. Test `project_motion` against a known current/prior clip pair and `InstanceTracker` through a two-frame rigid object move; include a replaced mesh and anonymous draw whose motion validity is false. GPU image-level motion tests belong to Task 4 after MRT resources exist.
+  ```cpp
+  auto previous = tracker.update("cube", mesh, model_a, bounds_a, "main");
+  tracker.finish_frame();
+  auto moved = tracker.update("cube", mesh, model_b, bounds_b, "main");
+  require(moved.previous_valid && moved.previous_model == model_a);
+  ```
+- [ ] **Step 2: Observe the expected pre-implementation failure.** Reconfigure, then run `cmake --build --preset linux-debug --target faset_render_temporal_motion_tests -j 4`; the new test fails to compile against missing motion interfaces. Build the changed existing tests with `cmake --build --preset linux-debug --target faset_render_gpu_shader_contract_tests faset_shaders -j 4`, then `ctest --test-dir build/linux-debug --no-tests=error --output-on-failure -R '^(render_shader_reflection|render_gpu_shader_contract)$'` must reject the new temporal ABI assertions rather than pass only old cases.
+- [ ] **Step 3: Implement both geometry paths and shader contracts.** Retain `InstanceUpdate` in selected Direct draws; compute the previous clip position from its previous model and previous jittered VP. Extend `GpuVertex` only as needed by temporal shader input locations. GPU temporal vertex multiplies `previousViewProjection * previousModel * localVertex`. Current/previous scene clip and validity reach the fragment; encode current-minus-prior local-scene UV, prior clip depth and validity. Make P2 culling read `(metadata.x & 1u) != 0`, not `metadata.x != 0`. Update C++ static assertions and reflection checks together.
+  ```slang
+  float4 previousClip = mul(view.previousViewProjection,
+                            mul(instance.previousModel, float4(vertex.position, 1)));
+  bool temporalValid = (instance.metadata.x & 2u) != 0u && previousClip.w > 0;
+  // Off still uses vertexMain / gpuVertexMain / fragmentMain.
+  ```
+- [ ] **Step 4: Run reflection, motion and P2 GPU suites under validation.** `ctest --test-dir build/linux-debug --output-on-failure -R 'render_temporal_motion|render_shader_reflection|render_gpu_shader_contract|render_gpu_visibility'` must pass with zero validation errors. Verify the Off direct/GPU image comparison remains within its established tolerance.
+- [ ] **Step 5: Commit.** `git add src/render/renderer.cpp include/faset/render/visibility.hpp shaders/baseline.slang shaders/gpu_scene.slang cmake/Renderer.cmake src/render/shader_contract.hpp src/render/shader_contract.cpp tests/test_shader_reflection.py tests/render_gpu_shader_contract_tests.cpp tests/render_temporal_motion_tests.cpp && git commit -m "Emit checked motion vectors for direct and GPU scenes"`.
+
+### Task 3: Scene targets, post-cull ordering and sharp UI boundary
+
+**Files:** Create `shaders/temporal.slang`, `tests/render_temporal_graph_tests.cpp`; modify `src/render/renderer.cpp`, `src/render/shader_contract.hpp`, `src/render/shader_contract.cpp`, `shaders/baseline.slang`, `shaders/gpu_scene.slang`, `cmake/Renderer.cmake`, `tests/render_tests.cpp`, `tests/render_gpu_acceptance_tests.cpp`.
+
+**Interfaces:** Add temporal-only internal `sceneColor` (`R8G8B8A8_UNORM`, sampled/color attachment), `sceneDepth` (`D32_SFLOAT`, sampled/depth attachment) and `sceneVelocity` (sampled floating-point/color attachment). Keep existing full-resolution `color` for capture and presentation. Temporal opaque pipeline variants use color+velocity MRT; transparent/sprite pixels overwrite velocity validity with invalid/reactive state. Split `draw_sprites_and_ui` so world sprites join the internal scene and UI draws only after resolve. Record names in `FrameStats::graph_passes` for ordering diagnostics. Main and post-raster graphics pipelines bind material set 0 and lighting set 1, plus scene set 2 only for GPU instances; shadow planning remains unjittered. For TAA, internal and output extents are identical; the scaling of Task 5 follows later.
+
+- [ ] **Step 1: Write failing graph/image tests and register their target.** Add `faset_render_temporal_graph_tests` / `render_temporal_graph` to `cmake/Renderer.cmake`. Render an odd, offset Editor `scene_rect`, a textured sprite behind/in front of a mesh, moving translucent geometry and bright UI text/quad. Assert `TemporalResolve` occurs after `PostRasterScene` in GPU occlusion mode, `UI` occurs after resolve, viewport clipping holds, and an unchanged UI pixel matches Off exactly. Check depth and velocity attachment store/load behavior with validation.
+  ```cpp
+  require(position(pass_names, "PostRasterScene") < position(pass_names, "TemporalResolve"));
+  require(position(pass_names, "TemporalResolve") < position(pass_names, "TemporalComposite"));
+  require(position(pass_names, "TemporalComposite") < position(pass_names, "UI"));
+  require(taa_frame.ui_pixel == off_frame.ui_pixel);
+  ```
+- [ ] **Step 2: Run the focused test and confirm the missing scene/UI split.** Reconfigure/build `faset_render_temporal_graph_tests`, then `ctest --test-dir build/linux-debug --no-tests=error --output-on-failure -R '^render_temporal_graph$'` must fail at the new pass-order/UI assertion. A compile failure on an absent `FrameStats::graph_passes` field is also a valid RED result; an unregistered test is not.
+- [ ] **Step 3: Refactor the render branch without changing Off output.** In the temporal branch, MainRaster clears color/depth/velocity, HZB reads stored scene depth, PostRaster loads all attachments, transparent/sprites retain their scene-depth test and invalidate velocity/reactive pixels, then `TemporalResolve`, `TemporalComposite` and `UI` are separate named passes. First make Resolve a spatial copy into a temporary `resolvedColor` and Composite a fullscreen draw to `color`; Task 4 replaces the spatial result with temporal accumulation. Explicitly transition color/depth/velocity from attachment to sampled layouts before compute, and resolved output to sampled before composite.
+  ```cpp
+  // Temporal branch only; Off keeps the established ForwardAndUI path.
+  graph.add("PostRasterScene", {"sceneColor", "sceneDepth", "post_indirect"},
+            {"sceneColor", "sceneDepth", "sceneVelocity"}, draw_post_scene);
+  graph.add("TemporalResolve", {"sceneColor", "sceneDepth", "sceneVelocity"},
+            {"resolvedColor"}, resolve_spatial);
+  graph.add("TemporalComposite", {"resolvedColor"}, {"color"}, draw_resolved_scene);
+  graph.add("UI", {"color"}, {"color"}, draw_output_ui);
+  ```
+- [ ] **Step 4: Run GPU image/validation and sprite/UI suites.** `ctest --test-dir build/linux-debug --output-on-failure -R 'render_temporal_graph|render_offscreen|render_sprite_alpha|render_gpu_visibility|ui_render'` passes. Compare Off captures before/after this commit to ensure no unrequested shading/UI change.
+- [ ] **Step 5: Commit.** `git add src/render/renderer.cpp src/render/shader_contract.hpp src/render/shader_contract.cpp shaders/baseline.slang shaders/gpu_scene.slang shaders/temporal.slang cmake/Renderer.cmake tests/render_tests.cpp tests/render_gpu_acceptance_tests.cpp tests/render_temporal_graph_tests.cpp && git commit -m "Separate temporal scene raster from output UI"`.
+
+### Task 4: Stable 1:1 TAA with disocclusion rejection
+
+**Files:** Create `tests/render_temporal_acceptance_tests.cpp`; modify `shaders/temporal.slang`, `src/render/renderer.cpp`, `cmake/Renderer.cmake`, `src/render/shader_contract.hpp`, `src/render/shader_contract.cpp`, `tests/test_shader_reflection.py`, `tests/render_temporal_graph_tests.cpp`.
+
+**Interfaces:** Allocate two output-resolution `R16G16B16A16_SFLOAT` sampled/storage color histories and two output-resolution `R32_SFLOAT` sampled/storage depth histories. `temporalResolveMain` reads current scene color/depth/velocity and prior history, writes current history. `temporalComposite*` draws the resolved result to the existing RGBA8 final `color`; it does not reapply tone mapping/gamma because scene shading is already display-referred. Add GPU pass time and a history accepted/rejected diagnostic counter that is read only in diagnostic mode.
+
+- [ ] **Step 1: Write failing deterministic frame-sequence tests and register their target.** Add `faset_render_temporal_acceptance_tests` / `render_temporal_acceptance` to `cmake/Renderer.cmake`. On Direct and P2 GPU modes, require first-frame rejection and second-frame acceptance. Test static diagonal/wire variance after 16 jitter phases, slow camera pan, moving rigid cube, opening a door, explicit cut, unmarked teleport, mesh/LOD identity change, and UI opacity. Compare each reveal/cut frame to Off at the same camera; old foreground colors must not trail into exposed background. Record tolerances per fixture in the test, not a universal image-perfect claim.
+  ```cpp
+  auto cut = render_frame(taa, scene_with_cut);
+  auto fresh = render_frame(off, scene_without_history);
+  require(!cut.stats.temporal_history_valid);
+  require(mean_rgb_error(cut.rgba, fresh.rgba, reveal_roi) <= 8.0);
+  ```
+- [ ] **Step 2: Run the acceptance target to see the expected lack of accumulation/rejection.** Reconfigure/build the new target, then `ctest --test-dir build/linux-debug --no-tests=error --output-on-failure -R '^render_temporal_acceptance$'` must fail in its new history/variance assertions; a zero-tests pass is not evidence.
+- [ ] **Step 3: Implement TAA resolve and real history lifetime.** Use deterministic Halton jitter, local-scene normalized motion and 3×3 nearest-depth velocity dilation. Reject invalid/out-of-bounds motion and sampled prior depth mismatches, clamp previous color to a current 3×3 neighborhood, reduce its bounded weight for high motion/reactive pixels, and use current color on first/rejected pixels. Write current color/depth to the next history only after a successful submitted frame. Grow the 12-query timestamp pool so every graph pass is timed, and expose separate temporal resolve/composite timings.
+  ```slang
+  float2 previousUV = currentUV - selectedMotion.xy;
+  bool accept = historyValid && selectedMotion.w > 0 && inBounds(previousUV) &&
+                depthAgrees(selectedMotion.z, historyDepth.SampleLevel(sampler, previousUV, 0));
+  float3 resolved = accept ? lerp(current.rgb, clamp(history.rgb, neighborhoodMin,
+                                                     neighborhoodMax), historyWeight)
+                           : current.rgb;
+  ```
+- [ ] **Step 4: Run policy, shader and GPU acceptance under validation.** `ctest --test-dir build/linux-debug --output-on-failure -R 'render_temporal|render_shader_reflection|render_gpu_visibility|render_offscreen'` passes, including Direct/P2. Capture repeatable Off/TAA comparison images and per-pass timing for review; a TAA frame with zero validation errors is not sufficient without the moving-image assertions.
+- [ ] **Step 5: Commit.** `git add shaders/temporal.slang tests/render_temporal_acceptance_tests.cpp src/render/renderer.cpp cmake/Renderer.cmake src/render/shader_contract.hpp src/render/shader_contract.cpp tests/test_shader_reflection.py tests/render_temporal_graph_tests.cpp && git commit -m "Resolve scene with depth-rejected temporal AA"`.
+
+### Task 5: Lower-resolution scene and output-resolution history
+
+**Files:** Modify `src/render/renderer.cpp`, `include/faset/render/renderer.hpp`, `include/faset/render/temporal.hpp`, `src/render/temporal.cpp`, `shaders/temporal.slang`, `tests/render_temporal_policy_tests.cpp`, `tests/render_temporal_acceptance_tests.cpp`, `tests/render_gpu_acceptance_tests.cpp`.
+
+**Interfaces:** `Upscale` computes internal width/height by `ceil(outputExtent * renderScale)` with a minimum of one pixel; stores history at output extent. It transforms `scene_rect` into a clipped internal viewport once per frame. P2 HZB, current/post depth and `SceneView` viewport use these internal values. Resolve maps each output-scene pixel to the internal scene signal and handles depth/velocity boundaries before history reuse. Output UI and capture remain full resolution.
+
+- [ ] **Step 1: Write failing scale tests.** Exercise 320×240 at 0.67, 319×241 with an offset scene rectangle at 0.5, resize, 2D sprites, and toggling 1.0 TAA → 0.67 Upscale → Off. Check reported internal extent, exact UI pixels, HZB reset, history reset reason and no stale edge pixels. Compare a static thin-wire and slow-pan sequence to a full-resolution spatial reference; require measured temporal variance to improve over a nearest-neighbor 0.67 spatial baseline, while reporting image error rather than asserting that all scenes improve.
+  ```cpp
+  require(upscaled.stats.temporal_internal_width == 215);
+  require(upscaled.stats.temporal_internal_height == 161);
+  require(upscaled.rgba.size() == 320u * 240u * 4u);
+  require(upscaled.stats.temporal_reset_reason == TemporalResetReason::ScaleChanged);
+  ```
+- [ ] **Step 2: Run the scale test and observe the missing reduced-resolution path.** Rebuild `faset_render_temporal_acceptance_tests` with the new assertions, then `ctest --test-dir build/linux-debug --no-tests=error --output-on-failure -R '^render_temporal_acceptance$'` must fail at the internal extent/scale transition assertion.
+- [ ] **Step 3: Implement internal target recreation and upscale sampling.** Keep `color`/readback output-sized, resize scene color/depth/velocity and HZB to internal size, scale only scene viewport/scissor, and include internal extent in both history keys. Use output-resolution history and depth-aware current sampling at output pixel centers; keep motion in local-scene normalized coordinates. Recreate descriptors after target changes and invalidate both temporal/HZB histories on scale/resize.
+  ```cpp
+  const auto internal_w = std::max(1u, static_cast<unsigned>(std::ceil(width * scale)));
+  const auto internal_h = std::max(1u, static_cast<unsigned>(std::ceil(height * scale)));
+  // scene_rect is mapped to this extent; UI remains at width x height.
+  ```
+- [ ] **Step 4: Run Direct/frustum/occlusion GPU sequences and baseline UI/resize tests.** `ctest --test-dir build/linux-debug --output-on-failure -R 'render_temporal|render_gpu_visibility|render_offscreen|render_sprite_alpha|editor_ui'` passes with zero Vulkan validation errors where the validation layer exists. Inspect side-by-side captures on physical GPU and software Vulkan.
+- [ ] **Step 5: Commit.** `git add src/render/renderer.cpp include/faset/render/renderer.hpp include/faset/render/temporal.hpp src/render/temporal.cpp shaders/temporal.slang tests/render_temporal_policy_tests.cpp tests/render_temporal_acceptance_tests.cpp tests/render_gpu_acceptance_tests.cpp && git commit -m "Reconstruct lower-resolution scenes at output resolution"`.
+
+### Task 6: Editor/Player control, shader reload, package and graceful fallback
+
+**Files:** Modify `src/editor/debug_overlay.cpp`, `src/editor/build_service.cpp`, `apps/player_main.cpp`, `src/render/renderer.cpp`, `src/render/shader_contract.cpp`, `cmake/Renderer.cmake`, `tests/render_reload_tests.cpp`, `tests/build_service_tests.cpp`, `tests/player_diagnostics_test.py`, `docs/manual/editor/profiling.md`; add temporal mode usage to the appropriate scripting/manual rendering page.
+
+**Interfaces:** Editor and Player select Off/TAA/Upscale with scale; the Player profile reports requested/effective mode, fallback/reset reason, internal/output extent, jitter, temporal GPU ms and memory. A complete shader bundle includes all temporal entry points and metadata. Reload is transactional: failure preserves the active set and history, success replaces pipelines and resets history. Device feature checks are separate from P2 `scene.available`, then `select_effective_temporal_mode` exposes fallback.
+
+- [ ] **Step 1: Write failing integration tests.** A missing/tampered temporal `.spv` or reflection rejects the bundle and exported game; a failed hot reload leaves previous rendered pixels/actual mode intact; successful reload resets history; a pure unsupported-capability fixture selects Off with a specific reason. A relocated 2D and 3D Player profile contains temporal requested/effective and reset fields. Check Editor control state matches `Renderer::temporal_mode()`.
+  ```cpp
+  const auto before = renderer.stats().effective_temporal_mode;
+  require(!renderer.reload_shaders(error) && !error.empty());
+  renderer.render(scene);
+  require(renderer.stats().effective_temporal_mode == before);
+  ```
+- [ ] **Step 2: Run focused integration tests for the expected package/control failure.** Build `faset_render_reload_tests`, `faset_build_service_tests`, and `faset_player_diagnostics`; then `ctest --test-dir build/linux-debug --no-tests=error --output-on-failure -R '^(render_shader_reload|process_and_cook|player_shutdown_diagnostics)$'` must execute registered tests and fail in the new temporal assertions. For the optional overlay, configure `cmake -S . -B build/p3-temporal-ui -G Ninja -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DBUILD_TESTING=ON -DFASET_DEBUG_IMGUI=ON`, build `faset_debug_overlay_tests`, and run `ctest --test-dir build/p3-temporal-ui --no-tests=error --output-on-failure -R '^editor_debug_overlay$'`. Record the specific failing assertions; an absent overlay test is not a pass.
+- [ ] **Step 3: Implement controls and packaging.** Compile/install temporal shaders in `cmake/Renderer.cmake`; update both explicit shader-copy lists in `src/editor/build_service.cpp`; validate reflection/strides; stage temporal pipelines before replacing live ones. Query sampled/color/storage/filter format support and compute queue support, report Off fallback explicitly, and avoid allocating history on Off. Add concise English Manual examples for mode choice and reading the profile.
+  ```cpp
+  stats.requested_temporal_mode = config.temporal_mode;
+  stats.effective_temporal_mode = select_effective_temporal_mode(config.temporal_mode, caps);
+  stats.temporal_status_reason = stats.effective_temporal_mode == TemporalMode::Off
+      ? missing_capability_name(caps) : std::string{};
+  ```
+- [ ] **Step 4: Run focused tests, both sample exports, strict Manual build and native Windows CI.** `ctest --test-dir build/linux-debug --no-tests=error --output-on-failure -R 'render_shader_reload|process_and_cook|player_shutdown_diagnostics|render_temporal'`, `ctest --test-dir build/p3-temporal-ui --no-tests=error --output-on-failure -R '^editor_debug_overlay$'`, and `python -m mkdocs build --strict` pass; relocated exports launch without compiler/source checkout. Record any Windows GPU/validation coverage gap explicitly.
+- [ ] **Step 5: Commit.** `git add src/editor/debug_overlay.cpp src/editor/build_service.cpp apps/player_main.cpp src/render/renderer.cpp src/render/shader_contract.cpp cmake/Renderer.cmake tests/render_reload_tests.cpp tests/build_service_tests.cpp tests/player_diagnostics_test.py docs/manual && git commit -m "Expose and package temporal reconstruction"`.
+
+### Task 7: Adversarial quality gate, performance record and P3 integration
+
+**Files:** Add `docs/validation/p3-temporal-2026-09-24/README.md` and image/measurement artifacts; modify `PLAN.md`, `docs/IMPLEMENTATION.md`, `docs/ARCHITECTURE.md`, `docs/manual/editor/profiling.md`, temporal tests as findings require.
+
+**Interfaces:** The evidence dossier binds revision, OS/GPU/driver, exact test commands, mode/scale, output/internal extent, scene sequence, raw image differences, static variance, disocclusion trail length, pass/full-frame time, allocated GPU bytes and feature limits. Lighting/shadow work may use the final `sceneColor/depth/velocity` boundary but does not mark temporal acceptance by itself.
+
+- [ ] **Step 1: Run every adversarial sequence against Off and 1:1 TAA before claiming upscaling readiness.** A newly exposed surface and camera cut must show current color immediately; thin static geometry should have lower temporal variance without unacceptable trail length. Repeat with 0.67 Upscale against 0.67 spatial and 1.0 full-res references on closed/open scenes. Keep the raw captures and metric script with the dossier.
+  ```text
+  Sequences: wire-static-16, pan-16, moving-cube-16, door-open-4,
+             cut-2, teleport-2, projection/resize/view-switch, UI+alpha.
+  Modes: Off, TAA 1.0, Upscale 0.67; visibility: Direct, Frustum, Occlusion.
+  ```
+- [ ] **Step 2: Run Debug/Release tests, validation, shader reload, strict docs, software GPU and native CI.** `cmake --build --preset linux-debug --parallel 4`, `ctest --preset linux-debug --output-on-failure`, `cmake --build --preset linux-release --parallel 4`, `ctest --test-dir build/linux-release --output-on-failure`, and strict MkDocs must pass. Run the selected SwiftShader ICD with temporal GPU tests and relocated exports. If a physical Windows GPU is unavailable, say so.
+- [ ] **Step 3: Record matched profiling and image metrics.** Use the same scene/camera path and resolution for Off/TAA/Upscale. Report pass GPU ms, full GPU ms, CPU extraction/readback, and live allocation, with raw samples and p50/p95. Report quality metrics on fixed ROIs and representative frames, plus captures for moving thin geometry, disocclusion, UI and transparency; do not turn fixture-specific results into a universal speed/quality claim.
+- [ ] **Step 4: Review the final diff independently and close load-bearing findings.** Confirm HZB correctness, history invalidation, shader package/reload atomicity, Direct/P2 equivalence and UI sharpness; run `graphify update .` after final code edits, then update PLAN/Manual/architecture and evidence links to match actual tested scope.
+- [ ] **Step 5: Commit and publish only verified work.** `git add PLAN.md docs/IMPLEMENTATION.md docs/ARCHITECTURE.md docs/manual docs/validation/p3-temporal-2026-09-24 tests && git commit -m "Validate P3 temporal reconstruction"`; publish checkpoint and final commits to the authorized remotes once local verification and CI are green.

docs/superpowers/specs/2026-09-23-p2-gpu-visibility-design.md

@@ -0,0 +1,29 @@
+# P2 GPU visibility and mesh LOD design
+
+This design implements [PLAN P2](../../../PLAN.md#p2-gpu-driven-visibility-и-lod) for the desktop Vulkan 1.3 renderer. The direct renderer remains a selectable reference for image and full-frame performance comparisons. The feature is limited to opaque triangle meshes. Ordered sprites, UI, and shadow casters keep their independent paths; camera visibility must never remove an offscreen shadow caster.
+
+## Data and ownership
+
+`DrawItem` receives an optional stable instance key and an optional ordered list of prepared coarser meshes. Scene extraction derives a key from persistent object/asset-primitive identity; ad-hoc draws without a key render correctly but do not use previous-frame occlusion or LOD history. The renderer assigns a slot and generation to each live key, invalidating previous transforms when the mesh identity changes or a slot is reused. An immutable frame snapshot contains current and previous world bounds, transforms, material values, selected mesh LOD, and a bin ID. A conservative world AABB is formed from all eight transformed corners of each mesh's local bounds. The bound used for culling covers the selected geometry; source content must not claim a narrower bound than its vertices.
+
+Prepared LODs are optional. The renderer chooses one by projected size, applies hysteresis around every threshold, and falls back to the nearest available level. A level switch retains the stable instance key but invalidates occlusion history for that instance. LOD selection never changes source asset IDs or authoring scene data.
+
+## GPU path
+
+The renderer groups opaque candidates by compatible mesh and texture into fixed bins. It uploads local mesh vertices once per unique mesh in the frame and uploads one transform/material/bounds record per instance. A compute pass tests current frustum and writes visible instance IDs into a pre-reserved range per bin, atomically updating the bin's indirect `instanceCount`. Each bin has a CPU-authored fixed draw template and one `vkCmdDrawIndirect` call; zero instances submit no geometry. The vertex shader resolves `SV_InstanceID` through the visible-ID buffer and transforms the local vertex on the GPU. The command uses `firstInstance = 0` and a pushed bin base, so it does not require optional `drawIndirectFirstInstance` or `multiDrawIndirect` features. Overflow is prevented by reserving exactly the number of bin candidates; buffer growth is checked before recording commands.
+
+The direct path continues to use existing CPU-transformed vertices, CPU frustum culling, and direct draws. Scene shading and texture descriptors are shared where possible. GPU and direct modes must produce equivalent final opaque images within stated raster tolerance. Scene culling does not affect the shadow pass.
+
+## HZB and two-pass occlusion
+
+Faset uses normal forward Z: depth clear is 1 and the comparison is `LESS_OR_EQUAL`. Its furthest-depth HZB therefore stores the **maximum** child depth, padding odd dimensions with 1. A candidate is marked occluded only when its conservative nearest depth is strictly beyond the maximum over its complete screen rectangle plus precision bias. Near-plane intersections, nonfinite projections, unknown previous transforms, a camera cut, a resized view, a different view identity, and an invalid history all fail open as visible.
+
+The pass order is: initialize fixed arguments/counters; MainCull against the current frustum and previous HZB; MainRaster into cleared color/depth; build current HZB from stored depth with per-mip barriers; PostCull deferred candidates against current HZB; PostRaster loading Main color/depth; then ordered sprites/UI and capture/presentation. Current HZB after Main is intentionally incomplete: a false previous occlusion is repaired by Post in the same frame, while absent occluders only reduce culling efficiency. Current HZB and its view metadata survive to the next rendered frame. History is per renderer/view and is invalidated by explicit cut, view/extent/projection changes, or incompatible instance generation. No GPU visibility decision requires synchronous CPU readback.
+
+RenderGraph names and validates pass order; Vulkan image and buffer barriers remain explicit in the backend. Compute writes become visible separately to indirect-command reads and vertex shader storage reads. Depth attachment writes become visible to HZB compute sampling only after ending the Main rendering instance. HZB mip writes become visible to the next mip's reads. The single-queue, one-frame-in-flight lifetime model is retained until measured work warrants a wider pipeline.
+
+## Diagnostics and acceptance
+
+The editor exposes GPU/direct and HZB-enabled modes and a current-HZB/debug visualization. Frame statistics distinguish submitted bins, main/deferred/post counts, frustum rejects, selected LODs, pass timings, and GPU allocation sizes. Debug counters may be read after the existing frame fence; normal culling decisions never use them. Full-frame profiles record both closed and open scenes with the same snapshot, camera path, resolution, driver, and build. Existing synchronous frame capture is accounted for or disabled in the comparison profile; no blanket speedup claim is made.
+
+Acceptance includes shader/reflection validation and package/export contents; CPU policy tests; GPU image comparison to direct mode; empty and capacity-boundary cases; wall/door reveal in the same final frame; camera cut/teleport, near-plane and camera-inside cases; odd viewport dimensions and resize; repeated spawn/despawn/mesh replacement; LOD threshold jitter; offscreen shadow caster; and zero Vulkan validation errors on the Linux reference GPU. Windows compile and available native GPU checks are reported separately without claiming hardware coverage that was not run.

docs/superpowers/specs/2026-09-24-p1-iteration-design.md

@@ -0,0 +1,74 @@
+# P1 gameplay iteration design
+
+This design closes [PLAN P1](../../../PLAN.md#p1-lua-и-скорость-итераций) for Linux and Windows desktop 2D/3D authoring. It improves the path from changing gameplay or a scene to seeing the result in the Player. C++ remains the compiled gameplay language; Lua remains an optional module with development reload. MCP controls the Editor and authoring/build services, not the live Player world.
+
+The Editor's dark visual treatment should be consistent with [the iteration console reference](../../design/p1-iteration-console-reference.png) and [the new-project reference](../../design/p1-project-template-reference.png). These images are visual references only. The behavior, data contracts, platform paths, accessibility and available actions in this specification and `PLAN.md` are the source of truth. The Windows path shown in the project image is illustrative; the real chooser must use each platform's native paths.
+
+## Existing baseline and scope
+
+The optional Lua VM, LuaLS annotations, component schemas, Inspector fields, atomic development reload and rollback already exist. `BuildService` already serializes GUI/MCP builds, uses incremental CMake/Ninja native trees separated by Debug and Release, publishes immutable successful generations, and preserves the last good generation after failure. The authoring service atomically journals every transaction under `.faset/recovery` and refuses to save over an externally changed scene. A disposable workflow script measures one changed C++ build and first Player frame. These remain the foundation, not new work to replace.
+
+P1 adds verifiable reuse of unchanged schema/build packages, useful compiler diagnostics, convenient new-project choices and code navigation, autosave of named scenes, and repeatable iteration measurements. It also closes the recorded Lua validation gap on Windows and in a graphical Release export. P1 does not add C++ hot reload, dynamic gameplay loading, Lua state preservation across reload, Player-world MCP access, a built-in code editor, or broad performance guarantees. Dynamic gameplay loading is reconsidered only if measured native link time is a material bottleneck.
+
+## User workflows
+
+### C++ edit, build and Play
+
+The developer edits `Scripts/Gameplay.cpp` or a header, presses **Build**, and sees a named job with phase, progress, elapsed time and diagnostics. A compiler error shows severity, a short message, project-relative file and one-based line/column when the tool supplies them. Selecting it opens the source at that location in the configured external editor. Raw compiler output remains available. A failed build leaves the prior Player/schema generation intact and marks Inspector metadata stale. An unchanged second build reports a cache hit and reuses the same validated generation. **Play** still captures the current authoring scene, invokes the build service, then launches an isolated Player; editing after capture does not silently change that snapshot.
+
+### Lua edit and reload
+
+A Lua project declares scripts in `project.faset.json` and can start with no project C++ files. Script edits mark schema metadata stale when declarations change; **Refresh Lua** validates schemas without recompiling unrelated C++ gameplay. The running development Player watches or explicitly reloads scripts; successful reload resets its world/script state, while an invalid edit preserves the old running version. The Editor and MCP surface parseable diagnostics with source locations where available. A packaged Release Player includes only the declared Lua snapshot and needs neither `slangc`, LuaLS nor the Editor.
+
+### New project and source navigation
+
+The new-project chooser offers four clear combinations: C++ 2D, C++ 3D, Lua 2D and Lua 3D. The existing CLI `--new NAME --dimension 2|3` and two-argument `BuildService::scaffold(name, dimension)` retain their C++ scaffold behavior for compatibility. The chooser and an explicit `--language cpp|lua` select a runnable template that adds a minimal start scene and documented starter behavior for the chosen dimension. Template creation never overwrites existing user files and rejects nonempty conflicting destinations. Lua starters include the module declaration and language-server setup without a C++ gameplay stub. The source browser opens C++, headers and Lua under `Scripts`; diagnostic rows open the exact project source line/column when supported by the configured editor.
+
+`faset_source_open` accepts a project-relative path and optional one-based line/column, validates that the target is a regular `.cpp`, `.hpp`, `.h` or `.lua` file beneath `Scripts`, and launches an argv array without a shell. It rejects traversal, symlinks escaping the project, directories and executable files. The existing `faset_script_open` Lua-only command remains a compatibility alias. Editor configuration supports `{file}`, `{line}`, `{column}` and `{project}` tokens. The default Zed invocation uses its `path:line:column` syntax; custom commands can substitute the tokens. Missing editor executables yield a concise actionable error and never make a build fail.
+
+### Autosave
+
+Autosave is enabled by default for named, dirty scene documents while a persistent Editor session is running, including headless MCP sessions. It waits 2 seconds after the last document revision change and saves through `AuthoringService::save`; rapid edits coalesce. A project-level `editor.autosave` Boolean in `project.faset.json` controls it, with a visible toggle in Project settings and a read-only `faset_autosave_status` command. Changing the toggle takes effect immediately in the current session and persists for the next open. `Ctrl+S` and `faset_document_save` remain immediate explicit saves. An unnamed scene is never assigned an implicit path: the UI says **Save As required**, and the existing recovery journal protects its edits.
+
+Autosave carries the document revision it observed into an optional `expected_revision` on the save API. A concurrent edit makes that save fail with `revision.conflict`, after which the newer revision is scheduled normally. Existing `disk_hash` comparison still rejects external modifications; autosave never silently overwrites them. A failed autosave leaves the document dirty and its journal intact, shows a persistent conflict/error with Save As or reload guidance, and does not log the same failure every frame. Another edit or an explicit retry permits a new attempt. Saving creates no Undo operation; Undo/Redo remain valid after autosave. Scene snapshots already captured for Play/export remain immutable. The recovery journal remains active even when autosave is disabled or before its timer expires.
+
+## Build cache and schema correctness
+
+The native build always runs CMake configure and Ninja/selected generator build. Those tools own source/header dependency analysis; a shortcut based only on `Session::source_signature()` is unsafe because that signature covers project `Scripts` but not engine sources, shaders, CMake recipes or toolchain changes. A no-op native build should do no compile or link work, but the UI must not call it a native cache hit merely because the later schema/package stage was reused.
+
+After a successful native build, `BuildService` computes a versioned package key from the selected configuration, normalized build recipe and configure arguments, `CMakeCache.txt` and toolchain identity, complete project `Scripts` content snapshot, Lua declaration/fingerprint, Player and SchemaExporter hashes, all required SPIR-V/reflection hashes, and copied runtime-library hashes. The toolchain identity includes resolved compiler/CMake/Slang executable identity or content hash; changing a toolchain in place must force the native tree to be reconfigured/rebuilt or make the service refuse reuse. Asset source files are not gameplay-build inputs.
+
+If the key matches the last successful immutable build, and every required file passes the stored manifest hash and schema validation, the service returns that generation with explicit `schema_cache_hit=true` and `generation_reused=true`. It skips SchemaExporter and package copying. A missing, malformed or corrupt cached file is never returned as a hit; the service attempts a fresh candidate or fails while retaining the prior pointer. A changed key runs SchemaExporter against the same captured Lua source snapshot, validates the complete schema, stages all files, rechecks the project source snapshot, then atomically publishes the new generation and pointer. Do not publish a mixed snapshot if any `Scripts` source changes during the build. Debug and Release have distinct keys and native trees. Export always revalidates referenced assets and packages their current generations even if gameplay build reuse succeeds; a stale asset must block export until reimport.
+
+`JobStatus` and `faset_job` expose the reused-generation flag, schema hit flag, elapsed phase times and final build fingerprint. Existing `result.directory`, `result.player`, `result.schema` and the last-good pointer remain compatible. Cache results must be understandable in the GUI and MCP without parsing logs.
+
+## Diagnostics and UI behavior
+
+The build service keeps its bounded raw log and adds a structured `diagnostics` array: `{severity, phase, message, file?, line?, column?, code?}`. The parser handles Clang/clang-cl and Lua source-location formats on Linux and Windows, including drive letters and Unicode paths. Project files are normalized to project-relative paths; outside-project diagnostics remain visible as text but cannot be passed to `faset_source_open`. ANSI escape sequences do not contaminate messages. Unrecognized output stays in the raw log; nonzero exit without a parsed error still creates a generic job failure rather than an empty error panel. Multiline notes remain associated with the triggering error where practical.
+
+The Console shows current and recent build jobs, counts by severity, phase, elapsed time, the first actionable error and expandable raw output. Selecting a diagnostic invokes the same `faset_source_open` command available to MCP. Disabled source actions explain why a location cannot be opened. The status bar distinguishes **Saved**, **Pending autosave**, **Saving**, **Save conflict**, **Save failed** and **Save As required**. Controls remain keyboard reachable, compact, high contrast and consistent with the Editor's dark theme. Layout and copy may evolve from the image reference as the actual controls are implemented.
+
+## Measurement and validation
+
+`tools/measure_workflows.py` retains disposable projects and machine-readable raw results. It records cold configure/build, warm unchanged build, changed C++ source/header build, build failure/recovery, Play-to-first-rendered-frame, Lua edit-to-successful-reload, and repeated Editor event-to-visible-state latency. Run at least five repetitions after a stated warm-up for warm/changed cases; retain each sample plus median and nearest-rank p95. Record exact revision and dirty state, OS, CPU, RAM, GPU/driver, compiler, CMake, Slang, build configuration, project/source hashes, scene size and whether validation/readback were enabled. Keep cold-start samples separate from warm samples; label offscreen first frame and windowed first presented frame separately using the Player's existing `startup_ms.main_to_first_frame` and `presentation_mode` profile fields. Include a larger generated scene/content case alongside the checked-in 2D/3D examples. Measurements are observations, not flaky CI timing gates.
+
+For the documented Linux reference host and exact two sample scenes, track the existing budgets: measured frame p95 ≤ 4 ms, GPU and readback p95 ≤ 1 ms each, simulation and snapshot p95 ≤ 0.5 ms each, explicit live Vulkan allocations ≤ 20 MiB, and startup from `main()` ≤ 500 ms. Run a 3,000-frame warm resource-lifecycle sample to check for growth. Report any missed budget honestly and investigate; do not claim the limits for other machines or content. Record a separate available Windows baseline, distinguishing software Vulkan from physical GPU. If physical Windows hardware is unavailable, mark that coverage unverified rather than blocking the functional Windows CI result.
+
+The Lua module must pass Linux and Windows native CPU suites; the watched/explicit reload integration must run under an available Vulkan device on both CI platforms; and a Lua-only Release export must validate and render after relocation with source project paths unavailable. Both Linux and Windows CI report exact test outcomes. Update the English Manual with C++/Lua iteration recipes, template selection, source editor setup, cache indicators, autosave/conflict recovery, and diagnostic navigation. Update `PLAN.md`, `docs/IMPLEMENTATION.md` and a dated validation dossier only after checks and measured evidence exist.
+
+## Acceptance matrix
+
+| Area | Required evidence |
+| --- | --- |
+| Lua | Existing lifecycle/safety/CLI suites pass on Linux and Windows; watched/explicit reload and relocated Lua-only Release export render on available Vulkan implementations. |
+| Cache | Second unchanged build reuses the same verified schema/package generation and does not invoke SchemaExporter; header, Lua, recipe/toolchain, shader or runtime output changes invalidate appropriately; corrupt entries never become hits. |
+| Rollback | Failed compile/schema/copy and source-race cases leave the previous successful pointer and Inspector schema available but stale; export still rejects stale assets. |
+| Diagnostics | Clang, clang-cl, Lua, Unicode path, drive-letter and unparseable-output fixtures pass; real C++ compile failure produces a navigable diagnostic and raw log. |
+| Templates/navigation | All four new-project combinations launch or validate, old CLI/scaffold defaults still work, existing files are not overwritten, source-open rejects traversal and opens project code at the requested position. |
+| Autosave | Named scene saves after idle, rapid edits coalesce, unnamed scene remains in recovery, disk/revision conflicts never overwrite, Undo and Play snapshot remain stable; GUI and MCP show status. |
+| Iteration | Raw repeated cold/warm/changed/Play/Lua/UI samples and environment metadata are committed; claims are limited to measured scenes/hosts; reference budgets and any misses are shown. |
+| Documentation | Strict MkDocs build and compiled tutorial tests pass; Manual, `PLAN.md` and validation dossier describe observed behavior and known coverage gaps. |
+
+## Delivery sequence
+
+Deliver safe cache keys and source snapshots first, then diagnostics/navigation, templates and autosave as independently testable slices. Finish with cross-platform Lua/export validation, repeated measurements, documentation and independent review. Each slice uses a failing contract test before implementation and a focused passing suite before its commit. The final P1 status is only marked complete when the acceptance matrix has linked evidence; unavailable physical Windows GPU or benchmark hardware is recorded as a coverage limit, not silently treated as passed.

docs/superpowers/specs/2026-09-24-p3-lighting-design.md

@@ -0,0 +1,51 @@
+# P3 lighting and shadows design
+
+This design implements the lighting and shadow portion of [PLAN P3](../../../PLAN.md#p3-освещение-тени-и-temporal-reconstruction) for desktop 3D games. Temporal reconstruction has a separate design and implementation plan. The P2 Direct, GPU frustum, and GPU occlusion paths must shade the same scene from the same immutable snapshot. Ordered sprites, editor UI, and 2D presentation remain unlit unless a later 2D-lighting project explicitly changes them.
+
+## Existing behavior and target
+
+`Snapshot` currently carries one `light_direction`; `SceneView::build` overwrites it for each `faset.light`, without using the authored color or intensity. `fragmentMain` evaluates one hard-coded directional BRDF and samples one 1024² D32 shadow map. Its shadow matrix covers a fixed world-origin orthographic box. The shadow pass renders all `cast_shadow` meshes through CPU-transformed geometry even when P2 GPU visibility is selected; it is independent of the camera visibility decision. The compiled `gpuShadowMain` is not used by the current pass. These facts make multiple authored lights, large camera movement, and explicit shadow budgets impossible without changing the scene and shader contracts.
+
+P3 supplies one sun plus point and spot lights, camera-fitted cascaded sun shadows, a bounded local shadow atlas, and independent per-shadow-view caster selection. Authored values reach exported Player games and the editor preview through the existing scene schema. A scene with no light component retains the previous default sun appearance. Lighting is accumulated in linear space before the current tone mapping; the legacy directional factor is preserved for the default so existing unlit UI and basic rendering tests remain meaningful. Artist-facing intensity is unitless in this stage; photometric units and IES profiles are outside P3.
+
+## Scene contract and validation
+
+Keep `faset.light` at builtin schema version 1 and add optional fields with defaults: `kind` (`directional`, `point`, `spot`, default `directional`), `enabled` (true), `color` (white), `intensity` (1, nonnegative), `range` (10, positive, for local lights), `inner_angle` (0.35 radians), `outer_angle` (0.70 radians, strictly below π/2), `casts_shadow` (true), and `shadow_priority` (integer 0). Existing fields and component IDs remain valid. Cross-field validation requires `0 <= inner_angle <= outer_angle`; local range, color channels, intensity, transforms, and cone directions must be finite. Invalid authored values return a diagnostic with entity and field rather than nonfinite GPU data. Missing new fields use the schema defaults.
+
+`Snapshot` retains `light_direction` for existing direct-render clients. Add an optional `SunLight`, a vector of `LocalLight`, and an optional explicit `CameraFrustum` containing unjittered view/projection matrices, near/far distances, and projection kind. `SceneView` populates these from the authoring scene. Each light carries the stable entity/component identity, transformed position or normalized direction, color, intensity, range, cone angles, and shadow options. The first enabled directional light by stable ID is the sun; extra directionals produce a visible diagnostic until a later multi-sun design exists. If there is no authored directional light, the renderer synthesizes the legacy sun from `Snapshot::light_direction`. Local lights are ordered by stable ID to prevent reordering from changing atlas allocation or results. Point attenuation tends smoothly to zero at `range`; a spot multiplies it by a smooth inner-to-outer cone factor. The shader handles zero distance and invalid normals without NaN output.
+
+Explicit camera frustum data is required for four cascades. If a low-level caller supplies only the legacy `view_projection`, the renderer uses one bounded legacy-compatible sun shadow view and reports `effective_sun_cascades = 1`; it never silently claims CSM. 2D sprite-only snapshots do not incur shadow work. The future temporal stage may jitter the main raster projection, but the shadow planner consumes the unjittered `CameraFrustum` exclusively.
+
+## Graphics shader ABI and ownership
+
+Preserve material descriptor **set 0** and its four bindings: sampled sun depth image at binding 0 (formerly the single shadow map), shadow sampler at 1, color image at 2, color sampler at 3. Add frame lighting descriptor **set 1** with a `StructuredBuffer` of a versioned, 16-byte-lane lighting header and local-light records plus one sampled 2D local depth atlas. Both the Direct pipeline and P2 GPU graphics pipeline bind this frame set; their fragment stage remains `fragmentMain` in `shaders/baseline.slang`. Move the P2 GPU vertex scene bindings (instance, visible-ID, view buffers) from set 1 to **set 2** in `shaders/gpu_scene.slang`, the Vulkan graphics layout, and the exact reflection validator. P2 cull and HZB compute bindings stay in their current set 0. Baseline graphics push constants remain 96 bytes and P2 graphics push constants remain 112 bytes, under the Vulkan 1.3 guaranteed 128-byte minimum. The shadow vertex entry can continue to read a per-view matrix through the existing push block, so no new shader entry is required for atlas rasterization.
+
+Host and Slang structs have named offsets, strides, static assertions, and reflection checks. Keep the SPIR-V + normalized Faset reflection package as the runtime boundary; `slangc` remains a build dependency, not a Player dependency. Existing shader-reload behavior must preserve working pipelines when an incompatible or invalid bundle is offered. Update the package validator and export checks whenever an entry or layout changes. Lighting buffers are renderer-owned per frame and never expose Vulkan types to authoring, gameplay, or MCP.
+
+## Sun cascades and atlas
+
+Use four practical-split cascades between the camera near plane and `min(camera far, 80 world units)` with λ = 0.5. Bound each receiver frustum slice by a stable square extent derived from its enclosing sphere in sun-light space; snap the XY projection center to its effective texel grid so small camera movement does not shimmer. The sun atlas is one 2048² D32 image with four 1024² tiles, including a two-texel guard inside each tile. Its C++/shader metadata contains each light VP, split end, atlas scale/offset, effective UV clamp, and bias. Select the cascade by unjittered view depth and blend over the final 5% of a split to avoid a hard line. Three-by-three PCF samples clamp to that tile's guarded interior. Atlas rendering clears each tile independently and samples it only after the whole atlas transitions from depth attachment to depth read-only. The split/fitting, atlas, blend, PCF guard, and depth-bias considerations follow Microsoft's [CSM technical article](https://learn.microsoft.com/en-us/windows/win32/dxtecharts/cascaded-shadow-maps) and [shadow depth-map guidance](https://github.com/MicrosoftDocs/win32/blob/docs/desktop-src/DxTechArts/common-techniques-to-improve-shadow-depth-maps.md); Faset's actual implementation remains Vulkan-native.
+
+The receiver frustum determines a cascade's XY footprint, but casters upstream of the camera slice still matter. Build shadow-view visibility from world-space caster bounds, never the main camera's P2 visible IDs. Extend the light-space depth interval conservatively over all cast-shadow bounds overlapping the cascade's XY footprint, then test candidates against that resulting view. Do not truncate this interval by the main camera far plane. Shadow geometry uses source LOD 0 initially, independent of the main camera's selected mesh LOD; a measured shadow-LOD policy can follow later.
+
+## Local shadows and budgets
+
+The local atlas is a separate 2048² D32 image with sixteen 512² guarded tiles. A spot light uses one perspective shadow view; a point light uses six 90° face views and receives all six tiles or none. A shadow tile stores its owner stable ID/face and generation. Rank candidate shadowed lights by authored `shadow_priority`, then projected influence, then stable ID; keep allocations stable while their owners remain eligible. Lower-priority lights that do not fit still illuminate the scene without shadowing, with an explicit reason/counter. No partial point-light shadow cubemap is allowed.
+
+At most 128 local lights are submitted to the shader per view; select them deterministically by priority/influence if more exist and report the count of omitted lights. At most 16 local shadow faces and 4096 caster draws per frame are scheduled. Shadow views are atomic for draw budgeting: if all casters for a view do not fit, skip that view and treat its contribution as unshadowed. Sun cascades are considered nearest first; local views follow by priority. The policy exposes requested and effective counts. If the nearest cascade itself exceeds the draw budget, it becomes unshadowed rather than emitting an incomplete shadow. No skipped tile is sampled. Atlas allocation is capped at 32 MiB of D32 image payload for both atlases, excluding Vulkan alignment/driver overhead; actual allocation bytes remain visible in `FrameStats`.
+
+Check D32 sampled/depth-attachment support, 2048² image extent, relevant sampled-image/storage-buffer limits, and allocation results before enabling the corresponding shadow feature. If the 2048² profile is unavailable, try a 1024² profile with four 512² sun tiles and sixteen 256² local tiles. If neither profile is available, keep direct lighting and explicitly report shadows unavailable. A failed optional atlas must not silently disable local illumination or crash a scene that previously rendered. Maintain explicit Vulkan transitions and barriers; the current `RenderGraph` validates ordering but does not synthesize barriers. One `ShadowAtlases` graph pass may loop over tile rendering instances because graph pass names must be unique.
+
+Every scheduled view records why it was redrawn (first use, light/camera/caster change, atlas reassignment, or conservative every-frame update), its caster count, tile, and GPU time. Caching is optional in this stage: reporting an every-frame update is preferable to reusing stale depth. If caching is introduced, an uncertain caster revision forces a redraw. Camera cuts, resolution changes, light deletion, and slot reuse invalidate relevant assignments and histories.
+
+## Forward+ measurement gate and diagnostics
+
+Start with a correct bounded loop over local lights in the fragment shader. Benchmark fixed 1080p scenes with 0, 4, 16, 32, 64, and 128 visible local lights in Release, with shadows separately disabled and enabled. Retain raw per-frame CSV, driver/GPU/commit/configuration, warm-up and three repeated runs, median and p95 of main raster, shadow passes, full GPU command span, and capture/readback CPU time. The current full framebuffer readback is synchronous, so its CPU cost is not attributed to light shading. If 32 or more lights add at least 1.0 ms median to main raster or at least 15% of the light-free GPU frame on the Linux reference GPU, add tiled Forward+; otherwise record why the simple path remains default and keep the measurement harness for later hardware. A conservative, depth-free 16×16 screen-tile list built from projected light volumes is sufficient for the first measured optimization; it does not require a depth prepass before the existing forward pass. No light may disappear on list overflow: the fragment path checks an overflow flag and scans the full submitted-light list for that tile. Measure the sum of list construction and raster, not the raster pass alone, before enabling tiled mode by default.
+
+`FrameStats`, Player diagnostics, and the editor debug overlay expose requested/effective sun cascades, visible and omitted local lights, scheduled/dropped shadow faces and reasons, atlas occupancy and allocated bytes, caster draws, shadow GPU time, and the active lighting path. Counters remain diagnostic-only; they do not require GPU readback for scheduling. Shadow atlas thumbnails may be added to developer diagnostics but are not a prerequisite for functional lighting.
+
+## Acceptance and integration boundaries
+
+CPU tests cover schema defaults/invalid fields, stable extraction from reordered entities, shadow-view math, cascade split/texel snap, offscreen casters, deterministic atlas allocation and face/draw capacity, point-light all-or-none behavior, and fallback capability policy. GPU image tests cover point distance, spot cone, color/intensity, sun cascade boundaries, caster movement, camera translation/cut/resize, point seams and atlas tile isolation, overflow as unshadowed light, and Direct vs P2 frustum/occlusion equivalence. Shader reflection, hot reload, exported Player shader contents, and Vulkan validation are exercised on Linux physical GPU and pinned Linux SwiftShader; Windows native build, GPU-labeled CI tests, and relocated exported Player examples run on pinned Windows SwiftShader. A physical Windows GPU is reported only if actually tested. The manual documents light properties, budgets, expected fallbacks, and script/editor examples. Acceptance records commit, hardware/driver, raw benchmark data, tests, known limitations, and links from `PLAN.md` without claiming universal speedups.
+
+Temporal reconstruction owns previous transforms, velocity targets, jitter, history rejection, TAA, and upscaling. Lighting owns only stable unjittered shadow views and direct-light data. The shared files `renderer.hpp`, `renderer.cpp`, and `baseline.slang` need sequenced integration or an agreed ABI commit before concurrent feature work; temporal code must not repurpose the lighting descriptors or shadow camera metadata.

docs/superpowers/specs/2026-09-24-p3-temporal-design.md

@@ -0,0 +1,59 @@
+# P3 temporal reconstruction design
+
+This design implements the temporal half of [PLAN P3](../../../PLAN.md#p3-освещение-тени-и-temporal-reconstruction) for Linux and Windows desktop games. The outcome is a selectable, observable 1:1 TAA path followed by a lower-internal-resolution temporal upscaler. The existing Direct renderer without temporal processing remains the reference and the default. P3 lighting and shadow work has its own design and can change the scene shader's lighting inputs without changing the temporal pass contract.
+
+Temporal renderer and shader integration starts **after** the lighting plan's Task 2 checkpoint commit, `Share typed multi-light shading across Direct and GPU paths`. That commit establishes material descriptor set 0, frame-lighting set 1, and GPU graphics scene set 2; GPU cull/HZB compute descriptors remain in set 0. Temporal graphics variants consume the same material and lighting sets as `fragmentMain`, add prior-transform reads only from the GPU scene set 2, and leave the 96-byte Direct and 112-byte GPU graphics push constants intact. Temporal resolve/composite use their own checked pipeline layouts. The shared reflection and hot-reload validator must accept the combined ABI, not reconstruct the pre-lighting set 1 layout.
+
+## Boundaries and modes
+
+`RendererConfig` selects `TemporalMode::Off`, `TAA`, or `Upscale`; `Upscale` also specifies an internal render scale in `[0.5, 1)`. TAA uses scale `1`. A runtime setter lets Editor and Player select the same modes without changing scene authoring files. Requested and effective modes are recorded separately: unsupported compute/format/extent capabilities produce an explicit `Off` fallback and a readable reason. Invalid scale is rejected as configuration input, rather than silently clamped. An exported Player contains cooked SPIR-V and reflection; Slang is not needed at runtime. Temporal processing is renderer-side and adds no live-game MCP endpoint.
+
+The output extent remains `Renderer::width()/height()`, the swapchain/capture extent and the pixel coordinate system of UI. At scale below one, opaque and world-space raster targets use an internal extent, with integer rounding made deterministic. `Snapshot::scene_rect` remains in output pixels; it is converted once to the internal viewport. Camera aspect and projection remain those of the output scene rectangle. Shadow map dimensions and light-space matrices never depend on render scale. HZB dimensions, viewport metadata, culling projection, and post-cull depth refer to the actual internal scene target.
+
+## Frame data and history ownership
+
+The caller supplies an **unjittered** `Snapshot::view_projection` and `projection`. Picking, gizmos, and authoring coordinates continue using them. The renderer chooses a deterministic Halton(2,3) subpixel offset, applies it only to the scene raster clip transform, and retains both current and previous jittered view-projection matrices. The offset is measured in internal scene pixels and enters clip space as `clip.xy += 2 * jitter / internalViewportSize * clip.w`; the sign is verified by an image/motion test for the Vulkan viewport convention. Culling and HZB projections must match the jittered geometry they test, with conservative edge handling. `Snapshot::camera_cut` is authoritative; a large discontinuity in camera position/orientation also rejects history when a caller fails to mark a teleport.
+
+`InstanceTracker` already records `previous_model`, world bounds, a stable slot/generation, mesh identity and rendered-frame completion. That state becomes available to both Direct and GPU paths. HZB history and temporal color history have **independent** validity decisions; absence of HZB or a Direct visibility mode cannot invalidate an otherwise valid TAA history. Mesh/LOD replacement, reused slot, an anonymous draw, camera cut and changed view make that instance's velocity invalid. GPU `InstanceRecord` gains a previous model matrix while keeping the existing stable slot/generation lanes. The `metadata.x` low bit remains the HZB eligibility bit and a distinct bit marks temporal previous-transform eligibility; culling tests only the HZB bit. Dense candidate indices remain frame-local addresses, not temporal identities.
+
+Temporal color/depth history is renderer-owned and double-buffered at **output resolution**. Each completed render commits one frame. A pending failed render must not promote history. The current active view may reuse history only if the previous frame has the same `view_id`, output/internal extents, scene rectangle, unjittered projection, temporal mode/scale, and compatible shader generation, and is not a cut. Switching among views safely resets history; retaining multiple cached histories is not required. Resize, shader reload, mode or scale change, and camera discontinuity reset it explicitly. The first valid frame uses current color only. The reset reason and whether a previous history was actually used are visible in `FrameStats` and Editor diagnostics.
+
+## Motion and reconstruction signal
+
+Both opaque mesh paths write the same per-pixel motion contract:
+
+- Direct path: the CPU-transformed vertex carries current clip position, prior clip position computed from `InstanceUpdate::previous_model` and prior jittered view-projection, plus a validity flag. The existing Off vertex format/shader remains a compatible path.
+- GPU path: the vertex shader reads current/previous model matrices from the instance record and current/previous jittered view-projections from the view record. It emits current and prior clip coordinates plus validity. Both Main and Post raster use this contract.
+- The scene fragment writes display-UV motion (`currentUV - previousUV`), expected depth in the previous projection, and validity/reactive state to a sampled floating-point MRT. A missing prior transform, invalid clip `w`, nonfinite projection, or non-opaque/reactive fragment marks motion invalid. UI never contributes motion. UVs are local to the scene rectangle so internal and output extents map consistently.
+
+The scene image remains the current renderer's display-referred LDR shading for this stage. History uses a higher-precision floating-point color image so repeated accumulation does not quantize to 8 bits; the final composite writes the existing `R8G8B8A8_UNORM` output exactly once. There is no exposure adaptation or HDR claim in this temporal implementation. P3 lighting may later move scene shading to linear HDR behind the same `sceneColor/depth/velocity -> resolvedColor` boundary.
+
+The signal checklist is informed by [AMD's FSR 2 integration guide](https://github.com/GPUOpen-Effects/FidelityFX-FSR2/blob/master/README.md#input-resources): it describes current color, depth, motion and reactive data, and explicit reset on camera cuts. Faset implements its own resolver and does not link FSR 2. Faset's **current-minus-previous local UV** motion sign and jitter-inclusive convention are its own contract; an FSR 2 adapter would have to convert to that API's documented motion and jitter conventions. [NVIDIA's Adaptive TAA paper](https://research.nvidia.com/publication/2018-08_adaptive-temporal-antialiasing) identifies blur and ghosting as temporal failure modes, which motivates the moving-image acceptance tests here; its adaptive ray-tracing algorithm is not part of this design.
+
+The 1:1 TAA resolve samples current color/depth/velocity, dilates motion from the nearest depth in a 3×3 neighborhood at silhouettes, and computes `previousUV = currentUV - motion`. It rejects history when view history or fragment motion is invalid, coordinates leave the previous scene rectangle, or previous expected depth disagrees with sampled history depth beyond a depth-aware tolerance. Surviving history color is clipped to a current-color 3×3 neighborhood and blended with a bounded weight reduced by motion and reactive content. A newly exposed background pixel must use current color immediately; it may accumulate normally on following frames. The resolve writes color and depth to the next output-resolution history image. Sky/clear pixels use current color when reliable reprojection is unavailable.
+
+`Upscale` reuses this validated resolve but samples current color/depth/velocity from a lower internal extent. It reconstructs the current signal at output-pixel positions, keeps output-resolution history, and uses the same rejection/dilation and first-frame spatial fallback. Switching render scale resets history. TAA must pass its moving-image tests before upscaling is enabled or described as complete; this path is a small, measured temporal upscaler, not a promise of Unreal TSR quality.
+
+## Render graph and scene/UI split
+
+The temporal path adds internal `sceneColor`, `sceneDepth`, and `sceneVelocity` targets while retaining `color` as the full-resolution final image used by Readback and Presentation. Existing Off rendering and its one-target shader remain available. The temporal graph orders passes as follows:
+
+1. ShadowMap and optional P2 MainCull.
+2. Main scene raster clears scene color/depth/velocity and renders opaque meshes. Optional P2 BuildCurrentHZB and PostCull run from this scene depth, then PostRaster loads all three scene attachments and finishes deferred opaque meshes.
+3. World transparency and sprites render against the same internal scene depth before resolve. Pixels they blend into color mark their velocity/reactive value invalid, so stale opaque history cannot leak through moving translucent content. They do not acquire synthetic rigid-mesh motion. The existing ordering and depth behavior are retained.
+4. TemporalResolve reads the completed scene image/depth/velocity and previous history, writes the next color/depth history. TemporalComposite maps that resolved scene to the full-size `color` target.
+5. A separate output-resolution UI pass renders quads, text, gizmo overlays and Editor chrome on `color`, without jitter or TAA. Readback and Presentation then consume `color` as before.
+
+Only the temporal-enabled branch needs new scene targets and a second color attachment in opaque pipelines. A one-target UI pipeline remains valid. `RenderGraph` validates ordering by names; Vulkan layout transitions and compute→sampled/attachment barriers are recorded explicitly. The renderer's single queue, fence-per-frame model makes history lifetime simple but its synchronous capture/readback cost remains part of full-frame timings. The present 12-slot GPU timestamp pool must grow enough to time every new pass instead of silently omitting the end of the graph.
+
+## Shader package, controls and fallback
+
+Temporal vertex/fragment, resolve and composite entry points have validated reflection, SPIR-V hash, descriptor types and record strides. Adding `previousModel` changes the GPU instance stride; the C++ static assertion, Slang record, reflection validator and GPU tests change together. Baseline Off shaders retain their existing entry points and layout fingerprints. Shader reload replaces a **complete** compatible temporal pipeline set atomically or preserves the working set; successful reload invalidates color history. BuildService copies every temporal `.spv` and `.reflection.json` into Linux/Windows exports and validates a relocated Player without Slang installed.
+
+Editor diagnostics expose mode, scale, effective mode/fallback, internal extent, jitter, history accepted/reset reason, reject statistics when requested, GPU temporal pass time and memory. Player profiling records these same fields per frame. GPU readback for per-pixel diagnostics is optional and never required for the normal resolve. If temporal resources cannot be created on a supported Vulkan 1.3 device, the actual mode is `Off`, the frame still renders by the existing path, and the reason is reported. A failed temporal shader reload keeps the prior pipelines and does not corrupt history or change the visible mode.
+
+## Acceptance
+
+Deterministic headless GPU sequences run for Direct, GPU frustum and GPU occlusion where supported. They cover static thin diagonals/wires at subpixel positions, slow camera pan, a moving rigid object, a doorway disocclusion, an explicit camera cut and unmarked teleport, projection/view/scene-rectangle/resize/mode/scale changes, anonymous and mesh-replaced instances, world transparency, sprites and pixel-exact UI. Tests compare current frames to `Off` and a high-resolution spatial reference, with fixed tolerance and documented image metrics rather than requiring bit-identical output across drivers. They assert zero Vulkan validation errors where the layer is present, no reappearance of old color after cut/reveal, correct actual mode and reset reason, and no UI softening. A clean fallback is exercised on a deliberately unsupported capability fixture.
+
+Run CPU policy tests, reflection/package/tamper tests, Linux validation on physical GPU and software Vulkan, Windows software Vulkan CI and native builds, and relocated 2D/3D Player captures. Record the exact revision, driver/GPU, build mode, internal/output resolutions, temporal and full-frame GPU/CPU costs, memory, image differences, and limitations. These results gate any claim that TAA/upscaling improves image quality or frame time in a particular scene.

docs/validation/README.md

@@ -3,6 +3,9 @@
 These files preserve bounded checks and their inputs. Each record states its source revision or working-tree limitation; a passing record does not certify later commits or every supported platform.
 
 - [MVP acceptance dossier](mvp-acceptance.md): criterion-by-criterion closure, tested revisions and remaining compatibility coverage.
+- [P1 gameplay iteration](p1-iteration-2026-09-24/README.md): repeatable Debug C++/Lua workflow, raw samples, toolchain provenance, real compiler navigation and coverage limits.
+- [P2 GPU visibility Linux evidence](p2-gpu-visibility-2026-09-23/README.md): Debug/Release GPU acceptance, lavapipe functional checks, relocated Player exports, and explicit platform/performance limits.
+- [P2 pinned SwiftShader compatibility](p2-swiftshader-2026-09-23/README.md): the Windows CI regression, shader capability fix, independent review closure, final native CI and relocated Player evidence.
 - [Windows software Vulkan](windows-software-vulkan-2026-09-18/README.md): fresh native build, 35 tests, launcher/window/MCP workflows and both relocated Release games on SwiftShader.
 - [Checkpoint 5 Linux acceptance](checkpoint5-linux-2026-09-18/README.md): clean offline source build, first Editor launch, exact-candidate standalone games and live Blender checks.
 - [Final Linux source checks](final-linux-2026-09-18/README.md): `4cb8255` integrated test results and both Release games after the asset-relocation correction, including package manifests and standalone captures.

docs/validation/lua-module.md

@@ -0,0 +1,72 @@
+# Lua module validation
+
+Local implementation checks, 2026-09-18. These results supplement, not replace,
+the earlier MVP acceptance record. Toolchain: Linux x86-64, GCC 13.3, CMake 4.4.3,
+Ninja 1.13.2; pinned Lua 5.4.9.
+
+## Observed results
+
+| Configuration | Result |
+|---|---|
+| Lua enabled, renderer/editor UI disabled | 20/20 CTest tests passed |
+| Lua disabled, renderer/editor UI disabled | 18/18 CTest tests passed |
+| AddressSanitizer + UndefinedBehaviorSanitizer, Lua suites | 3/3 tests passed |
+| Renderer-linked native Player and SchemaExporter | Built successfully; CPU Lua CLI contracts passed |
+| Lua-only project without project C++ files | Empty native adapter built; sample validated; exactly two Lua schemas exported |
+| Native Editor and Editor UI library | Compiled and linked; Editor `--help` ran |
+| Manual | MkDocs strict build passed |
+
+The Lua tests exercise lifecycle ordering, per-instance fields/state, VM ownership,
+stale/cross-world handles, deferred structural operations, native physics contacts,
+`require`, invalid schemas, CPU/memory limits and the shipped example scene. Additional
+safety cases cover deep/cyclic JSON, repeated-string/key expansion, structural queue
+limits, protected metatables, repeated OOM and reclamation of a failing instance.
+
+BuildService tests exercise source snapshots, fingerprints, changes during a build,
+Lua-only projects, export contents/notices, and switching back to Lua-free games.
+Their native build/export fixture is a stand-in, not a graphical Player execution.
+
+## Reproduce the CPU suite
+
+```sh
+cmake -S . -B build/lua-check -G Ninja -DCMAKE_BUILD_TYPE=Debug \
+  -DFASET_ENABLE_LUA=ON -DFASET_BUILD_RENDERER=OFF -DFASET_BUILD_EDITOR=OFF
+cmake --build build/lua-check --parallel
+ctest --test-dir build/lua-check --output-on-failure
+```
+
+Use a separate build directory with `-DFASET_ENABLE_LUA=OFF` for the optional-module
+check. For sanitizers, configure with `-DFASET_SANITIZERS=ON`, build the
+`faset_lua_tests`, `faset_lua_safety_tests`, and `faset_schema_exporter` targets, then
+run `ctest --test-dir <build> --output-on-failure -R '^lua_'`.
+
+## Not verified in the September 18 run
+
+- Windows compilation or execution of the new module.
+- Graphical/window interaction and real-time Lua reload in a running rendered game.
+  `lua_player_reload` is provided as a GPU-labelled integration test for an equipped host.
+- A complete real Release export launched on a separate machine.
+- LeakSanitizer: this execution environment uses tracing incompatible with its
+  process inspection, so sanitizer runs used `ASAN_OPTIONS=detect_leaks=0` and
+  `UBSAN_OPTIONS=halt_on_error=1`. Address/undefined-behavior checks stayed enabled.
+
+The renderer-linked CPU checks used the existing Vulkan loader, repo-pinned Vulkan
+headers and cached Slang, with SDL X11/Wayland disabled. No system graphics packages
+were installed. This proves linkage and CPU validation, not graphics compatibility.
+
+## September 24 Release follow-up
+
+The [Release execution record](lua-release-2026-09-24/README.md) closes the
+Linux offscreen export gap above. At source commit `4331857`, a Release Editor
+exported the checked-in Lua-only sample into a disposable Unicode-path project.
+The package was relocated, the source project path was hidden, and its Player
+validated and rendered 120 frames on an NVIDIA GeForce RTX 2080 Ti with driver
+595.84 and Khronos validation enabled; zero validation errors were reported.
+The package manifest has `lua_enabled: true`, declared Lua source and its license,
+and no project C++ gameplay source. The five focused Release Lua/schema tests
+passed. This verifies an offscreen run on Linux; a separate physical Windows GPU
+and manual window interaction have not been tested by this record. Windows
+SwiftShader execution is configured in CI and needs a passing run before it is
+claimed as covered.
+
+![Relocated Lua sample after 120 frames](lua-release-2026-09-24/lua.png)

docs/validation/lua-release-2026-09-24/README.md

@@ -0,0 +1,58 @@
+# Lua-only Release game: relocated execution
+
+This is a local Linux result for source revision
+`433185717e1f324acb6eaf186818589d11697453` on 2026-09-24. The
+[machine-readable report](report.json) records the exact source input hashes,
+Release package, Editor binary hash, command arguments and elapsed times. The
+Editor itself was built with the `linux-release` preset. The exported Player
+and package also identify their configuration as Release.
+
+| Check | Observed result |
+|---|---|
+| Disposable source | `examples/lua` copied to a Unicode-path temporary project outside the engine tree |
+| Package | `lua_enabled: true`; 32 hash-checked files, including Lua gameplay source and `Notices/lua/LICENSE.txt`; no project `Gameplay.cpp` or `.hpp` |
+| Relocation | Generation copied outside the project/engine; original project path hidden before Player launch |
+| CPU validation | Packaged Player `--validate` succeeded from an unrelated empty working directory |
+| GPU execution | 120/120 headless 1280×720 frames, 0 validation errors |
+| Device | NVIDIA GeForce RTX 2080 Ti; proprietary driver 595.84, Vulkan 1.4.329; selected-device details in the report and [Vulkan probe](vulkaninfo-summary.txt) |
+| Image | Four expected scene colors, including cyan player and gold collectible; raw [PPM](lua.ppm) SHA-256 `e2f4c3b84de75dadd2e31d388d0ba51abc1861f1ec76eb7ba51a4a2dcac720a7` |
+| Focused Release CTest | 5/5: `lua_contracts`, `lua_safety_contracts`, `lua_cli_contracts`, `lua_player_reload`, `build_schema_publication` |
+
+The [manifest](lua-manifest.json) binds the package file checksums. The
+[Player profile](lua-profile.json) contains all 120 per-frame samples and
+resource/timing definitions; the [validate](lua-validate.json),
+[render](lua-run.json) and [export](lua-export.json) logs retain raw process
+results. The [PNG preview](lua.png) is a lossless conversion of the checked
+PPM.
+
+The verifier also confirmed a clean Git source tree, rejected undeclared
+package files and unexpected C++ script files, classified the selected device
+as physical, and found the sample Lua `on_start` log in the relocated run.
+
+To repeat this check from a built checkout, choose a **new, empty** output
+directory:
+
+```sh
+cmake --preset linux-release
+cmake --build --preset linux-release --target faset_editor --parallel 4
+python3 tools/verify_playable_exports.py --editor build/linux-release/faset_editor \
+  --output .cache/lua-release-check --only-lua
+cmake --build --preset linux-release --target faset_player faset_schema_exporter \
+  faset_lua_tests faset_lua_safety_tests faset_build_schema_tests --parallel 4
+ctest --test-dir build/linux-release --no-tests=error --output-on-failure \
+  -R '^(lua_contracts|lua_safety_contracts|lua_cli_contracts|lua_player_reload|build_schema_publication)$'
+```
+
+The render used the Player's synthetic fixed timestep and offscreen Vulkan
+presentation. It does not establish manual window interaction or physical
+Windows GPU compatibility. The separate
+[Windows graphics run at `4ac02ee`](https://github.com/emil28092005/Faset_Engine/actions/runs/35937433040)
+passed 61/61 CTests and relocated all three Release games under pinned SwiftShader.
+The Lua-only package validated and completed 120 offscreen frames with its source
+project paths hidden. Its device is a **software** Vulkan implementation; the
+Khronos validation layer was not active on that Windows worker. The
+[P1 dossier's Windows report](../p1-iteration-2026-09-24/windows-4ac02ee/playable-report.json)
+retains the source/package identities and result. This does not establish
+physical Windows GPU compatibility.
+
+![Lua game rendered by the relocated Release Player](lua.png)

docs/validation/lua-release-2026-09-24/lua-manifest.json

@@ -0,0 +1,220 @@
+{
+  "asset_generations": {},
+  "build_fingerprint": "b745490f85f05987d849f6bb6f4d06953883f4b8e10c5551fadf164c7eec5857",
+  "configuration": "Release",
+  "executable": "faset_player",
+  "files": [
+    {
+      "path": "README.txt",
+      "sha256": "82bf72bc542643f6c4090e0a5de69b0014ca3fa17c6f9dfb12cc41e44c8b8db6",
+      "size": 262
+    },
+    {
+      "path": "Notices/Faset-NOTICE.txt",
+      "sha256": "30c2e7e80f5153b31ab57675e07246aef9165965d64e36022b426a26449ece3f",
+      "size": 204
+    },
+    {
+      "path": "Notices/dependencies.json",
+      "sha256": "262e8f63cf21c516829b1fedb0900ac90e76d62aa8f78d9ad02d8f24e0359e74",
+      "size": 2468
+    },
+    {
+      "path": "Notices/lua/LICENSE.txt",
+      "sha256": "e42d195c77d3ad7255ee9c874772d3c53998e7f60f9acf453d4630fa161e0bfe",
+      "size": 1126
+    },
+    {
+      "path": "Notices/stb/LICENSE",
+      "sha256": "bebfe904b14301657e4e5d655c811d51fd31b97c455b9cc2d8600d6bac6cff63",
+      "size": 2510
+    },
+    {
+      "path": "Notices/json/LICENSE.MIT",
+      "sha256": "46a65cffd1ea955132d95a8dd921640714a8d6b537d2e4e482d31145ae95b603",
+      "size": 1076
+    },
+    {
+      "path": "Notices/box3d/LICENSE",
+      "sha256": "da5e31a26bf3cfd5ba5c96d6823e480128c81e76c107ef9d3ee5d94789184b90",
+      "size": 1067
+    },
+    {
+      "path": "Notices/box2d/LICENSE",
+      "sha256": "68a3e676d7e94093b102d5cba0d4e04af812040d6f230c3db67a6664574e43d2",
+      "size": 1067
+    },
+    {
+      "path": "Notices/entt/LICENSE",
+      "sha256": "0785027ce472d7c61f05fba664a1d3ba6639c1593ced351ad9e4bed868765d99",
+      "size": 1097
+    },
+    {
+      "path": "Notices/sdl3/LICENSE.txt",
+      "sha256": "97f35b302b361680ec1e891e95d2d52097bb95abff361434916d99dc1305f127",
+      "size": 884
+    },
+    {
+      "path": "shaders/gpuPostCullMain.reflection.json",
+      "sha256": "eed140bbe09c7d14935b688c770261ac0e81677c0974aa811c88ed67ea779b95",
+      "size": 3591
+    },
+    {
+      "path": "shaders/gpuHzbMain.reflection.json",
+      "sha256": "589818f670881c64f3aba726ee3bc82fe4b9d835a347f99134e0e157dc4a112e",
+      "size": 2050
+    },
+    {
+      "path": "shaders/gpuCullMain.reflection.json",
+      "sha256": "996fe5c7e31c6b8f316d8f290b3be0ae7063eb46c500a661e8715e9b822a2598",
+      "size": 3587
+    },
+    {
+      "path": "shaders/gpuShadowMain.reflection.json",
+      "sha256": "9a03a2b692d2b0c758f63fb27760352cfef20a068372ebc137f1ca1797dcd3c2",
+      "size": 2755
+    },
+    {
+      "path": "shaders/gpuVertexMain.reflection.json",
+      "sha256": "9f43472c267dbb6a2ddc69e252f7f00c5ca46f376d3c7c27165c8d12a175179d",
+      "size": 3098
+    },
+    {
+      "path": "shaders/gpuPostCullMain.spv",
+      "sha256": "62cb72e356346e1511c6d640a3cecb4a6e5283795338299b357edae5f7f52be4",
+      "size": 12460
+    },
+    {
+      "path": "shaders/gpuHzbMain.spv",
+      "sha256": "08682362ee2120ed19d260e613285071747c3e436bb09bb6238e46f9cedc2308",
+      "size": 4140
+    },
+    {
+      "path": "shaders/gpuCullMain.spv",
+      "sha256": "7691360ec55f41d40d43652f506b051cef8b3a3ddcdcc7db61a7d4d97f9e87d8",
+      "size": 16180
+    },
+    {
+      "path": "shaders/gpuShadowMain.spv",
+      "sha256": "ffcdb91e70c41ce9452094865546a009b9203140cf8eeb3ad1b4e5868d82b815",
+      "size": 2404
+    },
+    {
+      "path": "shaders/gpuVertexMain.spv",
+      "sha256": "4647ef4fe1a68ab623ee9c19dac56631907f825cba0becd30869c5221c2a0385",
+      "size": 4928
+    },
+    {
+      "path": "shaders/shadowMain.reflection.json",
+      "sha256": "e3fd0889cd2f569d410f5d7558a4091d9f57f247a1dcf1788462f67525340819",
+      "size": 2645
+    },
+    {
+      "path": "shaders/fragmentMain.reflection.json",
+      "sha256": "72ebf8d32452830650416dc4717d89a4324e97ece7028dfb97c66803c8dce71f",
+      "size": 2649
+    },
+    {
+      "path": "shaders/vertexMain.reflection.json",
+      "sha256": "c584f3b957ebf194a292451362a98590f85ff3cfbfd8f917b1c1265039381777",
+      "size": 2639
+    },
+    {
+      "path": "shaders/shadowMain.spv",
+      "sha256": "7643b4d688492b5ee923b9606f0b0e70343ca05fa67673838206119a6f86d8d8",
+      "size": 784
+    },
+    {
+      "path": "shaders/fragmentMain.spv",
+      "sha256": "f5c4f289917ecab5d00d543c053aac1d10e6cca311fd172daf06d315160a3505",
+      "size": 7436
+    },
+    {
+      "path": "shaders/vertexMain.spv",
+      "sha256": "1ad2631c35d654f48166321ae43d4165043e1b919b14f1dc61caf97b1ada0898",
+      "size": 1224
+    },
+    {
+      "path": "faset_player",
+      "sha256": "99d7b8286a9151ec4eff9a9899e862d987048b031e1e40ca1938646afbde37bd",
+      "size": 6329192
+    },
+    {
+      "path": "project.faset.json",
+      "sha256": "e07b12047f8141c3c4cc8f0e7d0905a5c635375e4494755e34191db0859ab86f",
+      "size": 175
+    },
+    {
+      "path": "Scripts/util/motion.lua",
+      "sha256": "bad3dcdc1081fd1dec589c12dad8dc175b739d77ea52b957ead9ecb4b7cb88a3",
+      "size": 150
+    },
+    {
+      "path": "Scripts/player.lua",
+      "sha256": "1c51810574a3413c46a7cbd0ea2e84a9b802da1206a2b72bb78f6cc951367a11",
+      "size": 1376
+    },
+    {
+      "path": "Scripts/beacon.lua",
+      "sha256": "44d932ebedf66cadb9620f2d926177be2f8d43d71d56aa83611de686af026231",
+      "size": 820
+    },
+    {
+      "path": "scene.fscene",
+      "sha256": "641ba14a1f9c3966b9ec797814fdfa54f954dc5e0d53ab00c645598edef61baf",
+      "size": 1681
+    }
+  ],
+  "format": "faset.export",
+  "generation": "aa31bf16-984e-4854-b46f-15655bd6cc67",
+  "lua_enabled": true,
+  "lua_fingerprint": "a9261789bb1e0ca38bd40b08b0454165cd51454cba3ad4725dd357812ced6e35",
+  "platform": "linux",
+  "prerequisites": [
+    "Linux x86_64",
+    "Vulkan 1.3 driver",
+    "Compatible glibc and libstdc++ runtime"
+  ],
+  "renderer_profile": {
+    "api": "Vulkan 1.3",
+    "materials": [
+      "base-color factor and texture",
+      "metallic and roughness factors"
+    ],
+    "required_features": [
+      "dynamicRendering",
+      "synchronization2"
+    ],
+    "shadow_map": {
+      "resolution": 1024,
+      "world_extent": 40
+    },
+    "texture_sampling": "linear clamp, one mip level",
+    "unsupported_material_features": [
+      "normal maps",
+      "metallic-roughness maps",
+      "emissive and occlusion maps",
+      "alpha mode selection",
+      "unlit mode",
+      "per-material face culling"
+    ]
+  },
+  "scene_hash": "143724a468d711cbdf9a9700310d7b0acef003ce1b21422ca5204e0e565fa02c",
+  "simulation": {
+    "fixed_delta": 0.016666666666666666,
+    "gravity": [
+      0,
+      -9.81,
+      0
+    ],
+    "max_catch_up_ticks": 4,
+    "physics_substeps": 4
+  },
+  "units": {
+    "angle": "radian",
+    "coordinates": "right-handed Y-up",
+    "distance": "metre"
+  },
+  "validation_log": "{\"dimension\":2,\"validated\":true}\n",
+  "version": 1
+}

docs/validation/lua-release-2026-09-24/lua-run.json

@@ -0,0 +1,18 @@
+{
+  "arguments": [
+    "/tmp/faset-playable-exports-8wzkrc_u/Faset Café 世界/lua/faset_player",
+    "--headless",
+    "--frames",
+    "120",
+    "--capture",
+    "/tmp/faset-playable-exports-8wzkrc_u/Faset Café 世界/lua/verification.ppm",
+    "--profile",
+    "/tmp/faset-playable-exports-8wzkrc_u/Faset Café 世界/lua/profile.json"
+  ],
+  "cwd": "/tmp/faset-playable-exports-8wzkrc_u/empty-working-directory",
+  "seconds": 0.6288121230027173,
+  "exit_code": 0,
+  "timed_out": false,
+  "stdout": "{\"device\":\"NVIDIA GeForce RTX 2080 Ti\",\"dimension\":2,\"effective_visibility_mode\":\"direct\",\"frames\":120,\"gpu_visibility_active\":false,\"ticks\":120,\"validation_errors\":0,\"visibility_mode\":\"direct\"}\n",
+  "stderr": "Lua player ready: A/D move, Space jump, E reset\n"
+}

docs/validation/lua-release-2026-09-24/lua-validate.json

@@ -0,0 +1,12 @@
+{
+  "arguments": [
+    "/tmp/faset-playable-exports-8wzkrc_u/Faset Café 世界/lua/faset_player",
+    "--validate"
+  ],
+  "cwd": "/tmp/faset-playable-exports-8wzkrc_u/empty-working-directory",
+  "seconds": 0.007359832990914583,
+  "exit_code": 0,
+  "timed_out": false,
+  "stdout": "{\"dimension\":2,\"validated\":true}\n",
+  "stderr": ""
+}

docs/validation/lua-release-2026-09-24/report.json

@@ -0,0 +1,134 @@
+{
+  "format": "faset.playable-export-verification",
+  "version": 1,
+  "started_utc": "2026-09-23T23:30:12.719805+00:00",
+  "platform": "linux",
+  "engine": "/home/emil/Desktop/.worktrees/Faset_Engine-p1-lua-export",
+  "editor": "/home/emil/Desktop/.worktrees/Faset_Engine-p1-lua-export/build/linux-release/faset_editor",
+  "standalone_root": "/tmp/faset-playable-exports-8wzkrc_u",
+  "engine_revision": "433185717e1f324acb6eaf186818589d11697453",
+  "engine_dirty": false,
+  "engine_git_status": [],
+  "engine_diff_sha256": null,
+  "editor_sha256": "03ac75942f5f1d29e9d6fedb21ecffc6c74f4299401dbe84f01ab1b4e9c176a0",
+  "project_workspace": "/tmp/faset-playable-projects-cuhq4iwr",
+  "vulkaninfo_available": true,
+  "driver_override": null,
+  "frames_per_game": 120,
+  "status": "passed",
+  "projects": [
+    {
+      "name": "lua",
+      "dimension": 2,
+      "language": "lua",
+      "source_inputs": [
+        {
+          "path": "README.md",
+          "sha256": "8392da3c18916400ea628daed094c77c390c553cbdcf822da227bdcd3d86380c"
+        },
+        {
+          "path": "Scenes/main.scene.json",
+          "sha256": "f1ab54150a58b289c47bcc34566ad7ee3025ad931db81e7f5dce70d9fbcac8ab"
+        },
+        {
+          "path": "Scripts/beacon.lua",
+          "sha256": "44d932ebedf66cadb9620f2d926177be2f8d43d71d56aa83611de686af026231"
+        },
+        {
+          "path": "Scripts/player.lua",
+          "sha256": "1c51810574a3413c46a7cbd0ea2e84a9b802da1206a2b72bb78f6cc951367a11"
+        },
+        {
+          "path": "Scripts/util/motion.lua",
+          "sha256": "bad3dcdc1081fd1dec589c12dad8dc175b739d77ea52b957ead9ecb4b7cb88a3"
+        },
+        {
+          "path": "project.faset.json",
+          "sha256": "7e4c0781c1837208b4499a9991ffb702143edf1f933ae9c7e3d2543fd2577747"
+        }
+      ],
+      "generation": "aa31bf16-984e-4854-b46f-15655bd6cc67",
+      "configuration": "Release",
+      "standalone_directory": "/tmp/faset-playable-exports-8wzkrc_u/Faset Café 世界/lua",
+      "executable": "faset_player",
+      "package_file_count": 32,
+      "asset_generations": {},
+      "device": "NVIDIA GeForce RTX 2080 Ti",
+      "device_class": "physical",
+      "driver": {
+        "apiVersion": "1.4.329",
+        "driverVersion": "595.84.0.0",
+        "deviceName": "NVIDIA GeForce RTX 2080 Ti",
+        "driverID": "DRIVER_ID_NVIDIA_PROPRIETARY",
+        "driverName": "NVIDIA",
+        "driverInfo": "595.84"
+      },
+      "validation_enabled": true,
+      "validation_errors": 0,
+      "completed_frames": 120,
+      "summary_ms": {
+        "gpu": {
+          "max": 0.584992,
+          "min": 0.551712,
+          "p50": 0.5608,
+          "p95": 0.574592,
+          "samples": 120
+        },
+        "render_call": {
+          "max": 4.928888,
+          "min": 1.544123,
+          "p50": 1.919881,
+          "p95": 2.423702,
+          "samples": 120
+        },
+        "renderer_cpu": {
+          "max": 4.923196,
+          "min": 1.540666,
+          "p50": 1.915753,
+          "p95": 2.420426,
+          "samples": 120
+        },
+        "renderer_readback_cpu": {
+          "max": 2.837363,
+          "min": 0.395756,
+          "p50": 0.504853,
+          "p95": 0.641169,
+          "samples": 120
+        },
+        "simulation": {
+          "max": 0.210056,
+          "min": 0.084289,
+          "p50": 0.122261,
+          "p95": 0.171062,
+          "samples": 120
+        },
+        "snapshot": {
+          "max": 0.254931,
+          "min": 0.046518,
+          "p50": 0.065754,
+          "p95": 0.087906,
+          "samples": 120
+        },
+        "wall": {
+          "max": 5.322149,
+          "min": 1.702973,
+          "p50": 2.142903,
+          "p95": 2.634219,
+          "samples": 120
+        }
+      },
+      "capture": {
+        "width": 1280,
+        "height": 720,
+        "sampled_colors": 4,
+        "sha256": "e2f4c3b84de75dadd2e31d388d0ba51abc1861f1ec76eb7ba51a4a2dcac720a7"
+      },
+      "source_project_paths_unavailable": true,
+      "status": "passed"
+    }
+  ],
+  "requested_projects": [
+    "lua"
+  ],
+  "finished_utc": "2026-09-23T23:32:18.151669+00:00"
+}

docs/validation/lua-release-2026-09-24/vulkaninfo-summary.txt

@@ -0,0 +1,82 @@
+==========
+VULKANINFO
+==========
+
+Vulkan Instance Version: 1.4.341
+
+
+Instance Extensions: count = 27
+-------------------------------
+VK_EXT_acquire_drm_display             : extension revision 1
+VK_EXT_acquire_xlib_display            : extension revision 1
+VK_EXT_debug_report                    : extension revision 10
+VK_EXT_debug_utils                     : extension revision 2
+VK_EXT_direct_mode_display             : extension revision 1
+VK_EXT_display_surface_counter         : extension revision 1
+VK_EXT_headless_surface                : extension revision 1
+VK_EXT_layer_settings                  : extension revision 2
+VK_EXT_surface_maintenance1            : extension revision 1
+VK_EXT_swapchain_colorspace            : extension revision 5
+VK_KHR_device_group_creation           : extension revision 1
+VK_KHR_display                         : extension revision 23
+VK_KHR_external_fence_capabilities     : extension revision 1
+VK_KHR_external_memory_capabilities    : extension revision 1
+VK_KHR_external_semaphore_capabilities : extension revision 1
+VK_KHR_get_display_properties2         : extension revision 1
+VK_KHR_get_physical_device_properties2 : extension revision 2
+VK_KHR_get_surface_capabilities2       : extension revision 1
+VK_KHR_portability_enumeration         : extension revision 1
+VK_KHR_surface                         : extension revision 25
+VK_KHR_surface_maintenance1            : extension revision 1
+VK_KHR_surface_protected_capabilities  : extension revision 1
+VK_KHR_wayland_surface                 : extension revision 6
+VK_KHR_xcb_surface                     : extension revision 6
+VK_KHR_xlib_surface                    : extension revision 6
+VK_LUNARG_direct_driver_loading        : extension revision 1
+VK_NV_display_stereo                   : extension revision 1
+
+Instance Layers: count = 12
+---------------------------
+VK_LAYER_INTEL_nullhw             INTEL NULL HW                                                1.1.73   version 1
+VK_LAYER_KHRONOS_validation       Khronos Validation Layer                                     1.4.341  version 1
+VK_LAYER_MESA_anti_lag            Open-source implementation of the VK_AMD_anti_lag extension. 1.4.303  version 1
+VK_LAYER_MESA_device_select       Linux device selection layer                                 1.4.303  version 1
+VK_LAYER_MESA_overlay             Mesa Overlay layer                                           1.4.303  version 1
+VK_LAYER_MESA_screenshot          Mesa Screenshot layer                                        1.4.303  version 1
+VK_LAYER_NV_optimus               NVIDIA Optimus layer                                         1.4.329  version 1
+VK_LAYER_NV_present               NVIDIA Presentation Layer                                    1.4.329  version 1
+VK_LAYER_VALVE_steam_fossilize_32 Steam Pipeline Caching Layer                                 1.3.207  version 1
+VK_LAYER_VALVE_steam_fossilize_64 Steam Pipeline Caching Layer                                 1.3.207  version 1
+VK_LAYER_VALVE_steam_overlay_32   Steam Overlay Layer                                          1.3.207  version 1
+VK_LAYER_VALVE_steam_overlay_64   Steam Overlay Layer                                          1.3.207  version 1
+
+Devices:
+========
+GPU0:
+	apiVersion         = 1.4.329
+	driverVersion      = 595.84.0.0
+	vendorID           = 0x10de
+	deviceID           = 0x1e04
+	deviceType         = PHYSICAL_DEVICE_TYPE_DISCRETE_GPU
+	deviceName         = NVIDIA GeForce RTX 2080 Ti
+	driverID           = DRIVER_ID_NVIDIA_PROPRIETARY
+	driverName         = NVIDIA
+	driverInfo         = 595.84
+	conformanceVersion = 1.4.3.3
+	deviceUUID         = 2c71c7ba-97ac-c78e-2c06-af362631f3fe
+	driverUUID         = 027cbdd1-c478-513e-af69-ebc9eaa7de87
+GPU1:
+	apiVersion         = 1.4.335
+	driverVersion      = 26.0.8
+	vendorID           = 0x10005
+	deviceID           = 0x0000
+	deviceType         = PHYSICAL_DEVICE_TYPE_CPU
+	deviceName         = llvmpipe (LLVM 21.1.8, 256 bits)
+	driverID           = DRIVER_ID_MESA_LLVMPIPE
+	driverName         = llvmpipe
+	driverInfo         = Mesa 26.0.8-1ubuntu0.3 (LLVM 21.1.8)
+	conformanceVersion = 1.3.1.1
+	deviceUUID         = 6d657361-3236-2e30-2e38-2d3175627500
+	driverUUID         = 6c6c766d-7069-7065-5555-494400000000
+WARNING: [Loader Message] Code 0 : ICD for selected physical device does not export vkGetPhysicalDeviceDisplayPlanePropertiesKHR!
+WARNING: [Loader Message] Code 0 : ICD for selected physical device does not export vkGetPhysicalDeviceDisplayPropertiesKHR!

docs/validation/p1-iteration-2026-09-24/README.md

@@ -0,0 +1,138 @@
+# P1 gameplay iteration: measured Linux workflow
+
+The [unaltered version 2 workflow report](report.json) was produced by a clean
+`6c2e8fa80036315a695f67f3c53524165fb4b10a` checkout on 2026-09-24.
+It used disposable copies of the checked-in `collect-3d` and `examples/lua`
+projects. Every sample, process log and Player profile is retained under `raw/`;
+[the run log](workflow.log) shows the order and completion. The report identifies
+each input revision by SHA-256, and records all command arguments, phase labels,
+configuration and dirty-tree state. Its SHA-256 is
+`fd463c0cd12eed0a22143aa68bd732386804b0df4ecb2a3d9caa26f59dcfe6e2`.
+
+The original report's `toolchain.slang` is `null` because that version looked
+for `slangc` on `PATH`, while CMake used a configured executable. A **separate**
+[post-run provenance supplement](provenance.json), generated after commit
+`abd8c21` from the surviving disposable [compressed CMake cache](CMakeCache.txt.gz), hashes
+the selected CMake, Ninja, C/C++ compiler, Slang, Editor and UI-probe binaries.
+It binds to the original report hash and records both script revisions. The
+measured report was not rewritten. Subsequent workflow runs include these
+identities in their report directly. `4ac02ee` changed only the Windows CI export
+fixture location; neither follow-up is presented as the measured code revision.
+
+## Measurement conditions and results
+
+The host ran Linux 7.0, Ryzen 7 1700, 32 GiB RAM, RTX 2080 Ti and NVIDIA 595.84.
+The disposable project used Debug, Clang 21.1.8, CMake 4.2.3, Ninja 1.13.2 and
+Slang 2026.18. The Player rendered offscreen Vulkan at 1280×720 with validation
+active and full-frame readback. The run did not overlap the separate P3 GPU sweep.
+Build times still depend on ambient CPU load, filesystem cache and prepared
+dependencies. The `cold` row means an empty project `.faset` cache, **not** a cold
+OS page cache or a first dependency download.
+
+| Observation | Samples | Median | Nearest-rank p95 | Scope |
+| --- | ---: | ---: | ---: | --- |
+| Initial configure and native build | 1 | 106.01 s | — | Disposable Debug project |
+| Unchanged build | 5 | 11.53 s | 13.12 s | All five reused the verified schema/package generation |
+| Changed `Gameplay.cpp` build | 5 | 28.16 s | 30.33 s | One warm-up edit excluded |
+| Changed `Gameplay.hpp` build | 5 | 23.89 s | 25.51 s | One warm-up edit excluded |
+| Watched Lua edit to reload log | 5 | 0.502 s | 0.504 s | Persistent Player; includes watcher polling |
+| First completed offscreen Player frame | 5 | 0.284 s | 0.333 s | From `main()`; excludes OS loader and window presentation |
+| Synthetic Editor input to rendered state | 100 | 13.97 ms | 18.03 ms | Ten warm-ups; offscreen retained-UI frame, not input-to-photon |
+
+The intentional C++ compile failure took 10.00 s and the corrected recovery
+build 19.93 s. The failed job preserved its prior successful build pointer.
+The run also imported the small Blender bundle cold and cached in 49 and 52 ms,
+respectively; Editor process startup dominates that tiny asset sample, so those
+two values do not establish import-cache speedup. The raw
+[failed-build job](raw/build_failure-01-stdout.txt) exposed a navigation defect:
+the compiler named the staged source copy, and the original structured
+diagnostic omitted `file`. A later fix maps only the verified staged `Scripts`
+subtree to project-relative source. A [real failed-build replay](diagnostic-replay.json)
+with the corrected Editor returns `Scripts/Gameplay.cpp`, line 73, column 2.
+The `build_diagnostics` test also covers project-contained snapshot paths and
+Windows drives; `build_schema_publication` verifies that an error after 250
+third-party warnings survives the 200-row diagnostic limit. These are separate
+from this unmodified measurement.
+
+Follow-up `54d1bae` rehashes both the live source and the staged copy after
+native build and before reuse/publication. A fixture changes the staged C++
+header during schema export; the build fails and retains the last-good pointer.
+The copy is content-verified at those boundaries, not sealed against a same-user
+write-and-restore during compiler reads.
+
+The [3,000-frame lifecycle profile](raw/cpp-3000-frame-lifecycle.json) completed
+with zero Vulkan validation errors. Maximum explicit Vulkan allocation was
+15,787,008 bytes in both frames 101–200 and 2901–3000, a measured growth of zero;
+the live texture count remained one. These counters exclude driver-internal
+memory and do not prove absence of all resource leaks.
+
+The generated [527-entity scene](raw/generated-512.scene.json) adds 512 seeded
+copies to the 15-entity source and ran for 240 offscreen frames with zero Vulkan
+validation errors. Its [raw profile](raw/generated-512-profile.json) reports p95
+frame wall 149.39 ms, simulation 48.19 ms, scene snapshot 68.12 ms, renderer call
+36.51 ms and GPU timestamp 0.911 ms. It exposes a significant CPU scaling cost
+in this synthetic content; it is not a typical-game benchmark or a Release budget
+failure for the tiny checked-in sample.
+
+## Reference budgets and coverage
+
+The [2026-09-18 Release reference baseline](../linux-release-2026-09-18/README.md)
+measured the **exact** `collect-2d` and `collect-3d` packaged scenes on this host,
+at 1280×720 with validation/readback. Its 240-frame p95s met the initial tracking
+budgets: frame 2.684/2.732 ms versus ≤4; GPU 0.579/0.600 ms versus ≤1; readback
+0.633/0.608 ms versus ≤1; simulation 0.258/0.300 ms and snapshot 0.215/0.257 ms
+versus ≤0.5 each. Explicit allocations were about 15.02/15.06 MiB versus
+≤20 MiB; first-frame startup from `main()` was 265.5/260.8 ms versus ≤500 ms.
+That baseline was an evolving earlier working tree. Its values are **historical**
+and are not compared with this Debug workflow's timing.
+
+The [fresh clean combined P1/P3 Release reference](final-release/README.md) at
+`4a3453e` repeats these exact scenes on the same physical RTX 2080 Ti, now with
+120-frame source-hidden relocation checks for C++ 2D/3D and Lua-only, plus
+sequential 240-frame C++ 2D/3D profiles. The frame, GPU, readback, simulation,
+snapshot and startup tracking budgets all pass. Explicit allocations instead
+reach **43.022/43.118 MiB**, above the former ≤20 MiB budget because the new
+renderer eagerly retains a 16 MiB sun atlas and a 16 MiB local atlas in both
+scenes. The 2D sample casts no sun shadows and neither sample uses local shadow
+faces. This is a measured tracking-budget miss, not a failed export or a reason
+to redefine the counter silently. The linked dossier retains exact values,
+atlas breakdown, raw profiles and source/toolchain provenance.
+
+The [Lua-only Linux Release dossier](../lua-release-2026-09-24/README.md) separately
+records a relocated package that validated and rendered 120 frames after hiding
+its source project, with 0 validation errors. The final fixture placement was
+checked in clean-revision [`4ac02ee` Windows graphics CI](https://github.com/emil28092005/Faset_Engine/actions/runs/35937433040):
+61/61 CTests passed on pinned SwiftShader, the real 2D/3D Release export
+integration passed, and **all three** relocated Release games (`collect-2d`,
+`collect-3d`, Lua-only) validated and rendered 120/120 frames with source paths
+unavailable. The [Windows playable report](windows-4ac02ee/playable-report.json)
+contains package and source hashes, device identity, result details and capture
+checksums; [integration results](windows-4ac02ee/integration-result-2.json),
+[integration manifests](windows-4ac02ee/integration-manifest-2.json),
+[Vulkan probe](windows-4ac02ee/vulkan-probe.json) and
+[toolchain record](windows-4ac02ee/toolchain.json) preserve representative raw
+evidence. The parallel [native/manual CI](https://github.com/emil28092005/Faset_Engine/actions/runs/35937433211)
+passed on Linux and Windows. This is **software** Vulkan; Windows did not have an
+active Khronos validation layer (`validation_enabled: false`), and no physical
+Windows GPU/driver performance claim follows. The later [combined P1/P3 Windows
+graphics CI](https://github.com/emil28092005/Faset_Engine/actions/runs/35942307579)
+at `87230f3` passed 74/74 CTests, including real diagnostic navigation, real
+Release export integration and all three relocated games. The physical-GPU
+Linux reference above had active validation.
+
+## P1 acceptance record
+
+| Area | Evidence and current limit |
+| --- | --- |
+| Lua | Linux native and Release [relocated Lua result](../lua-release-2026-09-24/README.md), repeated in the [clean combined three-game Release reference](final-release/README.md); Windows CPU/SwiftShader [combined 74-test suite](https://github.com/emil28092005/Faset_Engine/actions/runs/35942307579) and [relocated Lua-only Release report](windows-4ac02ee/playable-report.json), 120 completed frames. |
+| Cache and rollback | [Five verified hits](report.json), `build_cache` and `build_schema_publication` contracts for headers, toolchain, schema/shader corruption and source races; the raw failed/recovered build retains the previous pointer. |
+| Diagnostics | `build_diagnostics` fixtures cover Clang, clang-cl, Lua, Unicode and unparseable output. The raw real failure above found a staged-source mapping gap; [the replay](diagnostic-replay.json), parser case, warning-flood case and real BuildService integration assertion cover the correction. |
+| Starters/navigation | [Four runnable C++/Lua × 2D/3D starters](../p1-starters-linux-2026-09-24.md) plus launcher/CLI and source-open tests. |
+| Autosave | `editor_session_settings`, UI tests and [workspace behavior](../../manual/editor/workspace.md#create-and-save-a-scene): idle coalescing, unnamed Save As, external/revision conflicts, Undo and recovery. |
+| Iteration | This Debug report, 179 raw files, 3,000-frame and seeded larger-scene profiles, plus the [clean combined Release reference](final-release/README.md) with three relocated games and exact 2D/3D budgets. The allocation budget miss is recorded; no CI timing gates. |
+| Documentation | The English Manual describes build/reload, templates, navigation, autosave and profile interpretation; strict MkDocs and full platform test totals are recorded in the implementation journal. |
+
+The [profiling guide](../../manual/editor/profiling.md#measure-editor-c-and-lua-iteration)
+documents how to repeat the run and interpret its deliberately distinct timing
+labels. C++ hot reload, state-preserving Lua reload and Player-world MCP are not
+part of this P1 contract.

docs/validation/p1-iteration-2026-09-24/final-release/README.md

@@ -0,0 +1,111 @@
+# Final combined P1/P3 Release reference — 2026-09-24
+
+This is the clean-source, physical-GPU reference for the checked-in playable
+`collect-2d`, `collect-3d`, and Lua-only games at
+`4a3453e2b1868555d833f578d43f48b8bc47d41a`. The real Release Editor
+exported each project to a self-contained package. The packages were copied to
+Unicode-named paths outside their disposable source projects, and those source
+paths were hidden while each Player ran from an unrelated empty working
+directory. The 3D export imported and packaged the Blender exit arch. All three
+games passed standalone CPU validation and rendered **120/120** offscreen Vulkan
+frames on the physical NVIDIA GeForce RTX 2080 Ti with the Khronos validation
+layer active and **zero validation errors**. The [verifier report](report.json),
+[2D manifest](evidence/collect-2d-manifest.json),
+[3D manifest](evidence/collect-3d-manifest.json), and
+[Lua manifest](evidence/lua-manifest.json) retain input, package and binary
+hashes. The [toolchain supplement](provenance.json) binds the unmodified report
+and 240-frame summary to the exact Editor, CMake, Ninja, Clang and Slang
+binaries. The verifier recorded a clean checkout at its start, and the second
+profiles used the same relocated Player binaries.
+
+| Relocated package | Runtime | Frames | GPU validation | Source paths hidden |
+| --- | --- | ---: | --- | --- |
+| `collect-2d` | C++ | 120/120 | active, 0 errors | yes |
+| `collect-3d` | C++ with Blender asset | 120/120 | active, 0 errors | yes |
+| `lua` | Lua-only | 120/120 | active, 0 errors | yes |
+
+The two **same relocated C++ executables** then ran a second, sequential
+240-frame profile. For each run, the disposable source-project paths were again
+hidden and restored afterward. These exact 2D/3D samples used default Direct
+visibility and temporal Off, 1280×720 offscreen Vulkan, synchronous readback,
+the active Khronos validation layer and synthetic fixed-step simulation. No
+frame was discarded as a warm-up: the table uses nearest-rank p95 over all 240
+completed frames, including the first. Both profiles report zero validation
+errors. Raw [2D](reference-240/collect-2d-profile-240.json) and
+[3D](reference-240/collect-3d-profile-240.json) profiles, exact
+[2D invocation](reference-240/collect-2d-run-240.json) and
+[3D invocation](reference-240/collect-3d-run-240.json), and the
+[machine-readable budget comparison](reference-240/reference-summary.json)
+support every value below.
+
+| Exact-scene observation | Initial P1 tracking budget | 2D | 3D |
+| --- | ---: | ---: | ---: |
+| Frame wall p95 | ≤4 ms | 2.694 ms | 3.036 ms |
+| GPU timestamp p95 | ≤1 ms | 0.573 ms | 0.617 ms |
+| Readback CPU p95 | ≤1 ms | 0.559 ms | 0.561 ms |
+| Simulation p95 | ≤0.5 ms | 0.242 ms | 0.300 ms |
+| Scene snapshot p95 | ≤0.5 ms | 0.197 ms | 0.288 ms |
+| `main()` to first frame | ≤500 ms | 295.4 ms | 248.3 ms |
+| Maximum explicit Vulkan allocation | ≤20 MiB | **43.022 MiB — miss** | **43.118 MiB — miss** |
+
+The memory miss is real, not a profile rounding artifact: 2D used 45,112,032
+bytes and 3D used 45,212,272 bytes, while the earlier threshold was 20,971,520
+bytes. Each run counted a **16 MiB sun atlas and a 16 MiB local-light atlas**
+inside the live Vulkan allocation total. The 2D sprites produced no sun-shadow
+raster work; the 3D meshes rendered four sun cascades. Neither sample used a
+local shadow face. Both 2048² D32 atlases are currently allocated when the
+Renderer is created, even when the scene never uses them. The remaining explicit
+allocations were 11.022 MiB (2D) and 11.118 MiB (3D). Lazy local-atlas
+allocation is a sensible follow-up, but alone it would still leave the 3D
+scene above 20 MiB with its current 2048² sun atlas. We have kept the physical
+counter and shadow resolution intact and recorded the miss rather than silently
+changing either to satisfy an older threshold. The 20 MiB value is an initial
+**tracking budget** for tiny pre-P3 scenes, not a functional export gate; any
+revised shadow-memory budget needs its own measured baseline.
+
+The Lua run establishes relocated Release execution, not a 2D/3D latency
+budget. The [2026-09-18 Release reference](../../linux-release-2026-09-18/README.md)
+used these scenes on the same GPU but an evolving earlier working tree; its
+numbers are historical context, not this clean combined revision. This run
+measures small scenes on one active Linux desktop and one driver (NVIDIA
+595.84). GPU timestamps exclude CPU work, `renderer_readback_cpu` is a
+map/copy/unmap duration inside the renderer call, and the explicit allocation
+counter excludes driver-internal memory. It does not establish production-game
+scaling, whole-process VRAM usage, display-paced FPS, physical Windows GPU
+performance or absence of all leaks.
+
+## Reproduce and inspect
+
+From this repository with the dependencies configured:
+
+```sh
+cmake --preset linux-release
+cmake --build --preset linux-release --target faset_editor --parallel 2
+python3 tools/verify_playable_exports.py \
+  --editor build/linux-release/faset_editor \
+  --output /tmp/faset-p1-release-new \
+  --standalone-root /tmp/faset-p1-packages-new \
+  --include-lua
+python3 docs/validation/p1-iteration-2026-09-24/final-release/profile_exact_scenes.py \
+  --verification /tmp/faset-p1-release-new/report.json \
+  --output /tmp/faset-p1-release-new/reference-240
+```
+
+Use **new, empty** output and standalone directories. The second helper
+refuses an incomplete or dirty-tree verifier report, hides the disposable
+source projects during each 240-frame run, checks exact settings and validation,
+then restores them. The original [verifier log](verifier.log),
+[240-frame log](reference-240.log), raw 120-frame profiles for
+[2D](evidence/collect-2d-profile.json),
+[3D](evidence/collect-3d-profile.json) and
+[Lua](evidence/lua-profile.json), PPM captures, and the
+[SHA-256 file list](SHA256SUMS.txt) are retained here. The
+large disposable native build directories and relocated executable packages
+remain under `/tmp`; their input, manifest and executable hashes are in the
+reports.
+
+![Relocated 2D sample](collect-2d.png)
+
+![Relocated 3D sample with Blender asset](collect-3d.png)
+
+![Relocated Lua sample](lua.png)

docs/validation/p1-iteration-2026-09-24/final-release/SHA256SUMS.txt

@@ -0,0 +1,35 @@
+d5dca233d7ddbb7c32998ec920fda6cf67e6515c965372985c807ccd4ff54075  README.md
+d23e8614c133938974d1c1a865100d24175242ab818573cb1416ba82d1e62260  collect-2d.png
+f83799304917c2e0250605e83f69cbee4865818078ba3f9aed590c010f2b19b3  collect-3d.png
+3ca7066843c2875c86a4917782a07f93358a44ebd220d25a3f2457ae542ec415  evidence/collect-2d-export.json
+5f8de3eb000dc7207b256265f0fa20a29efe194dd1347ab4c3bf670cfdcfb2b0  evidence/collect-2d-manifest.json
+c45dc33981db0c2038d22cda2be4151de46445a4f368259d6b0002c35e402633  evidence/collect-2d-profile.json
+591329c7cb85c9fc0220deec7e76ca24e139037481d949c91882858c76c2621a  evidence/collect-2d-run.json
+af24b1c312e67b0e0cbe2b5871888db17b9bb47e95eca5028c9e07d72b2f1bea  evidence/collect-2d-validate.json
+f9d74067d87c1ebf30c6db372a26d93b7285791c8cb0307a24af5adb23bf201a  evidence/collect-2d.ppm
+a00c55bbda0242e924781b4ca9d73910741506dce4df93dafde8d729389511a8  evidence/collect-3d-export.json
+7e09c5ae35c8f998510b83af51ded67bba0bc7483f8cfdb17a785368a8f9b2ca  evidence/collect-3d-import.json
+484eda90411c48277385a2f679561cfa6304965a7a7be6ec065bfbd9dace1722  evidence/collect-3d-manifest.json
+96193de60cf7fa139fc110c99628e065779a378151e816ce947129ed4217f9a0  evidence/collect-3d-profile.json
+17e2ea46f9811432018704fa2468850f015b113f3407525bf795c21cf44b4fcb  evidence/collect-3d-run.json
+f102446ff954cf1e9062726772a868ff1a30783da5ff77e2c3486227e8acc867  evidence/collect-3d-validate.json
+2905891c9766b2f1f65d5b4284056cb3839f1faae195f9fea39a56e3ebf44363  evidence/collect-3d.ppm
+737db5241ea2caba9393e18dbcf1e48ef6c106ae6f4fdc6ac3bfe0e2fc43325c  evidence/lua-export.json
+3caecdb756b289c2bd1f61ec4e5a8c5194b35166f34f332a1651a5a846e7f631  evidence/lua-manifest.json
+eb985bd647266529ab98d0535150e20e7c54692a2546e0df935bbcfb71cbca66  evidence/lua-profile.json
+acce29b23725fba6a54e2e70827b0bd92137408eacaec4f58f5dee37666a8d0c  evidence/lua-run.json
+f44cbe6db9ac6170c4db7f6f502fe09d62cc5da1e2535fe93cc474f6a28293ca  evidence/lua-validate.json
+e2f4c3b84de75dadd2e31d388d0ba51abc1861f1ec76eb7ba51a4a2dcac720a7  evidence/lua.ppm
+5e395b08f275eadc6066697204abf2287e9a1ea124cba6cf6f5deca3924282aa  evidence/vulkaninfo-summary.txt
+19c9b2c5a401af52980604fa074f89fe9452cfa728a606ad937c509a1c4164eb  lua.png
+5d69428a1202c1e144779074c0ab88360c459e2dd99b22c1fcf8929dbeab2618  profile_exact_scenes.py
+fa49dae530785e24fe028ee5d0ade949fab61d540b118d8bf96d787267e6f87b  provenance.json
+65858b1de2334d304ad3a0907180aaf4f79ead3da63762500e50b7298d922bfa  reference-240/collect-2d-profile-240.json
+0d117fc6571fc497271921e818c97c729aeb58da6613bb2b1f24c815ae171319  reference-240/collect-2d-run-240.json
+b0c4c6b4020b1ded792917fff1f36510b76bb30864d89bd4e6e250b5693c5fe8  reference-240/collect-3d-profile-240.json
+ebbc376e8788b11b31f1eb7a767142348bcc6a6986e0593e20b44cb0e2d1e65d  reference-240/collect-3d-run-240.json
+63da692b605621acc1cace00d4a3c9cf35de13abfd4351aea6653a88c870e03f  reference-240/playable-report.json
+f8297f3cb0578addee56c0b3cb9439b37ae37707b02d433d662b534620f329e9  reference-240/reference-summary.json
+d97939ba5cee29ae237568c00714b68ab6849c4c506987cff05392750da5e0ca  reference-240.log
+63da692b605621acc1cace00d4a3c9cf35de13abfd4351aea6653a88c870e03f  report.json
+f4a0f3a487a5d7180caa08c8c254d2e39bad5d6cf5c4877d131af3dbd98fa777  verifier.log

docs/validation/p1-iteration-2026-09-24/final-release/evidence/collect-2d-manifest.json

@@ -0,0 +1,269 @@
+{
+  "asset_generations": {},
+  "build_fingerprint": "b2559255996b7990919d5aa15cbfa53c225a0ee299e6a43ffbf04cd8bbb606db",
+  "configuration": "Release",
+  "executable": "faset_player",
+  "files": [
+    {
+      "path": "README.txt",
+      "sha256": "82bf72bc542643f6c4090e0a5de69b0014ca3fa17c6f9dfb12cc41e44c8b8db6",
+      "size": 262
+    },
+    {
+      "path": "Notices/Faset-NOTICE.txt",
+      "sha256": "30c2e7e80f5153b31ab57675e07246aef9165965d64e36022b426a26449ece3f",
+      "size": 204
+    },
+    {
+      "path": "Notices/dependencies.json",
+      "sha256": "a54639ad2d9ad13c2e5f1ec90d6775f5dfc493656789b78c7e44debe2a378fdc",
+      "size": 2206
+    },
+    {
+      "path": "Notices/stb/LICENSE",
+      "sha256": "bebfe904b14301657e4e5d655c811d51fd31b97c455b9cc2d8600d6bac6cff63",
+      "size": 2510
+    },
+    {
+      "path": "Notices/json/LICENSE.MIT",
+      "sha256": "46a65cffd1ea955132d95a8dd921640714a8d6b537d2e4e482d31145ae95b603",
+      "size": 1076
+    },
+    {
+      "path": "Notices/box3d/LICENSE",
+      "sha256": "da5e31a26bf3cfd5ba5c96d6823e480128c81e76c107ef9d3ee5d94789184b90",
+      "size": 1067
+    },
+    {
+      "path": "Notices/box2d/LICENSE",
+      "sha256": "68a3e676d7e94093b102d5cba0d4e04af812040d6f230c3db67a6664574e43d2",
+      "size": 1067
+    },
+    {
+      "path": "Notices/entt/LICENSE",
+      "sha256": "0785027ce472d7c61f05fba664a1d3ba6639c1593ced351ad9e4bed868765d99",
+      "size": 1097
+    },
+    {
+      "path": "Notices/sdl3/LICENSE.txt",
+      "sha256": "97f35b302b361680ec1e891e95d2d52097bb95abff361434916d99dc1305f127",
+      "size": 884
+    },
+    {
+      "path": "shaders/gpuTemporalVertexMain.reflection.json",
+      "sha256": "7a8efe2645e7ce465ca44d19f8cfb2eb6c767abd1c3ce12ed69a149a50be8a8c",
+      "size": 3308
+    },
+    {
+      "path": "shaders/gpuTemporalVertexMain.spv",
+      "sha256": "dfe7309aafbd41974668b295e179354965db440e4156b9f12d6a67db16b357f9",
+      "size": 5996
+    },
+    {
+      "path": "shaders/temporalFragmentMain.reflection.json",
+      "sha256": "e36452227788f3703d7342b6d9a7a0efef74ce4da3aa96bb176a26e169ec3628",
+      "size": 3874
+    },
+    {
+      "path": "shaders/temporalFragmentMain.spv",
+      "sha256": "03adc6673276979b3ea46becf3a36940d3061af77cb8c965c7471feff8dbf89a",
+      "size": 30976
+    },
+    {
+      "path": "shaders/temporalVertexMain.reflection.json",
+      "sha256": "6f7812ce88b14bca62a6d2ad82a8657e2ee48c252558f34677c6a2bd980a7edb",
+      "size": 3935
+    },
+    {
+      "path": "shaders/temporalVertexMain.spv",
+      "sha256": "6cc3535c952a33ee46fd417fbec7fcad8f24357508b2119256b3077be3d60955",
+      "size": 1784
+    },
+    {
+      "path": "shaders/temporalCompositeFragmentMain.reflection.json",
+      "sha256": "44765a41fc362c9a97b1a19834f285e2e7facb24d8715e3d8559b8e9633a7a0e",
+      "size": 959
+    },
+    {
+      "path": "shaders/temporalCompositeFragmentMain.spv",
+      "sha256": "9e21c8534c0e70a58ae018fb2d143bf9cfb70112e71b67585f525eef0aecad1b",
+      "size": 768
+    },
+    {
+      "path": "shaders/temporalCompositeVertexMain.reflection.json",
+      "sha256": "a3a2ea858bd038423896043b0703704f707addceb5bd56721cd897f6bd092065",
+      "size": 956
+    },
+    {
+      "path": "shaders/temporalCompositeVertexMain.spv",
+      "sha256": "6b19f65b64f40d0a249660fdfba9dd5d95831ffab7314a307bf1f5cf39c6a248",
+      "size": 340
+    },
+    {
+      "path": "shaders/temporalResolveMain.reflection.json",
+      "sha256": "9407ee1522f32df231d996ea691224863c023c1ca42cc02ccd7e16de1d873082",
+      "size": 3179
+    },
+    {
+      "path": "shaders/temporalResolveMain.spv",
+      "sha256": "4c5fc0da7a4c424e5426694c2c2d9f3cd17d1a64066712f5defe882ad8776662",
+      "size": 22192
+    },
+    {
+      "path": "shaders/gpuPostCullMain.reflection.json",
+      "sha256": "19ce128388c7f88e0c517fb58a25e46f1382e35ae5f376b10eebe155a2811c4c",
+      "size": 3591
+    },
+    {
+      "path": "shaders/gpuHzbMain.reflection.json",
+      "sha256": "589818f670881c64f3aba726ee3bc82fe4b9d835a347f99134e0e157dc4a112e",
+      "size": 2050
+    },
+    {
+      "path": "shaders/gpuCullMain.reflection.json",
+      "sha256": "8986a45a8d29743d16f0caece9181b18c85d6490d93b4a56cdb4f53052890f3f",
+      "size": 3587
+    },
+    {
+      "path": "shaders/gpuShadowMain.reflection.json",
+      "sha256": "96b3620b163dadf214933cfba6600b1b6a835c4d98b75b1f83e6ccd3dedb2425",
+      "size": 2755
+    },
+    {
+      "path": "shaders/gpuVertexMain.reflection.json",
+      "sha256": "01a6cc1bbf3c11c558560d6f8557fd4582d392906ed20a8c729673d0ebf640ed",
+      "size": 3098
+    },
+    {
+      "path": "shaders/gpuPostCullMain.spv",
+      "sha256": "1f8edd3be1f99f9433494a6f7be68f1317d6e7099e19354a7b8130d5d932224d",
+      "size": 12548
+    },
+    {
+      "path": "shaders/gpuHzbMain.spv",
+      "sha256": "08682362ee2120ed19d260e613285071747c3e436bb09bb6238e46f9cedc2308",
+      "size": 4140
+    },
+    {
+      "path": "shaders/gpuCullMain.spv",
+      "sha256": "e5ea6589ddb3613b59f8e58420be95a534cf4149816bc65bae26b1395c638955",
+      "size": 16288
+    },
+    {
+      "path": "shaders/gpuShadowMain.spv",
+      "sha256": "f56e0ae3e9b31cb1e3f24e379c81e11c853f8a7102648aaaebc92a17c7e8e53c",
+      "size": 2492
+    },
+    {
+      "path": "shaders/gpuVertexMain.spv",
+      "sha256": "32421d4a91f3a88d5210fee7af34b48bcad83072f14e2ccb9ef2ff983e45f78f",
+      "size": 5016
+    },
+    {
+      "path": "shaders/shadowMain.reflection.json",
+      "sha256": "d39e2f83c797589296eac9dce139b9ad836a895d6685bc40f79dd2609d687fee",
+      "size": 3597
+    },
+    {
+      "path": "shaders/fragmentMain.reflection.json",
+      "sha256": "2b07af2aae7578bdb6c2aa22658538821608b1dd5aeddd7b06e42b2e78cedf12",
+      "size": 3596
+    },
+    {
+      "path": "shaders/vertexMain.reflection.json",
+      "sha256": "b3bdff863d53a0b385e06a36701a83a6ecafe9a93e97281a732cce8ff862c0db",
+      "size": 3591
+    },
+    {
+      "path": "shaders/lightTileMain.reflection.json",
+      "sha256": "bf6a9256aaa6d6edacfa1e1c265d7c8ce2c1e4ea4036e0bea078c22fd4b536ca",
+      "size": 1978
+    },
+    {
+      "path": "shaders/lightTileMain.spv",
+      "sha256": "92850edcc5ee5b586a90ce84ee69a98075a6fff3c13db4a57528d9431afe8b68",
+      "size": 6800
+    },
+    {
+      "path": "shaders/shadowMain.spv",
+      "sha256": "7643b4d688492b5ee923b9606f0b0e70343ca05fa67673838206119a6f86d8d8",
+      "size": 784
+    },
+    {
+      "path": "shaders/fragmentMain.spv",
+      "sha256": "fea4dd48664a510bad12b5e8582f2db798d4dbea62ce0de35dc2acfe32372733",
+      "size": 28960
+    },
+    {
+      "path": "shaders/vertexMain.spv",
+      "sha256": "1ad2631c35d654f48166321ae43d4165043e1b919b14f1dc61caf97b1ada0898",
+      "size": 1224
+    },
+    {
+      "path": "faset_player",
+      "sha256": "5936d8a1ceae9250c69f1b8ebccbadebc40b13e812bebeb9752da3d14d202a4a",
+      "size": 6154704
+    },
+    {
+      "path": "scene.fscene",
+      "sha256": "0d7b221abc1cae5e9f1d04357c684ac6993f5878d634b4b950eec66dd8e55b2a",
+      "size": 6214
+    }
+  ],
+  "format": "faset.export",
+  "generation": "ca306aa8-a094-42bc-833f-a24a05cab73d",
+  "lua_enabled": false,
+  "lua_fingerprint": "",
+  "platform": "linux",
+  "prerequisites": [
+    "Linux x86_64",
+    "Vulkan 1.3 driver",
+    "Compatible glibc and libstdc++ runtime"
+  ],
+  "renderer_profile": {
+    "api": "Vulkan 1.3",
+    "materials": [
+      "base-color factor and texture",
+      "metallic and roughness factors"
+    ],
+    "required_features": [
+      "dynamicRendering",
+      "synchronization2"
+    ],
+    "shadow_atlases": {
+      "caster_draw_limit": 4096,
+      "fallback_resolution": 1024,
+      "local_face_limit": 16,
+      "preferred_resolution": 2048,
+      "sampled_d32_required": true,
+      "sun_cascade_limit": 4
+    },
+    "texture_sampling": "linear clamp, one mip level",
+    "unsupported_material_features": [
+      "normal maps",
+      "metallic-roughness maps",
+      "emissive and occlusion maps",
+      "alpha mode selection",
+      "unlit mode",
+      "per-material face culling"
+    ]
+  },
+  "scene_hash": "fdfa1c49cf78a1cf52cd41b201c35bb0b5f852c90b7626b2a7f17da3e2e3e24c",
+  "simulation": {
+    "fixed_delta": 0.016666666666666666,
+    "gravity": [
+      0,
+      -9.81,
+      0
+    ],
+    "max_catch_up_ticks": 4,
+    "physics_substeps": 4
+  },
+  "units": {
+    "angle": "radian",
+    "coordinates": "right-handed Y-up",
+    "distance": "metre"
+  },
+  "validation_log": "{\"dimension\":2,\"validated\":true}\n",
+  "version": 1
+}

docs/validation/p1-iteration-2026-09-24/final-release/evidence/collect-2d-run.json

@@ -0,0 +1,18 @@
+{
+  "arguments": [
+    "/tmp/faset-p1-final-packages-4a3453e/Faset Café 世界/collect-2d/faset_player",
+    "--headless",
+    "--frames",
+    "120",
+    "--capture",
+    "/tmp/faset-p1-final-packages-4a3453e/Faset Café 世界/collect-2d/verification.ppm",
+    "--profile",
+    "/tmp/faset-p1-final-packages-4a3453e/Faset Café 世界/collect-2d/profile.json"
+  ],
+  "cwd": "/tmp/faset-p1-final-packages-4a3453e/empty-working-directory",
+  "seconds": 0.6589637870201841,
+  "exit_code": 0,
+  "timed_out": false,
+  "stdout": "New round: collect the three gold cubes, then reach the green exit. E resets.\n{\"device\":\"NVIDIA GeForce RTX 2080 Ti\",\"dimension\":2,\"effective_temporal_mode\":\"off\",\"effective_visibility_mode\":\"direct\",\"frames\":120,\"gpu_visibility_active\":false,\"temporal_mode\":\"off\",\"ticks\":120,\"validation_errors\":0,\"visibility_mode\":\"direct\"}\n",
+  "stderr": ""
+}

docs/validation/p1-iteration-2026-09-24/final-release/evidence/collect-2d-validate.json

@@ -0,0 +1,12 @@
+{
+  "arguments": [
+    "/tmp/faset-p1-final-packages-4a3453e/Faset Café 世界/collect-2d/faset_player",
+    "--validate"
+  ],
+  "cwd": "/tmp/faset-p1-final-packages-4a3453e/empty-working-directory",
+  "seconds": 0.008382081025047228,
+  "exit_code": 0,
+  "timed_out": false,
+  "stdout": "{\"dimension\":2,\"validated\":true}\n",
+  "stderr": ""
+}

docs/validation/p1-iteration-2026-09-24/final-release/evidence/collect-3d-manifest.json

@@ -0,0 +1,296 @@
+{
+  "asset_generations": {
+    "5832763b-3ed0-44d6-9088-0b524f196a91": "4a5bfcc1437a7b4d65c388da2beace0308cceda8e16503d08ce676260f21d5c2"
+  },
+  "build_fingerprint": "bd02f95edc719dfab9193177d2839502f3322cd85b8fc8f6dcb4f9a2560362b1",
+  "configuration": "Release",
+  "executable": "faset_player",
+  "files": [
+    {
+      "path": "README.txt",
+      "sha256": "82bf72bc542643f6c4090e0a5de69b0014ca3fa17c6f9dfb12cc41e44c8b8db6",
+      "size": 262
+    },
+    {
+      "path": "Notices/Faset-NOTICE.txt",
+      "sha256": "30c2e7e80f5153b31ab57675e07246aef9165965d64e36022b426a26449ece3f",
+      "size": 204
+    },
+    {
+      "path": "Notices/dependencies.json",
+      "sha256": "a54639ad2d9ad13c2e5f1ec90d6775f5dfc493656789b78c7e44debe2a378fdc",
+      "size": 2206
+    },
+    {
+      "path": "Notices/stb/LICENSE",
+      "sha256": "bebfe904b14301657e4e5d655c811d51fd31b97c455b9cc2d8600d6bac6cff63",
+      "size": 2510
+    },
+    {
+      "path": "Notices/json/LICENSE.MIT",
+      "sha256": "46a65cffd1ea955132d95a8dd921640714a8d6b537d2e4e482d31145ae95b603",
+      "size": 1076
+    },
+    {
+      "path": "Notices/box3d/LICENSE",
+      "sha256": "da5e31a26bf3cfd5ba5c96d6823e480128c81e76c107ef9d3ee5d94789184b90",
+      "size": 1067
+    },
+    {
+      "path": "Notices/box2d/LICENSE",
+      "sha256": "68a3e676d7e94093b102d5cba0d4e04af812040d6f230c3db67a6664574e43d2",
+      "size": 1067
+    },
+    {
+      "path": "Notices/entt/LICENSE",
+      "sha256": "0785027ce472d7c61f05fba664a1d3ba6639c1593ced351ad9e4bed868765d99",
+      "size": 1097
+    },
+    {
+      "path": "Notices/sdl3/LICENSE.txt",
+      "sha256": "97f35b302b361680ec1e891e95d2d52097bb95abff361434916d99dc1305f127",
+      "size": 884
+    },
+    {
+      "path": "assets/5832763b-3ed0-44d6-9088-0b524f196a91/current.json",
+      "sha256": "b0732959808ce61ef5a3223fba2d9ad8c17a3ea7873d4a81c00aadee6c51032e",
+      "size": 134
+    },
+    {
+      "path": "assets/5832763b-3ed0-44d6-9088-0b524f196a91/generations/4a5bfcc1437a7b4d65c388da2beace0308cceda8e16503d08ce676260f21d5c2/manifest.json",
+      "sha256": "ee3f68794c6dc44ab492b1ba4640aa74e4de79a5ec10aed8dcdd45a03afc508e",
+      "size": 4532
+    },
+    {
+      "path": "assets/5832763b-3ed0-44d6-9088-0b524f196a91/generations/4a5bfcc1437a7b4d65c388da2beace0308cceda8e16503d08ce676260f21d5c2/meshes/mesh-93b5b3e52cb6bb120fefb80e2d8e222b-0.fmesh",
+      "sha256": "3875c16ea628d4126373ebfe07816621fbad3961596a2fcd112f1eec0e378071",
+      "size": 928
+    },
+    {
+      "path": "assets/5832763b-3ed0-44d6-9088-0b524f196a91/generations/4a5bfcc1437a7b4d65c388da2beace0308cceda8e16503d08ce676260f21d5c2/meshes/mesh-0961e2a3f92977836a3aa80cab09277e-0.fmesh",
+      "sha256": "98b38aca7d2786c58a2265ba4d1f2255123f03d31d947e239232cf55bfdc2c97",
+      "size": 928
+    },
+    {
+      "path": "assets/5832763b-3ed0-44d6-9088-0b524f196a91/generations/4a5bfcc1437a7b4d65c388da2beace0308cceda8e16503d08ce676260f21d5c2/meshes/mesh-fc069a07a87e0f831fd92efdbc4efa1f-0.fmesh",
+      "sha256": "98b38aca7d2786c58a2265ba4d1f2255123f03d31d947e239232cf55bfdc2c97",
+      "size": 928
+    },
+    {
+      "path": "shaders/gpuTemporalVertexMain.reflection.json",
+      "sha256": "7a8efe2645e7ce465ca44d19f8cfb2eb6c767abd1c3ce12ed69a149a50be8a8c",
+      "size": 3308
+    },
+    {
+      "path": "shaders/gpuTemporalVertexMain.spv",
+      "sha256": "dfe7309aafbd41974668b295e179354965db440e4156b9f12d6a67db16b357f9",
+      "size": 5996
+    },
+    {
+      "path": "shaders/temporalFragmentMain.reflection.json",
+      "sha256": "e36452227788f3703d7342b6d9a7a0efef74ce4da3aa96bb176a26e169ec3628",
+      "size": 3874
+    },
+    {
+      "path": "shaders/temporalFragmentMain.spv",
+      "sha256": "03adc6673276979b3ea46becf3a36940d3061af77cb8c965c7471feff8dbf89a",
+      "size": 30976
+    },
+    {
+      "path": "shaders/temporalVertexMain.reflection.json",
+      "sha256": "6f7812ce88b14bca62a6d2ad82a8657e2ee48c252558f34677c6a2bd980a7edb",
+      "size": 3935
+    },
+    {
+      "path": "shaders/temporalVertexMain.spv",
+      "sha256": "6cc3535c952a33ee46fd417fbec7fcad8f24357508b2119256b3077be3d60955",
+      "size": 1784
+    },
+    {
+      "path": "shaders/temporalCompositeFragmentMain.reflection.json",
+      "sha256": "44765a41fc362c9a97b1a19834f285e2e7facb24d8715e3d8559b8e9633a7a0e",
+      "size": 959
+    },
+    {
+      "path": "shaders/temporalCompositeFragmentMain.spv",
+      "sha256": "9e21c8534c0e70a58ae018fb2d143bf9cfb70112e71b67585f525eef0aecad1b",
+      "size": 768
+    },
+    {
+      "path": "shaders/temporalCompositeVertexMain.reflection.json",
+      "sha256": "a3a2ea858bd038423896043b0703704f707addceb5bd56721cd897f6bd092065",
+      "size": 956
+    },
+    {
+      "path": "shaders/temporalCompositeVertexMain.spv",
+      "sha256": "6b19f65b64f40d0a249660fdfba9dd5d95831ffab7314a307bf1f5cf39c6a248",
+      "size": 340
+    },
+    {
+      "path": "shaders/temporalResolveMain.reflection.json",
+      "sha256": "9407ee1522f32df231d996ea691224863c023c1ca42cc02ccd7e16de1d873082",
+      "size": 3179
+    },
+    {
+      "path": "shaders/temporalResolveMain.spv",
+      "sha256": "4c5fc0da7a4c424e5426694c2c2d9f3cd17d1a64066712f5defe882ad8776662",
+      "size": 22192
+    },
+    {
+      "path": "shaders/gpuPostCullMain.reflection.json",
+      "sha256": "19ce128388c7f88e0c517fb58a25e46f1382e35ae5f376b10eebe155a2811c4c",
+      "size": 3591
+    },
+    {
+      "path": "shaders/gpuHzbMain.reflection.json",
+      "sha256": "589818f670881c64f3aba726ee3bc82fe4b9d835a347f99134e0e157dc4a112e",
+      "size": 2050
+    },
+    {
+      "path": "shaders/gpuCullMain.reflection.json",
+      "sha256": "8986a45a8d29743d16f0caece9181b18c85d6490d93b4a56cdb4f53052890f3f",
+      "size": 3587
+    },
+    {
+      "path": "shaders/gpuShadowMain.reflection.json",
+      "sha256": "96b3620b163dadf214933cfba6600b1b6a835c4d98b75b1f83e6ccd3dedb2425",
+      "size": 2755
+    },
+    {
+      "path": "shaders/gpuVertexMain.reflection.json",
+      "sha256": "01a6cc1bbf3c11c558560d6f8557fd4582d392906ed20a8c729673d0ebf640ed",
+      "size": 3098
+    },
+    {
+      "path": "shaders/gpuPostCullMain.spv",
+      "sha256": "1f8edd3be1f99f9433494a6f7be68f1317d6e7099e19354a7b8130d5d932224d",
+      "size": 12548
+    },
+    {
+      "path": "shaders/gpuHzbMain.spv",
+      "sha256": "08682362ee2120ed19d260e613285071747c3e436bb09bb6238e46f9cedc2308",
+      "size": 4140
+    },
+    {
+      "path": "shaders/gpuCullMain.spv",
+      "sha256": "e5ea6589ddb3613b59f8e58420be95a534cf4149816bc65bae26b1395c638955",
+      "size": 16288
+    },
+    {
+      "path": "shaders/gpuShadowMain.spv",
+      "sha256": "f56e0ae3e9b31cb1e3f24e379c81e11c853f8a7102648aaaebc92a17c7e8e53c",
+      "size": 2492
+    },
+    {
+      "path": "shaders/gpuVertexMain.spv",
+      "sha256": "32421d4a91f3a88d5210fee7af34b48bcad83072f14e2ccb9ef2ff983e45f78f",
+      "size": 5016
+    },
+    {
+      "path": "shaders/shadowMain.reflection.json",
+      "sha256": "d39e2f83c797589296eac9dce139b9ad836a895d6685bc40f79dd2609d687fee",
+      "size": 3597
+    },
+    {
+      "path": "shaders/fragmentMain.reflection.json",
+      "sha256": "2b07af2aae7578bdb6c2aa22658538821608b1dd5aeddd7b06e42b2e78cedf12",
+      "size": 3596
+    },
+    {
+      "path": "shaders/vertexMain.reflection.json",
+      "sha256": "b3bdff863d53a0b385e06a36701a83a6ecafe9a93e97281a732cce8ff862c0db",
+      "size": 3591
+    },
+    {
+      "path": "shaders/lightTileMain.reflection.json",
+      "sha256": "bf6a9256aaa6d6edacfa1e1c265d7c8ce2c1e4ea4036e0bea078c22fd4b536ca",
+      "size": 1978
+    },
+    {
+      "path": "shaders/lightTileMain.spv",
+      "sha256": "92850edcc5ee5b586a90ce84ee69a98075a6fff3c13db4a57528d9431afe8b68",
+      "size": 6800
+    },
+    {
+      "path": "shaders/shadowMain.spv",
+      "sha256": "7643b4d688492b5ee923b9606f0b0e70343ca05fa67673838206119a6f86d8d8",
+      "size": 784
+    },
+    {
+      "path": "shaders/fragmentMain.spv",
+      "sha256": "fea4dd48664a510bad12b5e8582f2db798d4dbea62ce0de35dc2acfe32372733",
+      "size": 28960
+    },
+    {
+      "path": "shaders/vertexMain.spv",
+      "sha256": "1ad2631c35d654f48166321ae43d4165043e1b919b14f1dc61caf97b1ada0898",
+      "size": 1224
+    },
+    {
+      "path": "faset_player",
+      "sha256": "52fbe0067fc2be3807e60ffa5a77e819838dc50a4b723af51f16379b4a487e7c",
+      "size": 6163816
+    },
+    {
+      "path": "scene.fscene",
+      "sha256": "21c364140669ec82c6886102667b255df5ccdf0ec77e0ca64060f84dd7b86632",
+      "size": 8639
+    }
+  ],
+  "format": "faset.export",
+  "generation": "004c6e18-969b-4ef5-95bb-5d7742f96564",
+  "lua_enabled": false,
+  "lua_fingerprint": "",
+  "platform": "linux",
+  "prerequisites": [
+    "Linux x86_64",
+    "Vulkan 1.3 driver",
+    "Compatible glibc and libstdc++ runtime"
+  ],
+  "renderer_profile": {
+    "api": "Vulkan 1.3",
+    "materials": [
+      "base-color factor and texture",
+      "metallic and roughness factors"
+    ],
+    "required_features": [
+      "dynamicRendering",
+      "synchronization2"
+    ],
+    "shadow_atlases": {
+      "caster_draw_limit": 4096,
+      "fallback_resolution": 1024,
+      "local_face_limit": 16,
+      "preferred_resolution": 2048,
+      "sampled_d32_required": true,
+      "sun_cascade_limit": 4
+    },
+    "texture_sampling": "linear clamp, one mip level",
+    "unsupported_material_features": [
+      "normal maps",
+      "metallic-roughness maps",
+      "emissive and occlusion maps",
+      "alpha mode selection",
+      "unlit mode",
+      "per-material face culling"
+    ]
+  },
+  "scene_hash": "ee12794145c14ba5b599c5d9ae21648cccdfa91c47ee7742549f60d5fe7bc3e0",
+  "simulation": {
+    "fixed_delta": 0.016666666666666666,
+    "gravity": [
+      0,
+      -9.81,
+      0
+    ],
+    "max_catch_up_ticks": 4,
+    "physics_substeps": 4
+  },
+  "units": {
+    "angle": "radian",
+    "coordinates": "right-handed Y-up",
+    "distance": "metre"
+  },
+  "validation_log": "warning: material material-bb63b094febbf90bb7049c9bcf7587bc has features beyond the initial base-color/PBR renderer\n{\"dimension\":3,\"validated\":true}\n",
+  "version": 1
+}

docs/validation/p1-iteration-2026-09-24/final-release/evidence/collect-3d-run.json

@@ -0,0 +1,18 @@
+{
+  "arguments": [
+    "/tmp/faset-p1-final-packages-4a3453e/Faset Café 世界/collect-3d/faset_player",
+    "--headless",
+    "--frames",
+    "120",
+    "--capture",
+    "/tmp/faset-p1-final-packages-4a3453e/Faset Café 世界/collect-3d/verification.ppm",
+    "--profile",
+    "/tmp/faset-p1-final-packages-4a3453e/Faset Café 世界/collect-3d/profile.json"
+  ],
+  "cwd": "/tmp/faset-p1-final-packages-4a3453e/empty-working-directory",
+  "seconds": 0.6575766110036056,
+  "exit_code": 0,
+  "timed_out": false,
+  "stdout": "New round: collect the three gold cubes, then reach the green exit. E resets.\n{\"device\":\"NVIDIA GeForce RTX 2080 Ti\",\"dimension\":3,\"effective_temporal_mode\":\"off\",\"effective_visibility_mode\":\"direct\",\"frames\":120,\"gpu_visibility_active\":false,\"temporal_mode\":\"off\",\"ticks\":120,\"validation_errors\":0,\"visibility_mode\":\"direct\"}\n",
+  "stderr": "warning: material material-bb63b094febbf90bb7049c9bcf7587bc has features beyond the initial base-color/PBR renderer\n"
+}