API Reference

Ceramic

Type Kind Description
AllApi class Utility class to prevent dead code elimination of API classes.
AlphaColor abstract Color with alpha channel stored as a 32-bit integer.
AntialiasedTriangle class A specialized triangle shape that simulates antialiasing using additional vertices.
App class App class is the root instance of any ceramic app.
AppXUpdatesHandler class Internal handler for delayed update callbacks in the App class.
Arc class A mesh subclass for drawing arcs, pies, rings, and disc geometry.
ArrayPool class A pool system for efficiently reusing arrays of fixed sizes.
Assert class Assertion utility for runtime validation in debug builds.
Asset class Base class for all asset types in Ceramic.
AssetId abstract Type-safe wrapper for asset identifiers.
AssetOptions typedef Asset loading options.
AssetPathInfo class Information extracted from a raw asset path.
Assets class The main asset management class for Ceramic framework.
AssetsLoadMethod abstract Defines how assets should be loaded by the system.
AssetsScheduleMethod abstract Defines how multiple assets are scheduled for loading.
AssetStatus enum Represents the current loading state of an asset.
AtlasAsset class Asset for loading texture atlases (sprite sheets with metadata).
Audio class Main audio system manager for Ceramic.
AudioFilter class Base class for audio filters that can process audio buffers in real-time.
AudioFilterBuffer typedef Platform-specific audio filter buffer for real-time audio processing.
AudioFilters class Internal manager for audio filter worklets across audio buses.
AudioFilterWorklet class The actual worklet class that will do the audio processing of a given AudioFilter.
AudioMixer class Controls audio properties for a group of sounds.
AutoCollections interface Interface that enables automatic collection generation for classes.
BackgroundQueue class A thread-safe queue for executing functions serially in a background thread.
BezierEasing class High-performance Bezier curve easing for smooth animations.
BinaryAsset class Asset for loading binary files as raw bytes.
BitmapFont class A bitmap font implementation that handles both regular bitmap fonts and MSDF (Multi-channel Signe...
BitmapFontCharacter class Represents a single character (glyph) in a bitmap font.
BitmapFontData class Complete data structure containing all information about a bitmap font.
BitmapFontDataPage class Information about a single texture page in a multi-page bitmap font.
BitmapFontDistanceFieldData class Configuration data for distance field fonts (SDF/MSDF).
BitmapFontParser class Parser for bitmap font definition files in BMFont format.
Blending abstract Blending modes that control how pixels are combined when drawing.
Border class A rectangle visual that display a border
BorderPosition enum Defines where a border is positioned relative to a shape's edge.
Camera class A flexible camera system for 2D games.
Click class Component that detects click/tap events on visuals.
Closure class A simple closure implementation for storing a function with pre-bound arguments.
Collection abstract A type-safe collection for managing CollectionEntry items.
CollectionEntry class Base class for entries that can be stored in a Collection.
CollectionImpl class Internal implementation of the Collection abstract.
CollectionUtils class Utility functions for working with Collections.
Color abstract Class representing a color, based on Int.
Component interface Interface for components that can be attached to entities.
ComputeFps class A utility class for calculating frames per second (FPS) using a rolling average.
ConvertArray class Converter for array fields in fragments and data serialization.
ConvertColor class Converter for Color fields in fragments and data serialization.
ConvertComponentMap class Converter for component map fields in fragments and data serialization.
ConvertField interface Interface to convert basic type T to field type U and vice versa.
ConvertFont class Converter for BitmapFont fields in fragments and data serialization.
ConvertFragmentData class Converter for FragmentData fields in fragments and data serialization.
ConvertIntBoolMap class Converter for IntBoolMap fields in fragments and data serialization.
ConvertMap class Converter for Map fields in fragments and data serialization.
ConvertTexture class Converter for Texture fields in fragments and data serialization.
Csv class CSV parsing and generation utilities with proper escaping and quote handling.
CustomAssetKind class Defines a custom asset type that can be registered with the Assets system.
DatabaseAsset class Asset for loading CSV database files.
DecomposedTransform class Decomposed transform holds rotation, translation, scale, skew and pivot informations.
DoubleClick class Component that detects double-click/double-tap events on visuals.
DynamicData class A flexible component for attaching arbitrary data to entities.
Easing enum Enumeration of standard easing functions for animations.
EasingUtils class Utility functions for converting between Easing enum values and strings.
EditText class Component that enables text editing functionality for Text visuals.
Either abstract A type that can hold a value of either type T1 or type T2.
Entity class Base class for all entities in the Ceramic framework.
EntityData class Static utilities for managing dynamic data on entities.
Enums class Macro utilities for working with enum values at compile time.
Equal class Deep equality comparison utilities for various data types.
Errors class Global error handling utilities for the Ceramic engine.
Extensions class A collection of static extension methods for common data types.
FieldInfo class Runtime reflection utility for extracting field type information from classes.
FieldMeta class Runtime reflection utility for accessing field metadata.
Files class Cross-platform filesystem utilities for Ceramic.
FileWatcher class Cross-platform file monitoring system for hot-reloading and file change detection.
Filter class A visual container that renders its children to a texture for post-processing effects.
Flags abstract Efficient bit flag storage using a single integer.
Float32Array typedef A typed array of 32-bit floating point values.
FontAsset class Asset type for loading bitmap fonts.
Fragment class A fragment is a powerful container that manages groups of entities and visuals
FragmentData typedef Data structure that defines a fragment's content and properties.
FragmentItem typedef Defines an entity instance within a fragment.
Fragments class A compile-time generated class containing constants for all fragment assets.
FragmentsAsset class An asset that loads and manages fragment data from .fragment files.
GamepadAxis abstract Represents gamepad analog stick and trigger axes.
GamepadButton abstract Represents gamepad button mappings.
GeometryUtils class A collection of static utility functions for 2D geometric calculations.
GlyphQuad class A specialized Quad that represents a single rendered glyph (character) in text rendering.
Group class A container for managing collections of entities as a single unit.
HashedString class A utility class for encoding and decoding strings with integrity verification using MD5 hashes.
HighPassFilter class A high-pass audio filter that attenuates frequencies below a cutoff point.
HighPassFilterWorklet class The audio processing worklet for the high-pass filter.
ImageAsset class Asset type for loading image files as textures.
ImageType abstract Supported image file formats for loading and exporting images.
Immediate class A utility class for scheduling callbacks to be executed in a batch.
InitSettings class Same as Settings, but for app startup (inside Project.new(settings)).
Input class Manages all input handling for keyboard and gamepad devices.
IntBoolMap abstract A map that uses int as keys and booleans as values.
IntBoolMapIterator class
IntBoolMapKeyIterator class
IntBoolMapKeyValueIterator class
IntFloatMap class Fallback implementation of IntFloatMap for non-C++/C# targets.
IntFloatMapIterator class
IntFloatMapKeyIterator class
IntFloatMapKeyValueIterator class
IntIntMap class
IntIntMapIterator class
IntIntMapKeyIterator class
IntIntMapKeyValueIterator class
IntMap class An object map that uses integers as key.
IntMapIterator class
IntMapKeyIterator class
IntMapKeyValueIterator class
Json class JSON utility class that provides a unified interface for JSON operations across all Ceramic targets.
Key class Represents a keyboard key press event with both key code and scan code information.
KeyAcceleratorItem enum Represents a component of a keyboard shortcut combination.
KeyBinding class Represents a keyboard shortcut binding that triggers when a specific key combination is pressed.
KeyBindings class Manages a collection of keyboard shortcut bindings.
KeyCode abstract Keyboard key codes representing the character/symbol associated with a key.
Layer class A specialized container for organizing and grouping visuals.
Lazy interface Interface for implementing lazy initialization of properties in Ceramic classes.
Line class Display lines composed of multiple segments, curves and paths.
LineCap typedef Defines how line ends are rendered.
LineJoin typedef Defines how line segments are joined at corners.
Logger class Centralized logging system for Ceramic applications that provides colored, categorized output.
LongPress class Component that detects long press/hold gestures on visuals.
LowPassFilter class A low-pass audio filter that attenuates frequencies above a cutoff point.
LowPassFilterWorklet class The audio processing worklet for the low-pass filter.
LowRes class A container that displays visuals at low resolution with optional antialiasing through supersampl...
DefinesMacro class Utilities to access compile-time defines from code.
EnumAbstractMacro class Utility macros for working with enum abstracts at compile time.
PluginsMacro class Macro for automatic plugin initialization in the Ceramic framework.
Mesh class A flexible visual for drawing custom shapes composed of triangles.
MeshColorMapping abstract Defines how colors are mapped to a mesh's geometry.
MeshExtensions class Static extension class providing utility methods for Mesh manipulation.
MeshPool class A global object pool for efficiently reusing Mesh instances and their arrays.
MeshUtils class Low-level utility class for generating mesh data arrays.
MouseButton abstract A typed (mouse) button id
Ngon class A mesh that creates regular polygons with a configurable number of sides.
NineSlice class A visual divided into 9 areas to create "nine-slice" textured scalable objects.
NineSliceRendering abstract Defines how a slice (from a NineSlice object) should be rendered.
ParticleEmitter class A powerful and flexible particle emitter system for creating visual effects.
ParticleItem class Represents a single particle in a particle system.
Particles class A visual container that manages a particle emitter with convenient automatic emission modes.
ParticlesLaunchMode enum Defines how particle velocities are calculated when launched from an emitter.
ParticlesStatus enum Represents the current operational state of a particle emitter.
Path class Cross-platform path manipulation utilities optimized for Ceramic.
PersistentData class Provides a simple key-value storage system for persisting data between application sessions.
PixelArt class A filter configured to display pixel art content with high-quality upscaling.
Pixels class Utility class for manipulating raw RGBA pixel data.
Platform class A class that encapsulate platform-specific code.
Point class A mutable 3D point class with automatic object pooling for memory efficiency.
Pool class A generic object pool utility.
Preloadable interface Interface for objects that can report their loading progress.
PreloadStatus abstract Status values for preloadable resources.
PremultiplyAlpha class Utilities for converting between straight and premultiplied alpha in image data.
Quad class The most basic and commonly used visual for displaying rectangles and images.
ReadOnlyArray abstract ReadOnlyArray is an abstract over an ordinary Array which only exposes
ReadOnlyMap abstract A read-only view of a Map that prevents modification.
ReadOnlyPoint abstract A read-only view of a Point that prevents modification.
Renderer class The core 2D rendering engine for Ceramic, responsible for efficiently drawing all visuals to the ...
RenderPrimitiveType abstract Defines the primitive types used for rendering geometry.
RenderTexture class A texture that can be rendered to, allowing off-screen rendering.
Repeat class A visual component that repeats a texture pattern to fill a specified area.
ReusableArray class A reusable array to use in places that need a temporary array many times.
Runner class Cross-platform thread management utility for executing code on main and background threads.
RuntimeAssets class Runtime utilities to compute asset lists/names from raw (relative) file list.
ScanCode abstract Keyboard scan codes representing physical key positions.
Scene class Base class for creating scenes in Ceramic.
SceneStatus abstract Represents the lifecycle status of a Scene in the Ceramic framework.
SceneSystem class Core system responsible for managing scene lifecycle, transitions, and display hierarchy.
Screen class Core screen management class that handles display properties, coordinate transformations, and inp...
ScreenOrientation abstract Defines screen orientation modes for mobile and desktop applications.
ScreenScaling enum Defines how the application's logical screen size is mapped to the native screen.
ScriptableAlphaColor class Scriptable wrapper for AlphaColor to expose RGBA color functionality to scripts.
ScriptableBlending class Scriptable wrapper for Blending enum to expose blending modes to scripts.
ScriptableColor class Scriptable wrapper for Color to expose RGB color functionality to scripts.
ScriptableFlags class Scriptable wrapper for Flags to expose bit flag operations to scripts.
ScriptableMap interface Scriptable interface for Map to expose key-value mapping functionality to scripts.
ScriptableMeshColorMapping class Scriptable wrapper for MeshColorMapping to expose mesh coloring modes to scripts.
ScriptableMouseButton class Scriptable wrapper for MouseButton to expose mouse button constants to scripts.
ScriptableStd class Scriptable wrapper for Std to expose standard library functions to scripts.
ScrollDirection enum Defines the direction of scrolling for scrollable components.
Scroller class A scrollable container that allows smooth scrolling and dragging of content.
ScrollerDragThresholdStatus abstract
ScrollerStatus enum Represents the current state of a Scroller component during user interaction.
SeedRandom class Seeded random number generator to get reproducible sequences of values.
SelectText class Component that handles text selection and cursor display for Text visuals.
Settings class Central configuration hub for Ceramic applications.
Shader class Represents a GPU shader program for custom rendering effects.
ShaderAsset class Asset type for loading GPU shader programs.
ShaderAttribute class Defines a vertex attribute for shader programs.
Shape class A visual for drawing arbitrary 2D shapes with automatic triangulation.
Shortcuts class Convenience static accessors and utility methods for common Ceramic functionality.
Slug class URL-safe string generator that converts text into slugs suitable for URLs and filenames.
SlugOptions class Configuration options for slug generation.
SortVisuals class High-performance stable merge sort implementation specifically optimized for Visual arrays.
SortVisualsByDepth class Simplified high-performance stable merge sort for Visual arrays based on depth only.
Sound class Represents a loaded sound that can be played multiple times.
SoundAsset class Asset type for loading audio/sound files.
SoundPlayer abstract Controls an individual sound playback instance.
SpinLock abstract Lightweight spin lock implementation for low-contention thread synchronization.
State class Base class for states in a state machine.
StateMachine class A flexible state machine implementation for managing state transitions.
StateMachineBase class Base class for state machine implementations.
StateMachineComponent class A state machine that can be attached to entities as a component.
StateMachineImpl class Implementation class for StateMachine functionality.
StateMachineSystem class System that manages and updates all active state machines.
System class A System is an object assigned to app lifecycle and used to
Systems class Manager for all System instances in the application.
Task class Base class for asynchronous tasks that can either succeed or fail.
Tasks class Utility class for running Task instances from command-line arguments.
Text class A visual to layout and display text.
TextAlign enum Horizontal text alignment options for text rendering.
TextAsset class Asset type for loading text files.
TextInput class Handles keyboard text input and cursor navigation.
TextInputDelegate interface Interface for text layout information providers used by text input systems.
Texture class A texture represents an image loaded in GPU memory ready for rendering.
TextureAtlas class A texture atlas that combines multiple images into larger textures for efficient rendering.
TextureAtlasPacker class Dynamic texture atlas builder that packs multiple images into optimized texture pages at runtime.
TextureAtlasPage class Represents a single texture page within a texture atlas.
TextureAtlasParser class Parser for texture atlas definition files in multiple formats.
TextureAtlasRegion class Represents a single image region within a texture atlas.
TextureFilter enum Texture filtering modes that control how pixels are sampled when textures are scaled.
TextureTile class Defines a rectangular sub-region within a texture for rendering.
TextureTilePacker class Dynamic texture tile allocator with automatic packing and reuse capabilities.
TextureWrap abstract Texture wrapping modes for handling UV coordinates outside the 0-1 range.
Timeline class An animation timeline system that manages keyframe-based animations.
TimelineBoolKeyframe class A keyframe that stores a boolean value for timeline animations.
TimelineBoolTrack class A timeline track that animates boolean values.
TimelineColorKeyframe class A keyframe that stores a color value for timeline animations.
TimelineColorTrack class A timeline track that animates color values with smooth interpolation.
TimelineDegreesTrack class A specialized timeline track for animating rotation values in degrees.
TimelineFloatArrayKeyframe class A keyframe that stores an array of floating-point values for timeline animations.
TimelineFloatArrayTrack class A timeline track that animates arrays of floating-point values.
TimelineFloatKeyframe class A keyframe that stores a floating-point value for timeline animations.
TimelineFloatTrack class A timeline track that animates floating-point values with smooth interpolation.
TimelineKeyframe class
TimelineKeyframeData typedef Data structure representing a keyframe in serialized form.
Timelines class Central system for creating and binding timeline tracks and keyframes.
TimelineTrack class Base class for animation tracks in a timeline system.
TimelineTrackData typedef Data structure representing an animation track in serialized form.
Timer class Timer system for scheduling delayed and periodic callbacks.
TimerCallback class Internal data structure representing a scheduled timer callback.
Touch class Represents a single touch point in a multi-touch interaction.
Touches abstract A collection of active touch points for multi-touch handling.
TouchesIterator class Iterator for the Touches collection.
TouchInfo class
TrackerBackend class Backend adapter that bridges the Tracker observable framework with Ceramic's backend services.
Transform class Transform holds matrix data to make 2d rotate, translate, scale and skew transformations.
TransformPool class An utility to reuse transform matrix object at application level.
Triangle class A simple colored triangle shape that fits within the specified dimensions.
Triangulate class Utility class for triangulating polygons into triangles.
Tween class A lightweight tweening engine for animating numeric values over time.
UInt8Array typedef Platform-specific implementation of an 8-bit unsigned integer array.
Utils class Various utilities. Some of them are used by ceramic itself or its backends.
Value class An object that can hold any value.
ValueEntry class A collection entry that can hold any value.
Velocity class A velocity tracker that calculates speed based on position changes over time.
VisibleBounds class A component that displays the visible bounds of a visual entity.
Visual class Base class for all visual elements in Ceramic.
VisualTransition class A component that enables smooth property transitions for Visual objects.
VisualTransitionProperties abstract Property setter interface for visual transitions.
WaitCallbacks class Utility to create and wait for multiple callbacks and call
WatchDirectory class A directory watcher that monitors file changes in specified directories.
WatchedFile class Internal data structure for tracking watched file state.
TextureAtlasPackerPage class Internal representation of a texture page during packing.
TextureAtlasPackerRegion class Internal data structure for regions during the packing process.
TextureAtlasReader class Internal line-based reader for parsing LibGDX format atlas files.
PackedTextureTile class Internal texture tile implementation with grid allocation metadata.
EarClippingTriangulator class Implementation of the ear-clipping algorithm for polygon triangulation.
TweenEasingFunction class Internal utility class containing easing function implementations.

Arcade

Type Kind Description
Axis abstract Represents axis constants for physics calculations and collision detection.
Body class The Physics Body is linked to a single game object.
Collidable interface Any class implementing this interface can be used on World.collide()
Direction abstract Represents directional constants used for physics body movement and collision detection.
Extensions class A bunch of static extensions to make life easier.
Group class A Group is a container for multiple physics bodies.
Line class Represents a line segment with a start and end point.
Point class A 2D point with x and y coordinates.
QuadTree class A QuadTree implementation.
QuadTreePool class Object pool for QuadTree instances to reduce garbage collection overhead.
SortBodiesBottomTop class Provides a stable merge sort implementation for sorting Body arrays from bottom to top (by y coor...
SortBodiesLeftRight class Provides a stable merge sort implementation for sorting Body arrays from left to right (by x coor...
SortBodiesRightLeft class Provides a stable merge sort implementation for sorting Body arrays from right to left (by x coor...
SortBodiesTopBottom class Provides a stable merge sort implementation for sorting Body arrays from top to bottom (by y coor...
SortDirection abstract Defines sorting directions for physics bodies during collision detection.
World class The Arcade Physics world. Contains Arcade Physics related collision, overlap and motion methods.
ArcadeSortGroupBottomTop class Specialized merge sort implementation for sorting physics bodies.
ArcadeSortGroupLeftRight class Specialized merge sort implementation for sorting physics bodies.
ArcadeSortGroupRightLeft class Specialized merge sort implementation for sorting physics bodies.
ArcadeSortGroupTopBottom class Specialized merge sort implementation for sorting physics bodies.
ArcadeSystem class Main system managing Arcade physics simulation in Ceramic.
ArcadeWorld class Extended physics world that integrates Arcade physics with Ceramic's visual system.
VisualArcadePhysics class Component that adds Arcade physics functionality to a Visual.

Tilemap

Type Kind Description
AutoTile class Configuration for an auto-tiling tile that automatically adjusts its appearance
AutoTileKind abstract Defines the type of auto-tiling algorithm used by the AutoTiler component.
AutoTiler class Component that automatically processes tilemap tiles to apply auto-tiling rules.
ConvertTilemapData class Field converter that handles conversion between tilemap asset names (strings)
Tilemap class A visual component that renders tilemap data composed of multiple layers.
TilemapAsset class Asset type for loading tilemap data from various formats (TMX, LDtk).
TilemapData class Unified tilemap data structure that represents a tile-based map.
TilemapEditor class Interactive tilemap editor component that enables in-game tile painting and erasing.
TilemapLayer class Visual representation of a single layer within a tilemap.
TilemapLayerData class Data model representing a single layer within a tilemap.
TilemapOrientation enum Defines the projection orientation of a tilemap.
TilemapParser class Universal tilemap parser supporting multiple tilemap formats.
TilemapPlugin class Main plugin class that integrates tilemap support into Ceramic.
TilemapQuad class Specialized Quad visual used to render individual tiles in a tilemap layer.
TilemapRenderOrder enum Defines the order in which tiles are rendered in a tilemap.
TilemapStaggerAxis enum Defines the stagger axis for hexagonal and staggered tilemaps.
TilemapStaggerIndex enum Defines which rows or columns are staggered in hexagonal and staggered tilemaps.
TilemapTile abstract Represents a single tile in a tilemap, storing both the tile ID and transformation flags.
TilemapTmxParser class Internal parser for TMX (Tiled Map Editor) format files.
Tileset class Represents a collection of tiles used by a tilemap.
TilesetGridOrientation enum Defines the grid orientation for tiles within a tileset.
TilesetImage class Represents the image resource used by a tileset.
TileSlope class Defines slope collision data for a tile in a tileset.

Ldtk

Type Kind Description
LdtkAutoLayerRuleDefinition class This complex section isn't meant to be used by game devs according to LDtk documentation,
LdtkAutoRuleGroup class
LdtkBackgroundPosition class
LdtkCheckerMode abstract
LdtkData class Root class representing an LDtk project data structure.
LdtkDataHelpers class
LdtkDefinitions class Contains all the definitions used in an LDtk project.
LdtkEmbedAtlas abstract
LdtkEntityDefinition class Defines an entity type that can be placed in levels.
LdtkEntityInstance class An instance of an entity placed in a level.
LdtkEnumDefinition class
LdtkEnumTag class
LdtkEnumValueDefinition class
LdtkFieldDefinition class
LdtkFieldInstance class An instance of a custom field value.
LdtkIntGridValue class
LdtkLayerDefinition class Defines a layer type that can be used in levels.
LdtkLayerInstance class An instance of a layer in a level.
LdtkLayerType abstract
LdtkLevel class Represents a single level in an LDtk world.
LdtkLevelLocation abstract
LdtkLevelNeighbour class
LdtkRenderMode abstract
LdtkTileCustomData class
LdtkTileMode abstract
LdtkTileRenderMode abstract
LdtkTilesetDefinition class
LdtkTilesetRectangle class This object represents a custom sub rectangle in a Tileset image.
LdtkTocEntry class Represents a Table of Contents entry for entities marked with exportToToc.
LdtkTocInstanceData class Contains instance data for an entity referenced in the table of contents.
LdtkVisual class A default visual implementation to render LDtk entities.
LdtkWorld class Represents a world in an LDtk project.
LdtkWorldLayout abstract
TilemapLdtkParser class Parser that converts LDtk level data into Ceramic tilemap data structures.
TilemapLdtkParser_Fields_ class

Spine

Type Kind Description
BindSlotOptions typedef Configuration options for binding Spine slots together.
ConvertSpineData class Converter for Spine animation data fields in entity components.
SlotInfo class Information about a slot being updated during rendering.
Spine class Spine animation runtime for Ceramic engine.
SpineAsset class Asset loader for Spine 2D skeletal animation data.
SpineBindVisual class Utility class for binding Ceramic visuals to Spine skeleton slots.
SpineBindVisualOptions class Configuration options for binding a Ceramic visual to a Spine slot.
SpineBounds class Data structure representing the computed bounding box of a Spine animation.
SpineColors class Utility class for extracting color information from Spine animation slots.
SpineData class Container for loaded Spine animation data, including skeleton structure and texture atlas.
SpineFile class Implementation of Spine's FileHandle interface for Ceramic.
SpineListener class Internal listener for Spine animation state events.
SpineMontage class A powerful utility for managing and orchestrating Spine animations as a cohesive montage.
SpineMontageAnimation class Configuration data for a single animation within a SpineMontage.
SpineMontageDefaults class Default configuration values for animations in a SpineMontage.
SpineMontageSettings class Complete configuration for initializing a SpineMontage.
SpineMontageSpineSettings class Configuration for the Spine instance used by a SpineMontage.
SpinePlugin class Plugin that integrates the Spine 2D skeletal animation runtime into Ceramic.
SpineSystem class System responsible for updating all active Spine instances in the application.
SpineTextureLoader class Custom texture loader implementation for integrating Spine with Ceramic's asset system.
AlphaTimeline class Changes the alpha for a slot's {@link Slot#getColor()}.
Animation class Stores a list of timelines to animate a skeleton's pose over time.
AnimationState class Applies animations over time, queues animations for later playback, mixes (crossfading) between a...
AnimationStateAdapter class
AnimationStateData class Stores mix (crossfade) durations to be applied when {@link AnimationState} animations are changed.
AnimationStateDataKey class
AnimationStateListener interface The interface to implement for receiving TrackEntry events.
AtlasAttachmentLoader class An {@link AttachmentLoader} that configures attachments using texture regions from an {@link Atlas}.
Attachment class The base class for all attachments.
AttachmentLoader interface The interface which can be implemented to customize creating and populating attachments.
AttachmentType abstract Spine Runtimes License Agreement
AttachmentType_enum class
BoundingBoxAttachment class An attachment with vertices that make up a polygon.
ClippingAttachment class An attachment with vertices that make up a polygon used for clipping the rendering of other attac...
MeshAttachment class An attachment that displays a textured mesh.
PathAttachment class An attachment whose vertices make up a composite Bezier curve.
PointAttachment class An attachment which is a single point and a rotation.
RegionAttachment class An attachment that displays a textured quadrilateral.
VertexAttachment class Base class for an attachment with vertices that are transformed by one or more bones and can be d...
AttachmentTimeline class Changes a slot's {@link Slot#getAttachment()}.
BlendMode abstract Determines how images are blended with existing pixels when drawn.
BlendMode_enum class
Bone class Stores a bone's current pose.
BoneData class Stores the setup pose for a {@link Bone}.
BoneTimeline interface An interface for timelines which change the property of a bone.
ConstraintData class The base class for all constraint datas.
CurveTimeline class The base class for timelines that interpolate between frame values using stepped, linear, or a Be...
CurveTimeline1 class The base class for a {@link CurveTimeline} that sets one property.
CurveTimeline2 class The base class for a {@link CurveTimeline} which sets two properties.
DeformTimeline class Changes a slot's {@link Slot#getDeform()} to deform a {@link VertexAttachment}.
DrawOrderTimeline class Changes a skeleton's {@link Skeleton#getDrawOrder()}.
Event class Stores the current pose values for an {@link Event}.
EventData class Stores the setup pose values for an {@link Event}.
EventQueue class
EventTimeline class Fires an {@link Event} when specific animation times are reached.
EventType abstract
EventType_enum class
IkConstraint class Stores the current pose for an IK constraint.
IkConstraintData class Stores the setup pose for an {@link IkConstraint}.
IkConstraintTimeline class Changes an IK constraint's {@link IkConstraint#getMix()}, {@link IkConstraint#getSoftness()},
LinkedMesh class
MixBlend abstract Controls how timeline values are mixed with setup pose values or current pose values when a timel...
MixBlend_enum class
MixDirection abstract Indicates whether a timeline's alpha is mixing out over time toward 0 (the setup or ...
MixDirection_enum class
PathConstraint class Stores the current pose for a path constraint.
PathConstraintData class Stores the setup pose for a {@link PathConstraint}.
PathConstraintMixTimeline class Changes a transform constraint's {@link PathConstraint#getMixRotate()}, {@link PathConstraint#get...
PathConstraintPositionTimeline class Changes a path constraint's {@link PathConstraint#getPosition()}.
PathConstraintSpacingTimeline class Changes a path constraint's {@link PathConstraint#getSpacing()}.
PositionMode abstract Controls how the first bone is positioned along the path.
PositionMode_enum class
Property abstract
Property_enum class
RGB2Timeline class Changes the RGB for a slot's {@link Slot#getColor()} and {@link Slot#getDarkColor()} for two colo...
RGBA2Timeline class Changes a slot's {@link Slot#getColor()} and {@link Slot#getDarkColor()} for two color tinting.
RGBATimeline class Changes a slot's {@link Slot#getColor()}.
RGBTimeline class Changes the RGB for a slot's {@link Slot#getColor()}.
RotateMode abstract Controls how bones are rotated, translated, and scaled to match the path.
RotateMode_enum class
RotateTimeline class Changes a bone's local {@link Bone#getRotation()}.
ScaleTimeline class Changes a bone's local {@link Bone#getScaleX()} and {@link Bone#getScaleY()}.
ScaleXTimeline class Changes a bone's local {@link Bone#getScaleX()}.
ScaleYTimeline class Changes a bone's local {@link Bone#getScaleY()}.
ShearTimeline class Changes a bone's local {@link Bone#getShearX()} and {@link Bone#getShearY()}.
ShearXTimeline class Changes a bone's local {@link Bone#getShearX()}.
ShearYTimeline class Changes a bone's local {@link Bone#getShearY()}.
Skeleton class Stores the current pose for a skeleton.
SkeletonBounds class Collects each visible {@link BoundingBoxAttachment} and computes the world vertices for its polygon.
SkeletonData class Stores the setup pose and all of the stateless data for a skeleton.
SkeletonJson class Loads skeleton data in the Spine JSON format.
SkeletonLoader class Base class for loading skeleton data from a file.
Skin class Stores attachments by slot index and attachment name.
SkinEntry class Stores an entry in the skin consisting of the slot index and the attachment name.
Slot class Stores a slot's current pose.
SlotData class Stores the setup pose for a {@link Slot}.
SlotTimeline interface An interface for timelines which change the property of a slot.
SpacingMode abstract Controls how bones after the first bone are positioned along the path.
SpacingMode_enum class
Error class
IllegalArgumentException class
IllegalStateException class
RuntimeException class
ArrayExtensions class
FileExtensions class
SpineExtensions class
StringExtensions class
FileHandle interface
AtlasPage class
AtlasRegion class
AtlasRegionTexture abstract
Color class Color class ported from some of libgdx's Color code.
Format abstract
GL20 typedef
Reader class
TextureAtlas class
TextureFilter abstract
TextureLoader interface
TextureRegion class
TextureWrap class
MathUtils class
Matrix3 class
Vector2 class
AnimationStateMap abstract
Array abstract
AttachmentSet abstract
AttachmentSetEntry class
BooleanArray abstract
Either abstract Useful to limit a Dynamic function argument's type to the specified
FastCast class
FloatArray abstract
FloatArray2D typedef
IntArray abstract
IntArray2D typedef
JsonChild class
JsonDynamic class
JsonReader class
JsonValue interface
ObjectSet abstract
Pool class
Poolable interface Objects implementing this interface will have {@link #reset()} called when passed to {@link Pool#...
SerializationException class
Short typedef
ShortArray typedef
ShortArray2D typedef
SnapshotArray class
StdEx class
StringArray typedef
StringBuilder abstract
Timeline class The base class for all timelines.
TrackEntry class Stores settings and other state for the playback of an animation on an {@link AnimationState} track.
TransformConstraint class Stores the current pose for a transform constraint.
TransformConstraintData class Stores the setup pose for a {@link TransformConstraint}.
TransformConstraintTimeline class Changes a transform constraint's {@link TransformConstraint#getMixRotate()}, {@link TransformCons...
TransformMode abstract Determines how a bone inherits world transforms from parent bones.
TransformMode_enum class
TranslateTimeline class Changes a bone's local {@link Bone#getX()} and {@link Bone#getY()}.
TranslateXTimeline class Changes a bone's local {@link Bone#getX()}.
TranslateYTimeline class Changes a bone's local {@link Bone#getY()}.
Updatable interface The interface for items updated by {@link Skeleton#updateWorldTransform()}.
SkeletonClipping class Spine Runtimes License Agreement
SpineUtils class Spine Runtimes License Agreement
Triangulator class Spine Runtimes License Agreement
BindSlot class
DispatchSlotInfo class
TrackEntryPool class
PolygonPool class
Entry class
IndicesPool class
PolygonPool class

Script

Type Kind Description
Interp class Custom HScript interpreter with Ceramic-specific functionality.
Script class Dynamic scripting component for runtime code execution.
ScriptContent typedef Type alias for script source code content.
ScriptModule class Represents a script module for inter-script communication.
ScriptUtils class Utilities for converting JavaScript/TypeScript syntax to HScript.

Sprite

Type Kind Description
AsepriteJson typedef Data structure representing the JSON format exported by Aseprite.
AsepriteJsonFrame typedef Individual frame definition within the sprite sheet.
AsepriteJsonFrameTag typedef Animation definition in Aseprite, called a "frame tag".
AsepriteJsonFrameTagDirection abstract Animation playback direction for frame tags.
AsepriteJsonLayer typedef Layer information from the original Aseprite file.
AsepriteJsonMeta typedef Metadata section of the Aseprite JSON export.
AsepriteJsonParser class Parser for Aseprite JSON format sprite sheets.
AsepriteJsonRect typedef Rectangle structure with position and dimensions.
AsepriteJsonSize typedef Size structure for dimensions without position.
AsepriteJsonSlice typedef Slice definition for 9-slice scaling and UI elements.
ConvertSpriteSheet class Field converter for SpriteSheet instances.
Sprite class Sprite visual that displays animations from sprite sheets.
SpriteAsset class Asset loader for sprite sheets and animations.
SpritePlugin class Plugin that adds sprite sheet and animation support to Ceramic.
SpriteSheet class Container for sprite animations and texture atlas data.
SpriteSheetAnimation class Represents a named animation sequence within a sprite sheet.
SpriteSheetFrame class Represents a single frame within a sprite animation.
SpriteSheetParser class Generic sprite sheet data parser with auto-detection.
SpriteSystem class System that manages automatic updates for all Sprite instances.

Ui

Type Kind Description
ChildrenDepth abstract Determines how child elements are assigned depth values in the UI hierarchy.
CollectionView class A scrollable collection view that efficiently displays large data sets using view recycling.
CollectionViewDataSource interface Interface for providing data to a CollectionView.
CollectionViewFlowLayout class A flow-based layout for CollectionView that arranges items in rows or columns.
CollectionViewItemFrame class Represents the position and dimensions of an item in a CollectionView.
CollectionViewItemPosition abstract Defines where an item should be positioned when scrolling to it in a CollectionView.
CollectionViewItemsBehavior abstract Defines how a CollectionView manages item view creation and recycling.
CollectionViewLayout interface Interface for custom CollectionView layout implementations.
ColumnLayout class A specialized LinearLayout that arranges children vertically in a single column.
ComputedViewSize class Represents computed size information for a View during the layout process.
ImageView class A view component for displaying and laying out images with flexible scaling options.
ImageViewScaling enum Defines scaling modes for ImageView to control how images are sized within their bounds.
LayersLayout class A layout container that stacks children on top of each other like layers.
LayoutAlign enum General-purpose alignment enumeration for UI layouts.
LayoutDirection enum Defines the primary axis direction for layout arrangements.
LayoutHorizontalAlign enum Horizontal alignment options for UI elements within their containers.
LayoutVerticalAlign enum Vertical alignment options for UI elements within their containers.
LinearLayout class A flexible layout container that arranges its children in a single line,
RowLayout class A layout that arranges its children horizontally in a single row.
ScrollView class A view that provides scrolling functionality for content that exceeds its bounds.
TextView class A view that displays text with automatic sizing and alignment options.
View class The base view class for building UI layouts in Ceramic.
ViewLayoutMask abstract Bit mask that defines layout constraints for views.
ViewSize abstract Type-safe representation of view sizing modes.
ViewSystem class System responsible for managing and updating the UI view layout.

Dialogs

Type Kind Description
Dialogs class Cross-platform native file dialog implementation.
DialogsFileFilter typedef File type filter specification for native file dialogs.
DialogsPlugin class Plugin initialization for native file dialogs support.
Dialogs class
FileFilter typedef

Gif

Type Kind Description
GifCapture class Captures the screen content and creates animated GIF files.
GifEncoder class
GifFrame typedef
GifQuality abstract
GifRepeat abstract
LzwEncoder class
NeuQuant class

Tracker

Type Kind Description
Assert class
Autorun class
DynamicEvents class Fire and listen to dynamic events. Works similarly to static events, but dynamic.
Equal class
EventDispatcher class Event dispatcher used by DynamicEvents and Events macro as an alternative implementation
Events interface Events allows to add strictly typed events to classes.
Extensions class A bunch of static extensions to make life easier.
History class
Model class
Observable interface Observable allows to observe properties of an object.
SaveModel class
Serializable interface
Serialize class
SerializeChangeset class
SerializeModel class Utility to serialize a model object (and its children) continuously and efficiently
ShareChangeset class
ShareItem class
ShareItemAction abstract
ShareModel class
Tracker class
Utils class
EventDispatcherItem class

Elements

Type Kind Description
ArrayPointer typedef Function type for accessing and manipulating arrays by reference.
BaseTextFieldView class Base class for text field UI elements with autocomplete functionality.
BiBorderedTriangle class A triangular shape with customizable border rendering.
BooleanFieldView class A toggle switch UI element for boolean (true/false) values.
BoolPointer typedef Function type for accessing and modifying boolean values by reference.
Button class A clickable button UI element with text content.
CellCollectionView class A themed collection view for displaying cells with built-in scrolling and filtering.
CellView class A themeable cell view for list or collection display with interactive features.
CheckStatus abstract Represents the status of a checkbox or toggle control with change tracking.
ChoiceStatus abstract Represents the status of a choice selection with special states.
ClickableIconView class An interactive icon button that responds to clicks and hover states.
ColorFieldView class A color input field with an integrated color picker popup.
ColorPickerHSBGradientView class A gradient color selector for HSB (Hue, Saturation, Brightness) color space.
ColorPickerHSBSpectrumView class A vertical hue spectrum selector for HSB color space.
ColorPickerHSLuvGradientView class A color picker gradient view using the HSLuv color space for perceptually uniform color selection.
ColorPickerHSLuvSpectrumView class A vertical spectrum view for HSLuv color selection showing lightness values.
ColorPickerPaletteColorView class A single color swatch in a color picker palette.
ColorPickerView class A comprehensive color picker interface combining multiple color selection methods.
ConfirmStatus abstract Represents the status of a confirmation dialog or action.
Context class Global context singleton for the elements UI system.
CrossX class A visual component that renders an X-shaped cross icon.
DragDrop class A component that enables drag-and-drop functionality for visuals.
EditTextStatus abstract Represents the status of text editing operations using bit flags.
Entypo abstract Entypo icon font character codes.
EntypoIconView class A view component for displaying Entypo font icons.
EnumAbstractInfo class Runtime information container for enum abstract types.
EnumValuePointer typedef Type alias for enum value pointers in the elements UI system.
FieldSystem class Central system for managing field focus in the Elements UI framework.
FieldView class Base class for interactive field views in the Elements UI framework.
FloatPointer typedef Function type for accessing and modifying floating-point values by reference.
FormLayout class A specialized column layout designed for forms in the Elements UI framework.
Handle typedef A type alias for integer handles used throughout the Elements UI framework.
Im class Immediate mode UI system for Ceramic inspired by Dear ImGui.
ImRowLayout class A specialized row layout for the immediate mode UI system.
ImSystem class The core system that manages the immediate mode UI rendering pipeline.
InfoStatus abstract Represents the status of an informational dialog or notification.
InputStyle enum Defines the visual style options for input fields in the Elements UI system.
IntPointer typedef
ItalicText class A component that applies italic-style skewing to Text visuals.
LabeledView class A container that pairs a text label with any view, providing flexible label positioning.
LabelPosition abstract Enumeration defining the position of a label relative to its associated view.
LabelView class A themed text label for UI forms and layouts.
ListStatus abstract Abstract wrapper for tracking list view state changes and item operations.
ListView class A comprehensive list view with sorting, item management, and interaction features.
ListViewDataSource class Data source implementation for ListView's collection view.
PendingDialog class Model representing a pending dialog box with user interaction.
PromptStatus abstract Abstract type for tracking the completion status of prompt dialogs.
RelatedToFieldView interface Interface for views that are related to or associated with a FieldView.
SanitizeTextField class Advanced text field sanitization utility with mathematical operation support.
Scrollbar class A basic scrollbar visual component that provides visual feedback for scrollable content.
ScrollbarVisibility abstract Enumeration defining different scrollbar visibility behaviors for scrollable containers.
ScrollingLayout class A scrollable container that wraps a layout view with optional filtering and borders.
SelectFieldView class A dropdown selection field that allows users to choose from a predefined list of options.
SelectListView class A scrollable list view for displaying selectable items in dropdown controls.
Separator class A horizontal line separator for visually dividing content sections.
SliderFieldView class A numeric input field with an integrated slider for intuitive value adjustment.
StringPointer typedef Function type for accessing and modifying string values by reference.
TabFocus class Component for managing keyboard-based focus navigation using Tab key.
TabFocusable interface Interface for elements that can participate in Tab key focus navigation.
TabsLayout class A horizontal tab layout component for organizing content into multiple pages.
TabState abstract Represents the possible states of a tab in a tab control.
TextFieldKind enum Defines the different types of text field inputs available.
TextFieldView class A flexible text input field view with support for various input types and validation.
TextUtils class Utility class providing various text manipulation and transformation functions.
Theme class Comprehensive theme configuration for the elements UI system.
Tooltip class A tooltip component that displays informational text when hovering over visual elements.
UserData class Persistent user data model for storing application-specific user preferences and state.
VisualContainerView class A view container that displays and manages a single visual element with scaling and filtering opt...
VisualContainerViewScaling enum Defines the scaling behavior options for VisualContainerView.
Window class A draggable window container for UI elements.
WindowData class Persistent data model for window state and configuration.
WindowItem class A versatile data container for window UI elements with efficient pooling and recycling.
WindowItemKind abstract Window item types enumeration.

Clay

Type Kind Description
Audio class Clay backend audio implementation providing comprehensive sound management.
AudioFilterBuffer typedef Platform-specific audio filter buffer implementation for real-time audio processing.
AudioFilterInfo class Internal metadata for audio filters attached to a bus.
AudioHandle typedef Handle to an individual audio playback instance in the Clay audio system.
AudioResource typedef Represents loaded audio data in the Clay backend audio system.
Backend class
Binaries class Clay backend implementation for loading binary data files.
BlendMode typedef Type alias for the Clay engine's blend mode enumeration.
ClayEvents class Event handler for the Clay backend that bridges low-level Clay engine events
Clipboard class Clay backend implementation for system clipboard operations.
Draw class
ElectronRunner class Static holder for the Electron runner instance used in web builds.
Float32Array typedef Type alias for Clay's Float32Array implementation.
Info class Clay backend implementation providing platform and asset information.
Input class Clay backend input handling implementation.
IO class Clay backend implementation for persistent key-value storage.
LoadAudioOptions typedef Configuration options for loading audio resources in the Clay backend.
LoadBinaryOptions typedef Configuration options for loading binary data in the Clay backend.
LoadTextOptions typedef Configuration options for loading text files in the Clay backend.
LoadTextureOptions typedef Configuration options for loading texture/image resources in the Clay backend.
Main class Main entry point for Clay backend applications.
NativeMac class Native macOS-specific functionality for the Clay backend.
Screen class Clay backend screen and window management implementation.
Shader abstract Abstract type representing a compiled GPU shader program in the Clay backend.
ShaderImpl class Clay backend implementation of GPU shader programs.
Shaders class Clay backend implementation of shader program management.
TextInput class Clay backend implementation for system text input handling.
Texts class Clay backend implementation for loading text files.
Texture typedef Represents a GPU texture resource in the Clay backend.
TextureId typedef Represents a GPU texture identifier in the Clay backend.
TextureIdClayImpl abstract
Textures class Clay backend implementation of texture management.
UInt8Array typedef Type alias for Clay's UInt8Array implementation.
AppEventType abstract
ArrayPool typedef
Assets typedef
Audio typedef
AudioData class An audio data object contains information about audio samples or streams, ready to be used.
AudioDataOptions class
AudioEvent abstract
AudioFormat abstract The type of format data for audio
AudioHandle typedef An audio handle for tracking audio instances
AudioInstance class
AudioSource class
AudioState abstract
BackgroundQueue class An utility to enqueue functions and execute them in background, in a serialized way,
BaseAssets class
BaseAudio class
BaseIO class
BaseRuntime class
BlendMode abstract
ArrayBuffer typedef
ArrayBufferImpl abstract
ArrayBufferIO class
ArrayBufferView typedef
ArrayBufferViewImpl class
Float32Array typedef
Float32ArrayImpl abstract
Float64Array typedef
Float64ArrayImpl abstract
Int16Array typedef
Int16ArrayImpl abstract
Int32Array typedef
Int32ArrayImpl abstract
Int8Array typedef
Int8ArrayImpl abstract
TAError enum
TypedArrayType abstract
UINT typedef
Uint16Array typedef
Uint16ArrayImpl abstract
Uint32Array typedef
Uint32ArrayImpl abstract
Uint8Array typedef
Uint8ArrayImpl abstract
Uint8ClampedArray typedef
Uint8ClampedArrayImpl abstract
Clay class Clay app
Config class
Events class
Extensions class A bunch of static extensions to make life easier.
FileHandle typedef
FileSeek typedef
GamepadDeviceEventType abstract A gamepad device event type
GpuShader typedef
Color class
Graphics typedef
RenderTexture class
Shader class
Texture class A high level texture object to make it easier to manage textures
TextureAndSlot class
Uniforms class
Vector2 class
Vector3 class
Vector4 class
Image class
Immediate class
Input class
IntMap typedef
IO typedef
KeyCode abstract
Log class
Macros class
ModState class Input modifier state
NativeAssets class
NativeIO class
GL typedef
GLActiveInfo typedef
GLBuffer typedef
GLContextAttributes typedef
GLFramebuffer typedef
GLGraphics class A set of helpers to interact with GL stuff.
GLGraphics_GpuShader class
GLGraphics_RenderTarget class
GLProgram typedef
GLRenderbuffer typedef
GLShader typedef
GLTexture typedef
GLUniformLocation typedef
OpenGLProfile abstract A type of OpenGL context profile to request. see RenderConfigOpenGL for info
PremultiplyAlpha class
RenderConfig class Config specific to the rendering context that would be used when creating windows
RenderConfigOpenGL class Config specific to an OpenGL rendering context.
RenderTarget typedef
Resource class
Runner class A simple Haxe class for easily running threads and calling functions on the primary thread.
Runtime typedef
RuntimeConfig typedef
ScanCode abstract
FileHandle typedef
FileSeek abstract
SDL class
SDL_Extern class
SDLConfig class
SDLDisplayID typedef
SDLDisplayMode class
SDLDisplayModeConstPointer typedef
SDLEvent abstract
SDLEventPointer typedef
SDLGamepadPointer typedef
SDLGLContext class
SDLInitFlags typedef
SDLIO class
SDLIOStreamPointer typedef
SDLJoystickID typedef
SDLJoystickPointer typedef
SDLNativeEvent class
SDLNativeGamepad class
SDLNativeIOStream class
SDLNativeJoystick class
SDLNativePoint class
SDLNativeRect class
SDLNativeSize class
SDLNativeSurface class
SDLNativeWindow class
SDLPoint abstract
SDLPointPointer typedef
SDLRect abstract
SDLRectConstPointer typedef
SDLRectPointer typedef
SDLRuntime class
SDLSize abstract
SDLSizePointer typedef
SDLSurfacePointer typedef
SDLWindowFlags typedef
SDLWindowFlagsPointer typedef
SDLWindowID typedef
SDLWindowPointer typedef
WindowHandle typedef
SoloudAudio class
SoloudAudioData class
SoloudBus class
SoloudSound class
TextEventType abstract A text specific event event type
TextureDataType abstract
TextureFilter abstract
TextureFormat abstract
TextureId typedef
TextureType abstract
TextureWrap abstract
Utils class
WindowConfig class Window configuration information for creating windows
WindowEventType abstract

Ase

Type Kind Description
Ase class Aseprite file format reader/writer
AseHeader class
Cel class
CelChunk class
CelExtraChunk class
Chunk class
ChunkHeader class
ColorProfileChunk class
ExternalFilesChunk class
LayerBlendMode abstract
LayerChunk class
LayerFlags abstract
LayerType abstract
MaskChunk class
OldPaleteChunk class
Packet typedef
PaletteChunk class
PaletteChunkEntry class
SliceChunk class
SliceKey class
Tag typedef
TagsChunk class
TilesetChunk class
UserDataChunk class
Frame class
FrameHeader class
Layer class
Palette class
PaletteEntry typedef
CelType abstract
ChunkType abstract
ColorDepth abstract
ColorProfileType abstract
Serializable interface
AsepriteBlendFuncs class Blending functions that operate at pixel/color level, ported from Aseprite source code.
AsepriteData class Data structure containing parsed Aseprite file information.
AsepriteFrame class Represents a single frame from an Aseprite animation.
AsepriteFrameLayer class Represents a single layer's data within an Aseprite frame.
AsepritePalette class Represents a color palette from an Aseprite file.
AsepriteParser class Parser for Aseprite (.ase/.aseprite) animation files.
AsepriteTag class Represents an animation tag from an Aseprite file.

Format

Type Kind Description
Header typedef
Reader class
InflateImpl typedef

Tiled

Type Kind Description
Reader class ...
TmxBaseLayer class
TmxChunk class This is currently added only for infinite maps. The contents of a chunk element is same as that of
TmxData class When no encoding or compression is given, the tiles are stored as individual XML tile elements.
TmxDataCompression enum Compression type for data.
TmxDataEncoding enum Encoding of the data.
TmxGroup class A group layer, used to organize the layers of the map in a hierarchy.
TmxHAlign abstract
TmxImage class As of the current version of Tiled Qt, each tileset has a single image associated with it,
TmxImageLayer class A layer consisting of a single image.
TmxLayer enum
TmxMap class General .tmx map file
TmxObject class
TmxObjectGroup class Layer representing a group of objects.
TmxObjectGroupDrawOrder enum Whether the objects are drawn according to the order of appearance ("index") or sorted by their y...
TmxObjectTemplate class
TmxObjectType enum Type of the object.
TmxObjectTypeProperty class
TmxObjectTypeTemplate class
TmxOrientation enum Map orientation
TmxPoint class Utility for x/y object. Used for Polygon and Polyline object types.
TmxProperties abstract
TmxPropertyType enum
TmxRenderOrder enum Rendering order of tiles
TmxStaggerAxis enum
TmxStaggerIndex enum
TmxTerrain class
TmxText class Used to mark an object as a text object. Contains the actual text as character data.
TmxTile abstract Single tile in tile layer.
TmxTileLayer class
TmxTileOffset class This element is used to specify an offset in pixels, to be applied when drawing a tile from the r...
TmxTileset class Tileset
TmxTilesetGrid class This element is only used in case of isometric orientation, and determines how tile overlays for ...
TmxTilesetTile class
TmxTilesetTileFrame class Animation frame of a single tile in tileset.
TmxVAlign abstract
TmxWangSet class Defines a list of corner colors and a list of edge colors, and any number of Wang tiles using the...
TmxWangSetColor class A color that can be used to define the corner or an edge of a Wang tile.
TmxWangSetTile class Defines a Wang tile, by referring to a tile in the tileset and associating it with a certain Wang...
Tools class ...
ImplTmxProperties class

Nape

Type Kind Description
NapePhysicsBodyType enum Types of physics bodies in the Nape physics engine.
NapeSystem class Central system managing Nape physics simulation in Ceramic.
VisualNapePhysics class Component that links a Ceramic Visual to a Nape physics body.
BodyCallback class Callback object for Body type events.
BodyListener class Event listener for Body type events.
Callback class Base type for Callback event objects.
CbEvent class Enumeration of possible callback event types.
CbType class Callback Type applied to Interactors and Constraints.
CbTypeIterator class Haxe Iterator compatible iterator over Nape list.
CbTypeList class Nape list of CbType type objects
ConstraintCallback class Callback object for Constraint type events.
ConstraintListener class Event listener for Constraint type events.
InteractionCallback class Callback object for Interaction type events.
InteractionListener class Event listener for Interaction type events.
InteractionType class Enumeration of Interaction types.
Listener class Base type for all Nape callback listeners.
ListenerIterator class Haxe Iterator compatible iterator over Nape list.
ListenerList class Nape list of Listener type objects
ListenerType class Enumeration of Listener types.
OptionType class OptionType representing matching behaviour for Listeners.
PreCallback class Callback object for Pre-Interaction type events.
PreFlag class Enumeration of interaction states for arbiters. These values are returned
PreListener class Event listener for Pre-Interaction type events.
Config class Configuration parameters for Nape
AngleJoint class AngleJoint constraining the relative angles of two Bodies.
Constraint class Base type for all Nape joints and constraints
ConstraintIterator class Haxe Iterator compatible iterator over Nape list.
ConstraintList class Nape list of Constraint type objects
DistanceJoint class DistanceJoint limiting the distance between two local anchor points of Bodies.
LineJoint class LineJoint constraining anchor of one body, to a line segment of the other.
MotorJoint class MotorJoint constraining the angular velocities of two bodies
PivotJoint class PivotJoint constraining two anchors points of bodies to be equal.
PulleyJoint class PulleyJoint limiting the weighted sum of distances between 2 pairs of 4 local anchor points of Bo...
UserConstraint class UserConstraint providing a low-level API for user-defined Constraints.
WeldJoint class WeldJoint constraining two bodies to be exactly locked together.
Arbiter class Arbiter representing the state of an interaction between two Bodys.
ArbiterIterator class Haxe Iterator compatible iterator over Nape list.
ArbiterList class Nape list of Arbiter type objects
ArbiterType class Enumeration of Arbiter types.
CollisionArbiter class Arbiter sub type for collision interactions.
Contact class Contact point for collision interactions
ContactIterator class Haxe Iterator compatible iterator over Nape list.
ContactList class Nape list of Contact type objects
FluidArbiter class Fluid interaction subtype for Arbiter.
InteractionFilter class InteractionFilter provides bit flags for low-level filtering of interactions.
InteractionGroup class InteractionGroups are another way of filtering interactions.
InteractionGroupIterator class Haxe Iterator compatible iterator over Nape list.
InteractionGroupList class Nape list of InteractionGroup type objects
AABB class Axis Aligned Bounding Box (AABB)
ConvexResult class Class representing the results of a convex cast operation.
ConvexResultIterator class Haxe Iterator compatible iterator over Nape list.
ConvexResultList class Nape list of ConvexResult type objects
Geom class Geom class provides interface to collision detection routines in nape.
GeomPoly class Polygon class with various geometric methods
GeomPolyIterator class Haxe Iterator compatible iterator over Nape list.
GeomPolyList class Nape list of GeomPoly type objects
GeomVertexIterator class Haxe compatible iterator over vertices of GeomPoly.
IsoFunctionDef typedef Typedef defining iso-function type for MarchingSquares.
MarchingSquares class Iso-surface extraction into polygons.
Mat23 class 2D Matrix class representing affine transformations:
MatMN class A general MxN dimensional matrix.
Ray class Parametrically defined ray used in ray casting functions.
RayResult class Class representing the results of a ray cast operation.
RayResultIterator class Haxe Iterator compatible iterator over Nape list.
RayResultList class Nape list of RayResult type objects
Vec2 class 2 Dimensional vector.
Vec2Iterator class Haxe Iterator compatible iterator over Nape list.
Vec2List class Nape list of Vec2 type objects
Vec3 class A 3 dimensional vector object.
Winding class Enumeration represents the winding of a Polygon.
Body class Class representing a physics Rigid Body.
BodyIterator class Haxe Iterator compatible iterator over Nape list.
BodyList class Nape list of Body type objects
BodyType class Enumeration of rigid body types.
Compound class Compound represents a grouping of physics objects into a single object.
CompoundIterator class Haxe Iterator compatible iterator over Nape list.
CompoundList class Nape list of Compound type objects
FluidProperties class FluidProperties providing shared parameters for fluid interaction.
GravMassMode class Enumeration of GravMassMode values for a Body.
InertiaMode class Enumeration of InertiaMode values for a Body.
Interactor class
InteractorIterator class Haxe Iterator compatible iterator over Nape list.
InteractorList class Nape list of Interactor type objects
MassMode class Enumeration of MassMode values for a Body.
Material class Material property providing physical attributes to a Shape.
Circle class Shape subtype representing a Circle
Edge class Edge class providing internal details of Polygon.
EdgeIterator class Haxe Iterator compatible iterator over Nape list.
EdgeList class Nape list of Edge type objects
Polygon class Polygon subtype of Shape.
Shape class Base type for Nape Shape's
ShapeIterator class Haxe Iterator compatible iterator over Nape list.
ShapeList class Nape list of Shape type objects
ShapeType class Enumeration of Nape Shape types.
ValidationResult class Enumeration of validation results for a Polygon.
Broadphase class Enumeration of available broadphase collision types that Spaces may use.
Space class The heart of all Nape simulations.
TArray typedef Platform specific Array type.
Debug class Debug class providing general utilities
ZPP_BodyListener class
ZPP_Callback class
ZPP_CbSet class
ZPP_CbSetPair class
ZPP_CbType class
ZPP_ConstraintListener class
ZPP_InteractionListener class
ZPP_Listener class
ZPP_OptionType class
ZPP_AngleJoint class
ZPP_Constraint class
ZPP_CopyHelper class
ZPP_DistanceJoint class
ZPP_LineJoint class
ZPP_MotorJoint class
ZPP_PivotJoint class
ZPP_PulleyJoint class
ZPP_UserBody class
ZPP_UserConstraint class
ZPP_WeldJoint class
ZPP_Arbiter class
ZPP_ColArbiter class
ZPP_Contact class
ZPP_FluidArbiter class
ZPP_IContact class
ZPP_InteractionFilter class
ZPP_InteractionGroup class
ZPP_SensorArbiter class
ZPP_SpaceArbiterList class
ZPP_AABB class
ZPP_Collide class
ZPP_Convex class
ZPP_ConvexRayResult class
ZPP_CutInt class
ZPP_Cutter class
ZPP_CutVert class
ZPP_Geom class
ZPP_GeomPoly class
ZPP_GeomVert class
ZPP_GeomVertexIterator class
ZPP_MarchingSquares class
ZPP_MarchPair class
ZPP_MarchSpan class
ZPP_Mat23 class
ZPP_MatMN class
ZPP_Monotone class
ZPP_PartitionedPoly class
ZPP_PartitionPair class
ZPP_PartitionVertex class
ZPP_Ray class
ZPP_Simple class
ZPP_SimpleEvent class
ZPP_SimpleSeg class
ZPP_SimpleSweep class
ZPP_SimpleVert class
ZPP_Simplify class
ZPP_SimplifyP class
ZPP_SimplifyV class
ZPP_SweepDistance class
ZPP_ToiEvent class
ZPP_Triangular class
ZPP_Vec2 class
ZPP_Vec3 class
ZPP_VecMath class
ZPP_Body class
ZPP_Compound class
ZPP_FluidProperties class
ZPP_Interactor class
ZPP_Material class
ZPP_Circle class
ZPP_Edge class
ZPP_Polygon class
ZPP_Shape class
ZPP_AABBNode class
ZPP_AABBPair class
ZPP_AABBTree class
ZPP_Broadphase class
ZPP_CallbackSet class
ZPP_CbSetManager class
ZPP_Component class
ZPP_DynAABBPhase class
ZPP_Island class
ZPP_Space class
ZPP_SweepData class
ZPP_SweepPhase class
FastHash2_Hashable2_Boolfalse class
Hashable2_Boolfalse class
ZNPArray2_Float class
ZNPArray2_ZPP_GeomVert class
ZNPArray2_ZPP_MarchPair class
ZNPList_ConvexResult class
ZNPList_RayResult class
ZNPList_ZPP_AABBNode class
ZNPList_ZPP_AABBPair class
ZNPList_ZPP_Arbiter class
ZNPList_ZPP_Body class
ZNPList_ZPP_BodyListener class
ZNPList_ZPP_CallbackSet class
ZNPList_ZPP_CbSet class
ZNPList_ZPP_CbSetPair class
ZNPList_ZPP_CbType class
ZNPList_ZPP_ColArbiter class
ZNPList_ZPP_Component class
ZNPList_ZPP_Compound class
ZNPList_ZPP_Constraint class
ZNPList_ZPP_ConstraintListener class
ZNPList_ZPP_CutInt class
ZNPList_ZPP_CutVert class
ZNPList_ZPP_Edge class
ZNPList_ZPP_FluidArbiter class
ZNPList_ZPP_GeomPoly class
ZNPList_ZPP_GeomVert class
ZNPList_ZPP_InteractionGroup class
ZNPList_ZPP_InteractionListener class
ZNPList_ZPP_Interactor class
ZNPList_ZPP_Listener class
ZNPList_ZPP_PartitionedPoly class
ZNPList_ZPP_PartitionVertex class
ZNPList_ZPP_SensorArbiter class
ZNPList_ZPP_Shape class
ZNPList_ZPP_SimpleEvent class
ZNPList_ZPP_SimpleVert class
ZNPList_ZPP_SimplifyP class
ZNPList_ZPP_ToiEvent class
ZNPList_ZPP_Vec2 class
ZNPNode_ConvexResult class
ZNPNode_RayResult class
ZNPNode_ZPP_AABBNode class
ZNPNode_ZPP_AABBPair class
ZNPNode_ZPP_Arbiter class
ZNPNode_ZPP_Body class
ZNPNode_ZPP_BodyListener class
ZNPNode_ZPP_CallbackSet class
ZNPNode_ZPP_CbSet class
ZNPNode_ZPP_CbSetPair class
ZNPNode_ZPP_CbType class
ZNPNode_ZPP_ColArbiter class
ZNPNode_ZPP_Component class
ZNPNode_ZPP_Compound class
ZNPNode_ZPP_Constraint class
ZNPNode_ZPP_ConstraintListener class
ZNPNode_ZPP_CutInt class
ZNPNode_ZPP_CutVert class
ZNPNode_ZPP_Edge class
ZNPNode_ZPP_FluidArbiter class
ZNPNode_ZPP_GeomPoly class
ZNPNode_ZPP_GeomVert class
ZNPNode_ZPP_InteractionGroup class
ZNPNode_ZPP_InteractionListener class
ZNPNode_ZPP_Interactor class
ZNPNode_ZPP_Listener class
ZNPNode_ZPP_PartitionedPoly class
ZNPNode_ZPP_PartitionVertex class
ZNPNode_ZPP_SensorArbiter class
ZNPNode_ZPP_Shape class
ZNPNode_ZPP_SimpleEvent class
ZNPNode_ZPP_SimpleVert class
ZNPNode_ZPP_SimplifyP class
ZNPNode_ZPP_ToiEvent class
ZNPNode_ZPP_Vec2 class
ZPP_ArbiterList class
ZPP_BodyList class
ZPP_CbTypeList class
ZPP_CompoundList class
ZPP_ConstraintList class
ZPP_ContactList class
ZPP_ConvexResultList class
ZPP_EdgeList class
ZPP_Flags class
ZPP_GeomPolyList class
ZPP_InteractionGroupList class
ZPP_InteractorList class
ZPP_ListenerList class
ZPP_Math class
ZPP_MixVec2List class
ZPP_PubPool class
ZPP_RayResultList class
ZPP_Set_ZPP_Body class
ZPP_Set_ZPP_CbSet class
ZPP_Set_ZPP_CbSetPair class
ZPP_Set_ZPP_PartitionPair class
ZPP_Set_ZPP_PartitionVertex class
ZPP_Set_ZPP_SimpleEvent class
ZPP_Set_ZPP_SimpleSeg class
ZPP_Set_ZPP_SimpleVert class
ZPP_ShapeList class
ZPP_Vec2List class
ZPP_Const class
ZPP_ID class

OpenGL

Type Kind Description
Any typedef
GL class
GLActiveInfo typedef
GLbitfield typedef
GLBuffer abstract
GLContextAttributes typedef
GLenum typedef
GLFramebuffer abstract
GLObject abstract
GLProgram abstract
GLRenderbuffer abstract
GLShader abstract
GLShaderPrecisionFormat typedef
GLSync class
GLTexture abstract
GLuint typedef
GLUniformLocation abstract
IntRef abstract
WebGL class
GL_linc class

Soloud

Type Kind Description
AlignedFloatBuffer class Class that handles aligned allocations to support vectorized operations
AudioAttenuator class
AudioCollider class
AudioSource class Base class for audio sources
AudioSourceAttenuationModels abstract
AudioSourceFlags abstract
AudioSourceInstance class
AudioSourceInstance3dData class
AudioSourceInstanceFlags abstract
AudioSourceRef class
Bus class Base class for busses
Fader class Helper class to process faders
Filter class Base class for audio sources
FilterInstance class Base class for filter instances
FilterParamType abstract
Handle typedef
Result typedef
Soloud class Soloud core class.
SoloudBackends abstract
SoloudErrors abstract
SoloudFlags abstract
Time typedef
TinyAlignedFloatBuffer class Lightweight class that handles small aligned buffer to support vectorized operations
Wav class
WavStream class
Soloud_linc class

Stb

Type Kind Description
Image class
ImageWrite class
StbImageData typedef
StbImageInfo typedef

Timestamp

Type Kind Description
Timestamp class

BinPacking

Type Kind Description
DisjointRectCollection class
FreeRectChoiceHeuristic abstract
IOccupancy interface
MaxRectsPacker class
MaxRectsPackerBestFitPosition class
MaxRectsPackerRectScore class
Rect class
RectSize class

Hsluv

Type Kind Description
Angle typedef
Geometry class
Hsluv class Human-friendly HSL conversion utility class.
Line typedef
Point typedef

Hscript

Type Kind Description
Argument typedef
ClassDecl typedef
Const enum
CType enum
Error class
ErrorDef enum
Expr typedef
ExprDef enum
FieldAccess enum
FieldDecl typedef
FieldKind enum
FunctionDecl typedef
Interp class
Metadata typedef
ModuleDecl enum
ModuleType typedef
Parser class
Printer class
Token enum
Tools class
TypeDecl typedef
VarDecl typedef
Stop enum

Fuzzaldrin

Type Kind Description
Filter class
Fuzzaldrin class
Matcher class
Scorer class

Polyline

Type Kind Description
Extensions class
MiterUtils class
Stroke class
StrokeCap enum
StrokeJoin enum

Spec

Type Kind Description
Audio interface Backend interface for audio operations.
Backend interface Main backend interface that provides access to all platform-specific functionality.
Binaries interface Backend interface for binary data loading operations.
Clipboard interface Backend interface for system clipboard operations.
Input interface Backend interface for input handling.
IO interface Backend interface for file input/output operations.
Shaders interface Backend interface for GPU shader program management.
TextInput interface Backend interface for system text input handling.
Texts interface Backend interface for text file loading operations.
Textures interface Backend interface for texture (image) management and GPU operations.

Other

Type Kind Description
AllAssets class
Project class

Haxe

Type Kind Description
Any abstract Any is a type that is compatible with any other in both ways.
Array class An Array is a storage for values. You can access it using indexes or
ArrayAccess interface ArrayAccess is used to indicate a class that can be accessed using brackets.
Bool abstract The standard Boolean type, which can either be true or false.
Class abstract An abstract type that represents a Class.
Abi class
ArrayBase class
AutoCast class
Callable abstract The generator intercepts this type and converts it to a cpp.Function on cpp.
CallableData typedef
Char abstract
ConstCharStar abstract
ConstPointer class
EnumBase class
ErrorConstants class
Float32 abstract
Float64 abstract
Function abstract
FunctionData typedef
Int16 abstract
Int32 abstract
Int64 abstract
Int64Map class
Int8 abstract
NativeArray class
NativeFile class
NativeProcess class
NativeString class
NativeSys class
ObjectType class
Pointer class
RawConstPointer class
RawPointer class
Reference typedef Allows haxe to type result correctly, and hxcpp can recognise this and
Star typedef Allows haxe to type result correctly, and hxcpp can recognise this use the
UInt16 abstract
UInt32 abstract
UInt64 abstract
UInt8 abstract
Void class
Date class The Date class provides a basic structure for date and time related
Dynamic abstract Dynamic is a special type which is compatible with all other types.
Enum abstract An abstract type that represents an Enum type.
EnumValue abstract An abstract type that represents any enum value.
EReg class The EReg class represents regular expressions.
Float abstract The standard Float type, this is a double-precision IEEE 64bit float.
AtomicBool abstract Atomic boolean.
AtomicInt abstract
CallStack abstract Get information about the call stack.
Constructible abstract This type unifies with any instance of classes that have a constructor
Adler32 class Calculates the Adler32 of the given Bytes.
Base64 class Allows one to encode/decode String and bytes using Base64 encoding.
BaseCode class Allows one to encode/decode String and bytes using a power of two base dictionary.
HashMethod enum Hash methods for Hmac calculation.
Hmac class Calculates a Hmac of the given Bytes using a HashMethod.
Md5 class Creates a MD5 of a String.
Sha1 class Creates a Sha1 of a String.
Sha256 class Creates a Sha256 of a String.
ArraySort class ArraySort provides a stable implementation of merge sort through its sort
BalancedTree class BalancedTree allows key-value mapping with arbitrary keys, as long as they
EnumValueMap class EnumValueMap allows mapping of enum value keys to arbitrary values.
HashMap abstract HashMap allows mapping of hashable objects to arbitrary values.
IntMap class IntMap allows mapping of Int keys to arbitrary values.
List class A linked-list of elements. The list is composed of element container objects
Map abstract Map allows key to value mapping for arbitrary value types, and many key
ObjectMap class ObjectMap allows mapping of object keys to arbitrary values.
ReadOnlyArray abstract ReadOnlyArray is an abstract over an ordinary Array which only exposes
StringMap class StringMap allows mapping of String keys to arbitrary values.
TreeNode class A tree node of haxe.ds.BalancedTree.
Vector abstract A Vector is a storage of fixed size. It can be faster than Array on some
DynamicAccess abstract DynamicAccess is an abstract type for working with anonymous structures
EntryPoint class If `haxe.
EnumTools class This class provides advanced methods on enums. It is ideally used with
EnumValueTools class This class provides advanced methods on enum values. It is ideally used with
Exception class Base class for exceptions.
NotImplementedException class An exception that is thrown when requested function or operation does not have an implementation.
PosException class An exception that carry position information of a place where it was created.
AsVar abstract If this type is used as an argument type, the compiler ensures that
FlatEnum abstract This type unifies with an enum instance if all constructors of the enum
JsonParser class An implementation of JSON parser in Haxe.
JsonPrinter class An implementation of JSON printer in Haxe.
Function abstract This type unifies with any function type.
IMap interface
Int32 abstract Int32 provides a 32-bit integer with consistent overflow behavior across
Int64 abstract
ArrayBufferView abstract
ArrayBufferViewData typedef
ArrayBufferViewImpl class
Bytes class
BytesBuffer class
BytesData typedef
BytesInput class
BytesOutput class
Encoding enum String binary encoding supported by Haxe I/O
Eof class This exception is raised when reading while data is no longer available in the haxe.io.Input.
Error enum The possible IO errors that can occur
FPHelper class Helper that converts between floating point and binary representation.
Input class An Input is an abstract reader. See other classes in the haxe.io package
Int32Array abstract
Int32ArrayData typedef
Output class An Output is an abstract write. A specific output implementation will only
Path class This class provides a convenient way of working with paths. It supports the
StringInput class
UInt8Array abstract
UInt8ArrayData typedef
ArrayIterator class This iterator is used only when Array<T> is passed to Iterable<T>
ArrayKeyValueIterator class
DynamicAccessKeyValueIterator class This Key/Value iterator can be used to iterate over haxe.DynamicAccess.
MapKeyValueIterator class This Key/Value iterator can be used to iterate across maps.
StringIteratorUnicode class This iterator can be used to iterate across strings in a cross-platform
Json class Cross-platform JSON API: it will automatically use the optimized native API if available.
Log class Log primarily provides the trace() method, which is invoked upon a call to
AbstractType typedef Represents an abstract type.
AnonType typedef Represents information for anonymous structure types.
BaseType typedef The information that all types (ClassType, EnumType, DefType,
Case typedef Represents a switch case.
Catch typedef Represents a catch in the AST.
ClassField typedef Represents a class field.
ClassType typedef Represents a class type.
DefType typedef Represents a typedef.
EnumField typedef Represents an enum constructor.
EnumType typedef Represents an enum type.
Expr typedef Represents a node in the AST.
ExprOf typedef Represents a AST node identical to Expr, but it allows constraining the
Field typedef Represents a field in the AST.
Function typedef Represents a function in the AST.
FunctionArg typedef Represents a function argument in the AST.
ImportExpr typedef Represents the import expression.
MetaAccess typedef MetaAccess is a wrapper for the Metadata array. It can be used to add
Metadata typedef Represents metadata in the AST.
MetadataEntry typedef Represents a metadata entry in the AST.
ObjectField typedef Represents the field of an object declaration.
Position typedef Represents a position in a file.
Ref typedef Represents a reference to internal compiler structure. It exists to avoid
TFunc typedef Represents a function in the typed AST.
TVar typedef Represents a variable in the typed AST.
TypeDefinition typedef Represents a type definition.
TypedExpr typedef Represents a typed AST node.
TypeParamDecl typedef Represents a type parameter declaration in the AST.
TypeParameter typedef Represents the declaration of type parameters.
TypePath typedef Represents a type path in the AST.
Var typedef Represents a variable in the AST.
MainEvent class
MainLoop class
NotVoid abstract This type unifies with anything but Void.
PosInfos typedef PosInfos is a magic type which can be used to generate position information
Abstractdef typedef The abstract type runtime information.
Classdef typedef The runtime class definition information.
ClassField typedef The runtime class field information.
CType enum The runtime member types.
Enumdef typedef The enum runtime type information.
EnumField typedef The runtime enum constructor information.
FunctionArgument typedef The function argument runtime type information.
Meta class An API to access classes and enums metadata at runtime.
MetaData typedef The list of runtime metadata.
Path typedef The (dot-)path of the runtime type.
PathParams typedef The type parameters in the runtime type information.
Platforms typedef A list of strings representing the targets where the type is available.
Rights enum Represents the runtime rights of a type.
Rtti class Rtti is a helper class which supplements the @:rtti metadata.
Typedef typedef The typedef runtime information.
TypeInfos typedef The general runtime type information.
TypeParams typedef An array of strings representing the names of the type parameters the type
TypeRoot typedef Array of TypeTree.
TypeTree enum The tree types of the runtime type.
XmlParser class XmlParser processes the runtime type information (RTTI) which
Serializer class The Serializer class can be used to encode values and objects into a String,
StackItem enum Elements return by CallStack methods.
Timer class The Timer class allows you to create asynchronous timers on platforms that
Unserializer class The Unserializer class is the complement to the Serializer class. It parses
ValueException class An exception containing arbitrary value.
Access abstract The haxe.xml.Access API helps providing a fast dot-syntax access to the
Parser class
Printer class This class provides utility methods to convert Xml instances to
XmlParserException class
Compress class
FlushMode enum
Huffman enum
HuffTools class
InflateImpl class A pure Haxe implementation of the ZLIB Inflate algorithm which allows reading compressed data wit...
Uncompress class
Int abstract The standard Int type. Its precision depends on the platform.
IntIterator class IntIterator is used for implementing interval iterations.
Iterable typedef An Iterable is a data structure which has an iterator() method.
Iterator typedef An Iterator is a structure that permits iteration over elements of type T.
KeyValueIterable typedef A KeyValueIterable is a data structure which has a keyValueIterator()
KeyValueIterator typedef A KeyValueIterator is an Iterator that has a key and a value.
Lambda class The Lambda class is a collection of methods to support functional
List typedef
Map typedef
Math class This class defines mathematical functions and constants.
Null abstract Null<T> is a wrapper that can be used to make the basic types Int,
Reflect class The Reflect API is a way to manipulate values dynamically through an
Single abstract Single-precision IEEE 32bit float (4-byte).
Std class The Std class provides standard methods for manipulating basic types.
String class The basic String class.
StringBuf class A String buffer is an efficient way to build a big string by appending small
StringTools class This class provides advanced methods on Strings. It is ideally used with
Sys class This class provides access to various base functions of system platforms.
FileStat typedef File information, as given by sys.FileSystem.stat.
FileSystem class This class provides information about files and directories.
File class API for reading and writing files.
FileInput class Use sys.io.File.read to create a FileInput.
FileOutput class Use sys.io.File.write to create a FileOutput.
Process class
Deque class A Deque is a double-ended queue with a pop method that can block until
EventHandler abstract
EventLoop class An event loop implementation used for sys.thread.Thread
Lock class A Lock allows blocking execution until it has been unlocked. It keeps track
Mutex class Creates a mutex, which can be used to acquire a temporary lock
NextEventTime enum When an event loop has an available event to execute.
NoEventLoopException class
Thread abstract
Type class The Haxe Reflection API allows retrieval of type information at runtime.
UInt abstract The unsigned Int type is only defined for Flash and C#.
ValueType enum
Void abstract The standard Void type. Only null values can be of the type Void.
Xml class Cross-platform Xml API.
XmlType abstract Xml node types.
__Int64 typedef
NativeInt64Helper class
DefaultResolver class
ListIterator class
ListNode class
VectorData typedef
MetaObject typedef
AttribAccess abstract
HasAttribAccess abstract
HasNodeAccess abstract
NodeAccess abstract
NodeListAccess abstract
S abstract
State enum
Window class
Stdin class
Stdout class
RegularEvent class
HaxeThread class
NativeThreadHandle abstract
ThreadHandle typedef
ThreadImpl typedef