# Java3D - Problem mit rotierendem Würfel



## marcel_se_best (7. Dez 2008)

Hallo zusammen,
ich möchte folgende Interaktion bei einem Würfel realisieren.

Der Würfel soll sich um 360° drehen.
Mit gedrückter Maustaste kann man den Würfel anhalten und in Richtung der Mausbewegung rotieren.
Nach dem Loslassen der Maustaste soll sich der Würfel in die Richtung weiter drehen, in die ihn der User gedreht hat.

Ich habe mich mit RotationInterpolator, Behavior, MouseBehavior und MouseListener beschäftigt. Leider weiss ich nicht, welcher weg der Richtige ist.

Ich würde mich freuen, wenn ihr mir ein paar Tipps geben könntet, wie man eine solche  Anwenung am besten umsetzen sollte.

Vielen Dank für jede Hilfe


----------



## marcel_se_best (9. Dez 2008)

Hallo zusammen,
ich habe jetzt eine kleine Demo, wie oben beschrieben, umgesetzt (mit Java3D).
Jetzt habe ich noch ein kleines Problemchen und zwar:
Wenn der User den Würfel in die entgegengesetzte Richtung der Animation dreht, also eine neue Richtung festgelegt, springt der Würfel etwas und dreht sich dann wie gewünscht weiter. Wenn man den Würfel in Richtung der Animationsrichtung dreht, springt er nicht.
Was kann man gegen dieses unschöne Springen machen?
Hier mein Code:

```
import java.awt.*;
import java.awt.event.*;
import javax.media.j3d.*;
import javax.vecmath.Quat4d;
import javax.vecmath.Quat4f;
import javax.vecmath.Vector3f;

import com.sun.j3d.utils.universe.*;
import com.sun.j3d.utils.geometry.*;
import com.sun.j3d.utils.image.TextureLoader;
import com.sun.j3d.utils.behaviors.mouse.MouseRotate;

public class Cube04 extends Frame implements MouseListener
{
        public RotationInterpolator rotationInterpolator = null;
        public Alpha alpha = null;
        public Integer oldPos = null;
       
        public Cube04 (String title) {
                // AnzeigeInfos
        GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration();

        // Canvas mit den AnzeigeInfos
        Canvas3D canvas3d = new Canvas3D (config);
        add(canvas3d);

        // Universum im Canvas
        SimpleUniverse simpleUniverse = new SimpleUniverse(canvas3d);
       
        // Kamera
        ViewingPlatform viewingPlatform =  simpleUniverse.getViewingPlatform();
        TransformGroup viewTransformGroup = viewingPlatform.getMultiTransformGroup().getTransformGroup(0);
        Transform3D viewTransform3D = new Transform3D();
        viewTransformGroup.getTransform(viewTransform3D);
        viewTransform3D.rotX(-0.3); // Ausrichtung
        viewTransformGroup.setTransform(viewTransform3D);
        viewTransform3D.setTranslation(new Vector3f(0.0f, 0.9f, 3.0f)); // Position
        viewTransformGroup.setTransform(viewTransform3D);
       
        // Branchgruppe
        BranchGroup branchGroup = new BranchGroup();   
       
        // Transformgruppen
        TransformGroup tgInteraction = new TransformGroup();
        tgInteraction.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
        tgInteraction.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
       
        TransformGroup tgAnimation = new TransformGroup();
        tgAnimation.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
        tgAnimation.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
       
       
     // Appearance
        TextureLoader textureLoader = new TextureLoader("test.jpg", this);
        Texture texture = textureLoader.getTexture();
        Appearance appBox = new Appearance();
        appBox.setTexture(texture);
       
        // Würfel
        Box box = new Box(0.5f, 0.5f, 0.5f, Box.GENERATE_TEXTURE_COORDS, appBox);       
       
        // Animation
        Transform3D transform3D = new Transform3D();
        alpha = new Alpha(-1, 5000);
        rotationInterpolator = new RotationInterpolator(alpha, tgAnimation, transform3D, 0.0f, (float)Math.PI*2);
        rotationInterpolator.setSchedulingBounds(new BoundingSphere());
       
     // MausInteraktion
        MouseRotate mouseRotate = new MouseRotate();
        mouseRotate.setTransformGroup(tgInteraction);
        mouseRotate.setSchedulingBounds(new BoundingSphere());
        mouseRotate.setFactor(0.005, 0.0);
        canvas3d.addMouseListener(this);               

        branchGroup.addChild(tgInteraction);
        tgInteraction.addChild(mouseRotate);
        tgInteraction.addChild(tgAnimation);
        tgAnimation.addChild(rotationInterpolator);
        tgAnimation.addChild(box);
       
        branchGroup.compile();
        simpleUniverse.addBranchGraph(branchGroup);
        }

        public void mousePressed(MouseEvent e)
        {
                alpha.pause();
                oldPos = e.getX();
        }

        public void mouseReleased(MouseEvent e)
        {
                if(oldPos != e.getX())
                {
                        if(oldPos > e.getX())
                        {
                                rotationInterpolator.setMaximumAngle(-(float)Math.PI*2);
                        }
                        else
                        {
                                rotationInterpolator.setMaximumAngle((float)Math.PI*2);
                        }
                }
               
                alpha.resume();
        }
       
        public void mouseClicked(MouseEvent e)
        {               
        }

        public void mouseEntered(MouseEvent e)
        {
        }

        public void mouseExited(MouseEvent e)
        {
        }
       
        public static void main(String[] args)
        {               
                Cube04 scene = new Cube04("Cube3D");
                scene.setSize(800,600);
                scene.setVisible(true);
        }
}
```
PS: Ich habe auch schon versucht den Würfel anzuhalten, indem man nicht den Alpha stoppt, sondern den RotationInterpolator deaktiviert. Dann spring der Würfel aber immer.

Vielen Dank für jede Hilfe


----------



## Marco13 (10. Dez 2008)

Ich weiß grad' nicht, ob es so günstig ist, ein MouseRotate und einen RotationInterpolator zu mischen .... (hab grad leider keine Zeit, das zu testen...)


----------

