[JAVA][Beginning Java 8 Games Development]

Chapter 6 ■ The Foundation of Game Design: The JavaFX Scene Graph and the InvinciBagel Game Infrastructure
The Java class hierarchy for the Image class starts with the java.lang.Object master class and uses this class
to create the javafx.scene.image.Image class. As Figure 6-4 shows (l. 9), Image is contained in the JavaFX image
package, just like the ImageView class, and uses the following class hierarchy structure:
java.lang.Object
> javafx.scene.image.Image
The Image class supplies six different (overloaded) Image() constructor methods. These take anything from
a simple URL to a set of parameter values specifying the URL, width, height, aspectRatioLock, smoothing, and
preload options. These should be specified in that order within the constructor method, as you will soon see, when
you write an Image() constructor using the most complicated of all the constructor methods, which has the following
format:
Image(String url, double requestedWidth, double requestedHeight, boolean preserveRatio, boolean
smooth, boolean backgroundLoading)
The simple constructor for an Image object specifies only the URL and uses the following format:
Image(String url)
If you want to load an image and also have the constructor method scale the image to a different width and
height (usually, this is smaller, to save memory), while locking (preserving) the aspect ratio, using the highest-quality
resampling (smooth-pixel scaling), that Image object constructor uses the following format:
Image(String url, double scaleWidth, double scaleHeight, boolean preserveAspect, boolean smooth)
If you want to load an image in the background (asynchronously), using its “native,” or physical, resolution and
native aspect ratio, the Image() constructor uses the following format:
Image(String url, boolean backgroundLoading)
Two Image() constructor methods also use the java.io.InputStream class, which furnishes a real-time stream
(like streaming video or audio, only customized for a Java application) of input data to the Image() constructor
method. These two Image object constructor formats take the following formats (simple and complex):
Image(InputStream is) // This is the simple format. The complex format would thus be as follows:
Image(InputStream is, double newWidth, double newHeight, boolean preserveAspect, boolean smooth)
Therefore, the Image class (object) is used to prepare a digital image asset for use, that is, to read its data
from a URL; resize them, if necessary (using whatever smoothing and aspect ratio lock you like); and load them
asynchronously, while other things are going on in your application. It is important to note that the Image class
(or object) does not display an image asset: the Image class just loads it; scales it, if needed; and places it in system
memory to be used in your application.
To display an Image object, you will need to use a second class (object), called an ImageView class. The
ImageView object can be used as a node on your Scene Graph and references and then “paints” the Image object data
onto the layout container, which holds the ImageView node (in this case, a StackPane Scene Graph root and Parent
node to the leaf ImageView node). I will be covering the ImageView class in the next section.
From a digital image–compositing perspective, the StackPane class (object) is the image-compositing engine,
or layer manager, if you will, and each ImageView object represents an individual layer in the layer stack. An Image
object contains the digital image data in the ImageView layer or in more than one ImageView, if needed, as the Image
objects and the ImageView objects are decoupled and exist independently of each other.
www.it-ebooks.info
133