var container, scene, camera, renderer, controls, stats;
var keyboard = new THREEx.KeyboardState();
var clock = new THREE.Clock();
// custom global variables
var mainObj, mainGeo, adjacencyList;
 
init();
animate();
 
function init() {
	// SCENE
	scene = new THREE.Scene();
	// CAMERA
	var SCREEN_WIDTH = window.innerWidth, SCREEN_HEIGHT = window.innerHeight;
	var VIEW_ANGLE = 45, ASPECT = SCREEN_WIDTH / SCREEN_HEIGHT, NEAR = 0.1, FAR = 20000;
	camera = new THREE.PerspectiveCamera( VIEW_ANGLE, ASPECT, NEAR, FAR);
	scene.add(camera);
	camera.position.set(250, -20, 442.0931145267771);
	// camera.position.set(0,150,400);
	camera.lookAt(scene.position);	
	// RENDERER
	if ( Detector.webgl )
		renderer = new THREE.WebGLRenderer( {antialias:true, preserveDrawingBuffer: true } );
	else
		renderer = new THREE.CanvasRenderer(); 
	renderer.setSize(SCREEN_WIDTH, SCREEN_HEIGHT);
	container = document.getElementById( 'ThreeJS' );
	container.appendChild( renderer.domElement );
	// EVENTS
	THREEx.WindowResize(renderer, camera);
	THREEx.FullScreen.bindKey({ charCode : 'm'.charCodeAt(0) });
	// CONTROLS
	controls = new THREE.OrbitControls( camera, renderer.domElement );
 
	// LIGHT
	var light = new THREE.PointLight(0xffffff);
	light.position.set(0,250,0);
	scene.add(light);
 
	// scene.add(floor);
	// SKYBOX/FOG
	var skyBoxGeometry = new THREE.CubeGeometry( 10000, 10000, 10000 );
	var skyBoxMaterial = new THREE.MeshBasicMaterial( { color: 0x9999ff, side: THREE.BackSide } );
	var skyBox = new THREE.Mesh( skyBoxGeometry, skyBoxMaterial );
	// scene.add(skyBox);
	scene.fog = new THREE.FogExp2( 0x9999ff, 0.00025 );
 
	////////////
	// CUSTOM //
	////////////
	var materialNormal = new THREE.MeshNormalMaterial();
	var loader = new THREE.JSONLoader();
	loader.load( "./models/elephant.js", function( geo, head_materials ) {
			mainObj = new THREE.Mesh(
				// new THREE.CubeGeometry(50, 50, 50, 2, 1, 1), 
				// new THREE.IcosahedronGeometry( 120, 2 ),
				geo,
				// new THREE.MeshBasicMaterial( { color: 0x00ee00, wireframe: true, transparent: true } ) 
				materialNormal
				// new THREE.MeshNormalMaterial({side: THREE.DoubleSide })
				// new THREE.MeshFaceMaterial( head_materials )
			);
			mainObj.scale = new THREE.Vector3(300,300,300 );
 
			mainObj.position.set(-90,-20,0);
			mainObj.rotation.set(0,4*Math.PI/4,0);
			// mainObj.rotation.set(0,Math.PI/2,0);//face
			scene.add( mainObj );
			mainGeo = mainObj.geometry;
 
			adjacencyList = makeAdjacencyList(mainObj.geometry);
			mainGeo.vList = {};
			for (var i = 0; i < mainGeo.vertices.length; i++) { 				mainGeo.vList[i] = Math.random() > .5 ? 'T' : 'H';
			}
			var bar = 10;
			animate();
			screenshot(function(){
				main();
			});
			function main () {
				if (bar > 0) {
					starContract();
					animate();
					console.log('Contracted', i);
					screenshot(function(){
						bar--;
						main();
					});
				}
			}			
	});
}
	var mapping = {};
function starContract() {
	var neighbours, mappedTo;
	var c = 0;
	//For every vertex give it a H or T
	//Init a mapping from v -> v
	for (var v in mainGeo.vList) {
		mainGeo.vList[v] = Math.random() > .5 ? 'T' : 'H';
		mapping[v] = v;
	}
	//For ever T vertex pick one adjacent H to contract to.
	for (var v in mainGeo.vList) {
		if (mainGeo.vList[v] == 'T') {
			// map to and return a adjacent vertex
			mappedTo = contractToHead(v);
			//record where we mapped to.
			mapping[v] = mappedTo;
			if (mappedTo != v) delete mainGeo.vList[v];
			// console.log(v, mappedTo);
			c++;
		}
	}
	var oldN;
	var newN;
	// Update adjacency list to account for contracted vertices.
	for (var vert in adjacencyList) {
		for (var neigh in adjacencyList[vert]) {
			newN = mapping[neigh];
			delete adjacencyList[vert][neigh];
			adjacencyList[vert][newN] = true;
		}
	}
	for (var i = 0; i < mainGeo.vertices.length; i++) {
		mainGeo.vertices[i].copy(mainGeo.vertices[mapping[i]]);
	};
	mainGeo.verticesNeedUpdate = true;
	return;
}
function contractToHead(i) {
	neighbours = adjacencyList[i];
	if (Object.keys(neighbours).length == 0) {
		return console.log('no neighbors.');
	}
	for (var n in neighbours) {
		// attach to first H.
 
		if (mainGeo.vList[n] == 'H') {
			//contract the T vert to H vert
			mainGeo.vertices[i] = mainGeo.vertices[n];
			adjacencyList[n] = mergeObjs(adjacencyList[i], adjacencyList[n]);
			delete adjacencyList[n][n];
			delete adjacencyList[n][i];
			delete adjacencyList[i];
			return n;
		}	
	}
	return i;
}
 
function makeAdjacencyList (geometry) {
	var m = {};
	var f;
	for (var i = 0; i < geometry.faces.length; i++) {
		f = geometry.faces[i];
		if (!m[f.a]) m[f.a] = {};
		if (!m[f.b]) m[f.b] = {};
		if (!m[f.c]) m[f.c] = {};
		m[f.a][f.b] = true;
		m[f.a][f.c] = true;
		m[f.b][f.a] = true;
		m[f.b][f.c] = true;
		m[f.c][f.a] = true;
		m[f.c][f.b] = true;
	}
	return m;
}
var rdy = true;
function update() {
	if (keyboard.pressed("z") && rdy) {
		starContract();
		rdy = false;
		setTimeout(function() {
			rdy = true;
		}, 500);
	}
	// controls.update();
}
function randomInt(n, i) {
	i = i || 0;
	return Math.floor((Math.random()*n)+i);
}
function randomProperty(obj) {
  var result;
  var count = 0;
  for (var prop in obj) {
    if (Math.random() < 1/++count) {
			result = prop;
		}
	}
  return result;
}
function render() {
	renderer.render( scene, camera );
}
function animate() {
  requestAnimationFrame( animate );
	render();		
	update();
}
 
function mergeObjs(obj1,obj2) {
  var obj3 = {};
  for (var attrname in obj1) { obj3[attrname] = obj1[attrname]; }
  for (var attrname in obj2) { obj3[attrname] = obj2[attrname]; }
  return obj3;
}
// Array Remove - By John Resig (MIT Licensed)
Array.prototype.remove = function(from, to) {
  var rest = this.slice((to || from) + 1 || this.length);
  this.length = from < 0 ? this.length + from : from;
  return this.push.apply(this, rest);
}
 
/*** ADDING SCREEN SHOT ABILITY ***/
function screenshot (callback) {
	img = document.getElementById('embedImage');
  var imgNode;
  //Listen to 'P' key 
  try {
    img.src = renderer.domElement.toDataURL(); 
    img.download = 'foo.png';
    img.onload = function () {
    	var myWindow;
			myWindow = window.open(img.src.replace('image/png', 'image/octet-stream'), "width=512,height=512");
    	console.log('saved');
    	callback();
	  };
  } 
  catch(e) {
    console.log("Browser does not support taking screenshot of 3d context");
    return;
  }
}

/* Credit to Golan Levin for the recording option */
 
int nFrames = 10;
int nElapsedFrames = 0;
int quadCount = 30;
Quad[] quads = new Quad[quadCount];
boolean bRecording;
PFont font;
 
void setup() 
{
  frameRate(10);
  font = loadFont("Minecraftia-80.vlw");
  textFont(font, 80);
  smooth();
  noStroke();
  size(1500, 1500);
  float f = -(float) quadCount/2;
 
  for (int i = 0; i < quadCount; i++) { 
    quads[i] = new Quad(f);
    f++;
  }
}
 
void draw() {
  if (nElapsedFrames < nFrames) {
    translate(width/2, height/2); 
    background(#A32121);
 
    for (int i = 0; i < quadCount; i++) { 
      Quad quad = (Quad) quads[i];
      quad.display();
    }
    fill(255);
    text("#C0FFEE", -210, 680);
 
    saveFrame("c0ffee-###.png");
 
    nElapsedFrames++;
  }
  else {
    noLoop();
    exit();
  }
}
 
class Quad {
  float rad;
  float angle;
  float dec;
 
  //particle constructor
  Quad(float angle_) {
    angle = angle_;
    dec = 200 * 0.00004; 
 
  }
 
  void display () {
    //for GIF POP version only
    pushMatrix();
    scale(3.0, 3.0);
 
    pushMatrix();
    rotate(radians(90));
 
    fill(#C0FFEE, 45);
 
    quad(20*sin(angle), sin(angle), 180*cos(angle), sin(angle), 
    120*cos(angle), 100*sin(angle)+100, sin(angle), abs(30*sin(angle)));
 
    pushMatrix();
    scale(1.0, -1.0);
    quad(20*sin(angle), sin(angle), 180*cos(angle), sin(angle), 
    120*cos(angle), (100*sin(angle)+100), sin(angle), abs(30*sin(angle)));
    popMatrix();
 
    angle+=dec;
    popMatrix();
 
    popMatrix();
  }
}

// Kevan Loney
// January 2014
// CMU - IACD - Project 1_ Lenticular Animation - Coffee
// Prof. Golan Levin
 
//======================================================================================
 
// Global variables. 
 
int     nFramesInLoop = 30;
int     nElapsedFrames;
boolean bRecording; 
float   percentCompleteFraction;
 
//======================================================================================
 
void setup() {
  size (500, 500); 
  bRecording = false;
  nElapsedFrames = 0;
  frameRate (nFramesInLoop);
}
//======================================================================================
 
void keyPressed() { 
  // Press a key to export frames to the output folder
  bRecording = true;
  nElapsedFrames = 0;
}
 
//======================================================================================
 
void draw() {
 
  // Compute a percentage (0...1) representing where we are in the loop.
  float percentCompleteFraction = 0; 
  if (bRecording) {
    percentCompleteFraction = (float) nElapsedFrames / (float)nFramesInLoop;
  } 
  else {
    float modFrame = (float) (frameCount % nFramesInLoop);
    percentCompleteFraction = modFrame / (float)nFramesInLoop;
  }
 
  // Render the design, based on that percentage. 
  globalWorld (percentCompleteFraction);
 
  // If we're recording the output, save the frame to a file. 
  if (bRecording) {
    saveFrame("output/" + "-loop-" + nf(nElapsedFrames, 4) + ".png");
    nElapsedFrames++; 
    if (nElapsedFrames == nFramesInLoop) {
      bRecording = false;
    }
  }
}
 
//======================================================================================
 
void globalWorld(float percentCompleteFraction) {
background (#E0E0E0);
smooth();
 
  pushMatrix();
  translate(140,0);
  CoffeeDrips(percentCompleteFraction);
  popMatrix();
  pushMatrix();
  CoffeeCup();
  popMatrix();
 
}
 
void CoffeeCup () {
  //background(255);
  translate(500/3.8, 500-300);
  scale(1.1, 1.1);
  fill(#F2ECDF);
  stroke(255);
  strokeWeight(0);
 
  //-------------------------------------------------
  fill(#EDEDED);
  stroke(1);
  strokeWeight(0);
  beginShape(); //World Floor
  vertex(-118,240);
  vertex(340, 240);
  vertex(335, 272);
  vertex(-120, 272);
 
  endShape();
 
  //-------------------------------------------------
  beginShape(); // The base cup
  vertex(50, 250);
  vertex(0, 0);
  vertex(-10, 0);
  vertex(-10, -10);
  vertex(210, -10);
  vertex(210, 0);
  vertex(200, 0);
  vertex(150, 250);
  endShape();
  //-------------------------------------------------
  fill(40, 32, 17, 70); // Graphic Shadow
  stroke(255);
  strokeWeight(0);
  beginShape(); 
  vertex(50, 250);
  vertex(0, 0);
  vertex(200, 0);
  vertex(100, 20);
  vertex(75, 40);
  vertex(75,150);
  vertex(170,150);
  vertex(168, 160);
  vertex(75, 160);
  vertex(75, 250);
  endShape();
  //-------------------------------------------------
  fill(255, 255 , 255, 190); // Graphic Highlight
  stroke(255);
  strokeWeight(0);
  beginShape();
  vertex(140,250);
  vertex(146, 250);
  vertex(193, 10);
  vertex(187, 10);
  endShape();
  beginShape();
  vertex(-5, -6);
  vertex(-5, -8);
  vertex(205, -8);
  vertex(205, -6);
  endShape();
  //-------------------------------------------------
  fill(#A27926); // Graphic CupHolder
  stroke(1);
  strokeWeight(0);
  beginShape();
  vertex(195,65);
  vertex(5 ,65);
  vertex(25, 150);
  vertex(175, 150);
  endShape();
  //-------------------------------------------------
  fill(#195211); //Graphic SBucks Logo
  stroke(1);
  strokeWeight(0);
  ellipse(98, 108, 70, 70);
  //-------------------------------------------------
  fill(46, 87, 22, 90); // Graphic Holder Shadow
  stroke(1);
  strokeWeight(0);
  beginShape();
  vertex(5, 65);
  vertex(25, 150);
  vertex(50, 150);
  vertex(35, 70);
  vertex(193, 70);
  vertex(195,65);
  endShape();
  //-------------------------------------------------
  fill(#898989); //CUP shadow
  stroke(1);
  strokeWeight(0);
  beginShape();
  vertex(50, 250);
  vertex(-120, 272);
  vertex(335, 272);
  vertex(150, 250);
  endShape();
  //-------------------------------------------------
  fill(#646464); // Cup Shadow number2
  stroke(1);
  strokeWeight(0);
  beginShape();
  vertex(50,250);
  vertex(20,255);
  vertex(180, 255);
  vertex(150, 250);
  endShape();
 
}
 
void CoffeeDrips (float percent){
 
  float DripSize = -15;
  float changeY = DripSize - (percent*-30);
 
  int CoffeeDripAnim = 7;
  for (int i=0; i <= CoffeeDripAnim; i++) {
    float dripSpace = DripSize + (i*changeY);
    translate( 0, dripSpace);
 
  }
  fill(#552907); // Drip Base Shape/Color
  stroke(1);
  strokeWeight(0);
  translate (100,0);
  scale(3,3);
  beginShape();
  vertex(0,0);
  vertex(-3,10);
  vertex(-6, 15);
  vertex(-7, 19);
  vertex(-6.5,20);
  vertex(-4, 23);
  vertex(0, 25);
  vertex(4, 23);
  vertex(6.5, 20);
  vertex(7, 19);
  vertex(6, 15);
  vertex(3,10);
  endShape();
  //-------------------------------------------------
  fill(#EAC09F); // Drip Highlight
  stroke(1);
  strokeWeight(0);
  beginShape();
  vertex(1,8);
  vertex(2,12);
  vertex(4,15);
  vertex(5, 18);
  vertex(4, 21);
  vertex(2, 23);
  endShape();
 
}

// This is was based off a template by Prof. Golan Levin, Jan. 2014 CMU IACD
// When you press a key, this program will export a series of images
// into an "output" directory located in its sketch folder.
// These can then be combined into an animated GIF.
// Chanamon Ratanalert, January 2014 - CMU IACD
 
//===================================================
// Global variables.
 
int nFramesInLoop = 30; // for lenticular export, change this to 10!
int nElapsedFrames;
boolean bRecording;
float radius;
float wdth; //variable width of center diamonds
float maxWdth; //maximum width of center diamonds
float pointy; //variable height of points around large circle
float maxPointY; //max height of points around large circle
float tinting; //variable for color of small diamonds
float maxTinting; //max color change of small diamonds
int bkgd;
String myName = "chanamon";
//===================================================
void setup() {
size (500, 500);
radius = 140;
wdth = 100;
maxWdth = 100;
pointy = 30;
maxPointY = 30;
bkgd = 51;
tinting = 130;
maxTinting = 128;
 
bRecording = false;
// bRecording = true; //use true if want to immediately start recording
nElapsedFrames = 0;
frameRate (nFramesInLoop);
}
//===================================================
void keyPressed() {
// Press a key to export frames to the output folder
bRecording = true;
nElapsedFrames = 0;
}
 
//===================================================
void draw() {
 
// Compute a percentage (0...1) representing where we are in the loop.
float percentCompleteFraction = 0;
if (bRecording) {
percentCompleteFraction = (float) nElapsedFrames / (float)nFramesInLoop;
}
else {
float modFrame = (float) (frameCount % nFramesInLoop);
percentCompleteFraction = modFrame / (float)nFramesInLoop;
}
 
// Render the design, based on that percentage.
renderInner (percentCompleteFraction);
renderOuter (percentCompleteFraction);
 
// If we're recording the output, save the frame to a file.
if (bRecording) {
saveFrame("output/"+ myName + "-loop-" + nf(nElapsedFrames, 4) + ".png");
nElapsedFrames++;
// if (nElapsedFrames == nFramesInLoop) { //uncomment if want to record nFramesInLoop # of imgs
if (percentCompleteFraction == 3){
bRecording = false;
}
}
}
 
//===================================================
void renderInner (float percent) {
//this method draws the inner diamond spokes and two circles
 
//changes made as time passes
float angle = percent * (TWO_PI/8);
wdth = wdth - 1; //width of center diamonds
if (abs(wdth) >= maxWdth){
wdth = maxWdth;
}
 
//begin imaging
background(bkgd);
smooth();
translate(width/2, height/2);
rotate(angle);
stroke(bkgd + 90);
ellipse(0, 0, 10, 10); //center circle
ellipse(0, 0, radius*2, radius*2); //outer circle
noFill();
strokeWeight(2);
//draw inner diamond spokes
for (int i = 0; i <= 8; i++) {
stroke(255);
rotate(radians(45));
float topx = 0;
float topy = 0;
float dx = wdth/2;
float dy = radius/2;
beginShape();
vertex(topx, topy);
vertex(topx-dx, topy+dy);
vertex(topx, topy+radius);
vertex(topx+dx, topy+dy);
endShape(CLOSE);
}
}
 
//===================================================
void renderOuter (float percent) {
//this method draws the outer points and small diamonds
 
//changes made as time passes
float angle = percent * (TWO_PI/8);
wdth = wdth - 1; //width of center diamonds
if (abs(wdth) > maxWdth){
wdth = maxWdth;
}
 
tinting = tinting - 2; //changing color of small outer diamonds
if (abs(tinting) > maxTinting){
tinting = maxTinting;
}
 
//begin imaging
smooth();
rotate(angle*(-2));
noFill();
strokeWeight(2);
for (int i = 0; i <= 8; i++) {
rotate(radians(45));
stroke(bkgd + 90);
line(0,radius,radius/2,radius+pointy);
line(0,-radius,radius/2,-radius-pointy);
 
//draw diamonds
float topx = 0;
float topy = 0 + radius + pointy;
float r = pointy;
float w = 2*pointy/3;
float dx = w/2;
float dy = r/3;
stroke(bkgd + abs(tinting));
beginShape();
vertex(topx, topy);
vertex(topx-dx, topy+dy);
vertex(topx, topy+r);
vertex(topx+dx, topy+dy);
endShape(CLOSE);
}
}