fix render under ingame ui

Author: henderkes

GWToolboxdll/Modules/TestHarness.cpp

@@ -530,6 +530,10 @@ void TestHarness::Initialize()
 {
     ToolboxModule::Initialize();
 #ifdef HARNESS_ENABLED
+    // A command written before this instance existed is stale (e.g. the reload script's `shutdown`
+    // left unconsumed when no toolbox was loaded); executing it would kill the fresh instance.
+    std::error_code ec;
+    std::filesystem::remove(cmd_path(), ec);
     std::string existing;
     if (!Resources::ReadFile(config_path(), existing)) {
         Resources::WriteFile(config_path(),

GWToolboxdll/Utils/GameWorldCompositor.cpp

@@ -42,6 +42,9 @@ namespace {
     bool compositor_failed = false;
     bool compositor_hooked = false;
     bool drawn_this_frame = false; // guard: draw only in the first world pass per frame
+#ifdef _DEBUG
+    int dump_calls_remaining = 0; // harness `frcache` diagnostics: log buffer layout for the next N calls
+#endif
 
     // Registered overlay draws, invoked in registration order between world and HUD.
     std::vector<std::pair<int, GameWorldCompositor::DrawCallback>> callbacks;
@@ -113,6 +116,20 @@ namespace {
         GW::Hook::EnterHook();
         IDirect3DDevice9* device = GW::Render::GetDevice();
 
+#ifdef _DEBUG
+        if (dump_calls_remaining > 0 && render_buffer) {
+            dump_calls_remaining--;
+            auto& buf = *render_buffer;
+            Log::Log("[frcache] call size=%u drawn_this_frame=%d", buf.size(), drawn_this_frame ? 1 : 0);
+            for (uint32_t i = 0; i < buf.size(); i++) {
+                const auto& e = buf[i];
+                const GW::UI::Frame* f = (e.type != FRCACHE_GPU_RENDER && frame_array && e.index < frame_array->size()) ? (*frame_array)[e.index] : nullptr;
+                Log::Log("[frcache]   i=%u type=%u index=%u param=0x%x frame_id=%d visible=%d",
+                         i, (uint32_t)e.type, e.index, e.param, f ? (int)f->frame_id : -1, f && f->IsVisible() ? 1 : 0);
+            }
+        }
+#endif
+
         // Nothing to do (no overlays, unusable buffer/device) -> run the original untouched.
         if (callbacks.empty() || !render_buffer || !device) {
             FrCacheRenderAll_Ret(param_1, param_2);
@@ -122,37 +139,45 @@ namespace {
 
         auto& buffer = *render_buffer;
 
-        // The main 3D scene is the FIRST GPU_RENDER block; everything after is HUD - including the 2D HUD and
-        // agent/UI 3D renders, which all correctly draw over us. Split right after the first GPU block. (Skipping
-        // further consecutive GPU blocks would swallow GPU-rendered HUD entries into the world side, so our
-        // overlays would then draw on top of them.) UI-only/sub-render passes have no GPU block, so boundary
-        // stays == size and is skipped below.
-        uint32_t boundary = buffer.size();
+        // The main 3D scene starts with the FIRST GPU_RENDER entry; the HUD follows, possibly interleaved
+        // with further GPU entries (e.g. Domain of Anguish's frame keeps GPU slices to the very end). GPU
+        // entries are (index, count) slices of ONE contiguous GR command stream - FlushCommandQueue at the
+        // boundary materialises the whole queued world regardless of where the slices sit, so splitting
+        // right after the first GPU entry is safe. A GPU entry whose index does NOT continue the stream
+        // (index != previous index + count) is a SECOND world-render dispatch (e.g. a 3D bust in the
+        // hero/character panel): running that in a split-off second call re-runs the per-object cloth/hair
+        // physics off a fixed 1/30s accumulator not designed to advance twice in one real frame, desyncing
+        // constraint indices from the double-buffered positions (garbage spring-solver index / GrBound.cpp
+        // assert in wild dumps). UI-only/sub-render passes have no GPU entry, so boundary stays 0 and is
+        // skipped below.
+        uint32_t boundary = 0;
+        bool stream_restart = false;
+        uint32_t stream_expect = 0;
         for (uint32_t i = 0; i < buffer.size(); i++) {
-            if (buffer[i].type == FRCACHE_GPU_RENDER) {
-                boundary = i + 1;
+            const auto& e = buffer[i];
+            if (e.type != FRCACHE_GPU_RENDER) continue;
+            if (boundary == 0) boundary = i + 1;
+            else if (e.index != stream_expect) {
+                stream_restart = true;
                 break;
             }
+            stream_expect = e.index + e.param;
         }
 
-        // A second GPU_RENDER block after the boundary (e.g. a 3D bust in the hero/character panel)
-        // means GW is about to run its full world-render dispatch again this frame. That dispatch
-        // drives per-object animation/physics ticks off a fixed 1/30s accumulator that isn't safe to
-        // advance twice within one real frame -- doing so desyncs a cloth/hair object's constraint
-        // indices from its double-buffered positions (crash: garbage index in the spring solver, or
-        // a degenerate bounding volume asserting in GrBound.cpp). Bail out to a single untouched call
-        // in that case; our overlay draws on top of that rare secondary 3D content instead of under it.
-        bool has_second_gpu_render = false;
-        for (uint32_t i = boundary; i < buffer.size(); i++) {
-            if (buffer[i].type == FRCACHE_GPU_RENDER) {
-                has_second_gpu_render = true;
-                break;
-            }
+        // Only the main world-then-HUD pass draws; others pass through, and the guard draws exactly once per frame.
+        if (boundary == 0 || boundary >= buffer.size() || drawn_this_frame) {
+            FrCacheRenderAll_Ret(param_1, param_2);
+            GW::Hook::LeaveHook();
+            return;
         }
 
-        // Only the main world-then-HUD pass draws; others pass through, and the guard draws exactly once per frame.
-        if (boundary == 0 || boundary >= buffer.size() || drawn_this_frame || has_second_gpu_render) {
+        // Second dispatch present: keep GW's calls untouched (single call, single physics tick) and draw the
+        // overlays on top of the HUD for just this frame.
+        if (stream_restart) {
             FrCacheRenderAll_Ret(param_1, param_2);
+            GW::Render::FlushCommandQueue();
+            RunCallbacks(device);
+            drawn_this_frame = true;
             GW::Hook::LeaveHook();
             return;
         }
@@ -287,6 +312,13 @@ void GameWorldCompositor::UnregisterDraw(const int token)
     }
 }
 
+#ifdef _DEBUG
+void GameWorldCompositor::RequestBufferDump()
+{
+    dump_calls_remaining = 50;
+}
+#endif
+
 bool GameWorldCompositor::IsActive()
 {
     return compositor_hooked && !compositor_failed;

GWToolboxdll/Utils/GameWorldCompositor.h

@@ -54,6 +54,11 @@ namespace GameWorldCompositor {
     [[nodiscard]] IDirect3DPixelShader9* PixelShader();
     [[nodiscard]] IDirect3DVertexDeclaration9* VertexDeclaration();
 
+#ifdef _DEBUG
+    // Log every FrCacheRenderAll invocation's buffer layout for the next few calls (harness diagnostics).
+    void RequestBufferDump();
+#endif
+
     // Remove the hook and release shared GPU resources (shutdown).
     void Terminate();
 } // namespace GameWorldCompositor

GWToolboxdll/Windows/InfoWindow.cpp

@@ -132,7 +132,12 @@ namespace {
     }
     bool FileIdField(const char* label, const wchar_t* enc_str)
     {
-        return FileIdField(label, ArenaNetFileParser::FileHashToFileId(enc_str));
+        // Show the raw enc chars, not a re-encoding of the decoded id — when decode fails (0), the raw
+        // string is the only clue to what the game actually passed.
+        EncInfoField(label, enc_str);
+        const std::string label2 = std::format("{} (File ID)", label);
+        InfoField(label2.c_str(), "0x%X", ArenaNetFileParser::FileHashToFileId(enc_str));
+        return false;
     }
 
     void GetIdsFromFileId(const uint32_t param_1, short* param_2)
@@ -1034,7 +1039,13 @@ namespace {
         switch (message_id) {
             case GW::UI::UIMessage::kLoadMapContext: {
                 const auto packet = static_cast<GW::UI::UIPacket::kLoadMapContext*>(wParam);
-                wcscpy(mapfile, packet->file_name);
+                if (packet->file_name) {
+                    wcsncpy(mapfile, packet->file_name, _countof(mapfile) - 1);
+                    mapfile[_countof(mapfile) - 1] = 0;
+                }
+                else {
+                    mapfile[0] = 0;
+                }
             } break;
         }
     }

GWToolboxdll/Windows/Pathfinding/PathfindingWindow.cpp

@@ -448,6 +448,18 @@ namespace {
             }
         }
 
+        // A ctx-fallback entry (bounds mismatch below) is keyed by map_id + live node count, not fid — probe for it
+        // or the resident-only path never sees it and the prewarm loop re-reads the DAT forever.
+        if (map_id == GW::Map::GetMapID()) {
+            if (const auto mc = GW::GetMapContext(); mc && mc->path && mc->path->staticData) {
+                const auto ctx_hash = static_cast<uint64_t>(map_id) | (static_cast<uint64_t>(mc->path->pathNodes.size()) << 32);
+                if (const auto it = mile_paths_by_coords.find(ctx_hash); it != mile_paths_by_coords.end()) {
+                    TouchLru(ctx_hash);
+                    return it->second;
+                }
+            }
+        }
+
         // Not resident: the DAT read + parse below blocks the caller. Refuse on the game thread.
         if (!allow_load) return nullptr;
 
@@ -478,7 +490,9 @@ namespace {
         auto& map_data = *chosen;
 
         // file_id was not resident above, so this full key (file_id + pathNodeSize) is new too.
-        auto hash = static_cast<uint64_t>(fid);
+        // Ctx-fallback data must not be cached under the (stale) fid: it would shadow the real file's mesh
+        // for every other map sharing that fid. Key it by map_id like LoadMapFromContext does.
+        auto hash = chosen == &ctx_data ? static_cast<uint64_t>(map_id) : static_cast<uint64_t>(fid);
         hash |= static_cast<uint64_t>(map_data.pathNodeSize) << 32;
 
         // Cache map info for bounds drawing
@@ -2396,8 +2410,20 @@ namespace {
 
     std::set<uint32_t> file_id_mismatch_warned; // maps already warned about
 
+    // Maps whose outpost shares the explorable's MapID but loads a different map file (the constant table holds the
+    // explorable file; the outpost's kLoadMapContext file_name doesn't decode, so the runtime override can't catch it).
+    constexpr std::pair<GW::Constants::MapID, uint32_t> outpost_file_id_overrides[] = {
+        {GW::Constants::MapID::Domain_of_Anguish, 0x3452b}, // outpost = shared torment gate room; explorable = 0x3584f
+    };
+
     uint32_t GetMapFileId(GW::Constants::MapID map_id)
     {
+        if (map_id == GW::Map::GetMapID() && GW::Map::GetInstanceType() == GW::Constants::InstanceType::Outpost) {
+            for (const auto& [mid, outpost_fid] : outpost_file_id_overrides) {
+                if (mid == map_id) return outpost_fid;
+            }
+        }
+
         // Check runtime lookup table (populated from constant_maps_info + StoC packets)
         auto it = map_id_to_file_hash.find(map_id);
         if (it != map_id_to_file_hash.end()) return it->second;

GWToolboxdll/Windows/Pathfinding/maps_constant_data.h

@@ -148,7 +148,6 @@ std::unordered_map<int, std::vector<MapConstantInfo>> constant_maps_info = {
     {GW::Constants::MapID::Kamadan_Jewel_of_Istan_explorable, 0},
     {GW::Constants::MapID::The_Tribunal, 0},
     {GW::Constants::MapID::Cliffs_of_Dohjok, 0},
-    {GW::Constants::MapID::The_Ebony_Citadel_of_Mallyx_mission, 0},
     {GW::Constants::MapID::A_Land_of_Heroes, 0},
     {GW::Constants::MapID::Crystal_Overlook, 0},
     {GW::Constants::MapID::Gate_of_Anguish_elite_mission, 0},
@@ -891,7 +890,6 @@ std::unordered_map<int, std::vector<MapConstantInfo>> constant_maps_info = {
    {{GW::Constants::MapID::Gate_of_Torment_outpost, 0x3452b},
     {GW::Constants::MapID::Gate_of_Fear_outpost, 0x3452b},
     {GW::Constants::MapID::Gate_of_Secrets_outpost, 0x3452b},
-    {GW::Constants::MapID::Domain_of_Anguish, 0x3452b},
     {GW::Constants::MapID::Gate_of_Pain, 0x3452b},
     {GW::Constants::MapID::Gate_of_Madness, 0x3452b},
     {GW::Constants::MapID::Gate_of_the_Nightfallen_Lands_outpost, 0x3452b}}},
@@ -912,6 +910,9 @@ std::unordered_map<int, std::vector<MapConstantInfo>> constant_maps_info = {
    {{GW::Constants::MapID::Domain_of_Pain, 0x34bcc}}},
   {0x3583e,
    {{GW::Constants::MapID::Domain_of_Secrets, 0x3583e}}},
+  {0x3584f,
+   {{GW::Constants::MapID::Domain_of_Anguish, 0x3584f},
+    {GW::Constants::MapID::The_Ebony_Citadel_of_Mallyx_mission, 0x3584f}}},
   {0x33c20,
    {{GW::Constants::MapID::Jennurs_Horde, 0x33c20}}},
   {0x3443c,