List of Figures

Chapter 1: Java as a Game Platform

Figure 1.1: Puzzle Pirates by Three Rings.

Figure 1.2: Java Gran Prix.

Figure 1.3: Galactic Village by Galactic Village Games.

Figure 1.4: Alien Flux by Puppy Games.

Chapter 2: Fundamentals of Game Programming

Figure 2.1: A single pass through the game loop.

Figure 2.2: Transitions from frame to frame in a game.

Figure 2.3: A basic game state machine.

Figure 2.4: Collision is detected between the ball and the wall.

Figure 2.5: Collision is detected between the ball and a paddle.

Figure 2.6: Collision is detected between a ship and a meteor.

Figure 2.7: Vector reflection off the wall after collision.

Figure 2.8: Deterministic AI.

Figure 2.9: Tracking AI.

Figure 2.10: Evasion AI.

Chapter 3: 2D Graphics Programming

Figure 3.1: The 2D coordinate system.

Figure 3.2: The order in which a monitor displays the screen.

Figure 3.3: Results of running the FullScreenFrame1.

Figure 3.4: The drawing process.

Figure 3.5: Image tearing.

Figure 3.6: Page flipping.

Figure 3.7: Page flipping some color rectangles of random color. (See color version on companion CD-ROM.)

Figure 3.8: A SimpleBuffer in action.

Figure 3.9: Results of running the BufferedExample code.

Figure 3.10: Results of running the VolatileExample code.

Figure 3.11: Looking good with managed images.

Figure 3.12: Looking good with managed images.

Chapter 4: Creating Game Audio Using Java

Figure 4.1: The sound of the horn is Doppler shifting.

Figure 4.2: The Listener class’s “up” and “at” vectors.

Figure 4.3: Sample Source positions with respect to the origin.

Chapter 5: Java IO and NIO

Figure 5.1: Flow of data when read request occurs.

Figure 5.2: Byte stream classes.

Figure 5.3: char stream classes.

Figure 5.4: Buffer classes.

Figure 5.5: Direct versus nondirect buffers.

Figure 5.6: Little-endian versus big-endian byte order.

Figure 5.7: A buffer whose clear method has been called.

Figure 5.8: A buffer that contains some data.

Figure 5.9: A buffer whose flip method has been called.

Figure 5.10: Memory mapped file region.

Figure 5.11: The flow of data when reading from a file in Java versus in a native application.

Chapter 6: Performance and the Java Virtual Machine

Figure 6.1: A simple call graph.

Chapter 7: Local Area Networking for Java Games

Figure 7.1: The latency of water traveling through a hose is determined by the hose length.

Figure 7.2: The bandwidth of water traveling through a hose is determined by the hose’s width.

Figure 7.3: Sending data via TCP/IP.

Figure 7.4: Sending data via UDP.

Chapter 8: Faster Math

Figure 8.1: Trigonometry Functions.

Figure 8.2: Square Root Tests, slower than standard math.

Figure 8.3: Square Root Tests, faster than standard math.

Figure 8.4: Floating-point performance improvement.

Chapter 9: Game Databases and JDBC

Figure 9.1: Player and item database tables.

Figure 9.2: Foreign key relationship.

Figure 9.3: Two sets of data from two tables.

Chapter 11: Java Native Interface

Figure 11.1: JNI reference types.

Figure 11.2: Java heap and system memory.

Figure 11.3: Java ByteBuffer object that contains a pointer to a native buffer.

Chapter 12: 3D Graphics Foundations

Figure 12.1: Screenshot of early 3D games.

Figures 12.2: Screenshot of early 3D games.

Figure 12.3: The pixel fill rate and triangle process rate.

Figure 12.4: Coordinate triad and origin.

Figure 12.5: Polygon.

Figure 12.6: Polygon winding order.

Figure 12.7: Example object transformations.

Figure 12.8: Transformation hierarchies.

Figure 12.9: Ray tracing producing accurate shading, reflections, and shadows.

Figure 12.10: Vector types.

Figure 12.11: Simple shading function.

Figure 12.12: Shading types comparison.

Figure 12.13: Light types comparison.

Figure 12.14: Opaque and transparent objects.

Figure 12.15: Girl geometry with texture.

Figure 12.16: Texture map and 3D object showing corresponding image U-Vs and object vertices.

Figure 12.17: Textured plant with regular and alpha texture maps (outlined).

Figure 12.18: Texel pixelization.

Figure 12.19: Texel swimming.

Figure 12.20: Magmapping texture filtering.

Figure 12.21: MIPmapping texture technique removes texel swimming.

Figure 12.22: MIPmapping requires one-third more texture memory.

Figure 12.23: Example of texture collaging.

Figure 12.24: Aligned versus tilted texture.

Figure 12.25: Monk character rendered three ways: cel-shaded, environment mapped, and bump mapped.

Chapter 13: Java Bindings to OpenGL (JOGL)

Figure 13.1: The first two letters are the library prefix, which is a common design in C APIs. gl means that the function is part of the gl library, vertex is the command, 3 gives the number of arguments for this function, f denotes that the arguments are of type float.

Chapter 14: Overlays and Menus Using JOGL

Figure 14.1: The more important members of the HComponent class.

Figure 14.2: The component types defined and used here.

Figure 14.3: The more important members of the HContainer class.

Figure 14.4: The more important members of the HContainerManager class.

Chapter 15: 3D Render Engine Using JOGL

Figure 15.1: Retained mode structures. RenderShape contains references to a float[] matrix, a VertexArraySet object, and an Appearance object.

Figure 15.2: Simple render engine structure.

Figure 15.3: Example static and dynamic VertexArraySets.

Figure 15.4: Transformation hierarchy.

Figure 15.5: Backface culling applied to objects.

Figure 15.6: Backface culling single triangles.

Figure 15.7: The view frustum.

Figure 15.8: Example bounding volume types.

Figure 15.9: Simple bounding volume hierarchies.

Figure 15.10: Complex bounding volume hierarchies.

Figure 15.11: Quad tree spatial partitioning structure.

Chapter 16: 3D Collision Detection and Response

Figure 16.1: The Collision detection process.

Figure 16.2: Example bounding volume types.

Figure 16.3: Simple bounding volume hierarchy.

Figure 16.4: Complex bounding volume hierarchy.

Figure 16.5: Collision engine design.

Figure 16.6: Static collision success and failure.

Figure 16.7: Collisions object types.

Figure 16.8: Point- to-AABB and -Sphere collisions.

Figure 16.9: Sphere-and-AABB collision.

Figure 16.10: Closest point on a line.

Figure 16.11: Ray-to-sphere collision.

Figure 16.12: Point-to-cylinder collision.

Figure 16.13: Sphere-to-cylinder collision.

Figure 16.14: Ray-to-AABB collision. Frames 1 and 2 show a miss, frames 3 and 4 a hit.

Figure 16.15: Closest point to the plane.

Figure 16.16: Sphere-to-plane test—no collision.

Figure 16.17: Sphere-to-plane test—collision occurred.

Figure 16.18: Line segment-to-triangle intersection.

Figure 16.19: Line segment-to-triangle rejection cases.

Figure 16.20: The 3D half-space test.

Figure 16.21: Line-to-plane intersection equation.

Figure 16.22: Line-and-plane intersection.

Figure 16.23: Line-and-plane intersection.