main.cpp

#define IMGUI_DEFINE_MATH_OPERATORS

#include <imgui.h>
#include <imgui_impl_sdl2.h>
#include <imgui_impl_opengl3.h>

#include <iostream>
#include <SDL.h>
#if defined(IMGUI_IMPL_OPENGL_ES2)
#include <SDL_opengles2.h>
#else
#include <SDL_opengl.h>
#endif

#ifndef GL_FRAMEBUFFER
#define GL_FRAMEBUFFER 0x8D40
#define GL_COLOR_ATTACHMENT0 0x8CE0
#endif

#include <stdio.h>
#include <vector>
#include <limits>
#include <algorithm>
#include <chrono>
#include <string>
#include <cstdlib>  // atoi
#include "TileCache.h"
#include "nodes.h" //Also includes DataMOdel.h and LayoutEngine.h
#include "GLFunctions.h"
#include "GPURenderer.h"
#include "PhysicsLayoutSimulation.h"
#include "Debug.h"

// Verbose debug output (prints, profiling, layout-engine detail dumps). Off unless --debug is passed.
bool gDebugEnabled = false;

#ifdef _WIN32
#include <psapi.h>
#pragma comment(lib, "psapi.lib")

// Request the discrete GPU on hybrid-graphics laptops - Windows otherwise defaults an unrecognized
// .exe to the iGPU, whose Intel driver gives a strict GL 3.0 context and no compute shaders. Both
// vendors' drivers look these up by name at process start, so they must stay exported.
// (DWORD spelled as unsigned long so this doesn't depend on windows.h being included first.)
extern "C" {
    __declspec(dllexport) unsigned long NvOptimusEnablement = 0x00000001;
    __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
}
#endif

// Calculate bounding box of all nodes
ImVec2 CalculateNodesBounds(const ImGui::GraphView& graphView, ImVec2& outMin, ImVec2& outMax)
{
    outMin = ImVec2(std::numeric_limits<float>::max(), std::numeric_limits<float>::max());
    outMax = ImVec2(std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest());

    for (const std::pair<const int, ImGui::NodeView*> pair : graphView.nodeViewCache_)
    {
        const ImGui::NodeView* node = pair.second;
        outMin.x = ImMin(outMin.x, node->area_node_.Min.x);
        outMin.y = ImMin(outMin.y, node->area_node_.Min.y);
        outMax.x = ImMax(outMax.x, node->area_node_.Max.x);
        outMax.y = ImMax(outMax.y, node->area_node_.Max.y);
    }

    return ImVec2(outMax.x - outMin.x, outMax.y - outMin.y); // Return size
}

// Get system RAM in GB (total)
float GetSystemRAM_GB() {
#ifdef _WIN32
    MEMORYSTATUSEX memInfo;
    memInfo.dwLength = sizeof(MEMORYSTATUSEX);
    GlobalMemoryStatusEx(&memInfo);
    return (float)memInfo.ullTotalPhys / (1024.0f * 1024.0f * 1024.0f);
#else
    return 16.0f;  // Conservative default for Linux/Mac
#endif
}

// Get total used physical RAM in GB (by all processes)
float GetUsedPhysicalRAM_GB() {
#ifdef _WIN32
    MEMORYSTATUSEX memInfo;
    memInfo.dwLength = sizeof(MEMORYSTATUSEX);
    GlobalMemoryStatusEx(&memInfo);
    // Total - Available = Used by all processes (no paging lies)
    DWORDLONG usedBytes = memInfo.ullTotalPhys - memInfo.ullAvailPhys;
    return (float)usedBytes / (1024.0f * 1024.0f * 1024.0f);
#else
    return 8.0f;  // Conservative default for Linux/Mac
#endif
}

// Commit headroom (pagefile-backed) in GB, i.e. ullAvailPageFile.
//
// Distinct from free physical RAM and worth tracking separately: Windows charges a tile's FULL byte
// count against the commit limit the moment it is allocated, whether or not those pages are ever
// resident. Physical RAM can look comfortable while commit is nearly gone - measured here at 146 tiles
// (18.25 GB of tile bytes): working set 11.9 GB but private/commit 21.4 GB. Commit exhaustion is what
// fails allocations outright, so it is the constraint behind the silent crashes at high node counts,
// where the tile set plus the node/edge structures outran commit while free RAM still read fine.
//
// IMPORTANT: this is an instantaneous reading and NOT a ceiling. With a system-managed pagefile Windows
// grows the pagefile on demand, which RAISES the commit limit, so a small reading here does not mean an
// allocation would fail - it means the OS would expand backing store to satisfy it. Budget against
// GetEffectiveCommit_GB() instead, which adds that growth room. Using this value directly as a limit
// throttled the tile cache far below what the machine could run (see kDiskReserveGB).
float GetAvailableCommit_GB() {
#ifdef _WIN32
    MEMORYSTATUSEX memInfo;
    memInfo.dwLength = sizeof(MEMORYSTATUSEX);
    GlobalMemoryStatusEx(&memInfo);
    return (float)memInfo.ullAvailPageFile / (1024.0f * 1024.0f * 1024.0f);
#else
    return 8.0f;  // Conservative default for Linux/Mac
#endif
}

// Disk space left untouched when counting pagefile growth room. The pagefile can in principle grow until
// the volume is full; letting the tile budget bank on that would trade a graph nobody asked for against
// a wedged OS, so a fixed slice of the disk is never counted as commit.
static const float kDiskReserveGB = 8.0f;

// Free space on the volume holding the pagefile, i.e. how far the commit limit can still grow.
float GetPagefileVolumeFree_GB() {
#ifdef _WIN32
    ULARGE_INTEGER freeBytesAvailable;
    // The system pagefile lives on the Windows volume; GetWindowsDirectory gives us that root without
    // assuming a drive letter.
    char winDir[MAX_PATH] = {0};
    if (!GetWindowsDirectoryA(winDir, MAX_PATH)) return 0.0f;
    char root[4] = { winDir[0], ':', '\\', '\0' };
    if (!GetDiskFreeSpaceExA(root, &freeBytesAvailable, NULL, NULL)) return 0.0f;
    return (float)freeBytesAvailable.QuadPart / (1024.0f * 1024.0f * 1024.0f);
#else
    return 0.0f;
#endif
}

// Commit we can actually count on: what is free now, PLUS what the pagefile can still grow into.
//
// This is the correction for the tile cache being throttled below its predecessor. Budgeting against the
// instantaneous available commit alone was wrong twice over on a machine with a small auto-managed
// pagefile: measured 20.3 GB free commit but only 0.77 GB of a 7.5 GB pagefile actually in use (peak
// 1.5 GB), with 18 GB of free disk behind it. The commit limit was nowhere near its real ceiling, yet
// the check reported ~3.3 GB headroom against a 3.2 GB margin and pinned the cap at once - so a layout
// that used to render stopped completing.
//
// Counting growth room makes physical RAM the binding limit again, which is the intended design: RAM is
// the resource whose exhaustion actually kills the process, and it is the one the safety margin guards.
float GetEffectiveCommit_GB() {
    float growthRoom = GetPagefileVolumeFree_GB() - kDiskReserveGB;
    if (growthRoom < 0.0f) growthRoom = 0.0f;
    return GetAvailableCommit_GB() + growthRoom;
}

float TilePhysicalCostGB();  // defined with the tile budget model below
float TileVRAMCreditGB();    // ditto - tile bytes the card absorbs, applied once to the whole set

// How far the tile set's commit may exceed physical RAM, i.e. how much of it may be pagefile-backed by
// design. Zero: the set is sized to fit in RAM, leaving the pagefile as spillover Windows may use rather
// than budget spent in advance. Raising it buys tiles (~+35k grid nodes per 2 GB on a 32 GB machine) but not
// tiles you can rely on: Windows picks what gets paged out, so a paged tile makes a pan block on disk I/O.
// Set by --commit-overrun; see PrintUsage for the user-facing warning.
float gCommitOverrunGB = 0.0f;


//Memory Enforcer
// Returns true if memory is within safe limits, false if critically high
// STRATEGY: Check total system RAM usage (all processes) and keep safetyMarginGB free
bool EnforceMemoryLimits(TileCache& tileCache, float totalSystemRAM_GB, float safetyMarginGB, bool forceCheck = false) {
#ifdef _WIN32
    static float lastCheck = 0.0f;
    float currentTime = ImGui::GetTime();

    // Only do expensive check every 0.5 seconds (unless forced)
    if (!forceCheck && currentTime - lastCheck < 0.5f) {
        return true;  // Assume OK between checks
    }

    lastCheck = currentTime;

    // Get total physical RAM used by all processes
    float usedSystemRAM_GB = GetUsedPhysicalRAM_GB();
    float freeSystemRAM_GB = totalSystemRAM_GB - usedSystemRAM_GB;

    // Commit headroom, counting pagefile growth room. MUST be the effective value, not the instantaneous
    // one: with a system-managed pagefile a low instantaneous reading just means Windows would grow the
    // file, so throttling on it stalls allocations the OS would have happily backed. Gating on the raw
    // value here is exactly what froze the cap mid-bake and made layouts stop completing.
    float availCommit_GB = GetEffectiveCommit_GB();

    // Also get our process usage for informational purposes
    PROCESS_MEMORY_COUNTERS_EX pmc;
    float ourProcessGB = 0.0f;
    if (GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc))) {
        ourProcessGB = pmc.WorkingSetSize / (1024.0f * 1024.0f * 1024.0f);
    }

    // Memory pressure response: STOP GROWING, don't shrink.
    //
    // Dipping below the margin means "allocate no more", not "give tiles back". Tiles already allocated
    // cost nothing to keep and are the entire point of the cache, so evicting them to recover a fraction
    // of a tile's worth of RAM is pure loss - it throws away work the user can see.
    //
    // This deliberately does NOT lower the cap by a tile on every call. Doing so over-evicted badly:
    // freeing a texture doesn't return its RAM to the OS synchronously (the driver releases lazily), so
    // the next check still read low, lowered the cap again, and kept going until the driver caught up -
    // tens of tiles gone over a fraction-of-a-tile shortfall, and the cap never recovered afterward.
    // Eviction is now driven only by EvictLRU() enforcing this cap, i.e. when tiles genuinely exceed it.
    //
    // Either resource running short freezes allocation, but they get different thresholds because they
    // fail differently. RAM keeps the full safety margin - overrunning it means Windows kills us. Commit
    // only needs room for the tile actually in flight: it has already had kDiskReserveGB held back inside
    // GetEffectiveCommit_GB(), and running short grows the pagefile rather than killing the process.
    // Charging the RAM margin against commit too (the earlier version) double-counted it and tripped this
    // branch immediately, which is what capped the tile cache below its old value.
    const float commitFloorGB = TileCache::TileSizeGB() * 2.0f;
    bool lowRAM = freeSystemRAM_GB < safetyMarginGB;
    bool lowCommit = availCommit_GB < commitFloorGB;

    if (lowRAM || lowCommit) {
        int currentAllocated = tileCache.GetAllocatedTileCount();

        // Freeze allocation at the current level. Only ever lowers the cap to what is already allocated,
        // so this cannot trigger an eviction by itself.
        if (currentAllocated < TileCache::MAX_CACHED_TILES) {
            printf("\n*** Low %s: %.1f GB free RAM, %.1f GB usable commit (floors: %.1f / %.2f GB)"
                   " - pausing tile allocation ***\n",
                lowCommit ? "commit" : "RAM", freeSystemRAM_GB, availCommit_GB,
                safetyMarginGB, commitFloorGB);
            printf("    System total: %.1f GB, Used: %.1f GB (our process: %.1f GB)\n",
                totalSystemRAM_GB, usedSystemRAM_GB, ourProcessGB);
            printf("    Holding %d cached tiles; will resume if memory frees up\n", currentAllocated);
            TileCache::MAX_CACHED_TILES = currentAllocated;
            // Don't let the recovery path below hand this budget straight back on the next 0.5s tick.
            // The ceiling was computed at startup from a prediction; pressure is a measurement, and the
            // measurement wins.
            TileCache::TILE_BUDGET_CEILING = currentAllocated;
        }

        // LAST RESORT: actually shed tiles. Freezing allocation above is not sufficient on its own,
        // because past this point our working set keeps climbing WITHOUT us allocating anything. Tile
        // textures live partly in VRAM, and as the set outgrows the card the driver progressively spills
        // already-allocated tiles back into system memory - measured on a 9.4 GB card: 66 tiles (8.25 GB
        // of tile bytes) sat at a 1.01 GB working set with everything resident on the GPU, while 200 tiles
        // (25.0 GB) sat at 19.22 GB. Nothing new was allocated between those points in the tile count that
        // the pause could have stopped; the RAM arrived on its own. That is why the warning fires and free
        // RAM keeps falling anyway, and it is the mechanism behind the silent process death.
        //
        // So below a hard floor - genuinely about to be killed, not merely inside the margin - give tiles
        // back. This is the only lever that returns memory, and the trade is no longer close: a few tiles
        // going blank (they re-bake when memory allows) beats the process disappearing.
        const float kCriticalRAM_GB = safetyMarginGB * 0.5f;
        const int   kMinTilesToKeep = 4;   // enough to keep something on screen while we recover
        if (freeSystemRAM_GB < kCriticalRAM_GB && currentAllocated > kMinTilesToKeep) {
            // Shed the shortfall in tiles, plus one so we land clear of the floor rather than on it.
            int shed = (int)((kCriticalRAM_GB - freeSystemRAM_GB) / TilePhysicalCostGB()) + 1;
            int target = currentAllocated - shed;
            if (target < kMinTilesToKeep) target = kMinTilesToKeep;
            printf("*** CRITICAL: %.1f GB free RAM is below the %.1f GB hard floor"
                   " - shedding %d of %d tiles to stay alive ***\n",
                   freeSystemRAM_GB, kCriticalRAM_GB, currentAllocated - target, currentAllocated);
            TileCache::MAX_CACHED_TILES = target;
            TileCache::TILE_BUDGET_CEILING = target;
            tileCache.EvictLRU(true);  // may free VISIBLE tiles - see EvictLRU; nothing else is left here
        }

        return false;  // Memory pressure detected - callers must not allocate
    }

    // Recovery: RAM freed up, so let the cap climb back toward the startup budget. Without this, any
    // brief dip (another process spiking, a driver paging burst) lowered the cap permanently and the
    // tile count could only fall over the life of a session.
    //
    // Requires clearing the margin by a full tile plus a margin of its own, not just the margin itself:
    // recovering the instant we cross back would re-allocate, dip below again and oscillate.
    const float kRecoveryHysteresisGB = TileCache::TileSizeGB() * 2.0f;
    if (TileCache::MAX_CACHED_TILES < TileCache::TILE_BUDGET_CEILING &&
        freeSystemRAM_GB > safetyMarginGB + kRecoveryHysteresisGB &&
        availCommit_GB > commitFloorGB + kRecoveryHysteresisGB) {
        // Step up by the headroom actually available, so recovery tracks real memory rather than a guess.
        // Gated on BOTH resources at their own per-tile cost and their own floor - commit uses
        // commitFloorGB, not the RAM safety margin, for the reasons given at the pressure check above.
        //
        // No VRAM credit is added here, unlike TileBudgetForMemory(): freeSystemRAM_GB is a LIVE reading,
        // so whatever the card is already absorbing for the current tiles is priced into it. Crediting it
        // again would count it twice and hand back the overshoot this model exists to prevent.
        int affordableRAM = (int)((freeSystemRAM_GB - safetyMarginGB - kRecoveryHysteresisGB)
                                  / TilePhysicalCostGB());
        int affordableCommit = (int)((availCommit_GB - commitFloorGB - kRecoveryHysteresisGB)
                                     / TileCache::TileSizeGB());
        int affordable = affordableRAM < affordableCommit ? affordableRAM : affordableCommit;
        // Ramp rather than jumping the whole headroom: each new tile's real cost only shows up in
        // freeSystemRAM_GB after the driver commits it, so a single large step can allocate straight
        // through the margin before the next check (0.5s later) can see it.
        const int kMaxRecoveryStep = 4;
        if (affordable > kMaxRecoveryStep) affordable = kMaxRecoveryStep;
        if (affordable > 0) {
            int raised = TileCache::MAX_CACHED_TILES + affordable;
            TileCache::MAX_CACHED_TILES = raised > TileCache::TILE_BUDGET_CEILING
                                        ? TileCache::TILE_BUDGET_CEILING : raised;
        }
    }

    return true;  // Memory OK
#else
    return true;  // Non-Windows, no check
#endif
}

// Get GPU VRAM in GB
float GetGPU_VRAM_GB() {
    GLint totalMemKB = 0;

    // Try NVIDIA extension
    glGetIntegerv(0x9049, &totalMemKB);  // GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX
    if (totalMemKB > 0) {
        return totalMemKB / (1024.0f * 1024.0f);  // KB to GB
    }

    // Try AMD extension
    GLint memInfo[4] = {0};
    glGetIntegerv(0x87FC, memInfo);  // GL_VBO_FREE_MEMORY_ATI
    if (memInfo[0] > 0) {
        return memInfo[0] / (1024.0f * 1024.0f);  // KB to GB
    }

    // Intel GPU detection (Battlemage/Arc)
    const char* renderer = (const char*)glGetString(GL_RENDERER);
    if (renderer && strstr(renderer, "Intel")) {
        GLint maxTexSize = 0;
        glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTexSize);
        // Heuristic for discrete Intel GPUs
        if (maxTexSize >= 16384) {
            return 12.0f;  // Battlemage typically has 12GB
        }
    }

    // Fallback
    return 4.0f;
}

// Tile bytes the GPU holds resident, and which therefore do NOT land in our working set.
//
// A tile reserves TILE_SIZE^2 * 2 bytes, but that is its COMMIT cost, not its physical cost. Tiles are
// GL textures: part of the set is resident in VRAM at any moment, and the driver's system-memory copy of
// that part is not charged to us. Measured on a 31.7 GB / 9.2 GB-VRAM machine baking a 128-tile layout
// (16.0 GB of tile bytes): free RAM fell 21.5 -> 10.0 GB, i.e. 11.5 GB physical for 16.0 GB of bytes -
// so ~4.5 GB of the set was living on the card.
//
// An ABSOLUTE CAP, not a fraction of each tile. This is the correction for the budget creeping up on the
// RAM ceiling: the card holds what it holds no matter how many tiles exist, so once the set exceeds VRAM
// every FURTHER tile costs its full bytes in RAM. Charging a flat 0.75 of every tile instead made the
// model's error grow with tile count - calibrated at 128 tiles it broke even near 144, then under-charged
// by ~1.5 GB at 191, which swallowed half the safety margin and left free RAM within ~2 GB of the cliff.
// Subtracting a lump credit keeps the low-count generosity (where the card really does hold most of the
// set) while charging the marginal tile honestly at the high end, where the overshoot was.
//
// Half of VRAM: the driver also needs the card for the framebuffer, the node/edge/text vertex buffers and
// the SPH SSBOs, so the whole of it is never available to tiles. Conservative on purpose - under-crediting
// costs a few tiles, over-crediting walks back into the RAM ceiling.
float TileVRAMCreditGB() {
    float credit = GetGPU_VRAM_GB() * 0.5f;
    return credit > 0.0f ? credit : 0.0f;
}

// Physical-RAM cost of one allocated tile at the margin, as opposed to TileSizeGB() which is its commit
// cost. Full bytes: the VRAM credit is applied once to the whole set (see TileVRAMCreditGB), not per tile,
// so the next tile allocated past saturation costs all of itself in RAM.
float TilePhysicalCostGB() {
    return TileCache::TileSizeGB();
}

// Heap cost of the NON-TILE structures: the data model, the layout maps, the node view cache, the edge
// render cache and the spatial buckets. These are not tiles, but they are charged to the same physical RAM
// and the same commit, and until now the budget model ignored them entirely - which is precisely why free
// RAM ended up 2 GB from the ceiling (and sometimes past it) even with the tile count correctly capped.
// At 650k nodes they are 2.4 GB, i.e. most of a 3.2 GB safety margin, spent before a single tile is priced.
//
// Two coefficients, because the cost genuinely has both terms and the ratio between them is not fixed:
//   per node - data model 730 B, node view cache 1419 B (NodeView + its per-port allocations),
//              layout maps 97 B, node buckets 29 B.
//   per edge - edge render cache 93 B: a 48 B CachedEdge, its polyline in edgePointPool_ (16 B for the
//              straight 2-point edges the grid generates) and the edgeIndexByNode_ entry. Deeper routes
//              add 8 B per extra waypoint, so this term is a floor for layered datasets.
//
// Measured, not derived: instrumented working-set deltas around each build stage on this machine.
// The model was fitted at 650k nodes / 3.25M edges (2.410 GB) and checked at 200k / 1.0M (predicts
// 0.741 GB, measured 0.742) - so it holds across a 3x range and across a changing edge ratio.
//
// Split into what's built EAGERLY (data model + layout, during setup) and what's built LAZILY (node view
// cache, edge render cache, buckets - all inside the first bake). The split matters because the two
// budget call sites sit on opposite sides of it: the auto-sizer runs before the model exists and must
// reserve the whole cost, while CheckTileSafety runs after the layout, where the eager part is already
// visible in the live free-RAM reading and charging it again would understate the budget by ~0.5 GB.
// Edges per node in the synthetic grid dataset (DataModel::CreateNodesGrid connects each node to the
// previous one with 5 edges). The auto-sizer needs the edge count before the model exists, so it can't
// read it back - keep this in step with CreateNodesGrid or the reserved heap will be wrong.
const int kGridEdgesPerNode = 5;

const float kGraphHeapEagerBytesPerNode = 827.0f;    // data model 730 + layout maps 97
const float kGraphHeapLazyBytesPerNode  = 1448.0f;   // node view cache 1419 + node buckets 29
const float kGraphHeapLazyBytesPerEdge  = 93.0f;     // edge render cache (CachedEdge 48 + points 16 + index)

// Heap still to be allocated once the layout exists: the caches the first bake builds.
float GraphHeapLazyGB(long long nodes, long long edges) {
    if (nodes <= 0) return 0.0f;
    double bytes = (double)nodes * kGraphHeapLazyBytesPerNode + (double)edges * kGraphHeapLazyBytesPerEdge;
    return (float)(bytes / 1073741824.0);
}

// Total heap the graph will occupy, for callers deciding a node count before anything is allocated.
float GraphHeapTotalGB(long long nodes, long long edges) {
    if (nodes <= 0) return 0.0f;
    return GraphHeapLazyGB(nodes, edges)
         + (float)((double)nodes * kGraphHeapEagerBytesPerNode / 1073741824.0);
}

// How many tiles fit in memory. Tile cost is content-independent (an RGB565 tile reserves
// TILE_SIZE^2 * 2 bytes whether it holds nodes or not), so the per-tile figure is exact.
//
// Two independent limits, both real, so this takes the MIN:
//   physical - free RAM minus the safety margin, at TilePhysicalCostGB() per tile. Exceeding it means
//              Windows kills the process (it does not fail the allocation first; see SAFETY_MARGIN_GB).
//   commit   - available pagefile-backed commit, at the FULL TileSizeGB() per tile, since commit is
//              charged on allocation regardless of residency. The old physical-only model ignored this
//              entirely, and it is the limit behind the silent crashes: at high node counts the tile set
//              plus the node/edge structures exhausted commit while free RAM still looked healthy, so
//              nothing throttled and an allocation failed hard. Measured at 146 tiles (18.25 GB of tile
//              bytes): working set 11.9 GB but commit 21.4 GB, against a 39.3 GB commit limit.
//
// VRAM is neither added nor used as a cap: 207 allocated tiles (25.9 GB of tile bytes) coexisted on a
// 10 GB card, so the driver pages tiles between VRAM and system memory and VRAM is NOT a tile ceiling.
// Its effect on the budget is a one-time credit against the set's bytes - see TileVRAMCreditGB().
// graphHeapGB: the non-tile heap the graph will occupy (see GraphHeapCostGB). Reserved off the top of BOTH
// limits before any tile is priced. Callers that don't know the graph size yet pass 0, but the auto-sizing
// path must pass it - a 650k-node graph's 2.4 GB is ~19 tiles' worth of budget handed out twice otherwise.
int TileBudgetForMemory(float safetyMarginGB, float graphHeapGB = 0.0f) {
    float usableRAM = (GetSystemRAM_GB() - GetUsedPhysicalRAM_GB()) - safetyMarginGB - graphHeapGB;
    if (usableRAM < 0.0f) usableRAM = 0.0f;
    // Solve N * TileSizeGB() - vramCredit <= usableRAM for N: the whole set costs its bytes minus what
    // the card absorbs, so the credit is added ONCE here rather than discounted from every tile.
    int byPhysical = (int)((usableRAM + TileVRAMCreditGB()) / TilePhysicalCostGB());

    // Commit gets TWO ceilings, both applied, because it can run out for two unrelated reasons:
    //
    //   free RAM    - the same reading as above but WITHOUT the VRAM credit, since commit gets no credit for
    //                 residency: a tile living on the card still holds the commit for its system-memory
    //                 copy. This is what keeps the tile set from REQUIRING pagefile backing - the commit a
    //                 budget can't cover in RAM has to be paged, and Windows grows a system-managed
    //                 pagefile synchronously to provide it, which stalls the process hard (gCommitOverrunGB
    //                 relaxes this deliberately).
    //   commit limit - the actual ceiling, for the opposite case: a small pagefile on a nearly full disk,
    //                 where commit binds before RAM does.
    //
    // Free RAM is usually the tighter of the two. The commit limit only binds with little free disk, since
    // pagefile growth room counts toward it (see GetEffectiveCommit_GB).
    float usableCommitRAM = (GetSystemRAM_GB() - GetUsedPhysicalRAM_GB()) - safetyMarginGB - graphHeapGB
                          + gCommitOverrunGB;
    if (usableCommitRAM < 0.0f) usableCommitRAM = 0.0f;
    int byCommit = (int)(usableCommitRAM / TileCache::TileSizeGB());

    float growthRoom = GetEffectiveCommit_GB() - graphHeapGB;
    if (growthRoom < 0.0f) growthRoom = 0.0f;
    int byCommitLimit = (int)(growthRoom / TileCache::TileSizeGB());
    if (byCommitLimit < byCommit) byCommit = byCommitLimit;

    return byPhysical < byCommit ? byPhysical : byCommit;
}

// Tiles the layout for `nodes` grid nodes will actually need. Rounds up per axis: partial tiles on the
// right/bottom edges each cost a full allocation.
int GridTileCount(const LayoutEngine& layout, int nodes) {
    ImVec2 s = layout.GridWorldSizeForNodeCount(nodes);
    return TileCache::TilesToCover((int)s.x) * TileCache::TilesToCover((int)s.y);
}

// Pick a default grid node count sized to the tile budget.
//
// Compares TILE COUNTS, not areas. The grid is square in node count (nodesPerRow = sqrt(N)) but cells
// are ~2.5:1, so the world lands ~2:1 and quantizes on both axes - e.g. 16.7 x 8.4 tiles of area
// becomes 17 x 9 = 153 tiles, ~10% over what an area-only budget allows. Start from the area estimate
// (always an over-estimate) and shrink until the real tile grid fits; world size is monotonic in N.
//
// Charges the graph's own heap against the budget, which makes this a FIXED POINT rather than a division:
// more nodes means more non-tile heap (GraphHeapCostGB), which leaves fewer tiles, which allows fewer
// nodes. So it iterates to convergence instead of dividing once.
//
// This replaced a flat `tileBudget * 0.95` headroom. A fraction of the TILE budget is the wrong shape for
// this cost twice over: the real cost scales with the node count (which is the thing being solved for, not
// the tile count), and 5% understated it badly at the top end - at 650k nodes the structures are 2.4 GB
// against a 25 GB tile budget, so ~10%, and the missing 5% is what ate half the safety margin.
int AutoGridNodeCount(const LayoutEngine& layout, float safetyMarginGB, int edgesPerNode) {
    const long long kMinNodes = 10000, kMaxNodes = 2000000;

    // Area-based starting point: nodes = tiles * (tileArea / cellArea). Cell pitch is the growth from a
    // 1x1 grid to a 2x2 one, which cancels the fixed padding on both axes.
    ImVec2 one = layout.GridWorldSizeForNodeCount(1);
    ImVec2 four = layout.GridWorldSizeForNodeCount(4);
    double cellArea = (double)(four.x - one.x) * (double)(four.y - one.y);
    if (cellArea <= 0.0) return (int)kMinNodes;
    double tileArea = (double)TileCache::TILE_SIZE * (double)TileCache::TILE_SIZE;

    long long nodes = 0;
    // Converges in 2-3 passes: each pass prices the previous pass's node count and re-solves. Capped so a
    // pathological oscillation can't spin here. Monotone decreasing in practice (a bigger N only ever
    // reserves more heap), so the last value is the safe one.
    const int kMaxPasses = 8;
    for (int pass = 0; pass < kMaxPasses; ++pass) {
        // Total, not lazy: nothing is allocated yet at this point, so the whole cost is still ahead of us.
        int budget = TileBudgetForMemory(safetyMarginGB,
                                         GraphHeapTotalGB(nodes, nodes * (long long)edgesPerNode));
        if (budget <= 0) return (int)kMinNodes;

        long long next = (long long)(budget * (tileArea / cellArea));
        if (next > kMaxNodes) next = kMaxNodes;
        // Shrink until the integral tile grid fits (typically 1-2 passes; step scales with N).
        while (next > kMinNodes && GridTileCount(layout, (int)next) > budget)
            next -= (next / 32 > 0 ? next / 32 : 1);
        if (next < kMinNodes) next = kMinNodes;

        // Settled (within a rounding step of the last pass) - stop.
        if (nodes != 0 && llabs(next - nodes) <= nodes / 64) { nodes = next; break; }
        nodes = next;
    }

    return (int)(nodes < kMinNodes ? kMinNodes : nodes);
}

// Safety check: compute the tile budget for this layout and warn if it won't fit.
// Returns the max tiles that fit in RAM; the caller applies it to TileCache::MAX_CACHED_TILES.
// Default margin here is only a fallback - both call sites pass the main loop's SAFETY_MARGIN_GB.
// Keep the two in step so the startup prediction can't disagree with the runtime enforcement.
// graphHeapGB: the non-tile heap already spent on this graph, reserved before tiles are priced. Passing the
// real value is what keeps the startup prediction equal to what the runtime will actually allow.
int CheckTileSafety(int width, int height, const char* context = "layout", const float SAFETY_MARGIN_GB = 3.0f,
                    float graphHeapGB = 0.0f) {
    static float systemRAM_GB = GetSystemRAM_GB();
    static float gpuVRAM_GB = GetGPU_VRAM_GB();
    static bool firstRun = true;

    if (firstRun) {
        firstRun = false;
        printf("\n=== SYSTEM MEMORY ANALYSIS ===\n");
        printf("GPU: %s\n", (const char*)glGetString(GL_RENDERER));
        printf("System RAM: %.1f GB total\n", systemRAM_GB);
        printf("GPU VRAM: %.1f GB %s\n", gpuVRAM_GB,
               (gpuVRAM_GB == 4.0f || gpuVRAM_GB == 12.0f) ? "(estimated)" : "(detected)");
        printf("Note: Tile allocation enforced at runtime (stops when < %.1f GB RAM or commit free)\n",
               SAFETY_MARGIN_GB);
        printf("=============================\n\n");
    }

    const float TILE_SIZE_GB = TileCache::TileSizeGB();

    // Round UP on both axes: a partially covered tile still costs a full allocation. Truncating here
    // used to under-report the grid (e.g. 15x8=120 tiles reported as 15x7=105) and hid the overflow.
    int tilesX = TileCache::TilesToCover(width);
    int tilesY = TileCache::TilesToCover(height);
    int totalTiles = tilesX * tilesY;
    float estimatedMem_GB = totalTiles * TILE_SIZE_GB;

    // Get current system memory usage
    float totalSystemRAM_GB = GetSystemRAM_GB();
    float usedSystemRAM_GB = GetUsedPhysicalRAM_GB();
    float freeSystemRAM_GB = totalSystemRAM_GB - usedSystemRAM_GB;
    float usableRAM_GB = freeSystemRAM_GB - SAFETY_MARGIN_GB - graphHeapGB;
    float availCommit_GB = GetEffectiveCommit_GB() - graphHeapGB;

    // Delegate to the one budget model so this prediction cannot drift from what the runtime enforces.
    // A tile costs only part of its bytes in physical RAM but all of them in commit, and the budget is
    // the min of those two limits - see TileBudgetForMemory().
    int estimatedMaxTiles = TileBudgetForMemory(SAFETY_MARGIN_GB, graphHeapGB);

    printf("\n=== TILE SAFETY CHECK (%s) ===\n", context);
    printf("World size: %i × %i pixels\n", width, height);
    printf("Tile grid: %i × %i = %d tiles (%.1f GB)\n", tilesX, tilesY, totalTiles, estimatedMem_GB);
    printf("System RAM: %.1f GB total, %.1f GB used, %.1f GB free\n",
           totalSystemRAM_GB, usedSystemRAM_GB, freeSystemRAM_GB);
    printf("Usable for tiles: %.1f GB RAM (free - %.1f GB margin) / %.1f GB commit"
           " (%.1f GB free + pagefile growth room, less %.1f GB disk reserve)\n",
           usableRAM_GB, SAFETY_MARGIN_GB, availCommit_GB,
           GetAvailableCommit_GB(), kDiskReserveGB);
    // A tile costs the same bytes in RAM and commit; what differs is that the RAM side gets a one-time
    // credit for the part of the set the card absorbs. Print both so it's clear which limit is binding.
    printf("Per-tile cost: %.3f GB RAM / %.3f GB commit, less a one-time %.1f GB VRAM credit"
           " (half of %.1f GB detected)\n",
           TilePhysicalCostGB(), TILE_SIZE_GB, TileVRAMCreditGB(), gpuVRAM_GB);
    int tilesByRAM = (int)((ImMax(usableRAM_GB, 0.0f) + TileVRAMCreditGB()) / TilePhysicalCostGB());
    // Commit is bounded by free RAM as well as by the commit limit, and gets no VRAM credit - mirror
    // TileBudgetForMemory() exactly, or this line reports a limit the budget beside it doesn't use.
    int tilesByCommit = (int)(ImMax(usableRAM_GB + gCommitOverrunGB, 0.0f) / TILE_SIZE_GB);
    int tilesByCommitLimit = (int)(ImMax(availCommit_GB, 0.0f) / TILE_SIZE_GB);
    if (tilesByCommitLimit < tilesByCommit) tilesByCommit = tilesByCommitLimit;
    printf("Estimated max tiles: ~%d tiles (RAM allows %d, commit allows %d - %s is binding)\n",
           estimatedMaxTiles, tilesByRAM, tilesByCommit,
           tilesByRAM <= tilesByCommit ? "RAM" : "commit");

    if (totalTiles > estimatedMaxTiles) {
        printf("\n*** WARNING: Tile rendering will not complete - will run out of memory ***\n");
        printf("    Layout needs %d tiles, but only ~%d tiles can fit in memory\n",
               totalTiles, estimatedMaxTiles);
        printf("    You will still be able to navigate the graph, but some tiles will not display.");
    }

    // Always return estimated max - runtime check will enforce the real limit
    return estimatedMaxTiles;
}

// Helper: Recalculate minZoom to fit world bounds in viewport (call on re-layout or window resize)
// Also clamps currentCameraZoom to ensure it doesn't go below minZoom
void RecalculateMinZoom(float& minZoom, float& currentCameraZoom, ImVec2 viewportSize, int worldWidth, int worldHeight) {
    // Add 10% buffer so padding is visible as breathing room
    float minZoomX = (viewportSize.x * 0.9f) / (float)worldWidth;
    float minZoomY = (viewportSize.y * 0.9f) / (float)worldHeight;
    minZoom = ImMin(minZoomX, minZoomY);

    // Clamp current zoom to new minimum (zoom in if needed to fit window)
    currentCameraZoom = ImMax(currentCameraZoom, minZoom);
}

// Command-line configuration for the graph viewer. Populated by ParseArgs() from argv; the setup code
// below reads these instead of hardcoded values.
struct AppConfig {
    bool gpuRendering = true;         // --gpu on|off
    int  edgeRenderMode = 2;          // --curve 0..3 (0=BezierDirect,1=Polyline,2=CatmullRom,3=BezierChain)
    // Dataset: one of the four test hierarchies, or the grid. "grid" also honors gridNodeCount.
    enum class Dataset { TestHierarchy, LargeTestHierarchy, LargeWideTestHierarchy, LongEdgeTest, Grid };
    Dataset dataset = Dataset::LargeTestHierarchy;
    int  gridNodeCount = 300000;      // --nodes N (only used when --data grid)
    bool gridNodeCountExplicit = false;  // true if --nodes was passed (auto-sizing is skipped then)
    bool debug = false;               // --debug: verbose prints, profiling, layout detail dumps
    float commitOverrunGB = 0.0f;     // --commit-overrun GB (see gCommitOverrunGB)
};

static void PrintUsage(const char* exe) {
    printf("Usage: %s [options]\n", exe);
    printf("  --gpu on|off            GPU rendering (default on)\n");
    printf("  --curve 0..3            Edge curve type: 0=BezierDirect 1=Polyline 2=CatmullRom 3=BezierChain (default 2)\n");
    printf("  --data <name>           Dataset: test | large | wide | longedge | grid (default: large) \n");
    printf("  --nodes N               Node count for --data grid (default: generates as many nodes that reasonably render with available ram/vram)\n");
    printf("  --commit-overrun GB     Let the tile budget exceed free RAM by GB, backed by the pagefile\n");
    printf("                          (default 0 = tiles must fit in RAM). Raises the tile ceiling, so more\n");
    printf("                          of a large graph can be rendered. Setting will prompt confirmation\n");
    printf("  --debug                 Enable verbose debug output + profiling (default off)\n");
    printf("  --help                  Show this help and exit\n");
}

// Parse argv into cfg. Returns false if the program should exit (bad args or --help).
static bool ParseArgs(int argc, char** argv, AppConfig& cfg) {
    for (int i = 1; i < argc; i++) {
        std::string a = argv[i];
        auto next = [&](const char* name) -> const char* {
            if (i + 1 >= argc) { printf("Error: %s requires a value\n", name); return nullptr; }
            return argv[++i];
        };
        if (a == "--help" || a == "-h") { return false; }  // usage already printed at startup
        else if (a == "--debug") { cfg.debug = true; }
        else if (a == "--gpu") {
            const char* v = next("--gpu"); if (!v) return false;
            std::string s = v;
            if (s == "on" || s == "1" || s == "true")       cfg.gpuRendering = true;
            else if (s == "off" || s == "0" || s == "false") cfg.gpuRendering = false;
            else { printf("Error: --gpu expects on|off (got '%s')\n", v); return false; }
        }
        else if (a == "--curve") {
            const char* v = next("--curve"); if (!v) return false;
            int m = atoi(v);
            if (m < 0 || m > 3) { printf("Error: --curve expects 0..3 (got '%s')\n", v); return false; }
            cfg.edgeRenderMode = m;
        }
        else if (a == "--data") {
            const char* v = next("--data"); if (!v) return false;
            std::string s = v;
            if      (s == "test")     cfg.dataset = AppConfig::Dataset::TestHierarchy;
            else if (s == "large")    cfg.dataset = AppConfig::Dataset::LargeTestHierarchy;
            else if (s == "wide")     cfg.dataset = AppConfig::Dataset::LargeWideTestHierarchy;
            else if (s == "longedge") cfg.dataset = AppConfig::Dataset::LongEdgeTest;
            else if (s == "grid")     cfg.dataset = AppConfig::Dataset::Grid;
            else { printf("Error: --data expects test|large|wide|longedge|grid (got '%s')\n", v); return false; }
        }
        else if (a == "--nodes") {
            const char* v = next("--nodes"); if (!v) return false;
            int n = atoi(v);
            if (n < 1) { printf("Error: --nodes expects a positive integer (got '%s')\n", v); return false; }
            cfg.gridNodeCount = n;
            cfg.gridNodeCountExplicit = true;
        }
        else if (a == "--commit-overrun") {
            const char* v = next("--commit-overrun"); if (!v) return false;
            float gb = (float)atof(v);
            if (gb < 0.0f) { printf("Error: --commit-overrun expects GB >= 0 (got '%s')\n", v); return false; }
            cfg.commitOverrunGB = gb;
        }
        else { printf("Error: unknown argument '%s'\n", a.c_str()); PrintUsage(argv[0]); return false; }
    }
    return true;
}

int main(int argc, char** argv)
{
    // Unbuffer stdout so a redirected log survives an abnormal exit. Redirected output is block-buffered
    // by default, which silently discarded the last 4 KB - i.e. exactly the memory warnings printed just
    // before a low-memory death, the ones needed to diagnose it. _IONBF and not _IOLBF: MSVC's CRT
    // treats line buffering as full buffering, so _IOLBF would change nothing.
    setvbuf(stdout, nullptr, _IONBF, 0);

    // Always show the available options first, regardless of how the program is invoked.
    PrintUsage(argv[0]);

    AppConfig cfg;
    if (!ParseArgs(argc, argv, cfg))
        return 0;  // --help or a parse error already printed a message
    gDebugEnabled = cfg.debug;
    gCommitOverrunGB = cfg.commitOverrunGB;

    // Any overrun is opt-in per run, not just per command line: the failure mode is system-wide rather
    // than confined to this process, so it shouldn't be reachable by a typo or a copied command line.
    if (gCommitOverrunGB > 0.0f) {
        printf("\n*** WARNING: --commit-overrun %.1f GB CAN HANG YOUR ENTIRE MACHINE FOR SOME TIME. ***\n"
               "    System-wide hangs and application crashes have been observed at 500k+ node graphs on\n"
               "    systems with large enough RAM capacity to handle them.\n"
               "    The tile budget may exceed free RAM by %.1f GB, backed by the pagefile; Windows grows\n"
               "    the pagefile mid-render, which saturates the disk and freezes everything until it\n"
               "    finishes. Omit the flag (or pass 0) to keep tiles inside physical RAM.\n\n"
               "Continue with a %.1f GB overrun? [y/N] ",
               gCommitOverrunGB, gCommitOverrunGB, gCommitOverrunGB);

        // EOF (piped/redirected stdin, or a closed console) counts as "no" rather than blocking forever:
        // an unattended run must not sit on a prompt, and must not opt itself in either.
        int c = getchar();
        if (c != 'y' && c != 'Y') {
            printf("\nAborted. Re-run without --commit-overrun to size the tile budget to fit in RAM.\n");
            return 0;
        }
        while (c != '\n' && c != EOF) c = getchar();  // drop the rest of the line
        printf("\nProceeding with a %.1f GB commit overrun.\n\n", gCommitOverrunGB);
    }

    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_GAMECONTROLLER) != 0)
    {
        printf("Error: %s\n", SDL_GetError());
        return -1;
    }

    // Decide GL+GLSL versions. Ask for 4.3 first (compute shaders), then fall back to 3.0.
#if defined(IMGUI_IMPL_OPENGL_ES2)
    struct { int major, minor; const char* glsl; } tries[] = { {2, 0, "#version 100"} };
    const int gl_profile = SDL_GL_CONTEXT_PROFILE_ES;
    const int gl_flags = 0;
#elif defined(__APPLE__)
    // Apple caps desktop GL at 4.1, so 4.3 is never available.
    struct { int major, minor; const char* glsl; } tries[] = { {3, 2, "#version 150"} };
    const int gl_profile = SDL_GL_CONTEXT_PROFILE_CORE;
    const int gl_flags = SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG;  // Always required on Mac
#else
    struct { int major, minor; const char* glsl; } tries[] = { {4, 3, "#version 150"},
                                                              {3, 0, "#version 130"} };
    const int gl_profile = SDL_GL_CONTEXT_PROFILE_CORE;
    const int gl_flags = 0;
#endif

    //MSAA works on the window, not on the FBO's. So not turning on MSAA here.
    SDL_WindowFlags window_flags =
        (SDL_WindowFlags)(SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
    SDL_Window* window = nullptr;
    SDL_GLContext gl_context = nullptr;
    const char* glsl_version = nullptr;

    // SDL keeps the failed attempt's pixel format on the window, so recreate the window each try.
    for (int i = 0; i < (int)(sizeof(tries) / sizeof(tries[0])) && !gl_context; i++) {
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, gl_flags);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, gl_profile);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, tries[i].major);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, tries[i].minor);
        SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
        SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
        SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);

        window = SDL_CreateWindow("Dear ImGui SDL2+OpenGL3 example", SDL_WINDOWPOS_CENTERED,
                                  SDL_WINDOWPOS_CENTERED, 1280, 720, window_flags);
        if (window) {
            gl_context = SDL_GL_CreateContext(window);
            if (gl_context) { glsl_version = tries[i].glsl; break; }
            SDL_DestroyWindow(window);
            window = nullptr;
        }
        printf("GL %d.%d context unavailable (%s)\n", tries[i].major, tries[i].minor, SDL_GetError());
    }
    if (!gl_context) {
        printf("Error: could not create an OpenGL context: %s\n", SDL_GetError());
        return -1;
    }

    SDL_GL_MakeCurrent(window, gl_context);
    SDL_GL_SetSwapInterval(1); // Enable vsync (disable for fps testing)

    // Log the GPU we landed on: distinguishes "driver too old" from "Windows ran us on the iGPU".
    GLint glMajor = 0, glMinor = 0;
    glGetIntegerv(GL_MAJOR_VERSION, &glMajor);
    glGetIntegerv(GL_MINOR_VERSION, &glMinor);
    printf("OpenGL %d.%d | %s | %s\n", glMajor, glMinor,
           glGetString(GL_RENDERER) ? (const char*)glGetString(GL_RENDERER) : "(unknown renderer)",
           glGetString(GL_VERSION) ? (const char*)glGetString(GL_VERSION) : "(unknown version)");

    // Setup Dear ImGui context
    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGuiIO& io = ImGui::GetIO();
    (void)io;

    // Configure ImGui UI font (for menus, controls, etc. - NOT for node graph text)
    // Node graph text uses pre-generated SDF atlas loaded from font.png/font.fnt
    ImFontConfig fontConfig;
    fontConfig.SizePixels = 13.0f;  // Default UI font size
    fontConfig.OversampleH = 1;
    fontConfig.OversampleV = 1;
    fontConfig.GlyphRanges = io.Fonts->GetGlyphRangesDefault();  // Full ASCII 32-127
    io.Fonts->AddFontDefault(&fontConfig);

    printf("ImGui UI font configured: size=%.1f (for menus/controls only)\n", fontConfig.SizePixels);

    // Setup Dear ImGui style
    ImGui::StyleColorsDark();
    // ImGui::StyleColorsClassic();

    // Setup Platform/Renderer backends
    ImGui_ImplSDL2_InitForOpenGL(window, gl_context);
    ImGui_ImplOpenGL3_Init(glsl_version);

    // Load OpenGL extension functions (centralized in GLFunctions.h)
    if (!InitializeGLFunctions()) {
        printf("ERROR: Failed to initialize OpenGL functions\n");
        return -1;
    }

    // Setup Tile Cache for rendering (The Tile Cache keeps track of FBO tiles that make up the whole world space)
    TileCache tileCache;
    tileCache.Initialize();

    // Graph View world space dimensions (calculated from node bounds later)
    int width;
    int height;

    ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);

    //Initialize the core library architecture
    static GraphData::DataModel* dataModel = nullptr;
    static LayoutEngine* layoutEngine = nullptr;
    static ImGui::GraphView graphView;

    // GPU rendering configuration (from --gpu on|off).
    bool useGPURendering = cfg.gpuRendering;
    GPURenderer gpuRenderer;

    // GPU physics layout simulation (SPH skeleton: press P to nudge nodes off-home).
    PhysicsLayoutSimulation physicsSim;
    bool physicsActive = false;  // true while an animation is settling (overlay draw + step)
    // Keeps the overlay drawing for ONE extra frame after commit, covering the gap until the tiles
    // re-bake (which happens at the top of the NEXT frame). Without it, the settle frame shows the
    // still-hole-punched tiles with the overlay already off -> a one-frame empty parent + stray edges.
    bool physicsOverlayLinger = false;
    // Subgraph drag: when a left-drag starts on a subgraph boundary's empty area (not on a node),
    // the whole subgraph moves as a unit. Holds the parent id being dragged (-1 = none).
    int draggedSubgraphId = -1;
    // Cursor world position at the previous drag frame, and whether it's valid yet.
    //
    // Drags derive their delta from consecutive io.MousePos samples rather than io.MouseDelta, so that
    // motion is never lost to a frame that doesn't reach the drag branch. MouseDelta is per-frame and
    // resets each NewFrame(), so any frame that skips the drag block silently discards that frame's
    // travel; differencing world positions instead accumulates across the gap and stays exact.
    //
    // The frame-skipping itself is fixed in the bake loop (see the window-revive comment there). This is
    // belt-and-braces on top of it: it keeps the drag exact even if some future path - a slow bake, a
    // popup grabbing hover, an early-out - costs the drag a frame again.
    ImVec2 dragPrevMouseWorld = ImVec2(0.0f, 0.0f);
    bool dragPrevMouseWorldValid = false;
    // State captured when an expand/collapse animation begins, consumed once on settle to commit
    // the animated positions into the layout (tiles + hit-test).
    bool physicsCommitPending = false;
    std::map<int, ImVec2> physicsOldPositions;  // layout snapshot before the transition
    std::map<int, ImVec2> physicsNewSizes;      // sizes for nodes appearing this transition (children)
    int physicsParentId = -1;                   // parent being expanded (removed from layout on commit)
    // Collapse-specific state (two-phase: children shrink in, then neighbors spring home).
    bool physicsCollapsePending = false;
    int  physicsCollapsePhase = 0;              // 1 = children shrinking, 2 = neighbors returning
    int  physicsCollapseParentId = -1;          // the parent reappearing after collapse
    std::vector<int> physicsCollapseChildIds;   // children removed from the sim + layout on settle
    std::vector<int> physicsCollapseNeighbors;  // neighbors that spring home in phase 2

    bool nodeSetup = false;
    bool nodesDirty = true;
    // Main loop with event-driven rendering
    bool done = false;
    bool needsRender = true;  // Force initial render
    bool isInteracting = false;  // Track if user is actively interacting
    std::vector<float> extent;
    // Free RAM to keep in reserve, i.e. the ceiling on tile allocation. Windows kills the process
    // outright rather than failing an allocation when it runs dry, so the reactive eviction below never
    // gets a chance to give anything back - this margin is what prevents reaching that point at all.
    //
    // Two components, which is why it's a max() and not a single number:
    //   kMinMarginGB   - working room for the OS, the GPU driver and other processes. Absolute: a small
    //                    machine needs just as much of it, so this must never scale down.
    //   fraction       - the driver's system-memory paging copies of the resident tile set, which keep
    //                    growing for a moment after we stop allocating. That lag is proportional to how
    //                    much tile memory is in flight, and the tile budget is itself sized from RAM, so
    //                    on a big machine the overshoot is bigger and needs more headroom. A fixed 2.0 GB
    //                    was enough until the tile budget grew large enough to overshoot it: allocation
    //                    ran free RAM down to 1.9 GB and the process died there.
    // On a small machine the floor wins and this is just the old 2.0 GB behaviour, which is correct -
    // such a machine can't hold a graph big enough to produce the overshoot in the first place.
    const float kMinMarginGB = 2.0f;
    static const float SAFETY_MARGIN_GB = ImMax(kMinMarginGB, GetSystemRAM_GB() * 0.10f);

    while (!done)
    {
        // Get actual window size for UI rendering (not FBO)
        int window_width, window_height;
        SDL_GetWindowSize(window, &window_width, &window_height);

        // Event-driven rendering: wait for events when idle, poll continuously during interaction
        SDL_Event event;

        if (!needsRender && !isInteracting && !nodesDirty) {
            // Idle: wait up to 100ms for event (allows 10 FPS, for less GPU utilization go lower)
            if (SDL_WaitEventTimeout(&event, 100)) {
                ImGui_ImplSDL2_ProcessEvent(&event);
                if (event.type == SDL_QUIT) done = true;
                needsRender = true;  // Event occurred, render tiles
            }   
        }

        // Camera state
        static ImVec2 cameraOffset = ImVec2(0.0f, 0.0f); //World position at top left of viewport
        static float cameraZoom = 0.5f;  // Start zoomed out (will auto-fit on first scroll)
        static float minZoom = 0.1f;  // Minimum zoom (fit entire world)

        // Track Node Editor window size from previous frame for tile visibility
        static ImVec2 nodeEditorSize = ImVec2((float)window_width, (float)window_height);

        // Process any pending events
        while (SDL_PollEvent(&event)) {
            ImGui_ImplSDL2_ProcessEvent(&event);
            if (event.type == SDL_QUIT) done = true;
            if (event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_RESIZED) {
                // Recalculate minZoom when SDL window is resized
                int newWidth, newHeight;
                SDL_GetWindowSize(window, &newWidth, &newHeight);
                RecalculateMinZoom(minZoom, cameraZoom, ImVec2((float)newWidth, (float)newHeight), width, height);
            }
            needsRender = true;
        }

        // Node setup (first frame only) 
        if (!nodeSetup) {
            // Need ImGui context for font system during node creation
            ImGui_ImplOpenGL3_NewFrame();
            ImGui_ImplSDL2_NewFrame();
            ImGui::NewFrame();

            bool useGrid = (cfg.dataset == AppConfig::Dataset::Grid);

            // Step 1: Create the layout engine first - auto-sizing the grid needs its cell pitch to
            // convert a tile budget into a node count.
            layoutEngine = new LayoutEngine();
            layoutEngine->SetGridParameters(
                150.0f,  // nodeWidth (base width before dynamic calculation)
                50.0f,   // nodeHeight
                50.0f,   // horizontalSpacing (used for layerSpacing = 2x)
                50.0f    // verticalSpacing (gap between nodes in same layer)
            );

            // Step 2: Create data model (from --data, and --nodes for the grid).
            dataModel = new GraphData::DataModel();

            // For the grid with no explicit --nodes, size it to the tiles that fit VRAM + free RAM,
            // net of the heap the graph's own structures will take (see GraphHeapTotalGB).
            if (useGrid && !cfg.gridNodeCountExplicit) {
                cfg.gridNodeCount = AutoGridNodeCount(*layoutEngine, SAFETY_MARGIN_GB, kGridEdgesPerNode);
                float graphHeap = GraphHeapTotalGB(cfg.gridNodeCount,
                                                   (long long)cfg.gridNodeCount * kGridEdgesPerNode);
                int tileBudget = TileBudgetForMemory(SAFETY_MARGIN_GB, graphHeap);
                printf("Default (auto-sized) node count: rendering %d nodes "
                       "(%d tiles; limited by %.1f GB free RAM / %.1f GB free commit, "
                       "less %.2f GB reserved for the graph's own structures)\n",
                       cfg.gridNodeCount, tileBudget,
                       GetSystemRAM_GB() - GetUsedPhysicalRAM_GB(), GetAvailableCommit_GB(), graphHeap);
            }
            switch (cfg.dataset) {
                case AppConfig::Dataset::TestHierarchy:          dataModel->CreateTestHierarchy(); break;
                case AppConfig::Dataset::LargeTestHierarchy:     dataModel->CreateLargeTestHierarchy(); break;
                case AppConfig::Dataset::LargeWideTestHierarchy: dataModel->CreateLargeWideTestHierarchy(); break;
                case AppConfig::Dataset::LongEdgeTest:           dataModel->CreateLongEdgeTest(); break;
                case AppConfig::Dataset::Grid:                   dataModel->CreateNodesGrid(cfg.gridNodeCount); break;
            }

            // Choose layout algorithm: grid dataset uses the fast grid layout; everything else is layered.
            if (useGrid) {
                layoutEngine->SetGridNodesPerRow(std::sqrt(cfg.gridNodeCount));
                layoutEngine->ComputeGridLayout(*dataModel);
            } else {
                layoutEngine->ComputeLayoutLayered(*dataModel);  // hierarchical, reduces crossings
            }
            layoutEngine->SetEdgeRenderMode(cfg.edgeRenderMode);

            // Step 3: Set Architecture pointers
            graphView.SetDataModel(dataModel);
            graphView.SetLayoutengine(layoutEngine);

            // Step 3.5: Initialize GPU rendering if enabled
            // useGPURendering first: short-circuits so --gpu off skips shader compilation entirely
            // instead of compiling everything and then discarding it.
            if (useGPURendering && gpuRenderer.Initialize()) {
                graphView.SetGPURenderer(&gpuRenderer);
                graphView.SetGPURendering(true);
                printf("GPU rendering initialized successfully\n");

                // Load pre-generated SDF font atlas from Hiero
                // TODO: User needs to generate font.png and font.fnt using Hiero first
                // For now, we'll check if the files exist
                const char* fontPngPath = "font/froggerForever.png";
                const char* fontFntPath = "font/froggerForever.fnt";
                if (!gpuRenderer.LoadSDFAtlas(fontPngPath, fontFntPath)) {
                    printf("ERROR: Failed to load SDF atlas from %s and %s\n", fontPngPath, fontFntPath);
                    printf("       Please generate SDF font (using software like Hiero) and place files in the executable directory.\n");
                    printf("       Falling back to CPU rendering.\n");
                    graphView.SetGPURendering(false);
                }
            } else {
                printf(useGPURendering ? "GPU rendering unavailable, using CPU path\n"
                                       : "GPU rendering disabled (--gpu off), using CPU path\n");
            }

            // Step 3.6: Initialize + seed the physics layout simulation from the layout slots.
            // Only when GPU rendering is active - the sim uses compute shaders and only its overlay
            // draws it. In CPU mode expand/collapse relayout is immediate, so the sim isn't needed.
            if (useGPURendering && physicsSim.Initialize()) {
                physicsSim.SeedFromLayout(layoutEngine->nodePositions_, layoutEngine->nodeSizes_);
            }

            // Step 4: Get world bounds from layout engine
            ImRect worldBounds = layoutEngine->GetWorldBounds();
            width = (int)worldBounds.GetWidth();
            height = (int)worldBounds.GetHeight();

            // Heap the first bake still has to allocate for THIS graph (node view + edge render caches +
            // buckets). LAZY only: the data model and layout already exist by now, so their share is
            // already reflected in the live free-RAM reading CheckTileSafety takes. Read from the built
            // model rather than predicted, so it's exact for every dataset, not just the grid.
            float pendingGraphHeapGB = GraphHeapLazyGB((long long)dataModel->GetNodes().size(),
                                                       (long long)dataModel->GetConnections().size());

            // Saftey check: Warn if layout will exceed memory (non-blocking) - Actual enforcement happens at runtime in GetTile()
            int estimatedMaxTiles = CheckTileSafety(width, height, "initial setup", SAFETY_MARGIN_GB,
                                                    pendingGraphHeapGB);

            // Apply the computed budget. This used to be dropped on the floor, leaving MAX_CACHED_TILES
            // at its hardcoded default of 100 tiles (~12.8 GB) regardless of how much RAM was free - so
            // layouts needing more than 100 tiles silently stopped rendering even with RAM to spare.
            // EnforceMemoryLimits() can still lower this at runtime under real memory pressure.
            if (estimatedMaxTiles > 0) {
                TileCache::MAX_CACHED_TILES = estimatedMaxTiles;
                // Ceiling for the recovery path in EnforceMemoryLimits(): a cap lowered under pressure may
                // rise back toward this, but never past the budget RAM actually justified.
                TileCache::TILE_BUDGET_CEILING = estimatedMaxTiles;
                printf("Tile cache limit: %d tiles (%.1f GB max)\n",
                       TileCache::MAX_CACHED_TILES, TileCache::MAX_CACHED_TILES * TileCache::TileSizeGB());
            }

            // Calculate memory budget for our process
            float totalSystemRAM_GB = GetSystemRAM_GB();

            // Get baseline memory for informational purposes
#ifdef _WIN32
            PROCESS_MEMORY_COUNTERS_EX pmc;
            float baselineMemoryGB = 0.0f;
            if (GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc))) {
                baselineMemoryGB = pmc.WorkingSetSize / (1024.0f * 1024.0f * 1024.0f);
            }
#else
            float baselineMemoryGB = 2.0f;  // Conservative estimate for non-Windows
#endif

            printf("\n=== MEMORY BUDGET CALCULATION ===\n");
            printf("System total RAM: %.1f GB\n", totalSystemRAM_GB);
            printf("Our process budget: %.2f GB (total - safety)\n", totalSystemRAM_GB - SAFETY_MARGIN_GB);
            printf("Current baseline (before tiles): %.2f GB\n", baselineMemoryGB);
            printf("Budget remaining for tiles + overhead: %.2f GB\n", totalSystemRAM_GB - baselineMemoryGB - SAFETY_MARGIN_GB);
            printf("Note: Overhead (ImGui, caches) will consume part of budget\n");
            

            // Set memory limits on TileCache (runtime checks enforce these)
            tileCache.SetMemoryLimits(totalSystemRAM_GB - SAFETY_MARGIN_GB, totalSystemRAM_GB);

            printf("=================================\n\n");

            // Set initial camera zoom to fit all nodes
            //   Using window size since GetContentRegionAvail() isn't reliable during setup
            RecalculateMinZoom(minZoom, cameraZoom, ImVec2((float)window_width, (float)window_height), width, height);
            cameraZoom = minZoom;  // Force initial zoom to show entire graph
            if (gDebugEnabled) {
                printf("Window size: %dx%d, World size: %dx%d\n", window_width, window_height, width, height);
                printf("World size from LayoutEngine: %dx%d\n", width, height);
                printf("LayoutEngine bounds: Min(%.1f, %.1f) Max(%.1f, %.1f)\n",
                       worldBounds.Min.x, worldBounds.Min.y, worldBounds.Max.x, worldBounds.Max.y);
                printf("Initial camera zoom: %.2f\n", cameraZoom);
            }

            // Mark all tiles dirty for initial render
            tileCache.MarkAllDirty();

            ImGui::EndFrame();
            nodeSetup = true;
            nodesDirty = true;
        }

        // Periodic memory monitoring (calls EnforceMemoryLimits which checks every 0.5s)
        static float totalSystemRAM_GB_cached = GetSystemRAM_GB();
        EnforceMemoryLimits(tileCache, totalSystemRAM_GB_cached, SAFETY_MARGIN_GB);

        // Calculate visible tiles based on camera (using previous frame's Node Editor size)
        ImVec2 worldSize = ImVec2((float)width, (float)height);
        std::vector<Tile*> visibleTiles = tileCache.GetVisibleTiles(cameraOffset, cameraZoom, nodeEditorSize, worldSize);

        // Debug: Print visible tiles and camera state during interaction
        if (gDebugEnabled) {
            static int lastVisibleCount = -1;
            static float lastZoom = -1.0f;
            if ((int)visibleTiles.size() != lastVisibleCount || fabs(cameraZoom - lastZoom) > 0.01f) {
                printf("Visible tiles: %d, Zoom: %.2f, CameraOffset: (%.0f, %.0f)\n",
                       (int)visibleTiles.size(), cameraZoom, cameraOffset.x, cameraOffset.y);
                lastVisibleCount = (int)visibleTiles.size();
                lastZoom = cameraZoom;
            }
        }

        // Check if any visible tiles are dirty AND can be rendered
        bool anyTilesDirty = false;
        for (Tile* tile : visibleTiles) {
            if (tile->isDirty) {
                // If we're at MAX_CACHED_TILES, only render already-allocated dirty tiles
                if ((tileCache.GetAllocatedTileCount() >= TileCache::MAX_CACHED_TILES) && !tile->isAllocated) {
                    continue;  // Skip unallocated tiles when at limit
                }
                anyTilesDirty = true;
                break;
            }
        }

        // Render dirty tiles
        if (anyTilesDirty) {
            ImVec4 bg = ImGui::GetStyleColorVec4(ImGuiCol_WindowBg);
            // Linearize the tile clear color to match the node/edge colors (see LinearizeForTile in
            // nodes.cpp): RGB565 tiles store linear and skip the sRGB->linear convert the old format did,
            // so bake pow(c,2.2) into the background too, or nodes would darken against a still-bright bg.
            bg = ImVec4(powf(bg.x, 2.2f), powf(bg.y, 2.2f), powf(bg.z, 2.2f), bg.w);

            // PROFILING: time the entire dirty-tile render loop
            auto profLoopStart = std::chrono::high_resolution_clock::now();
            int profTilesRendered = 0;
            long long profRenderToTileUs = 0;  // accumulated RenderToTile() time only

            // Remember which windows the last real UI frame submitted, so we can revive them after the
            // bake loop. See the restore below for why this is REQUIRED for input to work at all.
            ImGuiContext& bakeCtx = *ImGui::GetCurrentContext();
            std::vector<ImGuiWindow*> uiWindowsToRevive;
            for (ImGuiWindow* w : bakeCtx.Windows)
                if (w->Active)
                    uiWindowsToRevive.push_back(w);

            for (Tile* tile : visibleTiles) {
                if (!tile->isDirty) continue;

                // Both limits below govern ALLOCATION only, so they must not gate a tile that is already
                // allocated: re-baking one costs no new memory, it reuses the FBO it already owns.
                // Skipping those was why edits (e.g. dragging a node) appeared to do nothing once the
                // cache filled up - at the cap the very first dirty tile hit `break` and no tile in the
                // list was ever re-rendered, so the change never became visible.
                if (!tile->isAllocated) {
                    // Hard limit: stop ALLOCATING new tiles at the cache limit. `continue`, not `break`:
                    // a later tile in this list may already be allocated and still needs its re-bake.
                    if (tileCache.GetAllocatedTileCount() >= TileCache::MAX_CACHED_TILES) {
                        //TODO Austin: Make this warning only display once. Eventually display warning in GUI
                        //printf("INFO: Reached MAX_CACHED_TILES (%d), stopping tile allocation\n", TileCache::MAX_CACHED_TILES);
                        continue;
                    }

                    // Check memory BEFORE each allocation (force check, bypass 0.5s throttle)
                    if (!EnforceMemoryLimits(tileCache, totalSystemRAM_GB_cached, SAFETY_MARGIN_GB, true)) {
                        //TODO Austin: Make this warning only display once. Eventually display warning in GUI
                        //printf("CRITICAL: Low RAM detected, stopping tile allocation\n");
                        continue;
                    }

                    // Allocate GL resources (GetVisibleTiles only creates metadata, doesn't allocate)
                    tileCache.AllocateTile(tile);
                }

                // Nothing to render into. Must be checked for EVERY tile, not just ones we tried to
                // allocate above: the `continue`s in that block skip allocation but would otherwise fall
                // through to the bake below, which would render into whatever FBO is currently bound and
                // burn a full ImGui frame per tile. That is what made the zoomed-out bake balloon.
                if (!tile->isAllocated) {
                    continue;
                }

                // Start ImGui frame for this tile
                ImGui_ImplOpenGL3_NewFrame();
                ImGui_ImplSDL2_NewFrame();

                // Set DisplaySize to tile size BEFORE NewFrame
                ImGui::GetIO().DisplaySize = ImVec2((float)TileCache::TILE_SIZE, (float)TileCache::TILE_SIZE);

                ImGui::NewFrame();

                // Bind tile FBO and clear
                glBindFramebuffer(GL_FRAMEBUFFER, tile->fbo);
                glViewport(0, 0, TileCache::TILE_SIZE, TileCache::TILE_SIZE);
                glDisable(GL_SCISSOR_TEST);  // full-tile bake: never clip (overlay may have left a scissor set)
                glClearColor(bg.x, bg.y, bg.z, bg.w);
                glClear(GL_COLOR_BUFFER_BIT);

                // Create fullscreen window for rendering (unique name per tile to avoid imgui state contamination)
                char windowName[64];
                snprintf(windowName, sizeof(windowName), "##TileRender_%d_%d",
                         (int)(tile->worldBounds.Min.x / TileCache::TILE_SIZE),
                         (int)(tile->worldBounds.Min.y / TileCache::TILE_SIZE));

                ImGui::SetNextWindowPos(ImVec2(0, 0));
                ImGui::SetNextWindowSize(ImVec2((float)TileCache::TILE_SIZE, (float)TileCache::TILE_SIZE));
                // NoMouseInputs et al: this window is TILE_SIZE^2 at (0,0), so it contains every possible
                // cursor position, and it would otherwise be a hover candidate on the next real UI frame
                // (FindHoveredWindowEx walks g.Windows back-to-front and skips only NoMouseInputs windows
                // - imgui.cpp:6149). These are offscreen bake targets and must never take input or focus.
                // NOTE: this is hygiene, not the drag fix - the actual input loss was the Node Editor
                // being left inactive by these frames; see the window-revive block after the loop.
                ImGui::Begin(windowName, nullptr,
                    ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
                    ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar |
                    ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoMouseInputs |
                    ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoFocusOnAppearing |
                    ImGuiWindowFlags_NoBringToFrontOnFocus);

                // Render nodes to this tile (timed in isolation)
                auto profRTTStart = std::chrono::high_resolution_clock::now();
                graphView.RenderToTile(tile);
                auto profRTTEnd = std::chrono::high_resolution_clock::now();
                profRenderToTileUs += std::chrono::duration_cast<std::chrono::microseconds>(profRTTEnd - profRTTStart).count();
                profTilesRendered++;

                ImGui::End();
                ImGui::Render();  // Must call Render() to finalize ImGui frame state

                // Only upload/draw ImGui data for CPU path. GPU path renders directly, doesn't need ImGui's draw data
                if (!graphView.IsUsingGPURendering()) {
                    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
                }

                // Unbind FBO after each tile render
                glBindFramebuffer(GL_FRAMEBUFFER, 0);

                tile->isDirty = false;
            }

            // REVIVE THE UI WINDOWS. This is required for canvas input to work at all, and is the real
            // reason dragging appeared broken on the GPU path.
            //
            // NewFrame() does `WasActive = Active; Active = false;` for every window and THEN resolves
            // hover, and FindHoveredWindowEx() skips any window with !WasActive (imgui.cpp:5629 and
            // :6147). The bake frames above submit ONLY their tile window, so they leave "Node Editor"
            // with Active == false. The next real UI frame therefore copies that into WasActive and drops
            // the Node Editor from hover resolution entirely - IsItemHovered() on the canvas
            // InvisibleButton is false, and the whole pan/zoom/drag block is skipped.
            //
            // Because a bake only runs when something is dirty, and dragging dirties tiles, this
            // alternated: drag frame -> bake -> dead frame -> drag frame. The drag applied motion on only
            // every OTHER frame, which is exactly the "moves at a percentage of the distance" symptom.
            // Re-asserting Active here (before the UI frame's NewFrame) makes WasActive true again, so the
            // canvas is hover-eligible on every frame. Begin() re-asserts Active for real moments later;
            // this only bridges the flag across the bake frames' lifecycle.
            for (ImGuiWindow* w : uiWindowsToRevive)
                w->Active = true;

            auto profLoopEnd = std::chrono::high_resolution_clock::now();
            long long profLoopMs = std::chrono::duration_cast<std::chrono::milliseconds>(profLoopEnd - profLoopStart).count();
            if (gDebugEnabled) {
                printf("[PROFILE] Dirty-tile loop: %lld ms total | %d tiles | RenderToTile sum: %lld ms | overhead (alloc/ImGui/FBO): %lld ms\n",
                       profLoopMs, profTilesRendered, profRenderToTileUs / 1000,
                       profLoopMs - (profRenderToTileUs / 1000));

                // Report tiles actually baked, not visibleTiles.size(): those differ whenever the cap or
                // low RAM skips some, and reporting the visible count hid exactly that case.
                printf("Rendered %d dirty tiles of %d visible (%d total allocated)\n",
                       profTilesRendered, (int)visibleTiles.size(), tileCache.GetAllocatedTileCount());
            }

            // Post-render memory check: RAM can spike after batch allocation
            // Force check to detect if we need to start evicting next frame
            EnforceMemoryLimits(tileCache, totalSystemRAM_GB_cached, SAFETY_MARGIN_GB, true);

            nodesDirty = false;
        }

        // Evict old tiles if over memory limit (runs every frame, not just when rendering)
        // This ensures newly visible tiles are properly marked as needing re-render
        tileCache.EvictLRU();

        // Render UI
        ImGui_ImplOpenGL3_NewFrame();
        ImGui_ImplSDL2_NewFrame();
        ImGui::NewFrame();
        ImGui::GetIO().DisplaySize = ImVec2((float)window_width, (float)window_height);

        ImGui::Begin("Node Editor", nullptr, ImGuiWindowFlags_NoBringToFrontOnFocus);

        ImVec2 regionAvail = ImGui::GetContentRegionAvail();

        // Update Node Editor size for next frame's tile visibility calculation
        nodeEditorSize = regionAvail;

        // Get window position for tile positioning
        ImVec2 windowPos = ImGui::GetCursorScreenPos();

        // Capture camera/window state for the end-of-frame physics overlay draw (below).
        ImVec2 overlayWindowPos = windowPos;
        ImVec2 overlayRegionAvail = regionAvail;

        // Always composite tiles to screen - the tiles themselves are cached textures
        // The expensive part (rendering nodes into FBO tiles) only happens when nodesDirty=true
        ImDrawList* drawList = ImGui::GetWindowDrawList();

        // Calculate visible world region based on camera
        ImVec2 visibleWorldMin = cameraOffset;
        ImVec2 visibleWorldMax = cameraOffset + (ImVec2((float)width, (float)height) / cameraZoom);

        for (Tile* tile : visibleTiles) {
            // Transform tile world bounds to screen space
            // screen_pos = (world_pos - cameraOffset) * cameraZoom + windowPos

            ImVec2 tileWorldMin = tile->worldBounds.Min;
            ImVec2 tileWorldMax = tile->worldBounds.Max;

            // Apply camera transform: translate and scale (maintain aspect ratio!)
            ImVec2 tileScreenMin = (tileWorldMin - cameraOffset) * cameraZoom + windowPos;
            ImVec2 tileScreenMax = (tileWorldMax - cameraOffset) * cameraZoom + windowPos;

            // Clip to viewport
            ImVec2 viewportMin = windowPos;
            ImVec2 viewportMax = windowPos + regionAvail;
            if (tileScreenMax.x < viewportMin.x || tileScreenMin.x > viewportMax.x ||
                tileScreenMax.y < viewportMin.y || tileScreenMin.y > viewportMax.y)
                continue;  // Tile not visible, skip

            // Skip tiles that were evicted (don't re-allocate them!)
            if (!tile->isAllocated) {
                // Draw placeholder for evicted tiles (light gray checkerboard)
                drawList->AddRectFilled(tileScreenMin, tileScreenMax, IM_COL32(200, 200, 200, 255));
                drawList->AddRect(tileScreenMin, tileScreenMax, IM_COL32(150, 150, 150, 255), 0.0f, 0, 2.0f);
                continue;
            }

            // FBO textures are upside-down (OpenGL origin is bottom-left, ImGui is top-left)
            ImVec2 uv0 = ImVec2(0.0f, 1.0f);  // Top-left in ImGui = bottom-left in OpenGL
            ImVec2 uv1 = ImVec2(1.0f, 0.0f);  // Bottom-right in ImGui = top-right in OpenGL

            drawList->AddImage((void*)(intptr_t)tile->texture, tileScreenMin, tileScreenMax, uv0, uv1);
        }

        // Create invisible button for input handling
        ImGui::SetCursorScreenPos(windowPos);
        ImGui::InvisibleButton("##canvas", regionAvail);

        // Handle pan (Right mouse drag)
        if (ImGui::IsItemHovered() && ImGui::IsMouseDragging(ImGuiMouseButton_Right)) {
            // No `* 2` fudge here: that compensated for the bake frames deactivating the Node Editor
            // window, which made every other frame non-hovered and halved the effective pan rate (see
            // the window-revive comment in the bake loop). With input arriving on every frame again,
            // doubling would overshoot by 2x.
            ImVec2 mouseDelta = ImGui::GetIO().MouseDelta;
            // Scale mouse delta by zoom (more zoomed = faster pan in texture space)
            cameraOffset.x -= mouseDelta.x / cameraZoom;
            cameraOffset.y -= mouseDelta.y / cameraZoom;
        }
     
        // Handle zoom (mouse wheel)
        if (ImGui::IsItemHovered() && ImGui::GetIO().MouseWheel != 0.0f) {
            float zoomDelta = ImGui::GetIO().MouseWheel * 0.1f;
            float oldZoom = cameraZoom;
            cameraZoom *= (1.0f + zoomDelta);

            // Clamp zoom: minZoom = entire world visible, 10.0 = zoomed in 10x
            cameraZoom = ImMax(minZoom, ImMin(cameraZoom, 10.0f));

            // Zoom towards mouse cursor position (keep world point under cursor stationary)
            ImVec2 mousePos = ImGui::GetIO().MousePos;
            ImVec2 canvasPos = windowPos;  // Use the canvas position from earlier

            // Calculate Mouse position relative to canvas, and World position at cursor before zoom: 
            ImVec2 mouseLocalPos = ImVec2(
                mousePos.x - canvasPos.x,
                mousePos.y - canvasPos.y
            ); 
            ImVec2 worldPosAtCursor = ImVec2(
                cameraOffset.x + mouseLocalPos.x / oldZoom,
                cameraOffset.y + mouseLocalPos.y / oldZoom
            );

            // After zoom, adjust camera so same world point stays under cursor
            cameraOffset.x = worldPosAtCursor.x - mouseLocalPos.x / cameraZoom;
            cameraOffset.y = worldPosAtCursor.y - mouseLocalPos.y / cameraZoom;
        }

        // Clamp camera bounds to prevent showing empty space beyond world edges of [0,0] to [width, height]
        // With 1:1 pixel mapping: visibleWorldSize = viewportSize / zoom
        float visibleWorldWidth = regionAvail.x / cameraZoom;
        float visibleWorldHeight = regionAvail.y / cameraZoom;
        float minOffsetX = ImMax(0.0f, (float)width - visibleWorldWidth); //when bottom right of viewport -> bottom right of world
        float minOffsetY = ImMax(0.0f, (float)height - visibleWorldHeight);

        cameraOffset.x = ImClamp(cameraOffset.x, 0.0f, minOffsetX);
        cameraOffset.y = ImClamp(cameraOffset.y, 0.0f, minOffsetY);

        // We don't mark tiles dirty when camera changes - Tiles are pre-rendered and cached.
        // Tiles only become dirty when:
        // 1. First created (isDirty = true in constructor)
        // 2. User edits nodes (handled by mouse click below)

        // Track interaction state to determine if we need continuous rendering
        isInteracting = false;

        // Check if user is actively interacting
        if (ImGui::IsItemHovered()) {
            // Pan camera (Right mouse drag)
            if (ImGui::IsMouseDragging(ImGuiMouseButton_Right)) {
                isInteracting = true;  // Panning
                needsRender = true;
            }

            // Zoom camera (Mouse wheel)
            if (ImGui::GetIO().MouseWheel != 0.0f) {
                isInteracting = true;  // Zooming
                needsRender = true;
            }

            // Convert screen position to world position for node interaction
            ImVec2 mouseScreen = ImGui::GetIO().MousePos - windowPos;
            ImVec2 mouseWorld = cameraOffset + (mouseScreen / cameraZoom);

            // World-space cursor motion since the last drag frame - the drag delta (see
            // dragPrevMouseWorld: io.MouseDelta is lossy across tile bakes, io.MousePos is not).
            // Note this is already in world units, so it must NOT be divided by cameraZoom again.
            // Zero on the first drag frame so the node doesn't jump from a stale reference point.
            ImVec2 dragWorldDelta = dragPrevMouseWorldValid
                                  ? (mouseWorld - dragPrevMouseWorld)
                                  : ImVec2(0.0f, 0.0f);

            // Select node (Left mouse click)
            if (ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
                // A shift-click on a collapsed EXPANDABLE node must ALWAYS expand it, even if that
                // node sits inside another subgraph's boundary - expanding takes precedence over
                // boundary-collapse. So detect that case first and suppress the collapse branch.
                ImGui::NodeView* hoveredNode = graphView.GetNodeAt(mouseWorld);
                bool shiftExpandNode = ImGui::GetIO().KeyShift && hoveredNode &&
                                       hoveredNode->isExpandable &&
                                       !layoutEngine->IsExpanded(hoveredNode->nodeId);

                // Otherwise, check if Shift+clicked on subgraph boundary (to collapse)
                int expandedSubgraphId = shiftExpandNode ? -1 : graphView.GetExpandedSubgraphAt(mouseWorld);

                if (expandedSubgraphId != -1 && ImGui::GetIO().KeyShift) {
                    // Clicked on subgraph boundary - SPH-animated collapse. Children rush inward to
                    // the parent's slot and vanish on settle; neighbors flow back to fill the space.
                    // NO relayout: neighbors return to their EXISTING fixed homes, which keeps the
                    // nested case correct (a still-expanded outer subgraph's particles keep repelling).
                    int parentId = expandedSubgraphId;
                    const GraphData::Node* collapsedNode = dataModel->GetNode(parentId);
                    if (collapsedNode && !useGPURendering) {
                        // CPU rendering: no physics sim. Collapse and relayout immediately, then re-bake.
                        std::map<int, ImVec2> oldPositions = layoutEngine->nodePositions_;
                        layoutEngine->CollapseNode(parentId);
                        layoutEngine->ComputeLayoutLayered(*dataModel);

                        ImRect wb = layoutEngine->GetWorldBounds();
                        width = (int)wb.GetWidth();
                        height = (int)wb.GetHeight();
                        RecalculateMinZoom(minZoom, cameraZoom, nodeEditorSize, width, height);

                        std::vector<ImRect> changedRegions =
                            layoutEngine->GetChangedRegions(oldPositions, dataModel->GetConnections());
                        for (const ImRect& region : changedRegions) tileCache.MarkDirty(region);

                        // Drop the removed children's cached views.
                        for (int childId : collapsedNode->childNodeIds) {
                            auto it = graphView.nodeViewCache_.find(childId);
                            if (it != graphView.nodeViewCache_.end()) {
                                delete it->second;
                                graphView.nodeViewCache_.erase(it);
                            }
                        }
                        graphView.connectionCacheValid_ = false;
                        graphView.InvalidateNodeViews();  // positions/topology changed -> re-sync node views
                        nodesDirty = true;
                        needsRender = true;
                    }
                    else if (collapsedNode) {
                        // Snapshot current layout for the settle-time dirty-region pass.
                        physicsOldPositions = layoutEngine->nodePositions_;

                        // Children converge on the parent's ORIGINAL fixed Sugiyama slot (where the
                        // parent will reappear) - NOT the current child centroid, which has drifted
                        // during expand. GetFixedHome returns the top-left of that slot.
                        ImVec2 parentHome = physicsSim.GetFixedHome(parentId);
                        ImVec2 parentSz   = layoutEngine->GetNodeSize(parentId);
                        ImVec2 centroid(parentHome.x + parentSz.x * 0.5f,
                                        parentHome.y + parentSz.y * 0.5f);

                        // Active subset = the collapsing children + neighbors near the centroid, so
                        // the vacated space gets filled (proximity, like expand).
                        std::vector<int> activeSubset;
                        std::vector<int> childIds;
                        for (int cid : collapsedNode->childNodeIds) {
                            childIds.push_back(cid);
                            activeSubset.push_back(cid);
                        }
                        std::vector<int> neighbors;
                        const float returnRadius = 1600.0f;
                        const float displacedThresh = 5.0f;  // px from fixed home => needs to return
                        for (const auto& [id, pos] : layoutEngine->nodePositions_) {
                            if (id < 0) continue;

                            // Skip children of ANOTHER still-expanded subgraph. They belong to an
                            // open subgraph and must keep their expanded arrangement - dragging them
                            // "home" would reset that subgraph's nodes to Sugiyama while it's open.
                            const GraphData::Node* n = dataModel->GetNode(id);
                            if (n && n->parentId >= 0 && n->parentId != parentId &&
                                layoutEngine->IsExpanded(n->parentId)) {
                                continue;
                            }

                            ImVec2 sz = layoutEngine->GetNodeSize(id);
                            float cx = pos.x + sz.x * 0.5f, cy = pos.y + sz.y * 0.5f;
                            float dx = cx - centroid.x, dy = cy - centroid.y;
                            bool nearCentroid = (dx * dx + dy * dy <= returnRadius * returnRadius);

                            // Also activate any node DISPLACED from its fixed home, however far from
                            // the centroid - a directly-adjacent block gets shoved the farthest on
                            // expand and could fall outside returnRadius, then get stranded (not
                            // integrated) while its neighbors return. If it's off its slot, it must
                            // participate so it can travel back.
                            ImVec2 fh = physicsSim.GetFixedHome(id);
                            float hdx = pos.x - fh.x, hdy = pos.y - fh.y;
                            bool displaced = (hdx * hdx + hdy * hdy > displacedThresh * displacedThresh);

                            if (nearCentroid || displaced) {
                                activeSubset.push_back(id);
                                neighbors.push_back(id);
                            }
                        }

                        physicsSim.BeginCollapse(childIds, centroid, activeSubset);
                        physicsActive = true;
                        physicsCollapsePending = true;
                        physicsCollapsePhase = 1;   // children shrinking inward
                        physicsCollapseParentId = parentId;
                        physicsCollapseChildIds = childIds;
                        physicsCollapseNeighbors = neighbors;
                        // Hole-punch the moving nodes out of the tiles (overlay draws them live).
                        graphView.SetAnimatedNodes(physicsSim.GetActiveNodeIds());
                        // Dirty their current tiles + force a re-bake so the frozen copies vanish.
                        for (int id : physicsSim.GetActiveNodeIds()) {
                            if (layoutEngine->HasNodePosition(id))
                                tileCache.MarkDirty(layoutEngine->GetNodeBounds(id));
                        }
                        graphView.connectionCacheValid_ = false;
                        graphView.InvalidateNodeViews();  // positions/topology changed -> re-sync node views
                        nodesDirty = true;   // force the one-time re-bake that applies the hole-punch
                        needsRender = true;
                    }
                }
                else {
                    // Not on subgraph boundary, check if clicked on a node
                    ImGui::NodeView* clickedNode = graphView.GetNodeAt(mouseWorld);

                    if (clickedNode) {
                        // Starting a node interaction ends any armed subgraph drag, so a missed
                        // release can't leave one live underneath this click.
                        draggedSubgraphId = -1;

                        // Check if this is an expandable node and Shift is pressed
                        if (clickedNode->isExpandable && ImGui::GetIO().KeyShift && !useGPURendering) {
                            // CPU rendering: no physics sim. Expand and relayout immediately, then re-bake.
                            int parentId = clickedNode->nodeId;
                            std::map<int, ImVec2> oldPositions = layoutEngine->nodePositions_;

                            layoutEngine->ExpandNode(parentId);
                            layoutEngine->ComputeLayoutLayered(*dataModel);

                            ImRect wb = layoutEngine->GetWorldBounds();
                            width = (int)wb.GetWidth();
                            height = (int)wb.GetHeight();
                            RecalculateMinZoom(minZoom, cameraZoom, nodeEditorSize, width, height);

                            std::vector<ImRect> changedRegions =
                                layoutEngine->GetChangedRegions(oldPositions, dataModel->GetConnections());
                            for (const ImRect& region : changedRegions) tileCache.MarkDirty(region);

                            // Drop the parent's cached view; it's replaced by its children.
                            auto it = graphView.nodeViewCache_.find(parentId);
                            if (it != graphView.nodeViewCache_.end()) {
                                delete it->second;
                                graphView.nodeViewCache_.erase(it);
                            }
                            graphView.connectionCacheValid_ = false;
                            graphView.InvalidateNodeViews();  // positions/topology changed -> re-sync node views
                            nodesDirty = true;
                            needsRender = true;
                        }
                        else if (clickedNode->isExpandable && ImGui::GetIO().KeyShift) {
                            int parentId = clickedNode->nodeId;

                            // SPH-animated expand. The parent's fixed slot is the spawn point;
                            // children fly out from it to their mini-Sugiyama slots while SPH
                            // pressure shoves neighbors aside. Neighbors keep their fixed homes.
                            ImVec2 spawnPoint = layoutEngine->GetNodePosition(parentId);
                            ImVec2 parentSize = layoutEngine->GetNodeSize(parentId);
                            spawnPoint = ImVec2(spawnPoint.x + parentSize.x * 0.5f,
                                                spawnPoint.y + parentSize.y * 0.5f);

                            // Snapshot the current layout (neighbors' fixed homes) before expanding.
                            physicsOldPositions = layoutEngine->nodePositions_;

                            // Update hierarchy so children become active.
                            layoutEngine->ExpandNode(parentId);

                            // Mini-Sugiyama on JUST this subgraph, placed at the parent's slot.
                            // These become the children's fixed homes.
                            LayoutEngine::LayoutResult sub =
                                layoutEngine->LayoutSubgraph(*dataModel, parentId, spawnPoint);

                            // Build the target home/size set for ALL active nodes: neighbors keep
                            // their existing slots, children get their subgraph slots. (Survivors'
                            // homes are preserved inside BeginTransition; we still pass them so the
                            // particle set matches the active node list.)
                            std::map<int, ImVec2> homes = physicsOldPositions;  // neighbors
                            std::map<int, ImVec2> sizes = layoutEngine->nodeSizes_;
                            homes.erase(parentId);  // parent is replaced by its children
                            for (const auto& [cid, cpos] : sub.positions) {
                                if (cid < 0) continue;  // skip subgraph dummies
                                homes[cid] = cpos;
                                // Use the TRUE rendered size (varies by port count), not the
                                // fixed-height LayoutEngine size, so the animated overlay matches
                                // the eventual baked node dimensions.
                                const GraphData::Node* cn = dataModel->GetNode(cid);
                                sizes[cid] = cn ? graphView.GetRenderedNodeSize(*cn, cpos)
                                                : layoutEngine->GetNodeSize(cid);

                                // DEBUG: log each child's mini-Sugiyama home slot + rendered size,
                                // plus its layout box (slot -> slot+size) so we can see if two
                                // siblings' boxes overlap even though their slots differ.
                                printf("[EXPAND child] id=%d '%s' slot=(%.0f,%.0f) size=(%.0f,%.0f) box=[%.0f,%.0f -> %.0f,%.0f]\n",
                                       cid, cn ? cn->name.c_str() : "?",
                                       cpos.x, cpos.y, sizes[cid].x, sizes[cid].y,
                                       cpos.x, cpos.y, cpos.x + sizes[cid].x, cpos.y + sizes[cid].y);
                            }

                            // Active subset = children + every node physically NEAR the parent.
                            // Proximity (not graph topology) is what matters: the nodes that must
                            // yield are the ones the expanding subgraph will crowd. Radius scales
                            // with the subgraph's own extent so bigger subgraphs push more aside.
                            std::vector<int> activeSubset;
                            const GraphData::Node* parentNode = dataModel->GetNode(parentId);
                            if (parentNode) {
                                for (int cid : parentNode->childNodeIds) activeSubset.push_back(cid);
                            }
                            // Extent of the mini-Sugiyama result (how much space the children need).
                            ImVec2 subMin(FLT_MAX, FLT_MAX), subMax(-FLT_MAX, -FLT_MAX);
                            for (const auto& [cid, cpos] : sub.positions) {
                                if (cid < 0) continue;
                                subMin.x = ImMin(subMin.x, cpos.x); subMin.y = ImMin(subMin.y, cpos.y);
                                subMax.x = ImMax(subMax.x, cpos.x); subMax.y = ImMax(subMax.y, cpos.y);
                            }
                            float subW = (subMax.x > subMin.x) ? (subMax.x - subMin.x) : 0.0f;
                            float subH = (subMax.y > subMin.y) ? (subMax.y - subMin.y) : 0.0f;
                            float activateRadius = 0.5f * sqrtf(subW * subW + subH * subH) + 800.0f;
                            for (const auto& [id, hpos] : homes) {
                                float dx = hpos.x - spawnPoint.x, dy = hpos.y - spawnPoint.y;
                                if (dx * dx + dy * dy <= activateRadius * activateRadius)
                                    activeSubset.push_back(id);
                            }

                            // Give every animated node its TRUE rendered size so the overlay boxes
                            // match the eventual baked dimensions (neighbors too, not just children).
                            for (int id : activeSubset) {
                                const GraphData::Node* n = dataModel->GetNode(id);
                                if (n && homes.count(id))
                                    sizes[id] = graphView.GetRenderedNodeSize(*n, homes[id]);
                            }

                            physicsSim.BeginTransition(homes, sizes, spawnPoint, activeSubset);
                            physicsActive = true;
                            physicsCommitPending = true;
                            physicsNewSizes = std::move(sizes);  // apply to nodeSizes_ on commit
                            physicsParentId = parentId;

                            // Hole-punch: tell the tile baker to skip the moving nodes (they're
                            // drawn live by the overlay) so we don't get a frozen ghost underneath.
                            graphView.SetAnimatedNodes(physicsSim.GetActiveNodeIds());

                            // Dirty the tiles holding the about-to-move nodes (at their CURRENT
                            // baked positions) so they re-bake once WITHOUT those nodes. Otherwise
                            // the stale cached tile keeps showing a frozen duplicate under the overlay.
                            for (int id : physicsSim.GetActiveNodeIds()) {
                                if (layoutEngine->HasNodePosition(id))
                                    tileCache.MarkDirty(layoutEngine->GetNodeBounds(id));
                            }

                            // Drop the parent's cached view (replaced by children) and invalidate
                            // the connection cache so the new topology draws once we commit.
                            auto it = graphView.nodeViewCache_.find(parentId);
                            if (it != graphView.nodeViewCache_.end()) {
                                delete it->second;
                                graphView.nodeViewCache_.erase(it);
                            }
                            graphView.connectionCacheValid_ = false;
                            graphView.InvalidateNodeViews();  // positions/topology changed -> re-sync node views
                            nodesDirty = true;   // force the one-time re-bake that applies the hole-punch
                            needsRender = true;
                        } else {
                            // Select node (hold Ctrl to add to selection)
                            bool addToSelection = ImGui::GetIO().KeyCtrl;
                            graphView.SelectNode(clickedNode, addToSelection);

                            // Mark tiles containing this node dirty
                            tileCache.MarkDirty(clickedNode->area_node_);
                            nodesDirty = true;
                            needsRender = true;
                        }
                    } else {
                        // No node under cursor. If it's inside a subgraph boundary's empty area,
                        // arm a whole-subgraph drag; otherwise clear selection.
                        //
                        // Assigned unconditionally (-1 when the click hits no boundary): leaving a stale
                        // id here meant every later click anywhere in the world kept dragging the
                        // previously dragged subgraph, since the release handler that clears it is
                        // reached only while the canvas is hovered.
                        int boundaryId = graphView.GetExpandedSubgraphAt(mouseWorld);
                        draggedSubgraphId = boundaryId;  // topmost boundary (z-order aware), or -1
                        if (boundaryId == -1) {
                            graphView.ClearSelection();
                        }
                        needsRender = true;
                    }
                }
            }

            // Drag the whole subgraph (left-drag started on its boundary's empty area).
            // (Release is handled outside the hover block - see below.)
            if (draggedSubgraphId != -1 && ImGui::IsMouseDragging(ImGuiMouseButton_Left)) {
                // World-space cursor motion (see dragPrevMouseWorld), not per-frame io.MouseDelta.
                ImVec2 mouseDelta = dragWorldDelta;

                // Snapshot the subgraph's children old positions for dirty-region tracking.
                std::map<int, ImVec2> oldPositions;
                const GraphData::Node* sg = dataModel->GetNode(draggedSubgraphId);
                if (sg) {
                    for (int cid : sg->childNodeIds) {
                        if (layoutEngine->HasNodePosition(cid))
                            oldPositions[cid] = layoutEngine->GetNodePosition(cid);
                    }
                }

                graphView.DragSubgraph(draggedSubgraphId, mouseDelta);

                // Update the sim homes so the SPH springs pull toward the dragged-to spot, not the
                // pre-drag slot. (All-collapsed hard-resets homes to Sugiyama, so this isn't permanent.)
                if (sg) {
                    for (int cid : sg->childNodeIds) {
                        if (layoutEngine->HasNodePosition(cid))
                            physicsSim.SetHome(cid, layoutEngine->GetNodePosition(cid));
                    }
                }

                std::vector<ImRect> changedRegions = layoutEngine->GetChangedRegions(oldPositions, dataModel->GetConnections());
                for (const ImRect& region : changedRegions) {
                    tileCache.MarkDirty(region);
                }
                // Incrementally re-resolve ONLY the dragged subgraph's edges (endpoints/routes moved).
                // A full edge-cache rebuild here re-resolved all ~1M edges every frame (~540ms -> 1.6fps);
                // this touches just the moved nodes' handful of edges instead.
                if (sg) {
                    graphView.RefreshEdgeGeometryForNodes(sg->childNodeIds);
                    // The drag moved these without rebuilding the spatial buckets, so their bucket
                    // entries point at the OLD tiles. Flag them as overrides so every tile draws them
                    // (exact cull still decides where they land) instead of losing them at a seam.
                    graphView.MarkBucketOverride(sg->childNodeIds);
                }
                nodesDirty = true;
                isInteracting = true;
                needsRender = true;
            }
            // Drag selected nodes (Left mouse drag) - only when not dragging a whole subgraph.
            else if (ImGui::IsMouseDragging(ImGuiMouseButton_Left)) {
                // World-space cursor motion (already divided by zoom at the source). NOT MouseDelta -
                // see dragPrevMouseWorld for why that can lose motion across skipped frames.
                ImVec2 mouseDelta = dragWorldDelta;

                // Track old positions of selected nodes before dragging
                std::map<int, ImVec2> oldPositions;
                for (const auto& pair : graphView.nodeViewCache_) {
                    if (pair.second->state_ & ImGui::NodeStateFlag_Selected) {
                        oldPositions[pair.first] = layoutEngine->GetNodePosition(pair.first);
                    }
                }

                graphView.DragSelectedNodes(mouseDelta);

                // Update sim homes for the dragged nodes so the SPH springs target the new spot.
                for (const auto& [id, oldPos] : oldPositions) {
                    if (layoutEngine->HasNodePosition(id))
                        physicsSim.SetHome(id, layoutEngine->GetNodePosition(id));
                }

                // Mark tiles dirty that contain moved nodes + their edges (not all visible tiles!)
                std::vector<ImRect> changedRegions = layoutEngine->GetChangedRegions(oldPositions, dataModel->GetConnections());
                for (const ImRect& region : changedRegions) {
                    tileCache.MarkDirty(region);
                }

                // Incrementally re-resolve ONLY the dragged nodes' edges (endpoints/routes moved). A full
                // edge-cache rebuild here re-resolved all ~1M edges every frame (~540ms -> 1.6fps); this
                // touches just the selected nodes' handful of edges instead.
                {
                    std::vector<int> movedIds;
                    movedIds.reserve(oldPositions.size());
                    for (const auto& [id, oldPos] : oldPositions) movedIds.push_back(id);
                    graphView.RefreshEdgeGeometryForNodes(movedIds);
                    graphView.MarkBucketOverride(movedIds);  // buckets still hold their pre-drag tiles
                }
                nodesDirty = true;
                isInteracting = true;  // Dragging nodes
                needsRender = true;
            }

            // Advance the drag reference point for next frame. Only valid while the left button is
            // held: with the button up the next frame's delta is forced to zero, so a drag can never
            // begin by teleporting the node across the motion that happened before the grab.
            dragPrevMouseWorld = mouseWorld;
            dragPrevMouseWorldValid = ImGui::IsMouseDown(ImGuiMouseButton_Left);
        }
        else {
            // Cursor left the canvas - drop the reference so re-entering doesn't apply the offscreen
            // travel as one jump.
            dragPrevMouseWorldValid = false;
        }

        // Release ends any subgraph drag. Deliberately OUTSIDE the IsItemHovered() block above: a
        // release off-canvas (past the canvas edge, over another window, or outside the app) must
        // still clear this, or the drag stays armed and the next click drags the old subgraph.
        if (ImGui::IsMouseReleased(ImGuiMouseButton_Left)) {
            draggedSubgraphId = -1;
        }

        // Reset needsRender flag after this frame (unless still interacting)
        if (!isInteracting && !nodesDirty) {
            needsRender = false;
        }

        ImGui::End();

        // --- Physics layout simulation (SPH skeleton) ---
        // Press Shift+P to nudge all nodes off-home; they spring back and settle.
        // (Shift-guarded so a stray P keypress doesn't kick off a full-graph sim by accident.)
        // NudgeAll marks EVERY particle active, so the sim goes O(M^2) over the whole graph. Guard it
        // to modest graphs (<50k nodes) - on the 200k-node dataset it would be unusably slow and swamp
        // the machine. The real expand/collapse path only activates a small perturbed subset, so it's
        // unaffected by this cap.
        static const int kMaxNudgeAllNodes = 50000;
        if (physicsSim.IsSupported() && ImGui::GetIO().KeyShift && ImGui::IsKeyPressed(ImGuiKey_P, false)) {
            if (physicsSim.GetParticleCount() < kMaxNudgeAllNodes) {
                physicsSim.NudgeAll(1500.0f);  // velocity impulse px/s; clamped by maxSpeed_(4000) + maxHomeDistance_(2500)
                physicsActive = true;
            } else {
                printf("P/NudgeAll skipped: %d nodes exceeds the %d-node cap for the full-graph SPH test\n",
                       physicsSim.GetParticleCount(), kMaxNudgeAllNodes);
            }
        }
        if (physicsActive) {
            // One step per frame at an enlarged dt (advances sim-time ~4x faster than wall-clock
            // for a snappy animation) - NO extra compute vs. a single 1/60 step. Safe because the
            // home springs are weak, so dt*stiffness stays well within semi-implicit Euler's
            // stability bound. If overshoot/jitter appears, lower this dt.
            physicsSim.Step(2.0f / 60.0f);
            needsRender = true;          // keep the frame loop hot while animating
            isInteracting = true;

            // Refresh the hole-punch set each step: wake-on-contact can add nodes to the active
            // set mid-animation. A newly-woken node was baked into its tile (it wasn't animated at
            // the last bake), so dirty its tile too, or it shows a frozen copy under the overlay.
            {
                const std::set<int>& nowActive = physicsSim.GetActiveNodeIds();
                for (int id : nowActive) {
                    if (!graphView.IsAnimated(id) && layoutEngine->HasNodePosition(id)) {
                        tileCache.MarkDirty(layoutEngine->GetNodeBounds(id));  // newly woken this step
                        nodesDirty = true;
                    }
                }
                graphView.SetAnimatedNodes(nowActive);
            }

            if (physicsSim.IsSettled()) {
                physicsActive = false;
                printf("PhysicsLayoutSimulation: settled\n");

                // Commit the animated result into the layout so the tiles (which currently show
                // the pre-transition state) match what the overlay was drawing, then re-bake.
                if (physicsCommitPending) {
                    physicsCommitPending = false;

                    // The expanded parent is replaced by its children - remove it from the layout.
                    if (physicsParentId != -1) {
                        layoutEngine->nodePositions_.erase(physicsParentId);
                        layoutEngine->nodeSizes_.erase(physicsParentId);
                        physicsParentId = -1;
                    }

                    // NOTE: no snap-to-home on EXPAND. Neighbors moved specifically to make room for
                    // the subgraph; the sim's collision-resolved positions ARE their correct final
                    // spots. Snapping them back to their original Sugiyama slots would undo the room
                    // they made and drop them on top of the children now occupying that space.
                    // (Snap only makes sense on COLLAPSE, where the subgraph is gone and neighbors
                    // genuinely should return home.)

                    // Overwrite active node positions with the settled particle positions.
                    // (Children gained positions; neighbors may have shifted under pressure.)
                    physicsSim.ReadBackPositions(layoutEngine->nodePositions_);

                    // Children are new to the layout - give them their sizes so GetWorldBounds and
                    // hit-testing (which do nodeSizes_.at(id)) don't throw.
                    for (const auto& [id, sz] : physicsNewSizes) {
                        layoutEngine->nodeSizes_[id] = sz;
                    }
                    physicsNewSizes.clear();

                    // World bounds / zoom may have changed as children spread out.
                    ImRect worldBounds = layoutEngine->GetWorldBounds();
                    width = (int)worldBounds.GetWidth();
                    height = (int)worldBounds.GetHeight();
                    RecalculateMinZoom(minZoom, cameraZoom, nodeEditorSize, width, height);

                    // Mark everything that moved (old + new positions) dirty and re-bake once.
                    std::vector<ImRect> changedRegions =
                        layoutEngine->GetChangedRegions(physicsOldPositions, dataModel->GetConnections());
                    for (const ImRect& region : changedRegions) {
                        tileCache.MarkDirty(region);
                    }
                    // New nodes (children) weren't in the old snapshot; mark their new tiles too.
                    for (const auto& [id, pos] : layoutEngine->nodePositions_) {
                        if (!physicsOldPositions.count(id)) {
                            tileCache.MarkDirty(layoutEngine->GetNodeBounds(id));
                        }
                    }

                    graphView.connectionCacheValid_ = false;
                    graphView.InvalidateNodeViews();  // positions/topology changed -> re-sync node views
                    // Keep hole-punch + overlay for ONE more frame (linger) so the overlay covers the
                    // parent/edges until this re-bake actually lands next frame. Cleared in the
                    // linger-finalize step above.
                    physicsOverlayLinger = true;
                    nodesDirty = true;
                    needsRender = true;
                    physicsOldPositions.clear();
                }

                // Collapse is TWO-PHASE:
                //  Phase 1 (children shrunk into the parent): remove the children, re-inject the
                //    parent as a particle at its FIXED home, then RE-KICK so neighbors spring the
                //    rest of the way home with the children's pressure now gone. Nothing committed
                //    to the layout yet.
                //  Phase 2 (neighbors settled): commit final positions + re-bake.
                if (physicsCollapsePending && physicsCollapsePhase == 1) {
                    physicsCollapsePhase = 2;

                    // Hierarchy: node is now collapsed (children inactive in the data model).
                    layoutEngine->CollapseNode(physicsCollapseParentId);

                    // Remove children from the sim + layout + view cache.
                    physicsSim.RemoveParticles(physicsCollapseChildIds);
                    for (int cid : physicsCollapseChildIds) {
                        // Dirty the child's vacated tile so its baked body/edges clear on the next bake.
                        tileCache.MarkDirty(layoutEngine->GetNodeBounds(cid));
                        layoutEngine->nodePositions_.erase(cid);
                        layoutEngine->nodeSizes_.erase(cid);
                        auto it = graphView.nodeViewCache_.find(cid);
                        if (it != graphView.nodeViewCache_.end()) {
                            delete it->second;
                            graphView.nodeViewCache_.erase(it);
                        }
                    }

                    // Topology changed (children gone, edges now route to the collapsed parent). Invalidate
                    // the edge cache NOW - otherwise a phase-2 re-bake still holds the old child-routed
                    // edges, and since the children are no longer in the animated set they aren't hole-
                    // punched, so they bake at their old positions -> the one-frame flash of stale child
                    // edges at collapse settle. Rebuilt lazily on the next bake with parent-routed edges.
                    graphView.connectionCacheValid_ = false;
                    graphView.InvalidateNodeViews();  // positions/topology changed -> re-sync node views

                    // Re-inject the parent as a particle sitting exactly on its fixed home. This is
                    // what makes a later expand of this same parent treat it as a survivor instead
                    // of a phantom "newcomer" that teleports to the spawn point.
                    ImVec2 parentHome = physicsSim.GetFixedHome(physicsCollapseParentId);
                    // Recreate the parent's NodeView at its home (it was deleted on expand). Without
                    // it the overlay can't draw the parent (BuildOverlayNodeText/Edges early-return
                    // with no view) -> the one-frame empty parent box + edges to (0,0). Also gives
                    // the true rendered size. Put it in nodePositions_ so hit-test/layout see it too.
                    layoutEngine->nodePositions_[physicsCollapseParentId] = parentHome;
                    const GraphData::Node* parentNode = dataModel->GetNode(physicsCollapseParentId);
                    ImVec2 parentSize = parentNode
                        ? graphView.GetRenderedNodeSize(*parentNode, parentHome)
                        : layoutEngine->GetNodeSize(physicsCollapseParentId);
                    layoutEngine->nodeSizes_[physicsCollapseParentId] = parentSize;
                    physicsSim.AddParticleAtHome(physicsCollapseParentId, parentHome, parentSize);

                    // The reappearing parent is animated too (drawn by the overlay this frame), so
                    // hole-punch it out of the tiles until settle.
                    graphView.SetAnimatedNodes(physicsSim.GetActiveNodeIds());

                    // Phase 2: let the neighbors (+ reappeared parent) spring home unobstructed.
                    // With the children gone, anyone NOT still crowded by another expanded subgraph
                    // reaches its fixed Sugiyama slot; anyone still near an expanded subgraph settles
                    // pushed-out (its particles still repel) -> nested-correct, emergently.
                    std::vector<int> phase2 = physicsCollapseNeighbors;
                    phase2.push_back(physicsCollapseParentId);
                    physicsSim.ReKick(phase2);
                    physicsActive = true;  // re-arm: the outer settle set this false; run phase 2
                }
                else if (physicsCollapsePending && physicsCollapsePhase == 2) {
                    physicsCollapsePending = false;
                    physicsCollapsePhase = 0;

                    if (layoutEngine->expandedNodes_.empty()) {
                        // This was the LAST subgraph: nothing is expanded, so the all-collapsed
                        // Sugiyama layout is the correct final state for EVERY node. Hard-guarantee
                        // it - snap all nodes exactly home regardless of drift or active-set membership.
                        physicsSim.SnapAllToHome();
                    }
                    // Otherwise (subgraphs still expanded): NO snapping at all. Neighbors keep their
                    // settled positions - even ones that happen to land near their Sugiyama slot -
                    // so nodes held out by a remaining subgraph aren't yanked home and don't overlap
                    // it. Exact-home is only guaranteed once everything is collapsed (branch above).

                    // Commit the fully-settled positions (neighbors + parent now at/near home).
                    physicsSim.ReadBackPositions(layoutEngine->nodePositions_);
                    layoutEngine->nodeSizes_[physicsCollapseParentId] =
                        layoutEngine->GetNodeSize(physicsCollapseParentId);

                    ImRect worldBounds = layoutEngine->GetWorldBounds();
                    width = (int)worldBounds.GetWidth();
                    height = (int)worldBounds.GetHeight();
                    RecalculateMinZoom(minZoom, cameraZoom, nodeEditorSize, width, height);

                    std::vector<ImRect> changedRegions =
                        layoutEngine->GetChangedRegions(physicsOldPositions, dataModel->GetConnections());
                    for (const ImRect& region : changedRegions) {
                        tileCache.MarkDirty(region);
                    }

                    graphView.connectionCacheValid_ = false;
                    graphView.InvalidateNodeViews();  // positions/topology changed -> re-sync node views
                    // Linger one frame (see expand commit) so the overlay covers the reappearing
                    // parent + its edges until this re-bake lands next frame - fixes the one-frame
                    // empty parent + stray (0,0) edges at collapse settle.
                    physicsOverlayLinger = true;
                    nodesDirty = true;
                    needsRender = true;
                    physicsOldPositions.clear();
                    physicsCollapseChildIds.clear();
                    physicsCollapseNeighbors.clear();
                    physicsCollapseParentId = -1;
                }

                // Settled with NO pending expand/collapse commit - this is the standalone Shift+P
                // NudgeAll test. The nodes were hole-punched out of the tiles for the overlay; without
                // a commit path nothing would re-bake them or clear the animated set, so they'd vanish
                // once the overlay switches off. Commit the settled positions and re-bake via the same
                // linger path the expand/collapse commits use.
                if (!physicsCommitPending && !physicsCollapsePending) {
                    physicsSim.ReadBackPositions(layoutEngine->nodePositions_);
                    graphView.connectionCacheValid_ = false;
                    graphView.InvalidateNodeViews();  // positions/topology changed -> re-sync node views
                    for (const auto& [id, pos] : layoutEngine->nodePositions_)
                        tileCache.MarkDirty(layoutEngine->GetNodeBounds(id));
                    physicsOverlayLinger = true;  // keep overlay one more frame; finalize clears animated set + re-bakes
                    nodesDirty = true;
                    needsRender = true;
                }
            }
        }

        ImGui::Begin("FPS Counter");
        ImGui::Text("FPS: %.1f", ImGui::GetIO().Framerate);
        ImGui::Text("Physics: %s", physicsActive ? "ACTIVE" : "settled");

        // Tile statistics (reuse worldSize from earlier in the loop)
        int allocatedTiles = tileCache.GetAllocatedTileCount();
        int visibleTileCount = tileCache.GetVisibleTiles(cameraOffset, cameraZoom,
                                                         nodeEditorSize, worldSize).size();
        ImGui::Text("Tiles: %d visible, %d allocated", visibleTileCount, allocatedTiles);
        ImGui::Text("Memory: ~%.1f GB", allocatedTiles * 134.0f / 1024.0f);  // ~134MB/tile at RGB565 (was 268 at RGBA8)

        ImGui::End();

        ImGui::Render();

        glViewport(0, 0, (int)io.DisplaySize.x, (int)io.DisplaySize.y);
        glClearColor(clear_color.x, clear_color.y, clear_color.z, clear_color.w);
        glClear(GL_COLOR_BUFFER_BIT);
        ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());

        // Physics overlay: while the sim is active (or lingering one frame post-commit), draw nodes
        // directly from the particle SSBO on top of the composited tiles.
        if ((physicsActive || physicsOverlayLinger) && useGPURendering && gpuRenderer.IsSupported()) {
            ImVec2 overlayViewport((float)window_width, (float)window_height);

            // Clip the overlay to the Node Editor's content region so it can't spill over other
            // panels or outside the window. glScissor is in framebuffer pixels with a bottom-left
            // origin, so scale window->framebuffer (DPI) and flip Y.
            float fbScaleX = io.DisplaySize.x / (float)window_width;
            float fbScaleY = io.DisplaySize.y / (float)window_height;
            int scX = (int)(overlayWindowPos.x * fbScaleX);
            int scY = (int)((io.DisplaySize.y) - (overlayWindowPos.y + overlayRegionAvail.y) * fbScaleY);
            int scW = (int)(overlayRegionAvail.x * fbScaleX);
            int scH = (int)(overlayRegionAvail.y * fbScaleY);
            glEnable(GL_SCISSOR_TEST);
            glScissor(scX, scY, scW, scH);

            // Overlay EDGES: redraw edges touching an animated node at their LIVE positions, so
            // connections follow the moving nodes (they were hole-punched out of the frozen tiles).
            // Drawn BEFORE the nodes so node bodies sit on top of the edge endpoints (tile order).
            {
                std::vector<GPUConnectionData> overlayEdges;
                graphView.BuildOverlayEdges(
                    [&](int id) -> ImVec2 {
                        // Animated endpoint -> live sim position; otherwise its committed layout
                        // slot (so the fixed end of a half-moving edge stays put, not at origin).
                        if (graphView.IsAnimated(id)) return physicsSim.GetParticlePosition(id);
                        return layoutEngine->GetNodePosition(id);
                    },
                    overlayEdges);
                if (!overlayEdges.empty()) {
                    gpuRenderer.RenderEdgesGPUBuild(
                        overlayEdges, ImRect(), ImVec2(-cameraOffset.x, -cameraOffset.y),
                        cameraZoom, layoutEngine->GetEdgeRenderMode(),
                        overlayWindowPos, overlayViewport);
                }
            }

            gpuRenderer.RenderParticleNodes(
                physicsSim.GetParticleBuffer(), physicsSim.GetActiveBuffer(),
                physicsSim.GetActiveCount(),
                cameraOffset, cameraZoom, overlayWindowPos,
                ImVec2((float)window_width, (float)window_height));

            // Overlay TEXT: draw each animated node's title at its LIVE position, using the same
            // SDF path as the tiles but with the screen-space transform. Reuses RenderText's
            // generalized transform (windowPos + window viewportSize instead of tile 8192 space).
            if (gpuRenderer.IsSDFReady()) {
                std::vector<GPUCharData> overlayChars;
                uint32_t textColor = ImGui::GetColorU32(ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
                for (int id : physicsSim.GetActiveNodeIds()) {
                    ImVec2 p = physicsSim.GetParticlePosition(id);  // live top-left, world space
                    // Title + input/output port labels, positioned at the node's live location.
                    graphView.BuildOverlayNodeText(id, p, textColor, overlayChars);
                }
                if (!overlayChars.empty()) {
                    gpuRenderer.RenderText(overlayChars, ImRect(),
                                           ImVec2(-cameraOffset.x, -cameraOffset.y), cameraZoom,
                                           overlayWindowPos,
                                           ImVec2((float)window_width, (float)window_height));
                }
            }

            glDisable(GL_SCISSOR_TEST);  // done clipping the overlay; don't leak into next frame

            // Linger finalize (runs AFTER this frame's overlay draw): the commit happened earlier
            // this frame but the tiles were baked stale at the top; the overlay above just covered
            // the gap. Now clear the hole-punch set + re-dirty so NEXT frame's re-bake is clean and
            // the overlay switches off with the baked tiles already correct - no empty-frame gap.
            if (physicsOverlayLinger && !physicsActive) {
                physicsOverlayLinger = false;
                graphView.ClearAnimatedNodes();
                for (const auto& [id, pos] : layoutEngine->nodePositions_)
                    tileCache.MarkDirty(layoutEngine->GetNodeBounds(id));
                nodesDirty = true;
                needsRender = true;
            }
        }

        SDL_GL_SwapWindow(window);


    }

    // Cleanup
    ImGui_ImplOpenGL3_Shutdown();
    ImGui_ImplSDL2_Shutdown();

    ImGui::DestroyContext();

    SDL_GL_DeleteContext(gl_context);
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;
}