/*Processing Framework <Cine X2 Engine>
Copyright@taka.BRK 20090513
*/
float[] squareX,squareY;
int wNum,hNum,array;
float angle,rSize,a;
int Length = 20;
float[] X = new float[Length],Y = new float[Length],Ang = new float[Length],Rot = new float[Length],c = new float[Length],Radius = new float[Length]; 
float cx,cy,power = 0,MaxPower = 200;
float fluc_color;
float fluc_y;

class cineX2{
  cineX2(){
    colorMode(RGB,256);
  }
  void card_shuffle(){
    stroke(0,0,0);
    strokeWeight(1);
    frameRate(24);
    colorMode(RGB,256);
    angle += 0.01f;
    for(int i=0;i<256;i++){
      translate(width/2,height/2);
      rotate(sin(angle)*cos(angle)*tan(angle));
      rect(i/cos(angle),-i*sin(angle),width/3,height/3);
      rectMode(CENTER);
      fill(0,i,256-i);
    }
  }
  void pink_pi(){
    colorMode(RGB,256);
    frameRate(24);
    noStroke();
    for(int i=0;i<100;i++){
      a += 0.001f;
      fill(256,i,256-i);
      rotate(a);
      ellipse(width/2,height/2,100,100);
    }
  }
  void RBW(){
    stroke(0);
    strokeWeight(1);
    angle += 0.00003f;
    for(int i=0;i<256;i++){
      rotate(cos(angle)*cos(angle)+sin(angle)+tan(angle)/2);
      translate(width/2,height/2);
      fill(i,256-i,0);
      plus(i,20);

      fill(0,0,i);
      ellipse(width/2,-i,50,50);
      ellipseMode(CENTER);

      fill(i,i,i);
      ellipse(width/1.3f,i,10,10);
      ellipseMode(CENTER);
    }
  }

  public void plus(int s,int t){
    beginShape();
    vertex( -t,  s );
    vertex(  t,  s );
    vertex(  t,  t );
    vertex(  s,  t );
    vertex(  s, -t );
    vertex(  t, -t );
    vertex(  t, -s );
    vertex( -t, -s );
    vertex( -t, -t );
    vertex( -s, -t );
    vertex( -s,  t );
    vertex( -t,  t );  
    endShape(CLOSE);
  }
  void worp_man(){
    frameRate(15);
    for(int k=0;k<5;k++){
       stroke(random(255),random(255),random(255));
       ellipse(width/2,height/2,random(1000),random(1000));
       fill(random(255),0,0,30); 
    }
  }
  void prism(){
  for(int i=0;i<5;i++){
      stroke(255-random(100),255-random(100),255-random(100),70);
      line(width/2,0,random(1000),random(1000));
      rotate(radians(360));
    }
  }
  void sonw_circle(){
    angle += 0.01f;
    for(int i=0;i<256;i++){
      translate(width/2,height/2);
      rotate(sqrt(2)*sin(angle));
      ellipse(i,i,10,10);
      fill(256,256,256);
    }
  }
  void spider_ball(){
    frameRate(24);
    stroke(0);
    strokeWeight(1);
    angle += 0.01f;
    for(int i = 0;i<256;i++){
      translate(i,i);
      rotate(cos(angle)*cos(angle));
      ellipse(i,i,100,100);
      fill(i,0,256-i);
    }
  }
  void powerBall(){
    colorMode(HSB,100);
    noStroke();
    fadeToWhite();
    if(power>0){
      for(int i=0;i<Length;i++){
        Ang[i] += Rot[i] * (power/10);
        X[i] = cx + (power * sin(radians(Ang[i])));
        Y[i] = cy + (power * cos(radians(Ang[i])));
        fill(c[i],80,100,min(power,80));
        ellipse(X[i],Y[i],Radius[i],Radius[i]);
      }
    }
    if(mousePressed){
      cx = mouseX;
      cy = mouseY;
      if(power<MaxPower)power += 1;
    }
    else{
      if(power>1)power = power * 0.98;
      else power=0;
    }
  }

  public void fadeToWhite(){
    rectMode(CORNER);
    fill(100,30);
    rect(0,0,width,height);
  }

  public void mousePressed(){
    power = 0;
    for(int i = 0;i < Length;i++){
      Radius[i] = random(10,30);
      c[i] = random(100);
      Rot[i] = random(-5,5);
    }
  }
  void rect_draw(){
    frameRate(30);
    stroke(random(256),random(256),random(256),30);
    int x = int(random(width));
    int y = int(random(height));
    rectLines(x,y,30,30);
  }
  void rectLines(int x,int y,int w,int h){
    line(x,y,x+w,y);
    line(x,y,x,y+h);
    line(x+w,y,x+w,y+h);
    line(x,y+h,x+w,y+h);
  }
  void randomLine(){
    colorMode(HSB,100);
    for(int i=0;i<1000;i++){
      stroke(random(256),random(256),random(256),30);
      line(random(width),random(3*width),random(height),height);
    }
  }
  void curveEffect(){
    for(int i=0;i<256;i++){
      stroke(0,0,i);
      strokeWeight(4);
      curve(i,0,i+160,60,40,i+120,160,200);
      curve(0,0,width-i,height-i*2,i*12,i*i,i*i,width/2);
      curve(width,height,0,0,sin(45)*i+width,cos(60)*i+height,width,0);
      curve(width/2,height/2,width*sin(60),height*cos(45)*cos(30),0,0,width,height);
    }
  }
  void sea(){
    fluc_color = 0;
    for(int j=0;j<=height;j+=5){
      fluc_color += random(-50,50);
      stroke(fluc_color,60,100,30);
      fluc_y = 0;
      beginShape();
      for(int i=0;i<=width;i+=5){
        fluc_y += random(-2,2);
        vertex(i,j+fluc_y);
      }
      endShape();
    }
  }
  void crimson_world(){
    stroke(255,0,0,70);
    colorMode(RGB);
    frameRate(10);
    noFill();
    for(int i = 0;i<30;i++){
      ellipse(random(width/2),random(height/2),random(width/2)+300,random(height/2)+300);
      rotateX(radians(i*15));
      rotateY(radians(i*5));
    }
  }
  float xmag,ymag,newXmag,newYmag = 0;
  void qube(){ 
    noStroke();
    colorMode(RGB,1);
    pushMatrix();
    translate(width/2,height/2,-30);
    float newXmag = mouseX/PApplet.parseFloat(width)*TWO_PI;
    float newYmag = mouseY/PApplet.parseFloat(height)*TWO_PI;
    float diff = xmag-newXmag;
    if(abs(diff)>0.01f){
      xmag -= diff/4.0f;
    }
    diff = ymag-newYmag;
    if(abs(diff)>0.01f){
      ymag -= diff/4.0f;
    }
    rotateX(-ymag);
    rotateY(-xmag);
    scale(50);
    beginShape(QUADS);
    fill(0,1,1);
    vertex(-1,1,1);
    fill(1,1,1);
    vertex(1,1,1);
    fill(1,0,1);
    vertex(1,-1,1);
    fill(0,0,1);
    vertex(-1,-1,1);
    fill(1,1,1);
    vertex(1,1,1);
    fill(1,1,0);
    vertex(1,1,-1);
    fill(1,0,0);
    vertex(1,-1,-1);
    fill(1,0,1);
    vertex(1,-1,1);
    fill(1,1,0);
    vertex(1,1,-1);
    fill(0,1,0);
    vertex(-1,1,-1);
    fill(0,0,0);
    vertex(-1,-1,-1);
    fill(1,0,0);
    vertex(1,-1,-1);
    fill(0,1,0);
    vertex(-1,1,-1);
    fill(0,1,1);
    vertex(-1,1,1);
    fill(0,0,1);
    vertex(-1,-1,1);
    fill(0,0,0);
    vertex(-1,-1,-1);
    fill(0,1,0);
    vertex(-1,1,-1);
    fill(1,1,0);
    vertex(1,1,-1);
    fill(1,1,1);
    vertex(1,1,1);
    fill(0,1,1);
    vertex(-1,1,1);
    fill(0,0,0);
    vertex(-1,-1,-1);
    fill(1,0,0);
    vertex(-1,-1,-1);
    fill(1,0,1);
    vertex(1,-1,1);
    fill(0,01);
    vertex(-1,-1,1);
    endShape();
    popMatrix();
  }
  void check(){
    colorMode(RGB,10);
    noStroke();
    fill(0,0,0,5);
    for(int i=0;i<5;i++){
      rect(0,10+i*40,width,20);
      rect(10+i*40,0,20,height);
    }
    fill(10,10,10,3);
    for(int i=0;i<5;i++){
      rect(0,10+i*40+3,width,2);
      rect(0,10+i*40+15,width,2);
      rect(10+i*40+3,0,2,height);
      rect(10+i*40+13,0,2,height);
    }
  }
  void pushText(String fontsrc){
    int MaxColor;
    PFont font;
    MaxColor = 100;
    colorMode(HSB,MaxColor);
    frameRate(10);
    font = loadFont(fontsrc);
    textFont(font);
    textAlign(CENTER);
    if(keyPressed){
      fill(random(MaxColor),MaxColor,MaxColor,80);
      text(key,random(width),random(height));
    }
  }
  void keyPressed(){
    switch(key){
    case ' ':
      background(0);
      break;
    }
  }
}
class fireCube{
  int [][] fire;
  color[] palette;
  float angle;
  int[] calc1,calc2,calc3,calc4,calc5;
  PGraphics pg;
  fireCube(int wi,int hi){
    size(wi,hi,P2D);
    pg = createGraphics(width,height,P3D);
    calc1 = new int[width];
    calc3 = new int[width];
    calc4 = new int[width];
    calc2 = new int[height];
    calc5 = new int[height];
    colorMode(HSB);
    fire = new int[width][height];
    palette = new color[255];
    for(int x = 0;x<palette.length;x++){
      palette[x] = color(x/3,255,constrain(x*3,0,255));
    }
    for(int x=0;x<width;x++){
      calc1[x] = x % width;
      calc3[x] = (x-1+width) % width;
      calc4[x] = (x+1) % width;
    }
    for(int y=0;y<height;y++){
      calc2[y] = (y+1) % height;
      calc5[y] = (y+2) % height;
    }
  }
  void draw(){
    angle = angle + 0.05;
    pg.beginDraw();
    pg.translate(width>>1,height>>1);
    pg.rotateX(sin(angle/2));
    pg.rotateY(cos(angle/2));
    pg.background(0);
    pg.stroke(128);
    pg.scale(25);
    pg.noFill();
    pg.box(4);
    pg.endDraw();
    for(int x = 0; x < width; x++){
      fire[x][height-1] = int(random(0,190)) ;
    }
    loadPixels();
    int counter=0;
    for(int y=0;y<height;y++){
      for(int x=0;x<width;x++){
        fire[x][y] = ((fire[calc3[x]][calc2[y]]
        + fire[calc1[x]][calc2[y]]
        + fire[calc4[x]][calc2[y]]
        + fire[calc1[x]][calc5[y]])<<5)/129;
        pixels[counter] = palette[fire[x][y]];
        if((pg.pixels[counter++]>>16 & 0xFF) == 128){
          fire[x][y] = 128;
        }
      }
    }
    updatePixels();
  }
}
class loadPics{
  PImage bg;
  loadPics(String src){
    bg = loadImage(src);
  }
  void back(){
    background(bg);
  } 
  void img(float _w,float _h){
    image(bg,_w,_h);
  }
}

class reflesh{
  int r,g,b,_alpha;
  reflesh(int _r,int _g,int _b,int _a){
    r = _r;
    g = _g;
    b = _b;
    _alpha = _a;
  }
  void draw(){
    rectMode(CORNER);
    fill(r,g,b,_alpha);
    rect(0,0,width,height);
  }
}
class randomLine2{
  int range_color,range_y;
  float fluc_color;
  randomLine2(int _rc,int _ry,float _fc){
    range_color = _rc;
    range_y = _ry;
    fluc_color = _fc;
  }
  void draw(){
    noFill();
    rectMode(CENTER);
    for(int i=0;i<height;i++){
      fluc_color += random(-range_color,range_color);
      stroke(fluc_color,60,100,60);
      float fluc_y = 0;
      beginShape();
      for(int j=0;j<width;j+=5){
        fluc_y += random(-range_y,range_y);
        vertex(j,i+fluc_y);
      }
      endShape();
    }
  }
}
class sunflower_shuffle{
  loadPics img;
  float angle,rSize,a;
  sunflower_shuffle(String imgsrc){
    img = new loadPics(imgsrc);
    frameRate(25);
  }
  void draw(){
    angle += 0.01f;
    for(int i=0;i<80;i++){
      rotateX(cos(angle)*cos(angle));
      rotateY(sin(angle)*tan(angle));
      img.img(160,160);
    }
  }
}
class font_circle{
  font_circle(String fontsrc){
    PFont font = loadFont(fontsrc);
    textFont(font);
    textAlign(CENTER);
  }
  void draw(){
    colorMode(HSB,100);
    int count = 0;
    while(count<400){
      float x = 200-random(width);
      float y = 200-random(height);
      float distance = sqrt(x*x+y*y);
      if(distance<150){
        textSize(random(10,20));
        fill(random(50,60),100,100,80);
        text("SEA",200+x,200+y);
        count++;
      }
    }
  }
}

class remort_contorol{
  int MaxColor;
  float X,Y,Speed,Angle,MaxSpeed = 10;
  remort_contorol(){
    MaxColor = width;
    background(MaxColor);
    rectMode(CENTER);
    frameRate(10);
  }
  void draw(){
    colorMode(HSB,MaxColor);
    X = width/2;
    Y = height/2;
    Speed = 0;
    Angle = 0;
    float acc = (mouseY-(height/2));
    Speed += acc*0.01;
    if(Speed<-MaxSpeed)Speed = -MaxSpeed;
    if(Speed>MaxSpeed)Speed = MaxSpeed;
    float ang = ((width/2)-mouseX);
    Angle += ang*0.05;
    X += Speed*sin(radians(Angle));
    Y += Speed*cos(radians(Angle));
    loopWorld();
    fill(abs(ang)*2,abs(acc)*2,MaxColor);
    rect(X,Y,20,20);
  }
  void loopWorld(){
    if(X<0)X = width + X;
    if(X>width)X = X-width;
    if(Y<0)Y = height+Y;
    if(Y>height)Y=Y-height;
  }
}
class bounceBall{
  float GRAVITY,FRICTION,X,Y,Spx,Spy;
  int Radius;
  color ball_color;
  bounceBall(float _x,float _y,float _spx,float _spy,int _radius,color _ball_color,float _gravity,float _friction){
    X = _x;
    Y = _y;
    Spx = _spx;
    Spy = _spy;
    Radius = _radius;
    ball_color = _ball_color;
    GRAVITY = _gravity;
    FRICTION = _friction;
  }
  void move(){
    Spy += GRAVITY;
    X += Spx;
    Y += Spy;
    this.bounce();
  }
  void draw(){
    fill(ball_color);
    ellipse(X,Y,Radius*2,Radius*2);
  }
  private void bounce(){
    int bounceMinX = Radius,bounceMaxX = width-Radius,bounceMinY = Radius,bounceMaxY = height-Radius;
    if(X<bounceMinX||X>bounceMaxX){
      Spx = -Spx*FRICTION;
      if(abs(Spx)<1)Spx = 0;
      if(X<bounceMinX)X = bounceMinX-(X-bounceMinX);
      if(X>bounceMaxX)X = bounceMaxX-(X-bounceMaxX);
    }

    if(Y<bounceMinY||Y>bounceMaxY){
      Spy = -Spy * FRICTION;
      if(abs(Spy)<GRAVITY)Spy = 0;
      if(Y<bounceMinY)Y=bounceMinY-(Y-bounceMinY);
      if(Y>bounceMaxY)Y=bounceMaxY-(Y-bounceMaxY);
    }
  }
}

class yuragi{
  int range;
  float r,g,b;
  yuragi(float _r,float _g,float _b,int _range){
    range = _range;
    r = _r;
    g = _g;
    b = _b;
  }
  public void draw(){
    for(int i=0;i<50;i++){
      for(int j=0;j<50;j++){
        fill(r,g,b);
        rect(10+j*20+random(-range,range),10+i*20+random(-range,range),10,10);
      }
    }
  }
}

class ellipseEffect{
  float x,y,cx,cy,ang1,ang2,r1,r2,rot1,rot2;
  ellipseEffect(){
    cx = width/2;
    cy = height/2;
    ang1 = ang2 =0;
    r1 = 100;
    r2 = 30;
    rot1 = 3;
    rot2 = 20;
  }
  void draw(){
    colorMode(HSB,100);
    noStroke();    
    frameRate(30);
    ang1 += rot1;
    ang2 += rot2;
    float rx = cx + (r1*sin(radians(ang1)));
    float ry = cy + (r1*cos(radians(ang1)));
    x = rx + (r2*sin(radians(ang2)));
    y = ry + (r2*cos(radians(ang2)));
    rectMode(CENTER);
    fill(0,100,100,60);
    rect(x,y,10,10);
  }
}

class ellipseEffect2{
  int maxColor;
  ellipseEffect2(){
    maxColor = width;
  }
  void draw(){
    colorMode(HSB,maxColor);
    noStroke();
    frameRate(10);
    fadeToWhite();
    float speed = dist(mouseX,mouseY,pmouseX,pmouseY);
    fill(mouseY,min(speed*2,maxColor),maxColor);
    ellipse(mouseX,mouseY,speed,speed);
  }
  void fadeToWhite(){
    rectMode(CORNER);
    fill(maxColor,10);
    rect(0,0,width,height);
  }
}

class pixelEffect{
  PImage pixelPics;
  pixelEffect(String src){
    size(width,height);
    colorMode(RGB,256);
    background(0);
    frameRate(24);
    pixelPics = loadImage(src);
    pixelPics.loadPixels();
  }
  void draw(){
    loadPixels();
    int x = int(random(pixelPics.width));
    int y = int(random(pixelPics.height));
    int pos = x + (y * width);
    pixels[pos] = pixelPics.pixels[pos];
    updatePixels();
  }
}
class redDot{
  Dot[] dot;
  float[] squareX;
  float[] squareY;
  int wNum,hNum;
  int array;
  int pattern_rd;

  redDot(){
    size(width,height);
    frameRate(24);
    // smooth();
    //pattern_rd = 0;
    wNum = 50;
    hNum = 50;
    array = 0;
    squareX = new float[wNum*hNum];
    squareY = new float[wNum*hNum];
    dot = new Dot[wNum*hNum];
    int dotWidth = 2;
    int dotHeight = 2;
    int dotMargin = 0;
    for(int j=0;j<hNum;j++){
      for(int i=0;i<wNum;i++){
        float tmpX = i*(dotWidth+dotMargin)+width/2-wNum*((dotWidth+dotMargin)/2);
        float tmpY = j*(dotHeight+dotMargin)+height/2-hNum*((dotHeight+dotMargin)/2);
        dot[array] = new Dot(10,10,tmpX,tmpY,50,array);
        squareX[array] = tmpX;
        squareY[array] = tmpY;
        array++;
      }
    }
  }

  void draw(){
    //background(0);
    for(int i=0;i<array;i++){
      dot[i].display();
      dot[i].move3();
    }
  }

  class Dot{
    int rectW,rectH;
    float xPos,yPos;
    int c;
    int dotNum;
    float xDiff,yDiff;
    float nextX,nextY;
    float speed;
    color c1 = color(255,0,0,255);

    Dot(int w,int h,float x,float y,int theColor,int dotCount){
      rectW = w;
      rectH = h;
      xPos = x;
      yPos = y;
      c = theColor;
      dotNum = dotCount;
      speed = 0.2;
    }

    void display(){
      fill(c1);
      stroke(c1);
      ellipseMode(CENTER);
      ellipse(xPos,yPos,rectW,rectH);
    }

    void move1(){
      nextX = squareX[dotNum];
      nextY = squareY[dotNum];
      yDiff = (yPos-nextY)*speed;
      xDiff = (xPos-nextX)*speed;
      xPos -= xDiff;
      yPos -= yDiff;  
    }
    void move2(){
      nextX = (width/2-20)*sin(this.dotNum*2*PI/width)+width/2;
      nextY = (height/2-20)*cos(this.dotNum*2*PI/height)+height/2;
      yDiff = (yPos-nextY)*speed;
      xDiff = (xPos-nextX)*speed;
      xPos -= xDiff;
      yPos -= yDiff;
    }
    void move3(){
      nextX += random(-width/8,width/8);
      nextY += random(-height/8,height/8);
      yDiff = (yPos-nextY)*speed;
      xDiff = (xPos-nextX)*speed;
      xPos -= xDiff;
      yPos -= yDiff;
    }

    void goOut(){
      if(xPos>width+this.rectW){
        xPos = 0;
        nextX = 0;
      }
      if(xPos<0-this.rectW){
        xPos=width;
        nextX=width;
      }
      if(yPos<0-this.rectH){
        xPos = height;
        yPos = height;
      }
      if(yPos>height+this.rectH){
        yPos = 0;
        nextY = 0;
      }
    }
  }
}
class blueWave{
  float yoff = 0,zoff = 0,ns = 0.1,zs = 8,nx,ny=yoff,z1,z2;
  blueWave(){
    noiseDetail(8,0.5);
  }
  void draw(){
    noStroke();
    colorMode(RGB,256);
    translate(width*0.5,height*.55,0);
    rotateX(PI/3.25);
    scale(15);
    for(int y = -10;y <= 10;y++){
      nx = 0.005;
      beginShape(TRIANGLE_STRIP);
      for(int x = -25;x<25;x++){
        z1 = noise(nx,ny,zoff);
        z2 = noise(nx,ny+ns,zoff);
        fill(0,0,z1*255,pow(10,0.85+z1*2));
        vertex(x,y,z1*zs);
        fill(0,0,z2*255,pow(10,0.85+z2*2));
        vertex(x,y+1,z2*zs);
        nx+=ns;
      }
      endShape();
      ny+=ns;
    }
  }
}
/*P3D*/
class KineticType{
  Line ln;
  Line lns[];
 String words[] = {
  "sometimes it's like", "the lines of text", "are so happy", "that they want to dance",
  "or leave the page or jump", "can you blame them?", "living on the page like that",
  "waiting to be read..."
};
  PFont f;
  KineticType(int wi,int hi){
    size(wi,hi,P3D);
    frameRate(30);
    lns = new Line[8];
    f = loadFont("Univers66.vlw.gz");
    textFont(f,1f);
    fill(255);
    for(int i = 0;i<8;i++){
      ln = new Line(words[i],0,i*70,f);
      lns[i] = ln;
    }
  }
  void draw(){
    background(0);
    translate((float)(width/2.0)-350,(height/2.0)-240,-450);
    rotateY(0.3);
    for(int i = 0;i<8;i++){
      float f1 = sin((i+1.0) * (millis()/10000.0) * TWO_PI);
      float f2 = sin((8.0-i) * (millis()/10000.0) * TWO_PI);
      Line line = lns[i];
      pushMatrix();
      translate(0.0,line.yPosition,0.0);
      for(int j = 0;j<line.myLetters.length;j++){
        if(j != 0){
          translate(textWidth(line.myLetters[j-1].myChar)*75,0.0,0.0);
         }
         rotateY(f1*0.035*f2);
         pushMatrix();
         scale(75.0,75.0,75.0);
         text(line.myLetters[j].myChar,0.0,0.0);
         popMatrix();
       }
       popMatrix();
      }
    }
    class Letter{
      char myChar;
      float x;
      float y;
      Letter(char c,float f,float f1){
        myChar = c;
        x = f;
        y = f1;
      }
    }
    class Word{
      String myName;
      int x;
      Word(String s){
        myName = s;
      }
    }
    class Line{
      String myString;
      int xPosition;
      int yPosition;
      int highlightNum;
      PFont f;
      float speed;
      float curlInX;
      Letter myLetters[];
      Line(String s,int i,int j,PFont bagelfont){
        myString = s;
        xPosition = i;
        yPosition = j;
        f = bagelfont;
        myLetters = new Letter[s.length()];
        float f1 = 0.0;
        for(int k = 0;k<s.length();k++){
          char c = s.charAt(k);
          f1 += textWidth(c);
          Letter letter = new Letter(c,f1,0.0);
          myLetters[k] = letter;
        }
        curlInX = 0.1;
      }
    }
}    
class Bird{
  float offsetX,offsetY,offsetZ;
  float w,h;
  int bodyFill;
  int wingFill;
  float ang = 0,ang2 = 0,ang3 = 0,ang4 = 0;
  float radiusX = 120,radiusY = 200, radiusZ = 700;
  float rotX = 15,rotY = 10,rotZ = 5;
  float flapSpeed = 0.4;
  float rotSpeed = 0.1;
  
  Bird(){
    this(0,0,0,60,80);
  }
  
  Bird(float offsetX,float offsetY,float offsetZ,float w,float h){
    this.offsetX = offsetX;
    this.offsetY = offsetY;
    this.offsetZ = offsetZ;
    this.w = w;
    this.h = h;
    bodyFill = color(153);
    wingFill = color(204);
  }
  void setFlight(float radiusX,float radiusY,float radiusZ,float rotX,float rotY,float rotZ){
    this.radiusX = radiusX;
    this.radiusY = radiusY;
    this.radiusZ = radiusZ;
    
    this.rotX = rotX;
    this.rotY = rotY;
    this.rotZ = rotZ;
  }
  void setWingSpeed(float flapSpeed){
    this.flapSpeed = flapSpeed;
  }
  void setRotSpeed(float rotSpeed){
    this.rotSpeed = rotSpeed;
  }
  void fly(){
    pushMatrix();
    float px,py,pz;
    px = sin(radians(ang3)) * radiusX;
    py = cos(radians(ang2)) * radiusY;
    pz = sin(radians(ang4)) * radiusZ;
    
    translate(width/2 + offsetX + px,height/2 + offsetY + py,-700 + offsetZ + pz);
    
    rotateX(sin(radians(ang2)) * rotX);
    rotateY(sin(radians(ang2)) * rotY);
    rotateZ(sin(radians(ang2)) * rotZ);
    
    fill(bodyFill);
    box(w/5,h,w/5);
    fill(wingFill);
    pushMatrix();
    rotateY(sin(radians(ang)) * 20);
    rect(0,-h/2,w,h);
    popMatrix();
    
    pushMatrix();
    rotateY(sin(radians(ang)) * -20);
    rect(-w,-h/2,w,h);
    popMatrix();
    
    ang += flapSpeed;
    if(ang>3){
      flapSpeed *= -1;
    }else if(ang<-3){
      flapSpeed *= -1;
    }
    
    ang2 += rotSpeed;
    ang3 += 1.25;
    ang4 += 0.55;
    popMatrix();
  }
}
class Birds{
  int birdCount = 2000;
  Bird[]birds = new Bird[birdCount];
  float[]x = new float[birdCount];
  float[]y = new float[birdCount];
  float[]z = new float[birdCount];
  float[]rx = new float[birdCount];
  float[]ry = new float[birdCount];
  float[]rz = new float[birdCount];
  float[]spd = new float[birdCount];
  float[]rot = new float[birdCount];
  Birds(int wi,int hi){
    size(wi,hi,P3D);
    noStroke();
  
    for(int i=0;i<birdCount;i++){
      birds[i] = new Bird(random(-300,300),random(-300,300),random(-500,-2500),random(5,30),random(5,30));
      x[i] = random(20,340);
      y[i] = random(30,350);
      z[i] = random(1000,4800);
      rx[i] = random(-160,160);
      ry[i] = random(-55,55);
      rz[i] = random(-20,20);
      spd[i] = random(0.1,3.75);
      rot[i] = random(0.025,.15);
    }
  }

  void draw(){
    background(0);
    lights();
    for(int i=0;i<birdCount;i++){
      birds[i].setFlight(x[i],y[i],z[i],rx[i],ry[i],rz[i]);
      birds[i].setWingSpeed(spd[i]);
      birds[i].fly();
    }
  }
}
class spaceEffect{
  int Length = 100;
  float[] x = new float[Length];
  float[] y = new float[Length];
  float[] z = new float[Length];
  spaceEffect(int w,int h,int speed){
    size(w,h,P3D);
    frameRate(speed);
    background(0);
    stroke(100);
    for(int i=0;i<Length;i++){
      x[i] = random(width);
      y[i] = random(height);
      z[i] = i*(-10);
    }
  }
  void draw(){
    background(0);
    for(int i=0;i<Length;i++){
      line(x[i],y[i],z[i],x[i],y[i],z[i]-40);
      z[i] += 20;
      if(z[i]>0){
        x[i] = random(width);
        y[i] = random(height);
        z[i] = -1000;
      }
    }
  }
}
class space_Ring_Effect{
  int Length = 100;
  float[] x = new float[Length];
  float[] y = new float[Length];
  float[] z = new float[Length];
  space_Ring_Effect(int w,int h,int speed){
    size(w,h,P3D);
    frameRate(speed);
    background(0);
    stroke(100);
    for(int i=0;i<Length;i++){
      x[i] = random(width);
      y[i] = random(height);
      z[i] = i*(-10);
    }
  }

  void draw(){
    background(0);
    for(int i=0;i<Length;i++){
      noFill();
      ellipse(x[i],y[i],z[i],z[i]-40);
      z[i] += 20;
      if(z[i]>0){
        x[i] = random(width);
        y[i] = random(height);
        z[i] = -1000;
      }
    }
  }
}
class sprite{
  float sspeed;
  int sW,sH;
  float angle,rSize,a;
  sprite(int _width,int _height,float ss){
    sW = _width;
    sH = _height;
    sspeed = ss;
    rSize = width/4;
    a = 0.0;
    size(sW,sH,P3D);
  }
  void draw(){
    frameRate(24);
    colorMode(RGB,256);
    a += sspeed;
    if(a>TWO_PI){
      a = 0.0;
    }
    stroke(256,0,0);
    strokeWeight(4);
    translate(width/2,height/2);
    rotateX(a);
    rotateY(a*2);
    fill(256,256,256);
    rect(-rSize, -rSize, rSize*2, rSize*2);
    translate(width%3,height/3);
    rotateX(a%6);
    rotateY(a%3);
    fill(256,0,0);
    rect(-rSize,-rSize,rSize*3,rSize/4);
    for(int i = 0;i<256;i++){
      translate(width/2,height/2);
      rotateX(a);
      rotateY(a*2);
      fill(i,i,i);
      rect(-rSize, -rSize, rSize*2, rSize*2);
      translate(width/2,height/2);
      rotateX(a);
      rotateY(a);
      fill(256,0,i);
      ellipse(100,100,100,100);
    }
  }
}

class RED_3D{
  float offset = PI/12,b = 0.0f,sSize;
  int num = 12,safecolor;
  int[] colors = new int[num];
  boolean pink = true;

  RED_3D(){
    colorMode(RGB,256);
    sSize = width/5;
    fill(204,204);
    safecolor = color(256,0,0);
    for(int i=0;i<num;i++){
      colors[i] = color(256*(i+1)/num,0*(num-i)/num,0);
    }
    lights();
  }
  void draw(){
    noStroke();
    frameRate(24);
    b += 0.02f;
    if(b>TWO_PI){
      b = 0.0f;
    }
    translate(width/2,height/2);
    rotateX(b/4);
    rotateY(b*2);
    rect(-sSize,-sSize,sSize*2,sSize*2);
    rotateX(b*1.001f);
    rotateY(b*2.002f);
    rect(-sSize,-sSize,sSize*2,sSize*2);
    rotateX(b);
    rotateY(b);
    rect(-sSize,-sSize,-sSize,-sSize);

    translate(0,0,16);
    translate(width/2,height/2,-20);
    if(b>=TWO_PI*2){
      b=0.0f;
    }
    for(int i=0;i<num;i++){
      pushMatrix();
      fill(colors[i]);
      rotateY(b+offset*i);
      rotateX(b/2+offset*i);
      box(width/2);
      popMatrix();
    }
  }
}
class Point3D{
  float x,y,z;
  Point3D(){}
  Point3D(float x,float y,float z){
    this.x = x;
    this.y = y;
    this.z = z;
  }
}
class Cube{
  PVector[] vertices = new PVector[24];
  float w,h,d;
  Cube(){}
  Cube(float w,float h,float d){
    this.w = w;
    this.h = h;
    this.d = d;
    vertices[0] = new PVector(-w/2, -h/2, d/2);
    vertices[1] = new PVector(w/2, -h/2, d/2);
    vertices[2] = new PVector(w/2, h/2, d/2);
    vertices[3] = new PVector(-w/2, h/2, d/2);

    vertices[4] = new PVector(-w/2, -h/2, d/2);
    vertices[5] = new PVector(-w/2, -h/2, -d/2);
    vertices[6] = new PVector(-w/2, h/2, -d/2);
    vertices[7] = new PVector(-w/2, h/2, d/2);

    vertices[8] = new PVector(w/2, -h/2, d/2);
    vertices[9] = new PVector(w/2, -h/2, -d/2);
    vertices[10] = new PVector(w/2, h/2, -d/2);
    vertices[11] = new PVector(w/2, h/2, d/2);

    vertices[12] = new PVector(-w/2, -h/2, -d/2);  
    vertices[13] = new PVector(w/2, -h/2, -d/2);
    vertices[14] = new PVector(w/2, h/2, -d/2);
    vertices[15] = new PVector(-w/2, h/2, -d/2);

    vertices[16] = new PVector(-w/2, -h/2, d/2);
    vertices[17] = new PVector(-w/2, -h/2, -d/2);
    vertices[18] = new PVector(w/2, -h/2, -d/2);
    vertices[19] = new PVector(w/2, -h/2, d/2);
    
    vertices[20] = new PVector(-w/2, h/2, d/2);
    vertices[21] = new PVector(-w/2, h/2, -d/2);
    vertices[22] = new PVector(w/2, h/2, -d/2);
    vertices[23] = new PVector(w/2, h/2, d/2);
  }
  void create(){
      for(int i = 0;i <6;i++){
          beginShape(QUADS);
           for(int j = 0;j < 4;j++){
             vertex(vertices[j+4*i].x,vertices[j+4*i].y,vertices[j+4*i].z);
           }
           endShape();
      }
  }
}
class brickTower{
  float bricksPerLayer = 16.0;
  float brickLayers = 18.0;
  Cube brick;
  float brickWidth = 60,brickHeight = 25,brickDepth = 25;
  float radius = 175.0;
  float angle = 0;
  brickTower(){
    size(640,360,P3D);
    brick = new Cube(brickWidth,brickHeight,brickDepth);
  }
  void draw(){
    background(0);
    float tempX = 0,tempY = 0,tempZ = 0;
    fill(182,62,29);
    noStroke();
    lights();
    translate(width/2,height*1.2,-380);
    rotateX(radians(-45));
    rotateY(frameCount * PI/600);
    for(int i = 0;i<brickLayers;i++){
       tempY -= brickHeight;
       angle = 360.0/bricksPerLayer * i/2;
       for(int j = 0;j < bricksPerLayer;j++){
         tempZ = cos(radians(angle))*radius;
         tempX = sin(radians(angle))*radius;
         pushMatrix();
         translate(tempX,tempY,tempZ);
         rotateY(radians(angle));
         if(i == brickLayers-1){
           if(j%2 == 0){
               brick.create();
           }
         }else{
           brick.create();
         }
         popMatrix();
         angle += 360.0/bricksPerLayer;
       }
    }
  }
}
class cubicGrid{
  float boxSize = 40;
  float margin = boxSize * 2;
  float depth = 400;
  color boxFill;
  cubicGrid(){
    size(640,360,P3D);
    noStroke();
  }
  void draw(){
    background(0);
    translate(width/2,height/2,-depth);
    rotateX(frameCount * 0.01);
    rotateY(frameCount * 0.01);
    for(float i = -depth/2 + margin;i <= depth/2-margin;i += boxSize){
      pushMatrix();
      for(float j = -height + margin;j <= height - margin;j += boxSize){
          pushMatrix();
          for(float k = -width + margin;k <= width-margin;k += boxSize){
            boxFill = color(abs(i),abs(j),abs(k),50);
            pushMatrix();
            translate(k,j,i);
            fill(boxFill);
            box(boxSize,boxSize,boxSize);
            popMatrix();
          }
          popMatrix();
      }
      popMatrix();
    }
  }
}
class primitives3D{
  primitives3D(){
    size(640,360,P3D);
    background(0);
    lights();
  }
  void draw(){
    noStroke();
    pushMatrix();
    translate(130,height/2,0);
    rotateX(-0.4);
    rotateY(1.25);
    box(100);
    popMatrix();
    
    noFill();
    stroke(255);
    pushMatrix();
    translate(500,height * 0.35,-200);
    sphere(280);
    popMatrix();
  }
}
class explode{
  PImage img;
  int cellsize = 2;
  int columns,rows;
  explode(String src){
    size(640,480,P3D);
    img = loadImage(src);
    columns = img.width/cellsize;
    rows = img.height/cellsize;
  }
  void draw(){
    background(0);
    for(int i = 0;i < columns;i++){
      for(int j = 0;j < rows;j++){
        int x = i * cellsize + cellsize/2;
        int y = j * cellsize + cellsize/2;
        int loc = x + y * img.width;
        color c = img.pixels[loc];
        float z = (mouseX / float(width)) * brightness(img.pixels[loc])-20.0;
        pushMatrix();
        translate(x + 200,y + 100,z);
        fill(c,204);
        noStroke();
        rectMode(CENTER);
        rect(0,0,cellsize,cellsize);
        popMatrix();
      }
    }
  }
}