flash on 2012-8-10

forked:1
favorite:1
lines:318
license : see code comments
modified : 2012-08-10 18:19:54

Embed: Tweet

package  
{
	import flash.display.*;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.geom.Point;

public class Main3 extends Sprite
	{
		public var bd:BitmapData;
		public var bezier:Bezier;
		public var i:int;
		public function Main3 () 
		{
			click ();
			stage.addEventListener (MouseEvent.CLICK, click);
			stage.addEventListener (Event.ENTER_FRAME, loop);
		}
		
		private function click (...whatever):void {
			i = -1;
			
			bezier = new Bezier (
				465 * (0.1 + 0.8 * Math.random ()),
				465 * (0.1 + 0.8 * Math.random ()),
				465 * (0.1 + 0.8 * Math.random ()),
				465 * (0.1 + 0.8 * Math.random ()),
				465 * (0.1 + 0.8 * Math.random ()),
				465 * (0.1 + 0.8 * Math.random ())
			);
			
			graphics.beginBitmapFill (bd = new BitmapData (465, 465, false, 0));
			graphics.drawRect (0, 0, 465, 465);
			graphics.endFill ();
			
			graphics.lineStyle (1, 0xFFFFFF);
			graphics.moveTo (bezier.getPos (0).x, bezier.getPos (0).y);
			graphics.curveTo (bezier.getCtrl ().x, bezier.getCtrl ().y, bezier.getPos (1).x, bezier.getPos (1).y);
		}
		
		private function loop(e:Event):void 
		{
			bd.lock();
			var j:int = i + 2345;
			while (i++ < 465 * 465) {
				var X:Number = int (i / 465);
				var Y:Number = i % 465;
				var P:Point = bezier.findNearestPoint (X, Y).pos;
				var G:int = 255 * (0.5 + 0.5 * (P.x - X) / 465);
				var B:int = 255 * (0.5 + 0.5 * (P.y - Y) / 465);
				bd.setPixel (X, Y, G * 256 + B);
				if (i > j) break;
			}
			bd.unlock();
		}
		
	}

}

/**
* Bezier class for collision detection
* @author Olivier Besson (http://www.gludion.com)
* @version 0.2
*/

import flash.geom.Point;

class Bezier
{
	// a value we consider "small enough" to equal it to zero:
	// (this is used for double solutions in 2nd or 3d degree equation)
	public static var zeroMax:Number = 0.0000001;
	
	private var p0:Point;			// handle 0 of curve
	private var p1:Point;			// handle 1 of curve
	private var p2:Point;			// handle 2 of curve
	
	// bounds data
	private var xMin:Number;
	private var xMax:Number;
	private var yMin:Number;
	private var yMax:Number;
	
	// data for position+tangent
	private var pos:Point;			// generic position on curve
	private var tan:Point;			// tangent
	private var nor:Point;			// normal
	
	// PERSONAL note: for conversion quadratic=>cubic, put 2 handles at 2/3 of p0p1 and p2p1

// data for nearest:
	private var A:Point;				// an util vector (= p1-p0)
	private var B:Point;				// an util vector (= p2-p1-A)
	private var solution:Object;		// solution of 3d degree equation
	private var nearest:Object;			// data about nearest point
	private var posMin:Point;			// nearest position on curve
	
	
	// defines a Quadratic Bezier Curve with p0 = (x0, y0), p1 = (x1, y1), p2 = (x2, y2)
	// p0 and p2 are anchor points.
	// p1 is control point.
	public function Bezier(x0:Number,y0:Number,x1:Number,y1:Number,x2:Number,y2:Number)
	{
		p0 = new Point();
		p1 = new Point();
		p2 = new Point();
	
		pos = new Point();
		tan = new Point();
		nor = new Point();
		
		A = new Point();
		B = new Point();
		solution = new Object();
		nearest = new Object();
		posMin = new Point();
		
		update(x0, y0, x1, y1, x2, y2);
	}
	
	// should be called after any anchor or control point is moved.
	public function update(x0:Number,y0:Number,x1:Number,y1:Number,x2:Number,y2:Number):void
	{
		p0.x = x0;
		p0.y = y0;
		p1.x = x1;
		p1.y = y1;
		p2.x = x2;
		p2.y = y2;
		
		// precompute A and B, which will be very useful next.
		A.x = p1.x - p0.x;
		A.y = p1.y - p0.y;
		B.x = p0.x - 2 * p1.x + p2.x;
		B.y = p0.y - 2 * p1.y + p2.y;
		
		// rough evaluation of bounds:
		xMin = Math.min(x0, Math.min(x1, x2));
		xMax = Math.max(x0, Math.max(x1, x2));
		yMin = Math.min(y0, Math.min(y1, y2));
		yMax = Math.max(y0, Math.max(y1, y2));
		
		// more accurate evaluation:
		// see Andree Michelle for a faster but less readable method 
		var u:Number;
		if (xMin == x1 || xMax == x1) 
		{
			u = -A.x / B.x; // u where getTan(u).x == 0
			u = (1 - u) * (1 - u) * p0.x + 2 * u * (1 - u) * p1.x + u * u * p2.x;
			if (xMin == x1) xMin = u;
			else xMax = u;
		}
		if (yMin == y1 || yMax == y1) 
		{
			u = -A.y / B.y; // u where getTan(u).y == 0
			u = (1 - u) * (1 - u) * p0.y + 2 * u * (1 - u) * p1.y + u * u * p2.y;
			if (yMin == y1) yMin = u;
			else yMax = u;
		}
	}
	
	public function hitTest(pBounds:Object):Boolean
	{
		if (pBounds.xMax < xMin || pBounds.xMin > xMax) return false;
		if (pBounds.yMax < yMin || pBounds.yMin > yMax) return false;
		return true;
	}
	
	// returns { t:Number, pos:Point, dist:Number, nor:Point }
	// (costs about 80 multiplications+additions)
	public function findNearestPoint(x:Number, y:Number):Object
	{
		// a temporary util vect = p0 - (x,y)
		pos.x = p0.x - x;
		pos.y = p0.y - y;
		// search points P of bezier curve with PM.(dP / dt) = 0
		// a calculus leads to a 3d degree equation :
		var a:Number = B.x * B.x + B.y * B.y;
		var b:Number = 3 * (A.x * B.x + A.y * B.y);
		var c:Number = 2 * (A.x * A.x + A.y * A.y) + pos.x * B.x + pos.y * B.y;
		var d:Number = pos.x * A.x + pos.y * A.y;
		var sol:Object = thirdDegreeEquation(a, b, c, d);
		
		var t:Number;
		var dist:Number;
		var tMin:Number;
		var distMin:Number = Number.MAX_VALUE;
		var d0:Number = getDist(x, y, p0.x, p0.y);
		var d2:Number = getDist(x, y, p2.x, p2.y);
		var orientedDist:Number;
		
		if (sol != null)
		{
			// find the closest point:
			for (var i:int = 1; i <= sol.count; i++)
			{
				t = sol["s" + i];
				if (t >= 0 && t <= 1)
				{
					pos = getPos(t);
					dist = getDist(x, y, pos.x, pos.y);
					if (dist < distMin)
					{
						// minimum found!
						tMin = t;
						distMin = dist;
						posMin.x = pos.x;
						posMin.y = pos.y;
					}
				}
			}
			if (!isNaN(tMin) && distMin < d0 && distMin < d2) 
			{
				// the closest point is on the curve
				nor.x = A.y + tMin * B.y;
				nor.y = -(A.x + tMin * B.x);
				nor.normalize(1);
				orientedDist = distMin;
				if ((x - posMin.x) * nor.x + (y - posMin.y) * nor.y < 0) 
				{
					nor.x *= -1;
					nor.y *= -1;
					orientedDist *= -1;
				}
				
				nearest.t = tMin;
				nearest.pos = posMin;
				nearest.nor = nor;
				nearest.dist = distMin;
				nearest.orientedDist = orientedDist;
				nearest.onCurve = true;
				return nearest;
			}
			
		} 
		// the closest point is one of the 2 end points
		if (d0 < d2) 
		{
			distMin = d0;
			tMin = 0;
			posMin.x = p0.x;
			posMin.y = p0.y;	
		} else 
		{
			distMin = d2;
			tMin = 1;
			posMin.x = p2.x;
			posMin.y = p2.y;
		}
		nor.x = x - posMin.x;
		nor.y = y - posMin.y;
		nor.normalize(1);
		
		nearest.t = tMin;
		nearest.pos = posMin;
		nearest.nor = nor;
		nearest.orientedDist = nearest.dist = distMin;
		nearest.onCurve = false;
		return nearest;
	}
	
	
	
	public function getPos(t:Number):Point
	{
		var a:Number = (1 - t) * (1 - t);
		var b:Number = 2 * t * (1 - t);
		var c:Number = t * t;
		pos.x = a * p0.x + b * p1.x + c * p2.x;
		pos.y = a * p0.y + b * p1.y + c * p2.y;
		return pos;
	}
	
	public function getCtrl():Point
	{
		return p1.clone();
	}
	
	// (dP/dt)(t) = 2*(A + t*B)
	public function getSpeed(t:Number):Number
	{
		tan.x = A.x + t * B.x;
		tan.y = A.y + t * B.y;
		return 2 * Math.sqrt(tan.x * tan.x + tan.y * tan.y);
		//return 2*tan.getNorm();
	}
	
	public function getNor(t:Number):Point
	{
		nor.x = A.y + t * B.y;
		nor.y = -(A.x + t * B.x);
		// normalize:
		var lNorm:Number = Math.sqrt(nor.x * nor.x + nor.y * nor.y);
		if (lNorm > 0)
		{
			nor.x /= lNorm;
			nor.y /= lNorm;
		}
		return nor;
	}
	
	// a local duplicate & optimized version of com.gludion.utils.MathUtils.thirdDegreeEquation(a,b,c,d):Object
	//WARNING: s2, s3 may be non - null if count = 1.
	// use only result["s"+i] where i <= count
	private function thirdDegreeEquation(
								a:Number,
								b:Number,
								c:Number,
								d:Number
								):Object	// returns a {count:Number, s1:Number, s2:Number, s3:Number} object
	{
		if (Math.abs(a) > zeroMax)
		{
			// let's adopt form: x3 + ax2 + bx + d = 0
			var z:Number = a; // multi-purpose util variable
			a = b / z;
			b = c / z;
			c = d / z;
			// we solve using Cardan formula: http://fr.wikipedia.org/wiki/M%C3%A9thode_de_Cardan
			var p:Number = b - a * a / 3;
			var q:Number = a * (2 * a * a - 9 * b) / 27 + c;
			var p3:Number = p * p * p;
			var D:Number = q * q + 4 * p3 / 27;
			var offset:Number = -a / 3;
			if (D > zeroMax)
			{
				// D positive
				z = Math.sqrt(D)
				var u:Number = ( -q + z) / 2;
				var v:Number = ( -q - z) / 2;
				u = (u >= 0)? Math.pow(u, 1 / 3) : -Math.pow( -u, 1 / 3);
				v = (v >= 0)? Math.pow(v, 1 / 3) : -Math.pow( -v, 1 / 3);
				solution.s1 = u + v + offset;
				solution.count = 1;
				return solution;
			} else if (D < -zeroMax)
			{
				// D negative
				u = 2 * Math.sqrt( -p / 3);
				v = Math.acos( -Math.sqrt( -27 / p3) * q / 2) / 3;
				solution.s1 = u * Math.cos(v) + offset;
				solution.s2 = u * Math.cos(v + 2 * Math.PI / 3) + offset;
				solution.s3 = u * Math.cos(v + 4 * Math.PI / 3) + offset;
				solution.count = 3;
				return solution;
			} else
			{
				// D zero
				if (q < 0) u = Math.pow( -q / 2, 1 / 3);
				else u = -Math.pow( q / 2, 1 / 3);
				solution.s1 = 2*u + offset;
				solution.s2 = -u + offset;
				solution.count = 2;
				return solution;
			}
		} else
		{
			// a = 0, then actually a 2nd degree equation:
			// form : ax2 + bx + c = 0;
			a = b;
			b = c;
			c = d;
			if (Math.abs(a) <= zeroMax)
			{
				if (Math.abs(b) <= zeroMax) return null;
				else 
				{
					solution.s1 = -c / b;
					solution.count = 1;
					return solution;
				}
			}
			D = b*b - 4*a*c;
			if (D <= - zeroMax) return null;
			if (D > zeroMax)
			{
				// D positive
				D = Math.sqrt(D);
				solution.s1 = ( -b - D) / (2 * a);
				solution.s2 = ( -b + D) / (2 * a);
				solution.count = 2;
				return solution;
			} else if (D < - zeroMax)
			{
				// D negative
				return null;
			} else 
			{
				// D zero
				solution.s1 = -b / (2 * a);
				solution.count = 1
				return solution;
			}
		}
	}
	
	private function getDist(x1:Number, y1:Number, x2:Number, y2:Number):Number
	{
		return Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
	}
}

Code Fullscreen

Preview Fullscreen