Chris Campbell (July 28, 2003 9:46PM PT)
URL: http://weblogs.java.net/pub/wlg/278
» Permalink
[I was going to reply to Chris's excellent weblog in the talkback section, but
I started rambling and it touched on some other thoughts I've had, so I decided
to ramble here instead... Keep in mind that I'm only half-wearing my Sun cap
right now (kind of like one of those green and brown, half A's, half Giants
caps that were popular in the '89 Series), so I'm not speaking entirely on behalf
of the company.]
In response to Chris Adamson's recent blog entry, The End (of Java3D) and the
Beginning (of JOGL) :
I'd just like to point out that JOGL is not an all-out replacement for Java3D.
The two can co-exist, and one could potentially rewrite the platform-specific
layer of J3D to sit atop JOGL. Java3D does indeed act as an "isolation
layer" for the underlying platform when a developer uses its "immediate
mode" APIs, but more importantly Java3D offers a high-level scene graph
API. Many educational and corporate institutions have chosen Java3D because
of its scene graph offerings, in addition to the appeal of its cross-platform
nature.
On the other side of the coin you have the traditional game shops, who want
to get as close to the graphics platforms/hardware as possible. Many of these
folks are finding JOGL a better fit because it's a lower-level API, and they
can make use of their existing OpenGL knowledge/code base. So I think it depends
on the type of application you're developing which API best suits your needs.
The gaming community has been clamoring for official Java bindings for OpenGL
for quite some time, so that's where Sun's efforts seem to be heading, but don't
count Java3D out for good; it still serves its purpose quite well as a higher
level 3D graphics library.
Related to this discussion, we're also starting to see some folks on the javagaming.org
forums asking whether JOGL would be a better fit than Java 2D for their apps/games.
Again, JOGL is not the end-all and be-all Java graphics library. Many people
don't realize that OpenGL is actually an expressive 2D library, despite its
tight association with the 3D world. However, there's so much more to 2D graphics
than rendering lines and sprites really fast (think medical imaging, complete
support for any image format or color/sample model, printing, text rendering,
stable offscreen rendering, etc). This is where Java 2D really blows the proverbial
socks off all the other 2D libraries out there.
My answer to those folks on javagaming.org is the same as my J3D response: Java
2D is a higher-level, easier-to-use, more robust, more full-featured 2D rendering
API than JOGL. Like J3D, the two technologies can play well together (if we
do our job correctly, there should be no reason why the two API's couldn't be
used in the same application). Also like J3D, we use hardware-accelerated graphics
libraries (such as Direct3D and OpenGL) under the hood, so for many applications,
performance should be virtually the same whether you use Java 2D or JOGL. As
I mentioned earlier for J3D, we could also port our OpenGL-based Java 2D pipeline
to sit atop JOGL (in fact, we're exploring this idea for a future release, which
should further decrease our dependence on native C code). If you want to access
the very latest in hardware technology, such as programmable shaders, or if
you have large data sets of vertices and you're comfortable with the increased
complexity of OpenGL, then JOGL would certainly be a better fit.
So the choice is yours... Each API has its benefits; it's up to you to evaluate
which one is best-suited for your next project! Chris Campbell is an engineer
on the Java 2D Team at Sun Microsystems, working on OpenGL hardware acceleration
and imaging related issues.