3D transformation in Java 2D?

Question

I don't want to use Java 3D/JOGL for my static generated images as those APIs / components have platform dependent modules. How can I generate 3D images with Java 2D? (E.g. a 3D object correctly displayed with Java 2D)?

Answer 1

Before going on, you may want to revisit your decision to even engage this problem. You're basically building your own 3d library, which is not a straightforward task. If you do not have a background in Advanced Calculus, Physics, or Linear Algebra, you will be seeing some new mathematics. You'll also be writing a LOT of code, that even when completed, will be difficult to use. Now assuming you want to continue. . .
You actually have two problems.
The first problem is mapping the pixels of an image to the surface of a sphere, which is not something I've worked on before. You'll need a mapping transformation to define how the wrapping will be done (since the surface of a sphere is not rectangular). Heres the first one that popped into my mind: map each line of latitude to a horizontal strip on the image. In other words, as you trace a line of latitude around the sphere, moving from longitude 0 to 360, get your color information from 0 to image.getWidth(), at a fixed Y value. Note that this solution will cause your image to look bloated near the equator. Also note that any efficient mapping transformation is going to require directly interacting with the image pixel data.
The second problem is projecting your 3d pixels to a 2d plane (the screen). As noted in my previous response, you'll need to define the plane in terms of two orthonormal basis vectors, and compute the dot product of your 3d point with each vector.
/* This code assumes the existence of a Point3D class with public
* x, y, and z coordinates. It also assumes the existence of a Plane3D
* with two Vector3D basisVectors. Each Vector3D also has an x, y and z.
public static Point project(Point3D point, Plane3D ontoThis){
   //compute the scalar product of the 3d point with the
   //planes first basis vector
   int x = (point.x * ontoThis.basisVector1.x) +
           (point.y * ontoThis.basisVector1.y) +
           (point.z * ontoThis.basisVector1.z);
   //compute the scalar product of the 3d point with the
   //planes 2nd basis vector
   int y = (point.x * ontoThis.basisVector2.x) +
           (point.y * ontoThis.basisVector2.y) +
           (point.z * ontoThis.basisVector2.z);
   //return the data
   return new Point(x,y);
}Notice that to control the perspective, you have to change your plane's basis vectors. This can make your scene difficult to control. Also, if you pick vectors that are not orthonormal, you will get crazy results. (This is comparable to telling the computer that the X and Y axis's do not intersect at a right angle, or that one axis is longer than another.)
I do not yet have a solution that provides an intuitive way of controlling perspective.
Message was edited by:
BillC