Improved mouse behaviors : Mouse Keyboard Action « 3D « Java

Java
1. 2D Graphics GUI
2. 3D
3. Advanced Graphics
4. Ant
5. Apache Common
6. Chart
7. Class
8. Collections Data Structure
9. Data Type
10. Database SQL JDBC
11. Design Pattern
12. Development Class
13. EJB3
14. Email
15. Event
16. File Input Output
17. Game
18. Generics
19. GWT
20. Hibernate
21. I18N
22. J2EE
23. J2ME
24. JDK 6
25. JNDI LDAP
26. JPA
27. JSP
28. JSTL
29. Language Basics
30. Network Protocol
31. PDF RTF
32. Reflection
33. Regular Expressions
34. Scripting
35. Security
36. Servlets
37. Spring
38. Swing Components
39. Swing JFC
40. SWT JFace Eclipse
41. Threads
42. Tiny Application
43. Velocity
44. Web Services SOA
45. XML
Java Tutorial
Java Source Code / Java Documentation
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java » 3D » Mouse Keyboard ActionScreenshots 
Improved mouse behaviors
Improved mouse behaviors

/**********************************************************
 Copyright (C) 2001   Daniel Selman

 First distributed with the book "Java 3D Programming"
 by Daniel Selman and published by Manning Publications.
 http://manning.com/selman

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation, version 2.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 The license can be found on the WWW at:
 http://www.fsf.org/copyleft/gpl.html

 Or by writing to:
 Free Software Foundation, Inc.,
 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

 Authors can be contacted at:
 Daniel Selman: daniel@selman.org

 If you make changes you think others would like, please 
 contact one of the authors or someone at the 
 www.j3d.org web site.
 **************************************************************/

import java.applet.Applet;
import java.awt.AWTEvent;
import java.awt.BorderLayout;
import java.awt.GraphicsConfigTemplate;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Label;
import java.awt.Panel;
import java.awt.TextField;
import java.awt.event.MouseEvent;
import java.io.File;
import java.net.URL;
import java.util.Enumeration;

import javax.media.j3d.Appearance;
import javax.media.j3d.AudioDevice;
import javax.media.j3d.Background;
import javax.media.j3d.Behavior;
import javax.media.j3d.BoundingSphere;
import javax.media.j3d.Bounds;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.GraphicsConfigTemplate3D;
import javax.media.j3d.Group;
import javax.media.j3d.Locale;
import javax.media.j3d.PhysicalBody;
import javax.media.j3d.PhysicalEnvironment;
import javax.media.j3d.PolygonAttributes;
import javax.media.j3d.Transform3D;
import javax.media.j3d.TransformGroup;
import javax.media.j3d.View;
import javax.media.j3d.ViewPlatform;
import javax.media.j3d.VirtualUniverse;
import javax.media.j3d.WakeupCriterion;
import javax.media.j3d.WakeupOnAWTEvent;
import javax.media.j3d.WakeupOr;
import javax.vecmath.Color3f;
import javax.vecmath.Matrix3d;
import javax.vecmath.Matrix4d;
import javax.vecmath.Point3d;
import javax.vecmath.Point3f;
import javax.vecmath.Vector3d;
import javax.vecmath.Vector3f;

import com.sun.j3d.audioengines.javasound.JavaSoundMixer;
import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.geometry.ColorCube;

/**
 * This example illustrates the mouse behaviors defined in the
 * org.selman.java3d.book package. These improved mouse behaviors: - handle
 * TransformGroups above the target TG properly <br>- can be applied to any
 * object, not just TGs <br>- support interface reporting to give easy feedback
 * on all manipulations <br>- better motion speed control <br>- range
 * validation to clamp scales and translation between limits <br>
 */
public class MouseNavigateTest extends Java3dApplet implements
    ScaleChangeListener, RotationChangeListener, TranslationChangeListener {
  private static int m_kWidth = 300;

  private static int m_kHeight = 400;

  // create some UI to provide feedback on all mouse
  // manipulations
  Label m_RotationLabel = null;

  TextField m_RotationFieldX = null;

  TextField m_RotationFieldY = null;

  TextField m_RotationFieldZ = null;

  Label m_TranslationLabel = null;

  TextField m_TranslationFieldX = null;

  TextField m_TranslationFieldY = null;

  TextField m_TranslationFieldZ = null;

  Label m_ScaleLabel = null;

  TextField m_ScaleFieldZ = null;

  TextField m_ScaleFieldY = null;

  TextField m_ScaleFieldX = null;

  public MouseNavigateTest() {
    initJava3d();
  }

  protected void addCanvas3D(Canvas3D c3d) {
    setLayout(new BorderLayout());
    add(c3d, BorderLayout.CENTER);

    Panel controlPanel = new Panel();

    // add the UI to the frame
    m_RotationLabel = new Label("Rotation: ");
    m_RotationFieldX = new TextField("0.00");
    m_RotationFieldY = new TextField("0.00");
    m_RotationFieldZ = new TextField("0.00");
    controlPanel.add(m_RotationLabel);
    controlPanel.add(m_RotationFieldX);
    controlPanel.add(m_RotationFieldY);
    controlPanel.add(m_RotationFieldZ);

    m_TranslationLabel = new Label("Translation: ");
    m_TranslationFieldX = new TextField("0.00");
    m_TranslationFieldY = new TextField("0.00");
    m_TranslationFieldZ = new TextField("0.00");
    controlPanel.add(m_TranslationLabel);
    controlPanel.add(m_TranslationFieldX);
    controlPanel.add(m_TranslationFieldY);
    controlPanel.add(m_TranslationFieldZ);

    m_ScaleLabel = new Label("Scale: ");
    m_ScaleFieldX = new TextField("0.00");
    m_ScaleFieldY = new TextField("0.00");
    m_ScaleFieldZ = new TextField("0.00");
    controlPanel.add(m_ScaleLabel);
    controlPanel.add(m_ScaleFieldX);
    controlPanel.add(m_ScaleFieldY);
    controlPanel.add(m_ScaleFieldZ);

    add(controlPanel, BorderLayout.SOUTH);

    doLayout();
  }

  protected double getScale() {
    return 1.0;
  }

  // do nothing for these notifications from the mouse behaviors
  public void onStartDrag(Object target) {
  }

  public void onEndDrag(Object target) {
  }

  public void onApplyTransform(Object target) {
  }

  public void onAdjustTransform(Object target, int xpos, int ypos) {
  }

  // called by TornadoMouseRotate
  // yes, those really are Euler angles for the objects rotation
  public void onRotate(Object target, Point3d point3d) {
    m_RotationFieldX.setText(String.valueOf((intjava.lang.Math
        .toDegrees(point3d.x)));
    m_RotationFieldY.setText(String.valueOf((intjava.lang.Math
        .toDegrees(point3d.y)));
    m_RotationFieldZ.setText(String.valueOf((intjava.lang.Math
        .toDegrees(point3d.z)));
  }

  // called by TornadoMouseScale
  public void onScale(Object target, Vector3d scale) {
    m_ScaleFieldX.setText(String.valueOf(scale.x));
    m_ScaleFieldY.setText(String.valueOf(scale.y));
    m_ScaleFieldZ.setText(String.valueOf(scale.z));
  }

  // called by TornadoMouseTranslate
  public void onTranslate(Object target, Vector3d vTranslation) {
    m_TranslationFieldX.setText(String.valueOf(vTranslation.x));
    m_TranslationFieldY.setText(String.valueOf(vTranslation.y));
    m_TranslationFieldZ.setText(String.valueOf(vTranslation.z));
  }

  // we want a black background
  protected Background createBackground() {
    return null;
  }

  protected BranchGroup createSceneBranchGroup() {
    BranchGroup objRoot = super.createSceneBranchGroup();

    // note that we are creating a TG *above* the TG
    // the is being controlled by the mouse behaviors.
    // The SUN mouse translate behavior would fail in this
    // instance as all movement would be in the X-Y plane
    // irrespective of any TG above the object.
    // The TornadoMouseTranslate behavior always moves an object
    // parrallel to the image plane
    TransformGroup objTrans1 = new TransformGroup();
    Transform3D t3d = new Transform3D();
    objTrans1.getTransform(t3d);
    t3d.setEuler(new Vector3d(0.90.80.3));
    objTrans1.setTransform(t3d);

    TransformGroup objTrans = new TransformGroup();
    objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
    objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);

    // create the mouse scale behavior and set limits
    TornadoMouseScale mouseScale = new TornadoMouseScale(50.1f);
    mouseScale.setMinScale(new Point3d(0.50.50.5));
    mouseScale.setMaxScale(new Point3d(222));
    mouseScale.setObject(objTrans);
    mouseScale.setChangeListener(this);
    mouseScale.setSchedulingBounds(getApplicationBounds());
    objTrans.addChild(mouseScale);

    // create the mouse rotate behavior
    TornadoMouseRotate mouseRotate = new TornadoMouseRotate(0.0010.001);
    mouseRotate.setInvert(true);
    mouseRotate.setObject(objTrans);
    mouseRotate.setChangeListener(this);
    mouseRotate.setSchedulingBounds(getApplicationBounds());
    objTrans.addChild(mouseRotate);

    // create the mouse translate behavior and set limits
    TornadoMouseTranslate mouseTrans = new TornadoMouseTranslate(0.005f);
    mouseTrans.setObject(objTrans);
    mouseTrans.setChangeListener(this);
    mouseTrans.setMinTranslate(new Point3d(-4, -4, -4));
    mouseTrans.setMaxTranslate(new Point3d(444));
    mouseTrans.setSchedulingBounds(getApplicationBounds());
    objTrans.addChild(mouseTrans);

    objTrans.addChild(new ColorCube(0.5));

    // create some axis for the world to show it has been rotated
    ColorCube axis = new ColorCube(5.0);
    Appearance app = new Appearance();
    app
        .setPolygonAttributes(new PolygonAttributes(
            PolygonAttributes.POLYGON_LINE,
            PolygonAttributes.CULL_NONE, 0));
    axis.setAppearance(app);
    objTrans1.addChild(axis);

    objTrans1.addChild(objTrans);
    objRoot.addChild(objTrans1);

    return objRoot;
  }

  public static void main(String[] args) {
    MouseNavigateTest mouseTest = new MouseNavigateTest();
    mouseTest.saveCommandLineArguments(args);

    new MainFrame(mouseTest, m_kWidth, m_kHeight);
  }
}

//*****************************************************************************
/**
 * TornadoMouseRotate
 
 * Custom mouse rotation behaviour
 
 @author Daniel Selman
 @version 1.0
 */
//*****************************************************************************

class TornadoMouseRotate extends TornadoMouseBehavior {
  protected double m_FactorX = 0.001;

  protected double m_FactorY = 0.001;

  protected Transform3D m_TransformX = null;

  protected Transform3D m_TransformY = null;

  protected boolean m_bInvert = false;

  //*****************************************************************************
  /**
   @param xf
   *            the x rotation scale factor
   @param yf
   *            the y rotation scale factor
   */
  //*****************************************************************************
  public TornadoMouseRotate(double xf, double yf) {
    m_FactorX = xf;
    m_FactorY = yf;

    m_TransformX = new Transform3D();
    m_TransformY = new Transform3D();

    m_bInvert = false;
  }

  protected boolean isStartBehaviorEvent(java.awt.event.MouseEvent evt) {
    int nId = evt.getID();
    return ((nId == MouseEvent.MOUSE_DRAGGED&& (evt.isAltDown() == false&& (evt
        .isMetaDown() == false));
  }

  //*****************************************************************************
  /**
   @param bInvert
   *            true to invert the Y axis
   */
  //*****************************************************************************
  public void setInvert(boolean bInvert) {
    m_bInvert = bInvert;
  }

  // this behavior is relative to the *screen*
  // the current rotation of the object etc. is ignored
  protected boolean isRelativeToObjectCoordinates() {
    return false;
  }

  protected void applyVectorToObject(Vector3f vector) {
    TransformGroup tg = getTransformGroup();

    if (tg != null) {
      tg.getTransform(m_Transform3D);

      double x_angle = vector.y * m_FactorX;
      double y_angle = vector.x * m_FactorY;

      m_TransformX.rotX(x_angle);
      m_TransformY.rotY(y_angle);

      Matrix4d mat = new Matrix4d();

      // Remember old matrix
      m_Transform3D.get(mat);

      // Translate to origin
      m_Transform3D.setTranslation(new Vector3d(0.00.00.0));

      if (m_bInvert != false) {
        m_Transform3D.mul(m_Transform3D, m_TransformX);
        m_Transform3D.mul(m_Transform3D, m_TransformY);
      else {
        m_Transform3D.mul(m_TransformX, m_Transform3D);
        m_Transform3D.mul(m_TransformY, m_Transform3D);
      }

      // Set old translation back
      Vector3d translation = new Vector3d(mat.m03, mat.m13, mat.m23);
      m_Transform3D.setTranslation(translation);

      // save the new Transform3D
      applyTransform();

      if (m_Listener != null) {
        Point3d rotate = Euler.getEulerRotation(m_Transform3D);
        ((RotationChangeListenerm_Listener)
            .onRotate(m_Object, rotate);
      }
    }
  }
// TornadoMouseRotate

class Euler {
  public static int EulOrdXYZs() {
    return EulOrd(X, EulParEven, EulRepNo, EulFrmS);
  }

  public static int EulOrdXYXs() {
    return EulOrd(X, EulParEven, EulRepYes, EulFrmS);
  }

  public static int EulOrdXZYs() {
    return EulOrd(X, EulParOdd, EulRepNo, EulFrmS);
  }

  public static int EulOrdXZXs() {
    return EulOrd(X, EulParOdd, EulRepYes, EulFrmS);
  }

  public static int EulOrdYZXs() {
    return EulOrd(Y, EulParEven, EulRepNo, EulFrmS);
  }

  public static int EulOrdYZYs() {
    return EulOrd(Y, EulParEven, EulRepYes, EulFrmS);
  }

  public static int EulOrdYXZs() {
    return EulOrd(Y, EulParOdd, EulRepNo, EulFrmS);
  }

  public static int EulOrdYXYs() {
    return EulOrd(Y, EulParOdd, EulRepYes, EulFrmS);
  }

  public static int EulOrdZXYs() {
    return EulOrd(Z, EulParEven, EulRepNo, EulFrmS);
  }

  public static int EulOrdZXZs() {
    return EulOrd(Z, EulParEven, EulRepYes, EulFrmS);
  }

  public static int EulOrdZYXs() {
    return EulOrd(Z, EulParOdd, EulRepNo, EulFrmS);
  }

  public static int EulOrdZYZs() {
    return EulOrd(Z, EulParOdd, EulRepYes, EulFrmS);
  }

  /* Rotating axes */
  public static int EulOrdZYXr() {
    return EulOrd(X, EulParEven, EulRepNo, EulFrmR);
  }

  public static int EulOrdXYXr() {
    return EulOrd(X, EulParEven, EulRepYes, EulFrmR);
  }

  public static int EulOrdYZXr() {
    return EulOrd(X, EulParOdd, EulRepNo, EulFrmR);
  }

  public static int EulOrdXZXr() {
    return EulOrd(X, EulParOdd, EulRepYes, EulFrmR);
  }

  public static int EulOrdXZYr() {
    return EulOrd(Y, EulParEven, EulRepNo, EulFrmR);
  }

  public static int EulOrdYZYr() {
    return EulOrd(Y, EulParEven, EulRepYes, EulFrmR);
  }

  public static int EulOrdZXYr() {
    return EulOrd(Y, EulParOdd, EulRepNo, EulFrmR);
  }

  public static int EulOrdYXYr() {
    return EulOrd(Y, EulParOdd, EulRepYes, EulFrmR);
  }

  public static int EulOrdYXZr() {
    return EulOrd(Z, EulParEven, EulRepNo, EulFrmR);
  }

  public static int EulOrdZXZr() {
    return EulOrd(Z, EulParEven, EulRepYes, EulFrmR);
  }

  public static int EulOrdXYZr() {
    return EulOrd(Z, EulParOdd, EulRepNo, EulFrmR);
  }

  public static int EulOrdZYZr() {
    return EulOrd(Z, EulParOdd, EulRepYes, EulFrmR);
  }

  public static int EulFrm(int ord) {
    // DCS, was unsigned
    return ((ord1);
  }

  public static int EulRep(int ord) {
    // DCS, was unsigned
    return (((ord>> 11);
  }

  public static int EulPar(int ord) {
    return (((ord>> 21);
  }

  public static int EulAxI(int ord) {
    // DCS, was unsigned
    return ((int) (EulSafe((((ord>> 33))));
  }

  public static int EulAxJ(int ord) {
    int i = 0;

    if (EulPar(ord== EulParOdd)
      i = 1;

    return ((int) (EulNext(EulAxI(ord+ i)));
  }

  public static int EulAxK(int ord) {
    int i = 0;

    if (EulPar(ord!= EulParOdd)
      i = 1;

    return ((int) (EulNext(EulAxI(ord+ i)));
  }

  public static int EulAxH(int ord) {
    if (EulRep(ord== EulRepNo)
      return EulAxK(ord);

    return EulAxI(ord);
  }

  public static int EulOrd(int i, int p, int r, int f) {
    return (((((((i<< 1(p)) << 1(r)) << 1(f));
  }

  // enum
  static final int X = 0;

  static final int Y = 1;

  static final int Z = 2;

  static final int W = 3;

  static final int EulRepNo = 0;

  static final int EulRepYes = 1;

  static final int EulParEven = 0;

  static final int EulParOdd = 1;

  static final int EulFrmS = 0;

  static final int EulFrmR = 1;

  static final float FLT_EPSILON = 1.192092896e-07F;

  static EulGetOrdInfo EulGetOrd(int ord) {
    EulGetOrdInfo info = new EulGetOrdInfo();

    // note, used to be unsigned!
    int o = ord;
    info.f = o & 1;
    o >>= 1;
    info.s = o & 1;
    o >>= 1;
    info.n = o & 1;
    o >>= 1;
    info.i = EulSafe(o & 3);
    info.j = EulNext(info.i + info.n);
    info.k = EulNext(info.i + - info.n);

    if (info.s != 0)
      info.h = info.k;
    else
      info.h = info.i;

    return info;
  }

  static int EulSafe(int val) {
    int[] valArray = 012};
    return valArray[val];
  }

  static int EulNext(int val) {
    int[] valArray = 120};
    return valArray[val];
  }

  // float HMatrix[4][4];

  /* Convert matrix to Euler angles (in radians). */
  public static EulerAngles Eul_FromMatrix(float[][] M, int order) {
    EulerAngles ea = new EulerAngles();

    EulGetOrdInfo info = EulGetOrd(order);

    int i = info.i;
    int j = info.j;
    int k = info.k;
    int h = info.h;
    int n = info.n;
    int s = info.s;
    int f = info.f;

    if (s == EulRepYes) {
      double sy = Math.sqrt(M[i][j* M[i][j+ M[i][k* M[i][k]);
      if (sy > 16 * FLT_EPSILON) {
        ea.x = (floatMath.atan2(M[i][j], M[i][k]);
        ea.y = (floatMath.atan2(sy, M[i][i]);
        ea.z = (floatMath.atan2(M[j][i], -M[k][i]);
      else {
        ea.x = (floatMath.atan2(-M[j][k], M[j][j]);
        ea.y = (floatMath.atan2(sy, M[i][i]);
        ea.z = 0;
      }
    else {
      double cy = Math.sqrt(M[i][i* M[i][i+ M[j][i* M[j][i]);
      if (cy > 16 * FLT_EPSILON) {
        ea.x = (floatMath.atan2(M[k][j], M[k][k]);
        ea.y = (floatMath.atan2(-M[k][i], cy);
        ea.z = (floatMath.atan2(M[j][i], M[i][i]);
      else {
        ea.x = (floatMath.atan2(-M[j][k], M[j][j]);
        ea.y = (floatMath.atan2(-M[k][i], cy);
        ea.z = 0;
      }
    }
    if (n == EulParOdd) {
      ea.x = -ea.x;
      ea.y = -ea.y;
      ea.z = -ea.z;
    }
    if (f == EulFrmR) {
      float t = ea.x;
      ea.x = ea.z;
      ea.z = t;
    }
    ea.w = order;
    return (ea);
  }

  /* Convert quaternion to Euler angles (in radians). */
  public static EulerAngles Eul_FromQuat(Quat q, int order) {
    float[][] M = new float[4][4];
    double Nq = q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
    double s = (Nq > 0.0(2.0 / Nq0.0;
    double xs = q.x * s, ys = q.y * s, zs = q.z * s;
    double wx = q.w * xs, wy = q.w * ys, wz = q.w * zs;
    double xx = q.x * xs, xy = q.x * ys, xz = q.x * zs;
    double yy = q.y * ys, yz = q.y * zs, zz = q.z * zs;
    M[X][X(float) (1.0 (yy + zz));
    M[X][Y(float) (xy - wz);
    M[X][Z(float) (xz + wy);
    M[Y][X(float) (xy + wz);
    M[Y][Y(float) (1.0 (xx + zz));
    M[Y][Z(float) (yz - wx);
    M[Z][X(float) (xz - wy);
    M[Z][Y(float) (yz + wx);
    M[Z][Z(float) (1.0 (xx + yy));
    M[W][X= M[W][Y= M[W][Z= M[X][W= M[Y][W= M[Z][W0.0f;
    M[W][W1.0f;
    return (Eul_FromMatrix(M, order));
  }

  public static Point3d getEulerRotation(Transform3D t3d) {
    Point3d Rotation = new Point3d();

    Matrix3d m1 = new Matrix3d();
    t3d.get(m1);

    // extract the rotation angles from the upper 3x3 rotation
    // component of the 4x4 transformation matrix
    Rotation.y = -java.lang.Math.asin(m1.getElement(20));
    double c = java.lang.Math.cos(Rotation.y);
    double tRx, tRy, tRz;

    if (java.lang.Math.abs(Rotation.y0.00001) {
      tRx = m1.getElement(22/ c;
      tRy = -m1.getElement(21/ c;

      Rotation.x = java.lang.Math.atan2(tRy, tRx);

      tRx = m1.getElement(00/ c;
      tRy = -m1.getElement(10/ c;

      Rotation.z = java.lang.Math.atan2(tRy, tRx);
    else {
      Rotation.x = 0.0;

      tRx = m1.getElement(11);
      tRy = m1.getElement(01);

      Rotation.z = java.lang.Math.atan2(tRy, tRx);
    }

    Rotation.x = -Rotation.x;
    Rotation.z = -Rotation.z;

    // now try to ensure that the values are positive by adding 2PI if
    // necessary...
    if (Rotation.x < 0.0)
      Rotation.x += * java.lang.Math.PI;

    if (Rotation.y < 0.0)
      Rotation.y += * java.lang.Math.PI;

    if (Rotation.z < 0.0)
      Rotation.z += * java.lang.Math.PI;

    return Rotation;
  }
}

class EulerAngles extends Quat {
  public EulerAngles() {
  }
}

class Quat
{
  public float x;
  public float y;
  public float z;
  public float w;

  public Quat( )
  {
  }
}

class EulGetOrdInfo {
  public int i;

  public int j;

  public int k;

  public int h;

  public int n;

  public int s;

  public int f;

  EulGetOrdInfo() {
  }
}

//*****************************************************************************
/**
 * Base class for the Tornado Mouse Behaviors (Rotate, Translate, Scale).
 
 @author Daniel Selman
 @version 1.0
 */
//*****************************************************************************

abstract class TornadoMouseBehavior extends Behavior {
  // private data
  protected Object m_Object = null;

  protected Point3f m_NewPos = null;

  protected Point3f m_OldPos = null;

  protected Vector3f m_TranslationVector = null;

  protected Transform3D m_Translation = null;

  protected boolean m_bDragging = false;

  protected WakeupOr m_MouseCriterion = null;

  protected int m_nLastY = 0;

  protected Transform3D m_Transform3D = null;

  protected TornadoChangeListener m_Listener = null;

  public TornadoMouseBehavior() {
    m_Object = null;
    m_NewPos = new Point3f();
    m_OldPos = new Point3f();

    m_Translation = new Transform3D();
    m_TranslationVector = new Vector3f();
    m_bDragging = false;

    m_Transform3D = new Transform3D();
  }

  //*****************************************************************************
  /**
   * Register a listener for the behavior.
   
   @param listener
   *            the listener to add or null to remove the listener
   */
  //*****************************************************************************
  public void setChangeListener(TornadoChangeListener listener) {
    m_Listener = listener;
  }

  //*****************************************************************************
  /**
   * Apply a delta vector (in the object's local coordinates) to the object.
   */
  //*****************************************************************************
  protected abstract void applyVectorToObject(Vector3f v);

  //*****************************************************************************
  /**
   @return true is this the mouse event that starts the tracking behaviour
   */
  //*****************************************************************************
  protected abstract boolean isStartBehaviorEvent(
      java.awt.event.MouseEvent evt);

  //*****************************************************************************
  /**
   * Dispatches mouse events as appropriate. Should not need to overide this
   * method.
   */
  //*****************************************************************************
  protected void processMouseEvent(java.awt.event.MouseEvent evt) {
    if (m_Object != null) {
      if (isStartBehaviorEvent(evt!= false)
        adjustTransform(evt.getX(), evt.getY());

      else if (isStopBehaviorEvent(evt!= false)
        onEndDrag();
    }
  }

  //*****************************************************************************
  /**
   @return true if this is the event that stops drag tracking behviour the
   *         default uses MOUSE_RELEASED.
   */
  //*****************************************************************************
  protected boolean isStopBehaviorEvent(java.awt.event.MouseEvent evt) {
    int nId = evt.getID();
    return (m_bDragging != false && nId == MouseEvent.MOUSE_RELEASED || nId == MouseEvent.MOUSE_EXITED);
  }

  //*****************************************************************************
  /**
   @return true if this behaviours change vector is relative to the starting
   *         mouse click. The default is a behaviour that generates delta
   *         change vectors as the user moves the mouse.
   */
  //*****************************************************************************
  protected boolean isRelativeToStartDrag() {
    return false;
  }

  //*****************************************************************************
  /**
   @return true if the mouse coordinates should be converted to local object
   *         coordinates before being processed by applyVectorToObject
   */
  //*****************************************************************************
  protected boolean isRelativeToObjectCoordinates() {
    return true;
  }

  //*****************************************************************************
  /**
   * Allows custom start drag processing. Default does nothing.
   */
  //*****************************************************************************
  protected void onStartDrag() {
    if (m_Listener != null)
      m_Listener.onStartDrag(m_Object);
  }

  //*****************************************************************************
  /**
   * Allows custom end drag processing. ** Call this base class! **
   */
  //*****************************************************************************
  protected void onEndDrag() {
    m_bDragging = false;

    if (m_Listener != null)
      m_Listener.onEndDrag(m_Object);
  }

  //*****************************************************************************
  /**
   * Gets the Transform3D to convert from the Objects coordinate system to the
   * world coordinate system.
   
   @param t3d
   *            the Transform3D to populate
   */
  //*****************************************************************************
  protected void getObjectLocalToVworld(Transform3D t3d) {
    if (getTransformGroup() != null)
      getTransformGroup().getLocalToVworld(t3d);
  }

  //*****************************************************************************
  /**
   * Gets the Transform3D to convert from the Image plate coordinate system to
   * the world coordinate system.
   
   @param t3d
   *            the Transform3D to populate
   */
  //*****************************************************************************
  protected void getImagePlateToVworld(Transform3D t3d) {
    getView().getCanvas3D(0).getImagePlateToVworld(t3d);
  }

  //*****************************************************************************
  /**
   @return the TransformGroup if a TG Object is associated with the behavior
   *         or null otherwise.
   */
  //*****************************************************************************
  protected TransformGroup getTransformGroup() {
    if (m_Object instanceof TransformGroup)
      return (TransformGroupm_Object;

    return null;
  }

  //*****************************************************************************
  /**
   * Saves the behaviors Transform3D into its TransformGroup (if present).
   * Catches any exceptions (bad transform) that might be thrown.
   */
  //*****************************************************************************
  protected void applyTransform() {
    TransformGroup tg = getTransformGroup();

    if (tg != null) {
      try {
        // save the new Transform3D
        tg.setTransform(m_Transform3D);

        if (m_Listener != null)
          m_Listener.onApplyTransform(m_Object);
      catch (Exception e) {
        System.err.println(e.toString());
      }
    }
  }

  //*****************************************************************************
  /**
   * Transforms the x,y mouse coordinates to coordinates relative to the
   * object. Calculates a "delta vector" in object coordinates and calls
   * ApplyVectorToObject().
   
   * Thanks to: A.R. van Ballegooy. Simon McMullen [simonmc@mincom.com]
   */
  //*****************************************************************************
  protected void adjustTransform(int xpos, int ypos) {
    if (m_Listener != null)
      m_Listener.onAdjustTransform(m_Object, xpos, ypos);

    if (m_bDragging == false) {
      // initialise the starting position
      m_OldPos.x = xpos;
      m_OldPos.y = ypos;
      m_OldPos.z = 0.0f;
      m_nLastY = ypos;

      onStartDrag();
    }

    m_bDragging = true;

    // save the current position and invert the tracking in the Y direction
    // (positive upwards)
    m_NewPos.x = xpos;
    m_NewPos.y = m_nLastY + (m_nLastY - ypos);
    m_NewPos.z = 0.0f;
    m_nLastY = ypos;

    // transform points to Virtual World Coordinates
    getImagePlateToVworld(m_Translation);

    if (isRelativeToStartDrag() == false)
      m_Translation.transform(m_OldPos);

    m_Translation.transform(m_NewPos);

    // transform coordinates to Object Space Coordinates
    // Make sure capability ALLOW_LOCAL_TO_VWORLD_READ is set....

    if (isRelativeToObjectCoordinates() != false) {
      getObjectLocalToVworld(m_Translation);
      m_Translation.transpose();

      // transform points to local coordinate system
      if (isRelativeToStartDrag() == false)
        m_Translation.transform(m_OldPos);

      m_Translation.transform(m_NewPos);
    }

    // Calculate change and scale
    m_TranslationVector.sub(m_NewPos, m_OldPos);

    applyVectorToObject(m_TranslationVector);

    if (isRelativeToStartDrag() == false) {
      // store the new positions
      m_OldPos.x = xpos;
      m_OldPos.y = ypos;
      m_OldPos.z = 0.0f;
    }
  }

  //*****************************************************************************
  /**
   * Dispatches events based on the behaviours criteria
   */
  //*****************************************************************************
  public void processStimulus(Enumeration criteria) {
    WakeupCriterion wakeup;
    AWTEvent[] event;
    int id;
    int dx, dy;

    if (m_Object != null) {
      while (criteria.hasMoreElements()) {
        wakeup = (WakeupCriterioncriteria.nextElement();

        if (wakeup instanceof WakeupOnAWTEvent) {
          event = ((WakeupOnAWTEventwakeup).getAWTEvent();

          for (int i = 0; i < event.length; i++) {
            processMouseEvent((MouseEventevent[i]);
          }
        }
      }
    }

    // tell the behaviour when to wake up again...
    wakeupOn(m_MouseCriterion);
  }

  //*****************************************************************************
  /**
   * Registers which AWT events are of interest to the behaviour
   */
  //*****************************************************************************
  public void initialize() {
    WakeupCriterion[] mouseEvents = new WakeupCriterion[3];

    mouseEvents[0new WakeupOnAWTEvent(MouseEvent.MOUSE_DRAGGED);
    mouseEvents[1new WakeupOnAWTEvent(MouseEvent.MOUSE_PRESSED);
    mouseEvents[2new WakeupOnAWTEvent(MouseEvent.MOUSE_RELEASED);

    m_MouseCriterion = new WakeupOr(mouseEvents);
    wakeupOn(m_MouseCriterion);
  }

  //*****************************************************************************
  /**
   * void setObject( Object obj )
   
   @param obj
   *            the Objectto manipulate. A null object disables the behaviour.
   */
  //*****************************************************************************
  public void setObject(Object obj) {
    m_Object = obj;
  }

// TornadoMouseBehavior

//*****************************************************************************
/**
 * TornadoMouseScale
 
 * Custon scaling behaviour
 
 @author Daniel Selman
 @version 1.0
 */
//*****************************************************************************

class TornadoMouseScale extends TornadoMouseBehavior {
  // private data
  protected float m_Delta = 0;

  protected float m_Threshold = 0;

  protected Point3d m_MinScale;

  protected Point3d m_MaxScale;

  //*****************************************************************************
  /**
   @param threshold
   *            the amount the mouse must be moved before an object is moved
   @param delta
   *            the step size to use for object scaling bigger = faster
   *            scaling.
   
   * Default minimum scale: 0.1,0.1,0.1 Default maximum scale: 5,5,5
   */
  //*****************************************************************************
  public TornadoMouseScale(float threshold, float delta) {
    m_Delta = delta;
    m_Threshold = threshold;

    m_MinScale = new Point3d(0.10.10.1);
    m_MaxScale = new Point3d(555);
  }

  //*****************************************************************************
  /**
   @param minScale
   *            the minimum x,y,z scale
   */
  //*****************************************************************************
  public void setMinScale(Point3d minScale) {
    m_MinScale = minScale;
  }

  //*****************************************************************************
  /**
   @param maxScale
   *            the maximum x,y,z scale
   */
  //*****************************************************************************
  public void setMaxScale(Point3d maxScale) {
    m_MaxScale = maxScale;
  }

  // this behavior is relative to the *screen*
  // the current rotation of the object etc. is ignored
  protected boolean isRelativeToObjectCoordinates() {
    return true;
  }

  protected boolean isStartBehaviorEvent(java.awt.event.MouseEvent evt) {
    int nId = evt.getID();
    return ((nId == MouseEvent.MOUSE_DRAGGED&& (evt.isAltDown() != false&& (evt
        .isMetaDown() == false));
  }

  protected void applyVectorToObject(Vector3f vector) {
    TransformGroup tg = getTransformGroup();

    if (tg != null) {
      tg.getTransform(m_Transform3D);

      Vector3d vScale = new Vector3d();
      m_Transform3D.getScale(vScale);

      Vector3f delta = new Vector3f();

      if (vector.x > m_Threshold)
        delta.x = m_Delta;
      else if (vector.x < -m_Threshold)
        delta.x = -m_Delta;

      if (vector.y > m_Threshold)
        delta.y = m_Delta;
      else if (vector.y < -m_Threshold)
        delta.y = -m_Delta;

      if (vector.z > m_Threshold)
        delta.z = m_Delta;
      else if (vector.z < -m_Threshold)
        delta.z = -m_Delta;

      Vector3d objectScale = new Vector3d(vScale.x + delta.x, vScale.y
          + delta.y, vScale.z + delta.z);

      if (objectScale.x >= m_MinScale.x && objectScale.y >= m_MinScale.y
          && objectScale.z >= m_MinScale.z) {
        if (objectScale.x <= m_MaxScale.x
            && objectScale.y <= m_MaxScale.y
            && objectScale.z <= m_MaxScale.z) {
          m_Transform3D.setScale(objectScale);

          // save the new Transform3D
          applyTransform();

          if (m_Listener != null)
            ((ScaleChangeListenerm_Listener).onScale(m_Object,
                objectScale);
        }
      }
    }
  }
// TornadoMouseScale

//*****************************************************************************
/**
 * TornadoMouseTranslate
 
 * Custom translation behavior.
 
 @author Daniel Selman
 @version 1.0
 */
//*****************************************************************************

class TornadoMouseTranslate extends TornadoMouseBehavior {
  // private data
  private float m_Scale = 1;

  protected Point3d m_MinTranslate = null;

  protected Point3d m_MaxTranslate = null;

  // protected data

  // public data

  //*****************************************************************************
  /**
   @param scale
   *            the translation scale factor (bigger = faster)
   
   * Default minimum translation: -10,-10,-10 Default maximum translation:
   * 10,10,10
   */
  //*****************************************************************************
  public TornadoMouseTranslate(float scale) {
    m_Scale = scale;

    m_MinTranslate = new Point3d(-10, -10, -10);
    m_MaxTranslate = new Point3d(101010);
  }

  //*****************************************************************************
  /**
   @param minTrans
   *            the minimum x,y,z translation
   */
  //*****************************************************************************
  public void setMinTranslate(Point3d minTrans) {
    m_MinTranslate = minTrans;
  }

  //*****************************************************************************
  /**
   @param maxTrans
   *            the maximum x,y,z translation
   */
  //*****************************************************************************
  public void setMaxTranslate(Point3d maxTrans) {
    m_MaxTranslate = maxTrans;
  }

  protected boolean isStartBehaviorEvent(java.awt.event.MouseEvent evt) {
    int nId = evt.getID();
    return ((nId == MouseEvent.MOUSE_DRAGGED&& (evt.isAltDown() == false&& (evt
        .isMetaDown() != false));
  }

  protected void applyVectorToObject(Vector3f vector) {
    TransformGroup tg = getTransformGroup();

    if (tg != null) {
      // scale the mouse movements so the objects roughly tracks with the
      // mouse
      vector.scale(m_Scale);

      Vector3d vTranslation = new Vector3d();
      tg.getTransform(m_Transform3D);
      m_Transform3D.get(vTranslation);

      vTranslation.x += vector.x;
      vTranslation.y += vector.y;
      vTranslation.z += vector.z;

      if (vTranslation.x >= m_MinTranslate.x
          && vTranslation.y >= m_MinTranslate.y
          && vTranslation.z >= m_MinTranslate.z) {
        if (vTranslation.x <= m_MaxTranslate.x
            && vTranslation.y <= m_MaxTranslate.y
            && vTranslation.z <= m_MaxTranslate.z) {
          m_Transform3D.setTranslation(vTranslation);
          applyTransform();

          if (m_Listener != null)
            ((TranslationChangeListenerm_Listener).onTranslate(
                m_Object, vTranslation);
        }
      }
    }
  }
// TornadoMouseTranslate

//*****************************************************************************
/**
 * Interface to listen for changes in translation from the TornadoMouseScale
 * class.
 
 @author Daniel Selman
 @version 1.0
 */
//*****************************************************************************

abstract interface ScaleChangeListener extends TornadoChangeListener {
  //*****************************************************************************
  /**
   * Callback to notify of new scale being applied.
   
   @param target
   *            the Object being manipulated
   @param scale
   *            the new scale being applied
   */
  //*****************************************************************************
  public void onScale(Object target, Vector3d scale);
}

//*****************************************************************************
/**
 * Interface to listen for changes in translation from the TornadoMouseTranslate
 * class.
 
 @author Daniel Selman
 @version 1.0
 */
//*****************************************************************************

abstract interface TranslationChangeListener extends TornadoChangeListener {
  //*****************************************************************************
  /**
   * Callback to notify of new translationg being applied.
   
   @param target
   *            the Object being manipulated
   @param vTranslation
   *            the new translation being applied
   */
  //*****************************************************************************
  public void onTranslate(Object target, Vector3d vTranslation);
}

//*****************************************************************************
/**
 * Interface to listen for changes in rotation from the TornadoMouseRotate
 * class.
 
 @author Daniel Selman
 @version 1.0
 */
//*****************************************************************************

abstract interface RotationChangeListener extends TornadoChangeListener {
  //*****************************************************************************
  /**
   * Callback to notify of new translationg being applied.
   
   @param target
   *            the Object being manipulated
   @param point3d
   *            the new rotation (Euler, radians) applied
   */
  //*****************************************************************************
  public void onRotate(Object target, Point3d point3d);
}

//*****************************************************************************
/**
 * Interface to listen for changes affected by in the TornadoMouseBehaviors.
 
 @author Daniel Selman
 @version 1.0
 */
//*****************************************************************************

abstract interface TornadoChangeListener {
  //*****************************************************************************
  /**
   * Callback to notify of a start drag event.
   
   @param target
   *            the Object being manipulated
   */
  //*****************************************************************************
  public void onStartDrag(Object target);

  //*****************************************************************************
  /**
   * Callback to notify of an end drag event.
   
   @param target
   *            the Object being manipulated
   */
  //*****************************************************************************
  public void onEndDrag(Object target);

  //*****************************************************************************
  /**
   * Notification that the Transform is being updated
   
   @param target
   *            the Object being manipulated
   */
  //*****************************************************************************
  public void onApplyTransform(Object target);

  //*****************************************************************************
  /**
   * Notification that a new Transform is being calculated
   
   @param target
   *            the Object being manipulated
   @param xpos
   *            the mouse x position
   @param ypos
   *            the mouse y position
   */
  //*****************************************************************************
  public void onAdjustTransform(Object target, int xpos, int ypos);
}

/*******************************************************************************
 * Copyright (C) 2001 Daniel Selman
 
 * First distributed with the book "Java 3D Programming" by Daniel Selman and
 * published by Manning Publications. http://manning.com/selman
 
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation, version 2.
 
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 
 * The license can be found on the WWW at: http://www.fsf.org/copyleft/gpl.html
 
 * Or by writing to: Free Software Foundation, Inc., 59 Temple Place - Suite
 * 330, Boston, MA 02111-1307, USA.
 
 * Authors can be contacted at: Daniel Selman: daniel@selman.org
 
 * If you make changes you think others would like, please contact one of the
 * authors or someone at the www.j3d.org web site.
 ******************************************************************************/

//*****************************************************************************
/**
 * Java3dApplet
 
 * Base class for defining a Java 3D applet. Contains some useful methods for
 * defining views and scenegraphs etc.
 
 @author Daniel Selman
 @version 1.0
 */
//*****************************************************************************

abstract class Java3dApplet extends Applet {
  public static int m_kWidth = 300;

  public static int m_kHeight = 300;

  protected String[] m_szCommandLineArray = null;

  protected VirtualUniverse m_Universe = null;

  protected BranchGroup m_SceneBranchGroup = null;

  protected Bounds m_ApplicationBounds = null;

  //  protected com.tornadolabs.j3dtree.Java3dTree m_Java3dTree = null;

  public Java3dApplet() {
  }

  public boolean isApplet() {
    try {
      System.getProperty("user.dir");
      System.out.println("Running as Application.");
      return false;
    catch (Exception e) {
    }

    System.out.println("Running as Applet.");
    return true;
  }

  public URL getWorkingDirectory() throws java.net.MalformedURLException {
    URL url = null;

    try {
      File file = new File(System.getProperty("user.dir"));
      System.out.println("Running as Application:");
      System.out.println("   " + file.toURL());
      return file.toURL();
    catch (Exception e) {
    }

    System.out.println("Running as Applet:");
    System.out.println("   " + getCodeBase());

    return getCodeBase();
  }

  public VirtualUniverse getVirtualUniverse() {
    return m_Universe;
  }

  //public com.tornadolabs.j3dtree.Java3dTree getJ3dTree() {
  //return m_Java3dTree;
  //  }

  public Locale getFirstLocale() {
    java.util.Enumeration e = m_Universe.getAllLocales();

    if (e.hasMoreElements() != false)
      return (Localee.nextElement();

    return null;
  }

  protected Bounds getApplicationBounds() {
    if (m_ApplicationBounds == null)
      m_ApplicationBounds = createApplicationBounds();

    return m_ApplicationBounds;
  }

  protected Bounds createApplicationBounds() {
    m_ApplicationBounds = new BoundingSphere(new Point3d(0.00.00.0),
        100.0);
    return m_ApplicationBounds;
  }

  protected Background createBackground() {
    Background back = new Background(new Color3f(0.9f0.9f0.9f));
    back.setApplicationBounds(createApplicationBounds());
    return back;
  }

  public void initJava3d() {
    //  m_Java3dTree = new com.tornadolabs.j3dtree.Java3dTree();
    m_Universe = createVirtualUniverse();

    Locale locale = createLocale(m_Universe);

    BranchGroup sceneBranchGroup = createSceneBranchGroup();

    ViewPlatform vp = createViewPlatform();
    BranchGroup viewBranchGroup = createViewBranchGroup(
        getViewTransformGroupArray(), vp);

    createView(vp);

    Background background = createBackground();

    if (background != null)
      sceneBranchGroup.addChild(background);

    //    m_Java3dTree.recursiveApplyCapability(sceneBranchGroup);
    //  m_Java3dTree.recursiveApplyCapability(viewBranchGroup);

    locale.addBranchGraph(sceneBranchGroup);
    addViewBranchGroup(locale, viewBranchGroup);

    onDoneInit();
  }

  protected void onDoneInit() {
    //  m_Java3dTree.updateNodes(m_Universe);
  }

  protected double getScale() {
    return 1.0;
  }

  public TransformGroup[] getViewTransformGroupArray() {
    TransformGroup[] tgArray = new TransformGroup[1];
    tgArray[0new TransformGroup();

    // move the camera BACK a little...
    // note that we have to invert the matrix as
    // we are moving the viewer
    Transform3D t3d = new Transform3D();
    t3d.setScale(getScale());
    t3d.setTranslation(new Vector3d(0.00.0, -20.0));
    t3d.invert();
    tgArray[0].setTransform(t3d);

    return tgArray;
  }

  protected void addViewBranchGroup(Locale locale, BranchGroup bg) {
    locale.addBranchGraph(bg);
  }

  protected Locale createLocale(VirtualUniverse u) {
    return new Locale(u);
  }

  protected BranchGroup createSceneBranchGroup() {
    m_SceneBranchGroup = new BranchGroup();
    return m_SceneBranchGroup;
  }

  protected View createView(ViewPlatform vp) {
    View view = new View();

    PhysicalBody pb = createPhysicalBody();
    PhysicalEnvironment pe = createPhysicalEnvironment();

    AudioDevice audioDevice = createAudioDevice(pe);

    if (audioDevice != null) {
      pe.setAudioDevice(audioDevice);
      audioDevice.initialize();
    }

    view.setPhysicalEnvironment(pe);
    view.setPhysicalBody(pb);

    if (vp != null)
      view.attachViewPlatform(vp);

    view.setBackClipDistance(getBackClipDistance());
    view.setFrontClipDistance(getFrontClipDistance());

    Canvas3D c3d = createCanvas3D();
    view.addCanvas3D(c3d);
    addCanvas3D(c3d);

    return view;
  }

  protected PhysicalBody createPhysicalBody() {
    return new PhysicalBody();
  }

  protected AudioDevice createAudioDevice(PhysicalEnvironment pe) {
    JavaSoundMixer javaSoundMixer = new JavaSoundMixer(pe);

    if (javaSoundMixer == null)
      System.out.println("create of audiodevice failed");

    return javaSoundMixer;
  }

  protected PhysicalEnvironment createPhysicalEnvironment() {
    return new PhysicalEnvironment();
  }

  protected float getViewPlatformActivationRadius() {
    return 100;
  }

  protected ViewPlatform createViewPlatform() {
    ViewPlatform vp = new ViewPlatform();
    vp.setViewAttachPolicy(View.RELATIVE_TO_FIELD_OF_VIEW);
    vp.setActivationRadius(getViewPlatformActivationRadius());

    return vp;
  }

  protected Canvas3D createCanvas3D() {
    GraphicsConfigTemplate3D gc3D = new GraphicsConfigTemplate3D();
    gc3D.setSceneAntialiasing(GraphicsConfigTemplate.PREFERRED);
    GraphicsDevice gd[] = GraphicsEnvironment.getLocalGraphicsEnvironment()
        .getScreenDevices();

    Canvas3D c3d = new Canvas3D(gd[0].getBestConfiguration(gc3D));
    c3d.setSize(getCanvas3dWidth(c3d), getCanvas3dHeight(c3d));

    return c3d;
  }

  protected int getCanvas3dWidth(Canvas3D c3d) {
    return m_kWidth;
  }

  protected int getCanvas3dHeight(Canvas3D c3d) {
    return m_kHeight;
  }

  protected double getBackClipDistance() {
    return 100.0;
  }

  protected double getFrontClipDistance() {
    return 1.0;
  }

  protected BranchGroup createViewBranchGroup(TransformGroup[] tgArray,
      ViewPlatform vp) {
    BranchGroup vpBranchGroup = new BranchGroup();

    if (tgArray != null && tgArray.length > 0) {
      Group parentGroup = vpBranchGroup;
      TransformGroup curTg = null;

      for (int n = 0; n < tgArray.length; n++) {
        curTg = tgArray[n];
        parentGroup.addChild(curTg);
        parentGroup = curTg;
      }

      tgArray[tgArray.length - 1].addChild(vp);
    else
      vpBranchGroup.addChild(vp);

    return vpBranchGroup;
  }

  protected void addCanvas3D(Canvas3D c3d) {
    setLayout(new BorderLayout());
    add(c3d, BorderLayout.CENTER);
    doLayout();
  }

  protected VirtualUniverse createVirtualUniverse() {
    return new VirtualUniverse();
  }

  protected void saveCommandLineArguments(String[] szArgs) {
    m_szCommandLineArray = szArgs;
  }

  protected String[] getCommandLineArguments() {
    return m_szCommandLineArray;
  }
}



           
       
Related examples in the same category
1. Navigation around the sceneNavigation around the scene
2. This is our first simple program that creates a cubeThis is our first simple program that creates a cube
3. Class Drag
4. Picking utilities on various GeometryArray subclasses and Morph objectPicking utilities on various GeometryArray subclasses and Morph object
5. Oriented TestOriented Test
6. Oriented Pt TestOriented Pt Test
7. Demonstrate the use of the mouse utility classesDemonstrate the use of the mouse utility classes
8. This application demonstrates the use of a billboard nodeThis application demonstrates the use of a billboard node
9. MouseBehaviorApp renders a single, interactively rotatable,translatable, and zoomable ColorCube objectMouseBehaviorApp renders a single, interactively rotatable,translatable, and zoomable ColorCube object
10. MouseRotate2App renders a single, interactively rotatable cubeMouseRotate2App renders a single, interactively rotatable cube
11. MouseNavigatorApp renders a single, interactively rotatable, traslatable, and zoomable ColorCube objectMouseNavigatorApp renders a single, interactively rotatable, traslatable, and zoomable ColorCube object
12. KeyNavigatorApp renders a simple landscapeKeyNavigatorApp renders a simple landscape
13. Rotate when any key is pressedRotate when any key is pressed
14. PickCallbackApp renders two interactively rotatable cubesPickCallbackApp renders two interactively rotatable cubes
15. MouseRotateApp renders a single, interactively rotatable cubeMouseRotateApp renders a single, interactively rotatable cube
16. MousePickApp renders two interactively rotatable cubesMousePickApp renders two interactively rotatable cubes
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.