Geographic information system (GIS) developers wishing to expand into the 3D world and game developers looking for an alternative to virtual world representation appreciate the difficulty in creating virtual worlds that accurately portray the real world and can be navigated by interactive programs. Java 3D provides powerful and efficient mechanisms to display virtual worlds and convenient user interfaces to manipulate the worlds' views. In this article, I describe how to load and display data available from the US Geological Survey (USGS) in DEM (digital elevation model) format and how to create a user interface that allows keyboard and mouse controls to navigate through the virtual world. Figure 1 presents an aerial view of the Grand Canyon created by the application. The application's complete source code and Javadoc HTML files are available in Resources, as is a link to the USGS Website where the data resides. |
Objects in our world have characteristics, or properties, such as shape, size, weight, position, orientation, and color (and the list goes on and on). Let's consider for a moment only their shape, position, and orientation -- these properties are what we call spatial properties. And let's start with something easier to work with than a chair -- a cube, for example. |
We'll be looking at a fairly specific subject: generating and rendering terrain maps, such as the surface of Mars or a few atoms of gold. Terrain-map rendering can be used for more than just aesthetic purposes -- many data-visualization techniques produce data that can be rendered as terrain maps. My intentions are, of course, entirely artistic, as you can see by the picture below! Should you so desire, the code that we will produce is general enough that with only minor tweaking it can also be used to render 3D structures other than terrains. |
The eventual result was the Virtual Reality Modeling Language (VRML). Based on the Open Inventor ASCII format from Silicon Graphics, VRML made it possible to describe three-dimensional scenes, complete with shapes, lights, textures, and other effects. VRML provided Web surfers with the added ability to interact with the Web via objects in the virtual world. |
While wire-frame drawings are a fit vehicle to introduce the topic of 3D computer graphics, they suffer from several shortcomings. In particular, they display only the edges of a model. Of course, that limitation is also one of their advantages. Edge information is faster to process and to display. Consequently, large wire-frame drawings often can be manipulated in real time, while more realistic drawings cannot. |
We learned we could build a skeletal copy of a real-world object composed solely of line segments, which allows us to capture the essential information about each object's shape -- the coordinates and the edges. We simply record the coordinates of each line segment's begin and end points in a table, embed that table in a program, and voilĂ , we have a model of the world inside a computer. |
Sun and its partners developed the Java Media and Communication APIs to provide the missing multimedia programming pieces. Two of the biggest pieces, 2D and 3D graphics, are targeted with the Java 2D and 3D APIs, respectively. Java 2D is a core platform API beginning with Java 1.2, while Java 3D will be released as an Extension API shortly after the 1.2 platform becomes available. We have recently finished a series of columns on Java 2D; now we turn our attention to Java 3D. |
|
Default Java 3D coordinate axes, as seen from directly in front of the monitor. We are looking in the -z axis direction, directly into the monitor. The origin is located in the center of the x-y plane. |
|
What has your GPU done for you today? Most modern computers are equipped with a ridiculously fast chip that's dedicated to graphics processing, but Java programs rarely get the chance to make it sing. With the JOGL API, we now have a way to let the GPU take over the lion's share of the math, which suddenly makes Java the language of choice for a lot of 3D applications. If we put all of those design patterns and sophisticated coding techniques we've been learning and refining together with bare-metal access to the graphics processor chip, we should be able to create surprisingly robust 3D apps that are also as fast as can be. This article describes my JOGL adventures while building a virtual universe that I call "Fluidiom" (fluid + idiom), based on push and pull forces. |
This article describes work that was carried out as part of an undergraduate thesis. It includes the development of a 3D multiplayer racing game, JautOGL, using Java 1.4's new I/O APIs for networking, JOGL (Java OpenGL) for graphics, and JOAL (Java OpenAL) for sound. Its supported functions and architecture are described below, together with some important and interesting details of the classes, which are illustrated too. Finally, the discussion of future developments and improvements that can be applied to JautOGL concludes the article. Figures 1 to 4 show some print screens of the game. |
Soon he joined with Sun developers Deron Johnson and Paul Byrne to form a core team committed to building a developer's release -- a completely rewritten version with full-scale productization in mind. In July of 2004, after completing a very initial cut of the developer's release, the Project went open source, and the rest is fast on its way to becoming history. In the latter part of 2004 Project Looking Glass will undergo the finalization of APIs and focus on 3D application development. |
New to the world of 3D? This tutorial offers Java? developers an introduction to the concepts involved with 3D programming in general and the Java 3D API in particular. IBM 3D software engineer and gamer at heart Suzy Deffeyes takes you on a joy ride through the world of Java 3D programming with a high-level discussion of the concepts involved and a detailed look at scene graphs -- the fundamental object used to describe the scene you want to render. |
The first lesson in this series was titled "Back to Basics in the Java 3D API" (see Resources). The previous lesson was titled "Simple Animation with the Java 3D API" This lesson is titled "Understanding the Alpha Time-Base Class in Java 3D" My current plan is for future lessons to deal with user and object interaction as well as advanced animation and textures. |
The first lesson in this series was titled "Back to Basics in the Java 3D API" (see Resources). The previous lesson was titled "Digging a Little Deeper into the Java 3D API." This lesson is titled "Simple Animation with the Java 3D API." My current plan is for future lessons to deal with the detailed behavior of an Alpha time-base object, user and object interaction as well as advanced animation and textures. |
I presented and explained four different programs in this lesson. The last program taught you how to do edge detection on an image. The first three programs were designed to help you understand how edge detection works. Those programs also taught you about color distance, and how to project 3D coordinates onto a 2D display plane. |
The first lesson in this series was titled "Back to Basics in the Java 3D API". The previous lesson was titled "Understanding Transforms in Java 2D." This lesson is titled "Understanding Transforms in Java 3D." |
This is the first part of a multi-part lesson designed to help you understand the use of lighting and illumination in 3D scenes produced using the Java 3D API. |
On the other hand, if you would like to learn how the class does what it does, and perhaps use your programming skills to improve it, keep reading. Hopefully, once you have finished the lesson, you will have learned quite a lot about plotting 3D surfaces using color in Java. |
The first lesson in this series was titled "Back to Basics in the Java 3D API" (see Resources). The previous lesson was titled "Understanding the Alpha Time-Base Class in Java 3D." This lesson is titled "Combining Rotation and Translation in Java 3d." My current plan is for future lessons to deal with user and object interaction as well as advanced animation and textures. |
In the earlier lesson titled "Understanding Lighting in the Java 3D API" (see Resources), I taught you about, and showed you examples of many of the important features of scene illumination in the Java 3D API. I also provided the source code for a complete Java 3D lighting simulator program that you can use to experiment with light in the Java 3D API. At the end of that tutorial, I stated "I will explain how the Java 3D lighting simulator program works in subsequent parts of this multi-part lesson." |
Previous article: Putting the Game-Math Library to Work: Math for Java Game Programmers Next article: Our First 3D Game Program: Math for Java Game Programmers |
This tutorial is the next lesson in a series designed to teach you some of the mathematical skills that you will need (in addition to good programming skills) to become a successful game programmer. The first lesson was titled Math for Java Game Programmers, Getting Started. The previous lesson was titled Math for Java Game Programmers, Venturing into a 3D World (see Resources). |
Upon reflection, I have decided that it would be impractical for me to attempt to explain the inner workings of that very complicated program without first explaining a large number of basic concepts involved in writing programs using the Java 3D API. Therefore, beginning with this lesson, my plan is to start with the basics and to publish a series of tutorial lessons in which I will work my way up to the general complexity exhibited by the program that I provided in the earlier lesson. This will be the first lesson in that series. |