float lastMFrac;

void setup() {
	size(600,600);

	smooth();
        noFill();
        stroke(0);
        strokeWeight(0.5);
}



void draw() {
	int drawX = width/2;
	int drawY = height;
	
	//Time
	float m = millis();
	float mFrac = m / 1000;
	float elapsedTime = (mFrac - lastMFrac);
	lastMFrac = mFrac;
	//
	
	background(255);
	
	pushMatrix();
	translate(drawX,drawY);
	
	flare07(m);

	popMatrix();
}



void flare07(float m) {
	final int FLARE_UNDULATE_WIDTH = 16;
	final float FLARE_UNDULATE_LENGTH = PI / 16;
	final float OUTER_FLARE_UNDULATE_LENGTH = PI / 24;
	final float FLARE_SPEED = 0.02;
	final float OUTER_FLARE_SPEED = 0.05;
	final int SEG_HEIGHT = 8;
	final int OUTER_FLARE_WIDTH = 64;
	final int ITERATIONS = 85;

	TinrocketVector2D flare = new TinrocketVector2D();
	TinrocketVector2D flareSegment = new TinrocketVector2D();
	TinrocketVector2D flareOuterSegment = new TinrocketVector2D();
        TinrocketVector2D flarePath[] = new TinrocketVector2D[ITERATIONS];
        float angle[] = new float[ITERATIONS];
	float yy = 0;
	
	for (int i = 1; i < ITERATIONS; i = i+1) {
		float sin_i = sin((i-(m*FLARE_SPEED))*FLARE_UNDULATE_LENGTH); //Inner sine path

		flareSegment.Set(0.0,-SEG_HEIGHT);
		flareSegment.RotateByDegrees(sin_i*(ITERATIONS-(ITERATIONS-i)));
		
		flare.Add(flareSegment);
                
                flarePath[i] = new TinrocketVector2D(flare);
                angle[i] = flareSegment.AngleAsRadians();
	}


        //Draw the center path
	beginShape();
	for (int i = 1; i < ITERATIONS; i = i+1) {
		vertex(flarePath[i].X,flarePath[i].Y);
	}
	endShape();	

        //Draw the fins
	beginShape(QUAD_STRIP);
	for (int i = 1; i < ITERATIONS; i = i+1) {
		float frac = 1.0 - (i / float(ITERATIONS));
		float sin_o = sin((i-(m*OUTER_FLARE_SPEED))*OUTER_FLARE_UNDULATE_LENGTH); //Outer sine path

		flareOuterSegment.Set((sin_o*frac*frac*OUTER_FLARE_WIDTH),0.0);
		flareOuterSegment.RotateByRadians(angle[i]+(PI*0.5)); //Make perpendicular to the inner path
		
                //Build the flare shape off the inner path
		vertex(flarePath[i].X+flareOuterSegment.X,flarePath[i].Y+flareOuterSegment.Y);
		vertex(flarePath[i].X-flareOuterSegment.X,flarePath[i].Y-flareOuterSegment.Y);
                //
	}
	endShape();		
}



class TinrocketVector2D {
	//Version: September 16, 2007
	//copyright © 2007 John Balestrieri, Tinrocket, LLC | www.tinrocket.com
	final static float RADIAN = 0.0174532925199432954743716805978692719;
	
	float X, Y;

	//Constructors
	TinrocketVector2D() {
		this.X = 0.0;
		this.Y = 0.0;
	}

	TinrocketVector2D(float ix, float iy) {
		this.X = ix;
		this.Y = iy;
	}

	TinrocketVector2D(TinrocketVector2D v) {
		this.X = v.X;
		this.Y = v.Y;
	}
	//

	void Add(float vx, float vy) {
		this.X += vx;
		this.Y += vy;
	}

	void Add(TinrocketVector2D v) {
		this.X += v.X;
		this.Y += v.Y;
	}

	void Add(TinrocketVector2D va, TinrocketVector2D vb) {
		this.X = va.X + vb.X;
		this.Y = va.Y + vb.Y;
	}

	float AngleAsDegrees() {
		if (this.Y >= 0.0) {
			return atan2(this.Y,this.X) / this.RADIAN;
	  	} else {
	    		return (atan2(this.Y,this.X) / this.RADIAN) + 360.0;
	  	}
	}
	
	float AngleAsRadians() {
		if (this.Y >= 0.0) {
			return atan2(this.Y,this.X);
	  	} else {
			return atan2(this.Y,this.X) + TWO_PI;
	  	}
	}

	float DotProduct(TinrocketVector2D v) {
		return (this.X * v.X) + (this.Y * v.Y);
	}

	//Return the vector length
	float Length() {
		return sqrt((this.X * this.X) + (this.Y * this.Y));
	}

	//Set the vector length
	void Length(float l) {
		float lngth, s;

		lngth = sqrt((this.X * this.X) + (this.Y * this.Y));

		if (lngth == 0.0) { 
			return; 
		}

		s = l / lngth;

		this.X *= s;
		this.Y *= s;
	}

	float LengthSquared() {
		return (this.X * this.X) + (this.Y * this.Y);
	}

	void Negate() {
		this.X = -this.X;
		this.Y = -this.Y;
	}

	void Normalize() {
		float l;

		l = sqrt((this.X * this.X) + (this.Y * this.Y));

		if (l == 0.0) {
			//Avoid NaN
			this.X = 0.0;
			this.Y = 0.0;
		} 
		else {
			//Normalize the vector 
			this.X /= l;
			this.Y /= l;
		}
	}
	
	TinrocketVector2D Perp() {
		return new TinrocketVector2D(this.Y,-this.X);
	}
	
	void RotateByDegrees(float degrees) {
		float r, rx, ry, cr, sr;

		//rotation is clockwise
		r = -RADIAN * degrees;
		cr = cos(r);
		sr = sin(r);

		rx = cr * this.X + sr * this.Y;
		ry = cr * this.Y - sr * this.X;

		this.X = rx;
		this.Y = ry;
	}
	
	void RotateByRadians(float radians) {
		float rx, ry, cr, sr;

		//rotation is clockwise
		cr = cos(-radians);
		sr = sin(-radians);

		rx = cr * this.X + sr * this.Y;
		ry = cr * this.Y - sr * this.X;

		this.X = rx;
		this.Y = ry;
	}
	
	void Scale(float s) {
		this.X *= s;
		this.Y *= s;
	}
	
	void Scale(float sx, float sy) {
		this.X *= sx;
		this.Y *= sy;
	}
	
	void Scale(TinrocketVector2D v) {
		this.X *= v.X;
		this.Y *= v.Y;
	}

	void Set(float sx, float sy) {
		this.X = sx;
		this.Y = sy;
	}
	
	void Set(TinrocketVector2D v) {
		this.X = v.X;
		this.Y = v.Y;
	}
	
	void Subtract(float vx, float vy) {
		this.X -= vx;
		this.Y -= vy;
	}

	void Subtract(TinrocketVector2D v) {
		this.X -= v.X;
		this.Y -= v.Y;
	}

	void Subtract(TinrocketVector2D va, TinrocketVector2D vb) {
		this.X = va.X - vb.X;
		this.Y = va.Y - vb.Y;
	}
}