3D Free Grounder
Raycast-based grounder for standard 3D locomotion — detects ground contact with coyote time, applies manual gravity when airborne, switches to Slide mode on steep slopes.
Tag: Docs
3D Free Mover
Standard 3D locomotion — camera-relative movement and rotation driven by spring-damped physics, with optional slope slowdown.
Categories:
Action
The base class for triggerable actions — channel-based firing, completion broadcasting, and action chaining for lightweight behavior sequencing.
Categories:
Change Logs
Version changelogs for all GS_Play gems and documentation.
Categories:
Common Enums
Shared enumeration types used across the GS_Play framework — CurveType for easing curve selection and BooleanConditions for condition evaluation.
Categories:
Dialogue Manager
Full API reference for GS_DialogueManagerComponent — dialogue database management, performer marker registration, and the DialoguePerformerMarkerComponent.
Categories:
Game Manager
The top-level game lifecycle controller — startup sequencing, systemic navigation, standby mode, and debug support.
Categories:
List of Savers
Pre-built saver components included in GS_Core — ready-to-use entity persistence without writing code.
Categories:
GS_MotionTrack
Abstract base class for all animation tracks — fields, lifecycle, and virtual methods for domain extension.
Movement
The complete movement subsystem — movers, grounders, movement influence, and the movement profile asset for configuring unit locomotion.
Categories:
Mover Context
The central movement hub — transforms raw input into camera-relative and ground-projected vectors, manages mode switching, context states, and movement profiles.
Categories:
Options Manager
The singleton options controller — merges option profiles into a live value map, applies values through their targets, persists them, and serves the active input profile.
Categories:
Performer Manager & Skin Slots
Performer manager lifecycle, skin slot system for modular character appearance, and config profile assets.
Categories:
Pulse Types
Built-in pulse types for the Pulsor interaction system.
Categories:
Pulsors
Physics-based pulse emitter and reactor system — extensible typed interactions via polymorphic PulseType and ReactorType classes.
Categories:
Save Manager
The central save/load controller — manages save files, triggers global persistence events, and provides data access for all savers.
Categories:
Audio Signal Model
How GS audio is put together — the two-plane architecture, the roles of miniaudio, SoLoud and Steam Audio, the canonical signal chain, and the vocabulary the rest of the audio docs use.
Categories:
Stage Manager
The singleton level controller — manages a list of stages, handles level loading/unloading, and coordinates staged startup with the Stage Data component.
Categories:
Targeting Handler
Central targeting processor — receives target registrations from sensory fields, selects best interact target, and manages cursor feedback.
Categories:
Time Manager
World clock management, time-of-day control, day/night cycle detection, and per-tick time notifications.
Categories:
Trigger Sensors
Trigger sensor component and sensor types — condition evaluation objects for physics, interact, and record-based world trigger activation.
Categories:
Typewriter
Full API reference for the TypewriterComponent — character-by-character text reveal with configurable speed, force-complete, and notification events.
Categories:
UI Manager
The singleton manager that owns all loaded UI canvases, maintains a global focus stack, and drives the startup focus sequence.
Categories:
Understanding GS_Play
What is GS_Play and what does it do?
Categories:
Unit Manager
The central manager for unit lifecycle — spawning, registration, standby coordination, and unit tracking across the game session.
Categories:
Environment System
Runtime system component that drives the world clock tick and handles GS_EnvironmentRequestBus queries.
Categories:
Unit Input Reactors
The reactor types GS_Unit ships — keyboard and joypad movement, and jump — and how they drive a unit’s mover context.
Categories:
Movers
Mover base class and concrete mover components — translate MoverContext input into physics-based unit motion via named mode activation.
Categories:
SensorType_Record
Record-based sensor type — fires when a named RecordKeeper entry reaches a configured value.
Categories:
Savers
The base class for entity-level save handlers — override BuildSaveData() and ProcessLoad() to persist any component data automatically.
Categories:
Slide Mover
Slope-sliding locomotion — automatically activated when slope exceeds maxWalkAngle, drives the unit down the slope via spring-damped physics with optional input resistance and automatic recovery.
Categories:
Stage Data
The per-level anchor component — holds stage configuration, NavMesh references, and runs the level’s staged activation sequence.
Categories:
Unit Controllers
The controller-unit possession model — base controller, player controller, and AI controller components for driving unit behavior.
Categories:
Grounders
Grounder base class and concrete grounder components — detect ground contact, compute ground normals and slope data, and drive mode switching on the MoverContext.
Categories:
Input Data
The decoupled input pipeline — reading hardware events on the controller, storing state on the unit, and reacting to state changes through reactor components.
Categories:
Record Keeper
Lightweight key-value progression tracking — store and retrieve named integer records without writing a custom saver.
Categories:
Targeting
Target detection, selection, and cursor management — scanning, filtering, and selecting entities based on proximity and sensory fields.
Categories:
Senses & Targeting Fields
Physics-based detection volumes for the targeting system — interaction fields and sensory detection.
Categories:
Input Profiles
Data assets for input binding configuration — map key bindings to named events, organized into toggleable groups for advanced runtime input control.
Categories:
Page Navigation
The core single-tier navigation component – root canvas registration, nested child page management, focus push/pop stacks, and show/hide transitions.
Categories:
Player Input Reader
Controller-side component that reads hardware input events and routes them to the possessed unit’s input data component.
Categories:
Units
What makes an entity a unit — the GS_UnitComponent, entity configuration, collision setup, and links to movement subsystems.
Categories:
Audio Manager
The base audio controller — engine lifecycle, project settings, the authoritative listener, mixing channels, event libraries, and the accessors GS_AudioPro builds on.
Categories:
Buttons
Enhanced button component with motion-driven hover and select animations, built on top of LyShine interactable notifications.
Categories:
Debug Mode
The Game Manager’s Debug Mode flag — what it changes about startup, which managers respond to it, and how to branch your own systems on it.
Categories:
GS_InputOptions
The input subsystem — Input Profiles for grouped event-to-binding mappings and Input Readers for processing input in gameplay.
Categories:
Locomotion
Velocity-driven animation hooks and prefab animation asset reloading for performer entities.
Categories:
Reactor Types
Built-in reactor types for the Pulsor interaction system.
Categories:
Targets
Target component types — base target markers and specialized interact targets that make entities detectable by the targeting system.
Categories:
World Triggers
Trigger sensor and world trigger system — event-driven world state changes via composable polymorphic type objects on two container components.
Categories:
World Triggers
World trigger component and trigger types — response execution objects that change world state when a trigger sensor fires.
Categories:
Cinematics Manager
Full API reference for GS_CinematicsManagerComponent — cinematic lifecycle control, stage marker registration, and the CinematicStageMarkerComponent.
Categories:
UI Animation
GS_Motion extension with eight LyShine-specific animation tracks, data-driven .uiam assets, and a standalone playback component.
Categories:
UI Interaction
Button animations and input interception — motion-driven hover/select states and input channel management for focused UI canvases.
Categories:
Interact Input Reader
Categories:
UI Input
Input interception for UI canvases – captures and redirects input events to prevent gameplay propagation while a UI is focused.
Categories:
Widgets
Standalone UI widget components — load screens, pause menus, and other self-contained UI elements that operate outside the page navigation model.
Categories:
Audio Change Log
GS_Audio version changelog.
Categories:
Audio Events
The .aev event library and the polymorphic audio event types — file pools, procedural noise, and sfxr chiptones — with shared pooling, concurrency, spatial tracking and extension hooks.
Categories:
Audio Manager
How to set up the GS_Play Audio Manager — engine startup, volume channels, event libraries, the listener, and running it without a Game Manager.
Categories:
Cam Manager
How to work with the GS_PhantomCam manager — enabling and disabling the camera system, and responding to active camera changes.
Categories:
Cinematics Manager
How to coordinate cinematic sequences in GS_Play — beginning and ending cutscenes, registering stage markers, and reacting to cinematic events from scripts.
Categories:
Classifications
The three GS_Core contract kinds in depth — TypeBase (Strategy), Emit (Observance), and Exchange (Mediator) — each with its authoring how-to, plus the naming guard and the hoisting mechanics authors need.
Categories:
GS_Core
The foundation gem for the GS_Play framework — game lifecycle, save system, stage management, input, actions, and utility libraries.
Categories:
GS_Core
The foundation gem for the GS_Play framework — game lifecycle, save system, stage management, input, actions, motion animation system, and utility libraries.
Categories:
Descriptor & Topology
GraphSystemDescriptor fields, topology selection, and GraphContext data type registration.
Categories:
Feature List
Quick index of all GS_Play Features.
Categories:
Feedback System
Feedback motion tracks, FeedbackEmitter component, and FeedbackMotionAsset reference.
Feedback System
How to work with GS_Play feedback motions — transform and material animation effects for game feel.
GS_Managers
The game lifecycle management system — startup sequencing, systemic navigation, and the extensible manager pattern.
Categories:
Managers System
How to work with the GS_Play manager system — startup events, game navigation, and standby mode from scripts.
Categories:
Head Tracking
Procedural head look-at targeting — drives bone orientation toward a world-space target with configurable angle limits and damping.
Categories:
ImGui Debug Menu
The in-game GS_Play debug menu — a content-free anchor in GS_Core that any gem contributes its own menu to, with ordered placement and per-gem ownership.
Categories:
Input Reader
Component that reads input through the active profile and fires named gameplay events, with runtime group toggling and input claiming.
Categories:
Inventory
How to work with GS_Play inventory — container-based item storage with slots and stacking.
Categories:
Manager
The base class for all game system managers — automatic two-stage initialization and lifecycle integration with the Game Manager.
Categories:
Mix Effects
The MixEffectComponent and all 22 mix effect types — named effect chains, order-independent wiring, local and global routing, and the runtime control surface.
Categories:
GS_Motion
The playback engine — ticks through tracks, computes per-track progress windows, and manages motion lifecycle.
Performer Manager
How to work with the GS_Play Performer Manager — performer registration and lifecycle.
Categories:
PhantomCam Recipes
Step-by-step recipes for the GS_PhantomCam virtual camera system — composing cams from stages, configuring noise, tug fields, group targets, influence fields, and the channel tier system.
Categories:
PhantomCam Configurations
Step-by-step recipes for composing common camera behaviors from Body, Aim, and Additive stages on a single Phantom Camera component.
Project Quick Start
Easy set up to get started.
Categories:
Pulsors
How to work with the GS_Interaction Pulsor system — emitting typed physics-based pulse events and reacting to them from scripts.
Categories:
Settings
The GS_Options settings framework — option profiles, the four option types, apply targets, presets, persistence, and the launch-time apply path.
Categories:
Settings
How to declare player settings as data, read and write them from your game, and offer quality presets.
Categories:
Simple Project Setup
Easy set up to get started.
Categories:
Status Effects
How to work with GS_Play status effects — timed modifiers that alter entity stats or behavior.
Categories:
Time Manager
How to work with the GS_Play Time Manager — world time, day/night cycles, and time passage control.
Categories:
UI Manager
How to work with the GS_Play UI Manager — canvas lifecycle, focus stack, and cross-canvas navigation.
Categories:
Unit Manager
How to work with the GS_Unit manager — spawning units, registering player controllers, and coordinating standby across all controlled characters.
AudioPro Change Log
GS_AudioPro version changelog.
Categories:
Audio Event Graph
Visual graph editor for authoring complex sound events with filters, effects, routing, and phase lifecycle.
Categories:
Audio Events
How to author and fire audio events — event libraries, clip pools, procedural noise and chiptones, distance falloff, and concurrency.
Categories:
Avatar Performer
How to work with GS_Play avatar performers.
Avatar Performer
How to work with GS_Play avatar performers — 3D pipeline, animation, equipment.
Babble
Audio babble synchronized to dialogue typewriter output — procedural vocalization tones keyed to speaker identity.
Categories:
Channels & Instancing
Concept primer for the PhantomCam channel system — what a channel is, which authoring tier to choose, and the pitfalls to know before authoring.
Categories:
Cinematics Change Log
GS_Cinematics version changelog.
Categories:
Serialization Helpers
Three reflection helpers — single-include headers for common and asset serialization, and a generic asset handler template for custom asset types.
Categories:
SFXR Profiles
The .sfxrprofile asset — procedural chiptone sound effects as first-class assets, with sfxr.me import and randomized profile pools.
Categories:
GS_AI
Foundation scaffold for AI-driven entity behavior in the GS_Play framework.
Categories:
GS_AI
Foundation scaffold for AI controller integration in GS_Play projects. Provides the system component and extension point for custom AI controller gems.
Categories:
Cam Core
How to work with GS_CamCoreComponent — the rendering bridge that reads the dominant Phantom Camera each frame and drives the real camera entity.
Categories:
Camera Noise Configurations
Step-by-step recipes for camera shake — continuous handheld feel via PerlinNoise, event-triggered bursts via ImpulseNoise, and stacking the two.
Contract Reference
Every GS_Core contract by capability folder and producing gem — the 9 TypeBase Strategy bases, the 13 Emit observation buses, and the Exchange query buses — with shipped-versus-pending status and a per-gem feature index.
Categories:
Controllers
How to work with GS_Unit controllers — the possession model, player and AI controller setup, and switching control at runtime.
Categories:
Curves
40+ easing curve functions for smooth animation and interpolation — organized by family with a CurveType enum for data-driven selection.
Categories:
Dialogue System
How to author and play back branching dialogue in GS_Play — the Dialogue Editor, node types, conditions, effects, performances, and the runtime sequencer.
Categories:
Display & Window Modes
The window modes GS_Options drives, how resolution relates to render resolution, and the platform limits worth stating plainly.
Categories:
Environment Change Log
GS_Environment version changelog.
Categories:
Equipment
How to work with GS_Play equipment — typed equipment slots with visual integration via GS_Performer skin slots.
GS_Save
The persistence system — save files, load data, and track progression with managers, savers, and record keepers.
Categories:
Save System
How to work with the GS_Play save system — saving game state, loading saves, and tracking progression with the Record Keeper.
Mixing & Effects
Named volume channels built on custom miniaudio nodes, environmental influence with priority stacking, and the component-authored mix effect layer.
Categories:
GS_MotionComposite
Runtime deep-copy motion instance with proxy entity overrides — created from GS_MotionAsset for per-entity playback.
Mover Context
Movement state coordinator for GS_Unit — manages movement modes, context states, input axis transformation, and movement profile priority.
Nodes
BaseNode, slot macros, auto-registration, rapid node creation, and built-in node types.
Categories:
Page Navigation
How to work with GS_Play page navigation — single-tier page hierarchy, focus management, and transitions.
Categories:
Patterns
Patterns associated with the GS_Play featuresets.
SFXR Profiles
How to make procedural sound effects — design a sound in the browser, paste it into a profile asset, and pool profiles for variation.
Categories:
Skin Slots
How to work with GS_Play skin slots — modular character appearance with swappable actor meshes and materials.
Sky Configuration
How to work with GS_Play sky configuration — data-driven sky color settings for time-of-day transitions.
Categories:
Targeting
How to work with the GS_Interaction Targeting system — selecting interactable entities, managing cursor display, and handling interaction input from scripts.
Categories:
Templates List
All ClassWizard templates for GS_Play gems — one-stop reference for generating extension classes across every gem.
GS_Audio
Sound for GS_Play — audio events, mixing and effects, spatial audio, and the premium Audio Pro tier with visual graph authoring, music scoring and voice synthesis.
Categories:
GS_Audio
The GS audio framework — event-based playback, mixing and the full DSP effect palette, HRTF spatialization, and the premium Audio Pro tier adding visual graph authoring, geometric acoustics, scoring and voice synthesis.
Categories:
Audio Event Graph
How to author complex sound events visually using the Audio Event Graph editor — nodes, phase lifecycle, variables, and runtime control.
Categories:
Best Practices
Conventions and habits that make working with GS_Play faster and less frustrating.
Categories:
Core Change Log
Changelog.
Categories:
Dialogue System
Architecture overview of the GS_Cinematics dialogue system — the Dialogue Editor, sequencing, UI display, actors, and extensible conditions, effects, and performances.
Categories:
Performers
Billboard and 3D character entity types — PaperFacingHandlerComponent for 2.5D rendering and the Avatar pipeline for rigged EMotionFX characters.
Springs
Spring-damper functions for physically-grounded value interpolation — smooth following, overshoot, and settling for floats, vectors, and quaternions.
Categories:
Stage Composition
Concept primer for composing camera behavior from Body, Aim, and Additive stages on a single Phantom Camera component.
Categories:
Noise
Project-owned Perlin noise toolkit — signed Perlin 1D/2D/3D, fractal multi-octave, layered (amp, freq, phase) stacks with the NoiseLayer struct, unit-range wrappers, and decorrelation patterns. Backs PhantomCam noise stages and any time-varying value modulation consumer.
Categories:
Orbital Solver
Pivot-aware position and pose blend primitive — Linear / Cylindrical / Spherical shapes around a configurable pivot. Powers PhantomCam blend shapes, DynamicOrbitBody damping, and LeadingFollowBody band response.
Categories:
Buttons
Redirected — button documentation is now part of UI Interaction.
Categories:
Camera Tug Configurations
Step-by-step recipes for tug-field cinematic pulls — vista pull, doorway glance, and decoupled source / destination patterns.
GS_Cinematics
Node-graph dialogue sequences, cinematic stage management, polymorphic performances, and world-space UI with typewriter and audio babble.
Categories:
GS_Cinematics
Dialogue graphs, cinematic staging, UI display, localization, and extensible condition/effect/performance systems for authored narrative experiences.
Categories:
Dialogue UI
How to display dialogue text, player choices, and typewriter effects in GS_Play — screen-space and world-space UI components and the bridge that connects them to the sequencer.
Categories:
Editor Window
MainWindow features, virtual hooks, page system, and container editor patterns.
Categories:
Gradients
Multi-stop gradient types for sampling color, float, and vector values over a normalized range — used by motion tracks and feedback effects.
Categories:
GS_StageManager
The level navigation system — handles loading, unloading, and staged startup of game levels with exit point traversal.
Categories:
Stage Management
How to work with the GS_Play stage management system — level loading, stage transitions, exit points, and stage data.
Input Data
How to work with the GS_Unit input pipeline — reading player input, converting keyboard and joystick signals into movement vectors, and chaining input reactors.
Input Reactors
The reactor mechanism — a component driven by a reactor profile asset that dispatches named input events to authored reaction types, with a notification bus for scripts.
Categories:
Interaction Change Log
GS_Interaction version changelog.
Categories:
Mixing & Effects
How to work with GS_Play audio mixing — volume channels, named effect chains, all 22 effects, and environmental influence zones.
Categories:
GS_MotionAsset
Abstract base for motion data assets — holds track definitions and creates runtime composites.
Paper Performer
Billboard-based character rendering — paper facing handlers that orient sprite quads toward the camera.
Categories:
Paper Performer
How to work with GS_Play paper performers — billboard-style 2.5D character rendering with camera-aware facing.
Performers
The character rendering entity types in GS_Performer — billboard 2.5D paper performers and fully-rigged 3D avatar performers.
Phantom Cameras
How to configure a Phantom Camera — priority, target, lens, stage composition, and snap / focus state.
Categories:
Score Arrangement
Multi-layer musical score system for dynamic music – tempo, time signatures, fade control, and layer selection.
Categories:
Spatialization
HRTF binaural spatialization and distance attenuation in the base gem — how a 3D sound is placed, the distance curve, HRTF interpolation modes, and the limits worth knowing.
Categories:
State Inheritance
One-checkbox author surface for cam-to-cam pose handoff during blends. When to enable it, what each body type does with it, and the common authoring gotcha.
Categories:
UI Interaction
How to work with GS_Play UI interaction — motion-based button animations and input interception for focused canvases.
Categories:
World Triggers
How to work with the GS_Interaction World Trigger system — configuring sensor types and trigger types to create event-driven world responses without scripting.
Categories:
Juice Change Log
GS_Juice version changelog.
Categories:
Spatial Audio
How sounds get placed in the world — setting the listener, splitting it for third-person, distance falloff, and what the free tier does and does not do.
Categories:
Audio Pro
GS_AudioPro — the premium audio gem. Visual graph authoring, procedural scoring, Klatt voice synthesis and geometric acoustics, layered onto everything the free gem already does.
Categories:
Blend Profiles
How to author .camblendprofile assets to control camera transitions — duration, easing, blend shape, pivot source, and the inherit-state toggle.
Categories:
Entity Helpers
Utility functions for finding entities in the scene by name — runtime entity lookup without maintaining manual references.
Categories:
GS_Environment
World time and environmental systems for GS_Play — time-of-day progression, day/night cycle management, and data-driven sky configuration.
Categories:
GS_Environment
Time of day progression, day/night cycle management, and sky colour configuration for GS_Play projects.
Categories:
Geometric Acoustics
Occlusion and reflections derived from world geometry — acoustic volumes and shapes, 15 material presets, listener-centric reverb, and an honest account of what is and is not simulated.
Categories:
Geometric Acoustics
How to make sounds get blocked by walls and pick up the reverb of the room they are in — acoustic volumes, materials, occlusion and reflections.
Categories:
Group Target Configurations
Step-by-step recipes for GroupTargetComponent — two-player party cam, combat encounter framing, and collapse-to-single-view triggers.
GS_Motion
Track-based animation and tween system — abstract base classes for motions, tracks, composites, assets, and proxies with a domain extension pattern.
Options & Input
How to work with the GS_Play options system — player settings with profiles and presets, plus input profiles, groups and runtime binding management.
Klatt Voice Synthesis
Custom text-to-speech via Klatt formant synthesis with 3D spatial audio, phoneme mapping, and voice profiling.
Categories:
Locomotion
How to work with GS_Play velocity locomotion — automatic animation parameter driving from entity velocity.
GS_MotionProxy
Serialized struct for track-to-entity redirection — allows designers to target named tracks at different entities.
Movement
How to work with GS_Unit movement — mover types, mover context, grounders, movement profiles, and influence fields.
Noise & Impulse
Author guide for camera shake — the two noise additive stages, preset library, gameplay-code impulse triggering, and the Stable-vs-Final pose readback rule.
Categories:
Performances
How to move and reposition actors during dialogue in GS_Play — the polymorphic performance system, built-in movement types, and async completion.
Categories:
Performer Change Log
GS_Performer version changelog.
Categories:
Score Arrangement
How to work with GS_Play score arrangements — multi-layer dynamic music with configurable time signatures and layer control.
UI Animation
How to work with GS_Play UI animations — motion-based LyShine property animation for pages, buttons, and standalone components.
Units
What makes an entity a unit — the GS_UnitComponent, entity configuration, collision setup, possession, standby, and movement.
Variables
Variable declarations, Get/Set nodes, reference bindings, and drag-to-canvas interactions.
Categories:
GS_GraphCanvas
A framework for building custom visual graph editors in O3DE — descriptors, nodes, variables, execution engines, and editor infrastructure.
Categories:
PhantomCam Change Log
GS_PhantomCam version changelog.
Categories:
Widgets
How to work with GS_Play UI widgets — load screens, pause menus, and other standalone UI components.
Categories:
Angle Helpers
Angle and orientation math — sector mapping, yaw extraction, quaternion conversion, and hysteresis for directional classification.
Categories:
Execution Engines
FlowGraphEvaluator, DataFlowGraphEvaluator, StateMachineEvaluator, GraphExecutionContext, and GraphInstance.
Categories:
Group Targets
Author guide for GroupTargetComponent — weighted-centroid focal entity. Common use cases, centroid modes, runtime subject management, and pitfalls.
Categories:
Actions System
How to work with the GS_Play action system — triggerable, composable behaviors that fire from scripts, triggers, or code.
GS_Options
The configuration system — player settings with profiles, presets and apply targets, plus input profiles, readers and reactors.
Categories:
Influence Field Configurations
Step-by-step recipes for camera priority shifts — spatial room boosts and stage-scoped always-on cinematic boosts.
Influence Fields
How GlobalCameraInfluenceComponent and CameraInfluenceFieldComponent shift camera priority globally or within spatial trigger volumes — types, priority stacking, channel-aware routing.
Categories:
GS_Interaction
Physics-based pulse events, proximity targeting with cursors, and data-driven world trigger zones.
Categories:
GS_Interaction
Entity interaction systems — physics-based pulse events, targeting and cursor management, and extensible world trigger actions.
Categories:
Klatt Voice Synthesis
How to work with GS_Play Klatt voice synthesis — text-to-speech with 3D spatial audio, voice profiles, and inline parameter control.
Lessons
Index of Lesson Guides
Performer Features
Universal capabilities for any performer entity — procedural head tracking, typewriter-synchronized babble, and mesh swapping.
Powerful Utilities
Powerful Utilities associated with the GS_Play featuresets.
Systems
Core framework systems — the GS_Motion track-based animation engine and the GS_Actions triggerable behavior system.
Categories:
Systems
Core framework systems — the GS_Actions triggerable behavior system and the GS_Motion track-based animation engine.
Categories:
UI Change Log
GS_UI version changelog.
Categories:
Unit Action Graph
How to open the Unit Action Graph editor, author parallel behavior layers, set up states and transitions, and add conditions.
Categories:
Envelope
The reflected ADSR envelope — an authorable attack/decay/sustain/release shape with evaluation, duration and completion helpers.
Categories:
Motion System
How to work with GS_Motion — the track-based animation and tween system that powers UI transitions, feedback effects, and custom animations.
GS_Juice
Game feel and feedback motion system — screen shake, bounce, flash, and material effects driven by the GS_Motion engine.
GS_Juice
Game feel and feedback motion system — GS_Motion extension with transform and material tracks for visual feedback effects.
Spline Helpers
Utility functions for O3DE spline queries — closest point, fraction, and local/world space conversion by entity ID.
Categories:
Tug Fields
Author guide for tug-field cinematic pulls — three-component model, PhysX layer setup, channel filtering, tuning, and pitfalls.
Categories:
Unit Change Log
GS_Unit version changelog.
Categories:
Audio Pro
GS_AudioPro — the premium audio gem. Visual sound authoring, adaptive music, generated speech and real acoustics, added on top of everything the free gem does.
Categories:
Channel Tier Configurations
Step-by-step walkthroughs for the PhantomCam channel system — Tier 1 single cam, Tier 2 level-placed, Tier 3 multi-channel co-op, common Tier 3 patterns, and the lobby flow for variable player counts.
Interfaces
The cross-gem contract layer — neutral agreements collected in GS_Core so feature gems depend on contracts instead of on each other’s internals. Covers the three contract kinds (TypeBase, Emit, Exchange).
Categories:
GS_Item
Inventory and equipment systems for GS_Play — container-based item storage, slot management, stacking, and visual equipment integration with GS_Performer.
Categories:
GS_Item
Data-driven inventory containers and equipment slot management for collectible, usable, and equippable items in GS_Play projects.
Categories:
Performer Features
Universal capabilities that extend any performer type — modular equipment via skin slots, and velocity-driven animation via locomotion.
Physics Trigger Volume
Base class and component for physics trigger and collision handling — inherit to create interactive volumes with enter, exit, and hold callbacks.
Categories:
Unit Action Graph
Hierarchical finite state machine editor for authoring character behavior with parallel layers, transitions, and conditions.
Categories:
Utilities
General-purpose components and math helpers — physics triggers, easing curves, spring dampers, gradients, splines, and more.
GS_Performer
Character rendering and animation for GS_Play — modular skin slots, billboard 2.5D rendering, and velocity-driven locomotion parameters.
GS_Performer
Modular character rendering via skin slots, paper billboard performers, velocity-driven locomotion, head tracking, and audio babble integration.
Categories:
Dialogue Sequencer
Full API reference for the DialogueSequencerComponent and DialogueUIBridgeComponent — runtime dialogue graph traversal, node processing, and UI routing.
Categories:
Debugging
How to run a level directly with Debug Mode, and how to inspect and drive a running game with the in-game GS_Play menu.
Categories:
GS_PhantomCam
Priority-based virtual camera management — composable stage pipeline, channel-aware instancing, blend profiles, and spatial influence fields.
Categories:
GS_PhantomCam
Priority-based virtual camera framework — composable stage pipeline, channel-aware instancing, blend profiles, influence fields, group targets, tug fields, and noise.
Categories:
Debug
In-game debugging surfaces provided by GS_Core — the extensible GS_Play ImGui menu.
Categories:
GS_Stats
RPG stat definitions, stat containers, and a polymorphic status effect system for character and entity attribute management.
Categories:
GS_Stats
RPG statistics and status effect systems for GS_Play — timed and permanent modifiers that alter entity stats and drive reactive gameplay behavior.
GS_Complete
Cross-gem integration layer — reference components that combine multiple GS_Play gems for camera-aware performers, cinematic controllers, and dialogue UI selection.
Categories:
Dialogue UI
Full API reference for all dialogue UI components — screen-space and world-space dialogue display, selection menus, typewriter text reveal, and babble audio.
Categories:
GS_UI
The complete UI framework for GS_Play — canvas lifecycle management, single-tier page navigation, enhanced buttons, data-driven animation, and input interception.
Categories:
GS_UI
The complete UI framework — single-tier page navigation, motion-based animations, enhanced buttons, input interception, load screens, and pause menus.
Categories:
Utilities
A collection of utility libraries — easing curves, spring dampers, physics trigger volumes, gradients, and entity helpers.
Categories:
Weighted Random
Weighted random selection — pick a key from a weighted map with probability proportional to each entry’s float weight.
Categories:
GS_Unit
The character and entity control system — unit registration, player and AI controllers, input processing, and modular movement.
GS_Unit
Character and entity control — unit lifecycle, player and AI controllers, input processing, movement, and grounding.
GS_Actions
A utility system for triggerable single-purpose actions — fire discrete behaviors from any system without recoding logic for each component.
Categories:
Dialogue Actors
Full API reference for DialoguePerformerMarkerComponent, ActorDefinition data model, and the performer registration and lookup system.
Categories:
Effects
Full API reference for the DialogueEffect base class and built-in effect types — SetRecords and ToggleEntitiesActive.
Categories:
Performances
Full API reference for the DialoguePerformance base class and built-in performance types — MoveTo, PathTo, and RepositionPerformer.
Categories:
Learn
Lessons for quick, or extended learning.
Categories:
Glossary
Descriptions and resources around common terminology used in the documentation.
Categories:
Recipes
Step-by-step recipes for composing specific configurations of GS_Play systems, organized by gem.
Third Party Implementations
Integration guides for third-party audio systems with GS_Audio.
Categories:
Third Party Implementations
Integration guides for third-party cross-gem components with GS_Complete.
Categories:
Third Party Implementations
Integration guides for third-party feedback systems with GS_Juice.
Categories:
3rd Party API
API for 3rd party support.
Categories:
Templates
ClassWizard templates for GS_Cinematics — dialogue conditions, effects, and performance objects for the dialogue sequencer.
Categories:
Templates
The GS_Play project templates, the ClassWizard component scaffolds for extending GS_Core, and the Editor-Only Environment prefab.
Categories:
Templates
ClassWizard templates for GS_Interaction — Pulsor pulses, reactors, world triggers, and trigger sensors.
Categories:
Templates
ClassWizard templates for GS_Juice — custom feedback motion tracks for world-space game-feel effects.
Categories:
Templates
ClassWizard templates for GS_PhantomCam — custom phantom camera behaviour components.
Categories:
Templates
ClassWizard templates for GS_UI — custom UI animation motion tracks.
Categories:
Templates
ClassWizard templates for GS_Unit — unit controllers, input reactors, mover components, and grounder components.
Categories:
Links
Useful links.
Categories:
Video Tutorials
Index of Video based tutorials.
Agentic Guidelines
Agent bootstrap document for GS_Play framework contextualization. Optimized for LLM parsing, not human reading.
Docs Change Log
Updated changelog.
Categories:
Core Actions
Pre-built actions included in GS_Core — ready-to-use triggerable behaviors for common game functionality.
Categories:
Equipment
Categories:
Inventory
Categories:
Status Effect
The core gem for the GS_Play framework.