[JAVA][Beginning Java 8 Games Development]

Chapter 4 ■ An Introduction to JavaFX 8: Exploring the Capabilities of the Java 8 Multimedia Engine
The LightBase class, and its PointLight and AmbientLight subclasses, can be used to light your scenes. These
classes are primarily used for 3D scenes, and they require 3D capabilities on any platform that the game is running
on, which is not really a problem these days, as most of the major CPU manufacturers also make (and include) GPUs.
Also, it is important to note that the Prism game engine will simulate a 3D environment (GPU), using 3D processing
emulation, if one is not available on the platform that is rendering the game. In addition, if you set it up correctly, you
can use the lighting classes with your 2D games or use lighting with a hybrid 2D-3D game.
The Camera class, and its ParallelCamera and PerspectiveCamera subclasses, can be used to photograph
or video your scene in 3D and 2D (and hybrid) game applications. Two of the camera classes, Camera and
ParallelCamera, do not require that 3D (GPU) capabilities be present on the platform that is playing your JavaFX
application (in this case, a game).
The subclasses of the Camera class provide two different, specialized types of cameras. The ParallelCamera class
can be used for rendering scenes without any depth perspective correction, which in the 3D industry is called an
orthographic projection. What this means is that this class is perfect for use with 2D scenes (and for 2D games).
The PerspectiveCamera class has a much more complex camera, used for 3D scenes, which will support 3D
viewing volumes. Like the LightBase class and its subclasses, the PerspectiveCamera class requires 3D capabilities on
the hardware platform that the application (or game) is running on.
The PerspectiveCamera class has a fieldOfView attribute (state or variable), which can be used to change its
viewing volume, just like a real camera zoom lens, when you zoom it in from wide angle. The default setting for
the fieldOfView attribute is an acute angle of 30 degrees. If you remember your geometry from high school, you
can visualize this field of view by looking down the y (vertical) axis at the camera. As you might expect, there are
.getFieldOfView() and .setFieldOfView(double) method calls to control this camera class attribute.
Next, let’s take a closer look at the Scene utility classes. After that, you will examine some of the javafx.scene
subpackages, such as javafx.scene.text, javafx.scene.image, javafx.scene.shape, and javafx.scene.layout.
JavaFX Scene Utilities: Scene Snapshots and Antialiasing
Finally, you should take a quick look at the three utility classes, shown in the right-hand column in Figure 4-2, as
they can be used to improve the quality of scene output on the user’s device’s screen (using antialiasing) as well as to
provide screen capture capabilities to either your user (for social media sharing) or your game play logic itself.
Let’s investigate the SceneAntialiasing class first. Antialiasing is a digital imaging industry term that references
an algorithm that smoothes jagged edges where two colors come together, usually on a diagonal line or in the
circular area of an image composite. An image composite is two separate images placed in layers to form one
image. Sometimes, the edges between the image components of these two (or more) image layers will need to be
smoothed. Smoothing (antialiasing) is required so that a final composite looks like it is one seamless image, which
is the intention of the artist or game designer. Interestingly, you are already implementing the JavaFX “layer engine”
in your InvinciBagel application, using the StackPane class (panes are layers). The “layer stack” image-compositing
approach is common in games as well as in software, such as Photoshop and GIMP.
The SceneAntialiasing class offers antialiasing processing (algorithm) to 3D scenes so that they can be
composited over your 2D scene background, whether that is the default, Color.WHITE, or any other color value; a
2D image (creating a hybrid 2D-3D application); or anything else, for that matter. The SceneAntialiasing class allows
you to set the static SceneAntialiasing data field to a value of DISABLED (turn antialiasing off) or BALANCED (turn
antialiasing on). The balanced option gives a balance of quality and performance, which simply means that the more
processing power the device’s hardware brings to the table, the more antialiasing quality will be processed.
Next, let’s explore the SnapshotParameters class (object), which is used to set up (contain) a rendering attribute
parameter that will be used by the SnapshotResult class (object). The parameters include the type of Camera
(parallel or perspective) object to be used; whether the depthBuffer (used for 3D) is on (true for 3D) or off (false for
2D); a Paint object, used to contain the image data; a Transform object, used to contain any transform data; and a
Rectangle2D object, used to define the viewport area to be rendered (i.e., the snapshot dimensions).
You will be looking at all these javafx.scene subpackage classes and concepts in this chapter as well as using
many of them over the course of this book. Much of the functionality that you will be tapping into for your Java 8 game
development will be found in these JavaFX 8.0 subpackages.
www.it-ebooks.info
81