| NGondwana | |
| NAssets | |
| CAssetsFile | Represents a 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 | |
| NMidi | |
| CSynthesizerSampleProvider | |
| CWaveProviderToWaveStream | |
| CAudioResource | Represents a audio resource that can be played, paused, resumed, and disposed |
| CAudioResourceManager | Manages the lifecycle of audio resources, providing loading, retrieval, cloning, and disposal functionality |
| CStereoPanSampleProvider | Simple stereo balancer: multiplies L/R samples independently. Expects stereo IEEE float (NAudio will convert upstream via ToSampleProvider()) |
| NCollision | |
| 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 Gondwana.Drawing.Tile." |
| CCollisionResult | |
| CCollisionWorld | |
| CICollider | World-space axis-aligned collider used by the collision system |
| CTileCollider | |
| 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 |
| NDrawing | |
| NAnimation | |
| 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 | |
| CCollisionDetectionAdjustment | Pixel adjustments applied to a Tile's DrawLocation to produce its collision box. Positive values shrink/expand the collision rect relative to the visual rect |
| NDirect | |
| 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 | |
| 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 |
| CDirectRectangle | Renders a configurable rectangle with support for fill, border, rounded corners, dash patterns, color pulsing, and pattern fills |
| CDirectVideo | Draws video frames provided by IVideoPlayer onto the backbuffer. Audio is handled by the IVideoPlayer implementation (e.g., VLC system output on desktop) |
| 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 | |
| CCompositeSprite | |
| CSprite | |
| CSpriteMovedEventArgs | |
| NTilesheets | |
| CTilesheet | Represents a tilesheet image and metadata for rendering tiles |
| CTilesheetDisposedEventArgs | Provides data for the event that is raised when a Tilesheet is disposed |
| 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 |
| 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 |
| NInput | |
| NGamepad | |
| 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 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 |
| 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 |
| 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 | |
| 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 | |
| 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 | |
| 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 | |
| CIVideoPlayer | |
| CVideoFrameReadyEventArgs | |
| CVideoStateChangedEventArgs | |
| CVlcVideoPlayer | |
| NWinForms | |
| NInput | |
| NGamepad | |
| NSDL2 | |
| CSdlGamepadAdapter | |
| CSdlGamepadManager | |
| NXInput | |
| CXInputGamepadAdapter | |
| CXInputGamepadManager | |
| 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 | |
| NRendering | |
| CWinFormBitmapRenderSurfaceAdapter | |
| CWinFormBitmapRenderSurfaceControl | |
| CWinFormGpuRenderSurfaceAdapter | |
| CWinFormGpuRenderSurfaceControl | |
| CCyclesPerSecondCalculatedEventArgs | Provides data for events that report calculated cycles per second (CPS) performance metrics. 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 |
| 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 |
| 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 save-state extensibility |
| 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 |
1.14.0