File Tree

Every source file scanned by the API documentation pipeline.

Each entry shows line count and — when the file has a top-of-file @brief — a one-line summary. Click a path to open the source file.

Auto-generated by docs/generate-file-tree.sh.

Module Dependency Graph

Edges are aggregated from #include "..." directives grouped by top-level module.

graph LR
    SparkEditor --> Communication
    SparkEditor --> Core
    SparkEditor --> Engine
    SparkEditor --> Graphics
    SparkEditor --> SceneManager
    SparkEditor --> UndoRedo
    SparkEditor --> Utils
    SparkEditor --> __
    SparkEditor --> misc
    SparkEngine --> Audio
    SparkEngine --> Camera
    SparkEngine --> Components
    SparkEngine --> Core
    SparkEngine --> D3D11
    SparkEngine --> D3D12
    SparkEngine --> Engine
    SparkEngine --> Enums
    SparkEngine --> Game
    SparkEngine --> Graphics
    SparkEngine --> HybridRT
    SparkEngine --> Input
    SparkEngine --> Metal
    SparkEngine --> OpenGL
    SparkEngine --> Physics
    SparkEngine --> RHI
    SparkEngine --> RenderGraph
    SparkEngine --> SceneManager
    SparkEngine --> Spark
    SparkEngine --> Systems
    SparkEngine --> Utils
    SparkEngine --> Vulkan
    SparkEngine --> __
    SparkGame --> Engine
    SparkGame --> Graphics
    SparkGame --> Spark
    SparkGame --> Utils
    SparkGameARPG --> Combat
    SparkGameARPG --> Demo
    SparkGameARPG --> Dungeon
    SparkGameARPG --> Engine
    SparkGameARPG --> Enums
    SparkGameARPG --> Graphics
    SparkGameARPG --> Hero
    SparkGameARPG --> Input
    SparkGameARPG --> Loot
    SparkGameARPG --> Monster
    SparkGameARPG --> Skill
    SparkGameARPG --> Spark
    SparkGameARPG --> Utils
    SparkGameFPS --> Audio
    SparkGameFPS --> Camera
    SparkGameFPS --> Console
    SparkGameFPS --> Core
    SparkGameFPS --> Engine
    SparkGameFPS --> Enums
    SparkGameFPS --> Game
    SparkGameFPS --> Graphics
    SparkGameFPS --> Input
    SparkGameFPS --> Physics
    SparkGameFPS --> Projectiles
    SparkGameFPS --> SceneManager
    SparkGameFPS --> Spark
    SparkGameFPS --> Utils
    SparkGameMMO --> Account
    SparkGameMMO --> Achievement
    SparkGameMMO --> Character
    SparkGameMMO --> Chat
    SparkGameMMO --> Crafting
    SparkGameMMO --> Dungeon
    SparkGameMMO --> Engine
    SparkGameMMO --> Enums
    SparkGameMMO --> Gameplay
    SparkGameMMO --> Graphics
    SparkGameMMO --> Guild
    SparkGameMMO --> Input
    SparkGameMMO --> Inventory
    SparkGameMMO --> Party
    SparkGameMMO --> Persistence
    SparkGameMMO --> Player
    SparkGameMMO --> Reputation
    SparkGameMMO --> Spark
    SparkGameMMO --> Trading
    SparkGameMMO --> UI
    SparkGameMMO --> Utils
    SparkGameMMO --> World
    SparkGameMMO --> WorldBoss
    SparkGameMMOFPS --> Account
    SparkGameMMOFPS --> Audio
    SparkGameMMOFPS --> Camera
    SparkGameMMOFPS --> Console
    SparkGameMMOFPS --> Core
    SparkGameMMOFPS --> Data
    SparkGameMMOFPS --> Engine
    SparkGameMMOFPS --> Game
    SparkGameMMOFPS --> Graphics
    SparkGameMMOFPS --> Input
    SparkGameMMOFPS --> Net
    SparkGameMMOFPS --> Persistence
    SparkGameMMOFPS --> Physics
    SparkGameMMOFPS --> SceneManager
    SparkGameMMOFPS --> Spark
    SparkGameMMOFPS --> UI
    SparkGameMMOFPS --> Utils
    SparkGameMMOFPS --> World
    SparkGameOpenWorld --> Audio
    SparkGameOpenWorld --> Engine
    SparkGameOpenWorld --> Enums
    SparkGameOpenWorld --> Events
    SparkGameOpenWorld --> Exploration
    SparkGameOpenWorld --> Gathering
    SparkGameOpenWorld --> Graphics
    SparkGameOpenWorld --> Persistence
    SparkGameOpenWorld --> Player
    SparkGameOpenWorld --> Settlement
    SparkGameOpenWorld --> Spark
    SparkGameOpenWorld --> Utils
    SparkGameOpenWorld --> Wildlife
    SparkGameOpenWorld --> World
    SparkGamePlatformer --> Audio
    SparkGamePlatformer --> Camera
    SparkGamePlatformer --> Checkpoint
    SparkGamePlatformer --> Collectible
    SparkGamePlatformer --> Core
    SparkGamePlatformer --> Engine
    SparkGamePlatformer --> Enums
    SparkGamePlatformer --> Hazard
    SparkGamePlatformer --> Input
    SparkGamePlatformer --> Level
    SparkGamePlatformer --> Player
    SparkGamePlatformer --> Spark
    SparkGamePlatformer --> Utils
    SparkGameRPG --> Audio
    SparkGameRPG --> Character
    SparkGameRPG --> Combat
    SparkGameRPG --> Engine
    SparkGameRPG --> Enums
    SparkGameRPG --> Gameplay
    SparkGameRPG --> Graphics
    SparkGameRPG --> Inventory
    SparkGameRPG --> NPC
    SparkGameRPG --> Spark
    SparkGameRPG --> Utils
    SparkGameRPG --> World
    SparkGameRTS --> Audio
    SparkGameRTS --> Building
    SparkGameRTS --> Command
    SparkGameRTS --> Demo
    SparkGameRTS --> Engine
    SparkGameRTS --> Enums
    SparkGameRTS --> FogOfWar
    SparkGameRTS --> Graphics
    SparkGameRTS --> Input
    SparkGameRTS --> Match
    SparkGameRTS --> Resource
    SparkGameRTS --> Spark
    SparkGameRTS --> Unit
    SparkGameRTS --> Utils
    SparkGameRacing --> AI
    SparkGameRacing --> Audio
    SparkGameRacing --> Camera
    SparkGameRacing --> Engine
    SparkGameRacing --> Enums
    SparkGameRacing --> Graphics
    SparkGameRacing --> HUD
    SparkGameRacing --> Input
    SparkGameRacing --> Race
    SparkGameRacing --> Spark
    SparkGameRacing --> Track
    SparkGameRacing --> Utils
    SparkGameRacing --> Vehicle
    SparkGameVisualScript --> Engine
    SparkGameVisualScript --> Spark
    SparkGameVisualScript --> Utils
    SparkSDK --> Spark
    SparkShaderCompiler --> __
    Tests --> Account
    Tests --> AssetPipeline
    Tests --> Audio
    Tests --> Camera
    Tests --> Communication
    Tests --> Console
    Tests --> Core
    Tests --> Data
    Tests --> Engine
    Tests --> Game
    Tests --> Graphics
    Tests --> Input
    Tests --> LevelStreaming
    Tests --> Net
    Tests --> Panels
    Tests --> Persistence
    Tests --> Physics
    Tests --> Prototyping
    Tests --> SceneManager
    Tests --> SceneSystem
    Tests --> Search
    Tests --> Spark
    Tests --> UI
    Tests --> UIDesigner
    Tests --> UndoRedo
    Tests --> Utils
    Tests --> VersionControl
    Tests --> Workflow
    Tests --> World
    Tests --> __

Hierarchy

`GameModules/SparkGame/Source/Core/`

GameplayShowcase.cpp — 472 LOC — Implementation of GameplayShowcase — engine subsystem demonstration
GameplayShowcase.h — 102 LOC — Demonstrates usage of multiple SparkEngine subsystems from a game module
Main.cpp — 222 LOC — SparkGame DLL - IModule implementation and exports
SparkGame.h — 62 LOC — SparkGame module - engine capabilities showcase

`GameModules/SparkGameARPG/Source/Combat/`

ARPGCombatSystem.cpp — 165 LOC — Real-time ARPG combat resolution, resistance calculation, and DoT processing
ARPGCombatSystem.h — 99 LOC — Real-time ARPG combat with damage types, resistances, and AoE

`GameModules/SparkGameARPG/Source/Core/`

ARPGAbilityCatalog.h — 139 LOC — Engine-native ability, aura, and proc definitions for SparkGameARPG.
ARPGEngineSystems.cpp — 553 LOC — Implementation of engine system integrations for the ARPG module
ARPGEngineSystems.h — 146 LOC — Wires Spark Engine subsystems into ARPG gameplay
Main.cpp — 485 LOC — SparkGameARPG DLL - IModule implementation and exports
SparkGameARPG.h — 92 LOC — SparkGameARPG module - Diablo-style action-RPG showcase

`GameModules/SparkGameARPG/Source/Demo/`

ARPGDemoEncounter.cpp — 361 LOC — Playable ARPG encounter orchestration.
ARPGDemoEncounter.h — 73 LOC — Small deterministic encounter loop that turns the ARPG systems into a playable example.

`GameModules/SparkGameARPG/Source/Dungeon/`

ARPGDungeonSystem.cpp — 252 LOC — Procedural dungeon floor generation and tier difficulty scaling
ARPGDungeonSystem.h — 89 LOC — Procedural dungeon level generation with difficulty tiers

`GameModules/SparkGameARPG/Source/Enums/`

ARPGEnums.h — 118 LOC — Enumerations for ARPG gameplay systems

`GameModules/SparkGameARPG/Source/Hero/`

ARPGHeroSystem.cpp — 361 LOC — Hero class definitions, stat growth, leveling, and attribute allocation
ARPGHeroSystem.h — 117 LOC — Hero classes, attributes, leveling, and experience curves

`GameModules/SparkGameARPG/Source/Loot/`

ARPGLootSystem.cpp — 262 LOC — Diablo-style randomized loot with affixes, rarity weights, and item naming
ARPGLootSystem.h — 81 LOC — Diablo-style randomized loot generation with affixes and rarity tiers

`GameModules/SparkGameARPG/Source/Monster/`

ARPGMonsterSystem.cpp — 365 LOC — Monster templates, spawning, level scaling, and champion affix assignment
ARPGMonsterSystem.h — 116 LOC — Monster types, champion affixes, elite packs, and boss encounters

`GameModules/SparkGameARPG/Source/Skill/`

ARPGSkillSystem.cpp — 288 LOC — Skill tree population, learning, cooldown tracking, and usage
ARPGSkillSystem.h — 91 LOC — Skill trees with active/passive abilities, cooldowns, and class tiers

`GameModules/SparkGameFPS/Source/Console/`

AdvancedConsoleCommands.cpp — 453 LOC — Complete console command integration for all advanced systems
AdvancedConsoleCommands.h — 21 LOC — Console command declarations for unified GraphicsEngine

`GameModules/SparkGameFPS/Source/Core/`

Main.cpp — 1304 LOC — SparkGameFPS DLL - IModule + IGameModule implementation and exports
SparkGameFPS.h — 89 LOC — SparkGameFPS module - Spark Engine FPS showcase

`GameModules/SparkGameFPS/Source/Enums/`

GameSystemEnums.h — 409 LOC — Game system enumerations for Spark Engine

`GameModules/SparkGameFPS/Source/Game/`

ArenaBuilder.cpp — 208 LOC — Procedural arena construction with multi-room layouts
ArenaBuilder.h — 69 LOC — Procedural arena construction with multi-room layouts
ClassSystem.cpp — 692 LOC — Implementation of the FPS class system
ClassSystem.h — 304 LOC — FPS class system for the Spark Engine showcase
Console.cpp — 268 LOC
Console.h — 205 LOC — Debug console system for runtime commands and logging
CubeObject.cpp — 67 LOC
CubeObject.h — 115 LOC — Axis-aligned cube primitive game object for prototyping and level design
Enemy.cpp — 432 LOC — AI-driven enemy implementation using engine BehaviorTree system
Enemy.h — 140 LOC — AI-driven enemy entity for the SparkGame arena
Game.cpp — 855 LOC
Game.h — 668 LOC — Main game class - Spark Arena engine showcase
GameConsoleOps.cpp — 894 LOC — Console integration, graphics settings, scene management, class system,
GameDebugUI.cpp — 145 LOC — Live status and editor controls for the playable Spark Arena example
GameEngineSystems.cpp — 273 LOC — Engine system integration — wires audio, weather, destruction,
GameMechanics.cpp — 397 LOC
GameMechanics.h — 229 LOC — Additional game mechanics for enhanced gameplay
GameMode.cpp — 697 LOC — Implementation of the FPS game mode system
GameMode.h — 299 LOC — FPS game mode system with scoring, rounds, and rules
GameSetup.cpp — 546 LOC — Game initialization helpers — scene creation, system setup
GravitySystem.cpp — 351 LOC
GravitySystem.h — 226 LOC — Enhanced gravity system with zones and per-object gravity
HUDSystem.cpp — 320 LOC — Implementation of the FPS HUD system
HUDSystem.h — 454 LOC — FPS Heads-Up Display system for rendering in-game UI elements
InteractiveObject.cpp — 974 LOC
InteractiveObject.h — 508 LOC — Interactive object system for Spark Engine
InventorySystem.h — 455 LOC — Item-based inventory system with slots, stacking, and weight
LootSystem.cpp — 326 LOC — Enemy loot drops and timed power-up buffs
LootSystem.h — 168 LOC — Enemy loot drops and timed power-up buffs
ModelObject.cpp — 97 LOC — Implementation of ModelObject class
ModelObject.h — 75 LOC — GameObject that renders .obj model files
MultiplayerSystem.cpp — 659 LOC — FPS multiplayer system implementation
MultiplayerSystem.h — 389 LOC — Networked multiplayer system for the FPS game module
PlaneObject.cpp — 62 LOC
PlaneObject.h — 119 LOC — Flat rectangular plane primitive for ground surfaces and level design
Player.cpp — 1084 LOC
Player.h — 795 LOC — Player character controller with movement, combat, and health systems
PlayerConsole.cpp — 251 LOC
PlayerTypes.h — 80 LOC — Player-related type definitions and state structures
ProgressionSystem.cpp — 200 LOC — XP, leveling, and unlock progression
ProgressionSystem.h — 152 LOC — XP, leveling, and unlock progression system
PyramidObject.cpp — 70 LOC
PyramidObject.h — 107 LOC — Four-sided pyramid primitive game object for decorative and test geometry
QuestSystem.h — 396 LOC — Objective-based quest tracking system with progress and rewards
RampObject.cpp — 63 LOC
RampObject.h — 111 LOC — Inclined ramp primitive game object for slopes and traversal surfaces
SphereObject.cpp — 65 LOC
SphereObject.h — 118 LOC — UV-sphere primitive game object for prototyping and physics testing
Terrain.cpp — 647 LOC
Terrain.h — 209 LOC — Enhanced terrain system with LOD, texture splatting, and RAII safety
VehicleSystem.cpp — 1009 LOC
VehicleSystem.h — 364 LOC — Ground and aerial vehicle system for Spark Engine
WallObject.cpp — 53 LOC
WallObject.h — 111 LOC — Vertical wall primitive game object for barriers and level boundaries
WaveSpawner.cpp — 284 LOC — Wave-based enemy spawning with escalating difficulty
WaveSpawner.h — 166 LOC — Wave-based enemy spawning system with escalating difficulty

`GameModules/SparkGameFPS/Source/Projectiles/`

Bullet.cpp — 52 LOC
Bullet.h — 90 LOC — High-speed hitscan-style bullet projectile for rifles and pistols
Grenade.cpp — 139 LOC
Grenade.h — 124 LOC — Gravity-affected grenade projectile with timed fuse and area explosion
Projectile.cpp — 178 LOC
Projectile.h — 212 LOC — Base class for all projectile objects in the game
ProjectilePool.cpp — 349 LOC
ProjectilePool.h — 184 LOC — Object pool system for efficient projectile management
Rocket.cpp — 139 LOC
Rocket.h — 152 LOC — Rocket projectile with contact explosion and smoke trail effect
WeaponStats.cpp — 340 LOC — Implementation of weapon statistics and utility functions
WeaponStats.h — 162 LOC — Weapon configuration and statistics system

`GameModules/SparkGameMMO/Source/Account/`

MMOAccountSystem.cpp — 551 LOC — Account registration, login authentication, and session management
MMOAccountSystem.h — 169 LOC — Account management: registration, login, sessions, bans

`GameModules/SparkGameMMO/Source/Achievement/`

MMOAchievementSystem.cpp — 318 LOC — Achievement definitions, stat tracking, and completion logic
MMOAchievementSystem.h — 114 LOC — Achievement tracking with stat-based criteria and tiered rewards

`GameModules/SparkGameMMO/Source/Character/`

MMOCharacterSystem.cpp — 480 LOC — Race/class definitions, character creation and selection
MMOCharacterSystem.h — 189 LOC — Character creation, selection, race/class definitions, and appearance

`GameModules/SparkGameMMO/Source/Chat/`

MMOChatSystem.cpp — 275 LOC — Multi-channel chat with network message routing
MMOChatSystem.h — 94 LOC — Multi-channel chat system for the MMO showcase

`GameModules/SparkGameMMO/Source/Core/`

MMOEngineSystems.cpp — 441 LOC — Wires SparkGameMMO into engine subsystems: weather, abilities, dialogue,
MMOEngineSystems.h — 110 LOC — Wires SparkGameMMO into engine subsystems: weather, abilities, dialogue,
Main.cpp — 858 LOC — SparkGameMMO DLL - IModule implementation and exports
SparkGameMMO.h — 114 LOC — SparkGameMMO module - MMO networking showcase

`GameModules/SparkGameMMO/Source/Crafting/`

MMOCraftingSystem.cpp — 369 LOC — Recipe registry, crafting execution, and skill progression
MMOCraftingSystem.h — 110 LOC — Item crafting with recipes, stations, and skill progression

`GameModules/SparkGameMMO/Source/Dungeon/`

MMODungeonSystem.cpp — 342 LOC — Dungeon definitions, instance management, boss encounters, lockouts
MMODungeonSystem.h — 143 LOC — Instanced dungeon system with boss encounters and loot lockouts

`GameModules/SparkGameMMO/Source/Enums/`

MMOEnums.h — 218 LOC — Enumerations for MMO gameplay systems

`GameModules/SparkGameMMO/Source/Gameplay/`

MMOGameplaySession.cpp — 495 LOC — Playable vertical slice for the SparkGameMMO showcase.
MMOGameplaySession.h — 104 LOC — Playable vertical slice that connects the MMO module's gameplay systems.

`GameModules/SparkGameMMO/Source/Guild/`

MMOGuildSystem.cpp — 301 LOC — Guild creation, membership, permissions, and bank operations
MMOGuildSystem.h — 116 LOC — Guild creation, rank management, permissions, and guild bank

`GameModules/SparkGameMMO/Source/Inventory/`

MMOInventorySystem.cpp — 333 LOC — Item registry, inventory operations, and loot table implementation
MMOInventorySystem.h — 118 LOC — MMO item definitions, inventory management, and loot tables

`GameModules/SparkGameMMO/Source/Party/`

MMOPartySystem.cpp — 305 LOC — Party formation, role assignment, ready checks, and loot rules
MMOPartySystem.h — 114 LOC — Party/group system for cooperative MMO content

`GameModules/SparkGameMMO/Source/Persistence/`

MMOPersistenceSystem.cpp — 891 LOC — Database schema, prepared statements, and save/load implementation
MMOPersistenceSystem.h — 257 LOC — MMO character and world persistence using AsyncDatabasePool

`GameModules/SparkGameMMO/Source/Player/`

MMOPlayerSystem.cpp — 574 LOC — MMO player spawning, replication, prediction, and area migration
MMOPlayerSystem.h — 151 LOC — MMO player management: spawning, replication, prediction, migration

`GameModules/SparkGameMMO/Source/Reputation/`

MMOReputationSystem.cpp — 309 LOC — Faction definitions, reputation changes with spillover, tier rewards
MMOReputationSystem.h — 97 LOC — Faction reputation tracking with tiered rewards and spillover

`GameModules/SparkGameMMO/Source/Trading/`

MMOTradingSystem.cpp — 420 LOC — Direct trading and auction house implementation
MMOTradingSystem.h — 124 LOC — Player-to-player trading and auction house

`GameModules/SparkGameMMO/Source/UI/`

MMOLoginUI.cpp — 545 LOC — Login, character select, and character creation ImGui panels
MMOLoginUI.h — 116 LOC — ImGui-based login, character select, and character creation screens

`GameModules/SparkGameMMO/Source/World/`

MMOWorldSetup.cpp — 501 LOC — MMO world area definitions and server topology configuration
MMOWorldSetup.h — 119 LOC — Configures the MMO world: area definitions, server topology, streaming

`GameModules/SparkGameMMO/Source/WorldBoss/`

MMOWorldBossSystem.cpp — 460 LOC — World boss definitions, phase management, contribution tracking
MMOWorldBossSystem.h — 139 LOC — Open-world boss encounters with phases, contribution tracking, shared loot

`GameModules/SparkGameMMOFPS/Source/Account/`

TFAccountSystem.cpp — 227 LOC — TERRAFRONT account register/login core logic (W5 onboarding, Task 2).
TFAccountSystem.h — 63 LOC — TERRAFRONT account register/login core logic (W5 onboarding, Task 2).
TFCharacterSystem.cpp — 165 LOC — TERRAFRONT character CRUD + enter-world core logic (W5 onboarding, Task 3).
TFCharacterSystem.h — 67 LOC — TERRAFRONT character CRUD + enter-world core logic (W5 onboarding, Task 3).
TFCrypto.cpp — 359 LOC — SHA-256 / HMAC-SHA256 / PBKDF2-HMAC-SHA256 implementation.
TFCrypto.h — 51 LOC — Self-contained SHA-256 / HMAC-SHA256 / PBKDF2-HMAC-SHA256 primitives

`GameModules/SparkGameMMOFPS/Source/Console/`

TFCommands.cpp — 461 LOC — TERRAFRONT console command registration (tf_*).
TFCommandsGameplay.cpp — 451 LOC — TERRAFRONT console commands — data/world, debug/move and W2/W3
TFCommandsInternal.h — 55 LOC — Shared internals for the TFCommands*.cpp split parts: the lower-case
TFCommandsNet.cpp — 498 LOC — TERRAFRONT console commands — chat + W5 onboarding surface and the
TFQuickplay.cpp — 148 LOC — Security-gated local-listen-host onboarding and war bootstrap.
TFQuickplay.h — 146 LOC — Local listen-host quickplay options and bootstrap entry point.

`GameModules/SparkGameMMOFPS/Source/Core/`

Main.cpp — 437 LOC — TERRAFRONT module — IModule exports and lifecycle (OnLoad boot
MainFrame.cpp — 257 LOC — TERRAFRONT module per-frame callbacks: OnUpdate / OnFixedUpdate /
SparkGameMMOFPS.h — 179 LOC — TERRAFRONT — massively-multiplayer combined-arms FPS module.
TFEvents.h — 138 LOC — TERRAFRONT in-process event structs + a tiny synchronous event bus.
TFFixedStep.h — 32 LOC — Shared TERRAFRONT authoritative fixed-step schedule.
TFTypes.h — 301 LOC — TERRAFRONT core types, ids, constants, and the shared game context.

`GameModules/SparkGameMMOFPS/Source/Data/`

TFDataTables.cpp — 380 LOC — JSON data-table loaders (factions, weapons, classes, vehicles,
TFDataTables.h — 278 LOC — JSON data-table loaders (weapons/vehicles/classes/regions/factions).
TFDataTablesInternal.h — 80 LOC — Shared internals for the TFDataTables*.cpp split parts: the
TFDataTablesParseRoster.cpp — 363 LOC — Roster-table parsers (factions/weapons/classes/vehicles) with the
TFDataTablesParseWorld.cpp — 431 LOC — World-table parsers (regions/continent lattice, presentation,

`GameModules/SparkGameMMOFPS/Source/Game/`

TFAbilitySystem.cpp — 435 LOC — Class abilities (W9) — lifecycle (Initialize/Update/FixedUpdate),
TFAbilitySystem.h — 236 LOC — Class abilities (W9): server-authoritative activation, durations,
TFAbilitySystemClient.cpp — 285 LOC — TFAbilitySystem client half: local-player mirror queries and tick,
TFAbilitySystemServer.cpp — 407 LOC — TFAbilitySystem server half: wire entry + validation, the
TFAbilityTypes.h — 117 LOC — Ability wire protocol + tuning split out of TFAbilitySystem.h
TFAudioAmbience.cpp — 433 LOC — Per-zone ambient beds (sanctuary hum / continent wind, crossfaded)
TFAudioAmbience.h — 146 LOC — Per-zone ambient audio beds + activity-biased one-shot layers.
TFAudioAmbienceWire.cpp — 145 LOC — TFAudioAmbience wire half: the W9 remote-fire client fx seam
TFBallistics.cpp — 116 LOC — Implementation of the stateless ballistics helpers: hit-zone
TFBallistics.h — 93 LOC — Server ballistics helpers for TFWeaponSystem: physics-backed world
TFBlobShadows.cpp — 217 LOC — Ground-projected blob shadow renderer (see TFBlobShadows.h for the
TFBlobShadows.h — 113 LOC — Client-side ground-projected "blob" shadows under pawns, vehicles,
TFBotSystem.cpp — 437 LOC — Server-side bots driving the REAL game paths: faction select + spawn
TFBotSystem.h — 296 LOC — Server-side AI combatants — the W2 validation workhorse that makes
TFBotSystemBrain.cpp — 396 LOC — TFBotSystem 5 Hz brain: per-life state reset, the alive think
TFBotSystemChaos.cpp — 402 LOC — TFBotSystem chaos exercise mode (bots-chaos lane): run start/stop,
TFBotSystemCombat.cpp — 236 LOC — TFBotSystem combat: target acquisition with hysteresis + rough LoS,
TFBotSystemInternal.h — 242 LOC — Shared internals for the TFBotSystem*.cpp split parts: bot tuning
TFBotSystemNav.cpp — 185 LOC — TFBotSystem local obstacle avoidance (W12 bot-navigation): chest-
TFBotSystemTypes.h — 31 LOC — Shared bot-facing declarations split out of TFBotSystem.h: the base
TFBotSystemVehicle.cpp — 300 LOC — TFBotSystem vehicle use: driver-seat approach/boarding through the
TFCaptureFx.cpp — 392 LOC — Capture-point presentation FX (see TFCaptureFx.h for the contract).
TFCaptureFx.h — 117 LOC — Client-side "capturing feels alive" presentation for region capture
TFChaosHarness.cpp — 271 LOC — Chaos-run validation: counters + the machine-greppable tf_validate
TFChaosHarness.h — 117 LOC — Chaos-run validation counters + the tf_validate PASS/FAIL report.
TFColossusSystem.cpp — 195 LOC — Colossus exosuit purchase (W3) — flux-gated in-place pawn swap.
TFColossusSystem.h — 95 LOC — Colossus exosuit purchase + suit stats (W3).
TFComponents.h — 115 LOC — TERRAFRONT ECS components (DESIGN.md §3).
TFDamageSystem.cpp — 457 LOC — Server-authoritative damage: shield-first absorb, faction regen
TFDamageSystem.h — 288 LOC — Health/shields, TTK model, friendly fire, kill credit.
TFDeployablePlacement.cpp — 201 LOC — W6 placement validation (slope / spacing / region ownership / physics
TFDeployableSystem.cpp — 347 LOC — Fabricator turret / ammo pack + Medtech beacon (W3) + resupply
TFDeployableSystem.h — 251 LOC — Fabricator turret / ammo pack + Medtech beacon (W3).
TFDeployableSystemInternal.h — 26 LOC — Shared internals for the TFDeployableSystem*.cpp split parts: the
TFDeployableSystemNet.cpp — 194 LOC — TFDeployableSystem 0x54FC-0x54FE replication: server broadcast
TFDeployableSystemServer.cpp — 265 LOC — TFDeployableSystem server placement + damage/destroy paths:
TFDeployableSystemTick.cpp — 318 LOC — TFDeployableSystem server-tick mechanics: lifetime expiry, the W3
TFDeployableTypes.h — 107 LOC — Deployable kind catalog + per-kind placement/stat specs (W6 expansion).
TFDirectiveData.h — 114 LOC — Data-driven directive (mission) definitions — code tables, no new file formats.
TFDirectiveSystem.cpp — 356 LOC — Directive progress tracking + tiered payouts (see header for design).
TFDirectiveSystem.h — 131 LOC — Server-tracked per-player directives (missions) with tiered rewards.
TFFootsteps.cpp — 283 LOC — Client-side footstep audio — see TFFootsteps.h for the trigger /
TFFootsteps.h — 101 LOC — Client-side footstep audio for the local pawn and nearby remote
TFGrenadeSystem.cpp — 275 LOC — Frag grenades (W10) — lifecycle, per-frame/fixed ticks, time base and
TFGrenadeSystem.h — 299 LOC — Frag grenades (W10): server-authoritative throw validation, ballistic
TFGrenadeSystemClient.cpp — 376 LOC — TFGrenadeSystem client half: G-key throw entry + local count mirror,
TFGrenadeSystemFx.cpp — 203 LOC — TFGrenadeSystem client rendering: replicated grenade bodies (sphere),
TFGrenadeSystemInternal.h — 33 LOC — Shared internals for the TFGrenadeSystem*.cpp split parts: the boom
TFGrenadeSystemServer.cpp — 460 LOC — TFGrenadeSystem server half: throw validation + spawn, ballistic
TFGrenadeSystemTypes.h — 172 LOC — Grenades-lane wire protocol (reserved TFMsg ids + packed structs),
TFGroundFx.cpp — 244 LOC — Hover-dust flipbook emitter (see TFGroundFx.h for the wiring
TFGroundFx.h — 97 LOC — Client-side hover-dust emitter: short-lived camera-facing flipbook
TFImpactFx.cpp — 467 LOC — Bullet-impact flipbook emitter (see TFImpactFx.h for the wiring and
TFImpactFx.h — 152 LOC — Client-side bullet-impact feedback: short-lived camera-facing
TFLanDiscovery.cpp — 362 LOC — W11 server-browser lane: lifecycle + LAN beacon broadcaster half
TFLanDiscovery.h — 149 LOC — W11 server-browser lane: LAN server discovery (UDP beacon + scanner).
TFLanDiscoveryInternal.h — 104 LOC — Shared internals for the TFLanDiscovery*.cpp split parts: the
TFLanDiscoveryScan.cpp — 185 LOC — W11 server-browser lane: LAN scanner half (client side) — bind UDP
TFMedalSystem.cpp — 239 LOC — TFMedalSystem core: the medal definition table + icon paths, system
TFMedalSystem.h — 296 LOC — Medals (killstreak / multikill / Savior / Avenger) + the server-tracked
TFMedalSystemClient.cpp — 212 LOC — TFMedalSystem client half: the TF_ScoreUpdate score-row mirror, the
TFMedalSystemServer.cpp — 337 LOC — TFMedalSystem server half: medal detection from the bus events
TFMovementModel.h — 158 LOC — TF movement model v1 — THE shared client/server movement step.
TFOpticsSystem.cpp — 351 LOC — Weapon optics presentation (see TFOpticsSystem.h for the contract).
TFOpticsSystem.h — 167 LOC — Weapon optics (W11 weapon-optics lane): per-weapon sight selection
TFOutfitSystem.cpp — 389 LOC — Outfits (clans/guilds) core: lifecycle, name/tag validation,
TFOutfitSystem.h — 277 LOC — Outfits (PS2-style clans/guilds): create, invite/accept, ranks,
TFOutfitSystemConsole.cpp — 216 LOC — TFOutfitSystem console commands (tf_outfit_*): registered from
TFOutfitSystemInternal.h — 52 LOC — Shared internals for the TFOutfitSystem*.cpp split parts: wall-clock
TFOutfitSystemScore.cpp — 157 LOC — TFOutfitSystem W12 competition score: aggregation off the existing
TFOutfitSystemServer.cpp — 448 LOC — TFOutfitSystem server op handlers: TF_OutfitRequest dispatch,
TFOutfitSystemTypes.h — 202 LOC — Outfit wire protocol split out of TFOutfitSystem.h (umbrella): the
TFOutfitSystemWire.cpp — 449 LOC — TFOutfitSystem wire halves: server-side sends (replies, chunked
TFPingSystem.cpp — 486 LOC — Squad-scoped tactical pings (W11) — server validation + squad
TFPingSystem.h — 287 LOC — Squad-scoped tactical pings (W11): server-validated placement, squad
TFPingSystemFx.cpp — 112 LOC — TFPingSystem client rendering: the billboarded diamond world markers
TFPlayerSystem.cpp — 357 LOC — Pawn registry + server spawn/kill/respawn flow, W1 full ECS
TFPlayerSystem.h — 133 LOC — Spawn/death/respawn, class loadouts, pawn registry (both sides).
TFPlayerSystemClient.cpp — 295 LOC — TFPlayerSystem query surface + pure-client half: PawnInfo queries,
TFPlayerSystemSpawn.cpp — 219 LOC — TFPlayerSystem spawn-request flow: TF_SpawnRequest validation
TFProgressionSystem.cpp — 465 LOC — Server-authoritative XP/rank/flux progression core: lifecycle, the
TFProgressionSystem.h — 275 LOC — XP events, ranks 1-30, flux income, persistence.
TFProgressionSystemInternal.h — 32 LOC — Shared internals for the TFProgressionSystem*.cpp split parts: the
TFProgressionSystemMeta.cpp — 366 LOC — TFProgressionSystem W6 progression expansion + loadout-depth wave:
TFProgressionSystemPersist.cpp — 233 LOC — TFProgressionSystem JSON persistence: read-modify-write of the
TFProgressionTypes.h — 92 LOC — Progression declaration groups split out of TFProgressionSystem.h:
TFRedeployRules.cpp — 102 LOC — Shared client/server redeploy eligibility (see TFRedeployRules.h).
TFRedeployRules.h — 61 LOC — Shared client/server eligibility rules for map redeploys (W7).
TFSecondaryMotion.cpp — 257 LOC — Damped pendulum-chain simulation (see TFSecondaryMotion.h for the
TFSecondaryMotion.h — 128 LOC — Reusable client-side secondary-motion framework: damped point-mass
TFServerValidation.cpp — 211 LOC — Server-authoritative anti-cheat sanity layer. See TFServerValidation.h
TFServerValidation.h — 190 LOC — Server-authoritative anti-cheat sanity layer (W13 anti-cheat lane).
TFSocialSystem.cpp — 354 LOC — Friends / block list / recent players + online-player roster:
TFSocialSystem.h — 237 LOC — Friends / block list / recent players + the online-player roster.
TFSocialSystemClient.cpp — 253 LOC — TFSocialSystem client mirror: roster / friends / blocked / recent
TFSocialSystemInternal.h — 67 LOC — Shared internals for the TFSocialSystem*.cpp split parts: wall-clock
TFSocialSystemServer.cpp — 372 LOC — TFSocialSystem server registry: enter/leave detection off
TFSocialSystemStore.cpp — 577 LOC — TFSocialSystem persistence: the atomic-JSON social store
TFSocialSystemWire.cpp — 181 LOC — TFSocialSystem server->client sends: list/roster snapshot builders,
TFSpectator.cpp — 345 LOC — Dead-time spectator camera lifecycle (W12 spectator-mode lane):
TFSpectator.h — 202 LOC — Dead-time spectator camera (W12 spectator-mode lane): squadmate
TFSpectatorDrive.cpp — 247 LOC — TFSpectator camera drive: the FOLLOW-mode third-person chase (wall
TFSpectatorUi.cpp — 157 LOC — TFSpectator ImGui overlay: the SPECTATING / KILLED BY / FREE CAMERA
TFSquadSystem.cpp — 266 LOC — Squads of 6 (W4): lifecycle (clock, disconnect-sweep cadence, net
TFSquadSystem.h — 287 LOC — Squads of 6: invite/accept/leave, squad spawn, waypoint.
TFSquadSystemClient.cpp — 418 LOC — TFSquadSystem client half: the local squad mirror (TF_SquadMsg state
TFSquadSystemInternal.h — 32 LOC — Shared internals for the TFSquadSystem*.cpp split parts: the roster
TFSquadSystemServer.cpp — 422 LOC — TFSquadSystem server registry: TF_SquadMsg op handlers
TFSquadTypes.h — 51 LOC — Squad constants and the W11 squad-v2 wire block (TF_SquadWaypoint on
TFTargetRange.cpp — 495 LOC — Sanctuary firing range (see the header for the cosmetic-only
TFTargetRange.h — 113 LOC — Sanctuary firing range: 6 target dummies at 20/40/60 m that react to
TFTransparentPass.cpp — 162 LOC — Sorted alpha-blended draw pass (see TFTransparentPass.h for the
TFTransparentPass.h — 116 LOC — Sorted alpha-blended draw pass for the module's basic-shader path
TFTutorial.cpp — 394 LOC — First-join sanctuary tutorial: lifecycle, console command, flow
TFTutorial.h — 147 LOC — First-join guided tutorial in Sanctuary Haven (W12 tutorial-flow
TFTutorialInternal.h — 56 LOC — Shared internals for the TFTutorial*.cpp split parts: the step-label
TFTutorialUi.cpp — 231 LOC — TFTutorial ImGui presentation: the toast line, the right-edge step
TFUiSounds.h — 104 LOC — Semantic UI bleep helper: terminal open/close/confirm/deny and
TFVehicleClient.cpp — 358 LOC — W3 vehicles — client UX half of TFVehicleSystem: terminal purchase
TFVehicleClientDraw.cpp — 218 LOC — W3 vehicles — client drawing half of TFVehicleClient.cpp: the E/B
TFVehicleFx.cpp — 322 LOC — Vehicle damage-state flipbook emitter + critical-tier engine audio
TFVehicleFx.h — 136 LOC — Client-side vehicle damage-state presentation: hull-hp-fraction
TFVehicleNet.cpp — 342 LOC — W3 vehicles — server replication half of TFVehicleSystem on the
TFVehicleNetMirror.cpp — 314 LOC — W3 vehicles — pure-client mirror half of TFVehicleSystem replication
TFVehiclePhysics.cpp — 443 LOC — Hover-rig force model: corner-spring suspension, drive/steer servo, grip,
TFVehiclePhysics.h — 133 LOC — Jolt-backed server-side rigid-body simulation for TERRAFRONT hover vehicles.
TFVehicleSystem.cpp — 358 LOC — W3 vehicles — lifecycle + shared server core: init/update/shutdown,
TFVehicleSystem.h — 299 LOC — Drifter/Aegis/Ravager/Vulture: seats, driving (ground + VTOL flight),
TFVehicleSystemDamage.cpp — 298 LOC — W3 vehicles — damage/destruction: the server-authoritative hp pool
TFVehicleSystemDrive.cpp — 288 LOC — W3 vehicles — authoritative driving model: the math-path StepVehicle
TFVehicleSystemInternal.h — 27 LOC — Shared internals for the TFVehicleSystem*.cpp split parts: the world
TFVehicleSystemRecords.h — 190 LOC — Record structs behind TFVehicleSystem, split from TFVehicleSystem.h
TFVehicleSystemSeats.cpp — 327 LOC — W3 vehicles — seats: enter/exit with the one-tick exit latch, the
TFVehicleSystemSpawn.cpp — 457 LOC — W3 vehicles — validated terminal purchase + vehicle entity creation,
TFVehicleSystemTypes.h — 74 LOC — Shared vehicle declarations split from TFVehicleSystem.h (the
TFVehicleTerminal.cpp — 206 LOC — Vehicle terminal prop spawner (see TFVehicleTerminal.h).
TFVehicleTerminal.h — 69 LOC — Client-side vehicle terminal props: one physical terminal console at
TFViewModel.cpp — 180 LOC — First-person arms + weapon viewmodel (see TFViewModel.h for the
TFViewModel.h — 139 LOC — First-person viewmodel: stylized arms + the equipped weapon, drawn at
TFViewModelInternal.h — 174 LOC — Shared internals for the TFViewModel*.cpp split parts: the viewmodel
TFViewModelRender.cpp — 484 LOC — TFViewModel per-frame Render pass: animation springs (recoil recovery,
TFVisualUtils.h — 36 LOC — Shared faction structure/pawn/vehicle tint-material lookup (sp4
TFWeaponMath.h — 167 LOC — Small float[3] vector helpers + capsule/cone math shared by the
TFWeaponServer.cpp — 268 LOC — Server half of TERRAFRONT weapons, fire-entry part: server-side
TFWeaponServerFx.cpp — 174 LOC — TFWeaponSystem server fx broadcasts: the 0x54F4 remote-fire fx for
TFWeaponServerHitscan.cpp — 235 LOC — TFWeaponSystem server hitscan: lag-compensated pellet rays with
TFWeaponServerInternal.h — 21 LOC — Shared internals for the TFWeaponServer*.cpp split parts: the
TFWeaponServerProjectile.cpp — 264 LOC — TFWeaponSystem server projectiles: spawn from validated fire events,
TFWeaponSystem.cpp — 486 LOC — Client half of TERRAFRONT weapons: loadout, ammo/reload, ADS,
TFWeaponSystem.h — 277 LOC — Data-driven weapons: hitscan + projectile, ADS/spread, ammo/reload.
TFWeaponSystemRemoteFire.cpp — 120 LOC — TFWeaponSystem remote/distant fire audio (W8 audio-polish lane):

`GameModules/SparkGameMMOFPS/Source/Net/`

TFChatRules.h — 155 LOC — Pure validation and recipient rules for TERRAFRONT chat.
TFClientNet.cpp — 333 LOC — W1 client networking core: connection observe, identity, and the
TFClientNet.h — 232 LOC — Client connection, ClientPrediction wiring, interpolation buffers.
TFClientNetHandlers.cpp — 384 LOC — TFClientNet client-side TFMsg handlers: registration/release against
TFClientNetInput.cpp — 280 LOC — TFClientNet input pump + prediction: 60 Hz InputManager sampling,
TFClientNetLoopback.cpp — 213 LOC — TFClientNet listen-host/standalone plumbing: the client-originated
TFClientNetView.cpp — 172 LOC — TFClientNet presentation plumbing: remote-pawn interpolation, the
TFClientSessionEnd.h — 18 LOC — Pure client-link teardown decision shared with tests.
TFClientSessionState.h — 55 LOC — Reply-driven onboarding state owned by one client connection.
TFFireFxProtocol.h — 187 LOC — Wire struct + message id for remote-fire fx: per-shot muzzle flash +
TFNetProtocol.h — 28 LOC — TERRAFRONT wire protocol — every app-level message on the network.
TFNetProtocolGameplay.h — 224 LOC — Packed gameplay wire structs: input, spawn, combat, capture,
TFNetProtocolIds.h — 162 LOC — TFMsg message-id enum for the TERRAFRONT wire protocol (0x5400 block).
TFNetProtocolOnboarding.h — 124 LOC — Packed onboarding wire structs: auth (W5 Task 4), character
TFNetworkLifecycle.h — 44 LOC — Shared, executable stop/restart contract for Terrafront network sessions.
TFOnboardingSessionRules.h — 18 LOC — Server-authoritative onboarding state-machine predicates.
TFRedeployProtocol.h — 64 LOC — Wire structs for the W7 map redeploy flow (ui-map-keys lane).
TFRepProtocol.h — 267 LOC — Private wire structs for the TF replication channel (owned by the
TFReplication.cpp — 334 LOC — TF replication channel (W1) — lifecycle + SERVER side: pawn
TFReplication.h — 142 LOC — TF replication channel — server-side pawn create/update/destroy
TFReplicationClient.cpp — 266 LOC — TF replication channel (W1) — CLIENT side: handlers for the 0x54F0
TFServerSim.cpp — 352 LOC — Authoritative fixed-tick simulation core: lifecycle, frozen
TFServerSim.h — 255 LOC — Authoritative fixed-tick simulation (movement validate, hits, capture).
TFServerSimConstants.h — 32 LOC — Shared simulation constants for the TFServerSim implementation split
TFServerSimMovement.cpp — 303 LOC — TFServerSim movement integration: per-player input replay through the
TFServerSimNet.cpp — 340 LOC — TFServerSim session/socket plumbing: TFMsg handler registration, client
TFServerSimNetHandlers.cpp — 455 LOC — TFServerSim gameplay TFMsg handlers: input/spawn/fire/faction, vehicle
TFServerSimOnboarding.cpp — 494 LOC — TFServerSim client-message routing choke point (the enter-world gate)
TFSocialProtocol.h — 139 LOC — Wire structs + message ids for the TERRAFRONT social layer

`GameModules/SparkGameMMOFPS/Source/Persistence/`

TFDatabase.cpp — 765 LOC — TFDatabase implementation — atomic-JSON-file backing (see TFDatabase.h).
TFDatabase.h — 145 LOC — TERRAFRONT account/character persistence (W5 onboarding, Task 1).
TFJsonStrict.h — 123 LOC — Lexical strictness missing from the DOM JSON parser.
TFOutfitStore.cpp — 469 LOC — TFOutfitStore implementation — atomic-JSON-file backing (see header).
TFOutfitStore.h — 165 LOC — TERRAFRONT outfit (clan/guild) persistence — atomic-JSON-file backing.
TFOutfitStoreDisk.cpp — 268 LOC — TFOutfitStore disk round-trip: strict-JSON load and atomic
TFPlayerMeta.cpp — 148 LOC — TFPlayerMetaStore — runtime record management + TFDatabase round-trip.
TFPlayerMeta.h — 130 LOC — Runtime per-player progression meta (unlocks, loadout, per-weapon
TFSavePaths.h — 324 LOC — One process-stable root for every TERRAFRONT persistence file.
TFShutdownOrder.h — 26 LOC — Pins the data-loss-sensitive shutdown dependency.
TFUnlockTree.cpp — 114 LOC — The unlock table (code data table) + linear lookups.
TFUnlockTree.h — 77 LOC — Data-driven-in-code weapon/vehicle unlock tree (rank- and flux-gated).
TFWorldSave.h — 231 LOC — Fail-closed, continent-qualified JSON persistence helpers.

`GameModules/SparkGameMMOFPS/Source/UI/`

TFChatWindow.cpp — 433 LOC — Client chat window implementation (see TFChatWindow.h).
TFChatWindow.h — 96 LOC — Client chat window: bottom-left overlay, channel tabs, slash-prefix
TFDeathRecap.cpp — 390 LOC — Death recap v2 client panel — see TFDeathRecap.h for the full design
TFDeathRecap.h — 114 LOC — Death recap v2 panel (W11 death-recap lane): timeline of the hits
TFDirectivePanel.cpp — 477 LOC — Directives panel implementation (see TFDirectivePanel.h).
TFDirectivePanel.h — 154 LOC — Player-facing directives panel (J): active directives with live
TFHUD.cpp — 257 LOC — TFHUD core: lifecycle, feed-in setters, and the per-frame pawn-state
TFHUD.h — 212 LOC — ImGui HUD: health/shield/ammo, crosshair, hitmarkers, killfeed,
TFHUDChat.cpp — 159 LOC — TFHUD built-in chat: the input-receiving chat window (history,
TFHUDCombat.cpp — 331 LOC — TFHUD combat-half state (W6): killfeed feed-in with headshot marker
TFHUDCombatDraw.cpp — 265 LOC — TFHUD combat-half drawing (W6): killfeed rows with weapon + headshot
TFHUDDraw.cpp — 411 LOC — TFHUD overlay drawing: the borderless full-viewport HUD window
TFHUDInternal.h — 35 LOC — Shared internals for the TFHUD*.cpp split parts: the hitmarker
TFKeybinds.h — 123 LOC — Client-side action -> key table for the TERRAFRONT UI layer.
TFLoadoutScreen.cpp — 497 LOC — loadout-depth wave: TFLoadoutScreen implementation. See the header
TFLoadoutScreen.h — 94 LOC — loadout-depth wave: the real loadout editor — primary/secondary/
TFLoginFlow.cpp — 354 LOC — W5 onboarding client UI state machine (see TFLoginFlow.h): lifecycle,
TFLoginFlow.h — 195 LOC — W5 onboarding: client ImGui state machine for login -> character
TFLoginFlowDraw.cpp — 389 LOC — TFLoginFlow rendering half: the full-viewport onboarding modal
TFMapScreen.cpp — 337 LOC — W2 continent map, lifecycle + input half: open/close/toggle with
TFMapScreen.h — 128 LOC — Continent hex map: ownership, lattice, capture progress, deploy.
TFMapScreenDraw.cpp — 486 LOC — TFMapScreen rendering half: fullscreen hex-grid overlay of the
TFMapScreenInspect.cpp — 190 LOC — TFMapScreen W7 selected-region inspect panel: owner / occupants /
TFMinimap.cpp — 402 LOC — Corner minimap v3 implementation (W13 minimap-v2 lane) — see
TFMinimap.h — 78 LOC — Corner minimap v3 (W13 minimap-v2 lane): owner-colored region hexes +
TFNameplates.cpp — 377 LOC — Over-pawn nameplate rendering + the client-side damage-reveal
TFNameplates.h — 93 LOC — Over-pawn MMO nameplates (W10): character name + outfit tag +
TFOutfitPanel.cpp — 388 LOC — Outfit UI implementation (see header for the embedding contract).
TFOutfitPanel.h — 87 LOC — Outfit (clan) UI: create form, roster with ranks, invite-by-name,
TFPingUI.cpp — 433 LOC — Q-key ping input (tap = context, hold = wheel), ray resolution,
TFPingUI.h — 112 LOC — Ping input + screen-space presentation (W11): Q-tap context ping,
TFPingUIDraw.cpp — 169 LOC — TFPingUI rendering half: distance labels drawn under the live 3D
TFScoreboard.cpp — 497 LOC — Hold-TAB fullscreen scoreboard: stacked faction sections with
TFScoreboard.h — 111 LOC — Per-faction K/D/score/regions tab screen.
TFSocialPanel.cpp — 440 LOC — Social window implementation (see TFSocialPanel.h).
TFSocialPanel.h — 69 LOC — Social window: friends / recent players / block list / squad roster.
TFSpawnScreen.cpp — 265 LOC — W2 death/spawn screen: faction splash (first join), class picker
TFSpawnScreen.h — 101 LOC — Death -> spawn point chooser (faction splash, class picker, spawn list).
TFSpawnScreenDraw.cpp — 399 LOC — TFSpawnScreen rendering half: the full-viewport deploy modal
TFSquadHUD.cpp — 430 LOC — W11 squad-v2: left-edge squadmate list, waypoint world beacon, and
TFSquadHUD.h — 76 LOC — PS2-style squad HUD (W11 squad-v2 lane): left-edge squadmate list
TFSquadHUDBeacon.cpp — 163 LOC — TFSquadHUD world-space half: the squad-waypoint beacon (tall pulsing
TFSquadHUDInternal.h — 31 LOC — Shared internals for the TFSquadHUD*.cpp split parts: the squad
TFUiCommon.h — 88 LOC — Shared ImGui helpers for the TERRAFRONT full-screen UIs
TFVehicleHUD.cpp — 242 LOC — W10 vehicle HUD bodies — seated cockpit widget (name / hull HP /
TFVehicleHUD.h — 49 LOC — W10 vehicle HUD — the seated player's cockpit widget (bottom-center):

`GameModules/SparkGameMMOFPS/Source/Utils/`

TFPerfCounters.h — 203 LOC — Cheap, allocation-free scoped timers for profiling the authoritative

`GameModules/SparkGameMMOFPS/Source/World/`

TFAlertSystem.cpp — 386 LOC — Continent alerts core: lifecycle + tf_alert console command, the
TFAlertSystem.h — 246 LOC — Continent alerts — server-scheduled timed events (Territory Rush /
TFAlertSystemInternal.h — 31 LOC — Shared internals for the TFAlertSystem*.cpp split parts: the faction
TFAlertSystemNet.cpp — 176 LOC — TFAlertSystem state view + wire plumbing: the TF_AlertState builder,
TFAlertSystemUi.cpp — 206 LOC — TFAlertSystem presentation: the tf_alert status report, the
TFAssetPaths.h — 32 LOC — TerraFront content-root-confined render asset resolution.
TFDayNight.cpp — 450 LOC — Continent day/night cycle: authoritative 40-minute day clock,
TFDayNight.h — 179 LOC — Continent day/night cycle — server-authoritative clock (1 game day ==
TFDayNightNet.cpp — 131 LOC — TFDayNight wire plumbing: the reliable TF_TimeOfDay broadcast on the
TFDecorCulling.h — 70 LOC — Distance culling for region decor entities (W10 distance-culling lane).
TFRegionDecor.cpp — 180 LOC — TFRegionDecor lifecycle: construction, Initialize (console commands),
TFRegionDecor.h — 271 LOC — Per-tier region decor: a deterministic ROLE-AGNOSTIC layout (region
TFRegionDecorData.cpp — 184 LOC — TFRegionDecor decor.json parsing (LoadTemplates): tier templates,
TFRegionDecorInstancing.cpp — 302 LOC — TFRegionDecor W12 decor-instancing lane: BuildInstanceGroups,
TFRegionDecorLayout.cpp — 425 LOC — TFRegionDecor role-agnostic layout (W10): ClearOfGameplay,
TFRegionDecorVisuals.cpp — 218 LOC — TFRegionDecor presentation passes: static collision registration
TFRegionSystem.cpp — 371 LOC — W2 territory war: lifecycle, region topology/seeding, lattice rules
TFRegionSystem.h — 214 LOC — Hex regions, conduit lattice, capture points, Dominion.
TFRegionSystemCapture.cpp — 265 LOC — TFRegionSystem authoritative side: the 1 Hz capture tick over the
TFRegionSystemInternal.h — 41 LOC — Shared internals for the TFRegionSystem*.cpp split parts: the
TFRegionSystemNet.cpp — 458 LOC — TFRegionSystem wire + persistence: TF_RegionState/TF_CaptureTick
TFRegionSystemUi.cpp — 362 LOC — TFRegionSystem viewer-facing surfaces: capture-point landmarks +
TFSanctuaryDecor.cpp — 346 LOC — Sanctuary Haven home-base decor + class terminal (see the header).
TFSanctuaryDecor.h — 76 LOC — Client-side Sanctuary Haven decor (sanc kit stamp) + the class
TFSanctuaryZone.h — 99 LOC — Sanctuary Haven zone constants + pure positional helpers (continents lane).
TFTravelSystem.cpp — 454 LOC — Continent/sanctuary travel — lifecycle, continents.json display
TFTravelSystem.h — 260 LOC — Continent/sanctuary travel: per-player mapId, sanctuary first-spawn
TFTravelSystemClient.cpp — 258 LOC — TFTravelSystem client half: local pawn/terminal helpers, the menu
TFTravelSystemInternal.h — 22 LOC — Shared internals for the TFTravelSystem*.cpp split parts: the XZ
TFTravelSystemNet.cpp — 183 LOC — TFTravelSystem wire plumbing (own channel, TFVehicleNet precedent):
TFTravelSystemServer.cpp — 227 LOC — TFTravelSystem server half: sanctuary first-spawn placement, stale
TFTravelSystemUi.cpp — 262 LOC — TFTravelSystem presentation: the [E] terminal prompt, sanctuary
TFTravelSystemWire.h — 69 LOC — Travel wire channel for TFTravelSystem: the reserved TFMsg block
TFWeatherFx.cpp — 348 LOC — Cindral dust-storm cycle (see TFWeatherFx.h for the ownership/wiring
TFWeatherFx.h — 213 LOC — Cindral dust-storm cycle: server-owned weather phase machine + pure
TFWeatherFxRender.cpp — 230 LOC — TFWeatherFx client presentation: wind-blown dust-flake billboards
TFWorldCollision.cpp — 365 LOC — Scene-file -> static Jolt box bodies: scene parse, OBJ AABB streaming,
TFWorldCollision.h — 197 LOC — Static Jolt collision for the authored scene (mesas, structures, props)
TFWorldCollisionDecor.cpp — 172 LOC — W10 decor-collision + W11 gate-passages: AddModelObb / AddObbPart
TFWorldCollisionInternal.h — 22 LOC — Shared internals for the TFWorldCollision*.cpp split parts: the body
TFWorldCollisionMove.cpp — 173 LOC — The shared capsule-sweep move resolver (server integrator + client
TFWorldSetup.cpp — 349 LOC — Scene/terrain load, WorldServer/AreaServer boot, origin-rebase driving.
TFWorldSetup.h — 256 LOC — Scene/terrain load, WorldServer/AreaServer boot, origin-rebase driving.
TFWorldSetupDraw.cpp — 392 LOC — TFWorldSetup camera + device-direct draw helpers: module camera,
TFWorldSetupNet.cpp — 262 LOC — TFWorldSetup networking boot (frozen API): StartHost/StartDedicated/
TFWorldSetupRender.cpp — 318 LOC — TFWorldSetup frame composition (RenderWorld): the module-owned
TFWorldSetupUpdate.cpp — 169 LOC — TFWorldSetup frame driving: per-frame Update (network pump, weather,

`GameModules/SparkGameOpenWorld/Source/Core/`

Main.cpp — 607 LOC — SparkGameOpenWorld DLL - IModule implementation and exports
OWEngineSystems.cpp — 384 LOC — Wires open world gameplay into engine subsystems
OWEngineSystems.h — 83 LOC — Wires open world gameplay into engine subsystems
SparkGameOpenWorld.h — 79 LOC — Open world game module - large-world exploration showcase

`GameModules/SparkGameOpenWorld/Source/Enums/`

OpenWorldEnums.h — 225 LOC — Enumerations for open world gameplay systems

`GameModules/SparkGameOpenWorld/Source/Events/`

OWDynamicEventSystem.cpp — 421 LOC — Dynamic world events and random encounters
OWDynamicEventSystem.h — 111 LOC — Dynamic world events, random encounters, and emergent gameplay

`GameModules/SparkGameOpenWorld/Source/Exploration/`

OWExplorationSystem.cpp — 396 LOC — POI discovery, map fog, and exploration progress tracking
OWExplorationSystem.h — 116 LOC — Points of interest, map discovery, landmarks, and exploration rewards

`GameModules/SparkGameOpenWorld/Source/Gathering/`

OWGatheringSystem.cpp — 532 LOC — Resource nodes, harvesting, and crafting recipes
OWGatheringSystem.h — 150 LOC — Resource nodes, harvesting, and crafting recipes

`GameModules/SparkGameOpenWorld/Source/Persistence/`

OWSaveData.h — 34 LOC — Versioned snapshot for OpenWorld gameplay state.

`GameModules/SparkGameOpenWorld/Source/Player/`

OWPlayerSystem.cpp — 316 LOC — Player survival mechanics, fast travel, and compass
OWPlayerSystem.h — 129 LOC — Open world player: survival stats, stamina, fast travel, compass

`GameModules/SparkGameOpenWorld/Source/Settlement/`

OWSettlementSystem.cpp — 461 LOC — NPC settlements and player camp management
OWSettlementSystem.h — 118 LOC — NPC settlements, merchants, and player camp building

`GameModules/SparkGameOpenWorld/Source/Wildlife/`

OWWildlifeSystem.cpp — 637 LOC — Wildlife ecology, herd behavior, predator-prey, taming
OWWildlifeSystem.h — 130 LOC — Wildlife ecology: animal spawning, herds, predator-prey, taming

`GameModules/SparkGameOpenWorld/Source/World/`

OWWorldSetup.cpp — 420 LOC — Open world biome regions, road network, and streaming registration
OWWorldSetup.h — 101 LOC — Open world map with 8 biome regions, seamless streaming, and origin rebasing

`GameModules/SparkGamePlatformer/Source/Camera/`

PlatformerCameraSystem.cpp — 241 LOC — Third-person follow camera with smooth tracking, look-ahead, and collision
PlatformerCameraSystem.h — 120 LOC — Third-person follow camera for 3D platformer

`GameModules/SparkGamePlatformer/Source/Checkpoint/`

PlatformerCheckpointSystem.cpp — 212 LOC — Checkpoint activation, respawn tracking, and flag animation
PlatformerCheckpointSystem.h — 91 LOC — Checkpoint and respawn system for platformer levels

`GameModules/SparkGamePlatformer/Source/Collectible/`

PlatformerCollectibleSystem.cpp — 296 LOC — Collectible placement, collection detection, and tracking
PlatformerCollectibleSystem.h — 137 LOC — Collectible management: coins, gems, stars, keys, power-ups

`GameModules/SparkGamePlatformer/Source/Core/`

Main.cpp — 445 LOC — SparkGamePlatformer DLL - IModule implementation and exports
PlatformerEngineSystems.cpp — 351 LOC — Engine system integration — wires audio, events, save, destruction,
PlatformerEngineSystems.h — 102 LOC — Wires SparkEngine subsystems (audio, events, save, destruction,
SparkGamePlatformer.h — 84 LOC — SparkGamePlatformer module - 3D platformer showcase

`GameModules/SparkGamePlatformer/Source/Enums/`

PlatformerEnums.h — 114 LOC — Enumerations for 3D platformer gameplay systems

`GameModules/SparkGamePlatformer/Source/Hazard/`

PlatformerHazardSystem.cpp — 476 LOC — Environmental hazard logic: crushers, sawblades, projectiles, lasers
PlatformerHazardSystem.h — 138 LOC — Environmental hazards: spikes, lava, crushers, sawblades, lasers

`GameModules/SparkGamePlatformer/Source/Level/`

PlatformerLevelSystem.cpp — 472 LOC — Level layout, progression, star ratings, and speedrun timer
PlatformerLevelSystem.h — 167 LOC — Level management: layout, platforms, themes, progression, and star ratings

`GameModules/SparkGamePlatformer/Source/Player/`

PlatformerPlayerController.cpp — 706 LOC — 3D platformer player controller with physics, state machine, and abilities
PlatformerPlayerController.h — 219 LOC — 3D platformer player movement, jumping, and ability state machine

`GameModules/SparkGameRPG/Source/Character/`

RPGCharacterSystem.cpp — 458 LOC — Character class definitions, stat growth, leveling, and equipment
RPGCharacterSystem.h — 152 LOC — Character creation, class definitions, stat allocation, and leveling

`GameModules/SparkGameRPG/Source/Combat/`

RPGCombatSystem.cpp — 342 LOC — Action combat, cooldowns, combos, damage formulas, and knockback
RPGCombatSystem.h — 134 LOC — Action-based combat with cooldowns, combos, and elemental damage

`GameModules/SparkGameRPG/Source/Core/`

Main.cpp — 508 LOC — SparkGameRPG DLL - IModule implementation and exports
RPGEngineSystems.cpp — 438 LOC — Wires RPG gameplay into engine subsystems
RPGEngineSystems.h — 77 LOC — Wires RPG gameplay into save, AI, cinematic, environment, audio, and event systems
SparkGameRPG.h — 88 LOC — SparkGameRPG module - RPG mechanics showcase

`GameModules/SparkGameRPG/Source/Dialogue/`

RPGDialogueSystem.cpp — 324 LOC — Branching dialogue, skill checks, and reward distribution
RPGDialogueSystem.h — 134 LOC — Branching dialogue trees with skill checks and consequences

`GameModules/SparkGameRPG/Source/Enums/`

RPGEnums.h — 152 LOC — Enumerations for RPG gameplay systems

`GameModules/SparkGameRPG/Source/Gameplay/`

RPGDemoSession.cpp — 689 LOC — Playable travel, combat, quest, and inventory loop for SparkGameRPG
RPGDemoSession.h — 75 LOC — Playable orchestration layer for the SparkGameRPG showcase
RPGDemoSessionUI.cpp — 77 LOC — Editor controls for the playable SparkGameRPG showcase
RPGGameplayBridge.cpp — 356 LOC
RPGGameplayBridge.h — 44 LOC

`GameModules/SparkGameRPG/Source/Inventory/`

RPGInventorySystem.cpp — 533 LOC — Item registry, inventory management, and equipment comparison
RPGInventorySystem.h — 110 LOC — Item definitions, equipment, consumables, and weight-based inventory

`GameModules/SparkGameRPG/Source/NPC/`

RPGNPCSystem.cpp — 415 LOC — NPC behavior, schedule updates, patrol movement, and disposition
RPGNPCSystem.h — 118 LOC — NPC AI with behavior states, schedules, and disposition

`GameModules/SparkGameRPG/Source/Quest/`

RPGQuestSystem.cpp — 357 LOC — Quest definitions, tracking, objective updates, and journal
RPGQuestSystem.h — 112 LOC — Quest tracking with objectives, chains, rewards, and journal

`GameModules/SparkGameRPG/Source/World/`

RPGWorldSetup.cpp — 275 LOC — RPG world areas, encounter tables, and streaming registration
RPGWorldSetup.h — 84 LOC — Defines RPG world areas, connections, and encounter tables

`GameModules/SparkGameRTS/Source/Building/`

RTSBuildingSystem.cpp — 428 LOC — Building templates, placement, construction timers, and production queues
RTSBuildingSystem.h — 121 LOC — Base building: tech trees, production queues, and structure management

`GameModules/SparkGameRTS/Source/Command/`

RTSCommandSystem.cpp — 311 LOC — Unit selection, command issuing, and command queue processing
RTSCommandSystem.h — 86 LOC — Unit commands: selection, move, attack, patrol, hold, build, gather

`GameModules/SparkGameRTS/Source/Core/`

Main.cpp — 431 LOC — SparkGameRTS DLL - IModule implementation and exports
RTSEngineSystems.cpp — 548 LOC — Implementation of RTSEngineSystems -- engine service wiring for the RTS module
RTSEngineSystems.h — 105 LOC — Wires SparkEngine subsystems (AI, events, audio, weather, destruction,
RTSPersistence.h — 401 LOC — Deterministic, validated snapshot codec for the RTS module's non-ECS state.
SparkGameRTS.h — 86 LOC — SparkGameRTS module - RTS mechanics showcase

`GameModules/SparkGameRTS/Source/Demo/`

RTSDemoPresentation.cpp — 425 LOC — Playable RTS showcase setup, controls, fog updates, and battlefield UI
RTSDemoPresentation.h — 67 LOC — Playable RTS showcase setup, controls, fog updates, and battlefield UI

`GameModules/SparkGameRTS/Source/Enums/`

RTSEnums.h — 131 LOC — Enumerations for RTS gameplay systems

`GameModules/SparkGameRTS/Source/FogOfWar/`

RTSFogOfWarSystem.cpp — 258 LOC — Grid-based fog of war: vision updates, exploration, and reveal/hide
RTSFogOfWarSystem.h — 82 LOC — Grid-based fog of war with vision ranges and exploration tracking

`GameModules/SparkGameRTS/Source/Match/`

RTSMatchSystem.cpp — 279 LOC — Match lifecycle: setup, faction selection, win conditions, state tracking
RTSMatchSystem.h — 82 LOC — Match management: setup, factions, win conditions, state tracking

`GameModules/SparkGameRTS/Source/Resource/`

RTSResourceSystem.cpp — 369 LOC — Economy: resource gathering, supply management, and node tracking
RTSResourceSystem.h — 104 LOC — Economy: minerals, gas, supply, resource nodes, and worker assignment

`GameModules/SparkGameRTS/Source/Unit/`

RTSUnitSystem.cpp — 318 LOC — Unit templates, spawning, lifecycle, and behavioral AI
RTSUnitSystem.h — 112 LOC — Unit management: templates, spawning, stats, and AI states

`GameModules/SparkGameRacing/Source/AI/`

RacingAIDriver.cpp — 384 LOC — AI racer behavior with difficulty scaling and rubber-banding
RacingAIDriver.h — 136 LOC — AI racer behavior with difficulty scaling and rubber-banding

`GameModules/SparkGameRacing/Source/Camera/`

RacingCameraSystem.cpp — 336 LOC — Multiple camera modes with smooth transitions
RacingCameraSystem.h — 115 LOC — Multiple camera modes for the racing showcase

`GameModules/SparkGameRacing/Source/Core/`

Main.cpp — 404 LOC — SparkGameRacing DLL - IModule implementation and exports
MainRaceFlow.cpp — 320 LOC — SparkGameRacing race-flow orchestration: default roster setup and
RacingEngineSystems.cpp — 471 LOC — Engine system integration for the racing module
RacingEngineSystems.h — 109 LOC — Wires Spark Engine subsystems into racing gameplay
RacingPersistence.h — 302 LOC — Deterministic, validated snapshot codec for Racing's non-ECS state.
RacingRaceFlow.cpp — 74 LOC — Module-independent racing flow helpers shared by runtime orchestration and tests.
RacingRaceFlow.h — 37 LOC — Testable race-flow decisions shared by the module orchestration.
SparkGameRacing.h — 89 LOC — SparkGameRacing module - Racing game showcase

`GameModules/SparkGameRacing/Source/Enums/`

RacingEnums.h — 97 LOC — Enumerations for racing gameplay systems

`GameModules/SparkGameRacing/Source/HUD/`

RacingHUDSystem.cpp — 218 LOC — Racing HUD overlay rendering
RacingHUDSystem.h — 116 LOC — Racing HUD overlay (speedometer, minimap, standings)

`GameModules/SparkGameRacing/Source/Race/`

RacingRaceManager.cpp — 494 LOC — Race lifecycle, timing, position tracking, and championship points
RacingRaceManager.h — 169 LOC — Race lifecycle, timing, and position tracking

`GameModules/SparkGameRacing/Source/Track/`

RacingTrackSystem.cpp — 368 LOC — Track layout, checkpoints, and surface zone management
RacingTrackSystem.h — 148 LOC — Track layout, checkpoints, and surface zones for the racing showcase

`GameModules/SparkGameRacing/Source/Vehicle/`

RacingVehicleSystem.cpp — 395 LOC — Physics-based vehicle driving model
RacingVehicleSystem.h — 139 LOC — Physics-based vehicle driving model for the racing showcase

`GameModules/SparkGameVisualScript/Source/Core/`

Main.cpp — 506 LOC — SparkGameVisualScript — IModule shell that loads visual scripts
SparkGameVisualScript.h — 78 LOC — Visual-script-only game module — zero C++ game logic
VisualScriptDemoRuntime.h — 127 LOC — Deterministic manifest and source binding helpers for the visual-script demo.

`SparkConsole/src/`

CommandParser.cpp — 57 LOC
CommandParser.h — 37 LOC — Splits raw command-line strings into a command name and argument list.
CommandRegistry.cpp — 84 LOC
CommandRegistry.h — 79 LOC — Console command registration and dispatch for the SparkConsole subprocess.
ConsoleApp.cpp — 1086 LOC
ConsoleApp.h — 125 LOC — SparkConsole application — external console subprocess for the Spark Engine.
PipeMessageFramer.h — 77 LOC — Bounded newline framing for the engine-to-SparkConsole byte stream.
main.cpp — 90 LOC

`SparkEditor/Source/Animation/`

AnimationClipManager.cpp — 291 LOC — AnimationTrack, AnimationClip methods, and AnimationTimeline file I/O
AnimationCurve.cpp — 177 LOC — AnimationCurve class methods: Evaluate, AddKeyframe, RemoveKeyframe, FindKeyframe
AnimationPlayback.cpp — 523 LOC — Playback controls, recording, keyframe editing, coordinate mapping, and view management
AnimationTimeline.cpp — 41 LOC — AnimationTimeline construction, initialization, and shutdown
AnimationTimeline.h — 447 LOC — Professional animation system and timeline editor for Spark Engine
AnimationTimelineTypes.h — 263 LOC — Type definitions for the animation timeline system
AnimationTimelineUI.cpp — 918 LOC — ImGui rendering and input handling for AnimationTimeline

`SparkEditor/Source/AssetBrowser/`

AssetDatabase.cpp — 997 LOC — Implementation of the advanced asset management system
AssetDatabase.h — 317 LOC — Advanced asset management system for Spark Engine Editor

`SparkEditor/Source/AssetPipeline/`

AdvancedAssetPipeline.cpp — 1031 LOC — Implementation of the advanced asset processing and pipeline system
AdvancedAssetPipeline.h — 569 LOC — Advanced asset processing and pipeline system for Spark Engine Editor
AdvancedAssetPipelineUI.cpp — 997 LOC — UI rendering methods for the AdvancedAssetPipeline
AssetPipelineTypes.h — 230 LOC — Type definitions for the advanced asset pipeline system
AssetProcessors.cpp — 1104 LOC — Asset processor implementations (Texture, Mesh, Audio, DependencyGraph)

`SparkEditor/Source/`

CommandHistory.h — 403 LOC — Undo/Redo command pattern for the Spark Editor

`SparkEditor/Source/Communication/`

CollaborativeEditSession.cpp — 1613 LOC — Multi-user collaborative editor session with TCP networking
CollaborativeEditSession.h — 442 LOC — Multi-user collaborative editor session with presence, locking, and TCP networking
CollaborativeEditSessionBroker.cpp — 395 LOC — SparkCollabServer-backed CollaborativeEditSession lifecycle and snapshot translation.
EngineInterface.cpp — 718 LOC — Implementation of the Engine communication interface
EngineInterface.h — 453 LOC — Communication interface between Editor and Engine
LiveEditBridge.cpp — 270 LOC — Bridge between collaborative editing and a running AreaServer
LiveEditBridge.h — 125 LOC — Bridge between collaborative editing and a running AreaServer
StandaloneCollaborationClient.cpp — 206 LOC — Typed editor/client transport for SparkCollabServer.
StandaloneCollaborationClient.h — 64 LOC — Typed editor/client transport for the standalone collaboration broker.

`SparkEditor/Source/Core/`

EditorApplication.cpp — 294 LOC — Implementation of the enhanced editor application class
EditorApplication.h — 153 LOC — Main SparkEditor application class with cross-platform graphics and ImGui integration
EditorApplicationLinux.cpp — 349 LOC — Linux/SDL2+OpenGL editor application — window creation, graphics init, run loop, shutdown
EditorApplicationWindows.cpp — 467 LOC — Windows/D3D11 editor application — window creation, graphics init, run loop, shutdown
EditorCommandRegistry.cpp — 187 LOC — Command palette registration for the SparkEditor UI.
EditorCrashHandler.cpp — 1067 LOC — Implementation of the editor crash handler
EditorCrashHandler.h — 206 LOC — Enhanced crash handling system for Spark Engine Editor
EditorFonts.cpp — 155 LOC — Font loading implementation for the Spark Engine Editor
EditorFonts.h — 57 LOC — Font management for the Spark Engine Editor
EditorIcons.h — 229 LOC — FontAwesome 6 icon constants for the Spark Engine Editor
EditorLayoutManager.cpp — 627 LOC — Implementation of EditorLayoutManager — disk-backed panel layouts
EditorLayoutManager.h — 234 LOC — Panel-layout persistence for the Spark Engine Editor
EditorLogger.cpp — 337 LOC — Implementation of the editor logging system
EditorLogger.h — 303 LOC — Advanced logging system for the Spark Engine Editor
EditorMenuBar.cpp — 914 LOC — Main menu bar and toolbar rendering for the SparkEditor UI
EditorNotificationManager.cpp — 134 LOC — Implementation of the SparkEditor toast notification queue.
EditorNotificationManager.h — 62 LOC — Toast-style notification queue for the SparkEditor UI.
EditorPanel.cpp — 86 LOC — Implementation of base editor panel class
EditorPanel.h — 301 LOC — Base class for all editor UI panels
EditorPanelFactory.cpp — 362 LOC — Panel creation for the SparkEditor UI
EditorPanelFactoryMetadata.cpp — 211 LOC — Panel metadata setup (icons, categories, default visibility) for the SparkEditor UI
EditorPluginManager.cpp — 501 LOC — Implementation of the editor plugin manager (R7.1)
EditorPluginManager.h — 230 LOC — Manages editor plugin lifecycle and registration (R7.1)
EditorTheme.cpp — 1587 LOC — Theme system implementation for the Spark Engine Editor
EditorTheme.h — 339 LOC — Professional theme management system with Unity/Unreal-inspired styling
EditorUI.cpp — 2247 LOC — Core editor UI system — lifecycle, rendering dispatch, layout, commands
EditorUI.h — 505 LOC — Core UI management system for the Spark Engine Editor with advanced features
EditorWindowManager.cpp — 399 LOC — Implementation of EditorWindowManager methods (layout persistence, JSON helpers)
EditorWindowManager.h — 245 LOC — Multi-monitor floating window management with layout persistence
IEditorPlugin.h — 100 LOC — Abstract interface for editor plugins (R7.1)
ProjectManager.cpp — 2482 LOC — Implementation of the project management system
ProjectManager.h — 223 LOC — Project management system for the Spark Engine Editor
TutorialSystem.h — 531 LOC — Interactive editor tutorial system with step-by-step guidance

`SparkEditor/Source/Enums/`

AudioSystemEnums.h — 114 LOC — Enumerations for the audio system
BuildSystemEnums.h — 115 LOC — Enumerations for the build and deployment system
CoreEditorEnums.h — 111 LOC — Core enumerations for the editor application
LevelStreamingEnums.h — 149 LOC — Enumerations for the level streaming system
ProfilerEnums.h — 124 LOC — Enumerations for the performance profiler system
RenderingEnums.h — 186 LOC — Enumerations for the rendering and graphics system
SceneSystemEnums.h — 206 LOC — Enumerations for the scene management system
VersionControlEnums.h — 128 LOC — Enumerations for the version control system

`SparkEditor/Source/Gizmos/`

GizmoSystem.cpp — 925 LOC — 3D object manipulation gizmo system implementation
GizmoSystem.h — 463 LOC — 3D object manipulation gizmo system for the Spark Engine Editor
SceneEditTools.cpp — 398 LOC — Implementation of the undoable scene-manipulation helpers (W9)
SceneEditTools.h — 77 LOC — Undoable scene-manipulation helpers for the editor viewport (W9)

`SparkEditor/Source/Integration/`

ExternalConsoleIntegration.cpp — 931 LOC — Enhanced external console integration with engine-style logging
ExternalConsoleIntegration.h — 153 LOC — External console integration for Spark Engine Editor
IntegrationTypes.h — 164 LOC — Type definitions for editor/engine integration
SparkEngineIntegration.cpp — 972 LOC — Full implementation of SparkEngineIntegration
SparkEngineIntegration.h — 612 LOC — Deep integration system between Spark Engine Editor and Runtime

`SparkEditor/Source/LevelStreaming/`

LevelStreamingSystem.cpp — 1272 LOC
LevelStreamingSystem.h — 463 LOC — Level streaming and world composition system for large worlds in Spark Engine
LevelStreamingTypes.h — 237 LOC — Type definitions for the level streaming and world composition system

`SparkEditor/Source/Lighting/`

LightingTools.cpp — 1163 LOC — Full implementation of the advanced lighting and environment system
LightingTools.h — 556 LOC — Advanced lighting and environment system for Spark Engine
LightingToolsUI.cpp — 864 LOC — UI rendering methods for LightingTools

`SparkEditor/Source/MaterialEditor/`

MaterialEditor.cpp — 1269 LOC — Node-based material editor implementation
MaterialEditor.h — 576 LOC — Visual material and shader editor for the Spark Engine Editor

`SparkEditor/Source/Panels/`

AIDebugPanel.cpp — 324 LOC — Real-time AI debug visualization panel implementation
AIDebugPanel.h — 103 LOC — Real-time AI debug visualization panel for inspecting live agent state
AIEditorPanel.cpp — 209 LOC — Implementation of the AI system editor panel
AIEditorPanel.h — 63 LOC — AI system editor panel for the Spark Engine Editor
AbilityEditorPanel.cpp — 381 LOC — Implementation of the ability/aura/proc editor panel
AbilityEditorPanel.h — 98 LOC — Ability/aura/proc editor panel for the Spark Engine Editor
AssetAuditGraph.h — 490 LOC — Editor-facing asset audit graph (unused / circular / size budgeting)
AssetBrowserPanel.cpp — 756 LOC — Implementation of the Asset Browser panel
AssetBrowserPanel.h — 127 LOC — Asset browser panel for the Spark Engine Editor
AudioMixerPanel.cpp — 278 LOC — Implementation of the audio mixer management panel
AudioMixerPanel.h — 91 LOC — Audio mixer and sound management panel for the Spark Engine Editor
BasicMaterialEditorDrawing.cpp — 347 LOC — ImGui drawing for the basic-path material editor panel
BasicMaterialEditorInternal.h — 25 LOC — Shared helpers for the BasicMaterialEditorPanel implementation files
BasicMaterialEditorPanel.cpp — 493 LOC — Editor for the basic-path material JSONs under Assets/Materials
BasicMaterialEditorPanel.h — 117 LOC — Editor for the basic-path material JSONs under Assets/Materials
BuildCookPanel.cpp — 698 LOC — Build, cook, and package settings panel implementation
BuildCookPanel.h — 148 LOC — Build, cook, and package settings panel for the Spark Engine Editor
BuildPipeline.cpp — 1659 LOC — Async CMake subprocess management for build orchestration
BuildPipeline.h — 202 LOC — Async build orchestrator that invokes CMake as a subprocess
BuildPipelineProcess.cpp — 459 LOC — Subprocess execution and output parsing for the build pipeline
CSGEditorPanel.h — 294 LOC — Editor panel for constructive solid geometry (CSG) level design
CinematicSequencerPanel.cpp — 376 LOC — Implementation of the cinematic sequence editor panel
CinematicSequencerPanel.h — 82 LOC — Cinematic sequence editor panel for the Spark Engine Editor
CollaborationPanel.cpp — 328 LOC — Editor panel for collaborative editing session management
CollaborationPanel.h — 61 LOC — Editor panel for managing collaborative editing sessions
ConditionEditorPanel.cpp — 301 LOC — Implementation of the condition system editor panel
ConditionEditorPanel.h — 76 LOC — Condition system editor panel for the Spark Engine Editor
ConsolePanel.cpp — 829 LOC — Implementation of the advanced console panel with integrated logging
ConsolePanel.h — 316 LOC — Advanced console panel for Spark Engine Editor with integrated logging
CoroutineDebugPanel.cpp — 177 LOC — Implementation of the coroutine debug panel
CoroutineDebugPanel.h — 66 LOC — Coroutine scheduler debug and visualization panel
DebugVisualizerPanel.cpp — 252 LOC — Debug visualization overlay panel implementation
DebugVisualizerPanel.h — 120 LOC — Debug visualization overlay panel for the Spark Engine Editor
DecalEditorPanel.cpp — 209 LOC — Implementation of the decal material and surface mapping editor
DecalEditorPanel.h — 64 LOC — Decal material and surface mapping editor panel
DecorLayoutEditorCanvas.cpp — 488 LOC — Toolbar and 2D top-down canvas for the decor layout editor
DecorLayoutEditorIO.cpp — 468 LOC — Load/save/serialize for the decor layout editor (Assets/MMOFPS/Data/decor.json)
DecorLayoutEditorInternal.h — 54 LOC — Shared constants and helpers for the DecorLayoutEditorPanel implementation files
DecorLayoutEditorPanel.cpp — 291 LOC — Visual editor for Assets/MMOFPS/Data/decor.json (W12) — core lifecycle, validation, footprints
DecorLayoutEditorPanel.h — 196 LOC — Visual editor for the TERRAFRONT region decor templates (Assets/MMOFPS/Data/decor.json) — W12
DecorLayoutEditorSidePane.cpp — 344 LOC — Side pane (tier/piece editors, validation, save) for the decor layout editor
DedicatedServerPanel.cpp — 1087 LOC — Editor panel for dedicated server management, cooking, and PIE launching
DedicatedServerPanel.h — 227 LOC — Editor panel for dedicated server management, cooking, and PIE server spawning
DedicatedServerProcessController.cpp — 229 LOC
DedicatedServerProcessController.h — 84 LOC — Testable lifecycle adapter between the editor and SparkServer.
DestructionEditorPanel.cpp — 181 LOC — Implementation of the destruction system editor panel
DestructionEditorPanel.h — 63 LOC — Destruction system editor panel for fracture pattern authoring
DialogueEditorPanel.cpp — 179 LOC — Implementation of the dialogue tree editor panel
DialogueEditorPanel.h — 89 LOC — Dialogue tree editor panel for the Spark Engine Editor
EditorAutomation.h — 466 LOC — Editor automation, scripted tools, and batch operation framework
EventMonitorPanel.cpp — 200 LOC — Implementation of the event system monitor panel
EventMonitorPanel.h — 72 LOC — Event system monitor panel for the Spark Engine Editor
EventResponsePanel.cpp — 668 LOC — Implementation of the event response rule editor panel
EventResponsePanel.h — 92 LOC — Editor panel for creating and managing event response rules (no-code gameplay)
FPSToolsPanel.cpp — 655 LOC — FPS-specific development tools
FPSToolsPanel.h — 92 LOC — FPS-specific development tools panel
GameModuleSelectorPanel.cpp — 508 LOC — Safe module discovery, separate-process launch, and manifest generation
GameModuleSelectorPanel.h — 86 LOC — Panel for discovering game modules and launching the game as a separate process
GameViewPanel.cpp — 1441 LOC — Game viewport panel with full FPS HUD — shows player camera perspective
GameViewPanel.h — 239 LOC — Game viewport panel with full FPS HUD preview
HierarchyPanel.cpp — 1524 LOC — Implementation of the Hierarchy panel
HierarchyPanel.h — 425 LOC — Scene hierarchy panel for the Spark Engine Editor
InspectorComponentRenderers_2D.cpp — 93 LOC — Inspector renderers for 2D components with complex conditional UI
InspectorComponentRenderers_Core3D.cpp — 559 LOC — Inspector renderers for core 3D components: Transform, MeshRenderer, Light, Camera, RigidBody, Collider
InspectorComponentRenderers_Gameplay.cpp — 66 LOC — Inspector renderers for gameplay components with complex conditional UI
InspectorComponentRenderers_Reflected.cpp — 276 LOC — Inspector renderers using reflection-driven field rendering
InspectorComponentRenderers_Reflected2D.cpp — 238 LOC — Reflection-driven inspector renderers for 2D components
InspectorComponentRenderers_ReflectedConditional.cpp — 303 LOC — Reflection-driven inspector renderers using conditional field visibility
InspectorComponentRenderers_ReflectedGameplay.cpp — 261 LOC — Reflection-driven inspector renderers for gameplay components
InspectorComponentRenderers_ReflectedInternal.h — 141 LOC — Shared macros and FieldInfo builders for the reflection-driven inspector renderer split
InspectorComponentRenderers_ReflectedVolumes.cpp — 252 LOC — Reflection-driven inspector renderers for volume, probe, placement, and audio components
InspectorPanel.cpp — 1437 LOC — Implementation of the Inspector panel
InspectorPanel.h — 210 LOC — Inspector panel for property editing in the Spark Engine Editor
LocalizationPanel.cpp — 258 LOC — Implementation of the localization editor panel
LocalizationPanel.h — 60 LOC — Localization editor panel for the Spark Engine Editor
MaterialEditorPanel.cpp — 627 LOC — Visual material and shader property editor — core lifecycle and UI
MaterialEditorPanel.h — 270 LOC — Visual material and shader property editor
MaterialEditorParameters.cpp — 537 LOC — Parameter and texture editing for the material editor
MaterialEditorPreview.cpp — 787 LOC — Preview rendering, render state editing, and default material setup
ModdingPanel.cpp — 164 LOC — Implementation of the mod management panel
ModdingPanel.h — 55 LOC — Mod management and hot-reload panel
NetworkDebugPanel.h — 521 LOC — Editor panel for real-time network debugging and diagnostics
ObjectPlacementPanel.cpp — 428 LOC — Object placement and snapping tools panel implementation
ObjectPlacementPanel.h — 109 LOC — Object placement and snapping tools panel for level editing
ParticleEditorPanel.cpp — 345 LOC — Implementation of the particle system editor panel
ParticleEditorPanel.h — 101 LOC — Particle system editor panel for the Spark Engine Editor
Physics2DPanel.cpp — 312 LOC — Implementation of the 2D Physics panel
Physics2DPanel.h — 80 LOC — 2D Physics configuration and debug visualization panel
Physics3DPanel.cpp — 331 LOC — Implementation of the 3D Physics (Jolt) editor panel
Physics3DPanel.h — 111 LOC — 3D Physics (Jolt) configuration, debug visualization, and object placement panel
PlayControlLaunch.cpp — 409 LOC — Launch actions and instance bookkeeping for the play control panel.
PlayControlPanel.cpp — 245 LOC — Out-of-process play-testing controls implementation.
PlayControlPanel.h — 114 LOC — Out-of-process play-testing controls: launch/stop real SparkEngine.exe
PlayModeToolbarPanel.cpp — 654 LOC — Implementation of the play-in-editor toolbar with transport controls and simulation options
PlayModeToolbarPanel.h — 81 LOC — Dedicated play-in-editor toolbar with transport controls and simulation options
PostProcessingPanel.cpp — 168 LOC — Implementation of the post-processing settings panel
PostProcessingPanel.h — 43 LOC — Post-processing settings panel for the Spark Engine Editor
PrefabEditorPanel.cpp — 399 LOC — Implementation of the prefab editor panel
PrefabEditorPanel.h — 58 LOC — Panel for editing prefab templates
ProjectBrowserPanel.cpp — 510 LOC — Implementation of the project browser panel
ProjectBrowserPanel.h — 99 LOC — Project browser panel for creating and opening projects
ProjectSettingsPanel.cpp — 1501 LOC — Implementation of the project settings editor panel
ProjectSettingsPanel.h — 63 LOC — Project-wide settings editor panel for the Spark Engine Editor
PrototypingPanel.cpp — 204 LOC — Editor panel for rapid prototyping tools
PrototypingPanel.h — 48 LOC — Editor panel for rapid prototyping tools
RegionMapDataSource.cpp — 327 LOC — Safe Terrafront continent-to-region-map discovery for SparkEditor.
RegionMapDataSource.h — 39 LOC — Safe Terrafront continent-to-region-map discovery for SparkEditor.
RegionMapEditorCanvas.cpp — 377 LOC — 2D map canvas rendering and mouse interaction for RegionMapEditorPanel (W11)
RegionMapEditorIO.cpp — 480 LOC — Load / save / serialize for RegionMapEditorPanel continent region maps.
RegionMapEditorInternal.h — 77 LOC — Shared constants and helpers for the RegionMapEditorPanel implementation files
RegionMapEditorPanel.cpp — 365 LOC — Visual editor for Terrafront continent region maps — lifecycle, validation, layout
RegionMapEditorPanel.h — 162 LOC — Visual editor for Terrafront territory lattices registered by continents.json.
RegionMapEditorSidePane.cpp — 330 LOC — Side-pane editors (continent / region) and the validation + save UI for RegionMapEditorPanel (W11)
ReplayPanel.cpp — 174 LOC — Implementation of the replay system editor panel
ReplayPanel.h — 56 LOC — Replay system editor panel for recording and playback management
SaveSystemPanel.cpp — 211 LOC — Implementation of the save system management panel
SaveSystemPanel.h — 60 LOC — Save system management panel for the Spark Engine Editor
SceneImportPanel.cpp — 352 LOC — One-way import of game INI .scene files into the editor's live ECS World (W10)
SceneImportPanel.h — 142 LOC — One-way import of game INI .scene files into the editor's live ECS World (W10)
SceneImportPanelDrawing.cpp — 173 LOC — ImGui drawing for the one-way .scene import panel (W10)
SceneStatisticsPanel.cpp — 393 LOC — Implementation of the scene statistics panel
SceneStatisticsPanel.h — 125 LOC — Panel displaying real-time scene statistics and performance metrics
SceneViewPanel.cpp — 1069 LOC — Implementation of the Scene View panel
SceneViewPanel.h — 239 LOC — Scene view panel for 3D scene rendering in the Spark Engine Editor
ScriptDebugPanel.cpp — 365 LOC — Visual script debugger panel implementation
ScriptDebugPanel.h — 111 LOC — Visual script debugger panel with breakpoints, watch variables, and trace
ScriptEditorPanel.cpp — 182 LOC — Implementation of the AngelScript editor panel
ScriptEditorPanel.h — 64 LOC — AngelScript editor and hot-reload management panel
SearchPanel.cpp — 438 LOC — Implementation of the search panel
SearchPanel.h — 117 LOC — Search panel for finding entities, components, and assets
SelectionManager.h — 623 LOC — Centralized editor object selection and picking pipeline
ServiceTopologyController.cpp — 229 LOC
ServiceTopologyController.h — 86 LOC — Real local service process/control model.
ServiceTopologyPanel.cpp — 193 LOC
ServiceTopologyPanel.h — 36 LOC — Local daemon/collab/gateway topology controls.
SplineEditorPanel.cpp — 241 LOC — Implementation of the spline path editor panel
SplineEditorPanel.h — 65 LOC — Spline path editor panel for the Spark Engine Editor
SpriteAnimationEditorPanel.cpp — 537 LOC — Implementation of the Sprite Animation Editor panel
SpriteAnimationEditorPanel.h — 93 LOC — Sprite animation editor for creating and editing frame-based 2D animations
SpriteEditorPanel.cpp — 364 LOC — Implementation of the Sprite Editor panel
SpriteEditorPanel.h — 61 LOC — Sprite editor panel for 2D sprite configuration and preview
StreamingPanel.cpp — 300 LOC — Implementation of the area streaming management panel
StreamingPanel.h — 84 LOC — Area streaming and LOD management panel
TilemapEditorPanel.cpp — 541 LOC — Implementation of the Tilemap Editor panel
TilemapEditorPanel.h — 113 LOC — Tilemap editor panel for painting and editing tile-based maps
TimeOfDayPanel.cpp — 199 LOC — Implementation of the time-of-day editor panel
TimeOfDayPanel.h — 49 LOC — Time-of-day controls for the Spark Engine Editor
TriggerEditorPanel.cpp — 200 LOC — Implementation of the proximity trigger volume editor panel
TriggerEditorPanel.h — 64 LOC — Proximity trigger volume editor panel for the Spark Engine Editor
UIDesignerPanel.cpp — 319 LOC — WYSIWYG UI layout editor panel
UIDesignerPanel.h — 49 LOC — WYSIWYG UI layout editor panel
UndoHistoryPanel.cpp — 163 LOC — Implementation of the undo history panel
UndoHistoryPanel.h — 52 LOC — Panel displaying the undo/redo command history
VRConfigPanel.cpp — 131 LOC — Implementation of the VR configuration panel
VRConfigPanel.h — 51 LOC — VR device configuration and tracking panel
VisualScriptPanel.cpp — 1773 LOC — Implementation of the node-based visual scripting editor
VisualScriptPanel.h — 206 LOC — Node-based visual scripting editor panel
WeaponEditorPanel.cpp — 480 LOC — Weapon configuration and balancing editor
WeaponEditorPanel.h — 59 LOC — Weapon configuration and balancing editor panel
WeatherFogPanel.cpp — 185 LOC — Implementation of the weather and fog preset editor panel
WeatherFogPanel.h — 63 LOC — Weather and fog preset editor panel for the Spark Engine Editor
WorkflowPanel.cpp — 194 LOC — ImGui panel for browsing and running editor workflows
WorkflowPanel.h — 56 LOC — ImGui panel for browsing and running editor workflows

`SparkEditor/Source/Prefabs/`

PrefabAsset.cpp — 248 LOC — Implementation of the PrefabAsset class
PrefabAsset.h — 176 LOC — Prefab asset data structure for reusable entity templates
PrefabManager.cpp — 429 LOC — Implementation of the PrefabManager
PrefabManager.h — 186 LOC — Manages prefab assets — creation, instantiation, saving, and loading

`SparkEditor/Source/Profiler/`

PerformanceProfiler.cpp — 1609 LOC — Implementation of the Performance Profiler panel
PerformanceProfiler.h — 462 LOC — Performance profiling and optimization system for Spark Engine Editor
ProfilerTypes.h — 312 LOC — Type definitions, enums, and structs for the performance profiling system

`SparkEditor/Source/Prototyping/`

PrototypingSystem.cpp — 223 LOC — Rapid prototyping tools implementation
PrototypingSystem.h — 149 LOC — Rapid prototyping tools: blockout meshes, game templates, gameplay rules

`SparkEditor/Source/SceneSystem/`

BinarySceneSerializer.cpp — 136 LOC — Binary serialization and deserialization for scene files
JSONSceneSerializer.cpp — 2010 LOC — JSON serialization and deserialization for scene files
SceneComponentCodec.cpp — 826 LOC — Built-in scene component schema registry.
SceneComponentCodec.h — 127 LOC — Portable, schema-versioned persistence boundary for editor components.
SceneFile.cpp — 319 LOC — Implementation of SceneFile data structures and methods
SceneFile.h — 79 LOC — Scene file format definition and data structures
SceneFileTypes.h — 1140 LOC — Scene file type definitions, enums, and data structures
SceneManager.cpp — 172 LOC — Implementation of the scene management system
SceneManager.h — 70 LOC — Scene management system for the Spark Engine Editor
SceneSerializer.cpp — 234 LOC — Scene serialization coordinator and format utilities
SceneSerializer.h — 332 LOC — Scene file serialization and deserialization system

`SparkEditor/Source/Search/`

CommandPalette.cpp — 383 LOC — Implementation of the command palette overlay
CommandPalette.h — 122 LOC — Command palette overlay for quick action execution

`SparkEditor/Source/Terrain/`

TerrainData.cpp — 231 LOC — Implementation of terrain data structures (brush, heightmap, splatmap)
TerrainData.h — 178 LOC — Data structures for the terrain editing system
TerrainEditor.cpp — 515 LOC — Core terrain editor: lifecycle, load/save, undo/redo, mesh/collision rebuild
TerrainEditor.h — 157 LOC — Terrain editing panel for the Spark Engine Editor
TerrainEditorTools.cpp — 442 LOC — Tool application, coordinate conversion, noise, and erosion for the terrain editor
TerrainEditorUI.cpp — 430 LOC — ImGui UI rendering for the terrain editor panel

`SparkEditor/Source/UIDesigner/`

UIDesignerSystem.cpp — 420 LOC — WYSIWYG UI layout editor implementation
UIDesignerSystem.h — 167 LOC — WYSIWYG UI layout editor with widget tree and data binding

`SparkEditor/Source/UndoRedo/`

EditorCommand.h — 161 LOC — Command pattern base class and concrete commands for the undo/redo system
EditorCommands.h — 252 LOC — Additional concrete editor commands for hierarchy and material operations
UndoRedoManager.cpp — 273 LOC — Implementation of the undo/redo command history manager
UndoRedoManager.h — 201 LOC — Manages the undo/redo command history stack

`SparkEditor/Source/Utils/`

EditorConsoleBridge.cpp — 140 LOC — Implementation of EditorConsoleBridge (R7.3 — console consolidation)
EditorConsoleBridge.h — 125 LOC — Bridge that connects the editor's SimpleConsole to the engine's authoritative console (R7.3)
EditorLaunchContext.h — 259 LOC — Side-effect-free path policy for editor module discovery and play launches.
EditorProcessLaunch.cpp — 240 LOC — Process ownership, executable discovery, and command-line construction.
EditorProcessLaunch.h — 186 LOC — Shared CreateProcessW helper for editor panels that spawn a separate
EditorProcessLaunchPosix.cpp — 323 LOC — POSIX editor child-process backend.
EditorProcessLaunchPosixInternal.h — 174 LOC — Internal process-handle, UTF-8, parsing, and wait helpers for the POSIX backend.
EditorProcessLaunchText.h — 130 LOC — Shared Unicode and platform command-line quoting helpers.
EditorProcessLaunchWin32.cpp — 202 LOC — Windows editor child-process backend.
FolderDialog.cpp — 123 LOC — Cross-platform native folder-picker dialog implementation.
FolderDialog.h — 20 LOC — Cross-platform native folder-picker dialog.
ImGuiUtils.h — 26 LOC — Utility helpers for Dear ImGui rendering in the SparkEditor

`SparkEditor/Source/VersionControl/`

VersionControlConflicts.cpp — 254 LOC — Locking, conflict resolution, user settings, file status queries, and ignore patterns
VersionControlGitOps.cpp — 323 LOC — Git operations: staging, committing, pushing, pulling, branching, history, and diffs
VersionControlHelpers.cpp — 348 LOC — Parsing and utility helpers for VersionControlSystem
VersionControlRender.cpp — 589 LOC — UI rendering methods, operation queue processing, and command execution
VersionControlSystem.cpp — 460 LOC — Core VersionControlSystem lifecycle, merge handler implementations, and repository operations
VersionControlSystem.h — 511 LOC — Version control integration system for collaborative development in Spark Engine
VersionControlTypes.h — 289 LOC — Type definitions, structs, and base classes for the version control system

`SparkEditor/Source/Workflow/`

BuiltinWorkflows.cpp — 310 LOC — Implementations of pre-built editor workflow templates
BuiltinWorkflows.h — 17 LOC — Pre-built editor workflow templates
EditorWorkflow.cpp — 122 LOC — Workflow execution and registry implementation
EditorWorkflow.h — 133 LOC — Lightweight editor workflow automation system

`SparkEditor/Source/`

main.cpp — 533 LOC — SparkEditor entry point with integrated debug and collab server support

`SparkEngine/Source/Audio/`

AudioBackendFactory.cpp — 71 LOC — Platform-aware factory for audio backend selection
AudioBackendFactory.h — 60 LOC — Factory for creating the best available IAudioBackend at startup
AudioEngine.cpp — 975 LOC
AudioEngine.h — 589 LOC — XAudio2-based audio engine with comprehensive console integration
AudioMixer.cpp — 329 LOC — Implementation of the audio mixer, reverb zones, and occlusion
AudioMixer.h — 337 LOC — Audio mixer with mix buses, reverb zones, and occlusion
HRTFProcessor.cpp — 237 LOC — Analytical binaural HRTF renderer
HRTFProcessor.h — 167 LOC — Lightweight binaural HRTF approximation (ITD + ILD + head shadow)
IAudioBackend.h — 198 LOC — Abstract audio backend interface for cross-platform audio support
MusicManager.cpp — 542 LOC — Music system implementation — crossfading, playlists, dynamic music, reverb
MusicManager.h — 306 LOC — Music playback system with crossfading, playlists, and dynamic intensity
NullAudioBackend.h — 117 LOC — No-op audio backend for headless and unsupported platforms
OpenALAudioBackend.cpp — 164 LOC — IAudioBackend adapter delegating to the OpenAL Soft engine
OpenALAudioBackend.h — 79 LOC — IAudioBackend adapter wrapping OpenALAudioEngine for Linux/macOS
OpenALAudioEngine.cpp — 736 LOC — OpenAL Soft audio backend implementation for Linux/macOS
OpenALAudioEngine.h — 208 LOC — OpenAL Soft audio backend for Linux/macOS cross-platform audio
SoundEffect.cpp — 394 LOC
SoundEffect.h — 330 LOC — Sound effect loading and procedural audio generation system
XAudio2AudioBackend.cpp — 171 LOC — IAudioBackend adapter delegating to the XAudio2 AudioEngine
XAudio2AudioBackend.h — 80 LOC — IAudioBackend adapter wrapping the existing XAudio2-based AudioEngine

`SparkEngine/Source/Camera/`

SparkEngineCamera.cpp — 256 LOC — Core camera movement, rotation, and matrix update implementation
SparkEngineCamera.h — 408 LOC — First-person camera system with smooth movement and console integration
SparkEngineCameraConsoleOps.cpp — 254 LOC — Console integration methods for SparkEngineCamera
SparkEngineCameraInternal.h — 81 LOC — Shared console-logging helpers for the SparkEngineCamera implementation files

`SparkEngine/Source/Core/`

AssetHandle.h — 86 LOC — Lightweight hashed asset identifier for zero-allocation asset references
AssetIntegration.h — 263 LOC — Cross-links AssetHandle with the engine's resource systems
AssetMigration.h — 476 LOC — Versioned asset format migration system
AssetValidator.cpp — 441 LOC
AssetValidator.h — 119 LOC — Asset validation pipeline for content integrity checking
ComponentReflection.cpp — 1096 LOC — Runtime reflection registration for all ECS components
Contracts.h — 69 LOC — C++26 contract bridge macros (preconditions, postconditions, invariants)
DynamicPluginHost.cpp — 1453 LOC — Cross-platform implementation of Spark's stable C plugin ABI host.
DynamicPluginHost.h — 97 LOC — Production loader and lifecycle owner for the stable Spark plugin C ABI.
EngineBootstrap.cpp — 403 LOC — Dependency-ordered subsystem initialization and shutdown implementation
EngineBootstrap.h — 210 LOC — Dependency-ordered subsystem initialization and shutdown
EngineConsoleCommands.cpp — 974 LOC — Engine-wide console command registration
EngineConsoleCommands.h — 28 LOC — Registers engine-wide console commands (modules, physics, audio, save, architecture)
EngineContext.cpp — 244 LOC — Concrete IEngineContext implementation
EngineContext.h — 497 LOC — Concrete implementation of IEngineContext for the engine runtime
EngineDiagnostics.cpp — 1079 LOC — Runtime diagnostic commands that exercise live engine subsystems
EngineDiagnostics.h — 94 LOC — Runtime diagnostic commands that exercise live engine subsystems
EngineDiagnosticsExtended.cpp — 552 LOC — Extended runtime diagnostics for RHI, JobSystem, AI, debug tools,
EngineRuntime.cpp — 51 LOC — Storage for the process-wide EngineRuntime instance.
EngineRuntime.h — 89 LOC — Private container for engine-owned subsystem instances.
EngineSettings.cpp — 1623 LOC — Implementation of centralized engine settings
EngineSettings.h — 1080 LOC — Centralized engine settings loaded from INI configuration
EngineSetup.h — 281 LOC — Wires architecture components into the engine lifecycle
FaultIsolation.cpp — 391 LOC — Runtime fault isolation for engine subsystem updates
FaultIsolation.h — 143 LOC — Runtime fault isolation for engine subsystem updates
FileIntegrity.cpp — 176 LOC — Self-contained streaming SHA-256 used before native image mapping.
FileIntegrity.h — 15 LOC — Bounded-memory integrity helpers for native modules and plugins.
FixedTimestepAccumulator.cpp — 127 LOC — Implementation of the fixed-timestep accumulator
FixedTimestepAccumulator.h — 88 LOC — Centralized fixed-timestep accumulator for the main loop
GameImGuiLayer.cpp — 194 LOC — Game-mode ImGui overlay implementation (exe-only, Windows + DX11).
GameImGuiLayer.h — 75 LOC — Game-mode (non-editor) ImGui overlay for the SparkEngine executable.
GameModuleLoader.cpp — 151 LOC — Platform-specific implementation of dynamic game module loading
GameModuleLoader.h — 68 LOC — Loads game modules (DLLs/shared libraries) at runtime
GamePackager.cpp — 408 LOC
GamePackager.h — 91 LOC — Game packaging pipeline for distribution builds
GameplaySystemLifecycle.cpp — 200 LOC
GameplaySystemLifecycle.h — 64 LOC — Initialization, update, and shutdown for all gameplay and debug subsystems
IGameModule.h — 92 LOC — Abstract interface that game DLLs must implement

`SparkEngine/Source/Core/Lifecycle/`

GameplayLifecycleShared.cpp — 1391 LOC — Initialization, update, and shutdown for all gameplay and debug subsystems
GameplayLifecycleShared.h — 36 LOC — Shared lifecycle functions for gameplay and debug subsystem management
InitDebugStage.cpp — 21 LOC
InitGameplayStage.cpp — 21 LOC
InitNetworkingStage.cpp — 21 LOC
LifecycleStage.h — 46 LOC — Abstract base class for engine lifecycle stages (init, update, shutdown)
LifecycleStages.h — 19 LOC — Factory functions for concrete lifecycle stage instances
ShutdownStage.cpp — 25 LOC
UpdateStage.cpp — 25 LOC

`SparkEngine/Source/Core/`

ModuleHotReload.cpp — 308 LOC — DLL/SO hot-reload file watcher implementation
ModuleHotReload.h — 148 LOC — Watches module DLLs for changes and triggers automatic hot-reload
ModuleManager.cpp — 1741 LOC — Multi-module loader and lifecycle manager implementation
ModuleManager.h — 272 LOC — Multi-module loader and lifecycle manager
ModuleRuntimeInjection.cpp — 21 LOC — Private implementation of the public module runtime injection bridge.
NonNull.h — 73 LOC — Lightweight non-null pointer wrapper with debug-mode enforcement
Platform.h — 269 LOC — Cross-platform type definitions and compatibility layer
PlatformAudioStubs.h — 375 LOC — XAudio2, XInput, and related stubs for non-Windows platforms
PlatformD3DStubs.h — 221 LOC — D3D11/DXGI type stubs and ComPtr for non-Windows platforms
PlatformDirectXMathStubs.h — 771 LOC — DirectXMath compatibility stubs for non-Windows platforms
PlatformTypes.h — 440 LOC — Win32 type aliases and macros for non-Windows platforms
PluginRegistry.cpp — 116 LOC — Implementation of the static plugin registry
PluginRegistry.h — 82 LOC — Macro-based plugin registration using a static linked list
Reflection.h — 580 LOC — Lightweight compile-time type reflection system (ezEngine-inspired)
ReflectionSerializer.h — 234 LOC — Generic reflection-driven serialization utilities
ResourceVersionTracker.cpp — 88 LOC — Implementation of the resource version tracker
ResourceVersionTracker.h — 72 LOC — Tracks version numbers for loaded resources to detect staleness
RuntimePackage.cpp — 81 LOC — Cross-platform executable discovery and packaged-runtime anchoring.
RuntimePackage.h — 32 LOC — Packaged-runtime root discovery shared by every platform entry point.
SafeCast.h — 99 LOC — Type-safe cast utilities with debug-mode validation
SparkEngine.cpp — 527 LOC — SparkEngine executable entry point - loads game modules dynamically
SparkEngine.h — 41 LOC — Main engine header - SparkEngine is the executable runtime host
SparkEngineLinux.cpp — 243 LOC — POSIX entry point (main), signal handling, and command-line parsing (Linux + macOS).
SparkEngineLinuxHeadless.cpp — 246 LOC — Headless/dedicated-server loop and no-SDL2 fallback path (Linux + macOS).
SparkEngineLinuxInit.cpp — 374 LOC — Shared POSIX startup, per-frame tick, and shutdown helpers (Linux + macOS).
SparkEngineLinuxInternal.h — 69 LOC — Internal declarations shared by the POSIX (Linux + macOS) entry-point files.
SparkEngineLinuxSDL2.cpp — 464 LOC — SDL2 windowed-mode bring-up: window/backend selection and RunSDL2Windowed (Linux + macOS).
SparkEngineLinuxSDL2Events.cpp — 232 LOC — SDL2 event translation, dispatch, and per-frame main loop (Linux + macOS).
SparkEngineMacOS.cpp — 136 LOC — macOS-specific engine entry-point helpers (Metal view lifecycle, exe path).
SparkEngineMacOS.h — 54 LOC — macOS-specific engine entry-point helpers (Metal view, exe path).
SparkEngineWindows.cpp — 558 LOC — Windows entry point (wWinMain), command-line parsing, and -exec script playback
SparkEngineWindowsHeadless.cpp — 389 LOC — Headless/dedicated-server loop (Windows).
SparkEngineWindowsInit.cpp — 308 LOC — Windowed-mode subsystem initialization (Windows).
SparkEngineWindowsInternal.h — 108 LOC — Internal declarations shared by the Windows entry-point files.
SparkEngineWindowsModules.cpp — 244 LOC — Game-module discovery, -game/manifest loading, and the bare-launch project selector (Windows).
SparkEngineWindowsWin32.cpp — 474 LOC — Win32 message pump, window creation, and window procedure (Windows).
SparkExport.h — 38 LOC — DLL export/import macros for the Spark Engine module system
SparkPak.cpp — 363 LOC — SparkPakReader implementation — opens .spk archives and reads entries
SparkPak.h — 170 LOC — MPQ-inspired binary archive format for asset packaging
SparkPakWriter.cpp — 317 LOC — SparkPakWriter implementation — builds .spk archive files
SparkPakWriter.h — 68 LOC — Builder for SparkPak (.spk) archive files
StartupSplash.cpp — 800 LOC — Deterministic CPU startup animation with Win32 and SDL2 presenters.
StartupSplash.h — 85 LOC — Codec-free, cross-platform startup splash configuration and renderer.
SubsystemConsoleCommands.cpp — 692 LOC — Console commands for camera, network, AI, animation, weather, and post-processing
SubsystemConsoleCommands.h — 24 LOC — Console commands for subsystems: camera, network, AI, animation, weather,
SubsystemConsoleCommandsExt.cpp — 767 LOC — Console commands for input, scripting, cinematic, replay, localization,
WindowsCommandLine.h — 117 LOC — Win32 command-line token helpers shared by engine startup surfaces.
framework.h — 51 LOC — Core framework header with essential includes and library links
resource.h — 41 LOC — Windows resource definitions and identifiers
targetver.h — 26 LOC — Platform version targeting

`SparkEngine/Source/Engine/2D/`

Physics2D.h — 436 LOC — 2D physics simulation with AABB/circle collision detection and resolution
Physics2DTypes.h — 254 LOC — Type definitions, structs, and collision functions for 2D physics
SceneGraph2D.h — 325 LOC — Retained 2D scene graph with granular update flags

`SparkEngine/Source/Engine/AI/`

AIBudgetLimiter.cpp — 279 LOC — Implementation of the AI frame-budget limiter
AIBudgetLimiter.h — 53 LOC — Frame-budget limiter for AI processing (R4.3)
AIBudgetLimiterCore.h — 217 LOC — AIBudgetLimiter class — per-frame AI time-budget enforcement (R4.3)
AIBudgetTypes.h — 82 LOC — Shared data types for the AI budget limiter (R4.3)
AIDebugRenderer.cpp — 315 LOC — AI debug visualization using DebugDraw primitives
AIDebugRenderer.h — 239 LOC — Debug visualization for AI systems: NavMesh, paths, perception, behavior trees
AIDirector.cpp — 262 LOC — Implementation of the AI Director dynamic difficulty system
AIDirector.h — 220 LOC — Dynamic difficulty and pacing system (inspired by Left 4 Dead's AI Director)
AIIntegration.h — 293 LOC — Cross-links all AI architecture extensions with AISystem
AISystem.cpp — 931 LOC — AI system implementation — processes all AI agents each frame
AISystem.h — 417 LOC — ECS system for AI agent processing and coordination
BehaviorTree.h — 318 LOC — Behavior tree framework for NPC AI decision-making
BehaviorTreeNodes.h — 417 LOC — Concrete behavior tree node implementations
BehaviorTreeTypes.h — 260 LOC — Core types for the behavior tree framework: NodeStatus, Blackboard, and BTNode base class
CollisionAvoidance.cpp — 223 LOC — Implementation of the simplified ORCA collision avoidance system
CollisionAvoidance.h — 173 LOC — ORCA collision avoidance for AI crowds
CoverSystem.cpp — 334 LOC — Cover analysis and querying implementation
CoverSystem.h — 189 LOC — Cover analysis and querying for AI agents
EnvironmentQuery.h — 582 LOC — Environment Query System (EQS) for tactical AI positioning
FormationSystem.cpp — 271 LOC — Formation management system implementation
FormationSystem.h — 206 LOC — Formation management for AI groups
GroupAI.cpp — 306 LOC — Group/squad AI coordination system implementation
GroupAI.h — 240 LOC — Group/squad AI coordination system
MovementSystem.cpp — 871 LOC — Implementation of the priority-based movement generator stack
MovementSystem.h — 419 LOC — Priority-based movement generator stack (TC MotionMaster-inspired)
NavMesh.cpp — 1108 LOC — NavMesh implementation — query, builder, and manager
NavMesh.h — 468 LOC — Navigation mesh system for AI pathfinding
NavMeshLink.h — 134 LOC — Off-mesh navigation links for jumps, ladders, and teleporters
NavMeshObstacles.cpp — 435 LOC — Implementation of dynamic NavMesh obstacle carving
NavMeshObstacles.h — 396 LOC — Dynamic obstacle management for runtime NavMesh carving
NavMeshTypes.h — 388 LOC — Data types, enums, and structures for the NavMesh subsystem.
ParallelPerception.cpp — 337 LOC — Implementation of the parallelized, Octree-accelerated perception system
ParallelPerception.h — 255 LOC — Parallelized perception system using JobSystem and Octree spatial partitioning
PerceptionSystem.h — 478 LOC — AI perception system for sight, hearing, and memory
RecastDetourBackend.cpp — 343 LOC — Recast/Detour NavMesh generation implementation
RecastDetourBackend.h — 48 LOC — Recast/Detour-powered NavMesh generation backend
SteeringBehaviors.h — 484 LOC — Steering behavior utilities for AI agent locomotion
TacticalPointSystem.cpp — 280 LOC — Tactical point evaluation implementation
TacticalPointSystem.h — 219 LOC — Tactical point evaluation for AI combat positioning

`SparkEngine/Source/Engine/Accessibility/`

AccessibilitySystem.h — 329 LOC — Engine-wide accessibility framework with colorblind filters, subtitles, and adaptive UI

`SparkEngine/Source/Engine/Animation/`

AnimNotify.h — 296 LOC — Animation notify system for firing gameplay events from animation keyframes
AnimationBlender.h — 110 LOC — Animation blending modes, layers, and blend result structures
AnimationClip.h — 196 LOC — Keyframe data structures and animation clip definitions
AnimationCompression.cpp — 731 LOC — Implementation of animation keyframe compression and quantization
AnimationCompression.h — 138 LOC — Animation keyframe compression via redundant key removal and quantization
AnimationEvaluator.h — 122 LOC — Core animation processing: sampling, blending, skinning, and IK solving
AnimationRetargeting.h — 307 LOC — Skeleton retargeting for sharing animations between different characters
AnimationStateMachine.cpp — 193 LOC — AnimationStateMachine implementation — state transitions, crossfade blending, state management
AnimationSystem.cpp — 688 LOC — AnimationManager (asset cache) and AnimationInstance (per-entity runtime update)
AnimationSystem.h — 543 LOC — Skeletal animation system with bone hierarchies, skinning, blending, and state machines
AnimationTypes.h — 563 LOC — Core animation data types: bones, skeletons, keyframes, clips, blending, IK, and instances
BlendSpace.cpp — 444 LOC — Implementation of 2D parametric blend space with Delaunay triangulation
BlendSpace.h — 237 LOC — Parametric 2D blend space for animation blending
IKSolver.h — 101 LOC — Inverse Kinematics types and chain definitions
InverseKinematics.cpp — 347 LOC — IK solver implementations — TwoBoneIK, LookAtIK (FABRIK lives in InverseKinematicsFABRIK.cpp)
InverseKinematicsFABRIK.cpp — 175 LOC — IK solver implementation — FABRIK
PoseModifier.cpp — 362 LOC — Post-animation pose modification pipeline implementation
PoseModifier.h — 243 LOC — Post-animation pose modification pipeline
RagdollSystem.cpp — 275 LOC — Implementation of the ragdoll physics system
RagdollSystem.h — 269 LOC — Ragdoll physics with animation blending and hit reactions
SkeletalAnimation.cpp — 233 LOC — Low-level skeletal animation evaluation — keyframe interpolation, clip sampling,
Skeleton.h — 127 LOC — Bone and Skeleton structures for skeletal animation hierarchies

`SparkEngine/Source/Engine/Build/`

GamePackager.h — 456 LOC — Standalone game packaging system for distributable builds

`SparkEngine/Source/Engine/Cinematic/`

Sequencer.cpp — 891 LOC — Implementation of the cinematic sequencer system
Sequencer.h — 389 LOC — Timeline-based cinematic sequencer for cutscenes and scripted events
VideoPlayer.h — 372 LOC — Video playback system for cutscenes, splash screens, and in-world displays

`SparkEngine/Source/Engine/Coroutine/`

CancellationToken.h — 69 LOC — Cancellation token for coroutines tied to entity lifetime
CoroutineScheduler.h — 236 LOC — Gameplay coroutine system -- delayed, yielding, and repeating tasks
CoroutineTypes.h — 495 LOC — Type definitions for the coroutine system -- yield instructions, promise types, and builder coroutine

`SparkEngine/Source/Engine/Crafting/`

LootAndCraftingSystem.h — 492 LOC — Engine-level loot tables with weighted random drops and a crafting system

`SparkEngine/Source/Engine/DataTable/`

DataTableSystem.h — 800 LOC — Data-driven table system for loading and querying structured game data.

`SparkEngine/Source/Engine/Destruction/`

DestructionSystem.cpp — 259 LOC — Implementation of the destructible environment system
DestructionSystem.h — 286 LOC — Destructible environment system for FPS gameplay

`SparkEngine/Source/Engine/Dialogue/`

DialogueSystem.cpp — 578 LOC — Implementation of the dialogue tree and conversation system
DialogueSystem.h — 332 LOC — Dialogue tree and conversation system for NPCs
DynamicResponseSystem.cpp — 288 LOC — Dynamic response system implementation
DynamicResponseSystem.h — 227 LOC — Signal/condition-driven dynamic response system

`SparkEngine/Source/Engine/ECS/`

Components.h — 257 LOC — ECS components and World class for Spark Engine (umbrella header)

`SparkEngine/Source/Engine/ECS/Components/`

AIComponents.h — 94 LOC — ECS AI component: AIComponent with behavior tree and pathfinding
AdvancedPlacementComponents.h — 459 LOC — ECS components for advanced editor-placeable objects
AnimationComponents.h — 77 LOC — ECS animation components: AnimationController, ParticleEmitterComponent
AudioComponents.h — 55 LOC — ECS audio component: AudioSourceComponent
CollisionMaskComponents.h — 71 LOC — Lightweight game-logic collision masks separate from Bullet physics
CoreComponents.cpp — 69 LOC
CoreComponents.h — 150 LOC — Core ECS components: Transform, MeshRenderer, Camera, Script
FPSComponents.h — 285 LOC — ECS components for FPS gameplay: Decals, Projectiles, Interactions
GameplayComponents.h — 214 LOC — ECS gameplay components: Tags, Health, Active, Weather, Inventory, Quests
LightComponents.h — 61 LOC — ECS lighting component: LightComponent
NetworkComponents.h — 30 LOC — ECS networking components: NetworkIdentity
PhysicsComponents.h — 146 LOC — ECS physics components: RigidBodyComponent, ColliderComponent
PlacementComponents.h — 337 LOC — ECS components for editor-placeable gameplay objects
SplineComponents.h — 75 LOC — ECS components for spline paths and path following
Sprite2DComponents.h — 507 LOC — ECS components for 2D/2.5D rendering: sprites, tilemaps, parallax, Camera2D
TerrainComponents.h — 57 LOC — ECS components for terrain entities
VisibilityComponents.h — 64 LOC — Per-entity visibility bitmask and camera draw mask components
VolumeComponents.h — 333 LOC — ECS components for spatial volumes, probes, and placeable markers

`SparkEngine/Source/Engine/ECS/`

ECSIntegration.h — 173 LOC — Aggregates and cross-links all ECS architecture extensions
EntityArchetype.cpp — 99 LOC — Entity archetype system implementation
EntityArchetype.h — 179 LOC — Entity archetype/template system
EntityArchetypeLoader.cpp — 408 LOC — Data-driven archetype loading and entity spawning
EntityArchetypeLoader.h — 80 LOC — Data-driven archetype loading from .archetype files and spawn API
EntityPresetManager.cpp — 238 LOC — Implementation of entity preset registry with built-in game object templates
EntityPresetManager.h — 107 LOC — Pre-configured entity templates for rapid no-code game creation
ReactiveSystem.h — 224 LOC — EnTT-based reactive ECS system using observers (R2.4 — Architecture Analysis)
RuntimePrefab.h — 476 LOC — Runtime prefab system for data-driven entity templates with serialization

`SparkEngine/Source/Engine/ECS/Systems/`

ECSystemTypes.h — 121 LOC — Base types and interfaces shared by all ECS systems.
ECSystems.cpp — 739 LOC — ECS system implementations — the runtime logic that processes components each frame.
ECSystems.h — 846 LOC — ECS system definitions that process component data each frame
FixedTimestepPhysics.h — 138 LOC — Fixed-timestep physics system with accumulator pattern (R2.2 — Architecture Analysis)
ParallelSystemExecutor.h — 335 LOC — Parallel ECS system execution via the JobSystem (R2.1 — Architecture Analysis)
PhaseSystemManager.h — 234 LOC — Phase-based ECS system execution (R2.3 — Architecture Analysis)
Systems2D.h — 512 LOC — ECS systems for 2D/2.5D: sprite rendering, 2D physics, animation, parallax, tilemap
TerrainSystem.cpp — 89 LOC — Implementation of the TerrainSystem ECS system
TerrainSystem.h — 42 LOC — ECS system that processes TerrainComponent entities each frame

`SparkEngine/Source/Engine/Editor/`

CoreComponentSerializers.cpp — 355 LOC — Snapshot serializers for core scene ECS component types
CoreComponentSerializers.h — 23 LOC — Registers snapshot serializers for all core ECS components
CoreComponentSerializersInternal.h — 82 LOC — Shared internal helpers for the core component snapshot serializer translation units
CoreComponentSerializersPhysicsAudio.cpp — 209 LOC — Snapshot serializers for the physics and audio core ECS component types
PlayModeManager.h — 587 LOC — Play-in-editor mode management: scene snapshot, restore, time control
PlayModeTypes.h — 200 LOC — Type definitions for play-in-editor mode: enums, structs, callbacks
SceneSnapshotSerializer.h — 281 LOC — Binary ECS state serializer for play-in-editor snapshot save/restore

`SparkEngine/Source/Engine/Events/`

EventSystem.h — 473 LOC — Built-in event types and deferred event queue for engine communication

`SparkEngine/Source/Engine/Gameplay/`

AbilityAuras.cpp — 290 LOC — Aura management, tick processing, and proc system for AbilitySystem
AbilitySystem.cpp — 701 LOC — Implementation of the pipeline-based ability/spell system
AbilitySystem.h — 345 LOC — Pipeline-based ability/spell system with auras and procs (TrinityCore-inspired)
AchievementSystem.h — 498 LOC — Achievement tracking with progressive, tiered, and cumulative support
ConditionSystem.cpp — 558 LOC — Implementation of the universal condition evaluation system
ConditionSystem.h — 169 LOC — Universal data-driven condition evaluation (TC ConditionMgr-inspired)
EventResponseSystem.cpp — 868 LOC — Implementation of the data-driven event response rule engine
EventResponseSystem.h — 278 LOC — Data-driven "When/If/Then" event response rule engine for no-code gameplay
GameplaySystemExtension.h — 260 LOC — Extension point system for game modules to extend engine quest/dialogue
GameplayTags.h — 386 LOC — Hierarchical gameplay tag system for data-driven categorization and queries
InstanceEncounters.cpp — 223 LOC — Encounter control and lockout management for InstanceManager
InstanceManager.cpp — 317 LOC — Instance/dungeon management and encounter scripting implementation
InstanceManager.h — 237 LOC — Instance/dungeon management with encounter scripting (TC-inspired)
InventorySystem.cpp — 384 LOC — Implementation of the per-entity inventory management system
InventorySystem.h — 169 LOC — Reusable per-entity inventory management with item registry and stacking
MaterialEffects.cpp — 99 LOC — Material interaction effect system implementation
MaterialEffects.h — 159 LOC — Material interaction effect system
QuestSystem.cpp — 464 LOC — Implementation of the per-entity quest tracking system
QuestSystem.h — 244 LOC — Per-entity quest tracking with objectives, prerequisites, and rewards
WeaponManager.cpp — 483 LOC — Weapon system implementation - fire control, reload, recoil, ADS
WeaponManager.h — 308 LOC — Central weapon management system for FPS gameplay
WeatherGameplayIntegration.cpp — 199 LOC — Bridges weather events to physics wind, AI perception, and audio state
WeatherGameplayIntegration.h — 116 LOC — Bridges weather system events to gameplay mechanics (physics, AI, audio)

`SparkEngine/Source/Engine/HLOD/`

HLODSystem.h — 473 LOC — Hierarchical LOD and World Partition system

`SparkEngine/Source/Engine/HotReload/`

ModuleHotReload.h — 386 LOC — Runtime hot-reload system for game module DLLs

`SparkEngine/Source/Engine/LevelDesign/`

CSGSystem.h — 727 LOC — Constructive Solid Geometry (CSG) system for level greyboxing

`SparkEngine/Source/Engine/Loading/`

LoadingScreen.cpp — 195 LOC — Implementation of the loading screen and progress tracking system
LoadingScreen.h — 191 LOC — Async asset loading with progress tracking and loading screen support

`SparkEngine/Source/Engine/Localization/`

LocalizationSystem.cpp — 308 LOC — Implementation of the localization and string table system
LocalizationSystem.h — 207 LOC — Internationalization and localization system for Spark Engine

`SparkEngine/Source/Engine/Mobile/`

MobilePlatform.cpp — 203 LOC — Implementation of the mobile platform abstraction
MobilePlatform.h — 249 LOC — Mobile platform abstraction for touch input and GPU optimization

`SparkEngine/Source/Engine/Modding/`

ArchiveResourceProvider.cpp — 71 LOC — IResourceProvider implementation backed by SparkPak (.spk) archives
ArchiveResourceProvider.h — 60 LOC — IResourceProvider backed by a SparkPak (.spk) archive
ModSystem.cpp — 343 LOC — Implementation of the mod loading and management system
ModSystem.h — 199 LOC — Plugin and modding SDK for user-created content
ModSystemIO.cpp — 180 LOC — Mod system persistence and console output — config save/load, mod.json parsing, console status
VirtualFileSystem.cpp — 333 LOC — Implementation of the mount-priority virtual filesystem
VirtualFileSystem.h — 191 LOC — Mount-priority virtual filesystem for layered content loading

`SparkEngine/Source/Engine/Networking/`

AreaServer.cpp — 603 LOC — Area-based server process implementation
AreaServer.h — 279 LOC — Area-based server process for scalable multiplayer worlds
AreaServerTypes.h — 93 LOC — Configuration, migration, and statistics types for AreaServer
ClientPrediction.cpp — 170 LOC — Implementation of client-side prediction and server reconciliation
ClientPrediction.h — 198 LOC — Client-side prediction and server reconciliation for multiplayer FPS
ConnectionScope.h — 260 LOC — Per-connection object scoping for entity replication (Torque3D ghost-inspired)
ConnectionScopeFilter.h — 212 LOC — Per-connection entity visibility filtering for network replication
DatablockRegistry.h — 408 LOC — Immutable shared-data objects sent once at connection time (Torque3D-inspired)
DedicatedServer.cpp — 1021 LOC — Dedicated game server implementation
DedicatedServer.h — 391 LOC — Dedicated game server with full lifecycle management
DeltaSnapshotManager.cpp — 329 LOC — Implementation of per-connection delta snapshot tracking
DeltaSnapshotManager.h — 199 LOC — Per-connection delta snapshot tracking for replicated entity fields
EntityReplicator.cpp — 266 LOC — Implementation of dirty-tracked entity replication
EntityReplicator.h — 173 LOC — Manages entity state replication with dirty tracking and visibility (TC-inspired)
IAreaSimulation.h — 46 LOC — Plug-in interface for game-supplied authoritative area simulation
INetworkRuntime.h — 46 LOC — Minimal networking runtime interface used by DedicatedServer.
ITransport.h — 69 LOC — Abstract transport layer interface for network communication
InstabilitySimulator.cpp — 239 LOC — Implementation of artificial network instability injection
InstabilitySimulator.h — 145 LOC — Artificial network instability injection for testing and debugging
InterpolationBuffer.h — 239 LOC — Generic ring-buffer for timestamped network sample interpolation
LagCompensation.cpp — 267 LOC — Server-side hit rewind implementation
LagCompensation.h — 121 LOC — Server-side hit rewind — ring buffer of entity poses + rewound raycast
NetQuantize.cpp — 51 LOC — Implementation of quantized transform read/write through NetBuffer.
NetQuantize.h — 48 LOC — NetBuffer-aware helpers for quantized transform replication.
NetworkBindPolicy.h — 58 LOC — Process-local policy for confining development and test listeners.
NetworkBuffer.cpp — 189 LOC — NetBuffer serialization/deserialization helpers
NetworkConnection.cpp — 1421 LOC — Connection lifecycle and message routing for NetworkManager
NetworkEncryption.cpp — 299 LOC — Network encryption, token validation, rate limiting, and replay protection
NetworkEncryption.h — 204 LOC — Lightweight symmetric encryption layer for game network traffic
NetworkIntegration.h — 233 LOC — Cross-links ITransport and NetworkSecurity with NetworkManager
NetworkInterpolation.cpp — 116 LOC — Implementation of client-side network entity interpolation
NetworkInterpolation.h — 122 LOC — Client-side interpolation buffer for smooth remote entity rendering
NetworkManager.cpp — 953 LOC — Core NetworkManager — singleton, update loop, socket helpers, lag compensation
NetworkManager.h — 887 LOC — Multiplayer networking foundation with client/server architecture
NetworkManagerRuntimeAdapter.cpp — 85 LOC — INetworkRuntime adapter backed by NetworkManager.
NetworkManagerRuntimeAdapter.h — 43 LOC — INetworkRuntime adapter backed by NetworkManager.
NetworkReliable.cpp — 210 LOC — Reliable channel logic for NetworkManager
NetworkReplication.cpp — 609 LOC — Entity replication methods for NetworkManager
NetworkSecurity.h — 233 LOC — Network security layer -- packet encryption and connection token auth
NetworkWireLimits.h — 27 LOC — Authoritative size contract for Spark's UDP message wire format.
PacketValidator.cpp — 371 LOC — Network packet validation and sanitization implementation
PacketValidator.h — 164 LOC — Network packet validation and sanitization layer
ReplicationFields.cpp — 120 LOC — Implementation of ReplicatedFieldSet dirty tracking and visibility masks
ReplicationFields.h — 181 LOC — Typed replicated field system with automatic dirty tracking (TrinityCore-inspired)
SteamTransport.h — 95 LOC — Stub ITransport for future Steam Networking Sockets integration
SubTickInput.cpp — 114 LOC — Implementation of sub-tick input recording and processing
SubTickInput.h — 103 LOC — Sub-tick input recording for precise input timing within server ticks
UDPTransport.h — 248 LOC — UDP socket transport implementation of ITransport
WorldServer.cpp — 862 LOC — World server coordinator implementation
WorldServer.h — 356 LOC — Central coordinator for area-based multiplayer world architecture

`SparkEngine/Source/Engine/OnlineServices/`

OnlineServices.h — 666 LOC — Unified online platform integration with pluggable backends

`SparkEngine/Source/Engine/Persistence/`

AsyncDatabase.cpp — 975 LOC — Implementation of the async database persistence layer.
AsyncDatabase.h — 292 LOC — Async database layer with connection pooling and prepared statements (TC-inspired)

`SparkEngine/Source/Engine/Physics/`

JoltPhysicsInterface.h — 377 LOC — Abstract physics interface to support Jolt Physics migration

`SparkEngine/Source/Engine/Procedural/`

ProceduralGenerator.h — 560 LOC — Procedural content generation framework with noise, dungeon, and WFC support

`SparkEngine/Source/Engine/RemoteDebug/`

RemoteDebugSystem.h — 592 LOC — Remote debugging and live link between editor and running game

`SparkEngine/Source/Engine/Rendering/`

MovieRenderPipeline.h — 479 LOC — Offline cinematic rendering pipeline for high-quality frame output

`SparkEngine/Source/Engine/Replay/`

ReplaySystem.cpp — 536 LOC — Implementation of the replay recording and playback system
ReplaySystem.h — 195 LOC — Replay recording and playback system for FPS games

`SparkEngine/Source/Engine/SaveSystem/`

FreezeSystem.h — 305 LOC — Tag-validated, per-subsystem save state serialization
SaveSystem.cpp — 1558 LOC — Save/load system implementation with JSON serialization
SaveSystem.h — 675 LOC — Game state serialization and save/load system for Spark Engine.
SaveSystemTypes.h — 288 LOC — Data types used by the save/load system (metadata, serialized entities, save data).

`SparkEngine/Source/Engine/Scripting/`

AngelScriptEngine.cpp — 1473 LOC — AngelScript virtual machine wrapper implementation
AngelScriptEngine.h — 576 LOC — AngelScript virtual machine wrapper with hot-reload scripting support
ScriptHookManager.cpp — 176 LOC — Implementation of the centralized script hook dispatcher
ScriptHookManager.h — 251 LOC — Centralized script hook dispatcher for gameplay events (TC ScriptMgr-inspired)
ScriptHotReload.cpp — 314 LOC — Implementation of script hot-reload and file watching
ScriptHotReload.h — 335 LOC — File watcher and hot-reload system for AngelScript scripts
ScriptSandbox.cpp — 349 LOC — Runtime sandboxing implementation for AngelScript execution
ScriptSandbox.h — 217 LOC — Runtime sandboxing for AngelScript execution
VisualScriptCompiler.cpp — 1049 LOC — Implementation of visual script graph → AngelScript compiler
VisualScriptCompiler.h — 100 LOC — Compiles a visual script node graph into AngelScript source code
VisualScriptGraphTypes.h — 141 LOC — Pin, node, connection, and graph data structures for visual scripting
VisualScriptNodeTypes.h — 112 LOC — Node type enumeration for visual script graphs

`SparkEngine/Source/Engine/Security/`

MemoryIntegrity.cpp — 597 LOC — Runtime memory integrity and branch protection implementation
MemoryIntegrity.h — 313 LOC — Runtime memory integrity and branch protection system

`SparkEngine/Source/Engine/Streaming/`

AreaAssetLoader.cpp — 264 LOC — Bridges area streaming with async I/O via DirectStorageLoader
AreaAssetLoader.h — 144 LOC — Bridges SeamlessAreaManager with DirectStorageLoader for real asset I/O
DirectStorageLoader.cpp — 339 LOC — GPU-direct asset loading via DirectStorage (Windows 11+)
DirectStorageLoader.h — 197 LOC — GPU-direct asset loading via DirectStorage (Windows 11+)
SceneManifest.h — 151 LOC — Lightweight scene asset manifest for area streaming
SeamlessAreaManager.cpp — 270 LOC — Predictive asset streaming implementation
SeamlessAreaManager.h — 231 LOC — Predictive asset streaming for seamless area transitions
SeamlessAreaManagerStreaming.cpp — 296 LOC — Prediction and streaming logic for SeamlessAreaManager
SeamlessAreaManagerTypes.h — 117 LOC — Area state, definition, and configuration types for predictive streaming

`SparkEngine/Source/Engine/Text/`

FontSystem.h — 578 LOC — Runtime font rendering system with glyph atlas and text layout

`SparkEngine/Source/Engine/Tween/`

TweenSystem.cpp — 376 LOC — Advanced tween system implementation
TweenSystem.h — 203 LOC — Advanced tween system with sequencing, composition, and easing

`SparkEngine/Source/Engine/UI/`

UIDirtyTracking.h — 309 LOC — Dirty region tracking for UI rendering optimization
UIFactory.cpp — 202 LOC — Config-driven UI creation with data binding implementation
UIFactory.h — 161 LOC — Config-driven UI creation with typed data binding
UILayoutExtensions.cpp — 684 LOC
UILayoutExtensions.h — 250 LOC — Declarative UI layout containers, input widgets, and data binding
UISystem.cpp — 428 LOC — Implementation of the runtime UI/Widget system
UISystem.h — 488 LOC — Runtime UI/Widget system for in-game HUD and menus

`SparkEngine/Source/Engine/VR/`

VRSystem.cpp — 120 LOC — Implementation of the VR system framework (OpenXR-ready)
VRSystem.h — 209 LOC — VR/AR integration system (OpenXR-ready framework)

`SparkEngine/Source/Engine/World/`

ProximityTriggerSystem.cpp — 214 LOC — Spatial trigger volume system implementation
ProximityTriggerSystem.h — 176 LOC — Spatial trigger volume system
SpatialGrid.cpp — 302 LOC — Implementation of cell-based spatial partitioning
SpatialGrid.h — 213 LOC — Cell-based spatial partitioning for efficient entity queries (TC-inspired)
TimeOfDaySystem.cpp — 157 LOC — Time-of-day simulation — sun position, light color, ambient intensity
TimeOfDaySystem.h — 161 LOC — Time-of-day simulation with sun direction, light color, and weather integration
WorldOriginSystem.cpp — 169 LOC — Floating-point origin rebasing implementation
WorldOriginSystem.h — 196 LOC — Floating-point origin rebasing system for large worlds

`SparkEngine/Source/Enums/`

EnumUtils.cpp — 393 LOC — Implementation of enum utility functions
EnumUtils.h — 350 LOC — Utilities for enum operations, validation, and string conversion
GameSystemEnums.h — 409 LOC — Game system enumerations for Spark Engine
GraphicsEnums.h — 128 LOC — Core graphics system enumerations for Spark Engine
InputEnums.h — 144 LOC — Input system enumerations for Spark Engine

`SparkEngine/Source/Game/`

GameObject.cpp — 261 LOC
GameObject.h — 333 LOC — Base class for all interactive objects in the game world
Model.cpp — 215 LOC
Model.h — 43 LOC — Default constructor
ModelVertex.h — 80 LOC — Standard vertex structure for imported 3D models
PlaceholderMesh.h — 157 LOC — Robust mesh loading helper with automatic procedural fallback
Primitives.cpp — 109 LOC
Primitives.h — 86 LOC — Procedural primitive mesh generators for common 3D shapes
TemplateRuntime.h — 450 LOC — Small runtime bridge for installed-SDK game templates.

`SparkEngine/Source/Graphics/2D/`

SpriteBatch.h — 350 LOC — Batched 2D sprite renderer with automatic atlas sorting and draw-call merging

`SparkEngine/Source/Graphics/`

AdaptiveProbeVolumes.cpp — 555 LOC — Implementation of brick-based hierarchical probe volumes
AdaptiveProbeVolumes.h — 297 LOC — Brick-based hierarchical probe system with adaptive subdivision
AssetMetadata.cpp — 8 LOC — Platform-split redirect
AssetMetadataLinux.cpp — 305 LOC — Linux implementation — split from AssetMetadata.cpp
AssetMetadataWindows.cpp — 270 LOC — Windows/D3D11 implementation — split from AssetMetadata.cpp
AssetPipeline.cpp — 8 LOC — Platform-split redirect
AssetPipeline.h — 580 LOC — Complete asset pipeline system for model loading and streaming
AssetPipelineConsoleOps.cpp — 281 LOC — Console integration methods for AssetPipeline
AssetPipelineLinux.cpp — 343 LOC — Linux implementation — split from AssetPipeline.cpp
AssetPipelineLinuxStreaming.cpp — 204 LOC — Linux background streaming, metrics, and RHI mesh upload for AssetPipeline
AssetPipelineWindows.cpp — 441 LOC — Windows/D3D11 implementation — split from AssetPipeline.cpp
AssetTypes.cpp — 55 LOC — Cross-platform asset type definitions.
AssetTypesLinux.cpp — 331 LOC — Linux mesh asset implementation (MeshAsset)
AssetTypesLinuxMedia.cpp — 250 LOC — Linux texture/audio asset implementations (TextureAsset, AudioAsset) and AssetCache
AssetTypesWindows.cpp — 265 LOC — Windows/D3D11 mesh asset implementation (MeshAsset)
AssetTypesWindowsMedia.cpp — 358 LOC — Windows/D3D11 texture/audio asset implementations (TextureAsset, AudioAsset) and AssetCache
AsyncComputeScheduler.cpp — 282 LOC — Implementation of the async compute workload scheduler
AsyncComputeScheduler.h — 198 LOC — Async compute workload scheduler with multi-backend support
BVHAccelerator.h — 447 LOC — SAH-based Bounding Volume Hierarchy for hierarchical frustum culling
BasisTranscoder.h — 753 LOC — GPU texture transcoding from Basis Universal format to native GPU formats
BilateralUpsample.h — 231 LOC — Shared bilateral upsample utility for half-resolution effects
BloomEffect.cpp — 451 LOC — HDR bloom implementation with progressive downsample/upsample
BloomEffect.h — 141 LOC — HDR bloom post-processing with progressive downsample/upsample chain
CachedShadowAtlas.h — 331 LOC — Cached shadow atlas that avoids re-rendering static shadow maps
ClipmapTerrain.cpp — 404 LOC — Implementation of clipmap-based terrain LOD system
ClipmapTerrain.h — 178 LOC — Clipmap-based terrain LOD system for efficient large-world rendering
ClusteredLightCulling.cpp — 418 LOC — Implementation of CPU-side clustered light culling
ClusteredLightCulling.h — 187 LOC — GPU-based clustered light culling with a 3D frustum grid
ClusteredLightGPU.h — 171 LOC — GPU structured buffer layout for clustered forward+ lighting
ConstantBufferDiff.h — 138 LOC — Content-diff constant buffer uploads to skip redundant GPU updates
ConstantBufferRing.h — 365 LOC — Ring-buffer allocator for dynamic constant buffers
DDGIProbeSystem.cpp — 456 LOC — Implementation of DDGI probe system with SH accumulation and trilinear query
DDGIProbeSystem.h — 242 LOC — Dynamic Diffuse Global Illumination using irradiance probes
DecalSystem.cpp — 8 LOC — Platform-split redirect
DecalSystem.h — 170 LOC — Projected decal system for bullet holes, scorch marks, and environmental detail
DecalSystemLinux.cpp — 293 LOC — Linux implementation — split from DecalSystem.cpp
DecalSystemWindows.cpp — 337 LOC — Windows/D3D11 implementation — split from DecalSystem.cpp
DenoiserInterface.h — 261 LOC — AI-powered image denoiser interface for ray-traced output
DirtyRectTracker.h — 173 LOC — Dirty rectangle tracking for partial texture updates
DrawSortKey.h — 321 LOC — 64-bit composite sort key for draw call batching and radix sort
DynamicQualityScaler.cpp — 171 LOC — Implementation of dynamic resolution scaling based on frame performance
DynamicQualityScaler.h — 112 LOC — Dynamic resolution scaler that adjusts render resolution based on frame performance
DynamicQualityTypes.h — 354 LOC — Type definitions for the upscaling/dynamic quality system
EXRLoader.h — 247 LOC — Bounded OpenEXR memory loading for HDR engine assets.
FBXImporter.cpp — 801 LOC — FBX binary format parser implementation
FBXImporter.h — 432 LOC — Binary FBX file format importer for mesh, skeleton, and animation data
FastNoise2SIMD.h — 755 LOC — SIMD-accelerated procedural noise with node graph evaluation
FastNoiseLite.h — 695 LOC — Fast portable noise generation (CPU + HLSL compatible)
FogSystem.cpp — 150 LOC — Implementation of distance fog, height fog, and volumetric fog rendering
FogSystem.h — 287 LOC — Distance fog, height fog, and volumetric fog rendering
FoliageImpostorBaker.cpp — 176 LOC — CPU-portable impostor atlas layout and UV math
FoliageImpostorBaker.h — 364 LOC — Atlas packing and angle selection for foliage impostors
FoliageImpostorBakerWindows.cpp — 489 LOC — D3D11 GPU implementation of FoliageImpostorAtlas
FoliageRenderer.cpp — 463 LOC — CPU-portable foliage collection, batching, and LOD selection
FoliageRenderer.h — 510 LOC — Render-side consumer for FoliageManager instances
FoliageRendererWindows.cpp — 473 LOC — GPU-side foliage rendering — D3D11 upload, shader compilation, draw calls
FoliageSystem.cpp — 497 LOC — Implementation of FoliageManager — deterministic foliage scattering
FoliageSystem.h — 268 LOC — Instanced vegetation placement and rendering system
FroxelVolumetricFog.cpp — 480 LOC — CPU reference implementation of froxel-based volumetric fog
FroxelVolumetricFog.h — 230 LOC — Froxel-based volumetric fog using a frustum-aligned 3D grid
FrustumCulling.h — 398 LOC — Camera frustum extraction and AABB/sphere visibility testing
GLTFStaticMeshLoader.cpp — 650 LOC — Validated CPU-side glTF 2.0 static-mesh loading via cgltf.
GLTFStaticMeshLoader.h — 50 LOC — Fail-closed CPU loader for the supported glTF 2.0 static-mesh subset.
GPUClusterCulling.cpp — 280 LOC — GPU compute shader-based clustered light assignment
GPUClusterCulling.h — 165 LOC — GPU compute shader-based clustered light assignment
GPUDebugMarkers.h — 380 LOC — GPU annotation system for PIX, RenderDoc, and VS Graphics Debugger
GPUDrivenRenderer.cpp — 488 LOC — GPU-driven indirect rendering pipeline implementation
GPUDrivenRenderer.h — 218 LOC — GPU-driven indirect rendering pipeline with compute-based culling
GPUOcclusionCulling.cpp — 343 LOC — CPU reference implementation of GPU-driven occlusion culling
GPUOcclusionCulling.h — 176 LOC — GPU-driven occlusion culling using previous frame's hierarchical Z-buffer
GPUParticleSystem.cpp — 15 LOC — Platform-independent GPUParticleSystem code (destructor only)
GPUParticleSystem.h — 288 LOC — GPU-accelerated particle system using D3D11 compute shaders
GPUParticleSystemLinux.cpp — 106 LOC — Linux GPU particle system stubs — no-op implementations for headless/NullRHI
GPUParticleSystemWindows.cpp — 453 LOC — Windows/D3D11 GPU particle system — compute shader pipeline, buffer management, rendering
GPUParticleTypes.h — 154 LOC — Type definitions for the GPU particle system
GPUProfiler.cpp — 222 LOC — GPU profiler implementation
GPUProfiler.h — 158 LOC — GPU timestamp queries and pipeline statistics profiling
GPUSceneBuffer.h — 361 LOC — Persistent GPU structured buffer for scene instance data
GPUSkinning.cpp — 386 LOC — Implementation of GPU compute shader skinning
GPUSkinning.h — 225 LOC — GPU compute shader skinning manager for offloading vertex skinning from the vertex shader
GPUTimestampQuery.h — 493 LOC — Per-pass GPU timing with double-buffered timestamp queries
GTAOEffect.h — 450 LOC — Ground Truth Ambient Occlusion (GTAO) screen-space effect
GraphicsConsoleCommands.cpp — 425 LOC — Implementation of graphics console command registration
GraphicsConsoleCommands.h — 24 LOC — Registers graphics-related console commands
GraphicsConsoleOps.cpp — 8 LOC — Platform-split redirect
GraphicsConsoleOpsLinux.cpp — 270 LOC — Linux implementation — split from GraphicsConsoleOps.cpp
GraphicsConsoleOpsWindows.cpp — 233 LOC — Windows/D3D11 implementation — split from GraphicsConsoleOps.cpp
GraphicsConsoleOpsWindowsDiagnostics.cpp — 407 LOC — Windows/D3D11 console diagnostics and device operations
GraphicsDeviceResources.cpp — 8 LOC — Device creation and resource management — platform-split redirect
GraphicsDeviceResourcesLinux.cpp — 239 LOC — Linux RHI-bridge device and resource management for GraphicsEngine
GraphicsDeviceResourcesLinuxShaders.cpp — 383 LOC — Linux RHI-bridge basic shader system for GraphicsEngine
GraphicsDeviceResourcesWindows.cpp — 450 LOC — D3D11 device creation, render targets, render states, and pipeline setup
GraphicsDeviceResourcesWindowsBasicState.cpp — 530 LOC — D3D11 basic shader binding, constants, and basic material cache
GraphicsDeviceResourcesWindowsInstanced.cpp — 340 LOC — D3D11 basic instanced draw path (W12 decor-instancing)
GraphicsDeviceResourcesWindowsShaders.cpp — 443 LOC — D3D11 basic shader system initialization and shader compilation
GraphicsDeviceResourcesWindowsTextures.cpp — 481 LOC — D3D11 default, procedural, and file-loaded textures for the basic path
GraphicsEngine.cpp — 13 LOC — Central rendering orchestrator — platform-split redirect
GraphicsEngine.h — 1260 LOC — Advanced DirectX 11 graphics engine with AAA features and console integration
GraphicsEngineHybridRT.cpp — 61 LOC — Platform-agnostic HybridRT post-lighting dispatch.
GraphicsEngineLinux.cpp — 414 LOC — Linux RHI-bridge lifecycle (Initialize/Shutdown/Resize) for SparkEngine
GraphicsEngineLinuxAccessors.cpp — 110 LOC — Linux RHI-bridge system/state accessors for GraphicsEngine
GraphicsEngineLinuxFrame.cpp — 242 LOC — Linux RHI-bridge per-frame rendering path for GraphicsEngine
GraphicsEngineLinuxRenderTargets.cpp — 99 LOC — Platform render target helpers (Linux/macOS) for GraphicsEngine
GraphicsEngineRHI.h — 63 LOC — Internal header for Linux RHI state shared across GraphicsEngine translation units
GraphicsEngineSubmit.cpp — 151 LOC — Platform-agnostic ECS mesh draw submission for GraphicsEngine.
GraphicsEngineTypes.h — 214 LOC — Enums, settings structs, and data-transfer types used by GraphicsEngine
GraphicsEngineWindows.cpp — 389 LOC — Windows/D3D11 central rendering orchestrator for SparkEngine
GraphicsEngineWindowsAccessors.cpp — 131 LOC — Windows/D3D11 system/state accessors for GraphicsEngine
GraphicsEngineWindowsDeviceLost.cpp — 158 LOC — Windows/D3D11 device-lost recovery for GraphicsEngine
GraphicsEngineWindowsDrawList.cpp — 211 LOC — Windows/D3D11 ECS mesh draw-list processing for GraphicsEngine
GraphicsEngineWindowsFrame.cpp — 478 LOC — Windows/D3D11 per-frame rendering path for GraphicsEngine
GraphicsEngineWindowsInit.cpp — 412 LOC — Windows/D3D11 windowed initialization for GraphicsEngine
GraphicsRenderPipelines.cpp — 8 LOC — Rendering pipeline implementations — platform-split redirect
GraphicsRenderPipelinesLinux.cpp — 423 LOC — Linux RHI-bridge rendering pipeline implementations
GraphicsRenderPipelinesWindows.cpp — 273 LOC — D3D11 rendering pipeline implementations (Forward, Deferred, Forward+)
GraphicsRenderPipelinesWindowsPasses.cpp — 396 LOC — D3D11 G-Buffer fill, lighting pass, frustum culling, and post-processing passes
GraphicsStateAndSettings.cpp — 8 LOC — Graphics state, metrics, and settings — platform-split redirect
GraphicsStateAndSettingsLinux.cpp — 365 LOC — Linux RHI-bridge graphics state management, metrics, and settings
GraphicsStateAndSettingsWindows.cpp — 252 LOC — D3D11 graphics state management and metrics
GraphicsStateAndSettingsWindowsResize.cpp — 207 LOC — D3D11 resize handling, statistics reset, and screenshot capture
GraphicsStateAndSettingsWindowsSettings.cpp — 266 LOC — D3D11 graphics settings and configuration

`SparkEngine/Source/Graphics/HybridRT/`

HybridRTManager.cpp — 413 LOC — Hybrid ray tracing coordinator implementation
HybridRTManager.h — 238 LOC — Hybrid ray tracing coordinator — Lumen-style SS → Software RT → Hardware RT
HybridRTManagerExecute.cpp — 221 LOC — HybridRTManager per-frame execution: the Execute() backend dispatch
HybridRTTypes.h — 163 LOC — Shared types for the hybrid ray tracing system
ProbeSystem.cpp — 250 LOC — Irradiance probe grid management and compute dispatch
ProbeSystem.h — 105 LOC — Irradiance probe grid for cached global illumination
RTCompositor.cpp — 164 LOC — RT/SS result compositing with temporal accumulation
RTCompositor.h — 83 LOC — Composites screen-space and ray-traced results with temporal accumulation
RTMaterialAdapter.h — 69 LOC — Convert engine-side PBR material properties into the flat
RTSceneFeeder.cpp — 129 LOC — ECS walker that populates HybridRTManager's triangle-mesh scene.
RTSceneFeeder.h — 74 LOC — Utility that walks an ECS world and pushes every visible
SDFSceneManager.cpp — 202 LOC — SDF scene management and SDFGI compute shader dispatch
SDFSceneManager.h — 99 LOC — SDF scene representation and compute-based sphere tracing for software RT

`SparkEngine/Source/Graphics/`

LODGenerator.cpp — 452 LOC — QEM mesh simplification and LOD chain generation
LODGenerator.h — 169 LOC — Automatic LOD chain generation using quadric error metric simplification
LightLayers.h — 130 LOC — Per-object light layer masking for selective lighting
LightManager.h — 446 LOC — Light culling, tile binning, and shadow atlas management
LightProbeSystem.cpp — 340 LOC — Light probe management with SH interpolation and GPU data packing
LightProbeSystem.h — 188 LOC — Light probes with spherical harmonics encoding for indirect illumination
LightingSystem.cpp — 8 LOC — Platform-split redirect
LightingSystem.h — 477 LOC — Advanced lighting system with PBR support for Spark Engine
LightingSystemInternal.cpp — 8 LOC — Platform-split redirect
LightingSystemInternalLinux.cpp — 59 LOC — Linux implementation — split from LightingSystemInternal.cpp
LightingSystemInternalWindows.cpp — 323 LOC — Windows/D3D11 implementation — split from LightingSystemInternal.cpp
LightingSystemInternalWindowsCulling.cpp — 254 LOC — Windows/D3D11 light culling and shadow matrix math for LightingSystem
LightingSystemInternalWindowsIBL.cpp — 385 LOC — Windows/D3D11 image-based lighting generation for LightingSystem
LightingSystemInternalWindowsTypes.cpp — 105 LOC — Windows light/shadow type string conversions for LightingSystem
LightingSystemLinux.cpp — 325 LOC — Linux implementation — split from LightingSystem.cpp
LightingSystemLinuxTypes.cpp — 205 LOC — Linux Light class implementation and light/shadow type string conversions
LightingSystemWindows.cpp — 467 LOC — Windows/D3D11 implementation — split from LightingSystem.cpp
LightingSystemWindowsLightOps.cpp — 288 LOC — Windows light management and console operations for LightingSystem
LightingSystemWindowsTypes.cpp — 146 LOC — Windows Light class implementation for LightingSystem
LightmapBaker.h — 497 LOC — Offline lightmap baking system for pre-computed global illumination
LineTrailRenderer.h — 138 LOC — World-space line rendering and trail effects
MSDFTextRenderer.cpp — 476 LOC — MSDF text rendering implementation with instanced glyph quads
MSDFTextRenderer.h — 241 LOC — Multi-channel Signed Distance Field text rendering system
MakeDesc.h — 370 LOC — Zero-init factory functions for D3D11 descriptor structs
MaterialConsoleEdit.cpp — 362 LOC — Console commands for material property editing, texture assignment, and hot-reload.
MaterialConsoleOps.cpp — 862 LOC — Console commands for material inspection, listing, creation, deletion, and validation.
MaterialDefinition.h — 536 LOC — Declarative material definition format (Filament/Ogre-Next-inspired)
MaterialLoader.cpp — 258 LOC — Data-driven material loading from .sparkmat text files
MaterialLoader.h — 110 LOC — Data-driven material loading from .sparkmat text files
MaterialPropertyHandle.cpp — 82 LOC — Handle-based material uniform access — eliminates string lookups at runtime
MaterialPropertyHandle.h — 152 LOC — Handle-based material uniform access eliminating runtime string lookups
MaterialSystem.cpp — 486 LOC — Core MaterialSystem implementation — lifecycle, CRUD, texture loading, utilities
MaterialSystem.h — 569 LOC — Advanced material system for AAA-quality rendering with PBR support
MaterialSystemLinux.cpp — 151 LOC — Linux MaterialSystem methods — RHI-based stubs for texture/sampler/binding
MaterialSystemWindows.cpp — 264 LOC — Windows/D3D11 MaterialSystem methods — texture loading, binding, samplers, GPU state
MaterialTextureLoading.cpp — 184 LOC — WIC-based texture loading for the MaterialSystem (Windows only)
Mesh.cpp — 8 LOC — Platform-split redirect
Mesh.h — 242 LOC — 3D mesh management and primitive generation system (umbrella header)
MeshClusterSystem.h — 824 LOC — Nanite-inspired mesh cluster hierarchy with GPU-driven rendering
MeshLOD.cpp — 8 LOC — Platform-split redirect
MeshLOD.h — 170 LOC — Mesh Level-of-Detail system with automatic generation and distance-based switching
MeshLODLinux.cpp — 313 LOC — Linux implementation — split from MeshLOD.cpp
MeshLODWindows.cpp — 363 LOC — Windows/D3D11 implementation — split from MeshLOD.cpp
MeshLinux.cpp — 425 LOC — Linux implementation — split from Mesh.cpp
MeshOptimizer.h — 474 LOC — Mesh optimization pipeline: vertex cache, overdraw, fetch, simplification, meshlets
MeshShaderPipeline.cpp — 312 LOC — Mesh shader rendering pipeline implementation
MeshShaderPipeline.h — 152 LOC — Mesh shader rendering pipeline for meshlet-based geometry
MeshTypes.h — 83 LOC — Vertex, mesh data, and submesh structures for the mesh system
MeshWindows.cpp — 388 LOC — Windows/D3D11 implementation — split from Mesh.cpp
MeshWindowsPrimitives.cpp — 264 LOC — Procedural primitive generation for the Windows/D3D11 Mesh implementation
ModelLoading.cpp — 255 LOC — Cross-platform model rendering helpers (BindMesh, BindMaterial, DrawBoundMesh)
ModelLoadingLinux.cpp — 380 LOC — Linux model loading — split from ModelLoading.cpp
ModelLoadingWindows.cpp — 75 LOC — Windows/D3D11 model loading — split from ModelLoading.cpp

`SparkEngine/Source/Graphics/Neural/`

CpuNeuralInference.cpp — 358 LOC — SIMD-optimized CPU neural network inference implementation
CpuNeuralInference.h — 130 LOC — SIMD-optimized CPU neural network inference
CpuNeuralTraining.cpp — 466 LOC — CPU MLP training: backprop + SGD/Adam + MSE/L1/Huber losses
CpuNeuralTraining.h — 218 LOC — CPU neural-network training: backprop + optimizers + losses
NeuralFunctionApproximator.cpp — 166 LOC — Implementation of the learned CPU function facade
NeuralFunctionApproximator.h — 207 LOC — Generic learned CPU function f: R^N → R^M for engine subsystems
NeuralInference.cpp — 454 LOC — GPU neural network inference engine implementation
NeuralInference.h — 179 LOC — Lightweight GPU neural network inference engine (compute shader-based)
NeuralPostProcessing.cpp — 460 LOC — Neural denoiser and super-resolution implementation (CPU paths)
NeuralPostProcessing.h — 159 LOC — Neural-enhanced denoiser and super-resolution post-processing
NeuralRadianceCache.cpp — 285 LOC — Multi-resolution hash grid + MLP radiance cache implementation
NeuralRadianceCache.h — 189 LOC — Multi-resolution hash grid + MLP for cached indirect lighting
NeuralTextureCompressor.cpp — 389 LOC — Neural texture compression: CPU training + CPU/GPU decompression
NeuralTextureCompressor.h — 162 LOC — Neural texture compression: encode textures as tiny MLPs per block
NeuralTextureFormat.h — 70 LOC — .ntex binary file format for neural-compressed textures
NeuralTypes.h — 126 LOC — Shared types for the neural rendering subsystem
NeuralWeights.cpp — 236 LOC — .nnw file I/O for neural network weight serialization
NeuralWeights.h — 119 LOC — Serialization and deserialization of neural network weights (.nnw format)

`SparkEngine/Source/Graphics/`

OcclusionCulling.cpp — 360 LOC — Implementation of CPU software occlusion culling
OcclusionCulling.h — 207 LOC — CPU software occlusion culling with a low-resolution depth buffer
PBRMaterial.cpp — 456 LOC — Core PBR material state management
PBRMaterialBinding.cpp — 531 LOC — Shader resource binding for PBR materials
PBRMaterialLighting.cpp — 315 LOC — Platform-independent PBR material serialization and shader permutation logic
PBRMaterialLightingLinux.cpp — 49 LOC — Linux Material::LoadFromFile and ReloadMaterial stubs
PBRMaterialLightingWindows.cpp — 468 LOC — Windows/D3D11 Material::LoadFromFile and ReloadMaterial
PCSSshadows.h — 273 LOC — Percentage-Closer Soft Shadows with variable penumbra
ParticleSystem.cpp — 8 LOC — Platform-split redirect
ParticleSystem.h — 265 LOC — GPU-friendly particle system for visual effects
ParticleSystemLinux.cpp — 266 LOC — Linux ParticleSystem manager and console helpers — split from ParticleSystem.cpp.
ParticleSystemLinuxEmitter.cpp — 324 LOC — Linux ParticleEmitter implementation — split from ParticleSystemLinux.cpp,
ParticleSystemWindows.cpp — 294 LOC — Windows/D3D11 ParticleSystem manager and console helpers — split from ParticleSystem.cpp.
ParticleSystemWindowsEmitter.cpp — 395 LOC — Windows/D3D11 ParticleEmitter implementation — split from ParticleSystemWindows.cpp,
PersistentMaterialCB.h — 223 LOC — Persistent GPU material constant buffers (SRP Batcher pattern)
PipelineStateCache.h — 401 LOC — Hash-based caching of D3D11 pipeline state objects
PortalCulling.cpp — 296 LOC — Portal-based visibility culling — cell graph traversal and frustum narrowing
PortalCulling.h — 267 LOC — Portal-based visibility culling for indoor/architectural scenes
PostProcessingEffects.h — 17 LOC — Post-processing effect type definitions and settings structs
PostProcessingPipeline.cpp — 1602 LOC
PostProcessingPipeline.h — 449 LOC — Configurable post-processing effect chain with ordered passes
PostProcessingPipelineWindows.cpp — 221 LOC — D3D11 GPU resource creation and effect-shader compilation
PostProcessingPipelineWindowsPasses.cpp — 312 LOC — D3D11 per-pass GPU execution for the post-processing pipeline
PostProcessingPipelineWindowsShadersAO.h — 172 LOC — Inline HLSL sources for the ambient-occlusion post-process pixel shaders
PostProcessingPipelineWindowsShadersColor.h — 167 LOC — Inline HLSL sources for the color/HDR post-process pixel shaders
PostProcessingPipelineWindowsShadersFilter.h — 166 LOC — Inline HLSL sources for the filtering post-process pixel shaders
PostProcessingPipelineWindowsShadersLens.h — 188 LOC — Inline HLSL sources for the lens/camera post-process pixel shaders
PostProcessingTypes.h — 304 LOC — Type definitions, enums, and settings structs for the post-processing pipeline
ProjectAssetPath.cpp — 210 LOC — Canonical, project-confined asset path resolution implementation.
ProjectAssetPath.h — 52 LOC — Canonical, project-confined asset path resolution for render-time loads.

`SparkEngine/Source/Graphics/RHI/D3D11/`

D3D11Device.cpp — 1543 LOC — DirectX 11 RHI backend implementation
D3D11Device.h — 342 LOC — DirectX 11 implementation of the RHI device interface

`SparkEngine/Source/Graphics/RHI/D3D12/`

D3D12CommandList.cpp — 428 LOC — D3D12SwapChain and D3D12CommandList implementations
D3D12Device.cpp — 1593 LOC — Complete DirectX 12 RHI backend implementation
D3D12Device.h — 273 LOC — DirectX 12 implementation of the RHI device interface
D3D12Types.h — 539 LOC — D3D12 type definitions, constants, and lightweight resource wrappers

`SparkEngine/Source/Graphics/RHI/`

DXRSupport.cpp — 1115 LOC — DirectX Raytracing (DXR) implementation with full D3D12 pipeline
DXRSupport.h — 272 LOC — DirectX Raytracing (DXR) support for ray-traced reflections, GI, and shadows
DeferredDeletionQueue.h — 121 LOC — Frame-delayed GPU resource destruction queue

`SparkEngine/Source/Graphics/RHI/Metal/`

MetalDevice.h — 545 LOC — Apple Metal implementation of the RHI device interface
MetalGoldenImageCapture.h — 93 LOC — IGoldenImageCapture that reads back a Metal texture.
MetalInterop.h — 22 LOC — C++-safe entry points for Objective-C++ Metal implementation details.
MetalRayTracing.h — 241 LOC — Metal 2.4+ hardware ray-tracing backend for HybridRTManager.
MetalTextureReadback.h — 55 LOC — CPU readback of an MTLTexture into an RGBA byte vector.

`SparkEngine/Source/Graphics/RHI/`

NullRHIDevice.h — 376 LOC — Headless no-op RHI backend for testing and CI
NullRHIResources.h — 167 LOC — Concrete stub IRHI* resource implementations for the headless backend

`SparkEngine/Source/Graphics/RHI/OpenGL/`

OpenGLDevice.cpp — 2160 LOC — OpenGL 4.6 Core Profile RHI backend implementation
OpenGLDevice.h — 438 LOC — OpenGL 4.6 Core Profile implementation of the RHI device interface

`SparkEngine/Source/Graphics/RHI/`

PipelineStateCache.cpp — 84 LOC — Immutable flyweight PSO cache implementation
PipelineStateCache.h — 93 LOC — Immutable flyweight cache for pipeline state objects
RHI.h — 41 LOC — Master include for the Rendering Hardware Interface
RHIAdapter.cpp — 613 LOC — Implementation of the RHI adapter layer (R3.2 -- Route rendering through RHI)
RHIAdapter.h — 414 LOC — Adapter layer that routes legacy GraphicsEngine calls through the RHI
RHIBridge.cpp — 735 LOC — Implementation of the RHI bridge layer
RHIBridge.h — 270 LOC — Integration bridge between the RHI abstraction and the existing GraphicsEngine
RHIDevice.h — 184 LOC — Abstract Rendering Hardware Interface device
RHIDeviceBase.h — 48 LOC — Shared base class for concrete IRHIDevice implementations.
RHIFactory.cpp — 652 LOC — RHI factory and utility implementation
RHIFactory.h — 208 LOC — Factory and utility functions for RHI backend selection
RHIFormatUtils.h — 178 LOC — Shared format utility functions for all RHI backends
RHIHandlePool.h — 239 LOC — Typed handle pool with generation counters for RHI resources (Filament/bgfx-inspired)
RHIPipelineTypes.h — 219 LOC — Pipeline state types and advanced descriptors for the Rendering Hardware Interface
RHIResources.h — 106 LOC — Abstract resource interfaces for the Rendering Hardware Interface
RHITypes.h — 463 LOC — Core types and enumerations for the Rendering Hardware Interface
RHIValidationLayer.cpp — 318 LOC — Implementation of the debug-only RHI validation layer
RHIValidationLayer.h — 206 LOC — Debug-only validation decorator for RHI resource and state tracking
TransientBufferAllocator.h — 240 LOC — Per-frame bump allocator for transient vertex/index data

`SparkEngine/Source/Graphics/RHI/Vulkan/`

VulkanCommandList.cpp — 682 LOC — VulkanSwapChain and VulkanCommandList implementations
VulkanDescriptorCache.cpp — 260 LOC — Descriptor set layout caching and batched writes implementation
VulkanDescriptorCache.h — 131 LOC — Descriptor set layout caching and batched descriptor writes
VulkanDevice.cpp — 1991 LOC — Vulkan RHI backend implementation
VulkanDevice.h — 538 LOC — Vulkan implementation of the RHI device interface
VulkanFormatHelpers.cpp — 310 LOC — Vulkan format conversion utilities

`SparkEngine/Source/Graphics/`

RTHandleSystem.h — 268 LOC — Scale-based render texture allocation with automatic resolution adaptation
ReflectionProbeCache.h — 320 LOC — Cached reflection probe cubemaps with LRU eviction
RenderCommandRing.h — 209 LOC — Thread-decoupled render command ring buffer
RenderDevice.cpp — 262 LOC — Core GPU device and swap chain management for Direct3D 11
RenderDevice.h — 142 LOC — Thin wrapper around the RHI device and swap chain (R3.1 — Architecture Analysis)
RenderGraph.h — 1427 LOC — Declarative render graph / frame graph system for SparkEngine (umbrella header)

`SparkEngine/Source/Graphics/RenderGraph/`

RenderGraphBuilder.cpp — 530 LOC — Implementation of StandardPipelineBuilder (R3.3 -- Activate RenderGraph pipeline)
RenderGraphBuilder.h — 318 LOC — High-level helper that constructs a RenderGraph from the engine's
RenderGraphExporter.cpp — 92 LOC — GraphViz .dot export for render graph visualization
RenderGraphExporter.h — 39 LOC — Exports render graph as GraphViz .dot file for debugging
TransientResourcePool.cpp — 199 LOC — Implementation of age-based transient GPU resource pooling
TransientResourcePool.h — 151 LOC — Age-based transient GPU resource pooling for the render graph

`SparkEngine/Source/Graphics/`

RenderGraphBlackboard.h — 145 LOC — Type-erased inter-pass data sharing for the render graph
RenderGraphPass.h — 200 LOC — Render graph pass and builder classes
RenderGraphTypes.h — 352 LOC — Resource descriptors, enums, and handles for the render graph system
RenderPipeline.cpp — 439 LOC — Render graph-based pipeline that manages ordered render passes
RenderPipeline.h — 182 LOC — Frame graph-based render pipeline (R3.1, R3.3 — Architecture Analysis)
RenderTarget.cpp — 8 LOC — Platform-split redirect
RenderTarget.h — 386 LOC — Advanced render target system for deferred rendering and post-processing
RenderTargetConsole.cpp — 417 LOC — RenderTargetManager console integration and debug visualization
RenderTargetLinux.cpp — 170 LOC — Linux implementation — split from RenderTarget.cpp
RenderTargetManager.cpp — 8 LOC — Platform-split redirect
RenderTargetManagerLinux.cpp — 299 LOC — Linux implementation — split from RenderTargetManager.cpp
RenderTargetManagerWindows.cpp — 364 LOC — Windows/D3D11 implementation — split from RenderTargetManager.cpp
RenderTargetPool.h — 401 LOC — Pooled transient render target management
RenderTargetWindows.cpp — 402 LOC — Windows/D3D11 implementation — split from RenderTarget.cpp
RenderTargetWindowsMulti.cpp — 123 LOC — Windows/D3D11 MultipleRenderTargets implementation — split from RenderTargetWindows.cpp
SHLighting.h — 299 LOC — Spherical harmonics evaluation and BRDF LUT generation for IBL (Filament-inspired)
SSAOTemporal.h — 234 LOC — Temporal denoising for SSAO with history reprojection
SVGRenderer.h — 803 LOC — SVG path parsing, tessellation, and rendering to vertex buffers
SceneRenderer.cpp — 243 LOC — High-level scene rendering: draw command submission, frustum culling, and sorting
SceneRenderer.h — 198 LOC — ECS-based scene rendering — collects draw commands and feeds the pipeline (R3.1, R3.5)
ScreenCapture.h — 376 LOC — Screenshot and frame sequence capture system
ScreenSpaceEffects.cpp — 344 LOC — Implementation of screen-space rendering effects manager
ScreenSpaceEffects.h — 339 LOC — Screen-space rendering effects: SSAO, SSR, screen-space shadows
Shader.cpp — 8 LOC — Platform-split redirect
Shader.h — 667 LOC — Advanced HLSL shader management with PBR, lighting, and console integration
ShaderCompilation.cpp — 8 LOC — Platform-split redirect
ShaderCompilationLinux.cpp — 462 LOC — Linux implementation — split from ShaderCompilation.cpp
ShaderCompilationLinuxCompileOps.cpp — 222 LOC — Linux compile utilities — split from ShaderCompilationLinux.cpp
ShaderCompilationLinuxInternal.h — 76 LOC — Shared Linux-only helpers for the ShaderCompilationLinux*.cpp split parts
ShaderCompilationWindows.cpp — 467 LOC — Windows/D3D11 implementation — split from ShaderCompilation.cpp
ShaderCompilationWindowsCompileOps.cpp — 303 LOC — Windows/D3D11 compile utilities — split from ShaderCompilationWindows.cpp
ShaderConsoleOps.cpp — 482 LOC — Console integration methods for the Shader system
ShaderCrossCompiler.h — 394 LOC — Shader cross-compilation pipeline for multi-backend RHI support
ShaderDaemonBridge.cpp — 67 LOC — Implementation of the CompiledShaderBlob wire codec.
ShaderDaemonBridge.h — 52 LOC — Translate between engine CompiledShaderBlob and daemon opaque bytes.
ShaderDiskCache.cpp — 311 LOC — Persistent shader disk cache implementation
ShaderDiskCache.h — 156 LOC — Persistent on-disk shader compilation cache

`SparkEngine/Source/Graphics/ShaderGraph/`

ShaderGraphCompiler.cpp — 394 LOC — Node graph to HLSL compilation — topological traversal + code emission
ShaderGraphCompiler.h — 159 LOC — Compiles a material node graph into HLSL shader code (ezEngine-inspired)

`SparkEngine/Source/Graphics/`

ShaderHotReload.cpp — 373 LOC — Shader hot-reload system and variant management
ShaderHotReload.h — 549 LOC — Shader file watcher and hot-reload system
ShaderLinux.cpp — 383 LOC — Linux implementation — split from Shader.cpp
ShaderVariantSystem.h — 396 LOC — Shader variant keyword and stripping system
ShaderWindows.cpp — 324 LOC — Windows/D3D11 implementation — split from Shader.cpp
ShaderWindowsConstantBuffers.cpp — 204 LOC — Windows/D3D11 constant buffer management — split from ShaderWindows.cpp
ShadowAtlas.cpp — 366 LOC — Implementation of priority-based shadow map atlas tile allocation
ShadowAtlas.h — 138 LOC — Priority-based shadow map atlas for efficient shadow rendering
ShadowAtlasTypes.h — 41 LOC — Type definitions for the shadow atlas system
SkyAtmosphere.cpp — 437 LOC — Implementation of the Preetham analytical sky model
SkyAtmosphere.h — 226 LOC — Sky and atmosphere rendering using a simplified Preetham sky model
SlangShaderInterface.h — 317 LOC — Abstract interface for Slang shader compilation and reflection
SpringArm.h — 79 LOC — Camera collision avoidance arm (spring arm / camera boom)
TemporalEffects.h — 628 LOC — Temporal effects system: TAA, motion blur, temporal reprojection
TemporalEffectsTypes.h — 348 LOC — Type definitions for temporal effects: enums, settings structs, jitter generation, frame history
TemporalTypes.h — 338 LOC — Settings, enums, jitter generation, and helper types for temporal effects
TerrainRenderer.cpp — 398 LOC — Engine-level terrain renderer — heightmap mesh generation and GPU rendering
TerrainRenderer.h — 182 LOC — Engine-level terrain rendering for ECS TerrainComponent entities
TextureCompressor.cpp — 491 LOC — GPU texture compression implementation
TextureCompressor.h — 152 LOC — GPU texture compression pipeline (BC1/BC7/ASTC)
TextureEviction.cpp — 419 LOC — Cache eviction and VRAM management: LRU scoring, eviction policy,
TextureStreaming.cpp — 192 LOC — Async texture streaming: streaming queue, priority management, background
TextureSystem.h — 449 LOC — Advanced texture loading and management system for Spark Engine
TextureSystemLinux.cpp — 387 LOC — CPU-portable texture system logic (metadata, caching, format detection)
TextureSystemLinuxTexture.cpp — 176 LOC — Texture class implementation for Linux (stb_image/tinyexr CPU-side image loading)
TextureSystemWindows.cpp — 470 LOC — TextureSystem manager, console operations, and format utilities (Windows/D3D11)
TextureSystemWindowsTexture.cpp — 303 LOC — Texture class implementation for Windows (D3D11 + WIC image loading)
TonemapColorGrading.cpp — 541 LOC — Auto-exposure, tonemapping, and color grading implementation
TonemapColorGrading.h — 203 LOC — Tonemapping, auto-exposure, and color grading post-processing
UICompositor.h — 244 LOC — Compositor stack with pooled render targets for per-element UI effects
UpscalingShaders.h — 690 LOC — Inline HLSL compute shader source strings for the upscaling system
UpscalingSystem.cpp — 483 LOC — CPU-side upscaling utilities: Halton jitter, DLL detection, resolution calculation, mode/quality names
UpscalingSystem.h — 656 LOC — Upscaling integration: FSR 1.0/2.0, DLSS, XeSS
UpscalingSystemWindows.cpp — 441 LOC — GPU-side upscaling implementation: D3D11 resource creation, shader compilation, execute dispatches
UpscalingSystemWindowsExecute.cpp — 194 LOC — Per-backend upscaling Execute dispatches (FSR1, FSR2, DLSS, XeSS, SparkSR)
UpscalingSystemWindowsInternal.h — 30 LOC — Shared Windows-only UpscalingUtils declarations for the UpscalingSystemWindows*.cpp split parts
UpscalingTypes.h — 352 LOC — Type definitions for the upscaling system: enums, structs, constants
VRAMBudgetMonitor.cpp — 169 LOC — GPU memory budget monitoring implementation
VRAMBudgetMonitor.h — 109 LOC — GPU memory budget monitoring via DXGI adapter queries
VirtualTexture.cpp — 290 LOC — Implementation of virtual texture page cache management
VirtualTexture.h — 150 LOC — Virtual texturing with feedback-driven page streaming
VolumeSystem.h — 509 LOC — Spatial parameter blending system (Unity-inspired Volume framework)
VolumetricClouds.cpp — 485 LOC — CPU reference / GPU feeder for the volumetric cloud layer
VolumetricClouds.h — 218 LOC — Ray-marched volumetric cloud system with procedural noise coverage
VoxelConeTracing.h — 475 LOC — Voxel Cone Traced Global Illumination (VCTGI) for D3D11
WaterRenderer.cpp — 405 LOC — Implementation of Gerstner wave water surface simulation
WaterRenderer.h — 269 LOC — Water surface rendering with Gerstner wave simulation
WeatherSystem.h — 479 LOC — Dynamic weather simulation with rain, snow, fog, and storm effects
WorldBasicRenderer.cpp — 477 LOC
WorldBasicRenderer.h — 71 LOC — Per-path cache of device-loaded meshes for generic ECS rendering.

`SparkEngine/Source/Input/`

GamepadInput.cpp — 444 LOC
GamepadInput.h — 484 LOC — Xbox controller / gamepad input support via XInput
InputActionSystem.h — 530 LOC — Data-driven input action system with rebindable controls
InputBindings.cpp — 293 LOC — Implementation of the input binding, preset, and accessibility system
InputBindings.h — 236 LOC — Runtime input rebinding, presets, and accessibility features
InputManager.cpp — 971 LOC — Input handling implementation — shared logic + platform-specific backends
InputManager.h — 475 LOC — Comprehensive input handling system with console integration
InputTypes.h — 19 LOC — Shared input type definitions
PlatformInput.h — 501 LOC — Cross-platform input abstraction with action mapping and backend factory

`SparkEngine/Source/Physics/`

CharacterController.cpp — 242 LOC — Jolt CharacterVirtual wrapper implementation
CharacterController.h — 161 LOC — Jolt CharacterVirtual wrapper for game character movement
ClothSimulation.cpp — 372 LOC — Implementation of the position-based cloth and soft body simulation
ClothSimulation.h — 268 LOC — Position-based cloth and soft body simulation
CollisionSystem.cpp — 710 LOC
CollisionSystem.h — 438 LOC — Comprehensive 3D collision detection and physics system
IPhysicsBackend.h — 157 LOC — Abstract physics backend interface for swappable physics engines
JoltWarningRestore.h — 39 LOC — Re-enables important compiler warnings after JPH_SUPPRESS_WARNINGS
PhysicsBody.h — 203 LOC — PhysicsBody and PhysicsConstraint wrapper classes
PhysicsBodyImpl.cpp — 556 LOC — PhysicsBody and PhysicsConstraint method implementations
PhysicsConsoleOps.cpp — 376 LOC — Console integration methods for PhysicsSystem
PhysicsConstraints.cpp — 581 LOC — Constraint creation and removal for PhysicsSystem
PhysicsDebugRenderer.cpp — 34 LOC — Debug visualization data collector for Jolt Physics
PhysicsDebugRenderer.h — 80 LOC — Debug visualization for Jolt Physics
PhysicsMotorControl.cpp — 104 LOC — Constraint motor control and removal for PhysicsSystem
PhysicsShapeFactory.cpp — 376 LOC — Collision shape creation for Jolt Physics
PhysicsSpatialQueries.cpp — 237 LOC — Raycasting and overlap queries for PhysicsSystem
PhysicsSpatialQueriesCasts.cpp — 144 LOC — Shape cast (sweep) tests for PhysicsSystem
PhysicsSpatialQueriesFiltered.cpp — 212 LOC — Layer-mask filtered raycast and overlap queries for PhysicsSystem
PhysicsSpatialQueriesInternal.h — 75 LOC — Shared internal helpers for the PhysicsSystem spatial-query translation units
PhysicsSystem.cpp — 823 LOC — Core PhysicsSystem lifecycle, simulation loop, and collision processing
PhysicsSystem.h — 797 LOC — PhysicsSystem class and umbrella include for the physics subsystem
PhysicsSystemQueries.cpp — 742 LOC — Body lifecycle, debug rendering, materials, metrics, buoyancy, state
PhysicsSystemStub.cpp — 871 LOC — No-op implementation of PhysicsSystem when Jolt Physics is unavailable.
PhysicsTypes.h — 828 LOC — Physics type definitions, enums, descriptors, and utility functions.
RagdollSystem.cpp — 210 LOC — Jolt ragdoll wrapper implementation
RagdollSystem.h — 148 LOC — Jolt ragdoll wrapper for physics-driven skeletal animation
SoftBodyPhysics.cpp — 377 LOC — Jolt soft body wrapper implementation
SoftBodyPhysics.h — 199 LOC — Jolt soft body wrapper for cloth, ropes, and deformable objects
VehiclePhysics.cpp — 333 LOC — Jolt vehicle physics wrapper implementation
VehiclePhysics.h — 121 LOC — Jolt vehicle physics wrapper for wheeled, tracked, and motorcycle vehicles

`SparkEngine/Source/SceneManager/`

ReflectedSceneSerializer.cpp — 310 LOC
ReflectedSceneSerializer.h — 23 LOC — Reflection-driven JSON scene serialization for World objects.
SceneConfigDatabase.h — 162 LOC — Per-scene configuration override database
SceneManager.cpp — 917 LOC
SceneManager.h — 600 LOC — Scene management with serialization, hierarchy, and prefab support
SceneManagerTypes.h — 229 LOC — Type definitions, enums, and structs used by SceneManager

`SparkEngine/Source/`

SparkPCH.h — 68 LOC — Precompiled header for SparkEngine (R9.2 — Architecture Analysis)

`SparkEngine/Source/Utils/`

AlignedHeapArray.h — 212 LOC — SIMD-aligned heap arrays with move semantics
AngleUtils.h — 85 LOC — Constexpr angle arithmetic helpers (normalize, delta, lerp)
Assert.cpp — 354 LOC — Implementation of assertion failure handlers with optional suppression
Assert.h — 369 LOC — Comprehensive assertion and verification macro system for Spark Engine
AssetServiceClient.cpp — 99 LOC — Implementation of the typed Asset service client wrapper.
AssetServiceClient.h — 74 LOC — Engine-side wrapper for the SparkDaemon Asset service.
AssetServiceProtocol.h — 230 LOC — Wire format for the SparkDaemon Asset service (ServiceId::Asset).
AssetStallDetector.cpp — 196 LOC — Asset loading stall detection — timeout tracking and queue monitoring
AssetStallDetector.h — 152 LOC — Monitors asset loading pipeline for stalled or excessively slow requests
AtomicSharedPtr.h — 113 LOC — Lock-free atomic shared pointer wrapper
BenchmarkFramework.cpp — 238 LOC
BenchmarkFramework.h — 124 LOC — Performance regression benchmark framework with baseline comparison
BenchmarkFrameworkBaseline.cpp — 298 LOC — Baseline persistence and regression comparison for BenchmarkFramework
BitFlags.h — 167 LOC — Type-safe bitwise operations for enum class flags
BitUtils.h — 111 LOC — Constexpr bit manipulation utilities wrapping C++20
CacheDebugger.h — 402 LOC — Generic cache performance tracking and efficiency analysis
ChromeTracing.h — 212 LOC — Chrome tracing (chrome://tracing) JSON exporter
ColorUtils.h — 310 LOC — Color manipulation utilities for Spark Engine
CompressionUtils.cpp — 165 LOC — Unified compression implementation dispatching to miniz and zstd
CompressionUtils.h — 56 LOC — Unified compression API supporting multiple algorithms (miniz deflate, zstd)
ConfigParser.cpp — 33 LOC — Out-of-line ConfigParser methods that depend on LocalFileCache
ConfigParser.h — 323 LOC — INI-style configuration file parser
ConsoleProcessManager.cpp — 497 LOC — ConsoleProcessManager — manages the external SparkConsole subprocess.
ConsoleProcessManager.h — 123 LOC — Launches and communicates with the external SparkConsole subprocess via pipes.
ConsoleProcessManagerLinux.cpp — 8 LOC — Formerly the Linux/macOS implementation of ConsoleProcessManager.
ConsoleProcessManagerStub.cpp — 8 LOC — Formerly the unsupported-platform stub for ConsoleProcessManager.
ConsoleProcessManagerWin32.cpp — 8 LOC — Formerly the Windows implementation of ConsoleProcessManager.
ConsoleSink.cpp — 82 LOC — Logger-to-SimpleConsole bridge implementation
ConsoleSink.h — 55 LOC — Logger sink that bridges the unified Logger to SimpleConsole
ConsoleVariable.h — 457 LOC — Typed Console Variable (CVar) system for runtime configuration
ContainerUtils.h — 130 LOC — Safe container lookup and mutation helpers
Cooldown.h — 200 LOC — Reusable cooldown timer for gameplay, AI, and ability systems
CpuDebugger.h — 455 LOC — Per-section CPU timing with statistical analysis and hotspot detection
CrashHandler.cpp — 1469 LOC
CrashHandler.h — 118 LOC — Unhandled-exception crash handler with minidump generation and upload
CrashHandlerStub.cpp — 28 LOC — No-op fallbacks for CrashHandler when CrashHandler.cpp is excluded
CrashReportUploader.cpp — 1214 LOC — GitHub crash report upload implementation (extracted from CrashHandler)
CrashReportUploader.h — 136 LOC — Multi-backend crash report upload (GitHub, Dropbox, FTP, HTTP, proxy)
D3DUtils.cpp — 92 LOC
D3DUtils.h — 90 LOC — Global DirectX 11 device, context, and swap chain accessors
DaemonClient.cpp — 269 LOC — Implementation of DaemonClient — connect, send, receive.
DaemonClient.h — 113 LOC — Engine-side client for the SparkDaemon IPC foundation (Phase 1).
DaemonConnection.cpp — 76 LOC — Implementation of the process-wide DaemonConnection singleton.
DaemonConnection.h — 88 LOC — Process-wide accessor for the engine's DaemonClient.
DaemonDiagnostics.cpp — 164 LOC — Implementation of the daemon stats formatter (see header).
DaemonDiagnostics.h — 79 LOC — Human-readable formatter for the SparkDaemon state.
DaemonFraming.h — 309 LOC — Shared low-level framing helpers for SparkDaemon IPC.
DaemonLifecycle.cpp — 499 LOC — Engine-side startup/shutdown glue for SparkDaemon (see header).
DaemonLifecycle.h — 45 LOC — Engine-side startup/shutdown glue for the SparkDaemon IPC layer.
DaemonProtocol.h — 226 LOC — Wire format and shared constants for SparkDaemon IPC.
DeadlockDetector.cpp — 265 LOC — Wait-for graph deadlock detection implementation
DeadlockDetector.h — 198 LOC — Debug-mode deadlock detection via wait-for graph analysis
DebugDraw.h — 496 LOC — 3D debug shape rendering system for runtime visualization
DebugHookManager.cpp — 228 LOC — Implementation of the project-wide debugging hook system
DebugHookManager.h — 447 LOC — Project-wide debugging hook system for engine instrumentation
DebugOverlay.h — 413 LOC — Lightweight in-game debug HUD overlay
DeferredDeletion.h — 96 LOC — Collect-now, process-later deferred queue for end-of-frame deletion
Delegate.h — 112 LOC — Lightweight multicast delegate for local one-to-many callbacks
DeltaSmoother.h — 115 LOC — Frame time smoothing to reduce jitter in game systems
EntityEventBus.h — 333 LOC — Per-entity event dispatch (O3DE ById-inspired)
EventBus.h — 337 LOC — Type-safe publish/subscribe event bus with RAII subscription handles
Expected.h — 116 LOC — Feature-test bridge for std::expected (C++23).
FileLogger.h — 449 LOC — File-based logging system integrated with SparkError
FileUtils.cpp — 3 LOC
FileUtils.h — 277 LOC — File I/O and path manipulation utilities

`SparkEngine/Source/Utils/FileWatcher/`

FileWatcher.h — 463 LOC — File and directory change notification system

`SparkEngine/Source/Utils/`

FrameAllocator.h — 170 LOC — Per-frame linear (bump) allocator
FrameInspector.h — 409 LOC — Frame stepping and state inspection tool
FreezeDetector.cpp — 297 LOC — Watchdog thread implementation for main-loop freeze detection and recovery
FreezeDetector.h — 205 LOC — Watchdog thread that detects main-loop freezes and attempts recovery
GPUPerfCounters.h — 250 LOC — Categorized GPU performance counter tracking
GPUResourceLeakDetector.cpp — 254 LOC — GPU resource lifecycle tracking — leak detection and budget monitoring
GPUResourceLeakDetector.h — 162 LOC — Tracks GPU resource lifecycle to detect leaks and budget violations
GPUStallProfiler.h — 237 LOC — CPU-GPU timeline analysis and bottleneck detection
GameplayDebugger.h — 405 LOC — Structured in-world gameplay debugging with category-based visualization
GoldenImageTest.h — 559 LOC — Golden image / screenshot regression testing framework
Hash.h — 50 LOC — Compile-time and runtime hash utilities for strings and composite keys
HashCombine.h — 61 LOC — Hash-combining helpers for building composite hash values
HashFNV1a.h — 195 LOC — FNV-1a hashing (32-bit and 64-bit) with constexpr support and hash literals
HashTransparentString.h — 66 LOC — Transparent string hash/equality functors for heterogeneous map lookup
HitchDetector.cpp — 227 LOC — Frame hitch detection — rolling average analysis and spike classification
HitchDetector.h — 144 LOC — Detects frame-time spikes (micro-stutters) above rolling average thresholds
IODebugger.h — 407 LOC — File I/O operation tracking, bandwidth analysis, and bottleneck detection
InGameConsole.h — 507 LOC — In-game developer console overlay (Quake-style drop-down console)
InvalidStateDetector.cpp — 550 LOC — Runtime detection of impossible/contradictory ECS component state combinations
InvalidStateDetector.h — 193 LOC — Runtime detection of impossible/contradictory ECS component state combinations
JobSystem.h — 285 LOC — Simple thread pool for parallel work dispatch
JsonUtils.h — 1087 LOC — Minimal self-contained JSON parser and serializer
LocalFileCache.h — 451 LOC — In-memory file cache with LRU eviction for local file I/O
LockFreeRingAllocator.h — 155 LOC — Lock-free ring buffer allocator for producer-consumer patterns
LogMacros.h — 210 LOC — Unified logging macros for Spark Engine
Logger.cpp — 645 LOC — Unified logging system implementation
Logger.h — 586 LOC — Unified logging system for Spark Engine
MathUtils.cpp — 247 LOC
MathUtils.h — 504 LOC — Mathematics utility library for Spark Engine
MathUtilsExtended.cpp — 164 LOC
MathUtilsExtended.h — 276 LOC — Extended mathematics utilities for Spark Engine
MemoryDebugger.h — 458 LOC — Memory leak detection, allocation tracking, and corruption detection
MemoryMonitor.cpp — 687 LOC — Proactive runtime memory health monitoring implementation
MemoryMonitor.h — 288 LOC — Proactive runtime memory health monitoring and anomaly detection
MultiISA.h — 152 LOC — Multi-ISA function dispatch for CPU hot paths
NetworkHealthMonitor.cpp — 292 LOC — Network health monitoring — RTT/loss tracking and health state classification
NetworkHealthMonitor.h — 176 LOC — Monitors network connection quality with health state classification
ObjectPool.h — 154 LOC — Fixed-capacity object pool with optional thread safety
Octree.h — 535 LOC — Loose octree for spatial partitioning and fast broad-phase queries
OpaqueHandle.h — 117 LOC — Type-safe opaque handle wrapper for subsystem-managed pointers
PasswordHash.cpp — 345 LOC — Self-contained SHA-256, HMAC-SHA256, and PBKDF2 password hashing.
PasswordHash.h — 25 LOC — Portable PBKDF2-HMAC-SHA256 password hashing helpers.
PerformanceStats.h — 331 LOC — Real-time performance monitoring and statistics collection
Process.h — 160 LOC — Cross-platform subprocess spawning with optional stdin/stdout/stderr piping.
ProcessLinux.cpp — 490 LOC — Linux/macOS implementation of Spark::Process
ProcessPipeBuffer.h — 48 LOC — Bounded buffering policy shared by platform Process implementations.
ProcessStub.cpp — 107 LOC — Fallback stubs for platforms without subprocess support.
ProcessWin32.cpp — 145 LOC — Windows implementation of Spark::Process
ProcessWin32Internal.h — 130 LOC — Shared Windows-only Process::Impl definition for the ProcessWin32*.cpp split parts
ProcessWin32JobPolicy.h — 23 LOC — Testable lifetime policy for Win32 child-process job assignment.
ProcessWin32Launch.cpp — 329 LOC — Windows implementation of Spark::Process::Builder (configuration and launch)
ProfileProperties.cpp — 118 LOC — Implementation of frame-resetting typed profile properties
ProfileProperties.h — 126 LOC — Typed profile properties that auto-reset each frame
Profiler.cpp — 457 LOC — Frame profiling and performance analysis implementation
Profiler.h — 355 LOC — Frame profiling and performance analysis system
Quantization.cpp — 184 LOC — Shared implementations of smallest-three 48-bit quaternion packing
Quantization.h — 58 LOC — Low-precision packing for transforms: smallest-three 48-bit quaternions
RandomEngine.h — 263 LOC — Thread-safe random number generation with modern C++ distributions
Result.h — 151 LOC — Type-safe error handling via Result
RingBuffer.h — 188 LOC — Generic fixed-size and dynamic ring buffer templates
ScheduledCallback.h — 189 LOC — Time-delayed and repeating callback scheduler
ScopeGuard.h — 285 LOC — RAII scope-exit guards that execute cleanup code on scope exit
ScopedTimer.h — 103 LOC — RAII-based scoped timing utility for quick performance measurements
SecureMemory.h — 119 LOC — Small, portable helpers for promptly erasing live credential buffers.
SecureRandom.cpp — 88 LOC — Operating-system-backed cryptographic random byte generation.
SecureRandom.h — 17 LOC — Operating-system-backed cryptographic random byte generation.
Serializer.h — 349 LOC — Lightweight binary serialization and deserialization utilities
ShaderServiceClient.cpp — 86 LOC — Implementation of the typed Shader service client wrapper.
ShaderServiceClient.h — 71 LOC — Engine-side wrapper for the SparkDaemon Shader service.
ShaderServiceProtocol.h — 194 LOC — Wire format for the SparkDaemon Shader service (ServiceId::Shader).
SparkConsole.cpp — 747 LOC
SparkConsole.h — 220 LOC — Thread-safe in-engine log sink and command registry
SparkError.h — 465 LOC — Comprehensive error handling, bounds checking, and verbose diagnostics for Spark Engine
SplineMath.cpp — 140 LOC — Implementation of static spline math utility functions
SplineMath.h — 155 LOC — Static spline math utility functions for Spark Engine
SplinePath.cpp — 358 LOC — Implementation of SplinePath — reusable spline path evaluation
SplinePath.h — 156 LOC — Reusable spline path class for Spark Engine
StackTrace.h — 364 LOC — Portable stack trace capture utility for diagnostics and logging
StateMachine.h — 296 LOC — Generic template-based finite state machine with enter/update/exit callbacks
StringPool.h — 160 LOC — String interning for O(1) equality comparison of repeated names
StringUtils.h — 290 LOC — String manipulation utilities for Spark Engine
Telemetry.h — 548 LOC — Runtime telemetry and analytics with privacy-first design
ThreadDebugger.h — 498 LOC — Thread lifecycle tracking, mutex contention monitoring, and deadlock detection
ThreadSafeQueue.h — 153 LOC — Lock-based thread-safe queue for producer/consumer patterns
Timer.cpp — 70 LOC
Timer.h — 118 LOC — High-precision timing system for frame rate and delta time calculation
TimerManager.h — 324 LOC — Centralized gameplay timer service with named timers
TinyObjImpl.cpp — 14 LOC
Tween.h — 455 LOC — Tweening and easing library for smooth property interpolation
TypeTraits.h — 283 LOC — C++23 concept shorthands and compile-time type utilities
UUID.h — 122 LOC — Lightweight unique identifier generation
Validate.h — 523 LOC — Project-wide validation, defensive programming, and diagnostic logging utilities
VersionedHandle.h — 157 LOC — Generational index handle for detecting stale references
WineDetection.cpp — 255 LOC — Wine runtime detection via ntdll.dll::wine_get_version, and
WineDetection.h — 101 LOC — Detect whether a Windows build is running under Wine (and whether
WorkSema.h — 122 LOC — Spin-before-sleep work queue semaphore

`SparkSDK/Include/Spark/`

EventTypes.h — 28 LOC — Event system usage guide and forward declarations for game modules
IEngineContext.h — 332 LOC — Service locator interface for accessing engine subsystems
ILogger.h — 71 LOC — Logging interface for game modules
IModule.h — 186 LOC — Module interface for dynamically loaded game/gameplay modules
InputTypes.h — 94 LOC — Input type definitions for game modules
MathTypes.h — 113 LOC — Common math type definitions for game modules
ModuleABI.h — 201 LOC — Pre-instantiation compatibility contract for dynamic Spark modules
ModuleDllMain.h — 121 LOC — Standard DllMain entry point for Spark module DLLs.
ModuleRegistry.h — 64 LOC — Helper macros for implementing and exporting modules
ModuleRuntimeInjection.h — 20 LOC — Public declaration for the module-local runtime injection bridge.
PluginABI.h — 185 LOC — Stable, versioned C ABI for tooling and runtime plugins.
ServiceInterfaces.h — 46 LOC — Thin service interfaces for context-driven dependency injection.
SparkExport.h — 42 LOC — DLL export/import macros for the Spark Engine module system
SparkSDK.h — 29 LOC — Master include for the Spark Engine SDK
Version.h — 51 LOC — SparkEngine SDK version information and compatibility checks

`SparkShaderCompiler/src/`

main.cpp — 588 LOC — SparkShaderCompiler - Standalone offline shader compilation tool

`Tests/Fixtures/`

GatewayTopologyProbe.cpp — 198 LOC — Black-box client for the production SparkGateway local ingress API.

`Tests/Fixtures/ModuleABI/`

`Tests/Fixtures/PluginABI/`

ForwardMinorPlugin.cpp — 56 LOC
ValidPlugin.cpp — 92 LOC

`Tests/Integration/`

TestSubsystemIntegrationScenarios.cpp — 532 LOC — Integration scenarios that boot real engine subsystems and validate cross-system behavior.

`Tests/PackageSmoke/`

main.cpp — 42 LOC
module_header_smoke.cpp — 7 LOC

`Tests/Teardown/`

DebugHookTeardownProbe.cpp — 15 LOC — Process-boundary regression probe for debug-hook static lifetime.

`Tests/`

TestAIBehaviorTree.cpp — 284 LOC
TestAIBudgetLimiter.cpp — 50 LOC
TestAIDebugRenderer.cpp — 187 LOC
TestAIDebugRendererPhaseDD.cpp — 142 LOC — Phase DD Theme 3D tests for Spark::AI::AIDebugRenderer
TestAIDebugRendererReal.cpp — 102 LOC — Real-class tests for Spark::AI::AIDebugRenderer and DebugDrawOptions
TestAIDirector.cpp — 91 LOC
TestAIDirectorPhaseII.cpp — 94 LOC — Phase II Theme 3D tests for Spark::AI::AIDirector
TestAIIntegratedSystem.cpp — 167 LOC — Real-class tests for Spark::AI::AIIntegratedSystem after its
TestAIStress.cpp — 822 LOC
TestAbilitySystem.cpp — 730 LOC
TestAbilitySystemReal.cpp — 144 LOC — Real-class tests for Spark::Gameplay::AbilitySystem (registration/query API)
TestAccessibility.cpp — 262 LOC
TestAchievementSystem.cpp — 218 LOC
TestAchievementSystemReal.cpp — 146 LOC — Real-class tests for Spark::Gameplay::AchievementSystem
TestAdvancedAssetPipeline.cpp — 354 LOC — Production-linked completion, cancellation, and fail-closed tests.
TestAdversarialEngine.cpp — 1801 LOC
TestAlignedHeapArray.cpp — 160 LOC — Tests for SIMD-aligned heap memory arrays
TestAlignedHeapArrayReal.cpp — 66 LOC — Real-class tests for Spark::FixedHeapArray and DynamicHeapArray
TestAngelScriptEngine.cpp — 487 LOC
TestAngleUtils.cpp — 129 LOC
TestAngleUtilsReal.cpp — 62 LOC — Real-class tests for Spark::AngleUtils (replacing fake-coverage TestAngleUtils.cpp)
TestAnimNotify.cpp — 177 LOC
TestAnimationCompression.cpp — 226 LOC
TestAnimationCompressionReal.cpp — 82 LOC — Real-class tests for Spark::Animation::AnimationCompressor
TestAnimationPhysicsIntegration.cpp — 148 LOC — Integration tests for animation + physics interaction patterns
TestAnimationRetargeting.cpp — 162 LOC — Tests for Spark::Animation::AnimationRetargeting
TestAnimationStress.cpp — 583 LOC
TestAnimationSystem.cpp — 895 LOC
TestAreaAssetLoader.cpp — 468 LOC
TestAreaSimulationHook.cpp — 123 LOC — Tests for the AreaServer IAreaSimulation plug-in hook
TestAssertSuppression.cpp — 138 LOC
TestAssertSuppressionReal.cpp — 103 LOC — Real-class tests for Assert.h suppression API
TestAssetDatabase.cpp — 213 LOC
TestAssetDependencyGraph.cpp — 411 LOC
TestAssetMigration.cpp — 247 LOC
TestAssetMigrationPhaseEE.cpp — 131 LOC — Phase EE Theme 3D tests for Spark::AssetMigrationRegistry
TestAssetPipelineCache.cpp — 490 LOC — Tests for AssetPipeline: LRU cache eviction, memory budget management,
TestAssetPipelineIntegration.cpp — 201 LOC — Integration tests for AssetPipeline lifecycle, cache, and asset type detection
TestAssetPipelineReal.cpp — 220 LOC — Real-class tests for AssetPipeline types and AssetCache
TestAssetServiceClient.cpp — 459 LOC — Loopback + persistence tests for the Phase 3a Asset service.
TestAssetStallDetector.cpp — 312 LOC — Tests for the AssetStallDetector loading pipeline monitor
TestAssetValidator.cpp — 149 LOC
TestAsyncComputeScheduler.cpp — 194 LOC
TestAsyncComputeSchedulerPhaseCC.cpp — 186 LOC — Phase CC Theme 3D tests for Spark::Graphics::AsyncComputeScheduler
TestAsyncDatabase.cpp — 383 LOC
TestAsyncDatabaseRegressions.cpp — 122 LOC
TestAtomicSharedPtr.cpp — 127 LOC
TestAtomicSharedPtrReal.cpp — 95 LOC — Real-class tests for Spark::AtomicSharedPtr
TestAudioBackendFactory.cpp — 102 LOC — Verifies platform-specific audio backend selection
TestAudioEngine.cpp — 478 LOC
TestAudioMixerBus.cpp — 523 LOC — Tests for AudioMixer: bus hierarchy, volume cascading, mute/solo,
TestAutoLODPerformance.cpp — 159 LOC
TestBVHAccelerator.cpp — 255 LOC — Phase L — tests for the BVHAccelerator orphan
TestBehaviorTreeNodes.cpp — 247 LOC
TestBenchmarkFramework.cpp — 364 LOC — Get a cross-platform temporary file path for tests
TestBitFlags.cpp — 131 LOC
TestBitFlagsReal.cpp — 67 LOC — Real-class tests for Spark::BitFlags
TestBitUtils.cpp — 131 LOC
TestBitUtilsReal.cpp — 99 LOC — Real-class tests for Spark::BitUtils (replacing fake-coverage TestBitUtils.cpp)
TestBlendSpace.cpp — 161 LOC
TestBlendSpaceReal.cpp — 61 LOC — Real-class tests for Spark::Animation::BlendSpace2D
TestCSGEditorPanel.cpp — 282 LOC
TestCSGSystem.cpp — 158 LOC
TestCacheDebuggerPhaseFF.cpp — 126 LOC — Phase FF Theme 3D tests for Spark::CacheDebugger
TestCachedShadowAtlas.cpp — 275 LOC — Phase M — CPU reference tests for CachedShadowAtlas
TestCameraInterpolation.cpp — 198 LOC
TestCameraTransforms.cpp — 612 LOC — Tests for SparkEngineCamera: pitch clamping, matrix updates,
TestChromeTracing.cpp — 83 LOC — Tests for Spark::ChromeTracing profiler
TestClientPrediction.cpp — 301 LOC — Tests for Spark::ClientPrediction
TestClothSimulation.cpp — 196 LOC — Tests for Spark::Physics::ClothSimulation
TestClusteredLightGPU.cpp — 143 LOC
TestCollaborativeEditing.cpp — 539 LOC — Tests for the collaborative editing system
TestCollisionAvoidance.cpp — 216 LOC
TestCollisionLayers.cpp — 184 LOC
TestCollisionSystem.cpp — 270 LOC
TestColorUtils.cpp — 149 LOC
TestColorUtilsReal.cpp — 60 LOC — Real-class tests for Spark::ColorUtils namespace
TestCommandHistory.cpp — 312 LOC — Tests for the editor undo/redo command system
TestCommonMath.h — 78 LOC — Shared math types and comparison macros for test files
TestCompressionUtils.cpp — 90 LOC
TestCompressionUtilsReal.cpp — 78 LOC — Real-class tests for Spark::CompressionUtils functions
TestConditionSystem.cpp — 528 LOC
TestConfigParser.cpp — 219 LOC
TestConfigParserReal.cpp — 112 LOC — Real-class tests for Spark::ConfigParser
TestConnectionScope.cpp — 285 LOC
TestConnectionScopeFilter.cpp — 78 LOC
TestConnectionScopeWiring.cpp — 167 LOC — Verifies that NetworkManager and ConnectionScopeFilter are wired together
TestConnectionTimeout.cpp — 194 LOC — Tests for connection timeout detection, RTT estimation, and
TestConsoleRBAC.cpp — 375 LOC
TestConsoleVariables.cpp — 567 LOC — Tests for ConsoleVariable: CVar registration, type parsing,
TestConstantBufferDiff.cpp — 158 LOC — Tests for content-diff constant buffer upload skipping
TestConstantBufferDiffReal.cpp — 120 LOC — Real-class tests for Spark::Graphics::ConstantBufferDiffManager
TestConstantBufferRing.cpp — 109 LOC — Phase N — tests for the ConstantBufferRing orphan
TestContainerUtils.cpp — 140 LOC
TestContainerUtilsReal.cpp — 104 LOC — Real-class tests for Spark::ContainerUtils helpers
TestContracts.cpp — 68 LOC — Tests for C++26 contract bridge macros (Contracts.h)
TestCooldown.cpp — 110 LOC
TestCooldownReal.cpp — 81 LOC — Real-class tests for Spark::Cooldown and RepeatTimer
TestCoreAndBuildSystems.cpp — 480 LOC — Tests for untested core, build, and mobile subsystems
TestCoroutineScheduler.cpp — 336 LOC — Tests for the gameplay coroutine/task scheduler
TestCoverSystem.cpp — 191 LOC
TestCoverSystemReal.cpp — 77 LOC — Real-class tests for Spark::AI::CoverSystem
TestCoverageAI.cpp — 300 LOC — Deterministic real-class coverage for production AI subsystems.
TestCoverageCamera.cpp — 192 LOC — Production coverage for SparkEngineCamera behavior and console controls.
TestCoverageScripting.cpp — 377 LOC — Production coverage for script hot reload, sandbox diagnostics, and visual compilation.
TestCpuDebuggerPhaseGG.cpp — 100 LOC — Phase GG Theme 3D tests for Spark::CpuDebugger
TestCpuNeuralInference.cpp — 389 LOC — Tests for SIMD-optimized CPU neural inference
TestCpuNeuralTraining.cpp — 415 LOC — Tests for the CPU neural-network training substrate.
TestCrashReportUploader.cpp — 185 LOC
TestCrossSystemIntegration.cpp — 395 LOC — Integration tests for cross-system interaction
TestDXRSupport.cpp — 238 LOC
TestDaemonCodexFixes.cpp — 216 LOC — Regression tests for the three Codex review findings on PR #478.
TestDaemonConcurrent.cpp — 312 LOC — Concurrent-clients and stats-request tests for SparkDaemon.
TestDaemonDiagnostics.cpp — 161 LOC — Unit tests for the SparkDaemon stats formatter.
TestDaemonFoundation.cpp — 227 LOC — End-to-end loopback test for the Phase 1 daemon foundation.
TestDaemonLRU.cpp — 435 LOC — LRU eviction tests for the shader and asset cache services.
TestDaemonLifecycle.cpp — 449 LOC — Tests for the engine-side daemon lifecycle helper.
TestDaemonProtocol.cpp — 184 LOC — Codec tests for the SparkDaemon wire format (frame header + whole-frame round-trip).
TestDataTableSystem.cpp — 151 LOC
TestDatablockRegistry.cpp — 155 LOC
TestDatablockRegistryPhaseHH.cpp — 134 LOC — Phase HH Theme 3D tests for Spark::Net::DatablockRegistry
TestDayNightCycle.cpp — 258 LOC
TestDeadlockDetector.cpp — 341 LOC — Tests for the DeadlockDetector wait-for graph system
TestDebugHookManager.cpp — 649 LOC — Unit tests for Spark::DebugHookManager
TestDebugTools.cpp — 657 LOC — Unit tests for the enhanced debugging utilities
TestDebugUtilities.cpp — 557 LOC — Unit tests for CpuDebugger, CacheDebugger, IODebugger, and ThreadDebugger
TestDecalSystem.cpp — 88 LOC
TestDedicatedServer.cpp — 729 LOC
TestDedicatedServerProcessController.cpp — 69 LOC — Focused editor-to-SparkServer argument and packaging tests.
TestDedicatedServerRuntime.cpp — 331 LOC
TestDeferredDeletion.cpp — 162 LOC
TestDeferredDeletionReal.cpp — 72 LOC — Real-class tests for Spark::RHI::DeferredDeletionQueue
TestDeferredQueue.cpp — 110 LOC
TestDelegate.cpp — 143 LOC
TestDelegateReal.cpp — 107 LOC — Real-class tests for Spark::Delegate<Args...>
TestDeltaSmoother.cpp — 88 LOC
TestDeltaSmootherReal.cpp — 74 LOC — Real-class tests for Spark::DeltaSmoother
TestDenoiserInterface.cpp — 358 LOC — Phase Q — CPU reference tests for SoftwareDenoiser / IDenoiser
TestDescriptorCache.cpp — 134 LOC
TestDestructionSystem.cpp — 83 LOC — Tests for Spark::DestructionSystem and DestructibleComponent
TestDialogueStress.cpp — 359 LOC
TestDialogueSystem.cpp — 281 LOC — Tests for Spark::DialogueSystem
TestDirectStorageLoader.cpp — 234 LOC
TestDirectionalStreaming.cpp — 150 LOC — Tests for the directional preload bias in SeamlessAreaManager
TestDirtyRectTracker.cpp — 159 LOC — Tests for dirty rectangle tracking for partial texture updates
TestDirtyRectTrackerReal.cpp — 123 LOC — Real-class tests for Spark::Graphics::DirtyRectTracker
TestDirtyRegionGridPhaseDD.cpp — 174 LOC — Phase DD Theme 3D tests for Spark::UI::DirtyRegionGrid
TestDrawIndirect.cpp — 176 LOC
TestDynamicQualityScalerPhaseBB.cpp — 234 LOC — Phase BB Theme 3D tests for Spark::Graphics::DynamicQualityScaler
TestDynamicResponseSystem.cpp — 186 LOC
TestECSIntegration.cpp — 511 LOC — End-to-end ECS integration tests (R10.1 — Architecture Analysis)
TestECSStress.cpp — 275 LOC
TestECSWorld.cpp — 152 LOC
TestECSystemOrdering.cpp — 521 LOC — Tests for ECS SystemManager: system registration, execution ordering,
TestECSystemSpecialized.cpp — 862 LOC — Tests for specialized ECS systems: Decal, Projectile, Spline, Ability, Particle
TestECSystemsReal.cpp — 257 LOC — Real-class tests for ECS SystemManager and ISystem interface
TestEcsCameraConsole.cpp — 42 LOC
TestEditorAutomation.cpp — 228 LOC
TestEditorCommands.cpp — 321 LOC
TestEditorDocumentTransition.cpp — 83 LOC
TestEditorLayoutManager.cpp — 461 LOC — Tests for editor layout management
TestEditorSubsystems.cpp — 2745 LOC — Tests for editor subsystems that operate without ImGui or GPU
TestEditorWindowManager.cpp — 349 LOC
TestEngineBootPlatforms.cpp — 496 LOC — Tests for engine boot sequence across platforms
TestEngineContext.cpp — 609 LOC
TestEngineDiagnostics.cpp — 179 LOC — Runs the runtime diagnostics against live singleton subsystems.
TestEngineInterfaceProtocol.cpp — 102 LOC — Adversarial coverage for the editor/engine event decoder.
TestEngineLifecycle.cpp — 398 LOC — End-to-end engine lifecycle smoke tests
TestEngineLoadTest.cpp — 1720 LOC — Full engine load test — measures real CPU time, wall time, peak memory,
TestEngineMonitor.cpp — 736 LOC — Extended engine monitoring — runs subsystems for many frames,
TestEngineSettingsEdgeCases.cpp — 679 LOC — Edge-case tests for EngineSettings: boundary values, setting interactions
TestEngineSettingsParser.cpp — 731 LOC — Tests for EngineSettings: INI parsing, type conversion, default values,
TestEngineSettingsReal.cpp — 279 LOC — Real-class tests for EngineSettings singleton
TestEntityArchetype.cpp — 152 LOC
TestEntityEventBus.cpp — 187 LOC
TestEntityEventBusReal.cpp — 94 LOC — Real-class tests for Spark::EntityEventBus
TestEntityPresetManager.cpp — 236 LOC
TestEntityPresetManagerPhaseEE.cpp — 124 LOC — Phase EE Theme 3D tests for Spark::ECS::EntityPresetManager
TestEnvironmentQuery.cpp — 204 LOC — Tests for Spark::AI::EQS (Environment Query System)
TestEventBus.cpp — 226 LOC
TestEventBusReal.cpp — 100 LOC — Real-class tests for Spark::EventBus and SubscriptionHandle
TestEventResponseSystem.cpp — 440 LOC
TestEventResponseSystemPhaseEE.cpp — 122 LOC — Phase EE Theme 3D tests for Spark::Gameplay::EventResponseSystem
TestEventSystem.cpp — 242 LOC
TestExtendedSystems.cpp — 1065 LOC
TestFBXImportValidation.cpp — 85 LOC — Validation coverage for FBX importer data classes used by asset pipeline.
TestFBXImporter.cpp — 315 LOC — Tests for FBX binary format importer
TestFPSComponents.cpp — 321 LOC
TestFPSGameplayIntegration.cpp — 305 LOC — Integration tests for the FPS game module's core gameplay systems
TestFPSMultiplayer.cpp — 287 LOC — Tests for FPS multiplayer system
TestFastNoise2SIMD.cpp — 433 LOC — Phase S — CPU reference tests for FastNoise2SIMD
TestFaultIsolation.cpp — 352 LOC
TestFaultIsolationReal.cpp — 108 LOC — Real-class tests for Spark::SubsystemFaultIsolator
TestFileUtils.cpp — 447 LOC
TestFileUtilsReal.cpp — 84 LOC — Real-class tests for Spark::FileUtils namespace
TestFileWatcher.cpp — 258 LOC
TestFixtures.cpp — 61 LOC
TestFogSystem.cpp — 236 LOC
TestFoliageImpostorBaker.cpp — 371 LOC
TestFoliageRenderer.cpp — 734 LOC
TestFoliageSystem.cpp — 341 LOC
TestFontSystem.cpp — 178 LOC
TestFormationSystem.cpp — 213 LOC
TestFrameAllocator.cpp — 93 LOC — Tests for Spark::FrameAllocator
TestFramework.h — 398 LOC — Lightweight test framework for SparkEngine
TestFreezeDetector.cpp — 372 LOC — Tests for the FreezeDetector watchdog system
TestFreezeSystem.cpp — 204 LOC — Tests for tag-validated save state serialization
TestFrustumCulling.cpp — 321 LOC — Tests for frustum plane extraction and AABB/sphere visibility testing
TestFullEngineDiagnostics.cpp — 574 LOC — Comprehensive engine test — initializes ALL subsystems and runs
TestGLSLPipelineIntegration.cpp — 531 LOC — Integration tests proving the GLSL→OpenGL RHI pipeline works end-to-end
TestGLTFStaticMeshLoader.cpp — 266 LOC — CPU-only tests for the fail-closed glTF 2.0 static-mesh subset.
TestGPUClusterCulling.cpp — 185 LOC
TestGPUDrivenRenderer.cpp — 216 LOC
TestGPUDrivenRendererD3D11.cpp — 254 LOC — Production-linked ABI and live WARP coverage for GPU culling.
TestGPUParticleSystem.cpp — 233 LOC
TestGPUPerfCounters.cpp — 155 LOC — Tests for categorized GPU performance counter tracking
TestGPUProfiler.cpp — 138 LOC — Tests for GPU profiling system
TestGPUResourceLeakDetector.cpp — 342 LOC — Tests for the GPUResourceLeakDetector resource lifecycle tracker
TestGPUSkinning.cpp — 274 LOC
TestGPUStallProfiler.cpp — 109 LOC
TestGPUStallProfilerPhaseCC.cpp — 170 LOC — Phase CC Theme 3D tests for Spark::GPUStallProfiler
TestGTAOEffect.cpp — 215 LOC — Phase I — CPU reference tests for Ground Truth Ambient Occlusion
TestGameMode.cpp — 61 LOC
TestGameModeReal.cpp — 136 LOC — Real-class tests for Spark::GameMode, PlayerScore, GameModeRules, SpawnPoint
TestGameModuleMMO.cpp — 623 LOC — Tests for MMO game module character, social, world, and gameplay systems
TestGameModulePlatformerARPG.cpp — 869 LOC — Tests for Platformer and ARPG game module systems
TestGameModuleRPG.cpp — 599 LOC — Tests for SparkGameRPG module: character, combat, and quest systems
TestGameModuleRTS.cpp — 642 LOC — Tests for SparkGameRTS module: units, buildings, and resources
TestGameModuleRacing.cpp — 595 LOC — Tests for Racing game module systems: vehicle, track, and race manager
TestGameObjectTransforms.cpp — 439 LOC — Tests for GameObject: world matrix computation, direction vectors,
TestGamePackager.cpp — 156 LOC
TestGameViewPanel.cpp — 74 LOC — Play-state ownership tests for the editor Game View simulation.
TestGamepadInputProcessing.cpp — 631 LOC — Tests for GamepadInput: dead zone processing (circular vs axial),
TestGameplayDebugger.cpp — 157 LOC
[`TestGameplayExtension

Published from 16f41eb6ad5d. Edit the canonical source in wiki/.