Pasted

package com.ulfben.utils {
    import flash.display.*;
    import flash.geom.*;
 
    public class FastShapes {
        public static const HORIZONTAL_LINE:String = "FastShapes.horizontal";
        public static const VERTICAL_LINE:String = "FastShapes.vertical";
        public static const TO_RAD:Number = (Math.PI / 180);
        public static const TO_DEG:Number = (180 / Math.PI);
        public static const PI2:Number = Math.PI * 2;
        public static const HALF_PI:Number = Math.PI * 0.5;
        public static const QUARTER_PI:Number = Math.PI * 0.25;
        public static const EIGHTH_PI:Number = Math.PI * 0.125;
 
        /**
         * Creates look up tables for sin and cos, to reduce function calls.
         * index = int(angle * (2048/2PI))
         */     
        public static var sCosLUT:Vector.<Number> = new Vector.<Number>(0x800, true);
        public static var sSinLUT:Vector.<Number> = new Vector.<Number>(0x800, true);
        public static function initLUTs():void  {
            for (var i:int = 0; i < 0x800; ++i)
            {
                sCosLUT[i & 0x7FF] = Math.cos(i * 0.00306796157577128245943617517898); // 0.003067... is 2PI/2048
                sSinLUT[i & 0x7FF] = Math.sin(i * 0.00306796157577128245943617517898);
            }
        }
        public static function sinLUT(x:Number):Number{
            return sSinLUT[(x * 325.94932345220164765467394738691) & 2047]; // 325.949... is 2048/2PI
        }
        public static function cosLUT(x:Number):Number{
            return sCosLUT[((x * 325.94932345220164765467394738691) & 2047)]; //325.949... is 2048/2PI
        }
 
        public static function sinCoarse(x:Number):Number {
            if (x < -3.14159265) { //always wrap input angle to -PI..PI
                x += 6.28318531;
            } else if (x > 3.14159265) {
                x -= 6.28318531;
            }
            return (x < 0) ? (1.27323954 * x + .405284735 * x * x) : (1.27323954 * x - 0.405284735 * x * x);
        }
 
        public static function cosCoarse(x:Number):Number {
            if (x < -3.14159265) { //always wrap input angle to -PI..PI
                x += 6.28318531;
            } else if (x > 3.14159265) {
                x -= 6.28318531;
            }
            x += 1.57079632; // //compute cosine: sin(x + PI/2) = cos(x)
            if (x > 3.14159265) {
                x -= 6.28318531;
            }
            return (x < 0) ? (1.27323954 * x + 0.405284735 * x * x) : (1.27323954 * x - 0.405284735 * x * x);
        }
 
        public static function sinFine(x:Number):Number {
            if(x < -3.14159265) {
                    x += 6.28318531;
            } else if(x > 3.14159265) {
                    x -= 6.28318531;
            }
            x = (x < 0.0) ? (1.27323954 * x + .405284735 * x * x) : (1.27323954 * x - 0.405284735 * x * x)
            return (x < 0.0) ? (0.225 * (x *-x - x) + x) : (0.225 * (x * x - x) + x)
        }
    
        public static function cosFine(x:Number): Number {
            if(x < -3.14159265) {
                x += 6.28318531;
            } else if(x > 3.14159265) {
                x -= 6.28318531;
            }
            x += 1.57079632;
            if(x > 3.14159265) {
                x -= 6.28318531;
            }
            x = (x < 0.0) ? (1.27323954 * x + .405284735 * x * x) : (1.27323954 * x - 0.405284735 * x * x)
            return (x < 0.0) ? (0.225 * (x *-x - x) + x) : (0.225 * (x * x - x) + x)
        }
 
        public static var testCos:Function = cosFine; // cosLUT, cosCoarse, cosFine
        public static var testSin:Function = sinFine; // sinLUT,  sinCoarse, sinFine
 
 
        public function FastShapes() {
            throw new ArgumentError("The FastShapes Class cannot be instanicated.");
        }
 
        /***
         * drawCircle
         * Since Flash Player 8 there is an internal drawCircle-method. Before that I
         * used this. At some point they should be benchmarked against eachother.
         */
        public static function drawCircle(target:Graphics, x:Number, y:Number, r:Number):void {
            var tan:Number = Math.tan(EIGHTH_PI) * r;
            var sin:Number = testSin(QUARTER_PI) * r;
            target.moveTo(x + r, y);
            target.curveTo(r + x, tan + y, sin + x, sin + y);
            target.curveTo(tan + x, r + y, x, r + y);
            target.curveTo((-tan) + x, r + y, (-sin) + x, sin + y);
            target.curveTo(-r + x, tan + y, -r + x, y);
            target.curveTo(-r + x, (-tan) + y, (-sin) + x, (-sin) + y);
            target.curveTo((-tan) + x, -r + y, x, -r + y);
            target.curveTo(tan + x, -r + y, sin + x, (-sin) + y);
            target.curveTo(r + x, (-tan) + y, r + x, y);
            target.moveTo(x, y);
        }
 
        // wobbleFactor in percent. 0.04-0.08 is a good default range.
        public static function handDrawLine(target:Graphics, startPoint:Point, endPoint:Point, wobbleFactor:Number = 0.05):void {
            var wobble:Number = Point.distance(startPoint, endPoint) * wobbleFactor;
            var r1:Number = Math.random();
            var r2:Number = Math.random();
            var xfactor:Number = Math.random() > 0.5 ? wobble : -wobble;
            var yfactor:Number = Math.random() > 0.5 ? wobble : -wobble;
            var control1:Point = new Point((endPoint.x - startPoint.x) * r1 + startPoint.x + xfactor, (endPoint.y - startPoint.y) * r1 + startPoint.y + yfactor);
            var control2:Point = new Point((endPoint.x - startPoint.x) * r2 + startPoint.x - xfactor, (endPoint.y - startPoint.y) * r2 + startPoint.y - yfactor);
            target.moveTo(startPoint.x, startPoint.y);
            target.cubicCurveTo(control1.x, control1.y, control2.x, control2.y, endPoint.x, endPoint.y);
        }
 
        
         // Draws a dashed line from the point x1,y1 to the point x2,y2 
        public static function drawDash(target:Graphics, x1:Number, y1:Number, x2:Number, y2:Number, dashLength:Number = 5, spaceLength:Number = 5):void {
            var x:Number = x2 - x1;
            var y:Number = y2 - y1;
            var hyp:Number = Math.sqrt((x) * (x) + (y) * (y));
            var units:Number = hyp / (dashLength + spaceLength);
            var invertedUnits:Number = 1 / units;
            var dashSpaceRatio:Number = dashLength / (dashLength + spaceLength);
            var dashX:Number = (x * invertedUnits) * dashSpaceRatio;
            var spaceX:Number = (x * invertedUnits) - dashX;
            var dashY:Number = (y * invertedUnits) * dashSpaceRatio;
            var spaceY:Number = (y * invertedUnits) - dashY;
 
            target.moveTo(x1, y1);
            while (hyp > 0) {
                x1 += dashX;
                y1 += dashY;
                hyp -= dashLength;
                if (hyp < 0) {
                    x1 = x2;
                    y1 = y2;
                }
                target.lineTo(x1, y1);
                x1 += spaceX;
                y1 += spaceY;
                target.moveTo(x1, y1);
                hyp -= spaceLength;
            }
            target.moveTo(x2, y2);
        }
 
        
        //Draws an arc from the starting position of x,y.       
        public static function drawArc(target:Graphics, x:Number, y:Number, radius:Number, arc:Number, startAngle:Number = 0, yRadius:Number = 0):void {
            if (yRadius == 0) {
                yRadius = radius;
            }
            var segAngle:Number, theta:Number, halfTheta:Number, angle:Number, angleMid:Number, segs:Number, ax:Number, ay:Number, bx:Number, by:Number, cx:Number, cy:Number;
            if (FastShapes.abs(arc) > 360) {
                arc = 360; // no sense in drawing more than is needed :)
            }
            // Flash uses 8 segments per circle, to match that, we draw in a maximum of 45 degree segments.
            segs = FastShapes.ceil(FastShapes.abs(arc) / 45);
            segAngle = arc / segs;
            theta = -(segAngle) * FastShapes.TO_RAD;
            angle = -(startAngle) * FastShapes.TO_RAD;
            ax = x - testCos(angle) * radius;
            ay = y - testSin(angle) * yRadius;
            if (segs > 0) {
                target.moveTo(x, y);
                halfTheta = theta * 0.5;
                var radiusCosHalfTheta:Number = radius / testCos(halfTheta);
                var yRadiusCosHalfTheta:Number = yRadius / testCos(halfTheta);
                for (var i:int = 0; i < segs; ++i) {
                    angle += theta;
                    angleMid = angle - halfTheta;
                    bx = ax + testCos(angle) * radius;
                    by = ay + testSin(angle) * yRadius;
                    cx = ax + testCos(angleMid) * radiusCosHalfTheta;
                    cy = ay + testSin(angleMid) * yRadiusCosHalfTheta;
                    target.curveTo(cx, cy, bx, by);
                }
            }
        }
 
        // draws pie shaped wedges.  Could be employed to draw pie charts.      
        public static function drawWedge(target:Graphics, x:Number, y:Number, radius:Number, arc:Number, startAngle:Number = 0, yRadius:Number = 0):void {
            if (yRadius == 0) {
                yRadius = radius;
            }
            if (FastShapes.abs(arc) > 360) {
                arc = 360;
            }
            target.moveTo(x, y);
            var segAngle:Number, theta:Number, halfTheta:Number, angle:Number, angleMid:Number, segs:Number, ax:Number, ay:Number, bx:Number, by:Number, cx:Number, cy:Number;
            // Flash uses 8 segments per circle, to match that, we draw in a maximum of 45 degree segments.
            segs = FastShapes.ceil(FastShapes.abs(arc) / 45);
            segAngle = arc / segs;
            theta = -(segAngle) * FastShapes.TO_RAD;
            angle = -(startAngle) * FastShapes.TO_RAD;
            // draw the curve in segments no larger than 45 degrees.
            if (segs > 0) {
                ay = y + testSin(angle) * yRadius; //NOTE: angle is negative!
                ax = x + testCos(-angle) * radius; //NOTE: -angle == positive value here!
                target.lineTo(ax, ay);
                halfTheta = theta * 0.5;
                var radiusCosHalfTheta:Number = radius / testCos(halfTheta);
                var yRadiusCosHalfTheta:Number = yRadius / testCos(halfTheta);
                for (var i:int = 0; i < segs; ++i) {
                    angle += theta;
                    angleMid = angle - halfTheta;
                    bx = x + testCos(angle) * radius;
                    by = y + testSin(angle) * yRadius;
                    cx = x + testCos(angleMid) * radiusCosHalfTheta;
                    cy = y + testSin(angleMid) * yRadiusCosHalfTheta;
                    target.curveTo(cx, cy, bx, by);
                }
                target.lineTo(x, y);
            }
        }
 
        
        // draws a star shaped polygon.     
        public static function drawStar(target:Graphics, x:Number, y:Number, points:uint, innerRadius:Number, outerRadius:Number, angle:Number = 0):void {
            if (points <= 2) {
                throw ArgumentError("FastShapes.drawStar() - parameter 'points' needs to be atleast 3");
                return;
            }
            var step:Number, startnstep:Number, halfStep:Number, start:Number, n:Number, dx:Number, dy:Number;
            step = FastShapes.PI2 / points;
            halfStep = step * 0.5;
            start = angle * FastShapes.TO_RAD;
            target.moveTo(x + (testCos(start) * outerRadius), y - (testSin(start) * outerRadius));
            for (n = 1; n <= points; ++n) {
                startnstep = start + (step * n);
                dx = x + testCos(startnstep - halfStep) * innerRadius;
                dy = y - testSin(startnstep - halfStep) * innerRadius;
                target.lineTo(dx, dy);
                dx = x + testCos(startnstep) * outerRadius;
                dy = y - testSin(startnstep) * outerRadius;
                target.lineTo(dx, dy);
            }
        }
 
        /**
         * a method for creating polygon shapes.  Negative values will draw
         * the polygon in reverse direction.  Negative drawing may be useful
         * for creating knock-outs in masks.
         */
        public static function drawPolygon(target:Graphics, x:Number, y:Number, sides:uint, radius:Number, angle:Number = 0):void {
            if (sides <= 2) {
                throw ArgumentError("FastShapes.drawPolygon() - parameter 'sides' needs to be atleast 3");
                return;
            }
            var step:Number, startnstep:Number, start:Number, n:Number, dx:Number, dy:Number;
            step = FastShapes.PI2 / sides;
            start = angle * FastShapes.TO_RAD;
            target.moveTo(x + (testCos(start) * radius), y - (testSin(start) * radius));
            for (n = 1; n <= sides; ++n) {
                startnstep = start + (step * n);
                dx = x + testCos(startnstep) * radius;
                dy = y - testSin(startnstep) * radius;
                target.lineTo(dx, dy);
            }
        }
 
        /**
         * a method for creating hand drawn polygon shapes.  Negative values will draw
         * the polygon in reverse direction.  Negative drawing may be useful
         * for creating knock-outs in masks.    
         */
        public static function handDrawPolygon(target:Graphics, x:Number, y:Number, sides:uint, radius:Number, wobbleFactor:Number = 0.05, angle:Number = 0):void {
            if (sides <= 2) {
                throw ArgumentError("FastShapes.handDrawPolygon() - parameter 'sides' needs to be atleast 3");
                return;
            }
            var step:Number, start:Number, startnstep:Number, n:Number, dx:Number, dy:Number;
            step = FastShapes.PI2 / sides;
            start = angle * FastShapes.TO_RAD;
            var p1:Point = new Point(x + (testCos(start) * radius), y - (testSin(start) * radius))
            var p2:Point = new Point();
            target.moveTo(p1.x, p1.y);
            for (n = 1; n <= sides; ++n) {
                startnstep = start + (step * n);
                p2.x = x + testCos(startnstep) * radius; //dx
                p2.y = y - testSin(startnstep) * radius; //dy
                handDrawLine(target, p1, p2, wobbleFactor);
                p1.x = p2.x;
                p1.y = p2.y;
            }
        }
 
        /**
         * Burst is a method for drawing star bursts.  If you've ever worked
         * with an advertising department, you know what they are ;-)
         * Clients tend to want them, Developers tend to hate them...       
         */
        public static function drawBurst(target:Graphics, x:Number, y:Number, sides:uint, innerRadius:Number, outerRadius:Number, angle:Number = 0):void {
            if (sides <= 2) {
                throw ArgumentError("FastShapes.drawBurst - parameter 'sides' needs to be atleast 3");
                return;
            }
            var step:Number, halfStep:Number, qtrStep:Number, qtrStep3:Number, start:Number, n:Number, dx:Number, dy:Number, cx:Number, cy:Number;
            var startnstep:Number, innercos:Number;
            step = FastShapes.PI2 / sides;
            qtrStep = step * 0.25;
            halfStep = step * 0.5;
            qtrStep3 = step * 0.75;
            start = angle * FastShapes.TO_RAD;
            target.moveTo(x + (testCos(start) * outerRadius), y - (testSin(start) * outerRadius));
            for (n = 1; n <= sides; ++n) {
                startnstep = start + (step * n);
                innercos = (innerRadius / testCos(qtrStep));
                cx = x + testCos(startnstep - qtrStep3) * innercos;
                cy = y - testSin(startnstep - qtrStep3) * innercos;
                dx = x + testCos(startnstep - halfStep) * innerRadius;
                dy = y - testSin(startnstep - halfStep) * innerRadius;
                target.curveTo(cx, cy, dx, dy);
                cx = x + testCos(startnstep - qtrStep) * innercos;
                cy = y - testSin(startnstep - qtrStep) * innercos;
                dx = x + testCos(startnstep) * outerRadius;
                dy = y - testSin(startnstep) * outerRadius;
                target.curveTo(cx, cy, dx, dy);
            }
        }
         
        // draws a gear shape on the Graphics target             
        public static function drawGear(target:Graphics, x:Number, y:Number, sides:uint, innerRadius:Number = 80, outerRadius:Number = 4, angle:Number = 0, holeSides:Number = 2, holeRadius:Number = 0):void {
            if (sides <= 2) {
                throw ArgumentError("FastShapes.drawGear() - parameter 'sides' needs to be atleast 3");
                return;
            }
            var step:Number, startnstep:Number, qtrStep:Number, qtrStep2:Number, qtrStep3:Number, start:Number, n:Number, dx:Number, dy:Number;
            step = FastShapes.PI2 / sides;
            qtrStep = step * 0.25;
            qtrStep2 = (qtrStep * 2);
            qtrStep3 = (qtrStep * 3);
            start = angle * FastShapes.TO_RAD;
            target.moveTo(x + (testCos(start) * outerRadius), y - (testSin(start) * outerRadius));
            for (n = 1; n <= sides; ++n) {
                startnstep = start + (step * n);
                dx = x + testCos(startnstep - qtrStep3) * innerRadius;
                dy = y - testSin(startnstep - qtrStep3) * innerRadius;
                target.lineTo(dx, dy);
                dx = x + testCos(startnstep - qtrStep2) * innerRadius;
                dy = y - testSin(startnstep - qtrStep2) * innerRadius;
                target.lineTo(dx, dy);
                dx = x + testCos(startnstep - qtrStep) * outerRadius;
                dy = y - testSin(startnstep - qtrStep) * outerRadius;
                target.lineTo(dx, dy);
                dx = x + testCos(startnstep) * outerRadius;
                dy = y - testSin(startnstep) * outerRadius;
                target.lineTo(dx, dy);
            }
            // This is complete overkill... but I had it done already. :)
            if (holeSides > 2) {
                step = FastShapes.PI2 / holeSides;
                target.moveTo(x + (testCos(start) * holeRadius), y - (testSin(start) * holeRadius));
                for (n = 1; n <= holeSides; ++n) {
                    startnstep = start + (step * n);
                    dx = x + testCos(startnstep) * holeRadius;
                    dy = y - testSin(startnstep) * holeRadius;
                    target.lineTo(dx, dy);
                }
            }
        }
 
        //  draws a line between two points. Make it horizontal or vertical
        public static function drawLine(target:Graphics, x:Number, y:Number, length:Number, direction:String = FastShapes.HORIZONTAL_LINE):void {
            switch (direction) {
            case FastShapes.HORIZONTAL_LINE:
                target.moveTo(x, y);
                target.lineTo(length, y);
                break;
            case FastShapes.VERTICAL_LINE:
                target.moveTo(x, y);
                target.lineTo(x, length);
                break;
            }
        }
    }
}