object3d.as

著名的flash 3d引擎 away 3d的源代码

package away3d.core.base
{
    import away3d.containers.*;
    import away3d.core.*;
    import away3d.core.draw.*;
    import away3d.core.math.*;
    import away3d.core.render.*;
    import away3d.core.traverse.*;
    import away3d.core.utils.*;
    import away3d.events.*;
    
    import flash.display.*;
    import flash.events.EventDispatcher;
    
	 /**
	 * Dispatched when the local transform matrix of the 3d object changes.
	 * 
	 * @eventType away3d.events.Object3DEvent
	 * @see	#transform
	 */
	[Event(name="transformchanged",type="away3d.events.Object3DEvent")]
	
	 /**
	 * Dispatched when the scene transform matrix of the 3d object changes.
	 * 
	 * @eventType away3d.events.Object3DEvent
	 * @see	#sceneTransform
	 */
	[Event(name="scenetransformchanged",type="away3d.events.Object3DEvent")]
			
	 /**
	 * Dispatched when the parent scene of the 3d object changes
	 * 
	 * @eventType away3d.events.Object3DEvent
	 * @see	#scene
	 */
	[Event(name="scenechanged",type="away3d.events.Object3DEvent")]
			
	 /**
	 * Dispatched when the bounding radius of the 3d object changes.
	 * 
	 * @eventType away3d.events.Object3DEvent
	 * @see	#radius
	 */
	[Event(name="radiuschanged",type="away3d.events.Object3DEvent")]
			
	 /**
	 * Dispatched when the bounding dimensions of the 3d object changes.
	 * 
	 * @eventType away3d.events.Object3DEvent
	 * @see	#minX
	 * @see	#maxX
	 * @see	#minY
	 * @see	#maxY
	 * @see	#minZ
	 * @see	#maxZ
	 */
	[Event(name="dimensionschanged",type="away3d.events.Object3DEvent")]
    			
	 /**
	 * Dispatched when a user moves the cursor while it is over the 3d object.
	 * 
	 * @eventType away3d.events.MouseEvent3D
	 */
	[Event(name="mouseMove3D",type="away3d.events.MouseEvent3D")]
    			
	 /**
	 * Dispatched when a user presses the let hand mouse button while the cursor is over the 3d object.
	 * 
	 * @eventType away3d.events.MouseEvent3D
	 */
	[Event(name="mouseDown3D",type="away3d.events.MouseEvent3D")]
    			
	 /**
	 * Dispatched when a user releases the let hand mouse button while the cursor is over the 3d object.
	 * 
	 * @eventType away3d.events.MouseEvent3D
	 */
	[Event(name="mouseUp3D",type="away3d.events.MouseEvent3D")]
    			
	 /**
	 * Dispatched when a user moves the cursor over the 3d object.
	 * 
	 * @eventType away3d.events.MouseEvent3D
	 */
	[Event(name="mouseOver3D",type="away3d.events.MouseEvent3D")]
    			
	 /**
	 * Dispatched when a user moves the cursor away from the 3d object.
	 * 
	 * @eventType away3d.events.MouseEvent3D
	 */
	[Event(name="mouseOut3D",type="away3d.events.MouseEvent3D")]
	
    /**
    * Base class for all 3d objects.
    */
    public class Object3D extends EventDispatcher implements IClonable
    {
        use namespace arcane;
		/** @private */
        arcane var _transformDirty:Boolean;
        /** @private */
        arcane var _transform:Matrix3D = new Matrix3D();
        /** @private */
        arcane var _sceneTransformDirty:Boolean;
        /** @private */
        arcane var _sceneTransform:Matrix3D = new Matrix3D();
        /** @private */
        arcane function get parentradius():Number
        {
            //if (_transformDirty)   ???
            //    updateTransform();

            var x:Number = _transform.tx;
            var y:Number = _transform.ty;
            var z:Number = _transform.tz;
            return Math.sqrt(x*x + y*y + z*z) + boundingRadius;
        }
        /** @private */
        arcane function get parentmaxX():Number
        {
            return boundingRadius + _transform.tx;
        }
		/** @private */
        arcane function get parentminX():Number
        {
            return -boundingRadius + _transform.tx;
        }
		/** @private */
        arcane function get parentmaxY():Number
        {
            return boundingRadius + _transform.ty;
        }
		/** @private */
        arcane function get parentminY():Number
        {
            return -boundingRadius + _transform.ty;
        }
		/** @private */
        arcane function get parentmaxZ():Number
        {
            return boundingRadius + _transform.tz;
        }
		/** @private */
        arcane function get parentminZ():Number
        {
            return -boundingRadius + _transform.tz;
        }
        /** @private */
        arcane function notifyTransformChange():void
        {
        	_localTransformDirty = false;
        	
            if (!hasEventListener(Object3DEvent.TRANSFORM_CHANGED))
                return;

            if (!_transformchanged)
                _transformchanged = new Object3DEvent(Object3DEvent.TRANSFORM_CHANGED, this);
                
            dispatchEvent(_transformchanged);
        }
        /** @private */
        arcane function notifySceneTransformChange():void
        {
        	_sceneTransformDirty = false;
        	sceneTransformed = true;
        	
            if (!hasEventListener(Object3DEvent.SCENETRANSFORM_CHANGED))
                return;

            if (!_scenetransformchanged)
                _scenetransformchanged = new Object3DEvent(Object3DEvent.SCENETRANSFORM_CHANGED, this);
                
            dispatchEvent(_scenetransformchanged);
        }
        /** @private */       
        arcane function notifySceneChange():void
        {
            if (!hasEventListener(Object3DEvent.SCENE_CHANGED))
                return;

            if (!_scenechanged)
                _scenechanged = new Object3DEvent(Object3DEvent.SCENE_CHANGED, this);
                
            dispatchEvent(_scenechanged);
        }
        /** @private */
        arcane function notifyDimensionsChange():void
        {
            if (!hasEventListener(Object3DEvent.DIMENSIONS_CHANGED))
                return;
                
            if (!_dimensionschanged)
                _dimensionschanged = new Object3DEvent(Object3DEvent.DIMENSIONS_CHANGED, this);
                
            dispatchEvent(_dimensionschanged);
        }
        /** @private */
        arcane function notifyRadiusChange():void
        {
            if (!hasEventListener(Object3DEvent.RADIUS_CHANGED))
                return;
                
            if (!_radiuschanged)
                _radiuschanged = new Object3DEvent(Object3DEvent.RADIUS_CHANGED, this);
                
            dispatchEvent(_radiuschanged);
        }
        /** @private */
		arcane function dispatchMouseEvent(event:MouseEvent3D):Boolean
        {
            if (!hasEventListener(event.type))
                return false;

            dispatchEvent(event);

            return true;
        }
		
        private static var toDEGREES:Number = 180 / Math.PI;
        private static var toRADIANS:Number = Math.PI / 180;
		
        private var _rotationDirty:Boolean;
        private var _rotationX:Number;
        private var _rotationY:Number;
        private var _rotationZ:Number;
        private var _localTransformDirty:Boolean;
        private var _scene:Scene3D;
        private var _parent:ObjectContainer3D;
		private var _quaternion:Quaternion = new Quaternion();
		private var _rot:Number3D;
        private var _position:Number3D = new Number3D();
        private var _scenePosition:Number3D = new Number3D();
        private var _ddo:DrawDisplayObject = new DrawDisplayObject();
        private var _sc:ScreenVertex = new ScreenVertex();
        private var _v:View3D;
        private var _c:DisplayObject;       		
		private var _vector:Number3D = new Number3D();
		private var _m:Matrix3D = new Matrix3D();
    	private var _xAxis:Number3D = new Number3D();
    	private var _yAxis:Number3D = new Number3D();
    	private var _zAxis:Number3D = new Number3D();        
        private var _transformchanged:Object3DEvent;
        private var _scenetransformchanged:Object3DEvent;
        private var _scenechanged:Object3DEvent;
        private var _dimensionschanged:Object3DEvent;
        private var _radiuschanged:Object3DEvent;
        
        private function updateTransform():void
        {
            if (!_transformDirty) 
                return;

            _quaternion.euler2quaternion(-_rotationY, -_rotationZ, _rotationX); // Swapped
            _transform.quaternion2matrix(_quaternion);
			
            //m.scale(_scaleX, _scaleY, _scaleZ); // !! WRONG !!
			
            _transformDirty = false;
            _sceneTransformDirty = true;
            _localTransformDirty = true;
        }

        private function updateSceneTransform():void
        {
            if (!_sceneTransformDirty) 
                return;

            _sceneTransform.multiply(_parent.sceneTransform, transform);
            inverseSceneTransform.inverse(_sceneTransform);
            
            _sceneTransformDirty = false;
            notifySceneTransformChange();
        }
		
        private function updateRotation():void
        {
            _rot = _transform.matrix2euler();
            _rotationX = _rot.x * toRADIANS;
            _rotationY = _rot.y * toRADIANS;
            _rotationZ = _rot.z * toRADIANS;
    
            _rotationDirty = false;
        }

        private function onParentSceneChange(event:Object3DEvent):void
        {
            if (_scene == _parent.scene)
                return;

            _scene = _parent.scene;
            notifySceneChange();
        }

        private function onParentTransformChange(event:Object3DEvent):void
        {
            _sceneTransformDirty = true;
        }
		 
        /**
        * Instance of the Init object used to hold and parse default property values
        * specified by the initialiser object in the 3d object constructor.
        */
		protected var ini:Init;
		
        public var projection:Projection = new Projection();
        public var inverseSceneTransform:Matrix3D = new Matrix3D();
        public var viewTransform:Matrix3D = new Matrix3D();
    	public var sceneTransformed:Boolean;
    	
    	/**
    	 * The render session used by the 3d object
    	 */
        public var session:AbstractRenderSession;
        
    	/**
    	 * Defines whether the 3d object is visible in the scene
    	 */
        public var visible:Boolean = true;
		
    	/**
    	 * An optional name string for the 3d object.
    	 * 
    	 * Can be used to access specific 3d object in a scene by calling the <code>getChildByName</code> method on the parent <code>ObjectContainer3D</code>.
    	 * 
    	 * @see away3d.containers.ObjectContainer3D#getChildByName()
    	 */
        public var name:String;
        
    	/**
    	 * An optional array of filters that can be applied to the 3d object.
    	 * 
    	 * Requires <code>ownCanvas</code> to be set to true.
    	 * 
    	 * @see #ownCanvas
    	 */
        public var filters:Array;
    	    
        
    	/**
    	 * An optional alpha value that can be applied to the 3d object.
    	 * 
    	 * Requires <code>ownCanvas</code> to be set to true.
    	 * 
    	 * @see #ownCanvas
    	 */
        public var alpha:Number;
        
    	/**
    	 * An optional blend mode that can be applied to the 3d object.
    	 * 
    	 * Requires <code>ownCanvas</code> to be set to true.
    	 * 
    	 * @see #ownCanvas
    	 */
        public var blendMode:String;
        
    	/**
    	 * An optional untyped object that can contain used-defined properties
    	 */
        public var extra:Object;

    	/**
    	 * Defines whether mouse events are received on the 3d object
    	 */
        public var mouseEnabled:Boolean = true;
        
    	/**
    	 * Defines whether a hand cursor is displayed when the mouse rolls over the 3d object.
    	 */
        public var useHandCursor:Boolean = false;

    	/**
    	 * Defines whether the contents of the 3d object are rendered inside it's own sprite
    	 */
        public var ownCanvas:Boolean = false;
        
    	/**
    	 * Defines whether the contents of the 3d object are rendered using it's own render session
    	 */
        public var ownSession:AbstractRenderSession;
        
    	/**
    	 * Returns the bounding radius of the 3d object
    	 */
        public function get boundingRadius():Number
        {
            return 0;
        }
        
    	/**
    	 * Returns the maximum x value of the 3d object
    	 * 
    	 * @see	#x
    	 */
        public function get maxX():Number
        {
            return boundingRadius;
        }
        
    	/**
    	 * Returns the minimum x value of the 3d object
    	 * 
    	 * @see	#x
    	 */
        public function get minX():Number
        {
            return -boundingRadius;
        }
        
    	/**
    	 * Returns the maximum y value of the 3d object
    	 * 
    	 * @see	#y
    	 */
        public function get maxY():Number
        {
            return boundingRadius;
        }
        
    	/**
    	 * Returns the minimum y value of the 3d object
    	 * 
    	 * @see	#y
    	 */
        public function get minY():Number