diff options
Diffstat (limited to 'src/VirtualInputDevice/VirtualInputDevice.java')
| -rw-r--r-- | src/VirtualInputDevice/VirtualInputDevice.java | 258 |
1 files changed, 258 insertions, 0 deletions
diff --git a/src/VirtualInputDevice/VirtualInputDevice.java b/src/VirtualInputDevice/VirtualInputDevice.java new file mode 100644 index 0000000..d148fd0 --- /dev/null +++ b/src/VirtualInputDevice/VirtualInputDevice.java @@ -0,0 +1,258 @@ +/* + * $RCSfile$ + * + * Copyright (c) 2004 Sun Microsystems, Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistribution of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistribution in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of Sun Microsystems, Inc. or the names of + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * This software is provided "AS IS," without a warranty of any + * kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND + * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY + * EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL + * NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF + * USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS + * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR + * ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, + * CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND + * REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF OR + * INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGES. + * + * You acknowledge that this software is not designed, licensed or + * intended for use in the design, construction, operation or + * maintenance of any nuclear facility. + * + * $Revision$ + * $Date$ + * $State$ + */ + +import javax.media.j3d.*; +import javax.vecmath.*; +import java.awt.*; +import java.awt.event.*; + +public class VirtualInputDevice implements InputDevice { + + private Vector3f position = new Vector3f(); + private Transform3D newTransform = new Transform3D(); + Sensor sensors[] = new Sensor[1]; + + // The wheel controls control the view platform orientation + private RotationControls rotControls; + + // The button position controls control the view platform position + private PositionControls positionControls; + + private Transform3D rotTransX = new Transform3D(); + private Transform3D rotTransY = new Transform3D(); + private Transform3D rotTransZ = new Transform3D(); + + private Vector3f initPos = new Vector3f(); + + private int processingMode; + private SensorRead sensorRead = new SensorRead(); + + // These are the settable parameters. + private boolean printvalues; + private int xscreeninitloc; + private int yscreeninitloc; + private int xscreensize; + private int yscreensize; + private float xobjinitloc; + private float yobjinitloc; + private float zobjinitloc; + private float xaxisrotinit; + private float yaxisrotinit; + private float zaxisrotinit; + + /* + * Create a device, and use the string arguments in args to construct + * the device with user preferences. + */ + public VirtualInputDevice( String[] args ) { + + // default user-definable values + printvalues = false; + xscreeninitloc = 400; + yscreeninitloc = 0; + xscreensize = 400; + yscreensize = 200; + xobjinitloc = 0.0f; + yobjinitloc = 0.0f; + zobjinitloc = 2.2f; + xaxisrotinit = 0.0f; + yaxisrotinit = 0.0f; + zaxisrotinit = 0.0f; + + + for(int i=0 ; i<args.length ; i+=2) { + if(args[i] == null) + break; + else if(args[i] == "printvalues") + printvalues = (Boolean.valueOf(args[i+1])).booleanValue(); + else if(args[i] == "xscreeninitloc") + xscreeninitloc = (Integer.valueOf(args[i+1])).intValue(); + else if(args[i] == "yscreeninitloc") + yscreeninitloc = (Integer.valueOf(args[i+1])).intValue(); + else if(args[i] == "xscreensize") + xscreensize = (Integer.valueOf(args[i+1])).intValue(); + else if(args[i] == "yscreensize") + yscreensize = (Integer.valueOf(args[i+1])).intValue(); + else if(args[i] == "xobjinitloc") + xobjinitloc = (Float.valueOf(args[i+1])).floatValue(); + else if(args[i] == "yobjinitloc") + yobjinitloc = (Float.valueOf(args[i+1])).floatValue(); + else if(args[i] == "zobjinitloc") + zobjinitloc = (Integer.valueOf(args[i+1])).floatValue(); + } + + if(printvalues == true) { + System.out.println("Initial values for VirtualInputDevice:"); + System.out.println("xscreeninitloc = " + xscreeninitloc); + System.out.println("yscreeninitloc = " + yscreeninitloc); + System.out.println("xscreeninitsize = " + xscreensize); + System.out.println("yscreeninitsize = " + yscreensize); + System.out.println("xobjinitloc = " + xobjinitloc); + System.out.println("yobjinitloc = " + yobjinitloc); + System.out.println("zobjinitloc = " + zobjinitloc); + System.out.println("xaxisrotinit = " + xaxisrotinit); + System.out.println("yaxisrotinit = " + yaxisrotinit); + System.out.println("zaxisrotinit = " + zaxisrotinit); + } + + + // initialize the InputDevice GUI + Frame deviceFrame = new Frame(); + deviceFrame.setSize(xscreensize,yscreensize); + deviceFrame.setLocation(xscreeninitloc, yscreeninitloc); + deviceFrame.setTitle("Virtual Input Device"); + ButtonPositionControls positionControls; + // initialize position with initial x, y, and z position + positionControls = new ButtonPositionControls( xobjinitloc, + yobjinitloc, zobjinitloc); + WheelControls rotControls; + // initialize rotations with initial angles in radians) + rotControls = new WheelControls(xaxisrotinit, yaxisrotinit, + zaxisrotinit); + positionControls.setDevice (this); + Panel devicePanel = new Panel(); + devicePanel.setLayout( new BorderLayout() ); + devicePanel.add("East", positionControls ); + devicePanel.add("West", rotControls ); + deviceFrame.add( devicePanel ); + deviceFrame.pack(); + deviceFrame.setVisible(true); + + initPos.set(xobjinitloc, yobjinitloc, zobjinitloc); + + this.positionControls = positionControls; + this.rotControls = rotControls; + + // default processing mode + processingMode = InputDevice.DEMAND_DRIVEN; + + sensors[0] = new Sensor(this); + } + + public void close() { + } + + public int getProcessingMode() { + return processingMode; + } + + public int getSensorCount() { + return sensors.length; + } + + public Sensor getSensor( int sensorIndex ) { + return sensors[sensorIndex]; + } + + public boolean initialize() { + return true; + } + + public void pollAndProcessInput() { + + sensorRead.setTime( System.currentTimeMillis() ); + + rotTransX.rotX(-rotControls.getXAngle()); + rotTransY.rotY(-rotControls.getYAngle()); + rotTransZ.rotZ(-rotControls.getZAngle()); + + positionControls.getPosition(position); + newTransform.set(position); + newTransform.mul( rotTransX ); + + newTransform.mul(rotTransY); + newTransform.mul(rotTransZ); + + sensorRead.set( newTransform ); + sensors[0].setNextSensorRead( sensorRead ); + } + + + public void processStreamInput() { + } + + + public void setNominalPositionAndOrientation() { + + sensorRead.setTime( System.currentTimeMillis() ); + + rotTransX.rotX(xaxisrotinit); + rotTransY.rotY(yaxisrotinit); + rotTransZ.rotZ(zaxisrotinit); + + position.set(initPos); + + newTransform.set( position ); + + newTransform.mul(rotTransX); + newTransform.mul(rotTransY); + newTransform.mul(rotTransZ); + + sensorRead.set( newTransform ); + sensors[0].setNextSensorRead( sensorRead ); + rotControls.reset(); + positionControls.setPosition(initPos); + } + + + + public void setProcessingMode( int mode ) { + + // A typical driver might implement only one of these modes, and + // throw an exception when there is an attempt to switch modes. + // However, this example allows one to use any processing mode. + + switch(mode) { + case InputDevice.DEMAND_DRIVEN: + case InputDevice.NON_BLOCKING: + case InputDevice.BLOCKING: + processingMode = mode; + break; + default: + throw new IllegalArgumentException("Processing mode must " + + "be one of DEMAND_DRIVEN, NON_BLOCKING, or BLOCKING"); + } + } + +} |