View difference between Paste ID: gYZvS7LH and 8HzNz7Fd

 import java.applet.Applet;
 import java.awt.*;
 import java.awt.event.*;
 import com.sun.j3d.utils.applet.MainFrame;
 import com.sun.j3d.utils.behaviors.vp.OrbitBehavior;
 import com.sun.j3d.utils.geometry.GeometryInfo;
 import com.sun.j3d.utils.geometry.Cylinder;
 import com.sun.j3d.utils.geometry.Sphere;
 import com.sun.j3d.utils.geometry.NormalGenerator;
 import com.sun.j3d.utils.universe.*;
 import java.util.Enumeration;
 import javax.media.j3d.*;
 import javax.vecmath.*;
 import java.util.Timer;
 import java.util.TimerTask;
 import javax.swing.JLabel;
 
 
 /**
  * Klasa główna 'Main' zawiera deklaracje zmiennych
  * @author
  */
 public final class Main extends Applet implements KeyListener{
 
     final private static int Width = 900;
     final private static int Height = 600;
     final private OrbitBehavior obserwator;
     final private ViewingPlatform vPlatform;
     private RotationInterpolator punkt1; // arm sweep - baza robota
     private RotationInterpolator punkt2; // shoulder - ramie robota
     private RotationInterpolator punkt3;
     final private Timer zegar = new Timer();
     final private SimpleUniverse universe;
     private double x = 0.0f;
     private double y = 0.65f;
     private double z = 0.5f;
     private double x2 = 0.1f;
     private double y2 = 0.9f;
     private double z2 = 1.1f;
     private boolean spacja = false;
     private boolean zatrzask = false;
     private boolean inCollision = false;
     JLabel label = new JLabel("Ramię Robota:");
     private TransformGroup objTrans;
     final private Transform3D trans = new Transform3D();
     private TransformGroup objTrans2;
     final private Transform3D trans2 = new Transform3D();
     private TransformGroup objTrans3;
     final private Transform3D trans3 = new Transform3D();
     private TransformGroup objTrans4;
     final private Transform3D trans4 = new Transform3D();
     private RotationInterpolator rotacja;
     final private Transform3D hujRotation = new Transform3D();
 
 
     /**
      * W metodzie tworzymy scenę oraz elementy, które będą w niej zawarte - tj.
      * elementy manipulatora cylindrycznego (cylinder, cylinder2, chwytak i przedmiot),
      * oświetlenie sceny oraz podłoże służące jako punkt odniesienia.
      * @return obiekt 'scena' typu BranchGroup
      */
     public BranchGroup createSceneGraph() {
 
        Alpha alpha1 = new Alpha(-1, 5000); // arm sweep
 
        BranchGroup scena = new BranchGroup(); // scena główna - swiatla, podloga
        BoundingSphere bounds = new BoundingSphere(new Point3d(0.0,0.0,0.0), 100.0);
 
        Transform3D tmp = new Transform3D();
 
 
        objTrans = new TransformGroup();
        objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
        objTrans2 = new TransformGroup();
        objTrans2.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
 
        //statyw
        scena.addChild(objTrans);
        Cylinder cylinder1 = new Cylinder(0.1f, 1.5f);
        objTrans = new TransformGroup();
        objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
        Transform3D pos1 = new Transform3D();
        pos1.setTranslation(new Vector3f(0.0f, 0.25f, 0.0f));
        objTrans.setTransform(pos1);
        objTrans.addChild(cylinder1);
        //scena.addChild(objTrans);
 
        //ramie
        scena.addChild(objTrans2);
        Cylinder cylinder2 = new Cylinder(0.05f, 1.25f);
        objTrans2 = new TransformGroup();
        objTrans2.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
        Transform3D cyl2 = new Transform3D();
        tmp.set(new Vector3f(0.0f,0.0f,0.0f));
        cyl2.rotX(Math.PI/2);
        tmp.mul(cyl2);
        cyl2.setTranslation(new Vector3d(x, y, z));
        objTrans2.setTransform(cyl2);
        objTrans2.addChild(cylinder2);
        //scena.addChild(objTrans2);
 
        //kulka
        scena.addChild(objTrans3);
-       kulka.setTranslation(new Vector3d(x2, y2, z2));
+
        objTrans3 = new TransformGroup();
        objTrans3.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
        Transform3D kulka = new Transform3D();
        //kulka.setTranslation(new Vector3d(0.0, y2, z2));
        objTrans3.setTransform(kulka);
        objTrans3.addChild(chwytak);
        scena.addChild(objTrans3);
 
        //kulka
        scena.addChild(objTrans4);
 
        Appearance app = new Appearance();
        app.setColoringAttributes(new ColoringAttributes(1.0f, 0.0f, 0.0f,ColoringAttributes.ALLOW_COLOR_WRITE));
        app.setCapability(app.ALLOW_COLORING_ATTRIBUTES_WRITE);
        Sphere przedmiot = new Sphere(0.1f, app);
        objTrans4 = new TransformGroup();
        objTrans4.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
        Transform3D kulka2 = new Transform3D();
        kulka2.setTranslation(new Vector3f(0.0f, 0.0f, 1.0f));
        objTrans4.setTransform(kulka2);
        objTrans4.addChild(przedmiot);
        scena.addChild(objTrans4);
 
        // podłoże
        Appearance ap = new Appearance();
        Color3f black = new Color3f(.0f,.0f,.0f);
        Color3f white = new Color3f(0.8f,.8f,.8f);
        ap.setMaterial(new Material(white,black,white,black,80f));
        podloga ob = new podloga();
        ob.setAppearance(ap);
        scena.addChild(ob);
 
        // światło kierunkowe
        Color3f light1Color = new Color3f(1.0f, 1.0f, 1.0f);
        Vector3f light1Direction = new Vector3f(4.0f, -7.0f, -12.0f);
        DirectionalLight light1 = new DirectionalLight(light1Color, light1Direction);
        light1.setInfluencingBounds(bounds);
        scena.addChild(light1);
 
        // światło
        Color3f ambientColor = new Color3f(1.0f, 1.0f, 1.0f);
        AmbientLight ambientLightNode = new AmbientLight(ambientColor);
        ambientLightNode.setInfluencingBounds(bounds);
        scena.addChild(ambientLightNode);
 
        //objTrans2.addChild(objTrans3);
        objTrans.addChild(objTrans2);
        scena.addChild(objTrans);
 
     // Create a new Behavior object that will perform the collision
-        50.0);
+
     // the scene graph.
     CollisionDetector cd = new CollisionDetector(przedmiot);
     BoundingSphere boundy = new BoundingSphere(new Point3d(0.0, 0.0, 0.0),
         1.0);
     cd.setSchedulingBounds(boundy);
        objTrans3.addChild(cd);
 
        scena.compile();
        return scena;
     }
 
 
     /**
      * Konstruktor bezparametrowy klasy 'Main'. Ustawia on wygląd okna programu
      * (BorderLayout()), tworzy w nim podstawowe obiekty Java3D (SimpleUniverse).
      * Ustawia pozycję i zachowanie kamery oraz uruchamia zegar.
      */
     public Main() {
         setLayout(new BorderLayout());
 
         GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration();
         Canvas3D canvas3D = new Canvas3D(config);
         add("Center", canvas3D);
         canvas3D.addKeyListener(this);
         add("South",label);
 
         // Create a simple scene and attach it to the virtual universe
         BranchGroup scene = createSceneGraph();
         universe = new SimpleUniverse(canvas3D);
         universe.addBranchGraph(scene);
         obserwator = new OrbitBehavior(canvas3D);
         BoundingSphere bounds = new BoundingSphere(new Point3d(0.0,0.0,0.0), 100.0);
         obserwator.setSchedulingBounds(bounds);
         vPlatform = universe.getViewingPlatform();
         Transform3D temp = new Transform3D();
         temp.set(new Vector3f(0f,0f,7.0f));
         vPlatform.getViewPlatformTransform().setTransform(temp);
         vPlatform.setViewPlatformBehavior(obserwator);
         zegar.scheduleAtFixedRate(new Ruch(), 20, 25);
     }
 
     /**
      * Funkcja tworzy okno typu MainFrame o zadanych wymiarach Width i Height.
      * Konstruktor okna wywołuje konstruktor klasy Main().
      * @param args
      */
     public static void main(String[] args) {
        //Main bb = new Main();
        MainFrame mf = new MainFrame(new Main(),Width, Height);
     }
 
 /******************************************************************************/
 
   class CollisionDetector extends Behavior {
   private final Color3f highlightColor = new Color3f(0.0f, 1.0f, 0.0f);
-  private boolean inCollision = false;
+
   private final ColoringAttributes highlight = new ColoringAttributes(
       highlightColor, ColoringAttributes.SHADE_GOURAUD);
 
   private Sphere sferka;
 
   private ColoringAttributes shapeColoring;
 
   private Appearance shapeAppearance;
 
   private WakeupOnCollisionEntry wEnter;
 
   private WakeupOnCollisionExit wExit;
 
   public CollisionDetector(Sphere s) {
     sferka = s;
     shapeAppearance = sferka.getAppearance();
     shapeColoring = shapeAppearance.getColoringAttributes();
     inCollision = false;
-  @Override
+
 
   public void initialize() {
     wEnter = new WakeupOnCollisionEntry(sferka);
     wExit = new WakeupOnCollisionExit(sferka);
     wakeupOn(wEnter);
   }
-  @Override
+
   public void processStimulus(Enumeration criteria) {
     inCollision = !inCollision;
 
     if (inCollision) {
       shapeAppearance.setColoringAttributes(highlight);
       wakeupOn(wExit);
     } else {
       shapeAppearance.setColoringAttributes(shapeColoring);
       wakeupOn(wEnter);
     }
   }
   }
 
 /******************************************************************************/
 
    public static float round (double f)
 
    {  float temp = (float)(f*(Math.pow(10, 0)));
 
           temp = (Math.round(temp));
 
           temp = temp/(int)(Math.pow(10, 0));
 
           return temp;
 
    }
     /**
      * Funkcja wychwytuje zdarzenie wciśniecią przycisku na klawiaturze.
      * Zawiera obsługę przycisków służących do manipulacji robotem.
      * UP, DOWN     - przesuw ramienia w pionie
      * LEFT, RIGHT  - obrót ramienia wokół jego osi pionowej
      * A, S         - przesuw ramienia w poziomie (wysuwanie, wsuwanie)
      * Z            - standardowe ustawienie kamery
      * @param e (KeyEvent)
      */
     @Override
     public void keyPressed(KeyEvent e) {
         if(e.getKeyCode() == KeyEvent.VK_Z){
             vPlatform.setNominalViewingTransform();
         }
         if (Math.round(Math.toDegrees(x))==360) x=Math.toRadians(0);
         if (Math.toDegrees(x)==-1) x=Math.toRadians(358.9999999999974);
         switch(e.getKeyCode()){
             case KeyEvent.VK_UP:
                 if(y < 0.65f) {
                     y += 0.05;
                     y2 += 0.05;
                 }
                 break;
             case KeyEvent.VK_DOWN:
                 if(y > -0.6f) {
                     y -= 0.05;
                     y2 -= 0.05;
                 }
                 break;
             case KeyEvent.VK_LEFT:
                 x -= Math.PI/180;
                 break;
             case KeyEvent.VK_RIGHT:
                 x += Math.PI/180;
                 break;
             case KeyEvent.VK_A:
                 if(z > -0.3f) {
                     z -= 0.05;
                     z2 -= 0.05;
                 }
                 break;
             case KeyEvent.VK_S:
                 if(z < 0.5f) {
                     z += 0.05;
                     z2 += 0.05;
                 }
                 break;
             case KeyEvent.VK_SPACE:
                 spacja = !spacja;
                 zatrzask = true;
         }
     }
 
     /**
      * Funkcja wychwytująca puszczenie przycisku klawiatury - nie używana.
      * @param e
      */
     @Override
     public void keyReleased(KeyEvent e){
         switch(e.getKeyCode()){
             case KeyEvent.VK_SPACE:
                 zatrzask = false;
                 break;
         }
     }
 
     /**
      * Funkcja wychwytująca sygnał przycisku klawiatury - nie używana.
      * @param e
      */
     @Override
     public void keyTyped(KeyEvent e){
     }
 
 
 //    @Override
 //    public void mouseMoved(MouseEvent e) {
 //       // x = (float)(e.getX())/Width-.5f;
 //        //y = -(float)(e.getY())/Height+.5f;
 //    }
 
     /**
      * Klasa dziedzicząca po klasie TimerTask.
      * Zawiera funkcję run().
      */
     private class Ruch extends TimerTask{
         /**
-            trans.setTranslation(new Vector3d(0.1f, y, z));
+
-            trans2.setTranslation(new Vector3d(0.1f,y2,z2));
+
          * informacji o aktualnych wartościach parametrów w dolnym pasku
          * informacyjnym.
          */
         @Override
         public void run() {
             trans.rotX(Math.PI/2);
             trans.setTranslation(new Vector3d(0.0f, y, z));
             trans2.setTranslation(new Vector3d(0.0f,y2,z2));
             trans3.setTranslation(new Vector3d(0.0f, 0.0f, 1.0f));
             objTrans2.setTransform(trans);
             hujRotation.rotY(x);
             trans.mul(hujRotation, trans);
             trans2.mul(hujRotation, trans2);
             trans3.mul(hujRotation, trans3);
             objTrans2.setTransform(trans);
             objTrans3.setTransform(trans2);
             if (spacja==true && inCollision==true) objTrans4.setTransform(trans3);
             label.setText("Współrzędne: " + Math.round(Math.toDegrees(x)) + " , "+ y + " , " + z);
         }
     }
 
     /**
      * Klasa 'podloga' dziedzicząca po klasie 'Shape3D'.
      */
     public class podloga extends Shape3D{ // podłoże robota
         final private Point3f A= new Point3f(-5.0f, -0.5f, -5.0f);
         final private Point3f B= new Point3f(-5.0f, -0.5f, 5.0f);
         final private Point3f C= new Point3f(5.0f, -0.5f, 5.0f);
         final private Point3f D= new Point3f(5.0f, -0.5f, -5.0f);
         final private Point3f[] pts = new Point3f[8];
         int[] stripCounts= new int[2];
         int[] contourCount=new int[2];
 
         /**
          * Konstruktor bezparametrowy klasy 'podloga'. Tworzy punkt odniesienia
          * dla manipulatora.
          */
         public podloga(){
             // front
             pts[0]=C;
             pts[1]=D;
             pts[2]=A;
             pts[3]=B;
             //back
             pts[4]=C;
             pts[5]=B;
             pts[6]=A;
             pts[7]=D;
 
             stripCounts[0]=4;
             stripCounts[1]=4;
             contourCount[0]=1;
             contourCount[1]=1;
             GeometryInfo gInf = new GeometryInfo(GeometryInfo.POLYGON_ARRAY);
             gInf.setCoordinates(pts);
             gInf.setStripCounts(stripCounts);
             gInf.setContourCounts(contourCount);
             NormalGenerator ng= new NormalGenerator();
             ng.setCreaseAngle ((float) Math.toRadians(30));
             ng.generateNormals(gInf);
             this.setGeometry(gInf.getGeometryArray());
             }
     }
 
 }