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.
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.Defines how the application graphics should be displayed.
Circle that is defined by its center point and a radius.
Represents a color built out of red, green, and blue components.
Display object that acts as a container for holding 2D graphics.
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.
Configures the renderer's display mode, which consists of both the canvas
resolution and the targeted framerate.
Effects are short-lived sub-scenes that can be defined in a declarative
style.
Used when the renderer encounters an error.
Reference to a resource file that is part of the application using a
relative path.
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.
Interface for programmatically create 3D polygon models.
Shared interface for all types of 2D graphics that are part of the scene
graph.
Describes the graphics mode supported by the renderer.
Two-dimensional data structure with linear access time to each cell.
A no-op audio implementation for headless renderers that do not support
audio playback.
Media loader implementation that can be used in headless environments,
primarily for testing and simulation purposes.
Headless renderer implementation intended for testing or simulating 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.
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.
JavaScript function interface that is used to receive name/value messages
in callback functions.
Properties for one of the animations defined in a
PolygonModel.Interface for the platform-specific mechanism for network access.
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 stubs for the Pixi.js JavaScript library.
TeaVM interface for the
pixi-bridge.js JavaScript implementation.Renders graphics using the PixiJS JavaScript
library.
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.
An instance of a 3D polygon model that can added to the stage.
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.
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.
Creates and initialize
Renderer instances.Determines how the
Canvas should be scaled and zoomed when viewed
on devices with different screen sizes, resolutions, and aspect ratios.MultimediaLib applications are split into a number of scenes, each
representing a discrete phase of the application.
Provides access to the contents of the currently active scene, including
the stage, the scene's graphics, and the underlying renderer.
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.
Simple data structure for representing width and height in integer
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 all graphics that are part of the current scene.
Visitor interface that visits all graphics currently on the stage, visiting
them in the order in which they should be drawn.
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 stubs for the Three.js JavaScript library.
TeaVM interface for the
three-bridge.js JavaScript implementation.Renders 2D and 3D graphics using the three.js
JavaScript library.
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 a 3D polygon model is displayed on
the stage.
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 the window appearance on desktop platforms.
Access to all 3D graphicson the stage, only avalailable when using a
renderer that supports 3D graphics.