/** 
Looping Smoke Generator by Bill Robinson 2009.
Use the mouse. R key to reinitialise.
Assume a BSD style license.
*/
	
	
	
	static final Random rand=new Random();
	static final int MAX_SIZE=64;
	static final int nframes=50;
	
	static int tick;
	
	static final class particle {
		final float x1,y1;
		final int toff;
		int col;
		
		particle(final int swidth, final int sheight) {
			final int ew=swidth-MAX_SIZE*2, eh=sheight-MAX_SIZE*2;
			x1=ew/2+MAX_SIZE+(rand.nextInt(ew<<8)-(ew<<7))/256f;
			y1=eh/2+MAX_SIZE+(rand.nextInt(eh<<8)-(eh<<7))/256f;
			toff=rand.nextInt(nframes);
			int cel=rand.nextInt(64)+16;
			col=cel|(cel<<8)|(cel<<16);
		}
	}
	
	static particle[] particles;
	
    void dummy() {}	
    
	public void setup() {
		size(512,512,P2D);
		background(0);
		init_particles();
		frameRate(50);
	}

	private void init_particles() {
		particles=new particle[128];
		for (int i=0;i<particles.length;i++) {
			particles[i]=new particle(width,height);
		}
		quicksort(0,particles.length-1);
	}
	
	private static void init_colours(int col0, int col1) {
		for (int i=0;i<particles.length;i++) {
			int cel=rand.nextInt(257);
			int cem=256-cel;
			particles[i].col=
			(((col0&0xff00ff)*cel)&0xff00ff00)+
			(((col1&0xff00ff)*cem)&0xff00ff00)+
			(((col0&0x00ff00)*cel)&0x00ff0000)+
			(((col1&0x00ff00)*cem)&0x00ff0000)>>>8;
		}
	}
	
	static void quicksort(int i0, int i1) {
		int i=i0, j=i1;
		final int pivot=particles[i0+i1>>1].toff;
		
		do {
			while (particles[i].toff<pivot) i++;
			while (particles[j].toff>pivot) j--;
			if (i<=j) {
				final particle temp=particles[i];
				particles[i]=particles[j];
				particles[j]=temp;
				i++; j--;
			}
		} while (i<=j);
		if (i0<j) quicksort(i0, j);
		if (i<i1) quicksort(i, i1);
	}

	public void keyPressed() {
		if (key == 'r') {
			init_particles();
		}
		else if (key == '1') { init_colours(0x101010, 0x404040); }
		else if (key == '2') { init_colours(0x301010, 0x904040); }
		else if (key == '3') { init_colours(0x303010, 0x909040); }
		else if (key == '4') { init_colours(0x103010, 0x409040); }
		else if (key == '5') { init_colours(0x101030, 0x404090); }
	}
	
	static int hue=0;
	public void mouseClicked() {
		if (mouseButton==RIGHT) hue=(hue+15)%16;
		else hue=(hue+1)%16;
		if (hue==0) {
			init_colours(0x101010, 0x404040);
		}
		else {
			final float h = (hue-1)/15f;
			final float s = 0.5f;
			init_colours(Color.HSBtoRGB(h, s, 0.1f),Color.HSBtoRGB(h, s, 0.3f));
		}
	}
	
	public final void draw() {
		background(0x00999999);
//	    stroke(0xffcccccc);
//	    noStroke();
//	    fill(0xffaaaaaa);
		int o=0;
		int f=tick%nframes;
		for (int i=0;i<particles.length;i++) if (particles[i].toff>=nframes-f) { o=i; break; }

//		System.out.println("mouse "+mouseX+","+mouseY);
		final int swid = width;
		final int ox = mouseX>=0 && mouseX<swid ? mouseX : swid/2;
		final int oy = mouseY>=0 && mouseY<height ? mouseY : height/2;
		
		final int nframes2=nframes*nframes;
		loadPixels();
		for (int i=0;i<particles.length;i++) {
			final particle p=particles[(o+i)%particles.length];
			final int pf=(f+p.toff)%nframes;
			final int ipf=nframes-pf;
			final int ipf2 = ipf*ipf/nframes;
			final int iipf2 = nframes-ipf2;
			float x0 = ox+(p.x1-ox)/16f;
			float y0 = oy+(p.y1-oy)/16f;
			float cy=y0+(p.y1-y0)*iipf2/nframes;
			float cx=x0+(p.x1-x0)*iipf2/nframes;
			
//			int rad=20;
//			fill(0xffff0000|(p.toff<<8));
//			ellipse(cx, cy, rad, rad);

//			int op=pf<nframes>>2 ? (pf-(nframes>>2))*255/(nframes>>2) : ((nframes>>2))*255/(nframes*3>>2);
//			int op=(int)(256/Math.max(1,pf/5f));
			int op=ipf*256*ipf/nframes2;
//			int rad=40+(MAX_SIZE-40)*pf/nframes;
			int rad=(int)(Math.pow((float)pf/nframes,0.3)*MAX_SIZE);
			int rad2=rad*rad;
			int d=p.col;
			for (int y=-rad;y<cy+rad;y++) {
				int sy=(int) (cy+y);
				if (sy<0) continue;
				if (sy>=height) break;
				int y2=y*y;
				for (int x=-rad,off=sy*swid+(int)(cx+x);x<rad;x++,off++) {
					int sx=(int)(cx+x);
					if (sx<0) continue;
					if (sx>=swid) break;
					final int x2=x*x;
					if (y2+x2>rad2) continue;

					int c=pixels[off];
					int v = Math.max(c>>>24,Math.max(0, (int)(rad2-(x2+y2))*256/rad2)*op>>8);
					int u=256-v;
					pixels[off]=
						(((((c    )&0xff00ff)*u>>>8)&0x00ff00ff)+
						 ((((d    )&0xff00ff)*v>>>8)&0x00ff00ff))+
						(((((c>>>8)&0xff00ff)*u>>>8)&0x00ff00ff)+
						 ((((d>>>8)&0xff00ff)*v>>>8)&0x00ff00ff)<<8);
				}
			}
		}
		updatePixels();
		tick++;
	}