KeyNavigator.java

package org.freehep.j3d.plot;

import java.io.*;
import java.util.*;
import javax.media.j3d.*;
import javax.vecmath.*;
import java.awt.event.*;

/**
 * This is the KeyNavigator class.  It accumulates AWT key events (key
 * press and key release) and computes a new transform based on the
 * accumulated events and elapsed time.
 *
 * @author Joy Kyriakopulos (joyk@fnal.gov)
 * @version $Id: KeyNavigator.java 8584 2006-08-10 23:06:37Z duns $
 */
public class KeyNavigator {

    private	Vector3d	navVec;
    private	long		time;

    private	Vector3d	fwdAcc;
    private	Vector3d	bwdAcc;
    private	Vector3d	leftAcc;
    private	Vector3d	rightAcc;
    private	Vector3d	upAcc;
    private	Vector3d	downAcc;

    private	Vector3d	fwdDrag;
    private	Vector3d	bwdDrag;
    private	Vector3d	leftDrag;
    private	Vector3d	rightDrag;
    private	Vector3d	upDrag;
    private	Vector3d	downDrag;

    private	double		fwdVMax;
    private	double		bwdVMax;
    private	double		leftVMax;
    private	double		rightVMax;
    private	double		upVMax;
    private	double		downVMax;

    private	float		leftRotAngle;
    private	float		rightRotAngle;
    private	float		upRotAngle;
    private	float		downRotAngle;

    private	double		mmx;

    private	Vector3d	a	= new Vector3d();
    private	Vector3d	dv	= new Vector3d();
    private	Point3d		dp	= new Point3d();
    private	Quat4d		udQuat	= new Quat4d();
    private	Quat4d		lrQuat	= new Quat4d();
    private	Vector3d	vpPos	= new Vector3d();
    private	double		vpScale;
    private	Quat4d		vpQuat	= new Quat4d();
    private	Matrix4d	vpMatrix = new Matrix4d();
    private	Transform3D	vpTrans	= new Transform3D();
    private	Matrix4d	mat	= new Matrix4d();
    private	Vector3d	nda	= new Vector3d();
    private	Vector3d	temp	= new Vector3d();
    private	Transform3D	nominal = new Transform3D();
    private	TransformGroup	targetTG;

    private	static	final	int	UP_ARROW	= (1<<0);
    private	static	final	int	DOWN_ARROW	= (1<<1);
    private	static	final	int	LEFT_ARROW	= (1<<2);
    private	static	final	int	RIGHT_ARROW	= (1<<3);
    private	static	final	int	PLUS_SIGN	= (1<<4);
    private	static	final	int	MINUS_SIGN	= (1<<5);
    private	static	final	int	PAGE_UP		= (1<<6);
    private	static	final	int	PAGE_DOWN	= (1<<7);
    private	static	final	int	HOME_DIR	= (1<<8);
    private	static	final	int	HOME_NOMINAL	= (1<<9);

    private	static	final	int	SHIFT		= (1<<10);
    private	static	final	int	ALT		= (1<<11);
    private	static	final	int	META		= (1<<12);

    private	static	final	int	KEY_UP		= (1<<13);
    private	static	final	int	KEY_DOWN	= (1<<14);

    private	int	key_state = 0;
    private	int	modifier_key_state = 0;


    /**
     * Constructs a new key navigator object that operates on the specified
     * transform group.  All parameters are set to their default, idle state.
     * @param targetTG the target transform group
     */
    public KeyNavigator(TransformGroup targetTG) {
	this.targetTG = targetTG;
	targetTG.getTransform(nominal);

	mmx = 128.0;
	navVec =    new Vector3d(0.0,0.0,0.0);

	fwdAcc =     new Vector3d( 0.0, 0.0,-mmx);
	bwdAcc =     new Vector3d( 0.0, 0.0, mmx);
	leftAcc =    new Vector3d(-mmx, 0.0, 0.0);
	rightAcc =   new Vector3d( mmx, 0.0, 0.0);
	upAcc =      new Vector3d( 0.0, mmx, 0.0);
	downAcc =    new Vector3d( 0.0,-mmx, 0.0);

	fwdDrag =    new Vector3d( 0.0, 0.0, mmx);
	bwdDrag =    new Vector3d( 0.0, 0.0,-mmx);
	leftDrag =   new Vector3d( mmx, 0.0, 0.0);
	rightDrag =  new Vector3d(-mmx, 0.0, 0.0);
	upDrag =     new Vector3d( 0.0,-mmx, 0.0);
	downDrag =   new Vector3d( 0.0, mmx, 0.0);

	fwdVMax   = -mmx;
	bwdVMax   = mmx;
	leftVMax  = -mmx;
	rightVMax = mmx;
	upVMax    = mmx;
	downVMax  = -mmx;

	leftRotAngle = (float) (-Math.PI*2.0/3.0);
	rightRotAngle = (float) (Math.PI*2.0/3.0);
	upRotAngle = (float) (Math.PI*2.0/3.0);
	downRotAngle = (float) (-Math.PI*2.0/3.0);

	// Create Timer here.
	time = System.currentTimeMillis();

    }


    private long getDeltaTime() {
	long newTime = System.currentTimeMillis();
	long deltaTime = newTime - time;
	time = newTime;
	if (deltaTime > 2000) return 0;
	else return deltaTime;
    }

    /* Generate a quaterion as a rotation of radians av about 0/x 1/y 2/z axis */
    private void genRotQuat(double av, int axis, Quat4d q) {
	double b;

	q.x = q.y = q.z = 0.0;
	q.w = Math.cos(av/2.0);

	b = 1.0 - q.w*q.w;

	if (b > 0.0)
	    b = Math.sqrt(b);
	else
	    return;

	if (av < 0.0)
	    b = -b;
	if (axis == 0)
	    q.x = b;
	else if (axis == 1)
	    q.y = b;
	else
	    q.z = b;

    }

    private void accKeyAdd(Vector3d a, Vector3d da, Vector3d drag, double scaleVel) {

	/* Scaling of acceleration due to modification keys */
	nda.scale(scaleVel, da);
	/* Addition of sufficent acceleration to counteract drag */
	nda.sub(drag);

	/* Summing into overall acceleration */
	a.add(nda);

    }


    /**
     * Computes a new transform for the next frame based on
     * the current transform, accumulated keyboard inputs, and
     * elapsed time.  This new transform is written into the target
     * transform group.
     * This method should be called once per frame.
     */
    public void integrateTransformChanges() {
	double scaleVel, scaleRot, scaleScale, pre;
	double udAng, lrAng, r;

	// Get the current View Platform transform into a transform3D object.
	targetTG.getTransform(vpTrans);
	// Extract the position, quaterion, and scale from the transform3D.
	vpScale = vpTrans.get(vpQuat, vpPos);


	double deltaTime = (double) getDeltaTime();
	deltaTime *= 0.001;

	/* Calculate scale due to modification keys */
	if ((modifier_key_state & SHIFT) != 0 &&
	    (modifier_key_state & META) == 0) {
	    scaleVel = 3.0; scaleRot = 2.0; scaleScale = 4.0;
	}
	else if ((modifier_key_state & SHIFT) == 0 &&
	         (modifier_key_state & META) != 0) {
	    scaleVel = 0.1; scaleRot = 0.1; scaleScale = 0.1;
	}
	else if ((modifier_key_state & SHIFT) != 0 &&
	         (modifier_key_state & META) != 0) {
	    scaleVel = 0.3; scaleRot = 0.5; scaleScale = 0.1;
	}
	else {
	    scaleRot = scaleVel = 1.0; scaleScale = 4.0;
	}

	/*
	 *  Processing of rectiliear motion keys.
	 */

	a.x = a.y = a.z = 0.0;  /* acceleration initially 0 */

	/* Acceleration due to keys being down */
	if ((key_state & UP_ARROW) != 0 && (key_state & DOWN_ARROW) == 0)
	    accKeyAdd(a, fwdAcc, fwdDrag, scaleVel);
	else
	if ((key_state & UP_ARROW) == 0 && (key_state & DOWN_ARROW) != 0)
	    accKeyAdd(a, bwdAcc, bwdDrag, scaleVel);

	if (((modifier_key_state & ALT) != 0) &&
	    (key_state & LEFT_ARROW) != 0 && (key_state & RIGHT_ARROW) == 0) {
	    accKeyAdd(a, leftAcc, leftDrag, scaleVel);
	} else
	if (((modifier_key_state & ALT) != 0) &&
	    (key_state & LEFT_ARROW) == 0 && (key_state & RIGHT_ARROW) != 0)
	    accKeyAdd(a, rightAcc, rightDrag, scaleVel);

	if (((modifier_key_state & ALT) != 0) &&
	    (key_state & PAGE_UP) != 0 && (key_state & PAGE_DOWN) == 0)
	    accKeyAdd(a, upAcc, upDrag, scaleVel);
	else
	if (((modifier_key_state & ALT) != 0) &&
	    (key_state & PAGE_UP) == 0 && (key_state & PAGE_DOWN) != 0)
	    accKeyAdd(a, downAcc, downDrag, scaleVel);
 

	/*
	 *  Drag due to new or existing motion
	 */
	pre = navVec.z + a.z * deltaTime;
	if (pre < 0.0) {
	    if (pre + fwdDrag.z * deltaTime < 0.0)
		a.add(fwdDrag);
	    else
		a.z -= pre/deltaTime;
	} else if (pre > 0.0) {
	    if (pre + bwdDrag.z * deltaTime > 0.0)
		a.add(bwdDrag);
	    else
		a.z -= pre/deltaTime;
	}

	pre = navVec.x + a.x * deltaTime;
	if (pre < 0.0) {
	    if (pre + leftDrag.x * deltaTime < 0.0)
		a.add(leftDrag);
	    else
		a.x -= pre/deltaTime;
	} else if (pre > 0.0) {
	    if (pre + rightDrag.x * deltaTime > 0.0)
		a.add(rightDrag);
	    else
		a.x -= pre/deltaTime;
	}

	pre = navVec.y + a.y * deltaTime;
	if (pre < 0.0) {
	    if (pre + downDrag.y * deltaTime < 0.0)
		a.add(downDrag);
	    else
		a.y -= pre/deltaTime;
	} else if (pre > 0.0) {
	    if (pre + upDrag.y * deltaTime > 0.0)
		a.add(upDrag);
	    else
		a.y -= pre/deltaTime;
	}

	/* Integration of acceleration to velocity */
	dv.scale(deltaTime, a);
	navVec.add(dv);

	/* Speed limits */
	if (navVec.z < scaleVel * fwdVMax) navVec.z = scaleVel * fwdVMax;
	if (navVec.z > scaleVel * bwdVMax) navVec.z = scaleVel * bwdVMax;
	if (navVec.x < scaleVel * leftVMax) navVec.x = scaleVel * leftVMax;
	if (navVec.x > scaleVel * rightVMax) navVec.x = scaleVel* rightVMax;
	if (navVec.y > scaleVel * upVMax) navVec.y = scaleVel * upVMax;
	if (navVec.y < scaleVel * downVMax) navVec.y = scaleVel * downVMax;

	/* Integration of velocity to distance */
	dp.scale(deltaTime, navVec);

	/* Scale our motion to the current avatar scale */
	// 1.0 eventually needs to be a more complex value (see hs).
	//      r = workplace_coexistence_to_vworld_ori.scale/
	//	one_to_one_coexistence_to_vworld_ori.scale;
	r = vpScale/1.0;
	dp.scale(r, dp);

	/*
	 *  Processing of rotation motion keys.
	 */
	udAng = lrAng = 0.0;

	/* Rotation due to keys being down */
	if (((modifier_key_state & ALT) == 0) &&
	    (key_state & LEFT_ARROW) != 0 && (key_state & RIGHT_ARROW) == 0)
	    lrAng = (double) leftRotAngle;
	else if (((modifier_key_state & ALT) == 0) &&
	    (key_state & LEFT_ARROW) == 0 && (key_state & RIGHT_ARROW) != 0)
	    lrAng =  (double) rightRotAngle;

	if (((modifier_key_state & ALT) == 0) &&
	    (key_state & PAGE_UP) != 0 && (key_state & PAGE_DOWN) == 0)
	    udAng = (double) upRotAngle;
	else if (((modifier_key_state & ALT) == 0) &&
	    	 (key_state & PAGE_UP) == 0 && (key_state & PAGE_DOWN) != 0)
	    udAng = (double) downRotAngle;

	lrAng *= scaleRot;
	udAng *= scaleRot;

	/* Scaling of angle change to delta time */
	lrAng *= deltaTime;
	udAng *= deltaTime;


	/* Addition to existing orientation */
	// vr_quat_inverse(&workplace_coexistence_to_vworld_ori.quat, &vpQuat);
	// vpQuat gotten at top of method.
	vpQuat.inverse();

	if(lrAng != 0.0) {
	    genRotQuat(lrAng, 1, lrQuat);
	    vpQuat.mul(lrQuat, vpQuat);
	}

	if(udAng != 0.0) {
	    genRotQuat(udAng, 0, udQuat);
	    vpQuat.mul(udQuat, vpQuat);
	}

	/* Rotation of distance vector */
	vpQuat.inverse();
	vpQuat.normalize();  /* Improvment over HoloSketch */
	mat.set(vpQuat);
	mat.transform(dp);

	/* Processing of scale */
	if ((key_state & PLUS_SIGN) != 0) {
	    vpScale *= (1.0 + (scaleScale*deltaTime));
	    if (vpScale > 10e+14) vpScale = 1.0;
	} else if ((key_state & MINUS_SIGN) != 0) {
	    vpScale /= (1.0 + (scaleScale*deltaTime));
	    if (vpScale < 10e-14) vpScale = 1.0;
	}

	// add dp into current vp position.
	vpPos.add(dp);

	if ((key_state & HOME_NOMINAL) != 0) {
	    resetVelocity();
	    // Extract the position, quaterion, and scale from the nominal
	    // transform
	    vpScale = nominal.get(vpQuat, vpPos);
	}


	/* Final update of view platform */
	// Put the transform back into the transform group.
	vpTrans.set(vpQuat, vpPos, vpScale);
	targetTG.setTransform(vpTrans);
    }


    /**
     * Resets the keyboard navigation velocity to 0.
     */
    private void resetVelocity() {
	navVec.x = navVec.y = navVec.z = 0.0;
    }


    /**
     * Processed a keyboard event.  This routine should be called
     * every time a KEY_PRESSED or KEY_RELEASED event is received.
     * @param keyEvent the AWT key event
     */
    public void processKeyEvent(KeyEvent keyEvent) {
	int keyCode = keyEvent.getKeyCode();
	int keyChar = keyEvent.getKeyChar();

//System.err.println("keyCode " + keyCode + "  keyChar " + keyChar);

	if (keyEvent.getID() == KeyEvent.KEY_RELEASED) {
	    if (keyChar == '+') key_state &= ~PLUS_SIGN;
	    else
	    switch (keyCode) {
	    case KeyEvent.VK_UP:	key_state &= ~UP_ARROW;	   break;
	    case KeyEvent.VK_DOWN:	key_state &= ~DOWN_ARROW;  break;
	    case KeyEvent.VK_LEFT:	key_state &= ~LEFT_ARROW;  break;
	    case KeyEvent.VK_RIGHT:	key_state &= ~RIGHT_ARROW; break;
	    case KeyEvent.VK_PAGE_UP:	key_state &= ~PAGE_UP;	   break;
	    case KeyEvent.VK_PAGE_DOWN: key_state &= ~PAGE_DOWN;   break;
	    case KeyEvent.VK_EQUALS:	key_state &= ~HOME_NOMINAL;break;
	    default: switch(keyChar) {
		case '-': key_state &= ~MINUS_SIGN; break;
		}
	    }
	} else if (keyEvent.getID() == KeyEvent.KEY_PRESSED) {
	    if (keyChar == '+') key_state |=  PLUS_SIGN;
	    switch (keyCode) {
	    case KeyEvent.VK_UP:	key_state |=  UP_ARROW;	   break;
	    case KeyEvent.VK_DOWN:	key_state |=  DOWN_ARROW;  break;
	    case KeyEvent.VK_LEFT:	key_state |=  LEFT_ARROW;  break;
	    case KeyEvent.VK_RIGHT:	key_state |=  RIGHT_ARROW; break;
	    case KeyEvent.VK_PAGE_UP:	key_state |=  PAGE_UP;	   break;
	    case KeyEvent.VK_PAGE_DOWN: key_state |=  PAGE_DOWN;   break;
	    case KeyEvent.VK_EQUALS:	key_state |=  HOME_NOMINAL;break;
	    default: switch(keyChar) {
		case '-': key_state |=  MINUS_SIGN; break;
		}
	    }
	}

	/* Check modifier keys */
	if (keyEvent.isShiftDown())
	    modifier_key_state |=  SHIFT;
	else
	    modifier_key_state &= ~SHIFT;

	if (keyEvent.isMetaDown())
	    modifier_key_state |=  META;
	else
	    modifier_key_state &= ~META;
	
	if (keyEvent.isAltDown())
	    modifier_key_state |=  ALT;
	else
	    modifier_key_state &= ~ALT;

//System.err.println("keyCode " + keyEvent.getKeyCode() + "  modifiers " + keyEvent.getModifiers());
//System.err.println("SHIFT_MASK " + keyEvent.SHIFT_MASK);
//System.err.println("CTRL_MASK " + keyEvent.CTRL_MASK);
//System.err.println("META_MASK " + keyEvent.META_MASK);
//System.err.println("ALT_MASK " + keyEvent.ALT_MASK);

    }
}