All Classes and Interfaces
Class
Description
Describes the alignment with which a text should be displayed.
Immutable representation of an angle in degrees.
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.
Contains the API for calling JavaScript functions using TeaVM.
Provides access to the browser's DOM contents.
Data structure that can be flushed to obtain values that have accumulated
over time.
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.
Very simple data structure for representing 2D 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.
Attached to a
Graphic2D and used by the renderer to determine when
and how this graphic should be displayed.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.
Describes a font's visual appearance.
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.
Indicates whether the renderer is capable of displaying 2D or 3D graphics.
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.
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.
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.Bridge to the parts of the PeerJS interface that are implemented in
JavaScript.
Implements the
PeerConnection interface in Java, which is then
bridged to the PeerJS implementation in JavaScript via TeaVM.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.
Describes a point with X and Y coordinates within a two-dimensional space.
Describes a point with X, Y, and Z coordinates within a three-dimensional
space.
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.
Two-dimensional rectangle with coordinates defined with float precision.
Rectangular region with integer coordinates, typically used to describe
a pixel region within an image.
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.
Helper class that can be used to create 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.
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.
Semi-generic JavaScript function callback that can be used to return the
result of an asynchronous operation that can either succeed or fail.
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.
Read-only interface for reading
Transform properties.Thrown when attempting to perform an operation which is not supported by
the renderer's graphics mode.
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.
Data structure that collects all properties necessary for rendering
2D polygon graphics using WebGL.
Graphics using WebGL.
Window options that are used by the renderer when starting applications on
desktop platforms.
Access to all 3D graphicson the stage, only avalailable when using a
renderer that supports 3D graphics.