Raytracing a Java3D scene's View

Question

Hi,
I have a simple Java3D modelling app, which I am trying to hook up a basic Raytracer to.
Scene Graph looks something like the following:
                 VirtualUniverse, etc
                          |
                       Locale
                          |
    ContentBranchGroup         ViewsBranchGroup
            |                          |
           ...                 TransformGroup [*]
                                       |
                                 ViewPlatform  -  ViewI have a simple mouse pan behaviour, a mouse zoom behaviour, and a mouse orbit behaviour that all modify the Transform Group marked with a [*] above, thereby changing the "camera" by which the user looks at the scene. The behaviours work very well.
I am trying to hook the raytracer up to "look" through this camera. (I have all the other raytracer stuff working)
The raytracer requires the following:
- The camera eye position
- The camera target (look at) position
- The camera up vector
I am trying to extract this information from the [*] marked TransformGroup's Transform3D object but it is very difficult. I can get the eye position using the transform3D.get(Vector3d) method.
I have tried so many ways to get the target and up vectors. I know the principles to get them but the Transform3D get() methods are to say the least, a nightmare, for me to work with. CAN ANYBODY HELP ME?
If it helps I have managed to get the Euler angles for the camera rotation (converting the rotation Quaternion)...
What next? Please...!
Thanks in advance

Answer 1

Yes, I understand what you are trying to do. Essentially, what it requires is that you do some linear algebra from the position and orientation of the camera object. So, you can get the following:
Camera position:
the actual point location of the camera in the virtual world:
viewTransform3D.get( Vector3f position );
Camera "look at" position:
I assume you don't actually need the point on the X-Y plane (or at least, you shouldn't), but a point along the path in which the camera points (we call the VPN, or view-plane normal). So, in essence, when you take the "look at point" and subtract the "camera position point", you get a vector in 3d space which tells you the direction the camera is pointing. Whichever one you need, you will have to calculate that. More on this in a moment.
Camera "up vector":
This is another one you will have to calculate based on the location of the camera and its current orientation. This one again is a vector based on the original "up" location (also called VUP). More on this one right now...
A good way to resolve this issue is to calculate these vectors based on two points at the beginning of your application, and use them to calcuate the camera's focus point (via VPN) and the camera's up vector. Its pretty simple and easy to implement. Basically, when you set up your camera (view platform), you set the camera position to some default location. When you set this default location, create 2 points which represent the end of the up vector and the end of the VPN, respectively. Then, whenever the transform group which contains the camera's transform is manipulated, simply take that Transform3D and use its matrix to modify the locations of your two initial points, thus giving you the end of the up vector and the end of the vpn transformed by the same transform used to rotate the camera. Then simply subract the camera's location point from each of these and you have the up vector and the vpn, ready for your ray tracer.
I've included some sample code to show you what I'm talking about. Check out the canvas' mouse listener to find the calculations for the VUP and VPN. It sounds like your implementation requires a look at Point3d, so what you could do is just take the camera's location and add some multiple of the VPN to get a look at point.
Anyway, here's the code...
import com.sun.j3d.utils.behaviors.vp.OrbitBehavior;
import com.sun.j3d.utils.geometry.ColorCube;
import com.sun.j3d.utils.universe.SimpleUniverse;
import java.awt.Dimension;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import javax.media.j3d.AmbientLight;
import javax.media.j3d.Appearance;
import javax.media.j3d.BoundingSphere;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.DirectionalLight;
import javax.media.j3d.Group;
import javax.media.j3d.GraphicsConfigTemplate3D;
import javax.media.j3d.Light;
import javax.media.j3d.Material;
import javax.media.j3d.PhysicalBody;
import javax.media.j3d.PhysicalEnvironment;
import javax.media.j3d.PointLight;
import javax.media.j3d.PolygonAttributes;
import javax.media.j3d.Shape3D;
import javax.media.j3d.TransformGroup;
import javax.media.j3d.Transform3D;
import javax.media.j3d.View;
import javax.media.j3d.ViewPlatform;
import javax.media.j3d.TransformGroup;
import javax.swing.BoxLayout;
import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.vecmath.Color3f;
import javax.vecmath.Color4f;
import javax.vecmath.Point3d;
import javax.vecmath.Point3f;
import javax.vecmath.Vector3d;
import javax.vecmath.Vector3f;
* The <code>SimpleViewCalculator</code> class calculates the up vector and the
* view plane normal for a camera based on its current position and the
* transformation of two default up vector and VPN reference points.
* @version 1.0
public class SimpleViewCalculator
  extends JFrame
  // CONSTRUCTOR
   * Creates a new <code>SimpleViewCalculator</code> instance.
  public SimpleViewCalculator()
    // Create the canvas and add it to the universe.
    canvas = initializeCanvas();
    universe = new SimpleUniverse( canvas );
    // Create the content for the virtual universe.
    worldRoot = createWorldObjects();
    worldRoot.addChild( createColorCube( 0.0f, 0.0f, 0.0f, 5.0f ) );
    universe.addBranchGraph( worldRoot );
    universe.getViewingPlatform().
      setViewPlatformBehavior( createOrbitBehavior() );
    // Set the clipping distances for the view.
    universe.getViewer().getView( ).setBackClipDistance( 1000.0 );
    universe.getViewer().getView( ).setFrontClipDistance( 0.1 );  
    setCameraPosition( 0.0f,  0.0f, 50.0f );
    upPoint = new Point3d( 0.0, 1.0, 0.0 );
    lookAtPoint = new Point3d( 0.0, 0.0, -1.0 );
       this.getContentPane().setLayout(
      new BoxLayout( this.getContentPane(), BoxLayout.Y_AXIS ) );
    this.getContentPane().add( canvas );
    canvas.addMouseListener(
      new MouseAdapter()
         * The mouseClicked on this mouse listener is where the work for
         * calculating the up vector and the view plane normal.
        public void mouseClicked( MouseEvent event )
          TransformGroup viewPlatformTG =
            universe.getViewingPlatform().getViewPlatformTransform();
          Transform3D cameraT3D = new Transform3D();
          Vector3d cameraPos = new Vector3d();
          viewPlatformTG.getTransform( cameraT3D );
          cameraT3D.get( cameraPos );
          // Calculate the "up" vector.
          Point3d newUpPoint = new Point3d();
          cameraT3D.transform( upPoint, newUpPoint );
          Vector3d upVector = new Vector3d();
          upVector.x = newUpPoint.x - cameraPos.x;
          upVector.y = newUpPoint.y - cameraPos.y;
          upVector.z = newUpPoint.z - cameraPos.z;
          upVector.normalize();
          System.err.println( "new up vector = " + upVector );
          // Calculate the "vpn" or direction the camera is pointing.
          Point3d newLookAtPoint = new Point3d();
          cameraT3D.transform( lookAtPoint, newLookAtPoint );
          Vector3d vpn = new Vector3d();
          vpn.x = newLookAtPoint.x - cameraPos.x;
          vpn.y = newLookAtPoint.y - cameraPos.y;
          vpn.z = newLookAtPoint.z - cameraPos.z;
          vpn.normalize();
          System.err.println( "new view plane normal = " + vpn );
    this.setVisible( true );
    this.setSize( new Dimension( 300, 375 ) );   
  // METHODS
   * Initialize a Canvas3D with default graphics configuration for user's
   * system.
   * @return a <code>Canvas3D</code> value
  private Canvas3D initializeCanvas()
    GraphicsConfigTemplate3D tmpl = new GraphicsConfigTemplate3D( );
    GraphicsEnvironment env =
      GraphicsEnvironment.getLocalGraphicsEnvironment( );
    GraphicsDevice device = env.getDefaultScreenDevice( );
    GraphicsConfiguration config = device.getBestConfiguration( tmpl );
    Canvas3D canvas3D = new Canvas3D( config );
    return canvas3D; 
   * Create a orbit behavior for the canvas and simple universe.
  private OrbitBehavior createOrbitBehavior()
    OrbitBehavior orbit =
      new OrbitBehavior( canvas, OrbitBehavior.REVERSE_ALL );
    BoundingSphere bounds =
      new BoundingSphere( new Point3d( 0.0, 0.0, 0.0 ), 1000000000 );
    orbit.setSchedulingBounds( bounds );
    orbit.setTranslateEnable( true );
    orbit.setZoomEnable( true );
    orbit.setProportionalZoom( true );
    orbit.setReverseZoom( true );
    return orbit;
   * Create the objects that will appear in the virutal world and add them to a
   * branch group which is returned to the calling method.
   * @return a <code>BranchGroup</code> value
  private BranchGroup createWorldObjects()
    BranchGroup root = new BranchGroup();
    root.setCapability( BranchGroup.ALLOW_DETACH );
    root.setCapability( Group.ALLOW_CHILDREN_EXTEND );
    root.setCapability( Group.ALLOW_CHILDREN_READ );
    root.setCapability( Group.ALLOW_CHILDREN_WRITE );
    return root;
   * Create a color cube of <code>scale</code> size, attached to a branch group.
   * This method returns a color cube attached to that branch group.
  private BranchGroup createColorCube( float x, float y, float z, double scale )
       BranchGroup colorCubeRoot = new BranchGroup();
       colorCubeRoot.setCapability( BranchGroup.ALLOW_DETACH );
       TransformGroup colorCubeTG = new TransformGroup();
       Transform3D colorCubeT3D = new Transform3D();
       colorCubeT3D.set( new Vector3f( x, y, z ) );
       colorCubeTG.setTransform( colorCubeT3D );
       colorCubeRoot.addChild( colorCubeTG );
       ColorCube cube = new ColorCube( scale );
       colorCubeTG.addChild( cube );
       return colorCubeRoot;
   * Set the position of the camera.
  private void setCameraPosition( float x, float y, float z )
    Transform3D vt = new Transform3D();
    Point3d eye = new Point3d( x, y , z );
    Point3d  center = new Point3d( 0, 0, 0 );
    Vector3d up = new Vector3d( 0.0, 1.0, 0.0 );   
    vt.lookAt( eye, center, up );
    vt.invert( );
    vt.setTranslation( new Vector3d( eye.x, eye.y, eye.z ) );
    universe.getViewer().getViewingPlatform( ).
      getViewPlatformTransform( ).setTransform( vt );
   * Main method for application.
  public static void main( String[] args )
    new SimpleViewCalculator();     
  // ATTRIBUTES
  /** A Simple 3D virtual world. */
  private SimpleUniverse universe;
  /** Component to paint contents of virtual world. */
  private Canvas3D canvas;
  /** Allows mouse rotations, etc. */
  private OrbitBehavior orbitBehavior;
  /** View object for simple universe. */
  private View view;
  /** Branch group for adding world objects. */
  private BranchGroup worldRoot;
  /** Branch group for attaching lights. */
  private BranchGroup lightRoot;
  /** Point light for illuminating scene. */
  private PointLight pointLight;
  /** A point used to calcuate the up vector. */
  private Point3d upPoint;
  /** A point used to calculate the VPN. */
  private Point3d lookAtPoint;
}Hope that helps. You should check this on your own to make sure no mistakes were made, I didn't have too much time to test it.
Cheers,
Greg