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.