All Classes and Interfaces

Class
Description
Describes the alignment with which a text should be displayed.
Immutable angle in degrees, in the range between 0° and 360°.
2D sprite animation that shows a number of images in sequence.
Describes an audio clip that has been loaded by the renderer.
Implements the Image interface using an BufferedImage, which is part of the standard library.
Input device that uses AWT to capture mouse and keyboard events.
Immutable three-dimensional box with float precision.
Entry point to access the various "bridge" interfaces that can be used to call JavaScript functions using TeaVM.
TeaVM interface for the browser-bridge.js JavaScript implementation.
The application "canvas" defines how the renderer should display graphics for the current screen size and resolution.
Circle that is defined by its center point and a radius.
Does not draw any graphics, but collects the visited stage nodes in a list.
Represents a color built out of red, green, and blue components.
Stage node that does not provide any graphics, but can instead be used to add additional graphics as children.
Simple data structure for representing (X, Y) coordinates with integer precision.
Simple demo application that displays a number of animated Mario sprites on top of a black background.
Simple demo application for 3D graphics that shows a checkerboard floor and a number of models randomly walking around.
Launches one of the demo applications from the command line.
Effects are short-lived sub-scenes that can be defined in a declarative style.
 
Used when the renderer encounters an error.
Describes a TrueType or FreeType font that can be used by the renderer to draw text.
Tracks performance statistics for each frame, then reports on average performance behavior over time using a sliding window.
Uses libGDX's sound system for audio playback.
 
Refers to a texture that is managed by libGDX.
 
Loads media assets using the libGDX framework.
 
Renderer built on top of the libGDX framework.
Describes the graphics mode that is currently being used by the renderer.
Two-dimensional data structure with linear access time to each cell.
Stage node that does not provide any graphics, but can instead be used to add additional graphics as children.
Headless renderer implementation which can be used for testing and simulation purposes, and (unlike all other renderers) can be used on platforms without a graphics environment.
Renders graphics using the HTML canvas API.
Generates application icons for various platforms, based on a PNG image.
Describes image data for an image that has been loaded by the renderer.
Command line tool for various forms of image manipulation that are not available at runtime due to lack of platform support.
Used to poll the status of the platform's input devices.
Uses Java 2D to render graphics.
Implementation of a renderer that uses APIs from the Java standard library.
Plays audio clips using Java Sound.
Handles the JavaFX application, window, and animation loop.
Uses the JavaFX media player to play audio.
Renders graphics to a hardware-accelerated JavaFX Canvas.
Image loaded with JavaFX, which does not use the Java2D and ImageIO APIs that are part of the standard library.
Captures the current state for mouse and keyboard events, updated using JavaFX event handlers.
Media implementation for JavaFX.
Renderer based on OpenJFX, which was previously known as JavaFX.
Enumerates the keys on a conventional keyboard.
Light source that influences 3D graphics on the stage.
Describes a straight line between two points within a two-dimensional space.
Tracks progress for media files that are loaded by the renderer.
Interface for objects responsible for loading multiple media assets in bulk.
Indicates an error has occured when loading or processing media, such as images or audio.
Loads media files such as images or audio in a format that can later be used by the renderer.
Polygon mesh that can be used to render 3D graphics.
JavaScript function interface that is used to receive name/value messages in callback functions.
Interface for the platform-specific mechanism for network access.
A no-op audio implementation for (headless) renderers that do not support audio playback.
Displays an image and/or message to inform the user to change their device orientation.
Uses a particle wipe effect that can be used for screen transitions.
Access to a currently active peer-to-peer connection, which can be obtained from Network.
TeaVM interface for the peerjs-bridge.js JavaScript implementation.
Implements the PeerConnection interface in Java, which is then bridged to the PeerJS implementation in JavaScript via TeaVM.
Data structure for messages received from a peer-to-peer connection.
Depicts various performance statistics, both in terms of overall performance and on a frame-by-frame basis.
TeaVM interface for the pixi-bridge.js JavaScript implementation.
Uses the PixiJS JavaScript library to render 2D graphics.
Immutable point within a two-dimensional space, with its X and Y coordinates defined with float precision.
Immutable point within a three-dimensional space, with its X, Y, and Z coordinates defined with float precision.
Represents a pointer device, which can be a mouse, a trackpad, or touch controls, depending on the current platform and device.
A two-dimensional convex polygon with float precision coordinates.
Draws a graphical primitive to the screen.
Utility class to help with random numbers.
Immutable two-dimensional rectangle with float precision.
Rectangular region with integer coordinates.
Used to configure and launch the renderer, and can also be used to obtain this configuration at runtime.
The renderer acts as the entry point from the application to the underlying platform, managing the animation loop, graphics, audio, and input.
Indicates an error that has caused the renderer to terminate the animation loop.
Determines how the Canvas should be scaled and zoomed when viewed on devices with different screen sizes, resolutions, and aspect ratios.
Applications are split into *scenes*.
The currently active scene (and its sub-scenes) receive access to the scene context, which is provided by the renderer via callback methods.
Controls the scene life cycle, including the life cycle of its attached sub-scenes.
Line that consists of multiple segments, where each segment is a straight line but the combination still allows for more complex line shapes.
Shared interface for all two-dimensional shapes.
Shared interface for all three-dimensional shapes.
Simple data structure for representing width and height in integer precision.
Immutable three-dimensional sphere with float precision.
Displays a loading screen with a progress bar while the renderer is loading media files asynchronously.
Static or animated image that can be displayed on the stage.
Packs a number of images into a larger image, with each image existing as a named region.
Loads a sprite atlas based on the libGDX .atlas file format.
Command line tool that generates a sprite atlas from a directory of images.
The stage contains the graphics and audio for the currently active scene.
Shared interface for all 3D graphics that can be added to the stage's scene graph.
Shared interface for all 3D graphics that can be added to the stage's scene graph.
Interface that is notified whenever the stage is modified.
Visitor interface that can be used to traverse all nodes currently on the stage.
Uses APIs from the Java standard library to load media files: Java2D and ImageIO for loading images, Java Sound for loading audio clips, and AWT for loading fonts.
Sends HTTP requests using the HTTP client included as part of the Java standard library.
Finite state machine that allows a number of possible states, but can only have one currently active state at any point in time.
Sub-scene that can be used to track swipe gestures for both mouse pointers and touch controls.
Plays audio clips using the HTML5 media API that is supported by all modern browsers.
Launcher for the TeaVM version of the demo application.
Base interface for the different JavaScript graphics frameworks supported by the TeaVM renderer.
Image implementation that is based on an HTML img element.
Captures browser events for various input methods, and makes them accessible from the animation loop.
Delegates media loading to the browser.
Sends HTTP requests by delegating them to JavaScript and sending them as AJAX requests.
Renderer based on TeaVM that is transpiled to JavaScript and runs in the browser.
Transpiles MultimediaLib applications to JavaScript using TeaVM.
Draws text to the screen using the specified TrueType font.
TeaVM interface for the three-bridge.js JavaScript implementation.
Uses the Three.js JavaScript library to render 3D graphics.
Wrapper around a Three.js Mesh/Object3D instance in JavaScript, since that cannot implement Mesh directly.
Utility class for time-based behavior.
Defines the list of transformation properties that should be applied to graphics when displaying them.
Transformation matrix that controls how polygonal 3D graphics are displayed.
Standardized interface for all objects that should be updated every frame during the animation loop.
A two-dimensional vector expressed using an origin, a direction, and a magnitude.
Defines how the application window should be displayed on desktop platforms.