drawtriangle.as

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

package away3d.core.draw
{
    import away3d.core.*;
    import away3d.materials.*;
    import away3d.core.base.*;
    import away3d.core.render.*;

    
    import flash.display.*;
    import flash.geom.Matrix;
    import flash.geom.Rectangle;
    
    /**
    * Triangle drawing primitive
    */
    public class DrawTriangle extends DrawPrimitive
    {
        use namespace arcane;
		/** @private */
        arcane final function acuteAngled():Boolean
        {
            d01 = v0.distanceSqr(v1);
            d12 = v1.distanceSqr(v2);
            d20 = v2.distanceSqr(v0);
            dd01 = d01 * d01;
            dd12 = d12 * d12;
            dd20 = d20 * d20;
            
            return (dd01 <= dd12 + dd20) && (dd12 <= dd20 + dd01) && (dd20 <= dd01 + dd12);
        }
		/** @private */
        arcane final function maxEdgeSqr():Number
        {
            return Math.max(Math.max(v0.distanceSqr(v1),
                                        v1.distanceSqr(v2)),
                                        v2.distanceSqr(v0));
        }
		/** @private */
        arcane final function minEdgeSqr():Number
        {
            return Math.min(Math.min(v0.distanceSqr(v1),
                                        v1.distanceSqr(v2)),
                                        v2.distanceSqr(v0));
        }
		/** @private */
        arcane final function maxDistortSqr(focus:Number):Number
        {
            return Math.max(Math.max(v0.distortSqr(v1, focus),
                                        v1.distortSqr(v2, focus)),
                                        v2.distortSqr(v0, focus));
        }
		/** @private */
        arcane final function minDistortSqr(focus:Number):Number
        {
            return Math.min(Math.min(v0.distortSqr(v1, focus),
                                        v1.distortSqr(v2, focus)),
                                        v2.distortSqr(v0, focus));
        }
		/** @private */
        arcane function fivepointcut(v0:ScreenVertex, v01:ScreenVertex, v1:ScreenVertex, v12:ScreenVertex, v2:ScreenVertex, uv0:UV, uv01:UV, uv1:UV, uv12:UV, uv2:UV):Array
        {
            if (v0.distanceSqr(v12) < v01.distanceSqr(v2))
            {
                return [
                    create(face, material, projection,  v0, v01, v12,  uv0, uv01, uv12),
                    create(face, material, projection, v01,  v1, v12, uv01,  uv1, uv12),
                    create(face, material, projection,  v0, v12 , v2,  uv0, uv12, uv2)];
            }
            else
            {
                return [
                    create(face, material, projection,   v0, v01,  v2,  uv0, uv01, uv2),
                    create(face, material, projection,  v01,  v1, v12, uv01,  uv1, uv12),
                    create(face, material, projection,  v01, v12,  v2, uv01, uv12, uv2)];
            }
        }
		/** @private */
        arcane final function bisect(focus:Number):Array
        {
            d01 = v0.distanceSqr(v1);
            d12 = v1.distanceSqr(v2);
            d20 = v2.distanceSqr(v0);

            if ((d12 >= d01) && (d12 >= d20))
                return bisect12(focus);
            else
            if (d01 >= d20)
                return bisect01(focus);
            else
                return bisect20(focus);
        }
		/** @private */
        arcane final function distortbisect(focus:Number):Array
        {
            d01 = v0.distortSqr(v1, focus),
            d12 = v1.distortSqr(v2, focus),
            d20 = v2.distortSqr(v0, focus);

            if ((d12 >= d01) && (d12 >= d20))
                return bisect12(focus);
            else
            if (d01 >= d20)
                return bisect01(focus);
            else
                return bisect20(focus);
        }
        
		private var d01:Number;
        private var d12:Number;
        private var d20:Number;
        private var dd01:Number;
        private var dd12:Number;
        private var dd20:Number;
        private var materialWidth:Number;
        private var materialHeight:Number;
        private var _u0:Number;
        private var _u1:Number;
        private var _u2:Number;
        private var _v0:Number;
        private var _v1:Number;
        private var _v2:Number;
        private var focus:Number;
        private var ax:Number;
        private var ay:Number;
        private var az:Number;
        private var bx:Number;
        private var by:Number;
        private var bz:Number;
        private var cx:Number;
        private var cy:Number;
        private var cz:Number;
        private var azf:Number;
        private var bzf:Number;
        private var czf:Number;
        private var faz:Number;
        private var fbz:Number;
        private var fcz:Number;
        private var axf:Number;
        private var bxf:Number;
        private var cxf:Number;
        private var ayf:Number;
        private var byf:Number;
        private var cyf:Number;
        private var det:Number;
        private var da:Number;
        private var db:Number;
        private var dc:Number;
		private var au:Number;
        private var av:Number;
        private var bu:Number;
        private var bv:Number;
        private var cu:Number;
        private var cv:Number;
        private var v01:ScreenVertex;
        private var v12:ScreenVertex;
        private var v20:ScreenVertex;
        private var uv01:UV;
        private var uv12:UV;
        private var uv20:UV;
        
        private function num(n:Number):Number
        {
            return int(n*1000)/1000;
        }
        
        private final function bisect01(focus:Number):Array
        {
            var v01:ScreenVertex = ScreenVertex.median(v0, v1, focus),
                uv01:UV = UV.median(uv0, uv1);
            return [
                create(face, material, projection, v2, v0, v01, uv2, uv0, uv01),
                create(face, material, projection, v01, v1, v2, uv01, uv1, uv2) 
            ];
        }

        private final function bisect12(focus:Number):Array
        {
            var v12:ScreenVertex = ScreenVertex.median(v1, v2, focus),
                uv12:UV = UV.median(uv1, uv2);
            return [
                create(face, material, projection, v0, v1, v12, uv0, uv1, uv12),
                create(face, material, projection, v12, v2, v0, uv12, uv2, uv0) 
            ];
        }

        private final function bisect20(focus:Number):Array
        {
            var v20:ScreenVertex = ScreenVertex.median(v2, v0, focus),
                uv20:UV = UV.median(uv2, uv0);
            return [
                create(face, material, projection, v1, v2, v20, uv1, uv2, uv20),
                create(face, material, projection, v20, v0, v1, uv20, uv0, uv1) 
            ];                                                
        }
        
		/**
		 * The v0 screenvertex of the triangle primitive.
		 */
        public var v0:ScreenVertex;
        
		/**
		 * The v1 screenvertex of the triangle primitive.
		 */
        public var v1:ScreenVertex;
        
		/**
		 * The v2 screenvertex of the triangle primitive.
		 */
        public var v2:ScreenVertex;
        
		/**
		 * The uv0 uv coordinate of the triangle primitive.
		 */
        public var uv0:UV;
        
		/**
		 * The uv1 uv coordinate of the triangle primitive.
		 */
        public var uv1:UV;
        
		/**
		 * The uv2 uv coordinate of the triangle primitive.
		 */
        public var uv2:UV;
        
		/**
		 * The calulated area of the triangle primitive.
		 */
        public var area:Number;
        
    	/**
    	 * A reference to the face object used by the triangle primitive.
    	 */
        public var face:Face;
        
    	/**
    	 * Indicates whether the face of the triangle primitive is facing away from the camera.
    	 */
        public var backface:Boolean = false;
        
    	/**
    	 * The bitmapData object used as the triangle primitive texture.
    	 */
        public var material:ITriangleMaterial;
        
    	/**
    	 * The inverse texturemapping matrix of the triangle primitive texture.
    	 */
        public var invtexturemapping:Matrix;
        
    	/**
    	 * The texturemapping matrix of the triangle primitive texture.
    	 */
        public var texturemapping:Matrix;
        
		/**
		 * @inheritDoc
		 */
        public override function clear():void
        {
            v0 = null;
            v1 = null;
            v2 = null;
            uv0 = null;
            uv1 = null;
            uv2 = null;
            texturemapping = null;
        }
        
		/**
		 * @inheritDoc
		 */
        public override function render():void
        {
            material.renderTriangle(this);
        }
        
        /**
        * Calculates from the uv coordinates the mapping matrix required to draw the triangle primitive.
        */
        public final function transformUV(material:IUVMaterial):Matrix
        {
            materialWidth = material.width,
            materialHeight = material.height;
            
            if (uv0 == null || uv1 == null || uv2 == null)
                return null;

            _u0 = materialWidth * uv0._u;
            _u1 = materialWidth * uv1._u;
            _u2 = materialWidth * uv2._u;
            _v0 = materialHeight * (1 - uv0._v);