13 Production Subsystems

The first system to initialize. Detects the current platform and loads budget configurations that all other systems enforce. Profile v2.0 introduced UPGXPlatformConfig DataAsset with 10 budget structs covering every subsystem dimension.

11 subsystems read their platform budgets from Profile during initialization. This means the same project can target mobile, console, and PC with different quality levels — entirely from DataAssets, zero code changes.

// Platform detection happens automatically
UPGXProfileSubsystem* Profile = GetSubsystem<UPGXProfileSubsystem>();
EPGXPlatform Current = Profile->GetCurrentPlatform();
FPGXAudioBudget Budget = Profile->GetAudioBudget();

Complete polymorphic observability system. v3.0 was a full rewrite across 6 phases with ~45 new files and ~4,800 lines of code. Every PGX system has its own LogPGX{System} category.

Supports multiple log backends, runtime filter configuration, and structured log output. The Log Inspector panel provides real-time filtering and search across all PGX log categories.

// Per-system log categories — no more LogTemp
UE_LOG(LogPGXSave, Log, TEXT("Domain %s saved successfully"), *DomainName);
UE_LOG(LogPGXAudio, Warning, TEXT("Sound %s not found"), *SoundTag.ToString());

Domain-based save system with checksum verification, async migration, and slot guards. Saves are organized by GameplayTag domains — each system can own its data slice without knowing about others.

Features: async save/load, round-trip verification, IPGXSaveable interface for custom objects, domain clear operations, and automatic broadcast on save completion.

// Domain-based saves — each system owns its data
Save->SetDomainValue(Tag_PlayerData, TEXT("Health"), 100);
Save->SetDomainValue(Tag_PlayerData, TEXT("Position"), PlayerPos);
Save->QuickSaveAsync(Tag_AutoSave, FOnSaveComplete::CreateLambda([](bool bOk) {
    // Handle completion
}));

Game state machine with full history, batch transitions, and revert support. States are defined as GameplayTags — fully extensible without modifying framework code.

Features: transition validation, state history with configurable depth, batch transition requests, revert to previous state, and rich delegate notifications for every state change.

// State transitions with validation
GameFlow->RequestTransition(Tag_GameState_InGame);
GameFlow->RequestBatchTransition({Tag_State_A, Tag_State_B, Tag_State_C});
GameFlow->RevertToPreviousState();

Pipeline State Object precaching manager. Activates shader compilation contexts based on gameplay state, ensuring materials are ready before the player sees them.

Features: context activation/deactivation, recording mode, pause/resume support, and integration with the Loading system for pre-level PSO warmup.

// Precache pipelines before level loads
PSO->ActivatePipeline(Tag_PSO_Combat);
PSO->PauseRecording();   // During cutscenes
PSO->ResumeRecording();  // Back to gameplay

Level transition orchestrator with sublevel management, cancel support, and resolve callbacks. Provides a clean API layer over Unreal's streaming and travel systems.

Features: level requests with transition policies, sublevel load/unload, cancel in-flight transitions, and integration with Loading for seamless screen management.

// Clean level transitions
LevelFlow->RequestLevel(TEXT("MainMenu"));
LevelFlow->LoadSubLevel(TEXT("Combat_Arena_01"));
LevelFlow->CancelTransition(); // Abort if needed

Loading screen orchestration with progress tracking, skip support, and force-close safety. Coordinates with GameFlow (knows when it's safe to transition) and PSO (waits for shader warmup).

Features: configurable loading screens via DataAsset, progress callbacks, skip handling for impatient players, and force-close with timeout.

// Show loading screen with config
Loading->ShowLoadingScreen(LoadingConfig);
Loading->RequestProgress(0.5f);
Loading->AllowSkip();
Loading->ForceClose(5.0f); // Safety timeout

Memory and Garbage Collection Observability System. The only UEngineSubsystem in PGX — runs engine-wide, not per-GameInstance. Provides GC snapshot history, memory profiling, and health metrics.

Features: GC event tracking, memory profile history, health dots visualization in the editor, and sparkline graphs for temporal trends.

// Engine-wide GC observability
// MGOS runs as UEngineSubsystem — always available
// Inspector shows: GC frequency, pause times, memory trends
// Console: pgx.mgos.status, pgx.mgos.snapshot

Dual-backend audio subsystem with 7 DataAsset types and 50+ API functions. Supports sound, music, dialogue, and ambient layers. Per-channel volume control with smooth transitions.

Features: tag-based sound playback, music crossfading, dialogue queuing, channel volume/mute, backend switching, and 20 console commands for runtime debugging.

// Rich audio API
Audio->PlaySound(Tag_SFX_Explosion);
Audio->PlayMusic(Tag_Music_Combat, /*FadeIn=*/2.0f);
Audio->PlayDialogue(Tag_Dialogue_NPC_Greeting);
Audio->SetChannelVolume(Tag_Channel_Music, 0.7f);

DataTable-first data registry with compiled wiring and cache management. v2.0 pivoted from asset scanning to DataTable entries for deterministic ordering and editor tooling.

Features: tag-based lookup with typed returns, cache statistics, validation dashboard, and Content Browser integration for browsing registered entries.

// Type-safe tag-based data lookup
UPGXItemDefinition* Item = Registry->FindByTag<UPGXItemDefinition>(Tag_Item_Sword);
TArray<UPGXItemDefinition*> Weapons = Registry->FindAllByTag<UPGXItemDefinition>(Tag_Category_Weapons);

8 DataAsset types for defining game objects, characters, levels, and more. The "box and shapes" pattern: every DA has a class slot with three modes — Default (PGX built-in), CppClass (custom C++), or Blueprint (BP class).

This is the heart of PGX's UX-first philosophy: the developer creates a DA, fills properties, optionally overrides the class, and has a working system with zero code.

// Construction DAs — The Universal Entry Point
// 1. Create UPGXCharacterConstruction in Content Browser
// 2. Set properties (health, speed, abilities)
// 3. Optionally: ClassSourceMode = Blueprint, drag your BP
// 4. Done. The system uses your class automatically.

Pub/sub message bus with FInstancedStruct payloads. Any system can broadcast messages by GameplayTag without knowing who listens. Zero coupling between sender and receiver.

Features: tag-based subscription, wildcard listeners, message statistics, and CustomThunk Blueprint nodes with morphing pins (connect any struct type inline).

// Pub/sub — zero coupling
Msg->Broadcast(Tag_Combat_Hit, FInstancedStruct::Make(DamagePayload));

// Any system can listen
Msg->Listen(Tag_Combat_Hit, FOnMessage::CreateLambda([](const FPGXMessage& M) {
    auto* Damage = M.GetPayload<FPGXDamagePayload>();
}));

Behavior resolution bus. Unlike the Message system (fire-and-forget), EventHandler events are competitive — multiple handlers can register for the same event, and only the highest-priority handler that accepts it wins.

Features: priority-based resolution, conflict policies, execution sequences, telemetry tracking, and 27 Blueprint nodes including CustomThunk morphing pins for context structs.

// Behavior resolution — handlers compete
Events->RegisterHandler(Tag_Ability_Cast, Priority_100, MyHandler);
Events->FirePGXEvent(Tag_Ability_Cast, Context);
// Handler with highest priority that returns true wins
// Others don't execute — clean conflict resolution