[JAVA][Beginning Java 8 Games Development]

Chapter 4 ■ An Introduction to JavaFX 8: Exploring the Capabilities of the Java 8 Multimedia Engine
Chances are you will end up using the ten custom transition classes directly, as they provide the different types
of transitions you are likely to want to use (fades, fills, path based, stroke based, rotate, scale, movement, and so on).
I am going to move on to the AnimationTimer class next, as we will be using this class for our game engine during
the book.
The JavaFX AnimationTimer Class: Frame Processing, Nanoseconds, and Pulse
The JavaFX AnimationTimer class is not a subclass of the JavaFX Animation superclass, so its inheritance hierarchy
starts with the Java 8 masterclass, java.lang.Object, and looks like this:
> java.lang.Object
> javafx.animation.AnimationTimer
What this means is that the AnimationTimer class is scratch coded specifically to offer AnimationTimer
functionality to JavaFX and that it is not related to the Animation (or Timeline or Transition) class or subclasses in any
way. For this reason, the name of this class may be somewhat misleading if you are mentally grouping the class in with
the Animation, Interpolator, KeyFrame, and KeyValue classes that occupy the javafx.animation package with it, as is
has no relation to these classes whatsoever!
Like the Transition class, the AnimationTimer class has been declared a public abstract class. Because it is
an abstract class, it can only be used (subclassed or extended) to create AnimationTimer subclasses. Unlike the
Transition class, it has no subclasses that have been created for you; you have to create your own AnimationTimer
subclasses from scratch, which we will be doing later on in the book to create our GamePlayLoop.java class.
The AnimationTimer class is deceptively simple, in that it has only one method that you must override or replace,
contained in the public abstract class: the .handle() method. This method provides the programming logic that you
want to have executed on every frame of the JavaFX engine’s stage and scene processing cycle, which is optimized to
play at 60FPS (this is perfect for games). JavaFX uses a pulse system, which is based on the new Java 8 nanosecond
unit of time (previous versions of Java used milliseconds).
JavaFX Pulse Synchronization: Asynchronous Processing for Scene
Graph Elements
A JavaFX pulse is a type of synchronization (timing) event, one that synchronizes the states of the elements that are
contained within any given Scene Graph structure that you create for your JavaFX applications (games). The pulse
system in JavaFX is administered by the Glass Windowing Toolkit. Pulse uses high-resolution (nanosecond) timers,
which are also available to Java programmers using the System.nanoTime() method, as of the Java 8 API.
The pulse management system in JavaFX is capped or throttled to 60FPS. This is so that all the JavaFX threads
have the “processing headroom” to do what they need to do. A JavaFX application will automatically spawn up to
three threads, based on what you are doing in your application logic. A basic business application will probably only
use the primary JavaFX thread, but a 3D game will also spawn the Prism rendering thread, and if that game uses
audio or video, or both, which it usually will, it will spawn a media playback thread as well.
You will be using audio, 2D, 3D, and possibly video in the course of your game development journey, so your
JavaFX game application will certainly be multithreaded! As you will see, JavaFX has been designed to be able to
create games that take advantage of multithreading and nanosecond timing capabilities and 3D rendering hardware
(Prism) support.
Whenever something is changed in the Scene Graph, such as a UI control positioning, a CSS style definition, or
an animation playing, a pulse event is scheduled and is eventually fired to synchronize the states of elements on the
Scene Graph. The trick in JavaFX game design is to optimize pulse events so that they are focusing on the game play
logic (animation, collision detection, and so on); thus, you will minimize the other changes (UI control location, CSS
style changes, and so on) the pulse engine looks at. You will do this by using the Scene Graph as a fixed design system,
meaning that you will use the Scene Graph to design your game structure but will not manipulate nodes in real time
on the Scene Graph, using dynamic programming logic, as the pulse system will perform the updates.
87