publish

Cube_Demo/META-INF/MANIFEST.MF

@@ -0,0 +1,8 @@
+Manifest-Version: 1.0
+Ant-Version: Apache Ant 1.9.7
+Created-By: 1.8.0_172-b11 (Oracle Corporation)
+Class-Path: lib/SC_DLL_Wrapper.jar lib/jogamp-fat.jar lib/j3dcore.jar 
+ lib/j3dutils.jar lib/vecmath.jar
+X-COMMENT: Main-Class will be added automatically by build
+Main-Class: cube_demo.CubeApp
+

Cube_Demo/cube_demo/Axes.java

@@ -0,0 +1,36 @@
+package cube_demo;
+
+import javax.media.j3d.BranchGroup;
+import javax.media.j3d.Node;
+import javax.media.j3d.Transform3D;
+import javax.media.j3d.TransformGroup;
+import javax.vecmath.Vector3d;
+
+class Axes {
+  private BranchGroup mBrGrp = new BranchGroup();
+  
+  public BranchGroup getBrGrp() {
+    return this.mBrGrp;
+  }
+  
+  public Axes(double paramDouble1, double paramDouble2, double paramDouble3) {
+    Axis axis1 = new Axis(0);
+    Axis axis2 = new Axis(1);
+    Axis axis3 = new Axis(2);
+    Vector3d vector3d = new Vector3d(paramDouble1, paramDouble2, paramDouble3);
+    Transform3D transform3D = new Transform3D();
+    TransformGroup transformGroup = new TransformGroup();
+    transformGroup.addChild((Node)axis1.getBrGrp());
+    transformGroup.addChild((Node)axis2.getBrGrp());
+    transformGroup.addChild((Node)axis3.getBrGrp());
+    this.mBrGrp.addChild((Node)transformGroup);
+    transform3D.setTranslation(vector3d);
+    transformGroup.setTransform(transform3D);
+  }
+}
+
+
+/* Location:              /opt/SpaceControl/Cube_Demo.jar!/cube_demo/Axes.class
+ * Java compiler version: 8 (52.0)
+ * JD-Core Version:       1.2.1
+ */

Cube_Demo/cube_demo/Axis.java

@@ -0,0 +1,99 @@
+package cube_demo;
+
+import com.sun.j3d.utils.geometry.Cone;
+import com.sun.j3d.utils.geometry.Cylinder;
+import java.awt.Font;
+import javax.media.j3d.Appearance;
+import javax.media.j3d.BranchGroup;
+import javax.media.j3d.Font3D;
+import javax.media.j3d.FontExtrusion;
+import javax.media.j3d.Geometry;
+import javax.media.j3d.Material;
+import javax.media.j3d.Node;
+import javax.media.j3d.Shape3D;
+import javax.media.j3d.Text3D;
+import javax.media.j3d.Transform3D;
+import javax.media.j3d.TransformGroup;
+import javax.vecmath.Vector3d;
+
+class Axis {
+  private BranchGroup mBrGrp = new BranchGroup();
+  
+  public BranchGroup getBrGrp() {
+    return this.mBrGrp;
+  }
+  
+  public Axis(int paramInt) {
+    float f = 0.05F;
+    Cylinder cylinder = new Cylinder(f, 1.0F);
+    Cone cone = new Cone(f * 2.0F, f * 3.0F);
+    TransformGroup transformGroup1 = new TransformGroup();
+    TransformGroup transformGroup2 = new TransformGroup();
+    TransformGroup transformGroup3 = new TransformGroup();
+    TransformGroup transformGroup4 = new TransformGroup();
+    Vector3d vector3d = new Vector3d();
+    Transform3D transform3D1 = new Transform3D();
+    Transform3D transform3D2 = new Transform3D();
+    Transform3D transform3D3 = new Transform3D();
+    Transform3D transform3D4 = new Transform3D();
+    Transform3D transform3D5 = new Transform3D();
+    Material material1 = new Material();
+    Material material2 = new Material();
+    Appearance appearance1 = new Appearance();
+    Appearance appearance2 = new Appearance();
+    Font3D font3D = new Font3D(new Font("Helvetica", 0, 10), new FontExtrusion());
+    Text3D text3D = new Text3D(font3D);
+    Shape3D shape3D = new Shape3D((Geometry)text3D);
+    transformGroup1.addChild((Node)cylinder);
+    transformGroup2.addChild((Node)cone);
+    transformGroup4.addChild((Node)shape3D);
+    transformGroup3.addChild((Node)transformGroup1);
+    transformGroup3.addChild((Node)transformGroup2);
+    transformGroup3.addChild((Node)transformGroup4);
+    this.mBrGrp.addChild((Node)transformGroup3);
+    vector3d.set(0.0D, 0.5D, 0.0D);
+    transform3D1.setTranslation(vector3d);
+    transformGroup1.setTransform(transform3D1);
+    vector3d.set(0.0D, 1.0D, 0.0D);
+    transform3D2.setTranslation(vector3d);
+    transformGroup2.setTransform(transform3D2);
+    transform3D5.setIdentity();
+    switch (paramInt) {
+      case 0:
+        transform3D4.rotZ(-1.5707963267948966D);
+        transform3D5.rotZ(1.5707963267948966D);
+        text3D.setString("x");
+        break;
+      case 1:
+        text3D.setString("y");
+        break;
+      case 2:
+        transform3D4.rotX(1.5707963267948966D);
+        transform3D5.rotX(-1.5707963267948966D);
+        text3D.setString("z");
+        break;
+    } 
+    transform3D3.mul(transform3D5);
+    transform3D3.setScale(0.05D);
+    vector3d.set(-0.3D, 1.3D, 0.0D);
+    transform3D3.setTranslation(vector3d);
+    transformGroup4.setTransform(transform3D3);
+    transformGroup3.setTransform(transform3D4);
+    material1.setDiffuseColor(1.0F, 1.0F, 0.0F);
+    material1.setShininess(128.0F);
+    appearance1.setMaterial(material1);
+    cylinder.setAppearance(appearance1);
+    material2.setDiffuseColor(1.0F, 1.0F, 0.0F);
+    material2.setShininess(128.0F);
+    appearance2.setMaterial(material1);
+    cone.setAppearance(appearance2);
+    shape3D.setAppearance(appearance1);
+    this.mBrGrp.compile();
+  }
+}
+
+
+/* Location:              /opt/SpaceControl/Cube_Demo.jar!/cube_demo/Axis.class
+ * Java compiler version: 8 (52.0)
+ * JD-Core Version:       1.2.1
+ */

Cube_Demo/cube_demo/ColoredCube.java

@@ -0,0 +1,104 @@
+package cube_demo;
+
+import javax.media.j3d.BranchGroup;
+import javax.media.j3d.Node;
+import javax.media.j3d.Transform3D;
+import javax.media.j3d.TransformGroup;
+import javax.vecmath.Vector3d;
+
+class ColoredCube {
+  private BranchGroup mBrGrp = new BranchGroup();
+  
+  public BranchGroup getBrGrp() {
+    return this.mBrGrp;
+  }
+  
+  public ColoredCube(double paramDouble, boolean paramBoolean) {
+    CubeSide cubeSide1 = new CubeSide(1);
+    CubeSide cubeSide2 = new CubeSide(2);
+    CubeSide cubeSide3 = new CubeSide(3);
+    CubeSide cubeSide4 = new CubeSide(4);
+    CubeSide cubeSide5 = new CubeSide(5);
+    CubeSide cubeSide6 = new CubeSide(6);
+    Transform3D transform3D1 = new Transform3D();
+    Transform3D transform3D2 = new Transform3D();
+    TransformGroup transformGroup1 = new TransformGroup();
+    TransformGroup transformGroup2 = new TransformGroup();
+    TransformGroup transformGroup3 = new TransformGroup();
+    TransformGroup transformGroup4 = new TransformGroup();
+    TransformGroup transformGroup5 = new TransformGroup();
+    TransformGroup transformGroup6 = new TransformGroup();
+    TransformGroup transformGroup7 = new TransformGroup();
+    Vector3d vector3d = new Vector3d();
+    transformGroup1.addChild((Node)cubeSide1);
+    transformGroup2.addChild((Node)cubeSide2);
+    transformGroup3.addChild((Node)cubeSide3);
+    transformGroup4.addChild((Node)cubeSide4);
+    transformGroup5.addChild((Node)cubeSide5);
+    transformGroup6.addChild((Node)cubeSide6);
+    this.mBrGrp.addChild((Node)transformGroup1);
+    this.mBrGrp.addChild((Node)transformGroup2);
+    this.mBrGrp.addChild((Node)transformGroup3);
+    this.mBrGrp.addChild((Node)transformGroup4);
+    this.mBrGrp.addChild((Node)transformGroup5);
+    this.mBrGrp.addChild((Node)transformGroup6);
+    vector3d.set(0.0D, 0.0D, paramDouble);
+    transform3D1.setScale(paramDouble);
+    transform3D1.setTranslation(vector3d);
+    transformGroup1.setTransform(transform3D1);
+    if (paramBoolean) {
+      transform3D2.rotX(1.5707963267948966D);
+      transform3D1.rotY(1.5707963267948966D);
+      transform3D2.mul(transform3D1);
+      transform3D2.setScale(paramDouble);
+      vector3d.set(paramDouble, 0.0D, 0.0D);
+      transform3D2.setTranslation(vector3d);
+      transformGroup2.setTransform(transform3D2);
+      transform3D2.rotY(1.5707963267948966D);
+      transform3D1.rotX(-1.5707963267948966D);
+      transform3D2.mul(transform3D1);
+      transform3D2.setScale(paramDouble);
+      vector3d.set(0.0D, paramDouble, 0.0D);
+      transform3D2.setTranslation(vector3d);
+      transformGroup3.setTransform(transform3D2);
+      transform3D1.rotX(1.5707963267948966D);
+      transform3D1.setScale(paramDouble);
+      vector3d.set(0.0D, -paramDouble, 0.0D);
+      transform3D1.setTranslation(vector3d);
+      transformGroup4.setTransform(transform3D1);
+    } else {
+      transform3D1.rotY(1.5707963267948966D);
+      transform3D1.setScale(paramDouble);
+      vector3d.set(paramDouble, 0.0D, 0.0D);
+      transform3D1.setTranslation(vector3d);
+      transformGroup2.setTransform(transform3D1);
+      transform3D1.rotX(1.5707963267948966D);
+      transform3D1.setScale(paramDouble);
+      vector3d.set(0.0D, -paramDouble, 0.0D);
+      transform3D1.setTranslation(vector3d);
+      transformGroup3.setTransform(transform3D1);
+      transform3D1.rotX(-1.5707963267948966D);
+      transform3D1.setScale(paramDouble);
+      vector3d.set(0.0D, paramDouble, 0.0D);
+      transform3D1.setTranslation(vector3d);
+      transformGroup4.setTransform(transform3D1);
+    } 
+    transform3D1.rotY(-1.5707963267948966D);
+    transform3D1.setScale(paramDouble);
+    vector3d.set(-paramDouble, 0.0D, 0.0D);
+    transform3D1.setTranslation(vector3d);
+    transformGroup5.setTransform(transform3D1);
+    transform3D1.rotY(Math.PI);
+    transform3D1.setScale(paramDouble);
+    vector3d.set(0.0D, 0.0D, -paramDouble);
+    transform3D1.setTranslation(vector3d);
+    transformGroup6.setTransform(transform3D1);
+    this.mBrGrp.compile();
+  }
+}
+
+
+/* Location:              /opt/SpaceControl/Cube_Demo.jar!/cube_demo/ColoredCube.class
+ * Java compiler version: 8 (52.0)
+ * JD-Core Version:       1.2.1
+ */

Cube_Demo/cube_demo/CubeApp.java

@@ -0,0 +1,465 @@
+package cube_demo;
+
+import com.sun.j3d.utils.behaviors.vp.OrbitBehavior;
+import com.sun.j3d.utils.behaviors.vp.ViewPlatformBehavior;
+import com.sun.j3d.utils.geometry.Sphere;
+import com.sun.j3d.utils.image.TextureLoader;
+import com.sun.j3d.utils.universe.SimpleUniverse;
+import com.sun.j3d.utils.universe.ViewingPlatform;
+import de.spacecontrol.sc.dllwrapper.ScDllWrapper;
+import de.spacecontrol.sc.dllwrapper.ScEx;
+import de.spacecontrol.sc.dllwrapper.ScStdData;
+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.EventQueue;
+import java.awt.GraphicsConfiguration;
+import java.awt.Image;
+import java.awt.event.FocusAdapter;
+import java.awt.event.FocusEvent;
+import java.awt.event.KeyAdapter;
+import java.awt.event.KeyEvent;
+import java.lang.management.ManagementFactory;
+import java.util.ArrayList;
+import javax.media.j3d.AmbientLight;
+import javax.media.j3d.Appearance;
+import javax.media.j3d.Background;
+import javax.media.j3d.BoundingSphere;
+import javax.media.j3d.Bounds;
+import javax.media.j3d.BranchGroup;
+import javax.media.j3d.Canvas3D;
+import javax.media.j3d.Node;
+import javax.media.j3d.TextureAttributes;
+import javax.media.j3d.Transform3D;
+import javax.media.j3d.TransformGroup;
+import javax.swing.JFrame;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.UIManager;
+import javax.swing.UnsupportedLookAndFeelException;
+import javax.vecmath.AxisAngle4d;
+import javax.vecmath.Color4f;
+import javax.vecmath.Matrix4d;
+import javax.vecmath.Point3d;
+import javax.vecmath.Vector3d;
+
+public class CubeApp extends JFrame {
+  private final int mBoundsRange = 1000;
+  
+  private int mSceneNo;
+  
+  private double mHandSpan;
+  
+  private double mHandAngle;
+  
+  private ReadingThread mReadingThread = new ReadingThread(this);
+  
+  private int mDevIdx;
+  
+  private TransformGroup mCubeTfGrp = new TransformGroup();
+  
+  private TransformGroup mMirrCubeTfGrp = new TransformGroup();
+  
+  private Transform3D mCubeTf = new Transform3D();
+  
+  private Transform3D mCubeInvTf = new Transform3D();
+  
+  private Transform3D mTf = new Transform3D();
+  
+  private Transform3D mRotTf = new Transform3D();
+  
+  private Transform3D mMirrTf = new Transform3D();
+  
+  private Transform3D mMirrXzTf = new Transform3D();
+  
+  private Vector3d mV = new Vector3d();
+  
+  private Matrix4d mMatrix4d = new Matrix4d();
+  
+  private Vector3d mXAxis = new Vector3d();
+  
+  private Vector3d mYAxis = new Vector3d();
+  
+  private Vector3d mZAxis = new Vector3d();
+  
+  private final Vector3d mUx = new Vector3d(1.0D, 0.0D, 0.0D);
+  
+  private final Vector3d mUy = new Vector3d(0.0D, 1.0D, 0.0D);
+  
+  private final Vector3d mUz = new Vector3d(0.0D, 0.0D, 1.0D);
+  
+  private AxisAngle4d mXAxisAngle = new AxisAngle4d();
+  
+  private AxisAngle4d mYAxisAngle = new AxisAngle4d();
+  
+  private AxisAngle4d mZAxisAngle = new AxisAngle4d();
+  
+  private double mX;
+  
+  private double mY;
+  
+  private double mZ;
+  
+  private ViewingPlatform mVp;
+  
+  private JPanel mGraphicPanel;
+  
+  public int getDevIdx() {
+    return this.mDevIdx;
+  }
+  
+  public CubeApp() {
+    GraphicsConfiguration graphicsConfiguration = SimpleUniverse.getPreferredConfiguration();
+    Canvas3D canvas3D = new Canvas3D(graphicsConfiguration);
+    SimpleUniverse simpleUniverse = new SimpleUniverse(canvas3D);
+    BranchGroup branchGroup = null;
+    OrbitBehavior orbitBehavior = new OrbitBehavior(canvas3D);
+    ArrayList<Image> arrayList = new ArrayList();
+    String str1 = System.getProperty("os.name");
+    boolean bool = str1.contains("OS X");
+    this.mVp = simpleUniverse.getViewingPlatform();
+    Image image1 = getToolkit().getImage(getClass().getResource("/pics/cube_16.png"));
+    Image image2 = getToolkit().getImage(getClass().getResource("/pics/cube_32.png"));
+    Image image3 = getToolkit().getImage(getClass().getResource("/pics/cube_64.png"));
+    arrayList.add(image1);
+    arrayList.add(image2);
+    arrayList.add(image3);
+    setIconImages(arrayList);
+    try {
+      UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+    } catch (UnsupportedLookAndFeelException unsupportedLookAndFeelException) {
+      unsupportedLookAndFeelException.printStackTrace();
+    } catch (IllegalAccessException illegalAccessException) {
+      illegalAccessException.printStackTrace();
+    } catch (InstantiationException instantiationException) {
+      instantiationException.printStackTrace();
+    } catch (ClassNotFoundException classNotFoundException) {
+      classNotFoundException.printStackTrace();
+    } 
+    initComponents();
+    String str2 = bool ? getClass().getSimpleName() : getTitle();
+    this.mGraphicPanel.add("Center", (Component)canvas3D);
+    simpleUniverse.getViewer().getView().setBackClipDistance(1000.0D);
+    branchGroup = createCubeSceneGraph();
+    setViewPos(this.mVp);
+    orbitBehavior.setSchedulingBounds((Bounds)new BoundingSphere(new Point3d(), 1000.0D));
+    orbitBehavior.setZoomFactor(5.0D);
+    this.mVp.setViewPlatformBehavior((ViewPlatformBehavior)orbitBehavior);
+    this.mMatrix4d.setIdentity();
+    this.mMatrix4d.setM11(-1.0D);
+    this.mMirrXzTf.set(this.mMatrix4d);
+    branchGroup.compile();
+    simpleUniverse.addBranchGraph(branchGroup);
+    this.mGraphicPanel.requestFocus();
+    try {
+      String str3 = ManagementFactory.getRuntimeMXBean().getName();
+      int i = str3.indexOf('@');
+      String str4 = str3.substring(0, i);
+      ScDllWrapper.scConnect2(false, str2);
+      this.mReadingThread.start();
+    } catch (ScEx scEx) {
+      JOptionPane.showMessageDialog(this.mGraphicPanel, "No connection to SpaceControl driver!\nMove the cube with keys 1-6 and shift.", "Connection Error", 0);
+    } 
+  }
+  
+  private void setViewPos(ViewingPlatform paramViewingPlatform) {
+    TransformGroup transformGroup = paramViewingPlatform.getViewPlatformTransform();
+    Transform3D transform3D1 = new Transform3D();
+    Transform3D transform3D2 = new Transform3D();
+    transformGroup.getTransform(transform3D2);
+    transform3D2.rotY(Math.toRadians(0.0D));
+    transform3D2.rotX(Math.toRadians(-5.0D));
+    transform3D1.mul(transform3D2);
+    transform3D2.setTranslation(new Vector3d(0.0D, 5.0D, 18.0D));
+    transform3D1.mul(transform3D2);
+    transformGroup.setTransform(transform3D1);
+  }
+  
+  private BranchGroup createCubeSceneGraph() {
+    BranchGroup branchGroup1 = new BranchGroup();
+    BranchGroup branchGroup2 = new BranchGroup();
+    TransformGroup transformGroup = new TransformGroup();
+    Floor floor = new Floor();
+    FloorShade floorShade1 = new FloorShade(0, 16.0D, 8.0D, this.mGraphicPanel);
+    FloorShade floorShade2 = new FloorShade(1, 16.0D, 8.0D, this.mGraphicPanel);
+    FloorShade floorShade3 = new FloorShade(2, 16.0D, 8.0D, this.mGraphicPanel);
+    FloorShade floorShade4 = new FloorShade(3, 16.0D, 8.0D, this.mGraphicPanel);
+    FloorBack floorBack = new FloorBack(16.0D, 16.0D, -8.0D);
+    AmbientLight ambientLight = new AmbientLight();
+    Appearance appearance1 = new Appearance();
+    Lamp lamp1 = new Lamp(4.5D, 0.0D, 4.5D, 0.25D, 5.0D, false);
+    Lamp lamp2 = new Lamp(-4.5D, 0.0D, -4.5D, 0.25D, 5.0D, false);
+    Lamp lamp3 = new Lamp(-4.5D, 0.0D, -4.5D, 0.25D, 5.0D, true);
+    Lamp lamp4 = new Lamp(4.5D, 0.0D, 4.5D, 0.25D, 5.0D, true);
+    Background background = new Background();
+    ColoredCube coloredCube1 = new ColoredCube(0.4D, false);
+    ColoredCube coloredCube2 = new ColoredCube(0.4D, true);
+    Axes axes = new Axes(-8.0D, 0.2D, -8.0D);
+    TextureLoader textureLoader = new TextureLoader("src/pics/halebop.png", this);
+    Appearance appearance2 = new Appearance();
+    Sphere sphere = new Sphere(1.0F, 6, 50, appearance2);
+    branchGroup2.addChild((Node)background);
+    branchGroup2.addChild((Node)floor);
+    branchGroup2.addChild((Node)floorShade1);
+    branchGroup2.addChild((Node)floorShade2);
+    branchGroup2.addChild((Node)floorShade3);
+    branchGroup2.addChild((Node)floorShade4);
+    branchGroup2.addChild((Node)floorBack);
+    branchGroup2.addChild((Node)lamp1.getBrGrp());
+    branchGroup2.addChild((Node)lamp2.getBrGrp());
+    branchGroup2.addChild((Node)lamp3.getBrGrp());
+    branchGroup2.addChild((Node)lamp4.getBrGrp());
+    branchGroup2.addChild((Node)axes.getBrGrp());
+    branchGroup2.addChild((Node)this.mCubeTfGrp);
+    branchGroup2.addChild((Node)this.mMirrCubeTfGrp);
+    branchGroup2.addChild((Node)ambientLight);
+    appearance2.setTexture(textureLoader.getTexture());
+    appearance2.setTextureAttributes(new TextureAttributes(2, new Transform3D(), new Color4f(), 1));
+    branchGroup1.addChild((Node)new Stars());
+    branchGroup1.addChild((Node)sphere);
+    background.setApplicationBounds((Bounds)new BoundingSphere(new Point3d(), 1000.0D));
+    background.setGeometry(branchGroup1);
+    this.mCubeTfGrp.addChild((Node)coloredCube1.getBrGrp());
+    this.mMirrCubeTfGrp.addChild((Node)coloredCube2.getBrGrp());
+    this.mCubeTfGrp.setCapability(18);
+    this.mMirrCubeTfGrp.setCapability(18);
+    ambientLight.setInfluencingBounds((Bounds)new BoundingSphere(new Point3d(0.0D, 0.0D, 0.0D), 20.0D));
+    return branchGroup2;
+  }
+  
+  public void repaintDemo(ScStdData paramScStdData) {
+    double d7 = 500.0D;
+    if (!isShowing())
+      return; 
+    double d1 = paramScStdData.mA / d7;
+    double d2 = paramScStdData.mB / d7;
+    double d3 = paramScStdData.mC / d7;
+    double d4 = paramScStdData.mX / d7;
+    double d5 = paramScStdData.mY / d7;
+    double d6 = paramScStdData.mZ / d7;
+    this.mX += d4;
+    this.mY += d5;
+    this.mZ += d6;
+    calcScreenRotsRelativeToCube(d1, d2, d3);
+    this.mRotTf.setIdentity();
+    this.mTf.setIdentity();
+    this.mTf.setRotation(this.mXAxisAngle);
+    this.mRotTf.mul(this.mTf);
+    this.mTf.setIdentity();
+    this.mTf.setRotation(this.mYAxisAngle);
+    this.mRotTf.mul(this.mTf);
+    this.mTf.setIdentity();
+    this.mTf.setRotation(this.mZAxisAngle);
+    this.mRotTf.mul(this.mTf);
+    this.mCubeTf.mul(this.mRotTf);
+    if (this.mX > 7.0D)
+      this.mX = 7.0D; 
+    if (this.mX < -7.0D)
+      this.mX = -7.0D; 
+    if (this.mZ > 7.0D)
+      this.mZ = 7.0D; 
+    if (this.mZ < -7.0D)
+      this.mZ = -7.0D; 
+    if (this.mY > 7.0D)
+      this.mY = 7.0D; 
+    if (this.mY < 0.4D)
+      this.mY = 0.4D; 
+    this.mV.set(this.mX, this.mY, this.mZ);
+    this.mCubeTf.setTranslation(this.mV);
+    this.mCubeTfGrp.setTransform(this.mCubeTf);
+    this.mMirrTf.set(this.mMirrXzTf);
+    this.mMirrTf.mul(this.mCubeTf);
+    this.mMirrTf.mul(this.mMirrXzTf);
+    this.mMirrCubeTfGrp.setTransform(this.mMirrTf);
+  }
+  
+  private void calcScreenRotsRelativeToCube(double paramDouble1, double paramDouble2, double paramDouble3) {
+    this.mCubeInvTf.invert(this.mCubeTf);
+    this.mCubeInvTf.transform(this.mUx, this.mXAxis);
+    this.mXAxisAngle.set(this.mXAxis, paramDouble1);
+    this.mCubeInvTf.transform(this.mUy, this.mYAxis);
+    this.mYAxisAngle.set(this.mYAxis, paramDouble2);
+    this.mCubeInvTf.transform(this.mUz, this.mZAxis);
+    this.mZAxisAngle.set(this.mZAxis, paramDouble3);
+  }
+  
+  public void handleEvent(int paramInt1, int paramInt2) {
+    switch (paramInt2) {
+      case 131081:
+        handleFrontEvent();
+        break;
+      case 131082:
+        handleRightEvent();
+        break;
+      case 131083:
+        handleTopEvent();
+        break;
+      case 131094:
+        handleBackEvent();
+        break;
+      case 131095:
+        handleLeftEvent();
+        break;
+      case 131096:
+        handleBottomEvent();
+        break;
+      case 131084:
+        handleFitEvent();
+        break;
+      default:
+        System.out.println("*** Event '" + paramInt2 + "' not supported.");
+        break;
+    } 
+  }
+  
+  private void handleFrontEvent() {
+    ScStdData scStdData = new ScStdData();
+    rotateToFront();
+    this.mCubeTfGrp.setTransform(this.mCubeTf);
+    repaintDemo(scStdData);
+  }
+  
+  private void rotateToFront() {
+    Transform3D transform3D = new Transform3D();
+    Vector3d vector3d = new Vector3d();
+    this.mCubeTf.get(vector3d);
+    transform3D.invert(this.mCubeTf);
+    this.mCubeTf.mul(transform3D);
+    this.mCubeTf.setTranslation(vector3d);
+  }
+  
+  private void handleRightEvent() {
+    Transform3D transform3D = new Transform3D();
+    AxisAngle4d axisAngle4d = new AxisAngle4d(0.0D, 1.0D, 0.0D, -1.5707963267948966D);
+    ScStdData scStdData = new ScStdData();
+    rotateToFront();
+    transform3D.setRotation(axisAngle4d);
+    this.mCubeTf.mul(transform3D);
+    this.mCubeTfGrp.setTransform(this.mCubeTf);
+    repaintDemo(scStdData);
+  }
+  
+  private void handleTopEvent() {
+    Transform3D transform3D = new Transform3D();
+    AxisAngle4d axisAngle4d = new AxisAngle4d(1.0D, 0.0D, 0.0D, 1.5707963267948966D);
+    ScStdData scStdData = new ScStdData();
+    rotateToFront();
+    transform3D.setRotation(axisAngle4d);
+    this.mCubeTf.mul(transform3D);
+    this.mCubeTfGrp.setTransform(this.mCubeTf);
+    repaintDemo(scStdData);
+  }
+  
+  private void handleBackEvent() {
+    Transform3D transform3D = new Transform3D();
+    AxisAngle4d axisAngle4d = new AxisAngle4d(0.0D, 1.0D, 0.0D, Math.PI);
+    ScStdData scStdData = new ScStdData();
+    rotateToFront();
+    transform3D.setRotation(axisAngle4d);
+    this.mCubeTf.mul(transform3D);
+    this.mCubeTfGrp.setTransform(this.mCubeTf);
+    repaintDemo(scStdData);
+  }
+  
+  private void handleLeftEvent() {
+    Transform3D transform3D = new Transform3D();
+    AxisAngle4d axisAngle4d = new AxisAngle4d(0.0D, 1.0D, 0.0D, 1.5707963267948966D);
+    ScStdData scStdData = new ScStdData();
+    rotateToFront();
+    transform3D.setRotation(axisAngle4d);
+    this.mCubeTf.mul(transform3D);
+    this.mCubeTfGrp.setTransform(this.mCubeTf);
+    repaintDemo(scStdData);
+  }
+  
+  private void handleBottomEvent() {
+    Transform3D transform3D = new Transform3D();
+    AxisAngle4d axisAngle4d = new AxisAngle4d(1.0D, 0.0D, 0.0D, -1.5707963267948966D);
+    ScStdData scStdData = new ScStdData();
+    rotateToFront();
+    transform3D.setRotation(axisAngle4d);
+    this.mCubeTf.mul(transform3D);
+    this.mCubeTfGrp.setTransform(this.mCubeTf);
+    repaintDemo(scStdData);
+  }
+  
+  private void handleFitEvent() {
+    setViewPos(this.mVp);
+  }
+  
+  private void initComponents() {
+    this.mGraphicPanel = new JPanel();
+    setDefaultCloseOperation(3);
+    setTitle("SC Cube Demo");
+    this.mGraphicPanel.setMinimumSize(new Dimension(640, 480));
+    this.mGraphicPanel.setPreferredSize(new Dimension(640, 480));
+    this.mGraphicPanel.addFocusListener(new FocusAdapter() {
+          public void focusLost(FocusEvent param1FocusEvent) {
+            CubeApp.this.mGraphicPanelFocusLost(param1FocusEvent);
+          }
+        });
+    this.mGraphicPanel.addKeyListener(new KeyAdapter() {
+          public void keyPressed(KeyEvent param1KeyEvent) {
+            CubeApp.this.mGraphicPanelKeyPressed(param1KeyEvent);
+          }
+        });
+    this.mGraphicPanel.setLayout(new BorderLayout());
+    getContentPane().add(this.mGraphicPanel, "Center");
+    pack();
+  }
+  
+  private void mGraphicPanelFocusLost(FocusEvent paramFocusEvent) {
+    String str = System.getProperty("os.name");
+    if (str.equals("Linux"))
+      return; 
+    this.mGraphicPanel.requestFocus();
+  }
+  
+  private void mGraphicPanelKeyPressed(KeyEvent paramKeyEvent) {
+    int i = paramKeyEvent.getKeyCode();
+    char c = paramKeyEvent.getKeyChar();
+    ScStdData scStdData = new ScStdData();
+    if (c == '1') {
+      scStdData.mX = 1000;
+    } else if (c == '!') {
+      scStdData.mX = -1000;
+    } else if (c == '2') {
+      scStdData.mY = 1000;
+    } else if (c == '"') {
+      scStdData.mY = -1000;
+    } else if (c == '3') {
+      scStdData.mZ = 1000;
+    } else if (c == '<27>') {
+      scStdData.mZ = -1000;
+    } else if (c == '4') {
+      scStdData.mA = 1000;
+    } else if (c == '$') {
+      scStdData.mA = -1000;
+    } else if (c == '5') {
+      scStdData.mB = 1000;
+    } else if (c == '%') {
+      scStdData.mB = -1000;
+    } else if (c == '6') {
+      scStdData.mC = 1000;
+    } else if (c == '&') {
+      scStdData.mC = -1000;
+    } 
+    repaintDemo(scStdData);
+  }
+  
+  public static void main(String[] paramArrayOfString) {
+    EventQueue.invokeLater(new Runnable() {
+          public void run() {
+            CubeApp cubeApp = new CubeApp();
+            cubeApp.setVisible(true);
+            cubeApp.repaintDemo(new ScStdData());
+          }
+        });
+  }
+}
+
+
+/* Location:              /opt/SpaceControl/Cube_Demo.jar!/cube_demo/CubeApp.class
+ * Java compiler version: 8 (52.0)
+ * JD-Core Version:       1.2.1
+ */

Cube_Demo/cube_demo/CubeBehavior.java

@@ -0,0 +1,36 @@
+package cube_demo;
+
+import java.util.Enumeration;
+import javax.media.j3d.Behavior;
+import javax.media.j3d.TransformGroup;
+import javax.media.j3d.WakeupCondition;
+import javax.media.j3d.WakeupOnTransformChange;
+
+class CubeBehavior extends Behavior {
+  private TransformGroup mTfGrp;
+  
+  private WakeupOnTransformChange mWakeUp;
+  
+  public void setTg(TransformGroup paramTransformGroup) {
+    this.mTfGrp = paramTransformGroup;
+  }
+  
+  CubeBehavior(TransformGroup paramTransformGroup) {
+    this.mTfGrp = paramTransformGroup;
+  }
+  
+  public void initialize() {
+    this.mWakeUp = new WakeupOnTransformChange(this.mTfGrp);
+    wakeupOn((WakeupCondition)this.mWakeUp);
+  }
+  
+  public void processStimulus(Enumeration paramEnumeration) {
+    wakeupOn((WakeupCondition)this.mWakeUp);
+  }
+}
+
+
+/* Location:              /opt/SpaceControl/Cube_Demo.jar!/cube_demo/CubeBehavior.class
+ * Java compiler version: 8 (52.0)
+ * JD-Core Version:       1.2.1
+ */

Cube_Demo/cube_demo/CubeSide.java

@@ -0,0 +1,129 @@
+package cube_demo;
+
+import javax.media.j3d.Appearance;
+import javax.media.j3d.Geometry;
+import javax.media.j3d.Material;
+import javax.media.j3d.QuadArray;
+import javax.media.j3d.Shape3D;
+import javax.vecmath.Color3f;
+import javax.vecmath.Point3d;
+import javax.vecmath.Vector3f;
+
+class CubeSide extends Shape3D {
+  private Geometry mGeom;
+  
+  private Appearance mApr;
+  
+  public CubeSide(int paramInt) {
+    this.mGeom = createGeometry(paramInt);
+    this.mApr = createAppearance(paramInt);
+    setGeometry(this.mGeom);
+    setAppearance(this.mApr);
+  }
+  
+  private Geometry createGeometry(int paramInt) {
+    int i = 7;
+    int j = i * i * 4;
+    QuadArray quadArray = new QuadArray(j, 7);
+    int k = 0;
+    int m = 0;
+    Point3d point3d = new Point3d();
+    Color3f color3f1 = new Color3f(1.0F, 1.0F, 0.0F);
+    Color3f color3f2 = new Color3f(0.0F, 0.0F, 0.0F);
+    Vector3f vector3f = new Vector3f(0.0F, 0.0F, 1.0F);
+    int n = 0;
+    double d = 2.0D / i;
+    while (m < i) {
+      double d1 = -1.0D + m * d;
+      while (k < i) {
+        double d2 = -1.0D + k * d;
+        Color3f color3f = isEye(paramInt, k, m) ? color3f2 : color3f1;
+        point3d.set(d2, d1, 0.0D);
+        quadArray.setColor(n, color3f);
+        quadArray.setNormal(n, vector3f);
+        quadArray.setCoordinate(n++, point3d);
+        point3d.set(d2 + d, d1, 0.0D);
+        quadArray.setColor(n, color3f);
+        quadArray.setNormal(n, vector3f);
+        quadArray.setCoordinate(n++, point3d);
+        point3d.set(d2 + d, d1 + d, 0.0D);
+        quadArray.setColor(n, color3f);
+        quadArray.setNormal(n, vector3f);
+        quadArray.setCoordinate(n++, point3d);
+        point3d.set(d2, d1 + d, 0.0D);
+        quadArray.setColor(n, color3f);
+        quadArray.setNormal(n, vector3f);
+        quadArray.setCoordinate(n++, point3d);
+        k++;
+      } 
+      k = 0;
+      m++;
+    } 
+    return (Geometry)quadArray;
+  }
+  
+  private boolean isEye(int paramInt1, int paramInt2, int paramInt3) {
+    switch (paramInt1) {
+      case 1:
+        if (paramInt2 == 3 && paramInt3 == 3)
+          return true; 
+        break;
+      case 2:
+        if ((paramInt2 == 1 && paramInt3 == 1) || (paramInt2 == 5 && paramInt3 == 5))
+          return true; 
+        break;
+      case 3:
+        if ((paramInt2 == 1 && paramInt3 == 1) || (paramInt2 == 3 && paramInt3 == 3) || (paramInt2 == 5 && paramInt3 == 5))
+          return true; 
+        break;
+      case 4:
+        if ((paramInt2 == 1 && paramInt3 == 1) || (paramInt2 == 1 && paramInt3 == 5) || (paramInt2 == 5 && paramInt3 == 1) || (paramInt2 == 5 && paramInt3 == 5))
+          return true; 
+        break;
+      case 5:
+        if ((paramInt2 == 1 && paramInt3 == 1) || (paramInt2 == 1 && paramInt3 == 5) || (paramInt2 == 3 && paramInt3 == 3) || (paramInt2 == 5 && paramInt3 == 1) || (paramInt2 == 5 && paramInt3 == 5))
+          return true; 
+        break;
+      case 6:
+        if ((paramInt2 == 1 && paramInt3 == 1) || (paramInt2 == 1 && paramInt3 == 5) || (paramInt2 == 1 && paramInt3 == 3) || (paramInt2 == 5 && paramInt3 == 3) || (paramInt2 == 5 && paramInt3 == 1) || (paramInt2 == 5 && paramInt3 == 5))
+          return true; 
+        break;
+    } 
+    return false;
+  }
+  
+  private Appearance createAppearance(int paramInt) {
+    Appearance appearance = new Appearance();
+    Material material = new Material();
+    Color3f color3f = new Color3f();
+    switch (paramInt) {
+      case 1:
+        color3f.set(0.3F, 0.0F, 0.0F);
+        break;
+      case 2:
+        color3f.set(0.0F, 0.3F, 0.0F);
+        break;
+      case 3:
+        color3f.set(0.0F, 0.0F, 0.3F);
+        break;
+      case 4:
+        color3f.set(0.3F, 0.3F, 0.0F);
+        break;
+      case 5:
+        color3f.set(0.0F, 0.3F, 0.3F);
+        break;
+      case 6:
+        color3f.set(0.3F, 0.0F, 0.3F);
+        break;
+    } 
+    material.setAmbientColor(color3f);
+    appearance.setMaterial(material);
+    return appearance;
+  }
+}
+
+
+/* Location:              /opt/SpaceControl/Cube_Demo.jar!/cube_demo/CubeSide.class
+ * Java compiler version: 8 (52.0)
+ * JD-Core Version:       1.2.1
+ */

Cube_Demo/cube_demo/Floor.java

@@ -0,0 +1,77 @@
+package cube_demo;
+
+import javax.media.j3d.Appearance;
+import javax.media.j3d.Geometry;
+import javax.media.j3d.Material;
+import javax.media.j3d.QuadArray;
+import javax.media.j3d.Shape3D;
+import javax.media.j3d.TransparencyAttributes;
+import javax.vecmath.Color4f;
+import javax.vecmath.Point3d;
+import javax.vecmath.TexCoord2f;
+
+class Floor extends Shape3D {
+  private final int mGridNum = 8;
+  
+  private Geometry mGeom = createGeometry();
+  
+  private Appearance mApr = createAppearance();
+  
+  public Floor() {
+    setAppearance(this.mApr);
+    setGeometry(this.mGeom);
+  }
+  
+  private Geometry createGeometry() {
+    QuadArray quadArray = new QuadArray(1040, 15);
+    Point3d point3d = new Point3d();
+    TexCoord2f texCoord2f = new TexCoord2f();
+    Color4f color4f1 = new Color4f(1.0F, 0.0F, 0.0F, 1.0F);
+    Color4f color4f2 = new Color4f(0.157F, 0.5F, 1.0F, 0.8F);
+    Color4f color4f3 = new Color4f(1.0F, 1.0F, 1.0F, 0.8F);
+    Color4f color4f4 = color4f2;
+    int i = 0;
+    float[] arrayOfFloat = new float[3];
+    arrayOfFloat[0] = 0.0F;
+    arrayOfFloat[1] = 1.0F;
+    arrayOfFloat[2] = 0.0F;
+    for (int j = -8; j < 8; j++) {
+      for (int k = -8; k < 8; k++) {
+        point3d.set(k, 0.0D, j);
+        quadArray.setCoordinate(i, point3d);
+        quadArray.setColor(i, color4f4);
+        quadArray.setNormal(i++, arrayOfFloat);
+        point3d.set(k, 0.0D, (j + 1));
+        quadArray.setCoordinate(i, point3d);
+        quadArray.setColor(i, color4f4);
+        quadArray.setNormal(i++, arrayOfFloat);
+        point3d.set((k + 1), 0.0D, (j + 1));
+        quadArray.setCoordinate(i, point3d);
+        quadArray.setColor(i, color4f4);
+        quadArray.setNormal(i++, arrayOfFloat);
+        point3d.set((k + 1), 0.0D, j);
+        quadArray.setCoordinate(i, point3d);
+        quadArray.setColor(i, color4f4);
+        quadArray.setNormal(i++, arrayOfFloat);
+        color4f4 = (color4f4 == color4f2) ? color4f3 : color4f2;
+      } 
+      color4f4 = (color4f4 == color4f2) ? color4f3 : color4f2;
+    } 
+    return (Geometry)quadArray;
+  }
+  
+  private Appearance createAppearance() {
+    Appearance appearance = new Appearance();
+    Material material = new Material();
+    TransparencyAttributes transparencyAttributes = new TransparencyAttributes(1, 0.0F);
+    appearance.setMaterial(material);
+    appearance.setTransparencyAttributes(transparencyAttributes);
+    return appearance;
+  }
+}
+
+
+/* Location:              /opt/SpaceControl/Cube_Demo.jar!/cube_demo/Floor.class
+ * Java compiler version: 8 (52.0)
+ * JD-Core Version:       1.2.1
+ */

Cube_Demo/cube_demo/FloorBack.java

@@ -0,0 +1,51 @@
+package cube_demo;
+
+import javax.media.j3d.Appearance;
+import javax.media.j3d.Geometry;
+import javax.media.j3d.QuadArray;
+import javax.media.j3d.Shape3D;
+import javax.vecmath.Color3f;
+import javax.vecmath.Point3d;
+
+class FloorBack extends Shape3D {
+  private Geometry mGeom;
+  
+  private Appearance mApr;
+  
+  public FloorBack(double paramDouble1, double paramDouble2, double paramDouble3) {
+    this.mGeom = createGeometry(paramDouble1, paramDouble2, paramDouble3);
+    this.mApr = createAppearance();
+    setAppearance(this.mApr);
+    setGeometry(this.mGeom);
+  }
+  
+  private Geometry createGeometry(double paramDouble1, double paramDouble2, double paramDouble3) {
+    QuadArray quadArray = new QuadArray(4, 5);
+    Point3d point3d = new Point3d();
+    Color3f color3f = new Color3f(0.0F, 0.0F, 0.3F);
+    int i = 0;
+    point3d.set(-paramDouble1 / 2.0D, paramDouble3, paramDouble1 / 2.0D);
+    quadArray.setColor(i, color3f);
+    quadArray.setCoordinate(i++, point3d);
+    point3d.set(-paramDouble1 / 2.0D, paramDouble3, -paramDouble1 / 2.0D);
+    quadArray.setColor(i, color3f);
+    quadArray.setCoordinate(i++, point3d);
+    point3d.set(paramDouble1 / 2.0D, paramDouble3, -paramDouble1 / 2.0D);
+    quadArray.setColor(i, color3f);
+    quadArray.setCoordinate(i++, point3d);
+    point3d.set(paramDouble1 / 2.0D, paramDouble3, paramDouble1 / 2.0D);
+    quadArray.setColor(i, color3f);
+    quadArray.setCoordinate(i++, point3d);
+    return (Geometry)quadArray;
+  }
+  
+  private Appearance createAppearance() {
+    return new Appearance();
+  }
+}
+
+
+/* Location:              /opt/SpaceControl/Cube_Demo.jar!/cube_demo/FloorBack.class
+ * Java compiler version: 8 (52.0)
+ * JD-Core Version:       1.2.1
+ */

Cube_Demo/cube_demo/FloorShade.java

@@ -0,0 +1,100 @@
+package cube_demo;
+
+import com.sun.j3d.utils.image.TextureLoader;
+import javax.media.j3d.Appearance;
+import javax.media.j3d.Geometry;
+import javax.media.j3d.ImageComponent2D;
+import javax.media.j3d.QuadArray;
+import javax.media.j3d.Shape3D;
+import javax.media.j3d.Texture;
+import javax.media.j3d.Texture2D;
+import javax.swing.JPanel;
+import javax.vecmath.Point3d;
+import javax.vecmath.TexCoord2f;
+
+class FloorShade extends Shape3D {
+  private Geometry mGeom;
+  
+  private Appearance mApr;
+  
+  public FloorShade(int paramInt, double paramDouble1, double paramDouble2, JPanel paramJPanel) {
+    this.mGeom = createGeometry(paramInt, paramDouble1, paramDouble2);
+    this.mApr = createAppearance(paramJPanel);
+    setAppearance(this.mApr);
+    setGeometry(this.mGeom);
+  }
+  
+  private Geometry createGeometry(int paramInt, double paramDouble1, double paramDouble2) {
+    QuadArray quadArray = new QuadArray(4, 33);
+    Point3d point3d = new Point3d();
+    int i = 0;
+    TexCoord2f texCoord2f = new TexCoord2f();
+    switch (paramInt) {
+      case 0:
+        point3d.set(-paramDouble1 / 2.0D, 0.0D, paramDouble1 / 2.0D);
+        quadArray.setCoordinate(i++, point3d);
+        point3d.set(-paramDouble1 / 2.0D, -paramDouble2, paramDouble1 / 2.0D);
+        quadArray.setCoordinate(i++, point3d);
+        point3d.set(paramDouble1 / 2.0D, -paramDouble2, paramDouble1 / 2.0D);
+        quadArray.setCoordinate(i++, point3d);
+        point3d.set(paramDouble1 / 2.0D, 0.0D, paramDouble1 / 2.0D);
+        quadArray.setCoordinate(i++, point3d);
+        break;
+      case 1:
+        point3d.set(paramDouble1 / 2.0D, 0.0D, paramDouble1 / 2.0D);
+        quadArray.setCoordinate(i++, point3d);
+        point3d.set(paramDouble1 / 2.0D, -paramDouble2, paramDouble1 / 2.0D);
+        quadArray.setCoordinate(i++, point3d);
+        point3d.set(paramDouble1 / 2.0D, -paramDouble2, -paramDouble1 / 2.0D);
+        quadArray.setCoordinate(i++, point3d);
+        point3d.set(paramDouble1 / 2.0D, 0.0D, -paramDouble1 / 2.0D);
+        quadArray.setCoordinate(i++, point3d);
+        break;
+      case 2:
+        point3d.set(paramDouble1 / 2.0D, 0.0D, -paramDouble1 / 2.0D);
+        quadArray.setCoordinate(i++, point3d);
+        point3d.set(paramDouble1 / 2.0D, -paramDouble2, -paramDouble1 / 2.0D);
+        quadArray.setCoordinate(i++, point3d);
+        point3d.set(-paramDouble1 / 2.0D, -paramDouble2, -paramDouble1 / 2.0D);
+        quadArray.setCoordinate(i++, point3d);
+        point3d.set(-paramDouble1 / 2.0D, 0.0D, -paramDouble1 / 2.0D);
+        quadArray.setCoordinate(i++, point3d);
+        break;
+      case 3:
+        point3d.set(-paramDouble1 / 2.0D, 0.0D, -paramDouble1 / 2.0D);
+        quadArray.setCoordinate(i++, point3d);
+        point3d.set(-paramDouble1 / 2.0D, -paramDouble2, -paramDouble1 / 2.0D);
+        quadArray.setCoordinate(i++, point3d);
+        point3d.set(-paramDouble1 / 2.0D, -paramDouble2, paramDouble1 / 2.0D);
+        quadArray.setCoordinate(i++, point3d);
+        point3d.set(-paramDouble1 / 2.0D, 0.0D, paramDouble1 / 2.0D);
+        quadArray.setCoordinate(i++, point3d);
+        break;
+    } 
+    i = 0;
+    texCoord2f.set(0.0F, 1.0F);
+    quadArray.setTextureCoordinate(0, i++, texCoord2f);
+    texCoord2f.set(0.0F, 0.0F);
+    quadArray.setTextureCoordinate(0, i++, texCoord2f);
+    texCoord2f.set(1.0F, 0.0F);
+    quadArray.setTextureCoordinate(0, i++, texCoord2f);
+    texCoord2f.set(1.0F, 1.0F);
+    quadArray.setTextureCoordinate(0, i++, texCoord2f);
+    return (Geometry)quadArray;
+  }
+  
+  private Appearance createAppearance(JPanel paramJPanel) {
+    Appearance appearance = new Appearance();
+    TextureLoader textureLoader = new TextureLoader("src/pics/logo_big.png", paramJPanel);
+    ImageComponent2D imageComponent2D = textureLoader.getImage();
+    Texture2D texture2D = (Texture2D)textureLoader.getTexture();
+    appearance.setTexture((Texture)texture2D);
+    return appearance;
+  }
+}
+
+
+/* Location:              /opt/SpaceControl/Cube_Demo.jar!/cube_demo/FloorShade.class
+ * Java compiler version: 8 (52.0)
+ * JD-Core Version:       1.2.1
+ */

Cube_Demo/cube_demo/Lamp.java

@@ -0,0 +1,112 @@
+package cube_demo;
+
+import com.sun.j3d.utils.geometry.Cone;
+import javax.media.j3d.Appearance;
+import javax.media.j3d.BoundingSphere;
+import javax.media.j3d.Bounds;
+import javax.media.j3d.BranchGroup;
+import javax.media.j3d.ColoringAttributes;
+import javax.media.j3d.Material;
+import javax.media.j3d.Node;
+import javax.media.j3d.SpotLight;
+import javax.media.j3d.Transform3D;
+import javax.media.j3d.TransformGroup;
+import javax.vecmath.Matrix4d;
+import javax.vecmath.Point3d;
+import javax.vecmath.Vector3d;
+
+class Lamp {
+  private BranchGroup mBrGrp = new BranchGroup();
+  
+  public BranchGroup getBrGrp() {
+    return this.mBrGrp;
+  }
+  
+  public Lamp(double paramDouble1, double paramDouble2, double paramDouble3, double paramDouble4, double paramDouble5, boolean paramBoolean) {
+    Cone cone1 = new Cone((float)paramDouble4, (float)paramDouble5, 1, null);
+    Cone cone2 = new Cone((float)paramDouble4 * 2.0F, (float)paramDouble4, 1, null);
+    Cone cone3 = new Cone((float)paramDouble4 * 2.0F, 0.0F, 1, null);
+    Cone cone4 = new Cone((float)paramDouble4, (float)paramDouble4 / 2.0F, 1, null);
+    Vector3d vector3d = new Vector3d(paramDouble1, paramDouble2, paramDouble3);
+    Transform3D transform3D1 = new Transform3D();
+    Transform3D transform3D2 = new Transform3D();
+    TransformGroup transformGroup1 = new TransformGroup();
+    TransformGroup transformGroup2 = new TransformGroup();
+    TransformGroup transformGroup3 = new TransformGroup();
+    TransformGroup transformGroup4 = new TransformGroup();
+    TransformGroup transformGroup5 = new TransformGroup();
+    ColoringAttributes coloringAttributes = new ColoringAttributes();
+    Appearance appearance1 = new Appearance();
+    Appearance appearance2 = new Appearance();
+    Appearance appearance3 = new Appearance();
+    Appearance appearance4 = new Appearance();
+    Material material1 = new Material();
+    Material material2 = new Material();
+    Material material3 = new Material();
+    transformGroup1.addChild((Node)cone1);
+    transformGroup2.addChild((Node)cone2);
+    transformGroup3.addChild((Node)cone3);
+    transformGroup4.addChild((Node)cone4);
+    transformGroup5.addChild((Node)transformGroup1);
+    transformGroup5.addChild((Node)transformGroup2);
+    transformGroup5.addChild((Node)transformGroup3);
+    transformGroup5.addChild((Node)transformGroup4);
+    this.mBrGrp.addChild((Node)transformGroup5);
+    vector3d.set(0.0D, paramDouble5 / 2.0D, 0.0D);
+    transform3D1.setTranslation(vector3d);
+    transformGroup1.setTransform(transform3D1);
+    vector3d.set(0.0D, paramDouble5, 0.0D);
+    transform3D1.setTranslation(vector3d);
+    transformGroup2.setTransform(transform3D1);
+    vector3d.set(0.0D, paramDouble5 - paramDouble4 / 2.0D - 0.01D, 0.0D);
+    transform3D1.setTranslation(vector3d);
+    transformGroup3.setTransform(transform3D1);
+    vector3d.set(0.0D, paramDouble5 - paramDouble5 / 20.0D, 0.0D);
+    transform3D1.rotX(Math.PI);
+    transform3D1.setTranslation(vector3d);
+    transformGroup4.setTransform(transform3D1);
+    if (!paramBoolean) {
+      SpotLight spotLight = new SpotLight();
+      Point3d point3d = new Point3d(0.0D, (float)(paramDouble5 + paramDouble5 / 10.0D), 0.0D);
+      spotLight.setPosition((float)point3d.getX(), (float)point3d.getY(), (float)point3d.getZ());
+      spotLight.setInfluencingBounds((Bounds)new BoundingSphere(point3d, 20.0D));
+      spotLight.setSpreadAngle(1.5707964F);
+      spotLight.setDirection(0.0F, -1.0F, 0.0F);
+      spotLight.setConcentration(2.0F);
+      transformGroup5.addChild((Node)spotLight);
+    } 
+    vector3d.set(paramDouble1, paramDouble2, paramDouble3);
+    transform3D1.setIdentity();
+    transform3D1.setTranslation(vector3d);
+    if (paramBoolean) {
+      Matrix4d matrix4d = new Matrix4d();
+      transform3D1.get(matrix4d);
+      matrix4d.setM11(-matrix4d.getM11());
+      transform3D1.set(matrix4d);
+    } 
+    transformGroup5.setTransform(transform3D1);
+    material1.setAmbientColor(0.0F, 0.2F, 0.0F);
+    material1.setDiffuseColor(0.0F, 1.0F, 0.0F);
+    material1.setShininess(128.0F);
+    appearance1.setMaterial(material1);
+    cone1.setAppearance(appearance1);
+    material2.setAmbientColor(0.2F, 0.0F, 0.0F);
+    material2.setDiffuseColor(1.0F, 0.0F, 0.0F);
+    material2.setShininess(128.0F);
+    appearance2.setMaterial(material2);
+    cone2.setAppearance(appearance2);
+    coloringAttributes.setColor(0.8F, 0.0F, 0.0F);
+    appearance3.setColoringAttributes(coloringAttributes);
+    cone3.setAppearance(appearance3);
+    material3.setEmissiveColor(1.0F, 1.0F, 1.0F);
+    appearance4.setMaterial(material3);
+    cone4.setAppearance(appearance4);
+    this.mBrGrp.compile();
+  }
+}
+
+
+/* Location:              /opt/SpaceControl/Cube_Demo.jar!/cube_demo/Lamp.class
+ * Java compiler version: 8 (52.0)
+ * JD-Core Version:       1.2.1
+ */

Cube_Demo/cube_demo/ReadingThread.java

@@ -0,0 +1,62 @@
+package cube_demo;
+
+import de.spacecontrol.sc.dllwrapper.ScDllWrapper;
+import de.spacecontrol.sc.dllwrapper.ScEx;
+import de.spacecontrol.sc.dllwrapper.ScStdData;
+
+public class ReadingThread extends Thread {
+  private CubeApp mApp;
+  
+  private int mDevIdx;
+  
+  private boolean mIsReading;
+  
+  public void setDevIdx(int paramInt) {
+    this.mDevIdx = paramInt;
+  }
+  
+  public void stopReadingThread() {
+    this.mIsReading = false;
+  }
+  
+  public ReadingThread(CubeApp paramCubeApp) {
+    this.mApp = paramCubeApp;
+    this.mDevIdx = paramCubeApp.getDevIdx();
+  }
+  
+  public void run() {
+    boolean bool = true;
+    int i = 0;
+    ScStdData scStdData = new ScStdData();
+    this.mIsReading = true;
+    while (this.mIsReading) {
+      try {
+        ScDllWrapper.scFetchStdData(this.mDevIdx, scStdData);
+        if (scStdData.mEvent > -1) {
+          this.mApp.handleEvent(this.mDevIdx, scStdData.mEvent);
+          continue;
+        } 
+        this.mApp.repaintDemo(scStdData);
+      } catch (ScEx scEx) {
+        if (bool) {
+          this.mApp.repaintDemo(scStdData);
+          if (i++ > 3) {
+            i = 0;
+            bool = false;
+          } 
+        } 
+      } 
+    } 
+    System.out.println("*** Reading thread stopped.");
+  }
+  
+  public void stopp() {
+    this.mIsReading = false;
+  }
+}
+
+
+/* Location:              /opt/SpaceControl/Cube_Demo.jar!/cube_demo/ReadingThread.class
+ * Java compiler version: 8 (52.0)
+ * JD-Core Version:       1.2.1
+ */

Cube_Demo/cube_demo/Stars.java

@@ -0,0 +1,51 @@
+package cube_demo;
+
+import java.util.Random;
+import javax.media.j3d.Appearance;
+import javax.media.j3d.Geometry;
+import javax.media.j3d.PointArray;
+import javax.media.j3d.PointAttributes;
+import javax.media.j3d.Shape3D;
+
+class Stars extends Shape3D {
+  private Geometry mGeom = createGeometry();
+  
+  private Appearance mApr = createAppearance();
+  
+  public Stars() {
+    setGeometry(this.mGeom);
+    setAppearance(this.mApr);
+  }
+  
+  private Geometry createGeometry() {
+    int i = 1000;
+    PointArray pointArray = new PointArray(i, 5);
+    float[] arrayOfFloat1 = new float[3];
+    float[] arrayOfFloat2 = new float[3];
+    Random random = new Random();
+    for (int j = 0; j < i; j++) {
+      arrayOfFloat1[0] = random.nextFloat() - 0.5F;
+      arrayOfFloat1[1] = random.nextFloat() - 0.5F;
+      arrayOfFloat1[2] = random.nextFloat() - 0.5F;
+      pointArray.setCoordinates(j, arrayOfFloat1);
+      arrayOfFloat2[2] = random.nextFloat() * 0.8F + 0.2F;
+      arrayOfFloat2[1] = random.nextFloat() * 0.8F + 0.2F;
+      arrayOfFloat2[0] = random.nextFloat() * 0.8F + 0.2F;
+      pointArray.setColor(j, arrayOfFloat2);
+    } 
+    return (Geometry)pointArray;
+  }
+  
+  private Appearance createAppearance() {
+    PointAttributes pointAttributes = new PointAttributes(2.0F, true);
+    Appearance appearance = new Appearance();
+    appearance.setPointAttributes(pointAttributes);
+    return appearance;
+  }
+}
+
+
+/* Location:              /opt/SpaceControl/Cube_Demo.jar!/cube_demo/Stars.class
+ * Java compiler version: 8 (52.0)
+ * JD-Core Version:       1.2.1
+ */