Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123456]

NGondwana
NAssets
CAssetsFile	Represents an asset file used by the engine, providing functionality to load, manage, and save assets
CAssetsFileEntry	Represents an entry for an engine asset file, including its type and name
CAssetsFileIdentifier	Represents an identifier for a specific asset within a file, including its type and name
NAudio
NBrowser
CBrowserAudioBackend	Browser/WASM audio backend implemented with HTML media and Web Audio APIs
CBrowserAudioManager	Compatibility facade for browser audio. New code may use AudioResourceManager directly after calling Engine.UseBrowserAudio()
CBrowserAudioPlayer	Compatibility wrapper around the common AudioResource browser implementation
NGSND
CAudioDefinition	Root definition for the GSND (Gondwana Sound) file format
CAudioDefinitionSource	Captures provenance details for a Gondwana audio (.gsnd) definition
CAudioResourceDefinition	Defines one named audio resource in a GSND file
NMidi
CSynthesizerSampleProvider	Provides real-time audio sample generation from MIDI data using software synthesis
CWaveProviderToWaveStream	Wraps an IWaveProvider as a WaveStream with support for length and seeking
NNAudio
CNAudioAudioBackend	Windows desktop audio backend implemented with NAudio
CAudioResource	Represents an audio resource that can be played, paused, resumed, sought, and disposed. Playback is supplied by the currently configured IAudioBackend
CAudioResourceManager	Manages the lifecycle of audio resources independently of the playback backend
CIAudioBackend	Creates backend-specific playback handles for the engine's common audio API
CIAudioPlaybackHandle	Backend-provided playback handle used by AudioResource. Implements IDisposable to allow releasing any native or temporary resources associated with playback (for example temporary files or native audio handles)
NAvalonia
NHosting
CAvaloniaBitmapGameHost	Provides a base class for hosting Gondwana games in Avalonia desktop applications
CAvaloniaGpuGameHost	Provides a base class for hosting Gondwana games in Avalonia applications using GPU-accelerated (OpenGL) rendering via AvaloniaGpuRenderSurfaceControl
NInput
NKeyboard
CAvaloniaKeyboardAdapter	Global Avalonia key state collector that feeds the KeyboardEventPoller. Attaches tunnel-phase handlers at the TopLevel so it sees ALL key messages regardless of which control has focus, mirroring the WinForms IMessageFilter approach. Key codes are Key values cast to int
NMouse
CAvaloniaMouseAdapter	Provides a mouse/pointer input adapter for Avalonia applications, tracking pointer position, button states, modifier keys, and scroll events
NTouch
CAvaloniaTouchInputAdapter	Provides a passive touch/pointer state adapter for Avalonia applications, implementing ITouchAdapter by translating Avalonia PointerPressed, PointerMoved, PointerReleased, and PointerCaptureLost events into Gondwana touch state. Events are not raised directly; the TouchEventPoller polls this adapter each engine frame to detect transitions and raise events
NRendering
CAvaloniaBitmapRenderSurfaceAdapter	Provides a bitmap (CPU) render surface adapter for Avalonia that presents each frame by copying pixel data from a SKImage into an WriteableBitmap displayed by AvaloniaBitmapRenderSurfaceControl. This approach works on all Avalonia targets (desktop, WebAssembly, Android, iOS, macOS) without requiring platform-specific SkiaSharp view packages
CAvaloniaBitmapRenderSurfaceControl	An Avalonia Control that displays game frames produced by the Gondwana engine. Frames are received as WriteableBitmap instances from the AvaloniaBitmapRenderSurfaceAdapter and rendered via the Avalonia compositor. No platform-specific SkiaSharp view package is required; this works on all Avalonia targets
CAvaloniaGpuRenderSurfaceAdapter	Provides a GPU-accelerated render surface adapter for Avalonia, backed by global::Avalonia.OpenGL.Controls.OpenGlControlBase
CAvaloniaGpuRenderSurfaceControl	An Avalonia OpenGlControlBase that displays game frames produced by the Gondwana engine using GPU-accelerated rendering
NBlazor
NConfiguration
CBrowserLocalStorageEngineConfigurationStore	Persists Gondwana engine configuration in browser localStorage
NHosting
CBlazorGameHost	Provides a base class for Gondwana Blazor games rendered through the CPU-backed bitmap path
CBlazorGameHostBase	Provides the shared Gondwana lifecycle integration for Blazor bitmap and WebGL game hosts
CBlazorGpuGameHost	Provides a base class for Gondwana Blazor games rendered through WebGL and Gondwana.Rendering.Backbuffers.GpuBackbuffer
NInput
NKeyboard
CBlazorKeyboardAdapter	Keyboard adapter for Blazor applications that feeds the Gondwana KeyboardEventPoller by translating browser KeyboardEvent.code values into BlazorKey integer codes
NMouse
CBlazorMouseAdapter	Provides a mouse/pointer input adapter for Blazor applications, tracking pointer position, button states, modifier keys, and scroll wheel input
NTouch
CBlazorTouchAdapter	Provides a passive touch state adapter for Blazor applications, implementing ITouchAdapter by translating Blazor ontouchstart, ontouchmove, ontouchend, and ontouchcancel events into Gondwana touch state
NLogging
CBrowserConsoleLoggerProvider	Writes Microsoft.Extensions.Logging records to the browser developer console without using the desktop-oriented Microsoft console logging provider
NRendering
CBlazorBitmapRenderSurfaceAdapter	Provides a bitmap (CPU) render surface adapter for Blazor that presents each frame by converting pixel data from a SKImage into an RGBA byte array and drawing it onto the HTML canvas element owned by BlazorBitmapRenderSurfaceComponent
CBlazorBitmapRenderSurfaceComponent	A Blazor component that presents Gondwana game frames on an HTML <canvas> element and forwards keyboard, mouse, and touch events to the Gondwana input adapters
CBlazorGpuRenderSurfaceAdapter	Coordinates Gondwana foreground-frame requests with a Blazor WebGL render surface
CBlazorGpuRenderSurfaceComponent	A Blazor WebGL render surface that draws Gondwana scenes through an GpuBackbuffer without transferring frame pixels through JavaScript
CBlazorRenderSurfaceComponentBase	Provides the shared DOM input surface used by Gondwana's Blazor bitmap and GPU render components
CBlazorSkiaGlView	Gives Razor a local component name for SkiaSharp's WebGL view. This avoids Razor resolving SkiaSharp relative to Gondwana's own Gondwana.SkiaSharp namespace
CBlazorExternalUriLauncher	Opens external absolute URIs in a new browser tab or window
NConfiguration
CEngineConfiguration	Settings used by the engine when cycling
CEngineConfigurationFile	Represents a configuration file for the engine, providing functionality to create, load, and save engine settings
CIEngineConfigurationStore	Provides a persistence boundary for EngineConfiguration
NDiagnostics
CRuntimeProfiler	Opt-in, bounded runtime measurements independent of legacy CPS notifications
CTelemetrySource	Bounded extension source. Define measurements once, capture a generation before work, then record it
NDrawing
NAnimation
NGANI
CAnimationDefinition	Represents the root definition of an animation in the GANI (Gondwana Animation) file format
CAnimationDefinitionSource	Captures provenance details for an animation definition
CAnimationFrameDefinition	Identifies one tilesheet frame used by a GANI animation
CAnimationTilesheetSourceDefinition	Describes an authoring-time source for a logical tilesheet referenced by a GANI definition. Runtime materialization continues to resolve frames through the registered tilesheet name
CAnimator	Manages animation playback for a Tile, controlling animation cycles, frame timing, and raising events during the animation lifecycle
CAnimatorEventArgs	Provides data for animator-related events, containing references to the tile and animator involved in the event
CCycle	References a FrameSequence object, along with a particular Throttle value for animating through Frame objects
CFrameSequence	Represents a sequence of animation frames that can be cycled through using different animation patterns
NCollisions
CTileCollider	Provides collision detection capabilities for a Tile by implementing the ICollider interface
NDirect
NImageLayer
CImageInstance	Represents a single image instance rendered by an ImageInstanceLayer
CImageInstanceLayer	Represents a lightweight image-instance layer that manages and renders a collection of independently moving bitmap instances
NParticles
CParticle	Represents a single particle instance in the particle system
CParticleEmitter	Configures how particles are spawned over time at a given location
CParticleSurface	A flexible particle system for effects like smoke, sparks, fire, or snow, implemented as a DirectDrawingBase
CDirectComposite	Represents a movable composite that owns other movable direct drawables and keeps their positions relative to a shared anchor
CDirectDarknessOverlay	Renders a view-space darkness / fog overlay with optional world-space reveal sources
CRevealSource	Represents a single world-space reveal source used by a DirectDarknessOverlay
CDirectDrawingBase	Provides the base implementation for direct drawing objects that can be rendered to the backbuffer with support for opacity, fade transitions, reveal animations, and flexible positioning modes
CDirectDrawingManager	Manages the lifecycle, registration, and retrieval of all direct drawing objects in the Gondwana engine
CDirectDrawingMovableBase	Provides an abstract base class for direct drawings that support physics-based movement
CDirectImage	Renders a bitmap or image to a rectangular region with support for scaling modes, source clipping, tinting, opacity, blend modes, and rotation
CDirectLightLayer	Convenience owner for a group of scene-layer radial lights
CDirectRadialLight	Draws a bounded, radial light effect as a scene-layer direct drawing
CDirectRectangle	Renders a configurable rectangle with support for fill, border, rounded corners, dash patterns, color pulsing, and pattern fills
CDirectSceneLayerDarknessOverlay	Renders a world-bounded darkness/fog overlay as a scene-layer direct drawing
CRevealSource	Represents a single world-space reveal source used by a DirectSceneLayerDarknessOverlay
CDirectSvg	Renders an SVG resource directly by rasterizing lazily and caching the bitmap per destination size
CDirectVideo	Draws video frames provided by IVideoPlayer onto the backbuffer. Audio is handled by the IVideoPlayer implementation (e.g., VLC system output on desktop). Construct, control, update, draw and dispose on the engine/UI thread
CIDirectCompositeChild	Defines a movable direct drawable that may be owned by a DirectComposite
CIDirectCompositeContainer	Defines a container that can hold and manage a collection of direct composite children
CIDirectDrawable	Represents any drawable object (movable or static) that can render directly to a RenderSurfaceHost, report its position and bounds, and optionally support movement or composition
CTextBlock	A retained-mode text drawable with wrapping, multi-line ( ) support, horizontal/vertical alignment, padding, optional shadow/outline effects, and auto-shrink to fit
NSprites
NGSPR
CSpriteDefinition	A collection of authored sprites. Empty collections are valid
CSpriteDefinitionSource	Captures provenance details for a GSPR scene definition
CSpriteFrameDefinition	Stores a lightweight reference to one frame in a registered tilesheet
CSpriteInstanceDefinition	Stable authored state for one sprite, without runtime object graphs
CSpriteSceneSourceDefinition	Describes an authoring-time source for a logical scene referenced by a GSPR definition. Runtime sprite materialization resolves scene identities against already loaded scenes
CSpriteTilesheetSourceDefinition	Describes an authoring-time source for a logical tilesheet referenced by a GSPR definition. Runtime scene materialization continues to resolve frame references through the tilesheet registry
CCompositeSprite	Represents a composite sprite that contains multiple child sprites and manages them as a single unit. All child sprites must belong to the same SceneLayer
CSprite	Represents a movable visual element on a scene layer
CSpriteManager	Manages the lifecycle, lookup, and per-frame updates of all active Sprite instances
CSpriteMovedEventArgs	Provides data for sprite movement events
NTilesheets
NGTS
CTilesheetDefinition	Represents the root definition of a tilesheet in the GTS (Gondwana Tilesheet) file format
CTilesheetDefinitionSource	Captures provenance details for a tilesheet definition
CTilesheetFrameDefinition	Defines collision metadata for one frame in a tilesheet region
CTilesheetImageDefinition	Represents the image source definition for a tilesheet, specifying where the image data can be loaded from
CTilesheetMaskDefinition	Defines a color mask used to identify and process specific colors within a tilesheet image
CTilesheetRegionDefinition	Defines a rectangular region within a tilesheet, including layout and collision metadata
CTilesheet	Represents a tilesheet image and metadata for rendering tiles
CTilesheetRegion	Represents a rectangular region within a tilesheet that contains a grid of frames
CTilesheetRegistry	Thread-safe singleton registry for Tilesheet instances
CFrame	Represents the source Tilesheet and its coordinates to render on a destination
CIDrawable	Represents an object that can be drawn on a visual surface, with properties for visibility and stacking order
CSvgResource	Represents a loaded SVG asset that can be rasterized into cached bitmaps at requested sizes
CSvgResourceManager	Manages loaded SvgResource instances keyed by asset name
CTile	Represents an abstract base class for drawable tiles in the Gondwana engine. Provides core functionality for rendering, animation, collision detection, and scene layer integration
NEffects
CDisplayEffect	Base class for transient effects applied to a View or SceneLayer
CEarthquakeEffect	Applies a decaying, presentation-only camera shake to a View
CEffectsManager	Owns and advances display effects for one RenderSurfaceHost
CEraseEffect	Directionally removes a View or SceneLayer from presentation
CFadeEffect	Base implementation shared by fade-in and fade-out effects
CFadeInEffect	Fades a View or SceneLayer to fully opaque
CFadeOutEffect	Fades a View or SceneLayer to fully transparent
CFillEffect	Directionally reveals a View or SceneLayer
CSlideEffect	Base implementation shared by slide-in and slide-out effects
CSlideInEffect	Slides a View or SceneLayer into its normal presentation position
CSlideOutEffect	Slides a View or SceneLayer out of its normal presentation position
CWipeEffect	Base implementation shared by directional fill and erase effects
CZoomEffect	Base implementation shared by zoom-in and zoom-out effects
CZoomInEffect	Animates a View to a larger or otherwise explicitly supplied zoom factor
CZoomOutEffect	Animates a View to a smaller or otherwise explicitly supplied zoom factor
NExtensibility
CIEnginePlugin	Defines lifecycle hooks for extending engine startup, simulation, rendering, and shutdown behavior
NHosting
CGameHostBase	Provides a base class for hosting and managing the lifecycle of a Gondwana game application
NInput
NGamepad
NSDL2
CSdlGamepadAdapter	Provides a gamepad adapter implementation using SDL2 for cross-platform gamepad input support
CSdlGamepadManager	Manages SDL2-based gamepad connections, disconnections, and state updates for the application
CGamepadButtonDownEventArgs	Provides data for gamepad button down events, containing information about the button configuration and the gamepad adapter that generated the event
CGamepadButtonEventConfiguration	Represents the configuration for gamepad button events, including button identification and timing controls for event throttling. This configuration is used to control how frequently button events are raised and whether event processing is currently paused
CGamepadEventPoller	Provides centralized polling and event management for gamepad button inputs across multiple gamepad devices. This singleton class monitors registered buttons on connected gamepads and raises events when buttons are pressed, with support for event throttling and pause states at both global and per-button levels
CGamepadStickState	Represents the state of an analog stick on a gamepad, including both normalized floating-point values for convenient use in game logic and raw integer values from the underlying input system. This immutable struct provides methods for deadzone processing, direction detection, and magnitude calculation
CIGamepadAdapter	Defines an adapter interface for accessing gamepad input state and information
CIGamepadManager< out T >	Interface to track a collection of IGamepadAdapter gamepad adapters
NKeyboard
CIKeyboardAdapter	Represents an adapter for keyboard input, providing access to the currently pressed keys and active modifier states
CKeyboardEventPoller	Cross-platform singleton keyboard handler with throttling and manual input state feeding
CKeyDownEventArgs	Provides data for keyboard key events, including information about the key that was pressed, the action performed (pressed, released, or repeated), and the state of modifier keys at the time of the event. This event args class is used with keyboard input polling to deliver comprehensive keyboard event information to event handlers
CKeyEventConfiguration	Represents the configuration for keyboard key events, including key identification and timing controls for event throttling. This configuration is used to control how frequently key events are raised and whether event processing is currently paused for a specific key
NMouse
CIMouseAdapter	Defines an adapter interface for accessing mouse device state, including cursor position, button presses, scroll wheel input, and keyboard modifier states. Implementations of this interface provide abstraction over various mouse input APIs to provide unified access to mouse hardware across different platforms
CMouseButtonState	Represents the current and transitional state of a mouse button, tracking whether the button is currently held down and whether press or release events occurred in the current polling interval. This structure is typically used to detect button state changes and differentiate between continuous button holds and momentary press/release actions
CMouseEventArgs	Provides comprehensive data for mouse events, including cursor position (current and previous), button states with transition information, scroll wheel delta, and keyboard modifier states. This event args class is used with mouse input polling to deliver complete mouse state information to event handlers, enabling sophisticated mouse interaction handling including drag operations, modified clicks, and scroll detection
CMouseEventConfiguration	Represents the configuration for mouse event monitoring, including movement tracking settings and timing controls for event throttling. This configuration is used to control how frequently mouse events are raised, whether mouse movement should be tracked, and whether event processing is currently paused
CMouseEventPoller	Provides centralized polling and event management for mouse input, including button presses, cursor movement, and scroll wheel activity. This singleton class monitors mouse state and raises events with comprehensive information including button states, position data, scroll deltas, and keyboard modifier states, with support for event throttling and pause functionality
NTouch
NGestures
CGestureEventArgs	Provides data for the TouchEventPoller.TouchEvent, carrying the details of a recognized gesture. Check IsTap, IsSwipe, or IsPinch to determine which kind of gesture occurred, then access the corresponding nullable property (Tap, Swipe, or Pinch) for the specific data
CPinchedEventArgs	Provides data for the PinchGestureRecognizer.PinchUpdated event, describing the change in scale produced by a two-finger pinch or spread gesture
CPinchGestureRecognizer	Recognizes two-finger pinch and spread gestures by listening to touch events from an ITouchInput source. Raises PinchUpdated each time the distance between the two active contact points changes, providing a relative scale delta
CSwipedEventArgs	Provides data for the SwipeGestureRecognizer.Swiped event, including the direction, start and end positions, and the computed speed of the swipe
CSwipeGestureRecognizer	Recognizes swipe gestures by listening to touch events from an ITouchInput source. A swipe is a single-finger gesture that ends with sufficient speed and with a clear primary direction. Short or slow drags do not qualify
CTapGestureRecognizer	Recognizes single-finger tap gestures by listening to touch events from an ITouchInput source. A tap is defined as a touch that begins and ends within a configurable maximum duration and without exceeding a configurable maximum movement distance. Long presses and drags are ignored
CTappedEventArgs	Provides data for the TapGestureRecognizer.Tapped event, including the screen position where the tap occurred
CITouchAdapter	Defines a passive adapter interface for accessing touch device state. Implementations update their internal state in response to platform events and expose that state for polling by TouchEventPoller. No events are raised directly from an adapter; all event routing is handled by the poller
CITouchInput	Represents a touch input source that tracks active contact points and raises lifecycle events when fingers (or pointer-emulated contacts) begin, move, or end on a surface
CTouchEventArgs	Provides data for touch contact events raised by ITouchInput, including the touch point and engine tick associated with the event
CTouchEventConfiguration	Represents the configuration for touch event monitoring, including timing controls for movement-event throttling and pause functionality. This configuration is used by TouchEventPoller to control how frequently touch movement events are raised and whether event processing is currently paused
CTouchEventPoller	Provides centralized polling and event management for touch input. This singleton class monitors touch adapter state each engine frame, detects contact transitions, and raises events with comprehensive touch point information, with support for event throttling and pause functionality
CInputEventConfigurationBase	Provides a base class for input event configuration that implements throttling and pause functionality for various input types (keyboard, mouse, gamepad). This abstract class manages timing between events using high-resolution ticks and tracks the last event occurrence to enable event rate limiting. Derived classes extend this functionality for specific input device types
NLogging
CLoggingErrorEventArgs	Provides data for the LoggingError event
NPhysics
NCollisions
CAabb	Represents an axis-aligned bounding box (AABB) defined by its minimum and maximum coordinates along the X and Y axes. This is the collision area of a Drawing.Tile."
CColliderRegistry	Manages registration and querying of colliders, separating them into static and dynamic collections for efficient collision detection
CCollisionAdjust	Per-edge inset amounts applied to visual bounds to produce a collision rectangle
CCollisionGroupRegistry	Manages collision group definitions and provides bitwise mask values for collision filtering. Groups are represented as bit flags to allow efficient collision detection using bitwise operations
CCollisionProfile	Describes a reusable, scene-level collision-filtering role using collision group names rather than scene-specific integer masks
CCollisionProfileRegistry	Stores named collision-filtering profiles for a scene. Profiles resolve their group names through the scene's CollisionGroupRegistry
CICollider	World-space axis-aligned collider used by the collision system
CICollisionEntity	Represents an entity that participates in the collision system and has a defined collision area
CICollisionMovableEntity	Represents a collision entity that can be moved or repositioned in response to collision resolution
NMovement
NScripted
CScriptedMovement	Represents the state and parameters of a scripted movement operation applied to an object. Supports two movement modes: tween-based interpolation (MovementScriptType.TweenTo) and continuous directional movement (MovementScriptType.Toward)
CIMovable	Defines an object that can be moved within a specific coordinate space
CIMovableOnSceneLayer	Implemented by grid-space IMovable objects that belong to a specific Scenes.SceneLayer
CMovementController	Central controller responsible for managing all movement modes for a single IMovable object. Combines three systems: Follow – hard/soft following of pixel or grid targets. Scripted – tween or constant-speed motion toward a destination. Integrated – free physics-style integration (velocity and acceleration). The controller automatically selects the correct behavior each frame internally through AdvanceMovement(float)
CMovementState	Represents the current motion state of an IMovable object, including velocity, acceleration, damping, and active scripted movements. This structure is used by MovementController to track and manage both physics-based (integrated) and scripted motion behaviors
NRendering
NBackbuffers
CBackbufferBase	Represents a base class for managing a graphical backbuffer, and is the in-memory surface where rendering operations are performed before being presented to the display
CBitmapBackbuffer	Provides a bitmap-based backbuffer implementation for rendering operations using SkiaSharp. This backbuffer maintains an in-memory bitmap surface that can be drawn to from a render thread and safely snapshotted for display on the UI thread
CGpuBackbuffer	Provides a fully GPU-rendered backbuffer implementation using SkiaSharp and OpenGL
NText
CFontManager	Centralized manager for loading, retrieving, and unloading shared fonts. Fonts are stored by string key and reused across the application
NViews
CCamera	Represents a world-space camera for a Scene. The camera tracks a world-space upper-left position in pixels and is used by Views to determine which part of the Scene is visible. It supports snapping, smooth follow, dead zones, and clamping to world bounds
CView	Represents a rendered view of a scene, combining a camera position with a viewport configuration to control what portion of the world is visible and how it is displayed on screen. Multiple views can be used to create split-screen, picture-in-picture, or other multi-viewport rendering scenarios
CViewManager	Manages a collection of views for a render surface, handling view creation, removal, ordering, and multi-viewport layouts. Each view combines a camera and viewport to control what portion of the scene is rendered and where it appears on screen
CViewport	A rectangular window on the render target with its own zoom and placement. Viewport never moves the world; it only scales and positions the drawing
CViewportResizedEventArgs	Provides data for the Viewport.TargetRectChanged event, which is raised when a viewport's target rectangle is resized or repositioned on the render surface
CViewportZoomChangedEventArgs	Provides data for the Viewport.ZoomChanged event, which is raised when a viewport's zoom level changes either through direct assignment or animated zoom transitions
CRenderSurfaceAdapterBase	Represents the abstract base class for render surface adapters that present backbuffer output to a destination surface
CRenderSurfaceAdapterResizedEventArgs	Provides data for the RenderSurfaceAdapterBase.Resized event
CRenderSurfaceHost< TBackbuffer >	Hosts a render surface and manages rendering of a scene to a backbuffer of the specified type. Provides coordination between the scene, views, and the underlying UI adapter for efficient rendering and presentation
CRenderSurfaceHostBase	Represents a base class for hosting a render surface, providing functionality for managing rendering operations, backbuffer access, and integration with platform-specific adapters
CRenderSurfaceHostBindEventArgs	Provides data for the RenderSurfaceHost<TBackbuffer>.BindToScene event
NScenes
NGSCN
CSceneAnimationSourceDefinition	Describes an authoring-time source for a logical animation key referenced by a GSCN definition. Runtime scene materialization continues to resolve animations through the cycle registry
CSceneCollisionProfileDefinition	Defines one named scene collision profile using group names rather than runtime masks
CSceneDefinition	Represents the root definition of a scene in the GSCN (Gondwana Scene) file format
CSceneDefinitionSource	Captures provenance details for a GSCN scene definition
CSceneFrameDefinition	Stores a lightweight reference to one frame in a registered tilesheet
CSceneLayerDefinition	Defines one layer in a GSCN scene
CSceneLayerTileDefinition	Defines persistent state for one tile cell in a GSCN scene layer
CSceneTilesheetSourceDefinition	Describes an authoring-time source for a logical tilesheet referenced by a GSCN definition. Runtime scene materialization continues to resolve frame references through the tilesheet registry
CScene	Represents a game scene containing multiple layers of tiles, sprites, and game objects. A scene organizes content into layers with independent coordinate systems, parallax scrolling, and z-ordering, providing a complete environment for rendering and gameplay
CSceneLayer	Represents a single layer within a Scene, containing a grid of tiles and supporting various coordinate systems, parallax scrolling, and rendering properties. Scene layers provide the fundamental structure for organizing and rendering tile-based game content
CSceneLayerTile	Represents the values stored at a single location on a SceneLayer
NTimers
CTimer	Represents a high-resolution timer that can trigger events at specified intervals and supports various timer types and cycles. This class is designed to be used within the Gondwana engine
NVideo
NWidgets
CVideoWidget	An interactive video drawing with opt-in Widget dragging
CIVideoPlayer	Defines the contract for a video player that can play, pause, stop, and seek video content
CVideoFrameReadyEventArgs	Provides data for video frame ready events, containing frame buffer information and timing data
CVideoSource	A URI, borrowed/owned stream, or GAF asset to open with a video backend
CVideoStateChangedEventArgs	Provides data for video state changed events
CVlcVideoPlayer	Desktop/native LibVLC 3 player. Controls are serialized; event handlers must not block on the engine thread. FrameReady runs on a decoder thread and is copy-only
NWidgets
NControls
CButtonWidget	Represents a basic text button composed from a rectangle and text block
CCheckBoxWidget	Provides a two-state checkbox with a text label
CComboBoxWidget	Provides a compact selection control that expands into a ListBoxWidget
CHyperlinkWidget	Represents an interactive text link that opens an external URI
CIExternalUriLauncher	Defines a platform-specific service for opening external URIs
CLabelWidget	Displays retained-mode text as a reusable Gondwana widget
CListBoxWidget	Provides a selectable, vertically scrolling list of text items
CPanelWidget	Provides a rectangular widget container with a configurable color or image background
CProgressBarWidget	Displays a normalized progress value as a horizontal or vertical filled bar
CRadioButtonGroup	Coordinates mutually exclusive RadioButtonWidget instances
CRadioButtonWidget	Provides a radio-button control with optional mutually exclusive grouping
CTabControlWidget	Provides a tabbed container whose pages own ordinary Gondwana widgets
CTabPageWidget	Represents one selectable page owned by a TabControlWidget
CTextBoxWidget	Provides a single-line editable text box with keyboard caret navigation
NDialogs
CAboutBox	Represents a conventional application-information dialog
CConversationBox	Provides an NPC-style conversation panel with speaker, wrapped body text, and pointer or keyboard advance semantics
CDialogBox	Provides a draggable container with panel, title-bar, close, keyboard, and result semantics
NHud
CHealthBarWidget	Displays a world-space health bar that follows a sprite
CNameTagWidget	Displays a world-space name label that automatically follows a sprite
CProfilerWidget	Displays detached RuntimeProfiler snapshots as a screen-space HUD widget
CProfilerWidgetExtensionContext	Provides detached telemetry and rendering context to a ProfilerWidget.AdditionalLinesProvider callback
NLayout
CStackPanelWidget	Arranges child widgets sequentially in a horizontal or vertical stack
NMenus
CKeyGesture	A host key code and an exact combination of keyboard modifiers
CMenuBarMenu	Associates one top-level menu header with its dropdown
CMenuBarWidget	Provides a view-level menu bar with animated dropdown command lists
CMenuDropDownWidget	Represents a popup command list owned by a header or submenu item
CMenuHeaderWidget	Represents a top-level menu header such as File, Edit, or Help
CMenuItemWidget	A command, check/radio item, or submenu owner in a menu dropdown
NOverlays
CPopupWidget	Displays short-lived text or image content in view or scene-layer coordinates
CSplashScreen	Represents a full-screen splash screen widget that fades in, holds for a duration, and fades out
CToastWidget	Displays a text notification inside one View with a slide or fade transition and optional automatic dismissal
CTooltipWidget	Displays a lightweight view-level text tooltip near a screen position
CContainerWidget	Provides a widget that can own other widgets through the inherited DirectComposite child system
CDraggableContainerWidget	Base type for container widgets that can be repositioned through pointer dragging
CDraggableWidgetBase	Base type for leaf widgets that can be repositioned through pointer dragging
CWidgetBase	Provides the base implementation for widgets that can be drawn and receive pointer, keyboard, and focus input
CWidgetDragEventArgs	Event arguments for widget drag callbacks
CWidgetEventArgs	Base event argument type for Gondwana widget callbacks
CWidgetInputRouter	Routes mouse, touch, and keyboard input to registered widgets for a render surface host
CWidgetKeyboardEventArgs	Provides data for widget keyboard input events routed by WidgetInputRouter
CWidgetMouseWheelEventArgs	Event arguments for mouse-wheel input routed to a widget
CWidgetPointerEventArgs	Event arguments for pointer-based widget callbacks
NWinForms
NHosting
CWinFormsGameHost	Provides a base class for hosting Gondwana games in Windows Forms applications
CWinFormsGameHostBase	Provides shared Windows Forms host behavior for Gondwana game hosts
CWinFormsGpuGameHost	Provides a base class for hosting Gondwana games in Windows Forms applications using GPU-accelerated (OpenGL) rendering via WinFormGpuRenderSurfaceControl
NInput
NGamepad
NXInput
CXInputGamepadAdapter	Provides a gamepad adapter implementation using XInput for Xbox controller support on Windows
CXInputGamepadManager	Manages XInput-based gamepad connections and state updates for Xbox controllers on Windows
NKeyboard
CWinFormsKeyboardAdapter	Global WinForms key state collector that feeds the KeyboardHandler. Uses IMessageFilter so it sees ALL key messages (including arrows), regardless of which control has focus or how WinForms classifies them
NMouse
CWinFormsMouseAdapter	Provides a mouse input adapter for WinForms applications, tracking mouse position, button states, and scroll events
NRendering
CWinFormBitmapRenderSurfaceAdapter	Provides a render surface adapter for Windows Forms using SKControl and bitmap-based rendering
CWinFormBitmapRenderSurfaceControl	Provides a Windows Forms control that hosts bitmap-based Gondwana rendering
CWinFormGpuRenderSurfaceAdapter	Provides a GPU-accelerated render surface adapter for Windows Forms using OpenGL and SKGLControl
CWinFormGpuRenderSurfaceControl	Provides a Windows Forms control that hosts GPU-accelerated Gondwana rendering
CCyclesPerSecondCalculatedEventArgs	Provides the compatibility payload for legacy cycles-per-second (CPS) performance notifications. This event args class contains both gross and net cycle counts, their corresponding rates per second, and the sampling time period. Net CPS typically represents the effective frame rate (FPS) of the engine, while gross CPS includes all cycles regardless of whether they resulted in rendered frames
CEngine	Represents the core game engine singleton responsible for managing the main update loop, input systems, rendering, timing, and subsystem coordination
CEngineDispatcher	Provides thread-safe dispatching of actions to the engine's background thread. This dispatcher allows external code to safely post work items that should execute on the engine's dedicated update loop thread, ensuring thread-safe access to engine state
CEngineInputSystems	Provides centralized access to all the input systems of the engine, including gamepad, keyboard, mouse, and touch input
CEngineManagers	Provides centralized access to all engine resource managers
CEngineState	Represents the complete serializable state of the game engine, including assets, scenes, sprites, audio resources, and custom data. This class provides functionality to save and load engine state to/from files with support for selective state management, compression, and merge operations. The state can be persisted as JSON and optionally compressed using GZip compression
CEngineStateSaveOptions	Persistence choices for an EngineState save
CIEngineDispatcher	Defines a contract for dispatching actions to the engine's background thread in a thread-safe manner. Implementations of this interface provide mechanisms for posting work items from any thread to be executed on the engine's dedicated update loop thread, ensuring thread-safe access to engine state
CIUiDispatcher	Defines a contract for dispatching actions to the UI thread in a thread-safe manner. Implementations of this interface provide mechanisms for posting or sending work items from any thread to be executed on the application's main UI thread, ensuring thread-safe access to UI components and controls
CTypedValueBag	A flexible, strongly-typed value container intended for runtime-attached metadata and ephemeral engine state
CUiDispatcher	Provides a concrete implementation of IUiDispatcher for dispatching actions to the UI thread using a SynchronizationContext. This class enables thread-safe marshalling of operations from background threads to the application's main UI thread