Flash 3D 基础

1、设置消失点

      在3D中，消失点是所有物体远离时的聚集点。

在 Flash 10 里，每个显示元素可以有一个 perspectiveProjection 去指定控制怎么去渲染 3D。它指定的是 transform 的 perspectiveProjection 属性。所以，假如有一个名叫 s的 sprite,你可以这样去访问: 

s.transform.perspectiveProjection 

PerspectiveProjection 类有一个 projectionCenter属性是 Point 类的实例。这就是通常所说的消失点。因此，去设置显示元素的中心就可以像下面这样： 

s.transform.perspectiveProjection.projectionCenter=new Point(stage.stageWidth / 2, 

stage.stageHeight / 2);

这样只能设置一个 object 的消失点。当然这样就可以为这个元件的所有子元素设置消失点。

如果你想为影片中的所有元素设置消失点，可以在 root 上设置，像这样： 

root.transform.perspectiveProjection.projectionCenter=new Point(stage.stageWidth / 2,  stage.stageHeight / 2);

 

2、景深排序

    在同一个容器中任何用 addChild 方法添加到显示列表中的对象会显示在以前的对象的前面。唯一能够改变这种情况的途径是一些操作显示列表的方法，比如addChild,addChildAt,swapChildren,removeChild 等等。因为显示容器里没有排序方法，所以所有的景深排序工作都需要手动完成。

 

3、3D 容器

     显示对象的容器会在他们被改变的时候改变他们的子对象。换句话说，当你往一个 sprite
里添加一些显示对象并且移动它的容器的时候，它并不是简单地把窗口展平然后作为一个独立的对
象在 3D 空间里移动。它实际上改变每个子对象以使它们看起来是在 3D 空间里独立运动。

 

package
{
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.events.Event;
    import flash.text.TextField;
    import flash.text.TextFormat;
    
    public class Container3D extends Sprite
    {
        private var _sprite:Sprite;
        private var _n:Number = 0;
        
        public function Container3D()
        {
            stage.align = StageAlign.TOP_LEFT;
            stage.scaleMode = StageScaleMode.NO_SCALE;
            
           _sprite = new Sprite();
           _sprite.y = stage.stageHeight / 2;
           
           for( var i:int = 0; i < 100; i++ )
           {
               var tf:TextField = new TextField();
               tf.defaultTextFormat = new TextFormat( "Arial", 40 );
               tf.text = String.fromCharCode( 65 + Math.floor( Math.random()* 25 ) );
               tf.selectable = false;
               
               tf.x = Math.random() * 300 -150;
               tf.y = Math.random() * 300 -150;
               tf.z = Math.random() * 1000;
               
               _sprite.addChild( tf );               
           }
           
           addChild( _sprite );
           addEventListener( Event.ENTER_FRAME, onEnterFrame );
        }
        
        protected function onEnterFrame(event:Event):void
        {
            _sprite.x = stage.stageWidth / 2 + Math.cos(_n) * 200;
            _n += .05;
        }
    }
}

 

4、3D旋转

     在3D空间中，可以绕X、Y、 Z坐标轴旋转任何对象。

 

    可以通过 deltaTransformVector()方法来转换对象的坐标系，使在不同坐标系里的对象处于同一坐标系。

    如：

    var posA:Vector3D = objA.transform.matrix3D.position;
    posA = container.transform.matrix3D.deltaTransformVector( posA );

     在转换坐标系时，一定要确保容器 container 对象有3D属性，可以通过container.z = 0, container.rotationX等来设置。

    不然的话，container.transform.matrix3D 返回的将是 null。

package
{
    import flash.display.Shape;
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.events.Event;
    import flash.geom.Vector3D;
    
    [SWF(width="600", height="600")]
    public class RotateAndPosition extends Sprite
    {
        private var _holder:Sprite;
        private var _shapes:Array = [];
        
        public function RotateAndPosition()
        {
            stage.align = StageAlign.TOP_LEFT;
            stage.scaleMode = StageScaleMode.NO_SCALE;
            
            _holder = new Sprite();
            _holder.x = stage.stageWidth / 2;
            _holder.y = stage.stageHeight /2;
            _holder.z = 0;
            addChild( _holder );
            
            var shape1:Shape = makeShape();
            //shape1.x = 200;
            shape1.z = 200;
            _holder.addChild( shape1 );
            _shapes.push( shape1 );
            
            var shape2:Shape = makeShape();
            //shape2.x = 200;
            shape2.z = -200;
            _holder.addChild( shape2 );
            _shapes.push( shape2 );
            
            var shape3:Shape = makeShape();
            shape3.x = 200;
            //shape3.z = -200;
            shape3.rotationY = 90;
            _holder.addChild( shape3 );
            _shapes.push( shape3 );
            
            var shape4:Shape = makeShape();
            shape4.x = -200;
            //shape4.z = -200;
            shape4.rotationY = -90;
            _holder.addChild( shape4 );
            _shapes.push( shape4 );
            
            var shape5:Shape = makeShape();
            //shape2.x = 200;
            //shape5.z = -200;
            shape5.y = 200;
            shape5.rotationX = 90;;
            _holder.addChild( shape5 );
            _shapes.push( shape5 );
            
            var shape6:Shape = makeShape();
            //shape2.x = 200;
            //shape6.z = -200;
            shape6.y = -200;
            shape6.rotationX = -90;
            _holder.addChild( shape6 );
            _shapes.push( shape6 );
            
            sortShape();
            
            addEventListener( Event.ENTER_FRAME, onEnterFrame );
            
        }
        
        private function sortShape():void
        {
            _shapes.sort( depthSort );
            for( var i:int = 0; i < _shapes.length; i++ )
            {
                _holder.addChildAt( _shapes[i] as Shape, i );
            }
        }
        
        /**
         *  将局部坐标系转换为世界坐标系
         * @param objA
         * @param objB
         * @return 
         * 
         */        
        private function depthSort(objA:Object, objB:Object):int
        {
            var posA:Vector3D = objA.transform.matrix3D.position;
            posA = _holder.transform.matrix3D.deltaTransformVector( posA );
            var posB:Vector3D = objB.transform.matrix3D.position;
            posB = _holder.transform.matrix3D.deltaTransformVector( posB );
            return posB.z - posA.z;
        }
        
        /**
         * 创建Shape 
         * @return 
         * 
         */        
        private function makeShape():Shape
        {
            var shape:Shape = new Shape();
            shape.graphics.beginFill( 0xffffff * Math.random() );
            shape.graphics.drawRect( -100, -100, 200, 200 );
            shape.graphics.endFill();
            return shape;
        }
        
        protected function onEnterFrame(event:Event):void
        {
            _holder.rotationY += 2;
            _holder.rotationX += 1.5;
            
            sortShape();
        }
    }
}

 

package
{
    import flash.display.DisplayObject;
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.events.Event;
    import flash.geom.Vector3D;
    
    [SWF(width="800", height="800", backgroundColor="0xffffff")]
    public class Carousel extends Sprite
    {
        private var _holder:Sprite;
        private var _itemsNum:int = 5;
        private var _items:Array = [];
        private var radius:Number = 200;
        
        
        public function Carousel()
        {
            stage.align = StageAlign.TOP_LEFT;
            stage.scaleMode = StageScaleMode.NO_SCALE;
            
            _holder = new Sprite();
            _holder.x = stage.stageWidth / 2;
            _holder.y = stage.stageHeight /2;
            _holder.z = 0;
            addChild( _holder );
            
            for( var i:int = 0; i < _itemsNum; i++ )
            {
                var angel:Number = 2 * Math.PI / _itemsNum * i;
                var item:Sprite = makeItem();
                item.x = Math.cos( angel ) * radius;
                item.z = Math.sin( angel ) * radius;
                item.rotationY = -360 / _itemsNum * i + 90;
                //_holder.addChild( item );
                _items.push( item );        
            }
            
            sortItem();
            
            addEventListener( Event.ENTER_FRAME, onEnterFrame );
        }
        
        protected function onEnterFrame(event:Event):void
        {
            var speedX:Number = ( stage.stageWidth / 2 - mouseX ) * 0.05;
            //_holder.rotationY += ( stage.stageWidth / 2 - mouseX ) * 0.1;
            if( speedX > 5 )
            {
                _holder.rotationY += 5;
            }
            else if( speedX < -5 )
            {
                _holder.rotationY += -5;
            }
            else
            {
                _holder.rotationY += speedX;
            }
                        
            
            _holder.y += ( mouseY - _holder.y ) * 0.1;
            sortItem();
        }
        
        private function sortItem():void
        {
            _items.sort( depthSort );
            
            for( var i:int = 0; i < _items.length; i++ )
            {
                _holder.addChildAt( _items[i] as Sprite, i );
            }
        }
        
        private function depthSort(objA:DisplayObject, objB:DisplayObject):int
        {
            var posA:Vector3D = objA.transform.matrix3D.position;
            posA = _holder.transform.matrix3D.deltaTransformVector( posA );
            var posB:Vector3D = objB.transform.matrix3D.position;
            posB = _holder.transform.matrix3D.deltaTransformVector( posB );
            
            return posB.z - posA.z;
        }
        
        /**
         * 创建图形 
         * @return 
         * 
         */        
        private function makeItem():Sprite
        {
            var item:Sprite = new Sprite();
            item.graphics.beginFill( 0xffffff * Math.random() );
            item.graphics.drawRect( -100, -100, 200, 200 );
            item.graphics.endFill();
            return item;
        }
    }
}

5、视野与焦距

          焦距和视野联系很紧密并且都决定着物体看起来应该缩放和扭曲多少。

    在Flash 3D中，你可以通过设置焦距或视野来控制扭曲。实际上，设置了一个另外一个会跟着改变。但你要选择一个你感觉最舒服的去用。这个工作需要设置显示对象的

transform 属性的perspectiveProjection 属性：focalLength 和 fieldOfView。通常地，最好在你的 movie 的根目录设置这些属性，除非你的容器有一

特殊的要求或者对象有特殊的属性（比如在不同的窗口中看对象）。

视野需要用度数进行度量，并且需要大于 0 小于 180，否则将出现错误。

 如： 

      视野： root.transform.perspectiveProjection.fieldOfView = 100;
      焦距： root.transform.perspectiveProjection.focalLength = 1000;

 

6、屏幕坐标系和 3D 坐标系

      local3DtoGlobal：一个 3D 空间中的点转换为相对应的屏幕坐标。从 flash.geom.Vector3D 转 换 成 一 个 2Dflash.geom.Point 对象。

      globalToLocal3D： 屏幕上的坐标转换为指定3D空间中的点。

package
{
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.events.Event;
    import flash.geom.Point;
    import flash.geom.Vector3D;

    [SWF(width="800", height="800")]
    public class localGlobal extends Sprite
    {
        private var _sprite:Sprite;
        private var _tracker:Sprite;
        private var _angle:Number = 0;
        
        public function localGlobal()
        {
            if( stage )
            {
                init();
            }
            else
            {
                addEventListener( Event.ADDED_TO_STAGE, init );
            }
        }
        
        private function init():void
        {
            if( hasEventListener( Event.ADDED_TO_STAGE ) )
            {
                removeEventListener( Event.ADDED_TO_STAGE, init );
            }
            
            stage.align = StageAlign.TOP_LEFT;
            stage.scaleMode = StageScaleMode.NO_SCALE;
            
            _sprite = new Sprite();
            _sprite.graphics.lineStyle( 10 );
            _sprite.graphics.lineTo( 200, 0 );
            _sprite.graphics.drawCircle( 200, 0, 10 );
            _sprite.graphics.endFill();
            _sprite.x = 400;
            _sprite.y = 400;
            addChild( _sprite );
            
            _tracker = new Sprite();
            _tracker.graphics.lineStyle( 2, 0xff0000 );
            _tracker.graphics.drawCircle( 0, 0, 20 );
            _tracker.graphics.endFill();
            addChild( _tracker );
            
            addEventListener( Event.ENTER_FRAME, onEnterFrame );
            
            
        }
        
        protected function onEnterFrame(event:Event):void
        {
            _sprite.rotationX = 0.1;
            _sprite.rotationY += 1.2;
            _sprite.rotationZ += 0.5;
            //_sprite.x = 400 + Math.cos( _angle ) * 100;
            //_sprite.y = 400 + Math.sin( _angle ) * 100;
            //_sprite.z = 200 + Math.cos( _angle * 0.8 ) * 400;
            _angle += 0.5;
            
            // 把_sprite里3D空间的点转换为2D的坐标
            var p:Point = _sprite.local3DToGlobal( new Vector3D( 200, 0, 0 ) );
            _tracker.x = p.x;
            _tracker.y = p.y;
        }
    }
}

 

package
{
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.events.Event;
    import flash.geom.Point;
    import flash.geom.Vector3D;
    
    [SWF(width="800", height="800")]
    public class GlobalLocal extends Sprite
    {
        private var _sprite:Sprite;
        private var _tracker:Sprite;
        
        public function GlobalLocal()
        {
            stage.align = StageAlign.TOP_LEFT;
            stage.scaleMode = StageScaleMode.NO_SCALE;
            
            _sprite = new Sprite();
            _sprite.graphics.lineStyle( 10 );
            _sprite.graphics.drawRect( -200, -200, 400, 400 );
            _sprite.graphics.endFill();
            _sprite.x = 400;
            _sprite.y = 400;
            addChild( _sprite );
            
            _tracker = new Sprite();
            _tracker.graphics.lineStyle( 2, 0xff0000 );
            _tracker.graphics.drawCircle( 0, 0, 20 );
            _tracker.graphics.endFill();
            _sprite.addChild( _tracker );
            
            addEventListener( Event.ENTER_FRAME, onEnterFrame );
        }
        
        protected function onEnterFrame(event:Event):void
        {
            _sprite.rotationX = 0.1;
            _sprite.rotationY += 1.2;
            //_sprite.rotationZ += 0.5;
            //_sprite.x = 400 + Math.cos( _angle ) * 100;
            //_sprite.y = 400 + Math.sin( _angle ) * 100;
            //_sprite.z = 200 + Math.cos( _angle * 0.8 ) * 400;
            //_angle += 0.5;
            
            // 把_sprite里3D空间的点转换为2D的坐标
            //var p:Point = _sprite.local3DToGlobal( new Vector3D( 200, 0, 0 ) );
            
            /*var p:Vector3D = _sprite.globalToLocal3D( new Point( mouseX, mouseY ) );
            _tracker.x = p.x;
            _tracker.y = p.y;*/
            _tracker.x = _sprite.mouseX;
            _tracker.y = _sprite.mouseY;
        }
        
    }
}

  如果要存取一个在3D空间里改变的对象的mouseX和mouseY参数时，世界坐标到局部坐标的3D转换会自动进行。 

   要注意的是，这只是在转鼠标坐标时才有用。如果想要转换一个在舞台上的对象到3D坐标系，那么仍然需要使用转换函数。

/*var p:Vector3D = _sprite.globalToLocal3D( new Point( mouseX, mouseY ) );

_tracker.x = p.x;

_tracker.y = p.y;*/

_tracker.x = _sprite.mouseX;

_tracker.y = _sprite.mouseY;

 

7、指向某物

       pointAt 方法接收一个 Vector3D 对象作为指向的目标。如果这个函数是被显示对象的 transform 属性的 Matrix3D 对象调用，

   它会在 3D 空间中旋转那个显示对象使它指向一个特殊的区域。

package
{
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.geom.Vector3D;
    
    [SWF(width="800", height="800")]
    public class FollowMouse3D extends Sprite
    {
        private var _sprite:Sprite;
        private var _angleX:Number = 0;
        private var _angleY:Number = 0;
        private var _angleZ:Number = 0;
        
        public function FollowMouse3D()
        {
            _sprite = new Sprite();
            _sprite.x = 400;
            _sprite.y = 400;
            _sprite.z = 200;
            _sprite.graphics.beginFill( 0xff0000 );
            _sprite.graphics.moveTo( 0, 50 );
            _sprite.graphics.lineTo( -25, 25 );
            _sprite.graphics.lineTo( -10, 25 );
            _sprite.graphics.lineTo( -10, -50 );
            _sprite.graphics.lineTo( 10, -50 );
            _sprite.graphics.lineTo( 10, 25 );
            _sprite.graphics.lineTo( 25, 25 );
            _sprite.graphics.lineTo( 0, 50 );
            _sprite.graphics.endFill();
            addChild( _sprite ); 
            addEventListener(Event.ENTER_FRAME, onEnterFrame);
        }
        
        protected function onEnterFrame(event:Event):void
        {
            //_sprite.x = 400 + Math.sin( _angleX += 0.11 ) * 200;
            //_sprite.y = 400 + Math.sin( _angleY += 0.7 ) * 200;
            //_sprite.z = Math.sin( _angleZ += 0.09 ) * 200;
            _sprite.transform.matrix3D.pointAt( new Vector3D( mouseX, mouseY ) );
        }
    }
}