ऑब्जेक्ट को हमेशा कैमरे का सामना करने के लिए 3 डी में घुमावदार घुमावदार?

Question

मेरे पास 3 डी स्पेस में व्यवस्थित बहुत सारे sprites हैं, और उनके मूल कंटेनर में घूर्णन लागू होते हैं। मैं स्प्राइट्स 3 डी रोटेशन को कैसे उलट सकता हूं, कि वे हमेशा कैमरे (एक्शनस्क्रिप्ट 3) का सामना करते हैं?

यहाँ एक कोड यह परीक्षण करने के लिए:

package{ 
import flash.display.Sprite; 
import flash.events.Event; 
public class test extends Sprite{ 

var canvas:Sprite = new Sprite(); 
var sprites:Array = [] 

public function test(){ 
    addChild(canvas) 
    for (var i:int=0;i<20;i++){ 
     var sp:Sprite = new Sprite(); 
     canvas.addChild(sp); 
     sp.graphics.beginFill(0xFF0000); 
     sp.graphics.drawCircle(0,0,4); 
     sp.x = Math.random()*400-200; 
     sp.y = Math.random()*400-200; 
     sp.z = Math.random()*400-200; 
     sprites.push(sp); 
    } 
    addEventListener(Event.ENTER_FRAME,function():void{ 
     canvas.rotationX++; 
     canvas.rotationY = canvas.rotationY+Math.random()*2; 
     canvas.rotationZ++; 
     for (var i:int=0;i<20;i++){ 
      //this is not working... 
      sprites[i].rotationX = -canvas.rotationX 
      sprites[i].rotationY = -canvas.rotationY 
      sprites[i].rotationZ = -canvas.rotationZ 
     } 
    }) 
} 
} 
} 

मैं मैं स्प्राइट की rotation3D मैट्रिक्स के साथ कुछ जादू करने के लिए अनुमान लगा रहा है ... मैं इस स्क्रिप्ट को लागू करने की कोशिश की है: http://ughzoid.wordpress.com/2011/02/03/papervision3d-sprite3d/, लेकिन इतनी सफलता मिली
मदद के लिए धन्यवाद। इस किया जा रहा है एक सुझाव है, एक समाधान के लिए पहले से

Answer 1

सबसे आसान तरीका है "समाशोधन" को बदलने मैट्रिक्स की घूर्णन हिस्सा है। अपने ठेठ समरूप परिवर्तन इस

| xx xy xz xw | 
| yx yy yz yw | 
| zx zy zz zw | 
| wx wy wz ww | 

साथ wx = WY = WZ = 0, ww = 1.

तरह लग रहा है आप बारीकी से देखने के अगर आपको लगता है कि वास्तव में इस मैट्रिक्स एक 3x3 submatrix को परिभाषित करने से बना है देखेंगे रोटेशन, अनुवाद के लिए एक 3 subvector और एक समरूप पंक्ति 0 0 0 1

| R  T | 
| (0,0,0) 1 | 

एक बोर्ड/स्प्राइट आप अनुवाद रखने के लिए, लेकिन रोटेशन, यानी आर = मैं मामले कुछ में से छुटकारा पाने के लिए स्केलिंग लागू किया गया था पहचान पहचान को भी स्केल किया जाना चाहिए।

d = sqrt (xx² + yx² + zx²)

| d 0 0 T.x | 
| 0 d 0 T.y | 
| 0 0 d T.z | 
| 0 0 0 1 | 

लोड हो रहा है इस मैट्रिक्स आप कैमरे गठबंधन स्प्राइट आकर्षित करने के लिए अनुमति देता है:

यह निम्न recipie देता है।

Answer 2

क्षमा याचना:

अपने इरादे 3 डी गोलाकार रोटेशन अनुकरण है, तो आपके लिए सबसे आसान मार्ग 2.5 D एपीआई त्याग करने के लिए हो सकता है और केवल साधारण स्केलिंग और पाप/क्योंकि का उपयोग पोजीशनिंग के लिए गणना।

एक मजेदार जगह शुरू करने के लिए: http://www.reflektions.com/miniml/template_permalink.asp?id=329

Answer 3

मैं विकिपीडिया, मैट्रिक्स और काले जादू का उपयोग कर इसका समाधान कर लिया। मैं सभी वस्तुओं के घूर्णन को बदलने के बजाय कस्टम रोटेशन को लागू करना चुनता हूं। यहाँ कोड है, तो किसी का रुचि:

package{ 
import flash.display.Sprite; 
import flash.events.Event; 

public class test extends Sprite{ 

private var canvas:Sprite = new Sprite(); 
private var sprites:Array = [] 
private var rotx:Number=0,roty:Number=0,rotz:Number=0; 
private var mm:Matrix3 = new Matrix3(); 
public function test(){ 
    addChild(canvas); 
    canvas.x = canvas.y = 230 
    for (var i:int=0;i<30;i++){ 
     var sp:Sprite = new Sprite(); 
     canvas.addChild(sp); 
     sp.graphics.beginFill(0xFF0000); 
     sp.graphics.drawCircle(0,0,2); 
     sp.x = Math.random()*200-100; 
     sp.y = Math.random()*200-100; 
     sp.z = Math.random()*200-100; 
     sprites.push(sp); 
     rotx=0.06; //from top to bottom 
     //roty=0.1; //from right to left 
     rotz=0.1; //clockwise 
     mm.make3DTransformMatrix(rotx,roty,rotz); 
    } 
    addEventListener(Event.ENTER_FRAME,function():void{ 
     for (var i:int=0;i<sprites.length;i++){ 
      var s:Sprite = sprites[i]; 
      mm.rotateByAngles(s); 
     } 
    }) 
} 
} 
} 

और matrix3 वर्ग: यह करने के लिए

public class Matrix3{ 

    private var da:Vector.<Number>; // rows 

    public function make3DTransformMatrix(rotx:Number,roty:Number,rotz:Number):void{ 
     var cosx:Number = Math.cos(rotx); 
     var cosy:Number = Math.cos(roty); 
     var cosz:Number = Math.cos(rotz); 
     var sinx:Number = Math.sin(rotx); 
     var siny:Number = Math.sin(roty); 
     var sinz:Number = Math.sin(rotz); 
     da = new <Number>[ 
      cosy*cosz, -cosx*sinz+sinx*siny*cosz, sinx*sinz+cosx*siny*cosz, 
      cosy*sinz, cosx*cosz+sinx*siny*sinz , -sinx*cosz+cosx*siny*sinz, 
      -siny ,   sinx*cosy  ,  cosx*cosy   ]; 
    } 

    public function rotateByAngles(d:DisplayObject):void{ 
     var dx:Number,dy:Number,dz:Number; 
     dx = da[0]*d.x+da[1]*d.y+da[2]*d.z; 
     dy = da[3]*d.x+da[4]*d.y+da[5]*d.z; 
     dz = da[6]*d.x+da[7]*d.y+da[8]*d.z; 
     d.x = dx; 
     d.y = dy; 
     d.z = dz; 
    } 
} 
}