PositionInterpolator - change axis

Question

Hello,
A question concerning PositionInterpolator:
I�m trying to use setTransformAxis(Transform3D axisOfTransform) method to change axis from X (default) to Y. The question is how to construct Transform3D object that is passed as a parameter.
Thanks in advance!

Answer 1

Well kiddies, it's getting late and my head hurts. I'm still trying to get the new Interpolator working...
Anyway, here's what I got so far (if it helps you, etc etc). Everything works except the Interpolator. I'll have to run some tests to make sure I'm using it right. Keep in mind this code is incomplete (it doesn't do exactly what's it's supposed to yet):
// Allows an object or group of objects to be moved around SMOOTHLY by the
// keyboard in the X x Z plane.
public class KeyboardControlBehavior extends Behavior {
// USER DEFINED VARIABLES (SET ONCE, REQUIRED TO SET THINGS UP)
// The time is takes to move once.
private long time = 0;
// The distance travelled in one move.
private float distance = 0.0f;
// The TransformGroup to move around.
private TransformGroup target = null;
// SYSTEM DEFINED VARIABLES (SET ONCE, REQUIRED FOR FUTURE MOVEMENTS
private Vector3d rotationAxis = null;
// BEHAVIOR DEFINED VARIABLES (CONSTANTLY CHANGED TO KEEP MOVING FORWARD)
// The last keyboard key code that was pressed.
int lastKeyCode = KeyEvent.VK_RIGHT;
// The Interpolator used to make the smooth movement animation.
private RotPosScalePathInterpolator posInt = null;
// The Alpha object used by the Interpolator.
private Alpha alpha = null;
// The Knots used by the Interpolator (Alpha time of each key frame).
private float[] knots = null;
// The Quaternions used by the Interpolator (rotation of TransformGroup at
// each key frame).
private Quat4f[] quats = null;
// The Scales used by the Interpolator (scale of TransformGroup at each
// key frame).
private float[] scales = null;
// The Positions used by the Interpolator (position of TransformGroup at
// each key frame).
private Point3f[] positions = null;
// Create the KeyboardControlBehavior.
KeyboardControlBehavior(long time, float distance, TransformGroup target){
super();
// Set the target TransformGroup to move around.
this.target = target;
// Set the time it takes to move the TransformGroup around.
this.time = time;
// Set the Alpha object to the specified time for the Interpolator to use.
this.alpha = new Alpha(1, time);
// Set the distance to move the TransformGroup around.
this.distance = distance;
// Set the rotation axis of the Interpolator to be the Y axis.
Transform3D yAxis = new Transform3D();
yAxis.rotZ(-Math.PI/2.0f);
this.rotationAxis = new Vector3d();
yAxis.get(this.rotationAxis);
// Set the Alpha time of each key frame:
// - Initial frame is at 0.0
// - Rotation frame is at 0.3
// - Translation frame is at 1.0
this.knots = new float[3];
this.knots[0] = 0.0f;
this.knots[1] = 0.3f;
this.knots[2] = 1.0f;
// Set the Scales of each key frame to 100% (1.0f).
this.scales = new float[3];
this.scales[0] = 1.0f;
this.scales[1] = 1.0f;
this.scales[2] = 1.0f;
// Initialize all the positions to be the current TransformGroup's
// position.
Transform3D curPos = new Transform3D();
target.getTransform(curPos);
Vector3f curPosVec = new Vector3f();
curPos.get(curPosVec);
float[] curPos3f = new float[3];
curPosVec.get(curPos3f);
this.positions = new Point3f[3];
this.positions[0] = new Point3f(curPos3f);
this.positions[1] = new Point3f(curPos3f);
this.positions[2] = new Point3f(curPos3f);
// Initialize all the rotations to be the current TransformGroup's
// rotation (none).
this.quats = new Quat4f[3];
this.quats[0] = this.createQuaternionFromAxisAndAngle(this.rotationAxis, 0.0f);
this.quats[1] = this.createQuaternionFromAxisAndAngle(this.rotationAxis, 0.0f);
this.quats[2] = this.createQuaternionFromAxisAndAngle(this.rotationAxis, 0.0f);
// Create the new Interpolator, disable it and add it to the target
// TransformGroup.
this.posInt = new RotPosScalePathInterpolator(alpha, target, new Transform3D(), knots, quats, positions, scales);
this.posInt.setEnable(false);
target.addChild(posInt);
// Initialize the KeyboardControlBehavior.
public void initialize(){
// Set the initial wakeup condition to a key pressed.
this.wakeupOn(new WakeupOnAWTEvent(KeyEvent.KEY_PRESSED));
// KeyboardControlBehavior behavior (tasks to execute after a key is
// pressed).
public void processStimulus(Enumeration criteria){
// Extract the KeyEvent.
KeyEvent event = (KeyEvent) ((WakeupOnAWTEvent) criteria.nextElement()).getAWTEvent()[0];
// Read the key code that was pressed.
int currentKeyCode = event.getKeyCode();
// Execute the desired movement according to which arrow key was pressed
// as well as the previous arrow key (previous direction).
if(alpha.finished()) {
if(currentKeyCode == KeyEvent.VK_UP
|| currentKeyCode == KeyEvent.VK_DOWN
|| currentKeyCode == KeyEvent.VK_LEFT
|| currentKeyCode == KeyEvent.VK_RIGHT) {
// Set the position of the first key frame to the last key frame's
// position.
positions[0] = (Point3f)positions[2].clone();
// Set the rotation of the first key frame to the last key frame's
// rotation.
quats[0] = (Quat4f)quats[2].clone();
switch(currentKeyCode) {
case KeyEvent.VK_UP:
System.out.println("UP KEY");
// If the current direction is different than the last direction,
// a rotation into the new direction is required.
switch(lastKeyCode) {
case KeyEvent.VK_DOWN:
break;
case KeyEvent.VK_LEFT:
break;
case KeyEvent.VK_RIGHT:
break;
case KeyEvent.VK_UP:
// If we're going in the same direction, do not rotate.
positions[1] = (Point3f)positions[0].clone();
quats[1] = (Quat4f)quats[0].clone();
break;
// Set the last key frame farther away on the Z axis.
positions[2].z += distance;
break;
case KeyEvent.VK_DOWN:
System.out.println("DOWN KEY");
break;
case KeyEvent.VK_LEFT:
System.out.println("LEFT KEY");
break;
case KeyEvent.VK_RIGHT:
System.out.println("RIGHT KEY");
// If the current direction is different than the last direction,
// a rotation into the new direction is required.
switch(lastKeyCode) {
case KeyEvent.VK_DOWN:
break;
case KeyEvent.VK_LEFT:
break;
case KeyEvent.VK_RIGHT:
// If we're going in the same direction, do not rotate.
positions[1] = (Point3f)positions[0].clone();
quats[1] = (Quat4f)quats[0].clone();
break;
case KeyEvent.VK_UP:
break;
// Set the last key frame farther away on the X axis.
positions[2].x += distance;
break;
// Enable the Interpolator.
posInt.setEnable(true);
// Activate the Interpolator to move the TransformGroup.
posInt.getAlpha().setStartTime(System.currentTimeMillis());
// Save the last key code.
lastKeyCode = currentKeyCode;
else {
System.out.println("NOT AN ARROW KEY");
// Don't move the TransformGroup.
else {
System.out.println("Waiting for animation to complete...");
// Wait till animation is finished to process next key.
// Consume the key pressed event.
event.consume();
// Reset the wakeup condition to await the next key pressed event.
this.wakeupOn(new WakeupOnAWTEvent(KeyEvent.KEY_PRESSED));
// A very practical method to convert Radian angles into Quaternions.
// (Taken from page 207 of Daniel Selman's Java 3D Programming book.)
private Quat4f createQuaternionFromAxisAndAngle( Vector3d axis, double angle ) {
double sin_a = Math.sin( angle / 2 );
double cos_a = Math.cos( angle / 2 );
// Use a Vector so we can call normalize.
Vector4f q = new Vector4f();
q.x = (float) (axis.x + sin_a);
q.y = (float) (axis.y + sin_a);
q.z = (float) (axis.z + sin_a);
q.w = (float) cos_a;
// It is best to normalize the Quaternion so that only rotation
// information is used.
q.normalize();
// Convert to a Quat4f and return.
return new Quat4f( q );
} // end of class KeyboardNavigationBehavior