From 53ebfcc5ad5554b67d2287f8b02c22ec8405af0f Mon Sep 17 00:00:00 2001
From: kcr <kcr@28c7f869-5b4e-e670-f602-82bfaf57f300>
Date: Wed, 9 Jun 2004 03:28:13 +0000
Subject: Initial creation of j3d-examples sources in CVS repository

---
 src/VirtualInputDevice/VirtualInputDevice.java | 258 +++++++++++++++++++++++++
 1 file changed, 258 insertions(+)
 create mode 100644 src/VirtualInputDevice/VirtualInputDevice.java

(limited to 'src/VirtualInputDevice/VirtualInputDevice.java')

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");
+         }
+    }
+
+}
-- 
cgit v1.2.3