Papervision - ermitteln welche Seite eines Cubes die Kamera anschaut

[Nikolai]

Holla Zusammen

ich baue gerade mit as3 und papervision ein Element das einen Würfel beinhaltet der über die Maus per "Drag" (googleEarth-artig) rotiert werden kann.
Das klappt super.

Was ich nun vorhabe und nicht genau weiß wie ich ran gehen soll da ich in Papervision kaum was gemacht habe:

Ich möchte onMouseUp ermitteln welche Seite des Cubes die Kamera am ehesten anschaut (und dann den Cube dorthin tweenen mit der richtigen Rotation).

Ich bin aber nicht sicher ob das mit dem bisherigen Ansatz so funktionieren kann. Wenn sich jemand erbarmt mir einen Schups zu geben wäre ich echt dankbar...

Anschauen:
http://labs.advanced-users.de/cube/

Laden:
http://labs.advanced-users.de/cube/cubeheader.zip

Code:

PHP-Code:

package {
    import br.com.stimuli.loading.BulkLoader;
    import br.com.stimuli.loading.BulkProgressEvent;
    
    import org.papervision3d.core.math.Matrix3D;
    import org.papervision3d.core.math.Number3D;
    import org.papervision3d.core.proto.CameraObject3D;
    import org.papervision3d.core.proto.MaterialObject3D;
    import org.papervision3d.materials.*;
    import org.papervision3d.materials.utils.*;
    import org.papervision3d.objects.*;
    import org.papervision3d.objects.primitives.*;
    import org.papervision3d.render.*;
    import org.papervision3d.scenes.*;
    import org.papervision3d.view.*;
    
    import flash.display.Bitmap;
    import flash.display.BitmapData;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.geom.Point;    

    /**
     *    @author    Nikolai
     *    @date      10:42:26 06.08.2009
     */
    public class CubeRotator extends BasicView {

        private var cube : Cube;

        private var texture_bmp_data1 : BitmapData;
        private var texture_bmp_data2 : BitmapData;
        private var texture_bmp_data3 : BitmapData;
        private var texture_bmp_data4 : BitmapData;
        private var texture_bmp_data5 : BitmapData;
        private var texture_bmp_data6 : BitmapData;

        private var targetTexture1 : BitmapData;
        private var targetTexture2 : BitmapData;
        private var targetTexture3 : BitmapData;
        private var targetTexture4 : BitmapData;
        private var targetTexture5 : BitmapData;
        private var targetTexture6 : BitmapData;

        private var loader : BulkLoader;

        private var textureImage : Class;
        private var container : DisplayObject3D;

        private var previousMousePoint : Point = new Point();
        private static const FORWARD : Number3D = new Number3D(0, 0, 1);

        
        public function CubeRotator() {
            addEventListener(Event.ADDED_TO_STAGE, onAddedToStage);
        }

        private function onAddedToStage(event : Event) : void {

            loader = new BulkLoader("cube");
            loader.logLevel = BulkLoader.LOG_INFO;
            loader.add("1.jpg", {id:"1"});
            loader.add("2.jpg", {id:"2"});
            loader.add("3.jpg", {id:"3"});
            loader.add("4.jpg", {id:"4"});
            loader.add("5.jpg", {id:"5"});
            loader.add("6.jpg", {id:"6"});
            loader.addEventListener(BulkLoader.COMPLETE, onAllItemsLoaded);
            loader.addEventListener(BulkLoader.PROGRESS, onAllItemsProgress);
            
            loader.start();
        }

        private function onAllItemsProgress(event : BulkProgressEvent) : void {
            trace(event.loadingStatus());
        }

        
        private function onAllItemsLoaded(event : Event) : void {
            
            var bitmap1 : Bitmap = loader.getBitmap("1");
            var bitmap2 : Bitmap = loader.getBitmap("2");
            var bitmap3 : Bitmap = loader.getBitmap("3");
            var bitmap4 : Bitmap = loader.getBitmap("4");
            var bitmap5 : Bitmap = loader.getBitmap("5");
            var bitmap6 : Bitmap = loader.getBitmap("6");
            
            texture_bmp_data1 = bitmap1.bitmapData;
            texture_bmp_data2 = bitmap2.bitmapData;
            texture_bmp_data3 = bitmap3.bitmapData;
            texture_bmp_data4 = bitmap4.bitmapData;
            texture_bmp_data5 = bitmap5.bitmapData;
            texture_bmp_data6 = bitmap6.bitmapData;
            
            targetTexture1 = new BitmapData(200, 200, false, 0xffffff);
            targetTexture1.draw(texture_bmp_data1);
            targetTexture2 = new BitmapData(200, 200, false, 0xffffff);
            targetTexture2.draw(texture_bmp_data2);
            targetTexture3 = new BitmapData(200, 200, false, 0xffffff);
            targetTexture3.draw(texture_bmp_data3);
            targetTexture4 = new BitmapData(200, 200, false, 0xffffff);
            targetTexture4.draw(texture_bmp_data4);
            targetTexture5 = new BitmapData(200, 200, false, 0xffffff);
            targetTexture5.draw(texture_bmp_data5);
            targetTexture6 = new BitmapData(200, 200, false, 0xffffff);
            targetTexture6.draw(texture_bmp_data6);
            
            build3D();
        }

        private function build3D() : void {
            
            viewport = new Viewport3D(0, 0, true, true);
            addChild(viewport);
                                    
            renderer = new BasicRenderEngine();
                                    
            scene = new Scene3D();
            
            var frontmat : BitmapMaterial = new BitmapMaterial(targetTexture1);
            frontmat.interactive = true;    
            frontmat.name = "1";
            
            var backmat : BitmapMaterial = new BitmapMaterial(targetTexture2);
            backmat.interactive = true;    
            backmat.name = "2";
            
            var leftmat : BitmapMaterial = new BitmapMaterial(targetTexture3);
            leftmat.interactive = true;
            leftmat.name = "3";
            
            var rightmat : BitmapMaterial = new BitmapMaterial(targetTexture4);
            rightmat.interactive = true;    
            rightmat.name = "4";
            
            var topmat : BitmapMaterial = new BitmapMaterial(targetTexture5);
            topmat.interactive = true;    
            topmat.name = "5";
            
            var bottommat : BitmapMaterial = new BitmapMaterial(targetTexture6);
            bottommat.interactive = true;
            bottommat.name = "6";
            
            cube = new Cube(new MaterialsList({front:frontmat, back:backmat, left:leftmat, right:rightmat, top:topmat, bottom:bottommat}), 200, 200, 200, 5, 5, 5);
            
            camera.zoom = 11;
            camera.focus = 100;      
            
            this.stage.addEventListener(MouseEvent.MOUSE_DOWN, onMouseDown);
            
            container = new DisplayObject3D();
            container.addChild(cube, "cube");
         
            scene.addChild(container);
            singleRender();
        }

        private function onMouseDown( event : Event ) : void {
            this.startRendering();
            previousMousePoint = new Point(viewport.containerSprite.mouseX, viewport.containerSprite.mouseY);
            this.stage.addEventListener(MouseEvent.MOUSE_MOVE, onMouseMove);
            this.stage.addEventListener(MouseEvent.MOUSE_UP, onMouseUp);
        }

        private function onMouseUp( event : Event ) : void {
            //this.stopRendering();
            this.stage.removeEventListener(MouseEvent.MOUSE_MOVE, onMouseMove);
            this.stage.removeEventListener(MouseEvent.MOUSE_UP, onMouseUp);
            
            trace(container.rotationX, container.rotationY, container.rotationZ); 
            
            //container.lookAt(camera, new Number3D(0,90,0));
            //container.lookAt(camera);
        
            //side1 180 0 180
            //side2 0 0 0
            //side3 -180 -90 180
            //side4 180 90 180
            //side5 90 0 0
            //side6 90 0 180
            
        }

        private function onMouseMove( event : Event ) : void {  
            var currentMousePoint : Point = new Point(viewport.containerSprite.mouseX, viewport.containerSprite.mouseY);
    
            var difference : Point = currentMousePoint.subtract(previousMousePoint);
            var vector : Number3D = new Number3D(difference.x, difference.y, 0);
    
            var rotationAxis : Number3D = Number3D.cross(vector, FORWARD);
            rotationAxis.normalize();
    
            var distance : Number = Point.distance(currentMousePoint, previousMousePoint);
            var rotationMatrix : Matrix3D = Matrix3D.rotationMatrix(rotationAxis.x, -rotationAxis.y, rotationAxis.z, distance*2 / (600 * Math.pow(container.scale, 5)));
    
            container.transform.calculateMultiply3x3(rotationMatrix, container.transform);
            container.copyTransform(container);
         
            previousMousePoint = currentMousePoint;
        }
        
    }
} 


[joeydee]

Grundsätzlich löst man so etwas, indem man das Punktprodukt von Flächennormale und Richtung zur Kamera für jede Fläche bildet. Genau wie bei der Beleuchtung (die Kamera entspricht dabei dem Licht): Der größte Wert schaut dann am ehesten zur Kamera (wird am hellsten beleuchtet), negative Werte schauen von der Kamera weg (werden gar nicht beleuchtet).

Wenn es sich nur um einen Würfel handelt und die Kamera entlang einer Weltachse positioniert ist (z.B. v=(0,0,1)) ist es noch einfacher: die Flächennormalen stecken bereits in der aktuellen Rotationsmatrix, und beim Punktprodukt mit (0,0,1) bleibt nur jeweils der Z-Wert der Normalen übrig. Alles was man tun muss ist also die Z-Werte der drei Achsen sowie die negierten Z-Werte für die jeweils gegenüberliegende Seite zu vergleichen und den größten Wert aus diesen 6 finden - das ist dann die Seite die zur Kamera schaut.

private function onMouseUp( event : Event ) : void {
            //this.stopRendering();
            this.stage.removeEventListener(MouseEvent.MOUSE_MOVE, onMouseMove);
            this.stage.removeEventListener(MouseEvent.MOUSE_UP, onMouseUp);
            
            
            // ----- new -----
            
            //Skalarprodukte der einzelnen Oberflächennormalen mit der Kameraposition
            var s=new Array();
            s[1]=-container.transform.n33;
            s[2]=container.transform.n33;
            s[3]=container.transform.n31;
            s[4]=-container.transform.n31;
            s[5]=-container.transform.n32;
            s[6]=container.transform.n32;
            
            //Maximum finden
            var max=0;
            var side=0;
            for(var i=1;i<=6;i++){
                if(s[i]>max){
                    max=s[i];
                    side=i;
                    }
                }
                
            //gefundene Seite ausgeben
            trace(side);
    
            
            // ----- /new -----
            
            
            //trace(container.rotationX, container.rotationY, container.rotationZ); 
            
            //container.lookAt(camera, new Number3D(0,90,0));
            //container.lookAt(camera);
        
            //side1 180 0 180
            //side2 0 0 0
            //side3 -180 -90 180
            //side4 180 90 180
            //side5 90 0 0
            //side6 90 0 180
            
        } 

[Nikolai]

Toll

und danke für das BSP denn rein mit der Erklärung wäre ich glaube ich noch überfordert gewesen. 1a

[Nikolai]

Holla nochmal joeydee

eine Frage noch - ich bin mit der Matrix3D noch garnicht warm geworden...
Wenn ich nun den Würfel bzw. Container nach dem ich weiss welche Seite vorne ist auf eine feste rotationX, rotationY, rotationZ Position setzen möchte klappt das nicht mehr (sicher weil ich ja mit der Matrix rotiere).

Wie würdest du da ran gehen?
Habe vorher nur die rotationX (Y, Z) Werte bearbeitet und da war es logischerweise kein Problem dorthin zu tweenen...

Danke

[joeydee]

Mit Euler-Winkeln (das sind die Rotationswinkel der Achsen) ist das nicht ganz trivial zu lösen, da es u.a. mehrere Möglichkeiten und "Totpunkte" (Gimbal Lock) geben kann.
Die mathematisch beste Lösung ist wohl über Quaternions (in diesem Fall sozusagen ein mathematischer Ersatz zur Matrix als Lagebeschreibung eines Objekts), da kann man die Werte leichter interpolieren um von einer Lage in die andere zu drehen. Glücklicherweise unterstützt Papervision das :-)

Normalerweise biete ich ungern Komplettlösungen ohne dass der Nutzer versteht was da passiert, aber hier gehts leider nicht anders, Glück gehabt ;-)

Überall wo // ----- new ----- steht hat sich was geändert: Einbinden der Quaternion-Klasse und 3 private Vars im Header, der vorher gepostete Code natürlich, sowie eine zusätzliche Funktion zum Tweenen für den Enter-Frame-Listener.

Wenn du verstehst dass eine Matrix ein mathematisches Konstrukt zur allgemeinen Lagebeschreibung ist, und ein Quaternion ein Ersatz dafür sein kann, und dass Papervision gewisse Funktionen bietet beide ineinander umzurechnen, dann solltest du im Groben verstehen was da nun passiert (nächster Post, da zu lang)

[joeydee]

package {
    import br.com.stimuli.loading.BulkLoader;
    import br.com.stimuli.loading.BulkProgressEvent;
    
    import org.papervision3d.core.math.Matrix3D;
    import org.papervision3d.core.math.Quaternion;  // ----- new -----
    import org.papervision3d.core.math.Number3D;
    import org.papervision3d.core.proto.CameraObject3D;
    import org.papervision3d.core.proto.MaterialObject3D;
    import org.papervision3d.materials.*;
    import org.papervision3d.materials.utils.*;
    import org.papervision3d.objects.*;
    import org.papervision3d.objects.primitives.*;
    import org.papervision3d.render.*;
    import org.papervision3d.scenes.*;
    import org.papervision3d.view.*;
    
    import flash.display.Bitmap;
    import flash.display.BitmapData;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.geom.Point;    
 
    /**
     *    @author    Nikolai
     *    @date      10:42:26 06.08.2009
     */
    public class CubeRotator extends BasicView {
 
        private var cube : Cube;
 
        private var texture_bmp_data1 : BitmapData;
        private var texture_bmp_data2 : BitmapData;
        private var texture_bmp_data3 : BitmapData;
        private var texture_bmp_data4 : BitmapData;
        private var texture_bmp_data5 : BitmapData;
        private var texture_bmp_data6 : BitmapData;
 
        private var targetTexture1 : BitmapData;
        private var targetTexture2 : BitmapData;
        private var targetTexture3 : BitmapData;
        private var targetTexture4 : BitmapData;
        private var targetTexture5 : BitmapData;
        private var targetTexture6 : BitmapData;
 
        private var loader : BulkLoader;
 
        private var textureImage : Class;
        private var container : DisplayObject3D;
 
        private var previousMousePoint : Point = new Point();
        private static const FORWARD : Number3D = new Number3D(0, 0, 1);
        
        // ----- new -----
        private var isQuat:Quaternion;
        private var shallQuat:Quaternion;
        private var tweenTime:Number;
        
        public function CubeRotator() {
            trace("myClass");
            addEventListener(Event.ADDED_TO_STAGE, onAddedToStage);
        }
 
        private function onAddedToStage(event : Event) : void {
 
            loader = new BulkLoader("cube");
            loader.logLevel = BulkLoader.LOG_INFO;
            loader.add("1.jpg", {id:"1"});
            loader.add("2.jpg", {id:"2"});
            loader.add("3.jpg", {id:"3"});
            loader.add("4.jpg", {id:"4"});
            loader.add("5.jpg", {id:"5"});
            loader.add("6.jpg", {id:"6"});
            loader.addEventListener(BulkLoader.COMPLETE, onAllItemsLoaded);
            loader.addEventListener(BulkLoader.PROGRESS, onAllItemsProgress);
            
            loader.start();
        }
 
        private function onAllItemsProgress(event : BulkProgressEvent) : void {
            trace(event.loadingStatus());
        }
 
        
        private function onAllItemsLoaded(event : Event) : void {
            
            var bitmap1 : Bitmap = loader.getBitmap("1");
            var bitmap2 : Bitmap = loader.getBitmap("2");
            var bitmap3 : Bitmap = loader.getBitmap("3");
            var bitmap4 : Bitmap = loader.getBitmap("4");
            var bitmap5 : Bitmap = loader.getBitmap("5");
            var bitmap6 : Bitmap = loader.getBitmap("6");
            
            texture_bmp_data1 = bitmap1.bitmapData;
            texture_bmp_data2 = bitmap2.bitmapData;
            texture_bmp_data3 = bitmap3.bitmapData;
            texture_bmp_data4 = bitmap4.bitmapData;
            texture_bmp_data5 = bitmap5.bitmapData;
            texture_bmp_data6 = bitmap6.bitmapData;
            
            targetTexture1 = new BitmapData(200, 200, false, 0xffffff);
            targetTexture1.draw(texture_bmp_data1);
            targetTexture2 = new BitmapData(200, 200, false, 0xffffff);
            targetTexture2.draw(texture_bmp_data2);
            targetTexture3 = new BitmapData(200, 200, false, 0xffffff);
            targetTexture3.draw(texture_bmp_data3);
            targetTexture4 = new BitmapData(200, 200, false, 0xffffff);
            targetTexture4.draw(texture_bmp_data4);
            targetTexture5 = new BitmapData(200, 200, false, 0xffffff);
            targetTexture5.draw(texture_bmp_data5);
            targetTexture6 = new BitmapData(200, 200, false, 0xffffff);
            targetTexture6.draw(texture_bmp_data6);
            
            build3D();
        }
 
        private function build3D() : void {
            
            viewport = new Viewport3D(0, 0, true, true);
            addChild(viewport);
                                    
            renderer = new BasicRenderEngine();
                                    
            scene = new Scene3D();
            
            var frontmat : BitmapMaterial = new BitmapMaterial(targetTexture1);
            frontmat.interactive = true;    
            frontmat.name = "1";
            
            var backmat : BitmapMaterial = new BitmapMaterial(targetTexture2);
            backmat.interactive = true; 
            backmat.name = "2";
            
            var leftmat : BitmapMaterial = new BitmapMaterial(targetTexture3);
            leftmat.interactive = true;
            leftmat.name = "3";
            
            var rightmat : BitmapMaterial = new BitmapMaterial(targetTexture4);
            rightmat.interactive = true;    
            rightmat.name = "4";
            
            var topmat : BitmapMaterial = new BitmapMaterial(targetTexture5);
            topmat.interactive = true;  
            topmat.name = "5";
            
            var bottommat : BitmapMaterial = new BitmapMaterial(targetTexture6);
            bottommat.interactive = true;
            bottommat.name = "6";
            
            cube = new Cube(new MaterialsList({front:frontmat, back:backmat, left:leftmat, right:rightmat, top:topmat, bottom:bottommat}), 200, 200, 200, 5, 5, 5);
            
            camera.zoom = 11;
            camera.focus = 100;      
            
            this.stage.addEventListener(MouseEvent.MOUSE_DOWN, onMouseDown);
            
            container = new DisplayObject3D();
            container.addChild(cube, "cube");
         
            scene.addChild(container);
            singleRender();
        }
 
        private function onMouseDown( event : Event ) : void {
            this.startRendering();
            previousMousePoint = new Point(viewport.containerSprite.mouseX, viewport.containerSprite.mouseY);
            this.stage.addEventListener(MouseEvent.MOUSE_MOVE, onMouseMove);
            this.stage.addEventListener(MouseEvent.MOUSE_UP, onMouseUp);
        }
 
        private function onMouseUp( event : Event ) : void {
            //this.stopRendering();
            this.stage.removeEventListener(MouseEvent.MOUSE_MOVE, onMouseMove);
            this.stage.removeEventListener(MouseEvent.MOUSE_UP, onMouseUp);
            
            
            // ----- new -----
            
            //Skalarprodukte der einzelnen Oberflächennormalen mit der Kameraposition
            var s=new Array();
            s[1]=-container.transform.n33;
            s[2]=container.transform.n33;
            s[3]=container.transform.n31;
            s[4]=-container.transform.n31;
            s[5]=-container.transform.n32;
            s[6]=container.transform.n32;
            
            //Soll-Positionen als Quaternions
            var quaternionPos=new Array();
            quaternionPos[0]=new Quaternion();//Einheits-Quaternion, falls Maximum-Test weiter unten fehlschlägt
            quaternionPos[1]=Quaternion.createFromEuler(180,0,0,true);
            quaternionPos[2]=Quaternion.createFromEuler(0,0,0,true);
            quaternionPos[3]=Quaternion.createFromEuler(-90,0,0,true);
            quaternionPos[4]=Quaternion.createFromEuler(90,0,0,true);
            quaternionPos[5]=Quaternion.createFromEuler(0,0,-90,true);
            quaternionPos[6]=Quaternion.createFromEuler(0,180,90,true);
 
 
            //Maximum finden
            var max=0;
            var side=0;
            for(var i=1;i<=6;i++){
                if(s[i]>max){
                    max=s[i];
                    side=i;
                    }
                }
                
            //Debug only: gefundene Seite ausgeben
            //trace(side);
    
            isQuat=Quaternion.createFromMatrix(container.transform);    //Quaternion aus aktueller Matrix
            shallQuat=quaternionPos[side]; //Soll-Position als Quaternion aus der Liste
            
            //Tween zwischen isQuat und shallQuat starten
            tweenTime=0; 
            this.addEventListener(Event.ENTER_FRAME,tweenToPos);
            
            // ----- /new -----
            
            
            //trace(container.rotationX, container.rotationY, container.rotationZ); 
            
            //container.lookAt(camera, new Number3D(0,90,0));
            //container.lookAt(camera);
        
            //side1 180 0 180
            //side2 0 0 0
            //side3 -180 -90 180
            //side4 180 90 180
            //side5 90 0 0
            //side6 90 0 180
            
        }
        
        
        // ----- new -----
        // Rotation tweenen
        private function tweenToPos(event:Event){
            //time läuft von 0 bis 1;
            tweenTime+=0.1;
            if(tweenTime>1){
                this.removeEventListener(Event.ENTER_FRAME,tweenToPos); //Listener beenden
                container.transform=shallQuat.matrix; //Endposition zuweisen
                tweenTime=0;
                }
            else{
                var tweenQuat:Quaternion=Quaternion.slerp(isQuat,shallQuat,tweenTime); //aktuelle Tween-Position
                container.transform=tweenQuat.matrix; //Rotation zuweisen
                }
            }
 
        private function onMouseMove( event : Event ) : void {  
            var currentMousePoint : Point = new Point(viewport.containerSprite.mouseX, viewport.containerSprite.mouseY);
    
            var difference : Point = currentMousePoint.subtract(previousMousePoint);
            var vector : Number3D = new Number3D(difference.x, difference.y, 0);
    
            var rotationAxis : Number3D = Number3D.cross(vector, FORWARD);
            rotationAxis.normalize();
    
            var distance : Number = Point.distance(currentMousePoint, previousMousePoint);
            var rotationMatrix : Matrix3D = Matrix3D.rotationMatrix(rotationAxis.x, -rotationAxis.y, rotationAxis.z, distance*2 / (600 * Math.pow(container.scale, 5)));
    
            container.transform.calculateMultiply3x3(rotationMatrix, container.transform);
            container.copyTransform(container);
         
            previousMousePoint = currentMousePoint;
        }
        
    }
} 

[Nikolai]

Moin nochmal

danke für die Komplettlösung - ich denke das ich nach ein wenig rumspielen dazu in der Lage bin es besser zu begreifen.

Wirklich einen dicken Dank dafür - solltest du dich in der nähe von HH rumtreiben (oder auf der nächsten FFK) lass ich gerne ein paar Biere springen

[brainski]

Hallo joeydee!

Erstmals vielen Dank für dein Beispiel. Es hat mir geholfen, zu verstehen, wie ich meinen eigenen Würfel bauen muss.

Leider habe ich nun eine Schwierigkeit, die ich einfach nicht hinkriege.

Mein Würfel rotiert, wenn man mit der Maus ausserhalb des Flashfilms ist. D.h. die Rotationsachsen y,z verändern sich ständig. Wenn man auf den Würfel fährt wird die Rotation unterbrochen.

Wenn ich nun versuche, anaolg zu deinem Beispiel eine Transformation zu machen, dann wird der Würfel zwar rotiert jedoch werden die Rotationsachsen nicht auf 0 gestellt und der Würfel liegt schrägt im Bild.

Wie schaffe ich es, dass ich einen rotierenden Würfel wieder perfekt ausgerichtet hinbekomme?

Neuer Eventhandler im build3D();

addEventListener( Event.ENTER_FRAME, rotateObject );
this.stage.addEventListener( MouseEvent.MOUSE_OVER, onMouseOver);

//Roation tweening

		private function rotateObject( e:Event ):void {

			if (tweening) {

				cube.rotationY += 2;
				cube.rotationZ += 2;

				if (cube.rotationY >= 180) {
					cube.rotationY = -180;
				}
				if (cube.rotationZ >= 180) {
					cube.rotationZ = -180;
				}
				renderer.renderScene( scene, camera, viewport );
			}
		}

		private function onMouseOver( event : Event ):void {
			tweening = false;
		}

Für einen Tipp wäre ich unendlich dankbar!

[joeydee]

Eigentlich sollte das eine absolute Endposition sein, egal wie der Würfel vorher gedreht ist. Fehlersuche würde ich so anfangen: was passiert denn wenn du nach einigem Drehen statt dem Tween die Einheitsmatrix direkt zuweist (container.transform=new Matrix3D()) - ist er dann auch schräg?

[brainski]

Hallo joeydee

Danke für Deinen Vorschlag. Leider habe ich damit nichts herausfinden können. Anstelle des Tweens habe ich die Einheitsmatrix zugewiesen wie du vorschlägst.

Das Resultat ist dann ein Würfel, der immer auf eine Art schräg liegt.

Ich habe noch versucht, die Achsen auf 0 zusetzen bevor ich den Tween zum shallQUat starte. Dann funnktioniert es zwar, für den Benutzer ist es jedoch unbrauchbar weil der Würfel sich beim Zurücksetzen der Achse irgendwie verdreht und nicht die von der Maus ausgewählte Seite vorne ist.

Hast Du mir noch einen Tipp. Ich bin wirklich ratlos.

[joeydee]

Finde heraus, warum der Würfel trotz Einheitsmatrix verdreht dargestellt wird. Evtl. hast du die Kamera verdreht oder der Würfel liegt in einem Container, welcher verdreht ist.

[brainski]

Hallo joeydee

Danke für die beiden Inputs. Ich habe diese geprüft und gemerkt, dass ich den cube rotiert habe und nicht den container und deshalb die Transformation nicht funktionierte. Ich DANKE DIR für Deine Hilfe!!