All Classes and Interfaces
Class
Description
AbstractAppState implements some common methods
that make creation of AppStates easier.An eight sided box.
This call contains the basic behavior of a cinematic event.
Convenient base class for ClientServices providing some default ClientService
interface implementations as well as a few convenience methods
such as getServiceManager() and getService(type).
An abstract implementation of the Control interface.
Abstract base class for events related to cursor interactions
with spatials.
Base class that DragAndDropListeners can extend to provide
default implementations for some methods.
Base implementation of the Effect class that implements
standard interface functionality other than the create() method.
Base implementation of a stackable GuiComponent.
Name TBD, base implementation of the GuiControlListener class with
default method implementations.
AbstractHeightMap provides a base implementation of height
data for terrain rendering.Convenient base class for HostedServices providing some default HostedService
interface implementations as well as a few convenience methods
such as getServiceManager() and getService(type).
Convenient base class for HostedServices providing some default HostedService
interface implementations as well as a few convenience methods
such as getServiceManager() and getService(type).
A joystick represents a single joystick that is installed in the system.
Base implementation of the Kernel interface providing several
useful default implementations of some methods.
Interface implemented by all network messages.
A MessageListener implementation that will forward messages to methods
of a delegate object.
A default abstract implementation of a Control that
will only allow attachment to a Node and provides a special
getNode() method to subclasses.
Abstract implementation of
OpenCLObject providing the release
mechanisms.Manage the life cycle of a physics object linked to a spatial in a scene
graph.
The abstract base class for physics-debug controls (such as
BulletRigidBodyDebugControl) used to visualize individual collision objects
and joints.
Base class providing some default Service interface implementations
as well as a few convenience methods such as getServiceManager()
and getService(type).
Generic abstract filter that holds common implementations for the different
shadow filters
abstract shadow renderer that holds commons feature to have for a shadow
renderer
A Collidable with a triangular shape.
Base implementation of the Tween interface that provides
default implementations of the getLength() and interpolate()
methods that provide common tween clamping and bounds checking.
Wraps an array of Tween actions into an action object.
A combination of a command and some attributes
that define what the GUI element should look like.
A Button specialization that wraps an Action and
reflects changes to the Action's properties.
ActionListener is used to receive input events in "digital" style.ALAudioRenderer is the backend implementation for OpenAL audio rendering.
An ambient light adds a constant color to the scene.
Implementations of this interface can register to receive values for
active analog inputs.
AnalogListener is used to receive events of inputs
in analog format.AndroidAudioLoader will create an
AndroidAudioData object with the specified asset key.Deprecated.
Loads textures using Android's Bitmap class, but does not have the
RGBA8 alpha bug.
AndroidConfigChooser is used to determine the best suited EGL Config
AndroidGestureHandler uses Gesture type listeners to create jME TouchEvents
for gestures.
AndroidHarness wraps a jme application object and runs it on
AndroidAndroidInput is the main class that connects the Android system
inputs to jME.AndroidInputHandler14 extends AndroidInputHandler to
add the onHover and onGenericMotion events that where added in Android rev 14 (Android 4.0).The onGenericMotion events are the main interface to Joystick axes.
Main class that manages various joystick devices.
AndroidJoyInput14 extends AndroidJoyInput
to include support for physical joysticks/gamepads.Main class that creates and manages Android inputs for physical gamepads/joysticks.
AndroidKeyMapping is just a utility to convert the Android keyCodes into
jME KeyCodes so that events received in jME's KeyEvent will match between
Desktop and Android.
Converts from Java based logging (
Logger to Android based logging
Log.Allocates and destroys direct byte buffers using native code.
Native image loader to deal with filetypes that support alpha channels.
AndroidSensorJoyInput converts the Android Sensor system into Joystick events.
AndroidTouchInput is the base class that receives touch inputs from the
Android system and creates the TouchEvents for jME.
AndroidTouchHandler14 extends AndroidTouchHandler to process the onHover
events added in Android rev 14 (Android 4.0).
Deprecated.
use
AnimClipAn individual animation task, called each frame
by the AnimationState to update the animation.
Deprecated.
use
AnimEventDeprecated.
use
AnimFactoryDefines animations set that will be created while loading FBX scene
Created by Nehon
An AnimationMask is defining a subset of elements on which an animation will be applied.
Manages a list of Animation tasks, calling them each once
per frame until done or canceled.
Deprecated.
use AnimationEvent instead
Deprecated.
A named set of animation tracks that can be played in synchrony.
AnimComposer is a Spatial control that allows manipulation of
armature (skeletal) animation.Deprecated.
use
AnimComposerA CinematicEvent that plays a canned animation action in an
AnimComposer.Deprecated.
A convenience class to smoothly animate a Spatial using translation,
rotation, and scaling.
Created by nehon on 15/04/17.
Created by nehon on 15/04/17.
A named portion of an AnimComposer that can run (at most) one Action at a
time.
Interface to derive animation data from a track.
This class contains the Annotation definitions for jME3.
Annotation used for methods in math primitives that are destructive to the
object (xxxLocal, setXXX etc.).
Annotation used for public methods that are not to be called by users.
Annotation used for math primitive fields, method parameters or method return values.
Helper class for alternative API functions.
Utility class useful to API bindings.
A data class for API versioning information.
Simple interface for Field filtering.
Initializes components by connecting them to JME3 application resources.
load components by connecting them to JME3 application resources.
Updates components using JME3 application resources.
A fragment that receives the application instance.
The
Application interface represents the minimum exposed
capabilities of a concrete jME3 application.Can be hooked into the application (and render manager)
to receive callbacks about specific frame steps.
AppSettings provides a store of configuration
to be used by the application.AppState represents continuously executing code inside the main loop.
The
When an
AppStateManager holds a list of AppStates which
it will update and render.When an
AppState is attached or detached, the
AppState.stateAttached(com.jme3.app.state.AppStateManager) and
AppState.stateDetached(com.jme3.app.state.AppStateManager) methods
will be called respectively.Indicates an application-level step within the profiled
frame.
AppTask is used in AppTaskQueue to manage tasks that have
yet to be accomplished.Updates viewport components using JME3 application resources.
Deprecated.
use
AreaUtils instead, due to wrong packageAreaUtils is used to calculate the area of various objects, such as bounding volumes.Created by Nehon on 15/12/2017.
The class that creates a mesh to display how bones behave.
A class that displays a dotted line between a bone tail and its children's heads.
An AnimationMask to select joints from a single Armature.
The class that displays either wires between the bones' heads if no length
data is supplied and full bones' shapes otherwise.
Wraps an row/column ordered array in a GridModel.
Array serializer
The
Arrow debug shape represents an arrow.AssetCache is an interface for asset caches.AssetConfig loads a config file to configure the asset manager.AssetEventListener is an interface for listening to various
events happening inside AssetManager.The result of locating an asset through an AssetKey.
AssetKey is a key that is used to
look up a resource from a cache.The AssetLinkNode does not store its children when exported to file.
An interface for asset loaders.
AssetLoadException is thrown when the AssetManager
is able to find the requested asset, but there was a problem while loading
it.A fragment that loads assets using the provided AssetManager.
AssetLocator is used to locate a resource based on an AssetKey.AssetManager provides an interface for managing the data assets
of a jME3 application.AssetNotFoundException is thrown when the AssetManager
is unable to locate the requested asset using any of the registered
AssetLocators.AssetProcessor is used to apply processing to assets
after they have been loaded.A fragment that can load assets asynchronously using the provided AssetManager.
An asynchronous wrapper for the JME AssetManager that allows loading assets in a separate thread and
provides callbacks for when the asset is loaded.
Indicates that a given method should be executed asynchronously
through the RMI service.
An attribute is a shader variable mapping to a VertexBuffer data
on the CPU.
The attribute settings for a particular style selector.
An
AudioBuffer is an implementation of AudioData
where the audio is buffered (stored in memory).Holds render thread specific audio context information.
AudioData is an abstract representation
of audio data.AudioKey is extending AssetKey by holding stream flag.AudioListenerState updates the audio listener's position,
orientation, and velocity from a Camera.An
AudioNode is a scene Node which can play audio assets.Deprecated.
- use AudioSource.Status instead
Interface to be implemented by audio renderers.
Status indicates the current status of the audio source.AudioStream is an implementation of AudioData that acquires the
audio from an InputStream.Deprecated.
An app state dedicated to the rendering of a JMonkey application within an AWT component.
This class enables to update graphics of an AWT component with the result of JMonkey 3D rendering.
A JMonkey
context that is dedicated to AWT component rendering.A frame processor that enables to render JMonkey frame buffer onto an AWT component.
AwtKeyInputAwtMouseInputThe implementation of the
MouseInput dedicated to AWT component.
This class is dedicated to the queuing of AWT related tasks and their execution.
Represents one of the X, Y, or Z axes.
Represents a logical anglog input axis that can be used
for mapping inputs to logical functions.
Represents an OpenAL EFX Band-Pass Filter.
A base app state implementation the provides more built-in
management convenience than AbstractAppState, including methods
for enable/disable/initialize state management.
Consolidates the PickEventSession management for doing
scene picking.
This strategy returns the closest probe from the rendered object.
An AppProfiler implementation that collects two
per-frame application-wide timings for update versus
render and uses it to create a bar chart style Mesh.
Provides a basic profiling visualization that shows
per-frame application-wide timings for update and
rendering.
Deprecated.
use
DirectionalLightShadowRenderer with one split.Interface for - basically 3D - noise generation algorithms, based on the
book: Texturing & Modeling - A Procedural Approach
The main concept is to look at noise as a basis for generating fractals.
BatchNode holds geometries that are a batched version of all the geometries that are in its sub scenegraph.
Intended to replace the CharacterControl class.
Bounding Interval Hierarchy.
Determines how the billboard is aligned to the screen/camera.
Exports savable objects in jMonkeyEngine's native binary format.
The default loader to load binaries files.
Created by Nehon on 08/08/2017.
An appendable sequence of bits (0s and 1s).
Represents a single bitmap character.
Represents a font within jME that is generated with the AngelCode Bitmap Font Generator
Specifies horizontal alignment for text.
Specifies vertical alignment for text.
A provider interface which provides a value
BlendSpace.getWeight() to control the blending between 2 successive actions in a BlendAction.BloomFilter is used to make objects in the scene have a glow effect.
There are 2 mode : Scene and Objects.
Scene mode extracts the bright parts of the scene to make them glow
Object mode makes objects glow according to their material's glowMap or their GlowColor
See advanced:bloom_and_glow for more details
There are 2 mode : Scene and Objects.
Scene mode extracts the bright parts of the scene to make them glow
Object mode makes objects glow according to their material's glowMap or their GlowColor
See advanced:bloom_and_glow for more details
GlowMode specifies if the glow will be applied to the whole scene or to objects that have a glow color or a glow map
Deprecated.
use
JointLink an animated bone in a skeleton to a jointed rigid body in a ragdoll.
Deprecated.
use
AnimTrackBoolean serializer.
Boolean serializer.
A layout that manages children similar to Swing's BorderLayout where
children can be placed in any of Position enum values (Position.Center,
Position.North, etc.) Currently this layout operates only in the x/y
axes.
BoundingBox describes a bounding volume as an axis-aligned box.BoundingSphere defines a sphere that defines a container for a
group of vertices of a particular piece of geometry.A debugging shape for a BoundingSphere
Consists of 3 axis aligned circles.
BoundingVolume defines an interface for dealing with
containment of a collection of points.The type of bounding volume being used.
A box with solid (filled) faces.
Basic box collision shape
A layout that manages children similar to Swing's BoxLayout.
It basically works by casting a pick ray
against the bounding volumes of the TerrainQuad and its children, gathering
all of the TerrainPatches hit (in distance order.) The triangles of each patch
are then tested using the BresenhamYUpGridTracer to determine which triangles
to test and in what order.
Works on the XZ plane, with positive Y as up.
Wrapper for an OpenCL buffer object.
Result of an async mapping operation, contains the event and the target byte buffer.
Interface to create/destroy direct buffers.
The factory of buffer allocators.
Layout serializer for buffers
A generic memory buffer that can be divided in logical regions
Hint to suggest the renderer how to access this buffer
Hint to suggest the renderer how the data should be used
A slice of a buffer
BufferUtils is a helper class for generating nio buffers from
jME data classes such as Vectors and ColorRGBA.An app state to manage a single Bullet physics space.
Enumerate threading modes.
A physics-debug control used to visualize a PhysicsCharacter.
An app state to manage a debug visualization of a physics space.
Interface to restrict which physics objects are visualized.
A physics-debug control used to visualize a PhysicsGhostObject.
A physics-debug control used to visualize a PhysicsJoint.
A physics-debug control used to visualize a PhysicsRigidBody.
A physics-debug control used to visualize a PhysicsVehicle.
A standard Button GUI element that can be clicked to
perform an action or set of actions.
Represents a logical button input with an on/off state that
can be used to map inputs to logical functions.
Byte serializer.
ByteUtils is a helper class for converting numeric primitives
to and from byte representations.Implementation of the
PhysicalOggStream interface for reading
and caching an Ogg stream from a URL.What to do with a callback after it is called.
Internal type denoting the type of call to make when remotely
invoking methods.
A standalone, purely mathematical class for doing
camera-related computations.
The result of a culling check operation.
This Control maintains a reference to a Camera,
which will be synched with the position (worldTranslation)
of the current spatial.
A `CameraEvent` is a cinematic event that instantly sets the active camera
within a `Cinematic` sequence.
This class defines all the constants used in camera handlers for registration
with the inputManager
CameraNode simply uses CameraControl to implement
linking of camera and node data.Static utility methods for creating common Camera-related Tween objects.
Specifies a capability that the
Renderer
supports.Basic capsule collision shape
Applies a cartoon-style edge detection filter to all objects in the scene.
A static, indexed, Triangles-mode mesh for an axis-aligned rectangle in the
X-Y plane.
Contains information about any extra server channels (if they exist).
You might want to try
BetterCharacterControl as well.Char serializer.
Char serializer.
A camera that follows a spatial and can turn around it by dragging the mouse
This class is a camera controller that allow the camera to follow a target
Spatial.
A standard Checkbox GUI element that can be used to toggle
a boolean state represented by a CheckboxModel.
The model for a Checkbox element.
Holds a list of CheckboxModels and makes sure that only one at a time
is selected.
An element of a CompoundCollisionShape, consisting of a (non-compound) child
shape, offset and rotated with respect to its parent.
An appstate for composing and playing cutscenes in a game.
Internal information about a shared class.
Internal registry of shared types and their ClassInfo and MethodInfo
objects.
The
ClasspathLocator looks up an asset in the classpath.Represents a remote connection to a server that can be used
for sending and receiving messages.
Client registration is a message that contains a unique ID.
A message-specific serializer to avoid compatibility issues
between versions.
Interface implemented by Client-side services that augment
a network Client's functionality.
Manages ClientServices on behalf of a network Client object.
Listener that is notified about the connection state of
a Client.
Provided with the clientDisconnected() notification to
include additional information about the disconnect.
Deprecated.
CloneableAssetProcessor simply calls Object.clone()
on assets to clone them.Implementing the
CloneableSmartAsset interface allows use
of cloneable smart asset management.Provides custom cloning for a particular object type.
A deep clone utility that provides similar object-graph-preserving
qualities to typical serialization schemes.
Serializes collections.
Serializes collections.
Interface for Collidable objects.
CollisionData is an interface that can be used to
do triangle-accurate collision with bounding volumes and rays.A
CollisionResult represents a single collision instance
between two Collidable.CollisionResults is a collection returned as a result of a
collision detection operation done by Collidable.This Object holds information about a jbullet CollisionShape to be able to reuse
CollisionShapes (as suggested in bullet manuals)
TODO: add static methods to create shapes from nodes (like jbullet-jme constructor)
A utility class for generating collision shapes from Spatials.
Helper class for working with colors and gradients
This filter simply multiply the whole scene by a color
ColorRGBA defines a color made from a collection of red, green
and blue values stored in Linear color space.Generates a new height map based on
two provided height maps.
General command object that can be triggered by GUI elements
such as buttons.
A general mapping of source to some list of Command objects.
Wrapper for an OpenCL command queue.
Object is indexed and stored in primitive float[]
Serialize and compress Float by indexing similar values
Serialize and compress
Quaternion[] by indexing same values
It is converted to float[]Serialize and compress Vector3f[] by indexing same values
Specifies the shadow comparison mode
A component is a reusable piece of functionality that can be attached to a
ComponentManager.An interface to initializing and cleaning up components in the component manager.
An interface to load resources and configurations for components in a component manager.
The ComponentManager is responsible for managing the lifecycle of components within the application.
A component manager that manages components in a JME3 application.
A stack of components that comprise the layers of a GUI
element.
An interface to update components in the component manager.
This filter composes a texture with the viewport texture.
An AppState that manages a set of child app states, making sure
they are attached/detached and optional enabled/disabled with the
parent state.
A CompoundCollisionShape allows combining multiple base shapes
to generate a more sophisticated shape.
CompressedMessage is a base class for all messages that
compress others.
The field serializer is the default serializer used for custom class.
A utility class that parses a define condition in a GLSL language
style.
Cone collision shape represents a 3D cone with a radius, height, and axis (X, Y or Z).
From bullet manual:
To create ragdolls, the cone twist constraint is very useful for limbs like the upper arm.
To create ragdolls, the cone twist constraint is very useful for limbs like the upper arm.
Listener that is notified about connection arrivals and
removals within a server.
A single channel remote connection allowing the sending
and receiving of data.
Wraps a single Connector and forwards new messages
to the supplied message dispatcher.
Represents a client-side connection error, usually encapsulating
an IOException as its cause.
Creates Connectors for a specific host.
Checks the various JME 'constants' for drift using either asserts
or straight checks.
MouseListener implementation that will consume all events.
A special type of Panel that is preconfigured to hold
children using a layout.
A style selector that matches any element with the
specified child ID and parent ID.
Used to load textures from image binary content.
Used to locate a resource based on a
ContentTextureKey.The central OpenCL context.
A filter to adjust the colors of a rendered scene by normalizing each color channel to a specified range,
applying a power law, and scaling the output.
An interface for scene-graph controls.
Nice convenience methods for conversion between javax.vecmath and com.jme3.math
Objects, also some jme to jbullet mesh conversion.
A Post Processing filter that makes the screen look like it was drawn as
diagonal lines with a pen.
Wraps a cube map and allows reading or writing pixels.
Contains information about a 'cursor button' event over a particular
spatial.
A control that can be added to any Spatial to provide
standard CursorListener/CursorEvent support.
Implementations of this interface can be registered with the
CursorEventControl to receive cursor events for a Spatial.
Created Jun 5, 2012 9:45:58 AM
Contains information about a motion event over a particular
spatial.
A
Curve is a visual, line-based representation of a Spline.This class offers methods to help with curves and surfaces calculations.
Created by Nehon on 20/08/2017.
A simple cylinder, defined by its height and radius.
Basic cylinder collision shape
Configure a DynamicAnimControl and access its configuration.
Access a DynamicAnimControl at the PhysicsLink level once it's been added to
a Spatial.
A data store is key-value storage that can be used to store $
Savable and serializable objects and
primitives to a persistent storage.Provides data stores bound to a specific application name and asset manager.
Thrown when the supplied data does not fit any QR Code version.
Date serializer.
DDSLoader is an image loader that reads in a DirectX DDS file.Registers a few keys that will dump debug information
to the console.
Debugging aids.
An AppProfiler implementation that integrates the
per-frame application-wide timings for update versus
render into the Android systrace utility.
A default implementation of the CheckboxModel interface
that simply stores a boolean state and increments the version
when the state is changed.
A default implementation of the Client interface that delegates
its network connectivity to a kernel.Connector.
A default implementation cursor listener that provides default
implementations for all CursorListener methods.
A default implementation of the DocumentModel interface.
A default draggable implementation that will simply move a spatial
in a particular plane based on a starting location and an x/y delta.
A default implementation of the FocusTraversal interface that
is a control providing direct access to any child spatials
that have FocusTarget controls that are "focusable".
Default implementation of the JoystickAxis interface.
Default implementation of the JoystickButton interface.
Specifies the locations to which a
DefaultQualifier annotation applies.A default implementation mouse listener that provides default
implementations for all MouseListener methods.
This emitter influences the particles so that they move all in the same direction.
Default implementation of AbstractPipelineContext that
does nothing extra.
A default implementation of
PlatformChooser.Applied to a declaration of a package, type, method, variable, etc.,
specifies that the given annotation should be the default.
Indicates that the annotated qualifier is the default qualifier in the
qualifier hierarchy: it applies if the programmer writes no explicit
qualifier.
Specifies the annotations to be included in a type without having to provide
them explicitly.
A default implementation of the RangedValueModel interface
that keeps a value and a version, incrementing the version
whenever the value changes.
Convenient base class providing default implementations for
all RawInputListener methods.
A default implementation of the Server interface that delegates
its network connectivity to kernel.Kernel.
The new define list.
Implementations of this interface deform a vertex and normal
based on some implementation-specific function.
The main bootstrap class for the SimEthereal networking example
game.
Refines the qualified type of the annotated field or variable based on the
qualified type of the receiver.
A post-processing filter that performs a depth range
blur using a scaled convolution filter.
AssetManager is the primary method for managing and loading
assets inside jME.Created by Nehon on 25/01/2017.
Created by Nehon on 25/01/2017.
Represents a hardware device actually running the OpenCL kernels.
The device type
DirectionalLight is a light coming from a certain direction in world space.This Filter does basically the same as a DirectionalLightShadowRenderer
except it renders the post shadow pass as a fullscreen quad pass instead of a
geometry pass.
DirectionalLightShadowRenderer renderer use Parallel Split Shadow Mapping
technique (pssm)
It splits the view frustum in several parts and compute a shadow map for each one.
splits are distributed so that the closer they are from the camera, the smaller they are to maximize the resolution used of the shadow map.
This results in a better quality shadow than standard shadow mapping.
for more information on this read https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch10.html
It splits the view frustum in several parts and compute a shadow map for each one.
splits are distributed so that the closer they are from the camera, the smaller they are to maximize the resolution used of the shadow map.
This results in a better quality shadow than standard shadow mapping.
for more information on this read https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch10.html
An helper class that iterates and merges dirty regions
Represents a disconnect message.
A message-specific serializer to avoid compatibility issues
between versions.
This class holds information about the display that was returned by glfwGetMonitors() calls in
the context class
This class holds all information about all displays that where return from the glfwGetMonitors()
call.
Calculates the LOD of the terrain based on its distance from the
cameras.
A mesh that wraps another mesh to provide a deformed
view using a Deformation function.
DocumentModel is a container for text that provides basic editing
interaction as used by things like TextField.
A convenient base class for DocumentModel filtering that simply passes
most methods through to the wrapped delegate DocumentModel, while intercepting
others for subclasses to filter.
A hemisphere.
Part of the jME XML IO system as introduced in the Google Code jmexml project.
Part of the jME XML IO system as introduced in the Google Code jmexml project.
Deprecated.
This class was only used in XMLExporter and has been replaced by javax.xml.transform.Transformer
Double serializer.
Demo and test of the drag-and-drop support in Lemur.
Listener added to DragAndDropControls to perform the drag start,
drag over, and drop operations.
A demo of various DragHandler setups.
Implemented to provide a visual indicator of the dragged object.
Work in progress.
Provides information about an active drag and drop session.
Represents the status of a current drag operation with respect
to whether the item can be dropped successfully or not.
DummyInput as an implementation of
Input that raises no
input events.DummyKeyInput as an implementation of
KeyInput that raises no
input events.DummyMouseInput as an implementation of
MouseInput that raises no
input events.DXTFlipper is a utility class used to flip along Y axis DXT compressed textures.
Before adding this control to a spatial, configure it by invoking
DacConfiguration.link(java.lang.String, float, com.jme3.bullet.animation.RangeOfMotion)
for each bone that should have its own rigid body.Created by Nehon on 26/03/2017.
Expose several Easing function from Robert Penner
Created by Nehon on 26/03/2017.
An Ease function composed of 2 sb function for custom in and out easing
ShadowEdgeFiltering specifies how shadows are filteredRepresents a sort of 'factory' that can create animations for
a particular target.
Manages the available named Effects for a Spatial and keeps track of
the existing effects run for a particular channel.
Contains information about an effect that was previously
run on a particular channel within the EffectControl.
Deprecated.
A calculator for the eigenvectors and eigenvalues of a Matrix3f.
A fully qualified element ID.
A style selector that matches a specific
element ID.
An
EmitterShape that emits particles randomly within the bounds of an axis-aligned box.This emitter shape emits the particles from the given shape's interior constrained by its convex hull
(a geometry that tightly wraps the mesh).
This emitter shape emits the particles from the given shape's faces.
This emitter shape emits the particles from the given shape's vertices
An
EmitterShape that emits particles from a single point in space.This interface declares methods used by all shapes that represent particle emitters.
An
EmitterShape that emits particles randomly from within the volume of a sphere.An empty action implementation that does nothing (by default) when
activated.
This influencer does not influence particle at all.
An abstract endpoint in a Kernel that can be used for
sending/receiving messages within the kernel space.
Provides information about an added or
removed connection.
Computes the entropy value δ (delta) for a given terrain block and
LOD level.
Enum serializer.
Enum serializer.
An environment baker to bake a 3d environment into a cubemap
Encapsulates a received piece of data.
Represents an audio environment, primarily used to define reverb effects.
A 360 camera that can capture a cube map of a scene, and then generate the
Prefiltered Environment cube Map and the Irradiance cube Map needed for PBR
indirect lighting
A control that automatically handles environment bake and rebake including
only tagged spatials.
This class holds several utility method useful for Physically Based
Rendering.
Notified when errors happen on a connection.
A place-holder for future implementation of ETC texture flipping.
Wrapper for an OpenCL Event object.
Interface to handle a glTF extension.
Allows extraction of platform specific binaries from classpath via build
systems.
Interface to handle a glTF extra.
Fade Filter allows you to make an animated fade effect on a scene.
A faster LightProbeFactory that uses GPU accelerated algorithms.
FastMath provides 'fast' math approximations and float equivalents of Math
functions.Creates a heightmap based on the fault algorithm.
Quick n' dirty dumper of FBX binary files.
Responsible for producing FBX objects given an FBXElement.
Maps animation stacks to influenced nodes.
The field serializer is the default serializer used for custom class.
FileLocator allows you to specify a folder where to
look for assets.Specifies the overall type of fill for a distribution
or layout.
Determines a true or false value for a given input.
Filters are 2D effects applied to the rendered scene.
The filter is fed with the rendered scene image rendered in an offscreen frame buffer.
This texture is applied on a full-screen quad with a special material.
This material uses a shader that applies the desired effect to the scene texture.
This class is abstract, any Filter must extend it.
Any filter holds a frameBuffer and a texture
The getMaterial must return a Material that use a GLSL shader implementing the desired effect
The filter is fed with the rendered scene image rendered in an offscreen frame buffer.
This texture is applied on a full-screen quad with a special material.
This material uses a shader that applies the desired effect to the scene texture.
This class is abstract, any Filter must extend it.
Any filter holds a frameBuffer and a texture
The getMaterial must return a Material that use a GLSL shader implementing the desired effect
Used to load FilterPostProcessors which are not cached.
A FilterPostProcessor is a processor that can apply several
It manages a list of filters that will be applied in the order in which they've been added to the list
Filters to a rendered sceneIt manages a list of filters that will be applied in the order in which they've been added to the list
Static utility methods pertaining to Filter instances.
Float serializer.
FluidSimHeightMap generates a height map based using some
sort of fluid simulation.A first-person camera controller.
Manages a FlyByCamera.
Contains the information about a focus change.
Receives notifications about focus changes to a GuiControl.
AppState that manages the focus transition between
one FocusTarget and another.
MouseListener implementation that will automatically tranfer
focus to a GUI element if it is clicked.
Defines the standard functions and default mappings
used for UI navigation.
Manages the input based UI navigation and maybe some minimal
input hookups.
Implemented by classes that can receive GUI focus.
Implemented by classes that can provide focus traversal support
for navigation.
Wraps a standard GuiLayout to provide basic default focus
navigation support.
A filter to render a fog effect
A demo of a Textfield that allows direct entry as well as provides
some buttons for manipulating the DocumentModel separately.
Specifies the version of the format for jME3 object (j3o) files.
Port of the standard forward renderer to a pipeline.
Interface for a general fractal basis.
FractalSum is the simplest form of fractal functions summing up a few octaves
of the noise value with an ever decreasing roughness (0 to 1) amplitude
lacunarity = 2.0f is the classical octave distance
Note: though noise basis functions are generally designed to return value
between -1..1, there sum can easily be made to extend out of this range.
Fragments are interfaces that define specialized capabilities for components in the engine.
FrameBuffers are rendering surfaces allowing
off-screen rendering and render-to-texture functionality.RenderBuffer represents either a texture or a
buffer that will be rendered to.Created by nehon on 15/04/17.
A logical function identifier that can be used to map
controller inputs to actual analog and state listeners.
Deprecated.
use the Gamma Correction setting instead.
Render the environment into a cubemap
The field serializer is the default serializer used for custom class.
Constructs heightfields to be used in Terrain.
Geometry defines a leaf node of the scene graph.Options to align the buffers of geometries' meshes of a sub graph
GeometryComparator is a special version of Comparator
that is used to sort geometries for rendering in the RenderQueue.An abstract class for implementations that perform grouping of geometries
via instancing or batching.
This class is a special purpose list of
Geometry objects for render
queuing.A physics control to link a PhysicsGhostObject to a spatial.
Basic mesh collision shape
Baseline GL methods that must be available on all platforms.
GL functions only available on vanilla desktop OpenGL 2.
GL functions only available on vanilla desktop OpenGL 3.0+.
GL functions only available on vanilla desktop OpenGL 4.0.
Created by Nehon on 12/09/2017.
This class uses Reflection to intercept method calls to the Proxy Object (
This means we don't have to generate a class with overrides for every possible method just to add a
Note that we should not call
Note that this class is general purpose and as such every class instance (every object) can be guarded as long as the passed gl instance is valid.
GLDebug.createProxy(GL, Object, Class[])
and extends them with the Error Checking in GLDebug.checkError().This means we don't have to generate a class with overrides for every possible method just to add a
GLDebug.checkError() call.Note that we should not call
GLDebug.checkError() for GL.glGetError(), it doesn't make sense.Note that this class is general purpose and as such every class instance (every object) can be guarded as long as the passed gl instance is valid.
GL functions and constants only available on vanilla OpenGL ES 3.0.
GL functions provided by extensions.
Framebuffer object functions.
The LWJGL implementation of
JoyInput.The LWJGL implementation of
KeyInput.Captures mouse input using GLFW callbacks.
Describes an OpenGL image format.
Generates a table of supported image formats for a given renderer caps.
This shader Generator can generate Vertex and Fragment shaders from
shadernodes for GLSL 1.0
This shader Generator can generate Vertex and Fragment shaders from
ShaderNodes for GLSL 1.5
This shader Generator can generate Vertex and Fragment shaders from
ShaderNodes for GLESSL 3.0
Nowadays it's just a subclass of Glsl150ShaderGenerator overriding the version
string because GLSL 1.5 is mostly compatible with GLESSL 3.0
GLSL File parser that supports #import pre-processor statement
GLTF 2.0 loader
Created by Nehon on 07/08/2017.
An optional key to use when loading a glTF file
It allows you to specify custom data loader, replacing the default ones.
Created by Nehon on 07/08/2017.
Utility class that allows tracing of OpenGL calls generated by the engine.
Used for selecting character shape in cursive bitmap text.
Shader validator implementation for AMD's GPUShaderAnalyser.
A MessageBuffer implementation that will aggressively create
all messages as byte data comes in.
Simple grid shape.
GuiComparator sorts geometries back-to-front based
on their Z position.A member of a component stack that provides sizing or
rendering as part of that stack.
Manages a component stack, the parent/child relationship, and other
standard GuiControl functionality.
Name TBD, listens to the gui control for reshape and
focus lost/gained.
A utility class that sets up some default global behavior for
the default GUI elements and provides some common access to
things like the AssetManager.
A specific kind of GuiComponent that can manage the layout
of a set of child GuiControl-holding nodes.
Wraps a regular JME Material to provide general
access to paramaters that a UI would find useful
like color, etc.
Can be registered with a GuiControl to receive frame update
notifications as part of the GuiControl's controlUpdate().
A fragment that provides access to a GUI ViewPort.
GZIPCompressedMessage is the class that you need to use should you want to
compress a message using Gzip.
Serializes GZIP messages.
Horizontal alignment of a visual element, either
Left, Right, or Center.
Deprecated.
use the ToneMappingFilter.
Uses Bullet Physics Heightfield terrain collision system.
Deprecated.
in favor of TerrainGridTileLoader
Represents an OpenAL EFX High-Pass Filter.
HillHeightMap generates a height map base on the Hill
Algorithm.From bullet manual:
Hinge constraint, or revolute joint restricts two additional angular degrees of freedom, so the body can only rotate around one axis, the hinge axis.
Hinge constraint, or revolute joint restricts two additional angular degrees of freedom, so the body can only rotate around one axis, the hinge axis.
This is the connection back to a client that is being
hosted in a server instance.
Interface implemented by Server-side services that augment
a network Server's functionality.
Manages HostedServices on behalf of a network Server object.
A MouseListener implementation that will track the hover
state over entered and exited objects and Command<Spatial>
when a 'hover' state exists over a particular Spatial that
has this listener registered.
HttpZipLocator is similar to ZipLocator, except
it allows loading assets from a .ZIP file on the web instead of
on the local filesystem.Example ragdoll presets for a typical humanoid skeleton.
An environment baker, but this one is for Imaged Base Lighting.
An environment baker for IBL, that uses spherical harmonics for irradiance.
Fully accelerated env baker for IBL that runs entirely on the GPU
Fully accelerated env baker for IBL that bakes the specular map and spherical
harmonics on the GPU.
An env baker for IBL that bakes the specular map on the GPU and uses
spherical harmonics generated on the CPU for the irradiance map.
Presents an image as a stackable component that can
either by anchored to the sides and take up component
space or treated as an overlay.
A demo of the IconComponent.
A CloneFunction implementation that simply returns
the passed object without cloning it.
A specialized data-structure used to optimize state changes of "slot"
based state.
Wrapper for an OpenCL image.
Image defines a data format for a graphical image.ImageChannelOrder specifies the number of channels and the channel layout i.e.ImageChannelType describes the size of the channel data type.The image descriptor structure describes the type and dimensions of the image or image array.
Describes the image format, consisting of
Image.ImageChannelOrder and Image.ImageChannelType.Describes a mapped region of the image
The possible image types / dimensions.
ImageBasedHeightMap is a height map created from the grayscale
conversion of an image.ImageFlipper is a utility class used to flip images across the Y axis.
Utility class for reading and writing from jME3
images.Perlin's default implementation of Improved Perlin Noise
designed to work with Noise base
IndexBuffer is an abstraction for integer index buffers,
it is used to retrieve indices without knowing in which format they
are stored (ushort or uint).IndexBuffer implementation for
ByteBuffers.IndexBuffer implementation for
IntBuffers.IndexBuffer implementation for
ShortBuffers.This class provides methods that can be used to query information about
OpenCL objects.
Abstract interface for an input device.
Listener that will be notified when an input mapping has
changed.
Represents a logical input device like a specific game controller.
An abstract input event.
A fragment that intercept raw input events.
A generic interface for input listeners, the
AnalogListener and
ActionListener interfaces extend this interface.The
InputManager is responsible for converting input events
received from the Key, Mouse and Joy Input implementations into an
abstract, input device independent representation that user code can use.Wraps the normal InputManager to provide enhanced
function mapping that completely decouples the registration
of input from the listeners that are executed.
Represents a specific control mapping such that it can be reconfigured.
Input service provider interface that InputMapper can use to register for input
events by adding a RawInputListener.
Represents a trinary input state (0, 1, -1).
A 3D insets object representing a three dimensional padding
around some axis aligned box.
By default, it checks if geometry is in camera frustum and culls it
if it is outside camera view.
This class includes some utility methods for computing intersection
between bounding volumes and triangles.
Similar to a
Map except that ints are used as keys.The Integer serializer serializes...integers.
Implements OpenGL ES 2.0 and 3.0 for iOS.
IosTouchHandler is the base class that receives touch inputs from the
iOS system and creates the TouchEvents for jME.
Generates the Irradiance map for PBR.
Saves a Material to a j3m file with proper formatting.
Saves a Material to a j3m file with proper formatting.
Indicates an object that wishes to more actively participate in the
two-part deep copying process provided by the Cloner.
Represents a rendering context within the engine.
The type of context.
A Jme representation of the LWJGL Cursor class.
JmeExporter specifies an export implementation for jME3
data.More simple formatter than the default one used in Java logging.
JME-specific implementation of the InputProvider interface that can wrap
jMonkeyEngine's InputManager.
The
iOS GLES interface iOS alternative to Android's GLES20 and GLES30 classesA RelativeLayout class holder that wraps a
GLSurfaceView as a renderer UI component and uses OGLESContext as a renderer context to render
a jme game on an android view for custom xml designs.
The main idea of JmeSurfaceView class is to start a jMonkeyEngine application in a SystemListener context on a GL_ES thread,
then the game is rendered and updated through a GLSurfaceView component with a delay of user's choice using a Handler, during the delay,
the user has the ability to handle a couple of actions asynchronously as displaying a progress bar on a SplashScreen or an image or even play a preface game music of choice.Determines whether the app context would be destructed as a result of dispatching
Activity.finish()
with the holder activity context in case of JmeSurfaceView.DestructionPolicy.DESTROY_WHEN_FINISH or be
spared for a second use in case of JmeSurfaceView.DestructionPolicy.KEEP_WHEN_FINISH.Used as a static memory to protect the game context from destruction by Activity#onDestroy().
Utility class to access platform-dependant features.
Pulls in version info from the version.properties file.
Abstract Adapter class that implements optional methods of JobProgressListener.
An interface listener that will be notified of the progress of an asynchronous
generation job.
A Joint is the basic component of an armature designed to perform skeletal animation
Created by Nehon on 15/12/2017.
Implementations of this interface holds accumulated model transform of a Joint.
Joystick axis event.
Joystick button event.
A specific API for interfacing with joysticks or gaming controllers.
A joystick represents a single joystick that is installed in the system.
Represents a single axis of a Joystick.
Represents a single button of a Joystick.
Provides compatibility mapping to different joysticks
that both report their name in a unique way and require
remapping to achieve a proper default layout.
Listens for the state of a joystick connection.
Defines the basic byte[] passing messaging
kernel.
Wrapper for an OpenCL kernel, a piece of executable code on the GPU.
A placeholder for kernel arguments representing local kernel memory.
A placeholder for a kernel argument representing local kernel memory per thread.
The work size (global and local) for executing a kernel
Wraps a single Kernel and forwards new messages
to the supplied message dispatcher and new endpoint
events to the connection dispatcher.
This exception is thrown by
Program.build()
when the compilation failed.Represents a kernel-level error, usually encapsulating
an IOException as its cause.
Supplied to the DefaultServer to create any additional
channel kernels that might be required.
Represents kerning information for a character.
Defines a key action including potential modifiers.
A (currently) TextEntryComponent-specific listener for
KeyActions.
A specific API for interfacing with the keyboard.
Keyboard key event.
AppState that registers a RawInputListener with the
InputManager so that key events can optionally be received
and consumed before normal listeners get them.
Implementations of this interface can be registered
with the KeyInterceptState to receive key events.
Bit constants for the different key modifiers.
Translate key codes (from
KeyInput) to descriptive names.A
KeyTrigger is used as a mapping to keyboard keys.Deprecated.
Enumerate joint-control modes for this control.
Enumerate submodes for a link in kinematic mode.
A KTX file loader
KTX file format is an image container defined by the Khronos group
See specs here https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/
This loader doesn't support compressed files yet.
This class allows one to write a KTX file.
A standard GUI element for displaying text with an optional
shadow.
Stores/caches texture-state parameters so the
Renderer doesn't have to
set them each time.Sorts geometry based on an included "layer" user data,
accumulating an effective layer by walking up the
scene graph back to root.
A MessageBuffer implementation that will deserialize messages as they
are returned instead of deserializing them as the data comes in.
The
LegacyApplication class represents an instance of a
real-time 3D rendering jME application.Abstract class for representing a light source.
Describes the light type.
This Control maintains a reference to a Light,
which will be synched with the position (worldTranslation)
of the current spatial.
GuiMaterial wrapper for JME's default Lighting material.
LightList is used internally by Spatials to manage
lights that are attached to them.Deprecated.
Use a
LightControl attached to a Node directly.A LightProbe is not exactly a light.
This is the interface to implement if you want to make your own LightProbe blending strategy.
Creates LightProbes within a scene, given an EnvironmentCamera.
LightScattering filters create rays coming from light sources
This is often referred to as god rays.
A debug state that will display Light gizmos on screen.
Extension loader for KHR_lights_punctual extension which allows
for lights to be added to the node from the gltf model.
Allows querying the limits of certain features in
Renderer.Line defines a line.A simple line implementation with a start and an end.
LineSegment represents a segment in the space.
Line-wrap type for BitmapText
A demo of the ListBox element.
A CloneFunction implementation that deep clones a list by
creating a new list and cloning its values using the cloner.
Represents the audio listener in the 3D sound scene.
Implementation of a Map that favors iteration speed rather than
get/put speed.
Fast, stable sort used to sort geometries
It's adapted from Tim Peters's work on list sorting for Python.
LittleEndien is a class to read little-endian stored data
via an InputStream.Describes an RMI interface on the local machine.
Calculate the Level of Detail of a terrain patch based on the
cameras, or other locations.
Determines what Level of Detail a spatial should be, based on how many pixels
on the screen the spatial is taking up.
This is a utility class that adds the ability to generate LOD levels
for an arbitrary mesh.
Enumerate criteria for removing triangles.
Produces the mesh for the TerrainPatch.
Calculates the LOD value based on where the camera is.
A fragment that with a single update method that is called every frame during the application logic update
loop.
The Long serializer.
LoopMode determines how animations repeat, or if they
do not repeat.Defines the behavior of an application when it is not in focus or minimized.
A filter that attenuates frequencies above a specified threshold, allowing lower
frequencies to pass through with less attenuation.
An LRU cache, based on
LinkedHashMap.The LWJGL implementation of
AL.The LWJGL implementation of
ALC.The implementation of the
BufferAllocator which use MemoryUtil to manage memory.Threadsafe implementation of the
LWJGLBufferAllocator.Class
LwjglCanvas that integrates LWJGLX
which allows using AWT-Swing components.A LWJGL implementation of a graphics context.
The LWJGL implementation of
EFX.The LWJGL implementation og
GLExt.Implements GLFbo via GL_EXT_framebuffer_object.
Implements GLFbo via OpenGL3+.
The base class of LWJGL implementations.
A wrapper class over the GLFW framework in LWJGL 3.
Class
wjglxDefaultGLPlatform used to create a drawing platform.Interface
LwjglxGLPlatform; It is used to implement and manage
the context of a specific platform.Run in the jme3 main thread.
A fragment that provides access to a ViewPort.
Material describes the rendering style for a given
Geometry.Track bind ids for textures and buffers
Used internally
A MaterialAdapter allows to map a GLTF material to a JME material.
This appState is for debug purpose only, and was made to provide an easy way
to test shaders, with a live update capability.
Describes a J3MD (Material definition).
MaterialExtension defines a mapping from an Ogre3D "base" material
to a jME3 material definition.Used internally by
MaterialLoaderMaterialExtensionSet is simply a container for several
MaterialExtensions so that it can be set globally for all
OgreMaterialKeys used.Used for loading
materials only (not material definitions!).A map from material name to a material.
This class is to provide some constants materials.
Created by Nehon on 23/04/2017.
Describes a material parameter.
MatParamOverride is a mechanism by which
material parameters can be overridden on the scene graph.A material parameter that holds a reference to a texture and its required color space.
Custom Exception to report a j3md Material definition file parsing error.
A 3x3 matrix composed of 9 single-precision elements, used to represent
linear transformations of 3-D coordinates, such as rotations, reflections,
and scaling.
A 4x4 matrix composed of 16 single-precision elements, used to represent
linear or perspective transformations of 3-D coordinates.
This JointModelTransform implementation accumulate joints transforms in a Matrix4f to properly
support non uniform scaling in an armature hierarchy
A mesh implementation that creates a box with a specified
number of slices, masking off one or more sides.
Specifies how a buffer object can be accessed by the kernel.
See thread http://jmonkeyengine.org/forum/topic/monitor-direct-memory-usage-in-your-app/#post-205999
Mesh is used to store rendering data.The mode of the Mesh specifies both the type of primitive represented
by the mesh and how the data should be interpreted.
Utility class used by OgreLoader to load poses and mesh animations.
Basic mesh collision shape
Loads Ogre3D mesh.xml files.
Interface implemented by all network messages.
Accumulates network data into Message objects.
The source of a received message and the common abstract interface
of client->server and server->client objects.
Listener notified about new messages.
Keeps track of message listeners registered to specific
types or to any type.
Consolidates the conversion of messages to/from byte buffers
and provides a rolling message buffer.
A Command implementation that calls a configured
no-argument method through reflection.
Method definition is used to map methods on an RMI interface
to an implementation on a remote machine.
Internal information about shared methods.
MidpointDisplacementHeightMap generates a heightmap based on
the midpoint displacement algorithm.Mikktspace is a common standard for tangent space used across many 3D software.
Released under BSD License
Used to load model files, such as OBJ or Blender models.
Extends the regular JME KeyInputEvent to support modifiers
like shift, control, and alt.
A control that handle morph animation for Position, Normal and Tangent buffers.
Contains a list of weights and times for each keyframe.
A MotionEvent is a control over the spatial that manages the position and direction of the spatial while following a motion Path.
Enum for the different type of target direction behavior.
Motion path is used to create a path between way points.
Trigger the events happening on a motion path
Deprecated.
use MotionEvent instead
Keeps track of a set of "collision roots" for mouse picking
and performs the pick event processing necessary to deliver
MouseEvents and CollisionEvents to spatials with either the
MouseEventControl or CursorEventControl attached.
A
MouseAxisTrigger is used as a mapping to mouse axis,
a mouse axis is movement along the X axis (left/right), Y axis (up/down)
and the mouse wheel (scroll up/down).Mouse button press/release event.
A
MouseButtonTrigger is used as a mapping to receive events
from mouse buttons.A control that can be added to any Spatial to provide
standard MouseListener/MouseEvent support.
A specific API for interfacing with the mouse.
Implementations of this interface can be registered with the
MouseEventControl to receive mouse events for a Spatial.
Mouse movement event.
An extension of the TerrainLodControl that handles
multiple terrains at once.
A simple factory that delegates to java.util.concurrent's
default thread factory but adds a prefix to the beginning
of the thread name.
NanoTimer is a System.nanoTime implementation of Timer.Defines default native libraries that are loaded by
NativeLibraryLoader.A helper class that defines a native library by name, list of its native variants
for target platforms and a load function used to load library from an absolute
path after extracted by
NativeLibraryLoader.Utility class to register, extract, and load native libraries.
Describes a native object.
GLObjectManager tracks all GLObjects used by the Renderer.
Represents the android implementation for the native vorbis file decoder.
This decoder initializes an OggVorbis_File from an already opened file designated by the
NativeVorbisFile.fd.Used for TerrainQuad to find neighbours that are not part of the
same quad tree.
The main service provider for conveniently creating
server and client instances.
A Client whose network connection information can
be provided post-creation.
This influencer calculates initial velocity with the use of the emitter's shape.
Endpoint implementation that encapsulates the
channel IO based connection information and keeps
track of the outbound data queue for the channel.
KernelFactory implementation for creating TCP kernels
using the NIO selector model.
Node defines an internal node of a scene graph.Utility base class for Noise implementations
A simple aggregator basis.
Handles the normal vector updates when the terrain changes heights.
NullComparator does not sort geometries.NullLightFilter does nothing.
Render pipeline that performs no rendering.
NullSavable is an implementation of Savable with no data.
Boolean serializer.
Java Object that represents a native iOS class.
A MessageListener implementation that will forward messages to methods
of a specified delegate object.
Reads OBJ format models.
OgreMaterialKey allows specifying material extensions, which map
from Ogre3D base materials to jME3 materialsOgreMeshKey is used to load Ogre3D mesh.xml models with a specific
material file or list.
An interface designed to listen for exceptions and fire an event when an exception is thrown.
An interface used for dispatching an event when the layout holding the
GLSurfaceView is drawn,
the event is dispatched on the user activity context thread.An interface used for invoking an event when the user delay finishes, on the first update of the game.
An interface used for invoking an event when the application is started explicitly from
JmeSurfaceView.startRenderer(int).Generic OpenCL exception, can be thrown in every method of this package.
Base interface of all native OpenCL objects.
Releaser for an
OpenCLObject.Presents an option title, a message, and a set of option actions
to the user.
A quick demo of the option panel.
Provides modal option panel support where the option
panel is the only thing that can receive mouse/touch input
until closed.
A panel is the most basic GUI element consisting only
of a background and insets.
A demo of the IconComponent.
Static utility methods for creating common Lemur Panel-specific Tween objects.
Represents a single particle in a
ParticleEmitter.ParticleDepositionHeightMap creates a heightmap based on the
Particle Deposition algorithm based on Jason Shankel's paper from
"Game Programming Gems".ParticleEmitter is a special kind of geometry which simulates
a particle system.An interface that defines the methods to affect initial velocity of the particles.
The
ParticleMesh is the underlying visual implementation of a
particle emitter.Type of particle mesh
This is a fake runner, it will just run the task in the current thread immediately.
A special TextField implementation that displays an obscured version
of the password the user has entered.
Extension loader for "KHR_materials_emissive_strength".
Adapter for converting GLTF emissive strength to JME emissive intensity.
Adapts GLTF PBR materials to JME PBR materials.
Created by Nehon on 20/08/2017.
Material adapter for PBR Specular Glossiness pipeline
Created by Nehon on 20/08/2017.
Created by Nehon on 20/08/2017.
Basic Bullet Character
A CollisionEvent stores all information about a collision in the PhysicsWorld.
Interface to receive notifications whenever an object in a particular
collision group is about to collide.
Interface to receive notifications whenever an object in a particular physics
space collides.
Base class for collision objects (PhysicsRigidBody, PhysicsGhostObject)
An interface for a scene-graph control that links a physics object to a
Spatial.
From Bullet manual:
GhostObject can keep track of all objects that are overlapping.
GhostObject can keep track of all objects that are overlapping.
PhysicsJoint - Basic Physics Joint
The abstract base class used by DynamicAnimControl to link pieces of a JME
model to their corresponding collision objects in a ragdoll.
Contains the results of a PhysicsSpace rayTest.
PhysicsRigidBody - Basic physics object
PhysicsSpace - The central jbullet-jme physics space
interface with Broadphase types
Contains the results of a PhysicsSpace rayTest
Callback interface from the physics thread, used to clear/apply forces.
PhysicsVehicleNode - Special PhysicsNode that implements vehicle functions
Encapsulates the state necessary to deliver events to targets,
track capture, track enter/exit, etc.
Interface that pick event app states will implement so that
the GuiGlobals user need not worry about which one(s) is/are
active.
A
Picture represents a 2D image drawn on the screen.Handles objects globally for a single type of RenderPipeline.
Interface used to read a set of pixels in a KTX file
Plane defines a plane where Normal dot (x,y,z) = Constant.Describe the relationship between a point and a plane.
A wrapper for an OpenCL platform.
Enumerate known operating system/architecture pairs.
Enumerate generic names of operating systems
This SPI is called on startup to specify which platform and which devices
are used for context creation.
The play state of a cinematic event
From bullet manual:
Point to point constraint, also known as ball socket joint limits the translation so that the local pivot points of 2 rigid bodies match in worldspace.
Point to point constraint, also known as ball socket joint limits the translation so that the local pivot points of 2 rigid bodies match in worldspace.
Represents a point light.
This Filter does basically the same as a PointLightShadowRenderer except it
renders the post shadow pass as a fullscreen quad pass instead of a geometry
pass.
PointLightShadowRenderer renders shadows for a point light
Provides modal-style popup support where a single UI element can
essentially 'take over' the screen.
Controls the behavior for clicks outside the specified popup.
Deprecated.
Deprecated.
A Post Processing filter to change colors appear with sharp edges as if the
available amount of colors available was not enough to draw the true image.
A parameterized torus, also known as a pq torus.
Processor that lays depth first, this can improve performance in complex
scenes.
Generates one face of the prefiltered environment map for PBR.
GLSL Preprocessor
This class contains a primitive allocator with no special logic, should work
on any jvm
This is a guava method used in
Tweens class.A wrapper for an OpenCL program.
Implements a simple cache system for program objects.
A horizontal progress indicator supporting an optional text overlay.
Monitor the progress of an expensive terrain operation.
Deprecated.
Deprecated.
Deprecated.
Deprecated.
Includes various useful shadow mapping functions.
A QR Code symbol, which is a type of two-dimension barcode.
The error correction level in a QR Code symbol.
A segment of character/binary/control data in a QR Code symbol.
Describes how a segment's data bits are interpreted.
Quad represents a rectangular plane in space
defined by 4 vertices.Used to efficiently represent rotations and orientations in 3-dimensional
space, without risk of gimbal lock.
Radially blurs the scene from the center of it
an influencer to make blasts expanding on the ground.
Interface to receive notifications whenever a linked rigid body in a
DynamicAnimControl collides with another physics object.
Interface to receive notifications whenever a KinematicRagdollControl
collides with another physics object.
Utility methods used by KinematicRagdollControl.
Utility methods used by DynamicAnimControl and associated classes.
Represents a settable value between a certain minimum
and maximum range.
Range of motion for a ragdoll joint.
RawHeightMap creates a height map from a RAW image file.An interface used for receiving raw input from devices.
An abstract adapter class for
RawInputListener.Simple serializer
Ray defines a line segment which has an origin and a direction.Defines a rectangle that can constrict a text paragraph.
Rectangle defines a finite plane within three-dimensional space
that is specified via three points (A, B, C).A static, indexed, Triangle-mode mesh that renders a rectangle or
parallelogram, with customizable normals and texture coordinates.
This class contains the reflection based way to remove DirectByteBuffers in
java, allocation is done via ByteBuffer.allocateDirect
Reflection Processor
Used to render the reflected scene in an off view port
Sent to a remote client to make a remote method invocation.
Contains the return value for a remote method invocation, sent as a response
to a
RemoteMethodCallMessage with a non-zero invocationID.Contains various meta-data about an RMI interface.
Sent to expose RMI interfaces on the local client to other clients.
Used internally to remotely invoke methods on RMI shared objects.
Represents the current state of the graphics library.
Responsible for taking rendering commands and
executing them on the underlying video hardware.
Raised when a renderer encounters
a fatal rendering error.
Utility class used by the OGLESShaderRenderer and sister
classes.
A fragment that can receive a RenderManager instance and is called every frame during the render phase.
A high-level rendering interface that is
above the Renderer implementation.
Pipeline for rendering a ViewPort.
RenderQueue is used to queue up and sort
geometries for rendering.The render queue
Bucket specifies the bucket
to which the spatial will be placed when rendered.ShadowMode is a marker used to specify how shadow
effects should treat the spatial.RenderState specifies material rendering properties that cannot
be controlled by a shader on a Material.BlendEquation specifies the blending equation to combine
pixels.BlendEquationAlpha specifies the blending equation to
combine pixels for the alpha component.BlendFunc defines the blending functions for use with
BlendMode.Custom.BlendMode specifies the blending operation to use.FaceCullMode specifies the criteria for faces to be culled.StencilOperation specifies the stencil operation to use
in a certain scenario as specified in RenderState.setStencil(boolean, com.jme3.material.RenderState.StencilOperation, com.jme3.material.RenderState.StencilOperation, com.jme3.material.RenderState.StencilOperation, com.jme3.material.RenderState.StencilOperation, com.jme3.material.RenderState.StencilOperation, com.jme3.material.RenderState.StencilOperation, com.jme3.material.RenderState.TestFunction, com.jme3.material.RenderState.TestFunction)TestFunction specifies the testing function for stencil test
function.Resets (clearFrame()) the render's stats object every frame
during AppState.render().
This class is used to load resources from the default location usually the
classpath.
A physics control to link a PhysicsRigidBody to a spatial.
stores transform info of a PhysicsNode in a threadsafe manner to
allow multithreaded access from the jme scenegraph and the bullet physics space
Ring defines a flat ring or disc in three-dimensional
space that is specified via the ring's center point, an up vector, an inner
radius, and an outer radius.Ring buffer (fixed size queue) implementation using a circular array (array
with wrap-around).
A service that can be added to the client to support a simple
shared objects protocol.
Keeps track of the current connection performing a particular
RMI call.
A service that can be added to the host to support a simple
shared objects protocol.
RmiSerializer is responsible for serializing RMI messages
like define object, call, and return.A panel that expands or collapses its contents based on
pressing a title bar button.
AppState that manages and updates a RootNode attached to a ViewPort, the
default Application ViewPort is used by default, a RootNode is created by
default.
Used internally to send RPC call information to
the other end of a connection for execution.
RPC service that can be added to a network Client to
add RPC send/receive capabilities.
Wraps a message connection to provide RPC call support.
Implementations of this interface can be registered with
the RpcClientService or RpcHostService to handle the
remote procedure calls for a given object or objects.
RPC service that can be added to a network Server to
add RPC send/receive capabilities.
Used internally to send an RPC call's response back to
the caller.
Abstract runnable that can report its progress
A runner runs tasks in its own thread.
Provides a list with similar modification semantics to java.util.concurrent's
CopyOnWriteArrayList except that it is not concurrent and also provides
direct access to the current array.
Savable is an interface for objects that can be serialized
using jME's serialization system.SavableClassUtil contains various utilities to handle
Savable classes.Tool for saving Savables as SaveGame entries in a system-dependent way.
Utility methods for parsing XML data using SAX.
Iterates over the scene graph with the depth-first traversal method.
SceneGraphVisitorAdapter is used to traverse the scene
graph tree.SceneGraphVisitorAdapter is used to traverse the scene
graph tree.FBX file format loader
Scene processors are used to compute/render things before and after the classic render of the scene.
A GUI element that presents a value and a drop down for selecting
a different value.
Used internally to the Styles class to locate
attributes for a particular ElementId.
A Kernel implementation based on NIO selectors.
Represents a joystick axis based on an external sensor
(i.e.
This JointModelTransform implementation accumulates model transform in a Transform class
This does NOT support proper nonuniform scale in the armature hierarchy.
Represents a model that provides a mutable current value as well
as next and previous values.
Factory methods for standard sequence models.
Use this annotation when a class is going to be transferred
over the network.
Serializes uses Java built-in method.
The main serializer class, which will serialize objects such that
they can be sent across the network.
A general exception from the serialization routines.
Implements a MessageProtocol providing message serializer/deserialization
based on the built-in Serializer code.
A SerializerRegistration represents a connection between a class, and
its serializer.
Holds a compiled set of message registration information that
can be sent over the wire.
Represents a host that can send and receive messages to
a set of remote client connections.
The base interface for managed services.
The base service manager class from which the HostedServiceManager
and ClientServiceManager classes are derived.
A MessageListener implementation that will forward messages to methods
of a delegate specified as a HostedConnection session attribute.
Shader source describes a shader object in OpenGL.
Type of shader.
Created by Nehon on 28/10/2017.
Implementation of shader's buffer block.
Static tool box class for convenient methods to help debug shaders
This class is basically a struct that contains the ShaderNodes information
in an appropriate way to ease the shader generation process and make it
faster.
This class is the base for a shader generator using the ShaderNodes system,
it contains basis mechanism of generation, but no actual generation code.
A ShaderNode is the unit brick part of a shader program.
Shader node definition structure meant for holding loaded data from a
material definition j3md file
Used for loading
shader nodes definition
Determines whether the definition will be loaded with or without its documentationShaderNodeDefinition file loader (.j3sn)
a j3sn file is a block style file like j3md or j3m.
This class is here to be able to load shaderNodeDefinition from both the
J3MLoader and ShaderNodeDefinitionLoader.
A shader node variable
Helper class containing useful functions explained in the book:
Texturing & Modeling - A Procedural Approach
Includes various useful shadow mapping functions.
OccludersExtractor is a helper class to collect splitOccluders from scene recursively.
Short serializer.
SimpleApplication is the base class for all jME3 Applications.SimpleAssetCache is an asset cache
that caches assets without any automatic removal policy.SimpleBatchNode comes with some restrictions, but can yield better performances.
Just multiplies the terrain patch size by 2.
Simple Water renders a simple plane that use reflection and refraction to look like water.
A simple point, line, triangle or quad collisionShape based on one to four points-
Mask that excludes joints from participating in the layer if a higher layer
is using those joints in an animation.
From bullet manual:
This generic constraint can emulate a variety of standard constraints, by configuring each of the 6 degrees of freedom (DOF).
This generic constraint can emulate a variety of standard constraints, by configuring each of the 6 degrees of freedom (DOF).
Deprecated.
use
ArmatureDeprecated.
use
SkinningControlThe class that creates a mesh to display how bones behave.
A class that displays a dotted line between a bone tail and its children's heads.
The class that displays either heads of the bones if no length data is supplied or both heads and tails otherwise.
The class that displays either wires between the bones' heads if no length data is supplied and
full bones' shapes otherwise.
The Skinning control deforms a model according to an armature, It handles the
computation of the deformation matrices and performs the transformations on
the mesh
SkyFactory is used to create jME Spatials that can
be attached to the scene to display a sky image in the background.The type of map fed to the shader
A composite GUI element consisting of a draggable slider
with increment and decrement buttons at each end.
From bullet manual:
The slider constraint allows the body to rotate around one axis and translate along this axis.
The slider constraint allows the body to rotate around one axis and translate along this axis.
A straight forward socket-based connector implementation that
does not use any separate threading.
Adds a glow effect to the scene.
Quick and merge sort implementations that create no garbage, unlike
Arrays.sort(int[]).A sound track to be played in a cinematic.
Deprecated.
use SoundEvent instead
Spatial defines the base class for scene graph nodes.Specifies if this spatial should be batched
Specifies how frustum culling should be handled by
this spatial.
Specifies the mode of the depth first search.
Deprecated.
Static utility methods for creating common Spatial-related Tween objects.
Sphere represents a 3D object with all points equidistant
from a center point.Basic sphere collision shape
A GUI element that allows 'spinning' through a potentially
unbound sequence of values.
Represents a spotlight.
This Filter does basically the same as a SpotLightShadowRenderer except it
renders the post shadow pass as a fullscreen quad pass instead of a geometry
pass.
SpotLightShadowRenderer renderer use Parallel Split Shadow Mapping technique
(pssm)
It splits the view frustum in several parts and compute a shadow map for each one.
splits are distributed so that the closer they are from the camera, the smaller they are to maximize the resolution used of the shadow map.
This results in a better quality shadow than standard shadow mapping.
for more information on this read http://http.developer.nvidia.com/GPUGems3/gpugems3_ch10.html
It splits the view frustum in several parts and compute a shadow map for each one.
splits are distributed so that the closer they are from the camera, the smaller they are to maximize the resolution used of the shadow map.
This results in a better quality shadow than standard shadow mapping.
for more information on this read http://http.developer.nvidia.com/GPUGems3/gpugems3_ch10.html
A layout that manages children on a grid that automatically
resizes to fit the components along the major or minor
axes (row and column be default).
Indicates a scene processor-level step within the profiled
frame.
reads the pixels of an image whose origin is the top left corner
reads the pixels of an image whose origin is the bottom left corner
SSAO stands for screen space ambient occlusion
It's a technique that fakes ambient lighting by computing shadows that nearby objects would cast on each other.
A component that is never enabled and does nothing.
Implementations of this interface can register
to receive state change information for a logical
FunctionId.
A convenience StateFunctionListener implementation that
can call a method using reflection.
Rendering logic for static pass.
Allows tracking of real-time rendering statistics.
Displays stats in SimpleApplication's GUI node or
using the node and font parameters provided.
The
StatsView provides a heads-up display (HUD) of various
statistics of rendering.Serializer that respects the Std140 layout
(https://www.khronos.org/registry/OpenGL/specs/gl/glspec45.core.pdf#page=159)
(www.opengl.org/registry/specs/ARB/uniform_buffer_object.txt)
An
AssetInfo wrapper for InputStreams.String serializer.
Boolean serializer.
A box with solid (filled) faces.
Classes implementing this interface are considered struct-like constructs.
A field of a struct
A BufferObject containing a struct serialized with Std140 layout.
StructUtils
Annotation that can mark a field setter as a
style attribute setter.
A MouseListener implementation that can be used to debug
style hierarchies.
Annotation that marks a method that will initialize
styles for a particular class.
Provides support for automatically configuring GUI elements
based on a style attribute system similar to cascading style
sheets.
Used internally by the Styles API to track the style
definition hierarchy in tail-first form.
A meta-annotation to specify all the qualifiers that the given qualifier
is a subtype of.
This class represents a surface described by knots, weights and control points.
The
SystemListener provides a means for an application
to receive events relating to a context.A very simple tabbed panel element that presents a set
of button "tabs" at the top that can select different child
content.
A demo of the TabbedPanel element.
Deprecated.
This is an outdated and non-standard method.
Keeps track of tangent, binormal, and normal for one triangle.
Created by Nehon on 03/10/2016.
A three-by-three quad that can stretch textures in useful
ways.
A texture-covered background quad.
Creates TCP connectors to a specific remote address.
Represents a technique instance.
Describes a technique definition.
Describes light rendering mode.
Define in what space the light data should be sent to the shader.
TechniqueDefLogic is used to customize how
a material should be rendered.Temporary variables assigned to each thread.
Terrain can be one or many meshes comprising a (probably large) piece of land.
The class to provide single executor service to run background tasks of terrain stuff.
TerrainGrid itself is an actual TerrainQuad.
Notifies the user of grid change events, such as moving to new grid cells.
Updates grid offsets and cell positions.
Tells the terrain to update its Level of Detail.
A terrain patch is a leaf in the terrain quad tree.
Pick result on a terrain patch with the intersection on the bounding box
of that terrain patch.
Pick the location on the terrain from a given ray.
TerrainQuad is a heightfield-based terrain system.
A demo of text alignment using a set of buttons.
A component that renders a text string with a particular
alignment and offset.
A basic text entry component that allows displaying and editing of
text based on a DocumentModel.
A demo of a Textfield that allows direct entry as well as provides
some buttons for manipulating the DocumentModel separately.
A GUI element allowing text entry.
Uses a text field and a pair of object-string and string-object
transform functions to implement a ValueEditor.
A collection of convenience filters for input and output.
A demo of text styling.
Texture defines a texture object to be used to display an
image on a piece of geometry.If this texture is a depth texture (the format is Depth*) then
this value may be used to compare the texture depth to the R texture
coordinate.
This class implements a Texture array
warning, this feature is only supported on opengl 3.0 version.
TextureAtlas allows combining multiple textures to one texture atlas.Describes a cubemap texture.
Face of the Cubemap as described by its directional offset from the
origin.
Wraps a texture so that only a single level of the underlying image is bound
instead of the entire image.
Enum specifying the shader access hint of the image.
Used to load textures from image files such as JPG or PNG.
Thread-safe extension loader for KHR_texture_transform.
A checked exception, to be thrown (in place of an IndexOutOfBoundsException)
when a non-existent texture unit is assigned.
Internal utility class used by
GLRenderer to manage textures.TextureManager provides static methods for building a
Texture object.ThreadingManager manages the threads used to load content
within the Content Manager system.Timer is the base class for a high resolution timer.Tone-mapping filter that uses filmic curve.
Link the torso of an animated model to a rigid body in a ragdoll.
An ordinary (single holed) torus.
Similar to MouseAppState, this state adapts touch and multitouch
events to mouse and cursor events.
TouchEvent represents a single event from multi-touch input devicesTouchEventPool provides a RingBuffer of jME TouchEvents to help with garbage
collection on Android.
TouchEventPool provides a RingBuffer of jME TouchEvents to help with garbage
collection on iOS.
A specific API for interfacing with smartphone touch devices
TouchListener is used to receive events of inputs from smartphone touch devicesClass to trigger TouchEvents, keycode can be TouchInput.ALL(=0) or TouchInput.KEYCODE_*
Deprecated.
Deprecated.
A 3-D coordinate transform composed of translation, rotation, and scaling.
An AnimTrack that transforms a Joint or Spatial
using a list of transforms and times for keyframes.
A filter to handle translucent objects when rendering a scene with filters that uses depth like WaterFilter and SSAOFilter
just create a TranslucentBucketFilter and add it to the Filter list of a FilterPostProcessor
Describes a triangle in terms of its vertex locations, with auxiliary storage
for its centroid, normal vector, projection, and index.
A trigger represents a physical input, such as a keyboard key, a mouse
button, or joystick axis.
Represents some action that interpolates across input between 0
and some length value.
An Animation implementation that tracks execution time and
calls a delegate Tween object once per frame.
Static utility methods for creating common generic Tween objects.
A meta-annotation indicating that the annotated annotation is a type
qualifier.
A straight forward datagram socket-based UDP connector
implementation.
Endpoint implementation that encapsulates the
UDP connection information for return messaging,
identification of envelope sources, etc.
A Kernel implementation using UDP packets.
Single-threaded physical ogg stream.
Material adapter for the Unlit pipeline
A special annotation intended solely for representing an unqualified type in
the qualifier hierarchy, as an argument to
SubtypeOf.value(),
in the type qualifiers declarations.GuiMaterial wrapper for JME's default Unshaded material.
Thrown by
Collidable when the requested collision query could not
be completed because one of the collidables does not support colliding with
the other.Declares that the field may not be accessed if the receiver is of the
specified qualifier type (or any supertype).
Allows for enqueueing tasks onto the update loop / rendering thread.
Stores a terrain patch's details so the LOD background thread can update
the actual terrain patch back on the ogl thread.
Handles loading of assets from a URL
UrlLocator is a locator that combines a root URL
and the given path in the AssetKey to construct a new URL
that allows locating the asset.UserData is used to contain user data objects
set on spatials (primarily primitives) that do not implement
the Savable interface.Import user data from glTF extras.
Interface for shader validator tools.
Vertical alignment of a visual element, either
Top, Bottom, or Center.
Provides an appropriate editor element to edit a particular
type of value.
Factory methods for creating standard/common ValueEditors.
For a given value, classes that implement this interface will
provide a Panel that can display that value.
Factory methods for creating standard/common ValueRenderers.
Converts a value to a String by passing it into String.format()
using the supplied format string.
Similar to Functions.toStringFunction() except this will use
a provided string in the case of a null value.
Represents a mapping between 2 shader node variables or a left shader node variable and a value expression.
A vector composed of 2 single-precision components, used to represent
locations, offsets, directions, and rotations in 2-dimensional space.
A vector composed of 3 single-precision components, used to represent
locations, offsets, velocities, and directions in 3-dimensional space.
Vector4f defines a Vector for a four float value tuple.A simplified collection of Vector3f values without duplicates, implemented
using a Collection.
A physics control to link a PhysicsVehicle to a spatial.
Stores info about one wheel of a PhysicsVehicle
A utility implementation of a simple VersionedObject wrapper
object.
Implemented by objects that provided a versioned view
of a value.
Tracks an update version of a VersionedObject and can
provide basic change tracking for a caller.
Watches a composite set of VersionedReferences and presents
a combined version.
A
VertexBuffer contains a particular type of geometry
data used by Meshes.Specifies format of the data stored in the buffer.
Type of buffer.
The usage of the VertexBuffer, specifies how often the buffer
is used.
A Video recording AppState that records the screen output into an AVI file with
M-JPEG content.
Represents a view inside the display
window or a
FrameBuffer to which scenes will be rendered.IndexBuffer implementation that generates vertex indices sequentially
based on a specific Mesh
Mesh.Mode.Indicates a ViewPort-level step within the profiled
frame.
The WaterFilter is a 2-D post process that simulates water.
A garbage collector bound asset cache that handles non-cloneable objects.
WeakRefCloneAssetCache caches cloneable assets in a weak-key
cache, allowing them to be collected when memory is low.This strategy returns the 3 closest probe from the rendered object.
Listen to window size changes.
A demo of a Label that has a maximum width set so that long strings
will word wrap after a certain width.
WrappedIndexBuffer converts vertex indices from a non list based
mesh mode such as Mesh.Mode.TriangleStrip or Mesh.Mode.LineLoop
into a list based mode such as Mesh.Mode.Triangles or Mesh.Mode.Lines.Part of the jME XML IO system as introduced in the Google Code jmexml project.
Part of the jME XML IO system as introduced in the Google Code jmexml project.
Utilities for reading and writing XML files.
Compress a message using this ZIPCompressedMessage class
ZipLocator is a locator that looks up resources in a
.ZIP file.Serializes ZIP messages.
AndroidNativeBufferAllocatorinstead.