// zabnulvier v.008 - elout de kok - www.xs4all.nl/~elout/
// compiled in processing v.0067 - www.processing.org
// started 25 jan 2004 - last update 6 feb 2004

int fx=19,maxfx=19;
String fxname="";

BImage pixel_copy,my_imagebuffer,my_imagebuffer2;
int w,h;
 
//mouse and stuff
int midx,midy,mx=300,my=300,sx=20,sy=20,ox,oy,nx,ny,mousetimer;

int noisefactor=200; // make this bigger --> for more noise fun

// used for fps
int new_sec,old_sec,my_fps,temp_fps;

// use a precalculated random int buffer
// faster then calculating random() float`s all the time
int my_randombuffersize=5000;
int [] my_randombuffer=new int[my_randombuffersize];
int my_randomstep=1;
int my_randomposition=0;

//3d drawing stuff
int npoints=50;
float [] xd=new float[npoints];
float [] yd=new float[npoints];
float [] zd=new float[npoints];
int [] xxd=new int[npoints];
int [] yyd=new int[npoints];
int [] dr=new int[npoints];
int [] dg=new int[npoints];
int [] db=new int[npoints];


float pi=3.14159265f;

//for colour rotation
int mr,mg,mb;
int sr=1,sg=2,sb=3;
int blackpixel=( (0xff<<24) | (0<<16) | (0<<8) | 0);

//paintbomb
int bombtime=10;
int bombnum=60;
int [] bombx=new int[bombnum];
int [] bomby=new int[bombnum];
int [] bombsize=new int[bombnum];
int [] bombxspeed=new int[bombnum];
int [] bombyspeed=new int[bombnum];
int [] bombx1=new int[bombnum];
int [] bomby1=new int[bombnum];
int [] bombx2=new int[bombnum];
int [] bomby2=new int[bombnum];
int [] bombx3=new int[bombnum];
int [] bomby3=new int[bombnum];

//dripper
int dripnum=200;
int [] dripx=new int[dripnum];
int [] dripy=new int[dripnum];
int [] driplive=new int[dripnum];
int [] dripr=new int[dripnum];
int [] dripg=new int[dripnum];
int [] dripb=new int[dripnum];
int [] dripsize=new int[dripnum];
int [] dripxspeed=new int[dripnum];
int [] dripyspeed=new int[dripnum];

//curvedraw
int ppoints=10;
int [] pxd=new int[ppoints];
int [] pyd=new int[ppoints];

//zbuffer stuff thx to toxi
float[]  clearZ;
boolean strokecheck=false;

void setup()
{
  size(600, 300);
  cursor(CROSS);
  
  my_imagebuffer = new BImage(width, height);
  my_imagebuffer2 = new BImage(width, height);
  pixel_copy = new BImage(width, height);
  
  //set the zbuffer.
  clearZ=new float[width*height];
  System.arraycopy(g.zbuffer,0,clearZ,0,clearZ.length);
  
  //pixel_copy is now a reference of the pixels array
  //if the screen/pixels changes, pixel_copy will change as well 
  pixel_copy.pixels=pixels;
   
  midx=width/2;
  midy=height/2;
  w=width;
  h=height;

  // fill the precalculated random buffer with random-numbers
  for(int i=0; i<my_randombuffersize; i++){ my_randombuffer[i]=(int)random(256);}
  
  noStroke();
  ellipseMode(CENTER_DIAMETER); 
  background(100);
}

void loop()
{

  //clear the z-buffer, else the drawn lines won`t go away..
  if(strokecheck==true)
  {
    //clear the z-buffer
    System.arraycopy(clearZ,0,g.zbuffer,0,clearZ.length);
  }

  //check mouse position
  nx=mouseX;
  ny=mouseY;
  if (nx!=ox || ny!=oy)
  {
    mousetimer=0;
    ox=nx;
    oy=ny;
    mx=nx;
    my=ny;
  }
  
  //mousetimeout, after a while, 'automate' mouse
  mousetimer++;
  if (mousetimer>200)
  {
    //create a new mx/my
    mx=mx+((int) random(80)-40);
    my=my+((int) random(80)-40);
    if (mx<0){mx=mx+width;}
    if (mx>width){mx=mx-width;}
    if (my<0){my=my+height;}
    if (my>height){my=my-height;}
    //set a new random fx
    if(mousetimer>350)
    {
      fx=(int) random(maxfx+1);
      mousetimer=200+(int)random(150);
      System.arraycopy(pixels, 0, my_imagebuffer.pixels, 0, width*height);      
    }
  }
      
  if ( mx > midx){sx=0-((midx-mx)/2);}
  else{sx=((mx-midx)/2);}
  if ( my > midy){sy=0-((midy-my)/2);}
  else{sy=((my-midy)/2);}
    
  //animate  
  switch (fx)
  {
    case 0:  screennoise001();       break;     
    case 1:  screennoise002();       break;     
    case 2:  screennoise003();       break;     
    case 3:  screennoise004();       break;     
    case 4:  screennoise001b();      break;     
    case 5:  screennoise002b();      break;     
    case 6:  screennoise003b();      break;     
    case 7:  screennoise004b();      break;  
    case 8:  draw3d01();             break;  
    case 9:  draw3d02();             break; 
    case 10: paintbomb01();          break; 
    case 11: dripper01();            break; 
    case 12: dripper02();            break; 
    case 13: dripper03();            break; 
    case 14: dripper04();            break; 
    case 15: dripper05();            break; 
    case 16: scapeflow01();          break; 
    case 17: scapeflow02();          break; 
    case 18: curvedraw01();          break; 
    case 19: curvedraw02();          break; 
  }  

  //quick and dirty fps counter
  my_fps++;
  new_sec=second();
  if (new_sec!=old_sec)
  {
    old_sec=new_sec;
    temp_fps=my_fps;
    my_fps=0;
    status("fx:"+fx+" - "+fxname+" fps: "+ temp_fps+" - zabnulvier v.008 - elout de kok ©2004 -");
  }
  
  //just add a little delay so system can handle other stuff as well
  delay(5);

}

void mousePressed() 
{ 
  //fx++;
  //if(fx>maxfx){fx=0;}  
  fx=(int) random(maxfx+1);
  System.arraycopy(pixels, 0, my_imagebuffer.pixels, 0, width*height);      
} 
void keyPressed() 
{ 
    //println(key);
    if (key == 49){strokecheck=false; noStroke(); System.arraycopy(clearZ,0,g.zbuffer,0,clearZ.length);}   // 1
    if (key == 50){strokecheck=true; stroke(0);}    // 2
    if (key == 51){strokecheck=true; stroke(0,0,0,50);}  // 3
    if (key == 52){strokecheck=true; stroke(255);}  // 4
    if (key == 53){strokecheck=true; stroke(255,255,255,50);}  // 5
    if (key == 54){strokecheck=true; stroke(mr,mg,mb);}  // 6
    if (key == 55){strokecheck=true; stroke(mr,mg,mb,50);}  // 7
    if (key == 56){strokecheck=true; stroke(155);}  // 8
    if (key == 57){strokecheck=true; stroke(155,155,155,50);}  // 9
    if (key == 48){strokecheck=false; noStroke(); System.arraycopy(clearZ,0,g.zbuffer,0,clearZ.length);}  // 0
}

//a pre-calculated random buffer
private int get_my_random()
{
  my_randomposition=my_randomposition+my_randomstep;
  if (my_randomposition>=my_randombuffersize)
  {
    my_randomstep=(int) random(20)+1;
    my_randomposition=(int) random(20);
  }
  return (my_randombuffer[my_randomposition]);
}

//change a global color
void changecol()
{
  //red
  mr+=sr;
  if(mr>255)
  {
    mr=255;      
    sr=-((int)random(4)+1);
  } 
  if(mr<0)
  {
    mr=0;      
    sr=((int)random(4)+1);   
  }
  //green
  mg+=sg;
  if(mg>255)
  {
    mg=255;      
    sg=-((int)random(4)+1);
  } 
  if(mg<0)
  {
    mg=0;      
    sg=((int)random(4)+1);   
  }
  //blue
  mb+=sb;
  if(mb>255)
  {
    mb=255;      
    sb=-((int)random(4)+1);
  } 
  if(mb<0)
  {
    mb=0;      
    sb=((int)random(4)+1);   
  }
}

//-----------------------------------------------------------------
// start FX - animations
//-----------------------------------------------------------------

// fx=0 - screennoise 001
void screennoise001()
{
  fxname="noise 01";

  int sizer=get_my_random()%100+1;

  //draw something
  fill(get_my_random(),get_my_random(),get_my_random(),90);
  quad(mx-sizer,my-sizer,  mx+sizer,my-sizer, mx+sizer,my+sizer, mx-sizer,my+sizer);

  // my old trick; draw the same screen onto the same screen
  // with a slighty different offset
  image(pixel_copy, get_my_random()%noisefactor-noisefactor/2,get_my_random()%noisefactor-noisefactor/2 );
}

//---------------------------------------------------------------------------
// fx=1 - screennoise 002
void screennoise002()
{
  fxname="noise 02";

  int sizer=get_my_random()%100+1;
  fill(get_my_random(),get_my_random(),get_my_random(),80);
  quad(mx-sizer,my-sizer,  mx+sizer,my-sizer, mx+sizer,my+sizer, mx-sizer,my+sizer);

  // draw the same screen onto the same screen
  image(pixel_copy, -sx/2,-sy/2 );
}


//---------------------------------------------------------------------------
// fx=2 - screennoise 003 - train vertical
void screennoise003()
{
  fxname="noise train vertical";

  int sizer=get_my_random()%100+1;
  fill(get_my_random(),get_my_random(),get_my_random(),80);  
  quad(mx-sizer,my-sizer,  mx+sizer,my-sizer, mx+sizer,my+sizer, mx-sizer,my+sizer);

  // draw the same screen onto the same screen
  image(pixel_copy, 0,-sy/2 );
}
// fx=3 - screennoise 004  train horizontal
void screennoise004()
{
  fxname="noise train horizontal";
  int sizer=get_my_random()%100+1;
  fill(get_my_random(),get_my_random(),get_my_random(),40);
  quad(mx-sizer,my-sizer,  mx+sizer,my-sizer, mx+sizer,my+sizer, mx-sizer,my+sizer);

  //draw the same screen onto the same screen
  image(pixel_copy, -sx/2,0 );
}

//---------------------------------------------------------------------------
// fx=4 - screennoise 001b
void screennoise001b()
{
  fxname="noise 1b";

  int sizer=get_my_random()%100+1;

  changecol();
  fill(mr,mg,mb,160);
  quad(mx-sizer,my-sizer,  mx+sizer,my-sizer, mx+sizer,my+sizer, mx-sizer,my+sizer);

  //now copy the screen to my screenbuffer 
  // arraycopy: source,start, destiny,start , size
  System.arraycopy(pixels, 0, my_imagebuffer.pixels, 0, width*height);

  //draw the same screen onto the same screen
  image(my_imagebuffer, get_my_random()%noisefactor-noisefactor/2,get_my_random()%noisefactor-noisefactor/2 );
}

//---------------------------------------------------------------------------
// fx=5 - screennoise 002b
void screennoise002b()
{
  fxname="noise 2b";
  int sizer=get_my_random()%100+1;
  changecol();
  fill(mr,mg,mb,160);
  quad(mx-sizer,my-sizer,  mx+sizer,my-sizer, mx+sizer,my+sizer, mx-sizer,my+sizer);

  //now copy the screen to my screenbuffer 
  System.arraycopy(pixels, 0, my_imagebuffer.pixels, 0, width*height);

  // draw the same screen onto the same screen
  image(my_imagebuffer, -sx/2,-sy/2 );
}


//---------------------------------------------------------------------------
// fx=6 - screennoise 003 - train vertical
void screennoise003b()
{
  fxname="noise train'B' vertical";
  int sizer=get_my_random()%100+1;
  changecol();
  fill(mr,mg,mb,160);
  quad(mx-sizer,my-sizer,  mx+sizer,my-sizer, mx+sizer,my+sizer, mx-sizer,my+sizer);

  //now copy the screen to my screenbuffer 
  System.arraycopy(pixels, 0, my_imagebuffer.pixels, 0, width*height);
  
  // draw the same screen onto the same screen
  image(my_imagebuffer, 0,-sy/2 );
}

//---------------------------------------------------------------------------
// fx=7 - screennoise 004b  train horizontal
void screennoise004b()
{
  fxname="noise train'B' horizontal";
  int sizer=get_my_random()%100+1;
  changecol();
  fill(mr,mg,mb,160);
  quad(mx-sizer,my-sizer,  mx+sizer,my-sizer, mx+sizer,my+sizer, mx-sizer,my+sizer);

  //now copy the screen to my screenbuffer 
  System.arraycopy(pixels, 0, my_imagebuffer.pixels, 0, width*height);

  image(my_imagebuffer, -sx/2,0 );
}

//---------------------------------------------------------------------------
//3D structure
void draw3d01()
{
  fxname="draw 3D 01";	
  float rotatex= (float) (sx + sy) / 2;
  float rotatey= (float) sy;
  float rotatez= (float) sx;
  float qdx,qdy,qdz;
  rotatex=(rotatex/180*pi)/160;
  rotatey=(rotatey/180*pi)/160;
  rotatez=(rotatez/180*pi)/160;

  System.arraycopy(pixel_copy.pixels, 0,pixels , 0, width*height);
			
  for (int i=0; i<npoints-1; i++)
  {
    xd[i]=xd[i+1];
    yd[i]=yd[i+1];
    zd[i]=zd[i+1];
    dr[i]=dr[i+1];
    dg[i]=dg[i+1];
    db[i]=db[i+1];    
  }
  xd[npoints-1]=(float) (mx-midx)/66.0f;
  yd[npoints-1]=(float) (my-midy)/66.0f;
  zd[npoints-1]=sx/66.0f;

  changecol();
  changecol();
  dr[npoints-1]=mr;
  dg[npoints-1]=mg;
  db[npoints-1]=mb;    

  // begin 3d stuff		
  for (int i=0;i<=npoints-1;i++)
  {
    qdy=yd[i];
    qdz=zd[i];
    yd[i]=(float)( qdy*Math.cos(rotatex) - qdz*Math.sin(rotatex));
    zd[i]=(float)( qdz*Math.cos(rotatex) + qdy*Math.sin(rotatex));
    qdz=zd[i];
    qdx=xd[i];
    zd[i]=(float)( qdz*Math.cos(rotatey) - qdx*Math.sin(rotatey));
    xd[i]=(float)( qdx*Math.cos(rotatey) + qdz*Math.sin(rotatey));
    qdx=xd[i];
    qdy=yd[i];
    xd[i]=(float)( qdx*Math.cos(rotatez) - qdy*Math.sin(rotatez));
    yd[i]=(float)( qdy*Math.cos(rotatez) + qdx*Math.sin(rotatez));
  }

  for (int i=0;i<=npoints-1;i++)
  {
    xxd[i]=(int)(xd[i]*(5/(5+zd[i]))*midx/2+midx);
    yyd[i]=(int)(yd[i]*(5/(5+zd[i]))*midy/2+midy);
  }
			
  for (int i=0;i<npoints-3;i=i+2)
  {
    fill(dr[i],dg[i],db[i],60);
    triangle(xxd[i], yyd[i], xxd[i+1], yyd[i+1], midx, midy);
  }
}

//---------------------------------------------------------------------------
//3d structure p2
void draw3d02()
{	
  fxname="draw 3D 02";	
  float rotatex= (float) (sx + sy) / 2;
  float rotatey= (float) sy;
  float rotatez= (float) sx;
  float qdx,qdy,qdz;
  rotatex=(rotatex/180*pi)/140;
  rotatey=(rotatey/180*pi)/140;
  rotatez=(rotatez/180*pi)/140;

  System.arraycopy(pixel_copy.pixels, 0,pixels , 0, width*height);
    				
  for (int i=0; i<npoints-1; i++)
  {
    xd[i]=xd[i+1];
    yd[i]=yd[i+1];
    zd[i]=zd[i+1];
    dr[i]=dr[i+1];
    dg[i]=dg[i+1];
    db[i]=db[i+1];    
  }
  xd[npoints-1]=(float) (mx-midx)/66.0f;
  yd[npoints-1]=(float) (my-midy)/66.0f;
  zd[npoints-1]=sx/66.0f;

  changecol();
  changecol();
  dr[npoints-1]=mr;
  dg[npoints-1]=mg;
  db[npoints-1]=mb;    

  // begin 3d stuff		
  for (int i=0;i<=npoints-1;i++)
  {
    qdy=yd[i];
    qdz=zd[i];
    yd[i]=(float)( qdy*Math.cos(rotatex) - qdz*Math.sin(rotatex));
    zd[i]=(float)( qdz*Math.cos(rotatex) + qdy*Math.sin(rotatex));
    qdz=zd[i];
    qdx=xd[i];
    zd[i]=(float)( qdz*Math.cos(rotatey) - qdx*Math.sin(rotatey));
    xd[i]=(float)( qdx*Math.cos(rotatey) + qdz*Math.sin(rotatey));
    qdx=xd[i];
    qdy=yd[i];
    xd[i]=(float)( qdx*Math.cos(rotatez) - qdy*Math.sin(rotatez));
    yd[i]=(float)( qdy*Math.cos(rotatez) + qdx*Math.sin(rotatez));
  }

  for (int i=0;i<=npoints-1;i++)
  {
    xxd[i]=(int)(xd[i]*(5/(5+zd[i]))*midx/2+midx);
    yyd[i]=(int)(yd[i]*(5/(5+zd[i]))*midy/2+midy);
  }
			
  for (int i=0;i<npoints-3;i=i+4)
  {
    fill(dr[i],dg[i],db[i],60);
    triangle(xxd[i], yyd[i], xxd[i+1], yyd[i+1], xxd[25], yyd[25]);
    triangle(xxd[npoints-1], yyd[npoints-1], xxd[i+1], yyd[i+1], xxd[i+2], yyd[i+2]);
    //triangle(xxd[1], yyd[1], xxd[i+1], yyd[i+1], xxd[i+3], yyd[i+3]);  
  }
}

//---------------------------------------------------------------------------
//triangle explosion
void paintbomb01()
{
  fxname="trianglebomb 01";	
  bombtime++;
  if (bombtime>12)
  {
    System.arraycopy(pixels, 0, my_imagebuffer.pixels, 0, width*height);
    bombtime=0;
    for (int i=0;i<bombnum;i++)
    {
      bombx[i]=mx;
      bomby[i]=my;
      bombxspeed[i]=(int)random(20)-10;
      bombyspeed[i]=(int)random(20)-10;
      bombsize[i]=(int)random(40)+8;
      bombtime=(int)random(10);
      bombx1[i]=(int)random(80)-40;
      bomby1[i]=(int)random(80)-40;
      bombx2[i]=(int)random(80)-40;
      bomby2[i]=(int)random(80)-40;
      bombx3[i]=(int)random(80)-40;
      bomby3[i]=(int)random(80)-40;      
    }
  }   
  // draw the same screen onto the same screen
  // image(my_imagebuffer, 0,0 );  
  System.arraycopy(my_imagebuffer.pixels, 0,pixels , 0, width*height);
  
  changecol();
  fill(mr,mg,mb,160);
  for (int i=0;i<bombnum;i++)
  {
    triangle(bombx[i]+bombx1[i],bomby[i]+bomby1[i], bombx[i]+bombx2[i],bomby[i]+bomby2[i], bombx[i]+bombx3[i],bomby[i]+bomby3[i]);
    bombx[i]=bombx[i]+bombxspeed[i];
    bomby[i]=bomby[i]+bombyspeed[i];    
  }
}

//---------------------------------------------------------------------------
//dripping dots
void dripper01()
{
  fxname="dripper01 - dots";

  for (int i=0;i<dripnum;i++)
  {
    driplive[i]--;
    if(driplive[i]<0)
    {
      dripx[i]=mx;
      dripy[i]=my;
      driplive[i]=(int) random(100)+10;
      if(i<10){changecol();}
      dripr[i]=mr;
      dripg[i]=mg;
      dripb[i]=mb;
      dripsize[i]=(int) random(80)+10;
    }
    dripsize[i]--;
    if (dripsize[i]<10){ dripsize[i]=10;}
    fill(dripr[i],dripg[i],dripb[i],100);
    ellipse(dripx[i],dripy[i], dripsize[i]/5,dripsize[i]/5);
    dripy[i]+=driplive[i]/20;
    if (driplive[i]/20<1){dripy[i]++;}
    if (dripy[i]>height){driplive[i]=0;}
  }
}

//---------------------------------------------------------------------------
//drip explosion
void dripper02()
{
  fxname="dripper02 - drip explo";

  for (int i=0;i<dripnum;i++)
  {
    driplive[i]--;
    if(driplive[i]<0)
    {
      dripx[i]=mx;
      dripy[i]=my;
      driplive[i]=(int) random(100)+10;
      if(i<20){changecol();}
      dripr[i]=mr;
      dripg[i]=mg;
      dripb[i]=mb;
      dripsize[i]=(int) random(80)+10;
      dripxspeed[i]=(int) random(8)-4;
      dripyspeed[i]=(int) random(8)-4;      
    }
    dripsize[i]--;
    if (dripsize[i]<10){ dripsize[i]=10;}
    fill(dripr[i],dripg[i],dripb[i],160);
    ellipse(dripx[i],dripy[i], dripsize[i]/5,dripsize[i]/5);    
    dripx[i]+=driplive[i]/20+dripxspeed[i];
    dripy[i]+=driplive[i]/20+dripyspeed[i];
    if (driplive[i]/20<1){dripy[i]++;dripxspeed[i]=0;dripyspeed[i]=0;}
    if (dripx[i]>width){driplive[i]=0;}
    if (dripy[i]>height){driplive[i]=0;}
    if (dripx[i]<0){driplive[i]=0;}
    if (dripy[i]<0){driplive[i]=0;}
  }
}

//---------------------------------------------------------------------------
// dripper horizontal lines
void dripper03()
{
  fxname="dripper03 - horizontal";

  for (int i=0;i<dripnum;i++)
  {
    driplive[i]--;
    if(driplive[i]<0)
    {
      dripx[i]=mx;
      dripy[i]=my;
      driplive[i]=(int) random(100)+10;
      if(i<10){changecol();}
      dripr[i]=mr;
      dripg[i]=mg;
      dripb[i]=mb;
      dripsize[i]=(int) random(80)+10;
      dripxspeed[i]=(int) random(80)-40;
      dripyspeed[i]=(int) random(80)-40;      
    }
    dripsize[i]--;
    if (dripsize[i]<10){ dripsize[i]=10;}
    fill(dripr[i],dripg[i],dripb[i],160);
    ellipse(dripx[i],dripy[i], dripsize[i]/5,dripsize[i]/5);
    
    dripx[i]+=(int)((float)dripxspeed[i]/10);
   // dripy[i]+=(int)((float)dripyspeed[i]/10);
    if (driplive[i]/20<2){dripy[i]++;dripxspeed[i]=0;dripyspeed[i]=0;}
    if (dripx[i]>width){driplive[i]=0;}
    if (dripy[i]>height){driplive[i]=0;}
    if (dripx[i]<0){driplive[i]=0;}
    if (dripy[i]<0){driplive[i]=0;}
  }
}


//---------------------------------------------------------------------------
// dripper thin random line moving
void dripper04()
{
  fxname="dripper04 - thin lines";

  for (int i=0;i<dripnum;i++)
  {
    driplive[i]--;
    if(driplive[i]<0)
    {
      dripx[i]=mx;
      dripy[i]=my;
      driplive[i]=(int) random(100)+10;
      if(i<10){changecol();}
      dripr[i]=mr;
      dripg[i]=mg;
      dripb[i]=mb;
      dripsize[i]=(int) random(40)+10;
      dripxspeed[i]=(int) random(80)-40;
      dripyspeed[i]=(int) random(80)-40;      
    }
    dripsize[i]--;    
    if (dripsize[i]<10){ dripsize[i]=10;}
    fill(dripr[i],dripg[i],dripb[i],160);
    ellipse(dripx[i],dripy[i], dripsize[i]/5,dripsize[i]/5);
    
    dripx[i]+=(int)((float)dripxspeed[i]/10);
    dripy[i]+=(int)((float)dripyspeed[i]/10);
    dripxspeed[i]=dripxspeed[i]+(int)random(20)-10;
    dripyspeed[i]=dripyspeed[i]+(int)random(20)-10;
    if (driplive[i]/20<2){dripy[i]++;dripxspeed[i]=0;dripyspeed[i]=0;}
    if (dripx[i]>width){driplive[i]=0;}
    if (dripy[i]>height){driplive[i]=0;}
    if (dripx[i]<0){driplive[i]=0;}
    if (dripy[i]<0){driplive[i]=0;}
  }
}

//---------------------------------------------------------------------------
// dripper starlines
void dripper05()
{
  fxname="dripper05 - starlines";

  for (int i=0;i<dripnum;i++)
  {
    driplive[i]--;
    if(driplive[i]<0)
    {
      dripx[i]=mx;
      dripy[i]=my;
      driplive[i]=(int) random(100)+10;
      if(i<10){changecol();}
      dripr[i]=mr;
      dripg[i]=mg;
      dripb[i]=mb;
      dripsize[i]=(int) random(40)+10;
      dripxspeed[i]=(int) random(80)-40;
      dripyspeed[i]=(int) random(80)-40;      
    }
    dripsize[i]--;    
    if (dripsize[i]<10){ dripsize[i]=10;}
    fill(dripr[i],dripg[i],dripb[i],160);
    ellipse(dripx[i],dripy[i], dripsize[i]/5,dripsize[i]/5);
    
    dripx[i]+=(int)((float)dripxspeed[i]/10.0f);
    dripy[i]+=(int)((float)dripyspeed[i]/10.0f);
    if (dripx[i]>width){driplive[i]=0;}
    if (dripy[i]>height){driplive[i]=0;}
    if (dripx[i]<0){driplive[i]=0;}
    if (dripy[i]<0){driplive[i]=0;}
  }
}
//---------------------------------------------------------------------------
// landscape flow
void scapeflow01()
{
  fxname="landscapeflow01";
  if (sx>0){ scroll01(my_imagebuffer.pixels,my_imagebuffer2.pixels,sx/6); }
  else {scroll02(my_imagebuffer.pixels,my_imagebuffer2.pixels,-sx/6); }
  if (sy>0){scroll03(my_imagebuffer2.pixels,my_imagebuffer.pixels,sy/2); }
  else {scroll04(my_imagebuffer2.pixels,my_imagebuffer.pixels,-sy/2); }  
  changecol();
  blackpixel=( (0xff<<24) | (0<<16) | (0<<8) | 0);
  for (int i=0;i<20000;i++)
  {
    ppoint(my_imagebuffer.pixels,(int)random((width*height)-1), mr/6, mg/6, mb/6);
  }
  //update the screen, faster then using image()
  System.arraycopy(my_imagebuffer.pixels, 0,pixels , 0, width*height);
}

// landscape flow
void scapeflow02()
{
  fxname="landscapeflow02 - inverse";
  if (sx>0){ scroll01(my_imagebuffer.pixels,my_imagebuffer2.pixels,sx/6); }
  else {scroll02(my_imagebuffer.pixels,my_imagebuffer2.pixels,-sx/6); }
  if (sy>0){scroll03(my_imagebuffer2.pixels,my_imagebuffer.pixels,sy/2); }
  else {scroll04(my_imagebuffer2.pixels,my_imagebuffer.pixels,-sy/2); }  
  changecol();
  blackpixel=( (0xff<<24) | (mr<<16) | (mg<<8) | mb);
  for (int i=0;i<20000;i++)
  {
    ppoint2(my_imagebuffer.pixels,(int)random((width*height)-1), mr/15, mg/15, mb/15);
  }
  //update the screen, faster then using image()
  System.arraycopy(my_imagebuffer.pixels, 0,pixels , 0, width*height);
}
// routines needed for the scapeflow ----------
void ppoint(int output[],int posi, int r, int g, int b)
{
  r=r+((output[posi] >> 16) & 0xff);
  g=g+((output[posi] >>  8) & 0xff);
  b=b+(output[posi] & 0xff);
  if (r>255){r=255;}
  if (g>255){g=255;}
  if (b>255){b=255;}
  output[posi] =  ( (0xff<<24) | (r<<16) | (g<<8) | b);
}
// ppoint2----------
void ppoint2(int output[],int posi, int r, int g, int b)
{
  r=((output[posi] >> 16) & 0xff)-r;
  g=((output[posi] >>  8) & 0xff)-g;
  b=(output[posi] & 0xff)-b;
  if (r<0){r=0;}
  if (g<0){g=0;}
  if (b<0){b=0;}
  output[posi] =  ( (0xff<<24) | (r<<16) | (g<<8) | b);
}
// horizontal to right
void scroll01(int input[], int output[], int step)
{
  for (int i=0;i<h; i++)
  {
    copyar2(input, output, (i*w), step+(i*w), w-step);
  }

  // make black whats old
  for (int j=0;j<step;j++)
  {
    for (int i=0;i<h ;i++)
    {
      output[(i*w)+j]=blackpixel;
    }
  }
}
// horizontal to left
void scroll02(int input[], int output[], int step)
{
  for (int i=0;i<h; i++)
  {
    copyar2(input, output,step+(i*w), (i*w), w-step);
  }
  // make black whats old
  for (int j=0;j<step;j++)
  {
    for (int i=0;i<h ;i++)
    {
      output[(i*w)+(w-j-1)]=blackpixel;
    }
  }
}
// vertical down
void scroll03(int input[], int output[], int step)
{
  for (int i=0;i<h-step; i++)
  {
    copyar2(input, output, 0+(i*w), (step*w)+(i*w), w);
  }
  // make black whats old
  for (int j=0;j<step;j++)
  {
    for (int i=0;i<w ;i++)
    {
      output[(j*w)+i]=blackpixel;
    }
  }
}
// vertical up
void scroll04(int input[], int output[], int step)
{
  for (int i=0;i<h-step; i++)
  {
    copyar2(input, output, (step*w)+(i*w), (i*w), w);
  }
  // make black whats old
  for (int j=0;j<step;j++)
  {
    for (int i=0;i<w ;i++)
    {
      output[( ((h-1)-j) *w) +i ]=blackpixel;
    }
  }
}
void copyar2(int input[], int output[], int inputstart, int outputstart, int sizer) // source, destination
{	
  System.arraycopy(input, inputstart, output, outputstart, sizer);
}

//---------------------------------------------------------------------------
//curvedraw no.1
void curvedraw01()
{
  fxname="curvedraw 01";
  changecol();
  fill(mr,mg,mb,100);
  
  for (int i=0; i<ppoints-1; i++)
  {
    pxd[i]=pxd[i+1]+(int)random(40)-20;
    pyd[i]=pyd[i+1]+(int)random(40)-20;
  }
  pxd[ppoints-1]= mx;
  pyd[ppoints-1]= my;
  
  beginShape(POLYGON); 
    for (int i=0;i<ppoints-1;i++)
    {
      curveVertex(pxd[i], pyd[i]);   
    }
  endShape();   
}

//---------------------------------------------------------------------------
//curvedraw 2
void curvedraw02()
{
  fxname="curvedraw 02";
  changecol();
  fill(mr,mg,mb,140);
  
  for (int i=0; i<ppoints-1; i++)
  {
    pxd[i]=pxd[i+1]+sx/2;//+(int)random(40)-20;
    pyd[i]=pyd[i+1]+sy/2;//+(int)random(40)-20;
  }
  pxd[ppoints-1]= mx;
  pyd[ppoints-1]= my;
  
  beginShape(POLYGON); 
    for (int i=0;i<ppoints;i++)
    {
      curveVertex(pxd[i], pyd[i]);   
    }
  endShape();   
}