Address functions.

A generalized address.

Specifies the address of an identifiable value. OPTIMIZATION: Names is an array only for speed; it is invalid to mutate it. TODO: have Address constructor throw if multiple wildcards or ellipses are used in Debug build mode.

Converts Address types.

Address operators.

Gives an entity the base behavior of an animated billboard.

Augments an entity with an animated billboard.

A phantom type to denote the type of an asset as an animated model.

Gives an entity the base behavior of an animated model.

Augments an entity with an animated model.

Gives an entity the base behavior of an animated sprite.

Augments an entity with an animated sprite.

Describes an animation.

Details additional editing behavior for a simulant's properties.

A message to the physics system to apply an angular impulse to a body.

A message to the physics system to apply a force to a body.

A message to the physics system to apply a linear impulse to a body.

A message to the physics system to apply torque to a body.

Describes an argument used with the ImSim API.

Asset functions.

Describes a game asset, such as an image, sound, or model in detail. All assets must belong to an asset Package, which is a unit of asset loading. In order for the renderer to render a single texture, that texture, along with all the other assets in the corresponding package, must be loaded. Also, the only way to unload any of those assets is to send a package unload message to the relevent subsystem.

Describes a strongly-typed game asset, such as an image, sound, or model, in detail. All assets must belong to an asset Package, which is a unit of asset loading. In order for the renderer to render a single texture, that texture, along with all the other assets in the corresponding package, must be loaded. Also, the only way to unload any of those assets is to send a package unload message to the relevent subsystem.

Provides asset clients for direct usage.

Describes assets and how to process and use them.

A graph of all the assets used in a game.

Active patterns for recognizing asset file extensions.

The assets that come with the Nu Game Engine.

The assets that come with the Nu Game Engine.

AssetTag functions.

Describes a means for looking up an asset.

Describes a strongly-typed means for looking up an asset.

Converts AssetTag types, interning its strings for look-up speed.

AssetTag operators.

Additional assimp functionality. Intentionally prevents the original Assimp namespace from being opened.

The inferred attributes of an entity that are used to construct its bounds. HACK: added Unimportant field to allow attributes to be marked as unimportant. TODO: see if we can refactor this type to make its representation and algo less hacky.

A message to the audio system.

The audio player. Represents the audio subsystem of Nu generally.

Augments an entity with optional backdrop behavior.

Gives an entity the base behavior of a rigid 2d ball using dynamic physics.

Gives an entity the base behavior of a rigid 3d ball using dynamic physics.

Gives an entity the base behavior of basic static billboard emitter.

Augments an entity with basic static billboard emitter.

Gives an entity the base behavior of basic static sprite emitter.

Augments an entity with a basic static sprite emitter.

The batch phasing such involved in persisting OpenGL state.

Describes billboard-based particles.

A mutable billboard value type.

The blend mode of a sprite.

Blend-weights for a 3d terrain.

Blend-weighted material for a 3d terrain.

Gives an entity the base behavior of a rigid 2d block using static physics.

Gives an entity the base behavior of a rigid 3d block using static physics.

The data for a physics body event.

Identifies a body that can be found in a physics engine.

Describes a physics body intersection, such as found from a ray cast.

A joint on physics bodies. Because physics joints don't generalize well across 2D and 3D - or even across different 3D physics engines, we're currently only providing joint creation via the user-defined cases.

Gives an entity the base behavior of a physics-driven 2d joint.

Gives an entity the base behavior of a physics-driven 3d joint.

The data of a body joint break event.

A message from the physics system describing a body joint break.

Augments an entity with a physics-driven joint.

Identifies a joint in a physics engine.

Describes the universal properties of a body joint.

The data for a penetration event.

A message from the physics system describing body pentration that took place.

The properties needed to describe the physical part of a body.

The data for an explicit separation event. Unfortunately, due to the fact that physics system itself does not raise separation events until the following frame, we need both an implicit and explicit body separation representation and the user MUST handle both!

The data for an implicit separation event. Unfortunately, due to the fact that physics system itself does not raise separation events until the following frame, we need both an implicit and explicit body separation representation and the user MUST handle both!

A message from the physics system describing body separation that took place.

The shape of a physics body.

Identifies a body shape in a physics engine.

Describes body shape-specific properties.

Tje data for describing a change in transform.

A message from the physics system describing the updated transform of a body.

The type of a physics body.

Internal object that carries interstitial information between Nu and a physics engine.

Gives an entity the base behavior of a rigid 2d box using dynamic physics.

Gives an entity the base behavior of a rigid 3d box using dynamic physics.

Describes an event subscription that can be boxed / unboxed.

The shape of a physics body capsule.

The shape of a physics body box.

Provides operators for branchless programming. NOTE: implemented in terms of a static class to enable overloading.

Gives an entity the base behavior of a gui button.

Augments an entity with button behavior.

An internally cached animated model used to reduce GC promotion or pressure.

Describes an internally cached sprite used to avoid GC promotion of sprite descriptors.

An internally cached static model used to reduce GC promotion or pressure.

An internally cached static model surface used to reduce GC promotion or pressure.

The type of a subscription callback.

The shape of a physics body capsule.

Chain operators.

The Chain monad. Allows the user to define a chain of operations over the world that optionally spans across a bounded number of events.

ChainBuilder operators.

Implements the chain monad.

The data for a change in a simulant.

Gives an entity the base behavior of 2d physics-driven character in a platformer.

Gives an entity the base behavior of a 3d character.

The properties specific to the utilization of the character body types.

Describe the form of collision detection to use.

A model-message-command-content (MMCC) command tag type.

Provides engine-specific configuration functionality.

MMCC content declaration API.

MMCC content operators.

Provides core operations for basic Nu functionality.

The core operators that come with the Nu Game Engine.

Coroutine operators.

A coroutine in Nu allows easy definition of static behavior over multiple frames.

CoroutineBuilder operators.

A computation expression builder for Coroutine. Note that the "value" carried is simply unit as we are sequencing actions.

The result of stepping a coroutine.

A message to the physics system to create multiple bodies.

A message to the physics system to create a joint.

A message to the physics system to create a body.

Describes how to create a user-defined static model.

A phantom type to denote the type of an asset as a cube map.

DataToken functions.

Data tokens for downstream processing. NOTE: EffectToken exists only as a way to make effect emitters on emitters work due to issue #141. If we can cut this dependency then we can place this type definition above all the effects types in its own code folder.

Declaratively exposes simulant lenses and events.

Describes definition content to the model-message-command-content (MMCC) content system.

Specifies the type of desired fragment depth testing.

Specifies the desired screen, if any, or whether to ignore screen desire functionality altogether.

A message to the physics system to destroy multiple bodies.

A message to the physics system to destroy a joint.

A message to the physics system to destroy a body.

Describes how to destroy a user-defined static model.

Generalized interface tag for dispatchers.

The world's dispatchers (including facets). NOTE: it would be nice to make this record internal, but doing so would non-trivially increases the number of parameters of World.make, which is already rather long.

Describes the behavior of the screen dissolving algorithm.

The manner in which a gui entity may be docked by a parent entity.

Context for editing behavior.

Specifies an aspect of simulant editing to perform.

Enables common operations on 3D entities that intersect this entity's bounds. TODO: P1: implement EditAreaDispatcher for 2D entities.

Enables common operations on 3D entities that intersect this entity's bounds. TODO: P1: implement EditAreaFacet for 2D entities.

A time-based effect.

Gives an entity the base behavior of a 2d effect.

Gives an entity the base behavior of a 3d effect.

Augments an entity with an effect.

The endianness which indicates byte order in a raw asset.

The type around which the whole game engine is based! Used in combination with dispatchers to implement things like buttons, characters, blocks, and things of that sort.

A 2d entity dispatcher.

A 3d entity dispatcher.

Describes an entity to the MMCC content system.

Converts Entity types, interning its strings for look-up speed.

Describes an entity value independent of the engine. Used to directly serialize an entity.

The default dispatcher for entities.

Entity PropertyDescriptor functions.

Hosts the ongoing state of an entity.

Event functions.

The generalized event type (can be used to handle any event).

An event used by the event system.

Describes how events are filtered.

A functional publisher-neutral event mechanism for handling simulation events in Nu. Publisher-neutrality means that the user can subscribe to events regardless if the event source exists or not. This decouples subscription lifetime from event source lifetime.

Conveys debugging information about an event.

Engine and simulation events that come with Nu.

EventTrace functions.

Conveys an event's trace information.

Dynamically augments an entity's behavior in a composable way.

Gives an entity the base behavior of gui feeler (an invisible control that only takes mouse input).

Augments an entity with feeler behavior, acting as little invisible pane that produces touch events in response to mouse input.

Gives an entity the base behavior of gui fill bar.

Augments an entity with fill bar behavior.

A material as projected from images to a 3d terrain.

The direction in which a layout flows its children.

The manner in which a layout limits the flow its children.

Enables an entity to follow another entity (currently for 3D entities only).

A phantom type to denote the type of an asset as a font.

Represents an aspect of font styling.

Gives an entity the base behavior of a gui FPS counter.

The targeted frame rate.

Gives an entity the ability to freeze hierarchies of 3D entities.

The game type that hosts the various screens used to navigate through a game.

Describes a game to the model-message-command-content (MMCC) content system.

Converts Game types, interning its strings for look-up speed.

Describes a game value independent of the engine. Used to directly serialize a game.

The default dispatcher for games.

Describes a gamepad button.

The data for a gamepad button event.

Describes a gamepad direction.

The data for a gamepad button event.

Exposes the ongoing state of gamepads.

Game PropertyDescriptor functions.

Hosts the ongoing state of a game.

Provides a variable representation of time based on whether the engine is configured to use a static or a dynamic frame rate.

Type converter for GameTime.

Provides engine-specific value generation functionality.

Generates engine-specific values on-demand.

The shape of a physics body in terms of triangle faces.

Global mutable values. Any code that dynamically depends on these values must track their changes manually by internally keeping track of their last observed value and comparing it with the current one.

A simulant in the event system that is globalized and compatible with generalized events.

The OpenGL implementation of Renderer2d.

The OpenGL implementation of Renderer3d.

GlRendererImGui functions.

Renders an imgui view via OpenGL.

Forms a logical group of entities.

Describes a group to the model-message-command-content (MMCC) content system.

Converts Group types, interning its strings for look-up speed.

Describes a group value independent of the engine. Used to directly serialize a group.

The default dispatcher for groups.

Group PropertyDescriptor functions.

Hosts the ongoing state of a group.

A gui entity dispatcher.

Describes whether an in-flight event has been resolved or should cascade to down-stream handlers.

A height map for terrain.

Metadata for a height map, including resolution, normalized heights, and positions and texture coordinates.

Details additional editing behavior for hierarchy context menu.

A phantom type to denote the type of an asset as an image.

Wraps ImGui context, state, and calls. Also extends the ImGui interface with static methods. NOTE: API is primarily object-oriented / mutation-based because it's ported from a port.

The result of an imgui editing operation.

ImGuizmo functions.

The data for a physics integration event.

A message from the physics system.

The result of an intersection-detecting operation.

A job for threaded processing.

Processes jobs based on priority.

Processes jobs based on priority inline.

Processes jobs based on priority in parallel.

The result of running a job.

A message to the physics system to apply a jump motion to a body (KinematicCharacter only).

Justification (such as for text alignment).

Horizontal justification.

Vertical justification.

Denotes a key on the keyboard.

The data for a keyboard key event.

The data for a change in a simulant.

Gives an entity the base behavior of a gui label.

Generalized interface tag for late-bound objects.

Describes a layered rendering operation to a 2d rendering subsystem. NOTE: mutation is used only for internal caching.

A gui layout.

Augments an entity with the capability to perform layout transformations on its children.

Lens functions.

Provides access to the property of a simulant via an interface. Initially inspired by Haskell lenses, but specialized for simulant properties.

Provides access to the property of a simulant. Initially inspired by Haskell lenses, but highly specialized for simulant properties.

Lens operators.

The data for a life-cycle event.

Gives an entity the base behavior of a 3d light.

Augments an entity with a 3d light.

A mutable 3d light value type.

Configures 3d lighting and ssao.

Gives an entity the base behavior of a 3d lighting configuration.

Gives an entity the base behavior of a 3d light probe.

Augments an entity with a 3d light probe.

A mutable 3d light probe value type.

An aspect of a relation.

The synchronized global logging API.

Material functions.

Material description for surfaces.

MaterialProperties functions.

Material properties for surfaces. NOTE: this type has to go after TerrainMaterialProperties lest the latter's field names shadow this one's.

A model-message-command-content (MMCC) message tag type.

Metadata functions.

Metadata for an asset. Useful to describe various attributes of an asset without having the full asset loaded into memory.

The data for describing a mounting or unmounting event.

Describes a mouse button.

The data for a mouse button event.

The data for a mouse move event.

The data for a mouse wheel event.

Represents 3d navigation capabilies for a screen. NOTE: this type is intended only for internal engine use.

Configure the construction of 3d navigation meshes.

Augments an entity with a navigation mesh.

3d navigation input geometry provider.

Augments an entity with a 3d navigation body.

The data collected from a navigation builder result.

Identifies a navigation entry.

The result of a navigation computation.

The shape of a navigation body (includes both 2d and 3d representations, with some cases unsupported depending on the dimensionality of the system utilizing it).

Nu initialization functions. NOTE: this is a type in order to avoid creating a module name that may clash with the namespace name in an interactive environment.

Provides a way to make user-defined dispatchers, facets, and various other sorts of game- specific values and configurations.

An element in an octree.

Equality compares two octelements.

Masks for Octelement flags.

A spatial structure that organizes elements in a 3d grid.

Allows users to create their own one-body 2D joints.

Allows users to create their own one-body 3D joints.

Force qualification of OpenGL namespace in Nu unless opened explicitly.

An overlay.

Defines the manner in which overlays are applied to targets.

Describes the shape of a desired overlay.

Tracks assets as well as their originating file paths.

Describes asset packages.

A dictionary of asset packages.

Gives an entity the base behavior of a gui panel.

A mutable particle type.

The manner in which an entity paste operation should be executed.

Performs operations on System.String instances that contain file or directory path information. These operations are performed in a normalized manner where '/' is always used as the directory seperator.

Gives an entity the base behavior of a permafrozen hierarchy of potentially-rigid model surfaces.

Miscellaneous physics operations.

Represents a physics engine in Nu. TODO: investigate if we'll ever have to handle enough physics or integration messages to necessitate the use of SList instead of List.

The 2d implementation of PhysicsEngine in terms of Aether Physics.

The 2d implementation of PhysicsEngine in terms of Jolt Physics.

A message to the physics system.

The way in which an entity's motion is driven by a corresponding body.

Determines how an animated behavior is executed.

The shape of a physics body defined by body-relative points.

Describes the form of an element's presence.

Presence operators.

Describes the physical profile of a complex body.

Describes property content to the model-message-command-content (MMCC) content system.

PropertyDescriptor functions.

An element in a quadree.

Equality compares two quadelements.

Masks for Quadelement flags.

A spatial structure that organizes elements on a 2d plane.

Gives an entity the base behavior of a gui radio button.

Augments an entity with radio button behavior.

A phantom type to denote the type of an asset as a blob of raw data.

The format of a raw asset. NOTE: [] attribute was removed in order to work around an F# regression where calling GetUnionFields on this type's cases can result in an InvalidOperationException "Multiple CompilationMappingAttributes, expected at most one". TODO: apparently, one work-around for this regression is to update to the latest FSharp.Core as of the regression, version 9.0.3 (or higher), so let's do this when it makes sense then restore the Struct attribute.

A height map for 3d terrain constructed from a raw asset.

A refinement that can be applied to an asset during the build process.

Provides engine-specific reflection functionality.

Reflection operators.

Relation functions.

A relation that can be resolved to an address via contextual resolution. OPTIMIZATION: Links is an array only for speed; it is invalid to mutate it.

Converts Relation types.

Describes how to render an animated model.

Describes how to render multiple animated models with shared attributes.

An asset that is used for rendering.

Describes how to render a billboard.

Describes how to render billboard particles.

Describes how to render multiple billboards with shared attributes.

The 2d renderer. Represents a 2d rendering subsystem in Nu generally.

The 3d renderer. Represents a 3d rendering subsystem in Nu generally.

Configures 3d renderer.

Renders an imgui view. NOTE: API is object-oriented / mutation-based because it's ported from a port.

A non-threaded render process.

Renders 3D physics via ImGui.

A renderer process that may or may not be threaded. TODO: name all these abstract method parameters.

A threaded render process.

Describes how to render a 3D light.

Describes how to render a 3D light map.

Describes how to render a 3D light probe.

A message to a 2d rendering subsystem.

A message to the 3d renderer.

A message to the ImGui rendering subsystem.

Describes a 2d rendering operation.

Describes the nature of the rendering that takes place.

Describes how to render a sky box.

Describes how to render a static model.

Describes how to render multiple static model with shared attributes.

Describes how to render a static model surface.

Describes how to render a static model surface pre-batch.

Describes how to render multiple static model surface pre-batches with shared attributes.

The type of rendering used on a surface (for use by the higher-level engine API).

Describes how to render terrain.

The type of rendering used on a surface (for use by the lower-level renderer API).

Describes how to render a user-defined static model.

Represents different repetition modes for an animated behavior.

Details replacement for editing behavior for a simulant property, allowing the user to indicate that a property was replaced.

Specified the requested song, if any, or whether to ignore song request functionality altogether.

Effectively new-types the Regex type to implement custom type-conversion without needing explicit initialization by the client program.

Converts Rexpr types.

Augments an entity with a physics-driven rigid body.

Gives an entity the base behavior of physics-driven rigid model.

Gives an entity the base behavior of a hierarchy of indexed, physics-driven rigid models.

Gives an entity the base behavior of an indexed, physics-driven rigid model.

The timing with which an effect should be evaluated in a frame.

The screen type that allows transitioning to and from other screens, and also hosts the currently interactive groups of entities.

Describes the behavior of a screen.

Describes a screen to the model-message-command-content (MMCC) content system.

Converts Screen types, interning its strings for look-up speed.

Describes a screen value independent of the engine. Used to directly serialize a screen.

The default dispatcher for screens.

Screen PropertyDescriptor functions.

Hosts the ongoing state of a screen.

The SDL implementation of AudioPlayer.

Describes the general configuration of SDL.

The dependencies needed to initialize SDL.

Describes the initial configuration of a window created via SDL.

The data for a screen selection event.

Gives an entity the base behavior of physics-driven sensor model.

Gives an entity the base behavior of an indexed, physics-driven sensor model.

A message to the physics system to set the angular velocity of a body.

A message to the physics system to destroy a body.

A message to the physics system to destroy a body.

A message to the physics system to set the linear velocity of a body.

A message to the physics system to set the rotation of a body.

A message to the physics system to set the brake input of a vehicle body.

A message to the physics system to set the forward input of a vehicle body.

A message to the physics system to set the brake input of a vehicle body.

A message to the physics system to set the right input of a vehicle body.

A window for rendering in SDL OpenGL.

Signal functions.

A model-message-command-content (MMCC) signal tag type.

Signal operators.

A participant in the event graph.

Describes a simulant to the model-message-command-content (MMCC) content system.

Describes a generalized simulant value independent of the engine. Not used for serialization.

Generalized interface tag for simulant dispatchers.

Simulant operators.

Generalized interface for simulant state.

Gives an entity the base behavior of sky box.

Augments an entity with sky box.

The data required to execute slide screen presentation.

Describes the behavior of the screen slide algorithm.

Describes the type of snapshot taken for operation tracking.

A phantom type to denote the type of an asset as a song.

Describes a song.

Describes the information needed to sort simulants. OPTIMIZATION: carries related simulant to avoid GC pressure. NOTE: SortPriority can't be structified because it is currently cast to IComparable.

A phantom type to denote the type of an asset as a sound.

Describes a sound.

Gives an entity the base behavior of a rigid 2d sphere using static physics.

Gives an entity the base behavior of a rigid 3d sphere using static physics.

The shape of a physics body sphere.

Describes a Spine animation for a given track.

A phantom type to denote the type of an asset as a spine skeleton.

The data for describing an animation trigger event.

Describes how to render a Spine skeletong to the rendering system. NOTE: do NOT send your own copy of Spine.Skeleton as the one taken here will be operated on from another thread!

Gives an entity the base behavior of a Spine skeleton. NOTE: Spine skeletons are inherently imperative and therefore currently unsupported by undo / redo.

Augments an entity with Spine skeleton content. NOTE: SpineSkeleteState fields are inherently imperative and therefore currently unsupported by undo / redo.

Metadata of a Spine skeleton.

Represents the mutable backing state of an animating Spine skeleton. NOTE: this is inherently imperative and therefore currently unsupported by undo / redo.

Describes how to render a sprite to a rendering subsystem.

Describes how to render multiple sprite descriptors to a rendering subsystem.

Describes sprite-based particles.

Describes how to render multiple sprites to a rendering subsystem.

A mutable sprite value.

Gives an entity the base behavior of a static billboard.

Augments an entity with a static billboard.

A phantom type to denote the type of an asset as a static model.

Gives an entity the base behavior of a static model.

Augments an entity with a static model.

Gives an entity the base behavior of hierarchy of indexed static models.

The shape of a physics body in terms of a static model.

Describes a static model surface.

Gives an entity the base behavior of an indexed static model.

Augments an entity with an indexed static model surface.

Describes a pre-composed batch of static model surfaces.

The shape of a physics body in terms of a static model surface.

A mutable static model surface value type.

A mutable static model value type.

Gives an entity the base behavior of a static sprite.

Augments an entity with a static sprite.

Stream operators.

The Stream construct.

StructPair functions.

A struct-based representation of a pair. This type would seem redundant with struct (,) and KeyValuePair, but it's not. This type is unique in that allows you to take a reference to its Fst and Snd fields. Unfortunately, there seems to be no way to do that with struct (,) or KeyValuePair. NOTE: StructPair doesn't allow client assemblies to reference its fields, so it's not properly usable outside of Nu's engine code, unfortunately.

StructPair operators.

The stub implementation of AudioPlayer.

The stub implementation of PhysicsEngine.

The stub implementation of Renderer2d.

The stub implementation of Renderer3d.

StubRendererImGui functions.

A stub imgui renderer.

A map of event subscriptions.

An entry in the subscription map.

Abstracts over a subscription sorting procedure.

Describes the substantial nature of a body in terms of mass or density.

Provides references to symbols that are loaded from files.

Symbol loading metadata. OPTIMIZATION: made this a struct because, well, it's two booleans. If we add non-trivial fields to this, it will be okay to make it a reference type.

A tasklet to be completed at the scheduled time.

Describes a static 3d terrain.

Gives an entity the base behavior of a rigid 3d terrain.

Augments an entity with a rigid 3d terrain.

Describes a static 3d terrain geometry.

A layer from which a 3d terrain's material is composed.

Describes the material of which a 3d terrain is composed.

TerrainMaterialProperties functions.

Material properties for terrain surfaces.

The shape of a physics body in terms of a terrain height map.

Gives an entity the base behavior of a gui text box control.

Augments an entity with text box behavior.

Describes how to render text to a rendering subsystem.

Gives an entity the base behavior of a gui text control.

The data for a text edit event.

Augments an entity with text.

The data for a text input event.

A mutable text value.

Describes a Tiled tile animation.

Describes a Tiled tile.

A phantom type to denote the type of an asset as a tile map.

Describes a Tiled tile map.

Gives an entity the base behavior of an asset-defined tile map.

Augments an entity with a asset-defined tile map.

A tile map's metadata.

Describes how to render tile map tiles to the rendering system.

Thrown when a tile set property is not found.

Engine timing objects.

TmxMap functions for the world.

Gives an entity the base behavior of a user-defined tile map.

Augments an entity with a user-defined tile map.

Gives an entity the base behavior of gui toggle button.

Augments an entity with toggle button behavior.

Carries transformation data specific to an Entity.

The data of a body transform event.

Masks for Transform flags.

Describes one of a screen's transition processes.

The state of a screen's transition.

The type of a screen transition. Incoming means a new screen is being shown and Outgoing means an existing screen being hidden.

Tracks interpolated values typically used for traversal. TODO: P1: make this GameTime-based rather than frame-based!

Allows users to create their own two-body 2D joints.

Allows users to create their own two-body 3D joints.

Represents an unsubscription operation for an event.

A map of subscription keys to unsubscription data.

The properties needed to describe the vehicle aspects of a body.

Describes the bounds of a viewport. TODO: add missing doc comments to this type's functions.

Details additional editing behavior for viewport context menu.

Details the additional editing behavior for a simulant in a viewport.

A vui dispatcher (gui in 3d).

A window for rendering.

The world, in a functional programming sense. Hosts the simulation state, the dependencies needed to implement a game, messages to by consumed by the various engine subsystems, and general configuration data. For better ergonomics, the World type keeps a mutable reference to the functional WorldState, which is updated by the engine whenever the engine transforms the world state.

Audio functions for the world.

Chain functions for the world.

Configuration parameters for the world.

Data token processing functions for the world.

Entity functions for the world (2/2).

Game functions for the world (2/2).

Group functions for the world (2/2).

ImGui functions for the world.

More ImGui functions for the world.

ImSim API for the world.

HID input functions for the world.

Universal function definitions for the world (1/4).

Universal function definitions for the world (2/4).

Universal function definitions for the world (3/4).

Universal function definitions for the world (4/4).