/*******************************************************************************
 * MD2 Loader Example  - by Marcello Bastea-Forte (http://marcello.cellosoft.com/)
 *
 *  Contains the following modules:

 * MD2 Loader - loads, displays, animates MD2 (Quake 2) models for Processing
 *   - based on C++ MD2 loader by DigiBen (http://www.gametutorials.com/Tutorials/opengl/OpenGL_Pg4.htm)
 *   - heavily adapted and completely rewritten in Processing by Marcello (http://marcello.cellosoft.com/)
 *   - cubic interpolation by entheh (http://bdavis.strangesoft.net/)

 * Spin3d - Handles nice trackball style camera movement in Processing
 *   - based on Matrix3D code from cello3d by Marcello
 
 * PComponent - really lame Processing component engine
 *   - by Marcello
 
 
 * The 3D model used here was from the MD2 Loader code this was ported from,
 * I have no idea who made it, but I will assume it is from Quake 2 and is 
 * thus copyrighted by ID.
 
 ********************************************************************************/

Spin3d spin = new Spin3d();
MD2Model model;
ComponentManager cm = new ComponentManager();

void setup() {
  size(300,300);
  noStroke();
  noSmooth();
  
  model = new MD2Model("tris.md2",loadImage("hobgoblin.jpg"));
  
  AnimationList list = new AnimationList(model);
  
  list.move(5,5,width-10,15);
  
  cm.add(list);
}
void mouseMoved() {
  cm.mouseMotion();
}
void mouseDragged() {
  if (!cm.mouseMotion())
    spin.mouseMoved();
}
void mousePressed() {
  cm.mousePressed();
}
void mouseReleased() {
  cm.mouseReleased();
}

void proc() {
  cm.update();
  spin.update();
  model.update();
}
void loop() {
  proc();
  push();
    drawproc();
  pop();
  cm.draw();
}

void drawproc() {
  background(200);
  
  translate(width/2,height/2,0);
  spin.apply();

  scale(4);
  noStroke();
  noSmooth();
  fill(255);
  model.draw();
  stroke(0);
  noFill();
  scale(30);
  beginShape(QUADS);
    vertex(-1,-1,0);
    vertex(1,-1,0);
    vertex(1,1,0);
    vertex(-1,1,0);
  endShape();
}


/*******************************************************************************
 * PComponent - really lame Processing component engine
 *   - by Marcello
 ********************************************************************************/

class ComponentManager {
  Vector v = new Vector();
  
  void draw() {
    Enumeration e = v.elements();
    while (e.hasMoreElements()) {
      PComponent p = (PComponent)e.nextElement();
      p.draw();
    }
  }  
  void update() {
    Enumeration e = v.elements();
    while (e.hasMoreElements()) {
      PComponent p = (PComponent)e.nextElement();
      p.update();
    }
  }  
  boolean mousePressed() {
    Enumeration e = v.elements();
    while (e.hasMoreElements()) {
      PComponent p = (PComponent)e.nextElement();
      if (p.mousePressed())
        return true;
    }
    return false;
  }  
  boolean mouseReleased() {
    Enumeration e = v.elements();
    while (e.hasMoreElements()) {
      PComponent p = (PComponent)e.nextElement();
      if (p.mouseReleased())
        return true;
    }
    return false;
  }  
  boolean mouseMotion() {
    Enumeration e = v.elements();
    while (e.hasMoreElements()) {
      PComponent p = (PComponent)e.nextElement();
      if (p.mouseMotion())
        return true;
    }
    return false;
  }
  
  void add(PComponent p) {
    v.addElement(p);
  }
}
class PComponent {
  int x, y, w, h;
  boolean over;
  boolean pressed;
  boolean activepress;
  
  void move(int x, int y, int w, int h) {
    this.x=x;  this.y=y;  this.w=w;  this.h=h;
  }
  
  void draw() {
    translate(x,y);
    drawBackground();
    drawContents();
    drawBorder();
    translate(-x,-y);
  }
  void drawBackground() {
  }
  void drawContents() {
  }
  void drawBorder() {
  }
  void update() {
  }
  boolean mouseMotion() {
    over = mouseX>=x && mouseY>=y && mouseX < x+w && mouseY < y+h;
    activepress = over && pressed;
    return false;
  }
  boolean mousePressed() {
    over = mouseX>=x && mouseY>=y && mouseX < x+w && mouseY < y+h;
    activepress = pressed = over;
    return false;
  }
  boolean mouseReleased() {
    over = mouseX>=x && mouseY>=y && mouseX < x+w && mouseY < y+h;
    activepress = pressed = false;
    return false;
  }
}

class AnimationList extends PComponent {
  MD2Model model;
  AnimationList(MD2Model model) {
    this.model = model;
  }
  void drawContents() {
    stroke(over ? 255 : 180);
    line ( 0, h/2, w, h/2);
    int count = model.animations.length;
    ellipseMode(CENTER_RADIUS);
    for (int i=0; i<count; i++) {
      fill(i==model.currentAnimation ? 255 : 200);
      ellipse(5+i*(w-10)/(count-1),h/2,4,4);
    }
  }
  
  boolean mousePressed() {
    super.mousePressed();
    return mouseMotion();
  }
  boolean mouseMotion() {
    super.mouseMotion();
    if (pressed) {
      int count = model.animations.length;
      model.setAnimation((mouseX-x+10)*count/width);
      return true;
    }
    return false;
  }
  void drawBorder() { 
  }
}




















/*******************************************************************************
 * Spin3d - Handles nice trackball style camera movement in Processing
 *   - based on Matrix3D code from cello3d by Marcello
 ********************************************************************************/

public class Spin3d {
  float x= 0, y = 0;
  float tdx = 0, tdy = 0;
  float dx = tdx, dy = tdy;


  public void mouseMoved() {
    // GOTCHA: x and y are switched!
    tdx=0.01*(mouseY-pmouseY);
    tdy=0.01*(mouseX-pmouseX);
  }
  public void apply() {
    g.transform(m_0_0, m_0_1, m_0_2, m_0_3,
                m_1_0, m_1_1, m_1_2, m_1_3,
                m_2_0, m_2_1, m_2_2, m_2_3,
                m_3_0, m_3_1, m_3_2, m_3_3);
  }
  void update() {
    x += dx;
    y += dy;
    dx += (tdx-dx)/20;
    dy += (tdy-dy)/20;
    tdx += (0-tdx)/20;
    tdy += (0-tdy)/20;
    rotateX(dx);
    rotateY(dy);
  }

	public Spin3d() {
	}
	public float	
		m_0_0 = 1, m_0_1 = 0, m_0_2 = 0, m_0_3 = 0,
		m_1_0 = 0, m_1_1 = 1, m_1_2 = 0, m_1_3 = 0,
		m_2_0 = 0, m_2_1 = 0, m_2_2 = 1, m_2_3 = 0,
		m_3_0 = 0, m_3_1 = 0, m_3_2 = 0, m_3_3 = 1;

	public void rotateX(float t) {
		if (t==0) return;
		float sin = sin(t);
		float cos = cos(t);
		transform(
			1,    0,   0,   0,
			0,    cos, sin, 0,
			0,    -sin,cos, 0,
			0,    0,   0,   1
		);
	}
	public void rotateY(float t) {
		if (t==0) return;
		float sin = sin(t);
		float cos = cos(t);
		transform(
			cos, 0,   sin, 0,
			0,   1,   0,   0,
			-sin,0,   cos, 0,
			0,   0,   0,   1
		);
	}
	
	public void transform(float nm_0_0, float nm_0_1, float nm_0_2, float nm_0_3,
						float nm_1_0, float nm_1_1, float nm_1_2, float nm_1_3,
						float nm_2_0, float nm_2_1, float nm_2_2, float nm_2_3,
						float nm_3_0, float nm_3_1, float nm_3_2, float nm_3_3) {
							
		Spin3d m =  new Spin3d();

		m.m_0_0 = m_0_0; m.m_0_1 = m_0_1; m.m_0_2 = m_0_2; m.m_0_3 = m_0_3;
		m.m_1_0 = m_1_0; m.m_1_1 = m_1_1; m.m_1_2 = m_1_2; m.m_1_3 = m_1_3;
		m.m_2_0 = m_2_0; m.m_2_1 = m_2_1; m.m_2_2 = m_2_2; m.m_2_3 = m_2_3;
		m.m_3_0 = m_3_0; m.m_3_1 = m_3_1; m.m_3_2 = m_3_2; m.m_3_3 = m_3_3;

		m_0_0 = nm_0_0*m.m_0_0 + nm_0_1*m.m_1_0 + nm_0_2*m.m_2_0;
		m_0_1 = nm_0_0*m.m_0_1 + nm_0_1*m.m_1_1 + nm_0_2*m.m_2_1;
		m_0_2 = nm_0_0*m.m_0_2 + nm_0_1*m.m_1_2 + nm_0_2*m.m_2_2;
		m_0_3 = nm_0_0*m.m_0_3 + nm_0_1*m.m_1_3 + nm_0_2*m.m_2_3 + nm_0_3;
		m_1_0 = nm_1_0*m.m_0_0 + nm_1_1*m.m_1_0 + nm_1_2*m.m_2_0;
		m_1_1 = nm_1_0*m.m_0_1 + nm_1_1*m.m_1_1 + nm_1_2*m.m_2_1;
		m_1_2 = nm_1_0*m.m_0_2 + nm_1_1*m.m_1_2 + nm_1_2*m.m_2_2;
		m_1_3 = nm_1_0*m.m_0_3 + nm_1_1*m.m_1_3 + nm_1_2*m.m_2_3 + nm_1_3;
		m_2_0 = nm_2_0*m.m_0_0 + nm_2_1*m.m_1_0 + nm_2_2*m.m_2_0;
		m_2_1 = nm_2_0*m.m_0_1 + nm_2_1*m.m_1_1 + nm_2_2*m.m_2_1;
		m_2_2 = nm_2_0*m.m_0_2 + nm_2_1*m.m_1_2 + nm_2_2*m.m_2_2;
		m_2_3 = nm_2_0*m.m_0_3 + nm_2_1*m.m_1_3 + nm_2_2*m.m_2_3 + nm_2_3;
	}
}




















/*******************************************************************************
 * MD2 Loader - loads, displays, animates MD2 (Quake 2) models for Processing
 *   - based on C++ MD2 loader by DigiBen (http://www.gametutorials.com/Tutorials/opengl/OpenGL_Pg4.htm)
 *   - heavily adapted and completely rewritten in Processing by Marcello (http://marcello.cellosoft.com/)
 *   - cubic interpolation by entheh (http://bdavis.strangesoft.net/)
 ********************************************************************************/

int readInt4(byte[] b, int o) {
  return (0xFF&b[o++])|((0xFF&b[o++])<<8)|((0xFF&b[o++])<<16)|((0xFF&b[o])<<24);
}
float readFloat4(byte[] b, int o) {
  return Float.intBitsToFloat(readInt4(b,o));
}
short readShort2(byte[] b, int o) {
  return (short)((0xFF&b[o++])|((0xFF&b[o++])<<8));
}
String readString(byte[] b, int o, int len) {
  String s = "";
  while (len>=0 && b[o]!=0) {
    s+=char(b[o++]);
    len--;
  }
  return s;
}

// This holds the header information that is read in at the beginning of the file
class MD2Header { 
   int magic;				// This is used to identify the file
   int version;				// The version number of the file (Must be 8)
   int skinWidth;			// The skin width in pixels
   int skinHeight;			// The skin height in pixels
   int frameSize;			// The size in bytes the frames are
   int numSkins;			// The number of skins associated with the model
   int numVertices;			// The number of vertices (constant for each frame)
   int numTexCoords;			// The number of texture coordinates
   int numTriangles;			// The number of faces (polygons)
   int numGlCommands;			// The number of gl commands
   int numFrames;			// The number of animation frames
   int offsetSkins;			// The offset in the file for the skin data
   int offsetTexCoords;			// The offset in the file for the texture data
   int offsetTriangles;			// The offset in the file for the face data
   int offsetFrames;			// The offset in the file for the frames data
   int offsetGlCommands;		// The offset in the file for the gl commands data
   int offsetEnd;			// The end of the file offset
   MD2Header(byte[] b) {
     int i=0;
     magic            = readInt4(b,i); i+=4;
     version          = readInt4(b,i); i+=4;
     skinWidth        = readInt4(b,i); i+=4;
     skinHeight       = readInt4(b,i); i+=4;
     frameSize        = readInt4(b,i); i+=4;
     numSkins         = readInt4(b,i); i+=4;
     numVertices      = readInt4(b,i); i+=4;
     numTexCoords     = readInt4(b,i); i+=4;
     numTriangles     = readInt4(b,i); i+=4;
     numGlCommands    = readInt4(b,i); i+=4;
     numFrames        = readInt4(b,i); i+=4;
     offsetSkins      = readInt4(b,i); i+=4;
     offsetTexCoords  = readInt4(b,i); i+=4;
     offsetTriangles  = readInt4(b,i); i+=4;
     offsetFrames     = readInt4(b,i); i+=4;
     offsetGlCommands = readInt4(b,i); i+=4;
     offsetEnd        = readInt4(b,i); i+=4;
   }
}


// This is used to store the vertices that are read in for the current frame
class MD2AliasTriangle {
   int vertex[] = new int[3];
   int lightNormalIndex;
   MD2AliasTriangle(byte[] b, int o) {
     vertex[0] = 0xFF&b[o];
     vertex[1] = 0xFF&b[o+1];
     vertex[2] = 0xFF&b[o+2];
     lightNormalIndex = 0xFF&b[o+3];
   }
   int getSize() { return 4; }
};

// This stores the normals and vertices for the frames
class MD2Triangle {
   float vertex[] = new float[3];
   float normal[] = new float[3];
   int getSize() { return 4 * 6; }
};

// This stores the indices into the vertex and texture coordinate arrays
class MD2Face {
   short vertexIndices[] = new short[3];
   short textureIndices[] = new short[3];
   
   MD2Face(byte[] b, int o) {
     vertexIndices[0] = readShort2(b,o); o+=2;
     vertexIndices[1] = readShort2(b,o); o+=2;
     vertexIndices[2] = readShort2(b,o); o+=2;
     textureIndices[0] = readShort2(b,o); o+=2;
     textureIndices[1] = readShort2(b,o); o+=2;
     textureIndices[2] = readShort2(b,o); o+=2;
   }
   int getSize() { return 2 * 6; }
};

// This stores UV coordinates
class MD2TexCoord
{
   short u, v;
   MD2TexCoord(byte[] b, int o) {
     u = readShort2(b,o);
     v = readShort2(b,o+2);
   }
   int getSize() { return 4; }
};

// This stores the animation scale, translation and name information for a frame, plus verts
class MD2AliasFrame
{
   float scale[] = new float[3];
   float translate[] = new float[3];
   String name;
   MD2AliasTriangle aliasVertices[];
   MD2AliasFrame(byte[] b, int o, int size) {
     scale[0] = readFloat4(b, o); o+=4; size -= 4;
     scale[1] = readFloat4(b, o); o+=4; size -= 4;
     scale[2] = readFloat4(b, o); o+=4; size -= 4;
     translate[0] = readFloat4(b, o); o+=4; size -= 4;
     translate[1] = readFloat4(b, o); o+=4; size -= 4;
     translate[2] = readFloat4(b, o); o+=4; size -= 4;
     name = readString(b, o, 16); o+=16; size -= 16;
     
     int aliascount = size / 4;
     aliasVertices = new MD2AliasTriangle[aliascount];
     for (int i = 0; i<aliascount; i++) {
       aliasVertices[i] = new MD2AliasTriangle(b, o);
       o+=4;
     }
   }
   int getSize() {
     return 4*6 + 16 + aliasVertices[0].getSize() * aliasVertices.length;
   }
}

// This stores the frames vertices after they have been transformed
class MD2Frame {
   String name;
   MD2Triangle vertices[];
   MD2Frame(String name, int verticecount) {
     this.name = name;
     vertices = new MD2Triangle[verticecount];
     for (int i=0; i<vertices.length; i++)
       vertices[i] = new MD2Triangle();
   }
};
class MD2Animation {
  String name;
  int startFrame;
  int endFrame;
}

class MD2Model {
  MD2Header    header;			// The header data
  String       skins[];			// The skin data
  MD2TexCoord  texCoords[];		// The texture coordinates
  MD2Face      triangles[];		// Face index information
  MD2Frame     frames[];		// The frames of animation (vertices)
  MD2Animation animations[];
  
  BImage       texture;
  
  MD2Model(String file, BImage texture) {
    byte data[] = loadBytes(file);

    header = new MD2Header(data);
    

    if (header.version != 8)
      println("Error: version not 8");


    ReadMD2Data(data);
    
    BuildMD2Animations();
    
    ComputeNormals();

    this.texture = texture;
  }

  void ReadMD2Data(byte data[]) {
    skins     = new String     [header.numSkins];
    texCoords = new MD2TexCoord [header.numTexCoords];
    triangles = new MD2Face     [header.numTriangles];
    frames    = new MD2Frame    [header.numFrames];

    int o = header.offsetSkins;
    for (int i=0; i<skins.length; i++) {
      skins[i] = readString(data,o,64);
      o+=64;
    }
    
    o = header.offsetTexCoords;
    for (int i=0; i<texCoords.length; i++)
      o+= (texCoords[i] = new MD2TexCoord(data, o)).getSize();
    
    o = header.offsetTriangles;
    for (int i=0; i<triangles.length; i++)
      o += (triangles[i] = new MD2Face(data, o)).getSize();
    
    o = header.offsetFrames;
    for (int i=0; i<frames.length; i++) {
      MD2AliasFrame frame = new MD2AliasFrame(data, o, header.frameSize);
      o += frame.getSize(); 
      
      frames[i] = new MD2Frame(frame.name, header.numVertices);
      
      MD2Triangle vertices[] = frames[i].vertices;
      
      for (int j=0; j < header.numVertices; j++) {
        frames[i].vertices[j].vertex[0] = frame.aliasVertices[j].vertex[0] * frame.scale[0] + frame.translate[0];
        frames[i].vertices[j].vertex[2] = frame.aliasVertices[j].vertex[1] * frame.scale[1] + frame.translate[1];
        frames[i].vertices[j].vertex[1] = -(frame.aliasVertices[j].vertex[2] * frame.scale[2] + frame.translate[2]);
      } 
    }
  }
  
  void BuildMD2Animations() {
    Vector animations = new Vector();
    MD2Animation animation = null;
    String lastName = "";
    for (int i=0; i<frames.length; i++) {
      String s = frames[i].name;
      for (int j=s.length()-2; j<s.length(); j++) {
        char c = s.charAt(j);
        if (c>='0' && c<='9') {
          s = s.substring(0,j);
        }
      }
      
      if (!s.equals(lastName) || i==frames.length-1) {
        if (lastName.length()>0) {
          animation.name = lastName;
          animation.endFrame = i;
          animations.addElement(animation);
        }
        animation = new MD2Animation();
        animation.startFrame = i;
      }
      lastName = s;
    }
    this.animations = new MD2Animation[animations.size()];
    for (int i=0; i<this.animations.length; i++)
      this.animations[i] = (MD2Animation)animations.elementAt(i);
  }
  void setAnimation(int animation) {
    animation = constrain(animation,0,animations.length-1);
    if (currentAnimation == animation) return;
    currentAnimation = animation;
    nextFrame = animations[animation].startFrame;
    elapsedTime = 0;
  }  
  
  int currentAnimation = 0;
  
  int lastFrame = 0;
  int currentFrame = 0;
  int nextFrame = 0;
  int nextNextFrame = 0;
  
  void update() {
    MD2Animation anim = animations[currentAnimation];
    
    if (currentFrame == nextFrame) nextFrame++;
    if (nextFrame >= anim.endFrame)
      nextFrame = anim.startFrame;
    nextNextFrame = nextFrame + 1;
    if (nextNextFrame >= anim.endFrame)
      nextNextFrame = anim.startFrame;
    
    t = ReturnCurrentTime();
  }
  float t = 0;
  void draw() {
    beginShape(TRIANGLES);
    texture(texture);
      for (int j = 0; j<triangles.length; j++) {
        for (int v = 0; v < 3; v++) {
          // Get the index for each point of the face
          int vi = triangles[j].vertexIndices[v];
          int ti = triangles[j].textureIndices[v];
           
          float v0[] = frames[lastFrame].vertices[vi].vertex;
          float v1[] = frames[currentFrame].vertices[vi].vertex;
          float v2[] = frames[nextFrame].vertices[vi].vertex;
          float v3[] = frames[nextNextFrame].vertices[vi].vertex;
          
          // thanks to entheh for the following code
          float p[] = new float[3];
          float q[] = new float[3];
          float r[] = new float[3];
          float s[] = new float[3];
          
          for (int i=0; i<3; i++) {
            float a = v0[i], b = v1[i], c = v2[i], d = v3[i];
            p[i] = b;
            q[i] = 0.5f * (c - a);
            r[i] = a - 2.5f*b + 2*c - 0.5f*d;
            s[i] = 1.5f * (b - c) + 0.5f * (d - a);
          }
          
          
          vertex(p[0] + t * (q[0] + t * (r[0] + t * s[0])),
                 p[1] + t * (q[1] + t * (r[1] + t * s[1])),
                 p[2] + t * (q[2] + t * (r[2] + t * s[2])),
                 texCoords[ti].u,
                 texCoords[ti].v);
        }
      }
    endShape();
  }
  float elapsedTime = 0;
  float lastTime = 0;
  float animationSpeed = 5;
  
  float ReturnCurrentTime() {
    float time = millis();
    elapsedTime = time - lastTime;

    float t = elapsedTime / (1000 / animationSpeed);
    
    if (elapsedTime >= 1000 / animationSpeed) {
      lastFrame = currentFrame;
      currentFrame = nextFrame;
      lastTime = time;
    }
    return t;
  }
  
  void ComputeNormals() {
  }
}