/**
 * @author Tony Parisi / http://www.tonyparisi.com/
 */


THREE.glTFLoader = function (showStatus) {
	this.meshesRequested = 0;
	this.meshesLoaded = 0;
	this.pendingMeshes = [];
	this.animationsRequested = 0;
	this.animationsLoaded = 0;
	this.animations = [];
	this.shadersRequested = 0;
	this.shadersLoaded = 0;
	this.shaders = {};
	THREE.Loader.call( this, showStatus );
}

THREE.glTFLoader.prototype = Object.create( THREE.Loader.prototype );
THREE.glTFLoader.prototype.constructor = THREE.glTFLoader;

THREE.glTFLoader.prototype.load = function( url, callback ) {
	
	var theLoader = this;
	// Utilities

	function RgbArraytoHex(colorArray) {
		if (!colorArray) return 0xFFFFFFFF;
		var r = Math.floor(colorArray[0] * 255),
            g = Math.floor(colorArray[1] * 255),
            b = Math.floor(colorArray[2] * 255),
            a = 255;

		var color = (a << 24) + (r << 16) + (g << 8) + b;

		return color;
	}
    
	function convertAxisAngleToQuaternion(rotations, count)
    {
		var q = new THREE.Quaternion;
		var axis = new THREE.Vector3;
		var euler = new THREE.Vector3;
    	
		var i;
		for (i = 0; i < count; i ++) {
			axis.set(rotations[i * 4], rotations[i * 4 + 1],
    				rotations[i * 4 + 2]).normalize();
			var angle = rotations[i * 4 + 3];
			q.setFromAxisAngle(axis, angle);
			rotations[i * 4] = q.x;
			rotations[i * 4 + 1] = q.y;
			rotations[i * 4 + 2] = q.z;
			rotations[i * 4 + 3] = q.w;
		}
	}

	function componentsPerElementForGLType(glType) {
		switch (glType) {
			case WebGLRenderingContext.FLOAT :
			case WebGLRenderingContext.UNSIGNED_BYTE :
			case WebGLRenderingContext.UNSIGNED_SHORT :
				return 1;
			case WebGLRenderingContext.FLOAT_VEC2 :
				return 2;
			case WebGLRenderingContext.FLOAT_VEC3 :
				return 3;
			case WebGLRenderingContext.FLOAT_VEC4 :
				return 4;
			case WebGLRenderingContext.FLOAT_MAT4 :
				return 16;
			default:
				return null;
		}
	}


	function LoadTexture(src) {
		if (!src) { return null; }
		return THREE.ImageUtils.loadTexture(src);
	}

    // Geometry processing

	var ClassicGeometry = function() {

		this.geometry = new THREE.BufferGeometry;

		this.totalAttributes = 0;
		this.loadedAttributes = 0;
		this.indicesLoaded = false;
		this.finished = false;

		this.onload = null;

		this.uvs = null;
		this.indexArray = null;
	};

	ClassicGeometry.prototype.constructor = ClassicGeometry;

	ClassicGeometry.prototype.buildBufferGeometry = function() {
        // Build indexed mesh
		var geometry = this.geometry;

		geometry.addAttribute( 'index', new THREE.BufferAttribute( this.indexArray, 1 ) );
		geometry.addDrawCall( 0, this.indexArray.length, 0 );

		geometry.computeBoundingSphere();
	}
    
	ClassicGeometry.prototype.checkFinished = function() {
		if (this.indexArray && this.loadedAttributes === this.totalAttributes) {
        	
			this.buildBufferGeometry();
        	
			this.finished = true;

			if (this.onload) {
				this.onload();
			}
		}
	};

    // Delegate for processing index buffers
	var IndicesDelegate = function() {};

	IndicesDelegate.prototype.handleError = function(errorCode, info) {
        // FIXME: report error
		console.log("ERROR(IndicesDelegate):" + errorCode + ":" + info);
	};

	IndicesDelegate.prototype.convert = function(resource, ctx) {
		return new Uint16Array(resource, 0, ctx.indices.count);
	};

	IndicesDelegate.prototype.resourceAvailable = function(glResource, ctx) {
		var geometry = ctx.geometry;
		geometry.indexArray = glResource;
		geometry.checkFinished();
		return true;
	};

	var indicesDelegate = new IndicesDelegate();

	var IndicesContext = function(indices, geometry) {
		this.indices = indices;
		this.geometry = geometry;
	};
    
    // Delegate for processing vertex attribute buffers
	var VertexAttributeDelegate = function() {};

	VertexAttributeDelegate.prototype.handleError = function(errorCode, info) {
        // FIXME: report error
		console.log("ERROR(VertexAttributeDelegate):" + errorCode + ":" + info);
	};

	VertexAttributeDelegate.prototype.convert = function(resource, ctx) {
		return resource;
	};



	VertexAttributeDelegate.prototype.arrayResourceAvailable = function(glResource, ctx) {
		var geom = ctx.geometry;
		var attribute = ctx.attribute;
		var semantic = ctx.semantic;
		var floatArray;
		var i, l;
        //FIXME: Float32 is assumed here, but should be checked.

		if (semantic == "POSITION") {
            // TODO: Should be easy to take strides into account here
			floatArray = new Float32Array(glResource, 0, attribute.count * componentsPerElementForGLType(attribute.type));
			for (i = 0, l = floatArray.length; i < l; i += 3) {
				geom.geometry.vertices.push( new THREE.Vector3( floatArray[i], floatArray[i + 1], floatArray[i + 2] ) );
			}
		} else if (semantic == "NORMAL") {
			geom.geometry.normals = [];
			floatArray = new Float32Array(glResource, 0, attribute.count * componentsPerElementForGLType(attribute.type));
			for (i = 0, l = floatArray.length; i < l; i += 3) {
				geom.geometry.normals.push( new THREE.Vector3( floatArray[i], floatArray[i + 1], floatArray[i + 2] ) );
			}
		} else if ((semantic == "TEXCOORD_0") || (semantic == "TEXCOORD" )) {
			geom.uvs = [];
			floatArray = new Float32Array(glResource, 0, attribute.count * componentsPerElementForGLType(attribute.type));
			for (i = 0, l = floatArray.length; i < l; i += 2) {
				geom.uvs.push( new THREE.Vector2( floatArray[i], 1.0 - floatArray[i + 1] ) );
			}
		}
        else if (semantic == "WEIGHT") {
	nComponents = componentsPerElementForGLType(attribute.type);
	floatArray = new Float32Array(glResource, 0, attribute.count * nComponents);
	for (i = 0, l = floatArray.length; i < l; i += 4) {
		geom.geometry.skinWeights.push( new THREE.Vector4( floatArray[i], floatArray[i + 1], floatArray[i + 2], floatArray[i + 3] ) );
	}
        }
        else if (semantic == "JOINT") {
	nComponents = componentsPerElementForGLType(attribute.type);
	floatArray = new Float32Array(glResource, 0, attribute.count * nComponents);
	for (i = 0, l = floatArray.length; i < l; i += 4) {
		geom.geometry.skinIndices.push( new THREE.Vector4( floatArray[i], floatArray[i + 1], floatArray[i + 2], floatArray[i + 3] ) );
	}
        }
	}
    
	VertexAttributeDelegate.prototype.bufferResourceAvailable = function(glResource, ctx) {
		var geom = ctx.geometry;
		var attribute = ctx.attribute;
		var semantic = ctx.semantic;
		var floatArray;
		var i, l;
		var nComponents;
        //FIXME: Float32 is assumed here, but should be checked.

		if (semantic == "POSITION") {
            // TODO: Should be easy to take strides into account here
			floatArray = new Float32Array(glResource, 0, attribute.count * componentsPerElementForGLType(attribute.type));
			geom.geometry.addAttribute( 'position', new THREE.BufferAttribute( floatArray, 3 ) );
		} else if (semantic == "NORMAL") {
			floatArray = new Float32Array(glResource, 0, attribute.count * componentsPerElementForGLType(attribute.type));
			geom.geometry.addAttribute( 'normal', new THREE.BufferAttribute( floatArray, 3 ) );
		} else if ((semantic == "TEXCOORD_0") || (semantic == "TEXCOORD" )) {
        	
			nComponents = componentsPerElementForGLType(attribute.type);
			floatArray = new Float32Array(glResource, 0, attribute.count * nComponents);
            // N.B.: flip Y value... should we just set texture.flipY everywhere?
			for (i = 0; i < floatArray.length / 2; i ++) {
				floatArray[i * 2 + 1] = 1.0 - floatArray[i * 2 + 1];
			}
			geom.geometry.addAttribute( 'uv', new THREE.BufferAttribute( floatArray, nComponents ) );
		}
        else if (semantic == "WEIGHT") {
	nComponents = componentsPerElementForGLType(attribute.type);
	floatArray = new Float32Array(glResource, 0, attribute.count * nComponents);
	geom.geometry.addAttribute( 'skinWeight', new THREE.BufferAttribute( floatArray, nComponents ) );
        }
        else if (semantic == "JOINT") {
	nComponents = componentsPerElementForGLType(attribute.type);
	floatArray = new Float32Array(glResource, 0, attribute.count * nComponents);
	geom.geometry.addAttribute( 'skinIndex', new THREE.BufferAttribute( floatArray, nComponents ) );
        }
	}
    
	VertexAttributeDelegate.prototype.resourceAvailable = function(glResource, ctx) {

		this.bufferResourceAvailable(glResource, ctx);
    	
		var geom = ctx.geometry;
		geom.loadedAttributes ++;
		geom.checkFinished();
		return true;
	};

	var vertexAttributeDelegate = new VertexAttributeDelegate();

	var VertexAttributeContext = function(attribute, semantic, geometry) {
		this.attribute = attribute;
		this.semantic = semantic;
		this.geometry = geometry;
	};

	var Mesh = function() {
		this.primitives = [];
		this.materialsPending = [];
		this.loadedGeometry = 0;
		this.onCompleteCallbacks = [];
	};

	Mesh.prototype.addPrimitive = function(geometry, material) {
        
		var self = this;
		geometry.onload = function() {
			self.loadedGeometry ++;
			self.checkComplete();
		};
        
		this.primitives.push({
            geometry: geometry,
            material: material,
            mesh: null
        });
	};

	Mesh.prototype.onComplete = function(callback) {
		this.onCompleteCallbacks.push(callback);
		this.checkComplete();
	};

	Mesh.prototype.checkComplete = function() {
		var self = this;
		if (this.onCompleteCallbacks.length && this.primitives.length == this.loadedGeometry) {
			this.onCompleteCallbacks.forEach(function(callback) {
				callback(self);
			});
			this.onCompleteCallbacks = [];
		}
	};

	Mesh.prototype.attachToNode = function(threeNode) {
        // Assumes that the geometry is complete
		this.primitives.forEach(function(primitive) {
            /*if(!primitive.mesh) {
                primitive.mesh = new THREE.Mesh(primitive.geometry, primitive.material);
            }*/
			var material = primitive.material;
			if (!(material instanceof THREE.Material)) {
				material = theLoader.createShaderMaterial(material);
			}

			var threeMesh = new THREE.Mesh(primitive.geometry.geometry, material);
			threeMesh.castShadow = true;
			threeNode.add(threeMesh);
		});
	};

    // Delayed-loaded material
	var Material = function(params) {
		this.params = params;
	};
    
    // Delegate for processing animation parameter buffers
	var AnimationParameterDelegate = function() {};

	AnimationParameterDelegate.prototype.handleError = function(errorCode, info) {
        // FIXME: report error
		console.log("ERROR(AnimationParameterDelegate):" + errorCode + ":" + info);
	};

	AnimationParameterDelegate.prototype.convert = function(resource, ctx) {
		var parameter = ctx.parameter;

		var glResource = null;
		switch (parameter.type) {
			case WebGLRenderingContext.FLOAT :
			case WebGLRenderingContext.FLOAT_VEC2 :
			case WebGLRenderingContext.FLOAT_VEC3 :
			case WebGLRenderingContext.FLOAT_VEC4 :
				glResource = new Float32Array(resource, 0, parameter.count * componentsPerElementForGLType(parameter.type));
				break;
			default:
				break;
		}
    	
		return glResource;
	};

	AnimationParameterDelegate.prototype.resourceAvailable = function(glResource, ctx) {
		var animation = ctx.animation;
		var parameter = ctx.parameter;
		parameter.data = glResource;
		animation.handleParameterLoaded(parameter);
		return true;
	};

	var animationParameterDelegate = new AnimationParameterDelegate();

	var AnimationParameterContext = function(parameter, animation) {
		this.parameter = parameter;
		this.animation = animation;
	};

    // Animations
	var Animation = function() {

    	// create Three.js keyframe here
		this.totalParameters = 0;
		this.loadedParameters = 0;
		this.parameters = {};
		this.finishedLoading = false;
		this.onload = null;

	};

	Animation.prototype.constructor = Animation;

	Animation.prototype.handleParameterLoaded = function(parameter) {
		this.parameters[parameter.name] = parameter;
		this.loadedParameters ++;
		this.checkFinished();
	};
    
	Animation.prototype.checkFinished = function() {
		if (this.loadedParameters === this.totalParameters) {
            // Build animation
			this.finishedLoading = true;

			if (this.onload) {
				this.onload();
			}
		}
	};
    
    // Delegate for processing inverse bind matrices buffer
	var InverseBindMatricesDelegate = function() {};

	InverseBindMatricesDelegate.prototype.handleError = function(errorCode, info) {
        // FIXME: report error
		console.log("ERROR(InverseBindMatricesDelegate):" + errorCode + ":" + info);
	};

	InverseBindMatricesDelegate.prototype.convert = function(resource, ctx) {
		var parameter = ctx.parameter;

		var glResource = null;
		switch (parameter.type) {
			case WebGLRenderingContext.FLOAT_MAT4 :
				glResource = new Float32Array(resource, 0, parameter.count * componentsPerElementForGLType(parameter.type));
				break;
			default:
				break;
		}
    	
		return glResource;
	};

	InverseBindMatricesDelegate.prototype.resourceAvailable = function(glResource, ctx) {
		var skin = ctx.skin;
		skin.inverseBindMatrices = glResource;
		return true;
	};

	var inverseBindMatricesDelegate = new InverseBindMatricesDelegate();

	var InverseBindMatricesContext = function(param, skin) {
		this.parameter = param;
		this.skin = skin;
	};

    // Delegate for processing shaders from external files
	var ShaderDelegate = function() {};

	ShaderDelegate.prototype.handleError = function(errorCode, info) {
        // FIXME: report error
		console.log("ERROR(ShaderDelegate):" + errorCode + ":" + info);
	};

	ShaderDelegate.prototype.convert = function(resource, ctx) {
		return resource; 
	}
    
	ShaderDelegate.prototype.resourceAvailable = function(data, ctx) {
		theLoader.shadersLoaded ++;
		theLoader.shaders[ctx.id] = data;
		return true;
	};

	var shaderDelegate = new ShaderDelegate();

	var ShaderContext = function(id, path) {
		this.id = id;
		this.path = path;
	};
    
    // Resource management

	var ResourceEntry = function(entryID, object, description) {
		this.entryID = entryID;
		this.object = object;
		this.description = description;
	};

	var Resources = function() {
		this._entries = {};
	};

	Resources.prototype.setEntry = function(entryID, object, description) {
		if (!entryID) {
			console.error("No EntryID provided, cannot store", description);
			return;
		}

		if (this._entries[entryID]) {
			console.warn("entry[" + entryID + "] is being overwritten");
		}
    
		this._entries[entryID] = new ResourceEntry(entryID, object, description );
	};
    
	Resources.prototype.getEntry = function(entryID) {
		return this._entries[entryID];
	};

	Resources.prototype.clearEntries = function() {
		this._entries = {};
	};

	LoadDelegate = function() {
    }
    
	LoadDelegate.prototype.loadCompleted = function(callback, obj) {
		callback.call(Window, obj);
	}
    
    // Loader

	var ThreeGLTFLoader = Object.create(glTFParser, {

        load: {
            enumerable: true,
            value: function(userInfo, options) {
	this.resources = new Resources();
	this.cameras = [];
	this.lights = [];
	this.animations = [];
	this.joints = {};
	this.skeltons = {};
	THREE.GLTFLoaderUtils.init();
	glTFParser.load.call(this, userInfo, options);
            }
        },

        cameras: {
        	enumerable: true,
        	writable: true,
        	value : []
        },

        lights: {
        	enumerable: true,
        	writable: true,
        	value : []
        },
        
        animations: {
        	enumerable: true,
        	writable: true,
        	value : []
        },
        
        // Implement WebGLTFLoader handlers

        handleBuffer: {
            value: function(entryID, description, userInfo) {
	this.resources.setEntry(entryID, null, description);
	description.type = "ArrayBuffer";
	return true;
            }
        },

        handleBufferView: {
            value: function(entryID, description, userInfo) {
	this.resources.setEntry(entryID, null, description);

	var buffer =  this.resources.getEntry(description.buffer);
	description.type = "ArrayBufferView";

	var bufferViewEntry = this.resources.getEntry(entryID);
	bufferViewEntry.buffer = buffer;
	return true;
            }
        },

        handleShader: {
            value: function(entryID, description, userInfo) {
	this.resources.setEntry(entryID, null, description);
	var shaderRequest = {
        				id : entryID,
        				path : description.path,
        		};

	var shaderContext = new ShaderContext(entryID, description.path);

	theLoader.shadersRequested ++;
	THREE.GLTFLoaderUtils.getFile(shaderRequest, shaderDelegate, shaderContext);
        		
	return true;
            }
        },

        handleProgram: {
            value: function(entryID, description, userInfo) {
	this.resources.setEntry(entryID, null, description);
	return true;
            }
        },

        handleTechnique: {
            value: function(entryID, description, userInfo) {
	this.resources.setEntry(entryID, null, description);
	return true;
            }
        },

        createShaderMaterial : {
        	value: function(material) {
        		
	var fragmentShader = theLoader.shaders[material.params.fragmentShader];
	if (!fragmentShader) {
		console.log("ERROR: Missing fragment shader definition:", material.params.fragmentShader);
		return new THREE.MeshPhongMaterial;
	}
        		
	var vertexShader = theLoader.shaders[material.params.vertexShader];
	if (!fragmentShader) {
		console.log("ERROR: Missing vertex shader definition:", material.params.vertexShader);
		return new THREE.MeshPhongMaterial;
	}
        		
	var uniforms = {};
	var shaderMaterial = new THREE.ShaderMaterial( {

        			fragmentShader: fragmentShader,
        			vertexShader: vertexShader,
        			uniforms: uniforms,

        		} );

	return new THREE.MeshPhongMaterial(material.params);
        	}
        },
        
        createShaderParams : {
        	value: function(materialId, values, params, instanceProgram) {
	var program = this.resources.getEntry(instanceProgram.program);
				
	if (program) {
		params.fragmentShader = program.description.fragmentShader;
		params.vertexShader = program.description.vertexShader;
		params.attributes = instanceProgram.attributes;
		params.uniforms = instanceProgram.uniforms;
	}
        	}
        },
        
        threeJSMaterialType : {
            value: function(materialId, technique, values, params) {
        	
	var materialType = THREE.MeshPhongMaterial;
	var defaultPass = null;
	if (technique && technique.description && technique.description.passes)
        			defaultPass = technique.description.passes.defaultPass;
        		
	if (defaultPass) {
		if (defaultPass.details && defaultPass.details.commonProfile) {
			var profile = technique.description.passes.defaultPass.details.commonProfile;
			if (profile)
	            		{
				switch (profile.lightingModel)
		            		{
					case 'Blinn' :
					case 'Phong' :
						materialType = THREE.MeshPhongMaterial;
						break;
	
					case 'Lambert' :
						materialType = THREE.MeshLambertMaterial;
						break;
		            				
					default :
						materialType = THREE.MeshBasicMaterial;
						break;
				}
		            		
				if (profile.extras && profile.extras.doubleSided)
		            		{
					params.side = THREE.DoubleSide;
				}
			}
		}
        			else if (defaultPass.instanceProgram) {
        				
	var instanceProgram = defaultPass.instanceProgram;

	this.createShaderParams(materialId, values, params, instanceProgram);
    					
	var loadshaders = true;
    					
	if (loadshaders) {
		materialType = Material;
	}
        			}
	}
        		
	var texturePath = null;
	var textureParams = null;
	var diffuse = values.diffuse;
	if (diffuse)
                {
		var texture = diffuse;
		if (texture) {
			var textureEntry = this.resources.getEntry(texture);
			if (textureEntry) {
				{
					var imageEntry = this.resources.getEntry(textureEntry.description.source);
					if (imageEntry) {
						texturePath = imageEntry.description.path;
					}
                        		
					var samplerEntry = this.resources.getEntry(textureEntry.description.sampler);
					if (samplerEntry) {
						textureParams = samplerEntry.description;
					}
				}
			}
		}                    
	}

	var texture = LoadTexture(texturePath);
	if (texture && textureParams) {
                	
		if (textureParams.wrapS == WebGLRenderingContext.REPEAT)
                		texture.wrapS = THREE.RepeatWrapping;

		if (textureParams.wrapT == WebGLRenderingContext.REPEAT)
                		texture.wrapT = THREE.RepeatWrapping;
                	
		if (textureParams.magFilter == WebGLRenderingContext.LINEAR)
                		texture.magFilter = THREE.LinearFilter;

//                	if (textureParams.minFilter == "LINEAR")
//               		texture.minFilter = THREE.LinearFilter;
                	
		params.map = texture;
	}

	var envMapPath = null;
	var envMapParams = null;
	var reflective = values.reflective;
	if (reflective)
                {
		var texture = reflective;
		if (texture) {
			var textureEntry = this.resources.getEntry(texture);
			if (textureEntry) {
				{
					var imageEntry = this.resources.getEntry(textureEntry.description.source);
					if (imageEntry) {
						envMapPath = imageEntry.description.path;
					}
                        		
					var samplerEntry = this.resources.getEntry(textureEntry.description.sampler);
					if (samplerEntry) {
						envMapParams = samplerEntry.description;
					}
				}
			}
		}                    
	}

	var texture = LoadTexture(envMapPath);
	if (texture && envMapParams) {
                	
		if (envMapParams.wrapS == WebGLRenderingContext.REPEAT)
                		texture.wrapS = THREE.RepeatWrapping;

		if (envMapParams.wrapT == WebGLRenderingContext.REPEAT)
                		texture.wrapT = THREE.RepeatWrapping;
                	
		if (envMapParams.magFilter == WebGLRenderingContext.LINEAR)
                		texture.magFilter = THREE.LinearFilter;

//                	if (envMapParams.minFilter == WebGLRenderingContext.LINEAR)
//               		texture.minFilter = THREE.LinearFilter;
                	
		params.envMap = texture;
	}
                
	var shininess = values.shininesss || values.shininess; // N.B.: typo in converter!
	if (shininess)
                {
		shininess = shininess;
	}
                
	var diffuseColor = !texturePath ? diffuse : null;
	var opacity = 1.0;
	if (values.hasOwnProperty("transparency"))
                {
		var USE_A_ONE = true; // for now, hack because file format isn't telling us
		opacity =  USE_A_ONE ? values.transparency : (1.0 - values.transparency);
	}
                
                // if (diffuseColor) diffuseColor = [0, 1, 0];
                                    
	params.color = RgbArraytoHex(diffuseColor);
	params.opacity = opacity;
	params.transparent = opacity < 1.0;
                // hack hack hack
	if (texturePath && texturePath.toLowerCase().indexOf(".png") != -1)
                	params.transparent = true;
                
	if (!(shininess === undefined))
                {
		params.shininess = shininess;
	}
                
	if (!(values.emission === undefined))
                {
		params.emissive = RgbArraytoHex(values.emission);
	}
                
	if (!(values.specular === undefined))
                {
		params.specular = RgbArraytoHex(values.specular);
	}

	return materialType;
        		
        	}
        },
        
        handleMaterial: {
            value: function(entryID, description, userInfo) {
                //this should be rewritten using the meta datas that actually create the shader.
                //here we will infer what needs to be pass to Three.js by looking inside the technique parameters.
	var technique = this.resources.getEntry(description.instanceTechnique.technique);
	var materialParams = {};
	var values = description.instanceTechnique.values;
                
	var materialType = this.threeJSMaterialType(entryID, technique, values, materialParams);

	var material = new materialType(materialParams);
                
	this.resources.setEntry(entryID, material, description);

	return true;
            }
        },

        handleMesh: {
            value: function(entryID, description, userInfo) {
	var mesh = new Mesh();
	this.resources.setEntry(entryID, mesh, description);
	var primitivesDescription = description.primitives;
	if (!primitivesDescription) {
                    //FIXME: not implemented in delegate
		console.log("MISSING_PRIMITIVES for mesh:" + entryID);
		return false;
	}

	for (var i = 0 ; i < primitivesDescription.length ; i ++) {
		var primitiveDescription = primitivesDescription[i];
                    
		if (primitiveDescription.primitive === WebGLRenderingContext.TRIANGLES) {

			var geometry = new ClassicGeometry();
			var materialEntry = this.resources.getEntry(primitiveDescription.material);

			mesh.addPrimitive(geometry, materialEntry.object);

			var indices = this.resources.getEntry(primitiveDescription.indices);
			var bufferEntry = this.resources.getEntry(indices.description.bufferView);
			var indicesObject = {
                        		bufferView : bufferEntry,
                        		byteOffset : indices.description.byteOffset,
                        		count : indices.description.count,
                        		id : indices.entryID,
                        		type : indices.description.type
                        };
                        
			var indicesContext = new IndicesContext(indicesObject, geometry);
			var alreadyProcessedIndices = THREE.GLTFLoaderUtils.getBuffer(indicesObject, indicesDelegate, indicesContext);
                        /*if(alreadyProcessedIndices) {
                            indicesDelegate.resourceAvailable(alreadyProcessedIndices, indicesContext);
                        }*/

                        // Load Vertex Attributes
			var allAttributes = Object.keys(primitiveDescription.attributes);
			allAttributes.forEach( function(semantic) {
				geometry.totalAttributes ++;

				var attribute;
				var attributeID = primitiveDescription.attributes[semantic];
				var attributeEntry = this.resources.getEntry(attributeID);
				if (!attributeEntry) {
                                //let's just use an anonymous object for the attribute
					attribute = description.attributes[attributeID];
					attribute.id = attributeID;
					this.resources.setEntry(attributeID, attribute, attribute);
            
					var bufferEntry = this.resources.getEntry(attribute.bufferView);
					attributeEntry = this.resources.getEntry(attributeID);

				} else {
					attribute = attributeEntry.object;
					attribute.id = attributeID;
					var bufferEntry = this.resources.getEntry(attribute.bufferView);
				}

				var attributeObject = {
                            		bufferView : bufferEntry,
                            		byteOffset : attribute.byteOffset,
                            		byteStride : attribute.byteStride,
                            		count : attribute.count,
                            		max : attribute.max,
                            		min : attribute.min,
                            		type : attribute.type,
                            		id : attributeID             
                            };
                            
				var attribContext = new VertexAttributeContext(attributeObject, semantic, geometry);

				var alreadyProcessedAttribute = THREE.GLTFLoaderUtils.getBuffer(attributeObject, vertexAttributeDelegate, attribContext);
                            /*if(alreadyProcessedAttribute) {
                                vertexAttributeDelegate.resourceAvailable(alreadyProcessedAttribute, attribContext);
                            }*/
			}, this);
		}
	}
	return true;
            }
        },

        handleCamera: {
            value: function(entryID, description, userInfo) {
	var camera;
	if (description.type == "perspective")
                {
		var znear = description.perspective.znear;
		var zfar = description.perspective.zfar;
		var yfov = description.perspective.yfov;                	
		var xfov = description.perspective.xfov;
		var aspect_ratio = description.perspective.aspect_ratio;

		if (!aspect_ratio)
            			aspect_ratio = 1; 
            		
		if (yfov === undefined)
                	{
			if (xfov)
                		{
                			// According to COLLADA spec...
                			// aspect_ratio = xfov / yfov
				yfov = xfov / aspect_ratio;
			}
                		
		}
                	
		if (yfov)
                	{
			camera = new THREE.PerspectiveCamera(yfov, aspect_ratio, znear, zfar);
		}
	}
                else
	{
		camera = new THREE.OrthographicCamera( window.innerWidth / - 2, window.innerWidth / 2, window.innerHeight / 2, window.innerHeight / - 2, znear, zfar );
	}
                
	if (camera)
                {
		this.resources.setEntry(entryID, camera, description);
	}
                
	return true;
            }
        },

        handleLight: {
            value: function(entryID, description, userInfo) {

	var light = null;
	var type = description.type;
	if (type && description[type])
        		{
		var lparams = description[type];
		var color = RgbArraytoHex(lparams.color);
            		
		switch (type) {
			case "directional" :
				light = new THREE.DirectionalLight(color);
				light.position.set(0, 0, 1);
				break;
            			
			case "point" :
				light = new THREE.PointLight(color);
				break;
            			
			case "spot " :
				light = new THREE.SpotLight(color);
				light.position.set(0, 0, 1);
				break;
            			
			case "ambient" : 
				light = new THREE.AmbientLight(color);
				break;
		}
	}

	if (light)
        		{
		this.resources.setEntry(entryID, light, description);	
	}
        		
	return true;
            }
        },

        addPendingMesh: {
            value: function(mesh, threeNode) {
	theLoader.pendingMeshes.push({
        			mesh: mesh,
        			node: threeNode
        		});
        	}
        },
        
        handleNode: {
            value: function(entryID, description, userInfo) {

	var threeNode = null;
	            if (description.jointId) {
		threeNode = new THREE.Bone();
		threeNode.jointId = description.jointId;
		this.joints[description.jointId] = entryID;
	            }
	            else {
		threeNode = new THREE.Object3D();
	            }
	            
	threeNode.name = description.name;
                
	this.resources.setEntry(entryID, threeNode, description);

	var m = description.matrix;
	if (m) {
		threeNode.applyMatrix(new THREE.Matrix4().fromArray( m ));
		threeNode.matrixAutoUpdate = false;
		threeNode.matrixWorldNeedsUpdate = true;
	}
	else {
		var t = description.translation;
		var r = description.rotation;
		var s = description.scale;
                	
		var position = t ? new THREE.Vector3(t[0], t[1], t[2]) :
                		new THREE.Vector3;
		if (r) {
			convertAxisAngleToQuaternion(r, 1);
		}
		var rotation = r ? new THREE.Quaternion(r[0], r[1], r[2], r[3]) :
                		new THREE.Quaternion;
		var scale = s ? new THREE.Vector3(s[0], s[1], s[2]) :
                		new THREE.Vector3;
                	
		var matrix = new THREE.Matrix4;
		matrix.compose(position, rotation, scale);
		threeNode.matrixAutoUpdate = false;
		threeNode.matrixWorldNeedsUpdate = true;
		threeNode.applyMatrix(matrix);                    
	}

	var self = this;
                
                // Iterate through all node meshes and attach the appropriate objects
                //FIXME: decision needs to be made between these 2 ways, probably meshes will be discarded.
	var meshEntry;
	if (description.mesh) {
		meshEntry = this.resources.getEntry(description.mesh);
		theLoader.meshesRequested ++;
		meshEntry.object.onComplete(function(mesh) {
			self.addPendingMesh(mesh, threeNode);
			theLoader.meshesLoaded ++;
			theLoader.checkComplete();
		});
	}

	if (description.meshes) {
		description.meshes.forEach( function(meshID) {
			meshEntry = this.resources.getEntry(meshID);
			theLoader.meshesRequested ++;
			meshEntry.object.onComplete(function(mesh) {
				self.addPendingMesh(mesh, threeNode);
				theLoader.meshesLoaded ++;
				theLoader.checkComplete();
			});
		}, this);
	}

	if (description.instanceSkin) {

		var skinEntry =  this.resources.getEntry(description.instanceSkin.skin);
                	
		if (skinEntry) {

			var skin = skinEntry.object;
			description.instanceSkin.skin = skin;
			threeNode.instanceSkin = description.instanceSkin;

			var sources = description.instanceSkin.sources;
			skin.meshes = [];
			sources.forEach( function(meshID) {
				meshEntry = this.resources.getEntry(meshID);
				theLoader.meshesRequested ++;
				meshEntry.object.onComplete(function(mesh) {
                            	
					skin.meshes.push(mesh);
					theLoader.meshesLoaded ++;
					theLoader.checkComplete();
				});
			}, this);
                        
		}
	}
                                
	if (description.camera) {
		var cameraEntry = this.resources.getEntry(description.camera);
		if (cameraEntry) {
			threeNode.add(cameraEntry.object);
			this.cameras.push(cameraEntry.object);
		}
	}

	if (description.light) {
		var lightEntry = this.resources.getEntry(description.light);
		if (lightEntry) {
			threeNode.add(lightEntry.object);
			this.lights.push(lightEntry.object);
		}
	}
                
	return true;
            }
        },
        
        buildNodeHirerachy: {
            value: function(nodeEntryId, parentThreeNode) {
	var nodeEntry = this.resources.getEntry(nodeEntryId);
	var threeNode = nodeEntry.object;
	parentThreeNode.add(threeNode);

	var children = nodeEntry.description.children;
	if (children) {
		children.forEach( function(childID) {
			this.buildNodeHirerachy(childID, threeNode);
		}, this);
	}

	return threeNode;
            }
        },

        buildSkin: {
            value: function(node) {
        	
	var skin = node.instanceSkin.skin;
	if (skin) {
		node.instanceSkin.skeletons.forEach(function(skeleton) {
			var nodeEntry = this.resources.getEntry(skeleton);
			if (nodeEntry) {

				var rootSkeleton = nodeEntry.object;

				var dobones = true;

				var i, len = skin.meshes.length;
				for (i = 0; i < len; i ++) {
					var mesh = skin.meshes[i];
					var threeMesh = null;
					mesh.primitives.forEach(function(primitive) {

						var material = primitive.material;
						if (!(material instanceof THREE.Material)) {
							material = this.createShaderMaterial(material);
						}

						threeMesh = new THREE.SkinnedMesh(primitive.geometry.geometry, material, false);
						threeMesh.add(rootSkeleton);
                                	
						var geometry = primitive.geometry.geometry;
						var j;
						if (geometry.vertices) {
							for ( j = 0; j < geometry.vertices.length; j ++ ) {
								geometry.vertices[j].applyMatrix4( skin.bindShapeMatrix );	
							}
						}
                                    else if (geometry.attributes.position) {
	var a = geometry.attributes.position.array;
	var v = new THREE.Vector3;
	                            		for ( j = 0; j < a.length / 3; j ++ ) {
		v.set(a[j * 3], a[j * 3 + 1], a[j * 3 + 2]);
		v.applyMatrix4( skin.bindShapeMatrix );
		a[j * 3] = v.x;
		a[j * 3 + 1] = v.y;
		a[j * 3 + 2] = v.z;
	                            		}
                                    }

						if (threeMesh && dobones) {

							material.skinning = true;
        	                            
							threeMesh.boneInverses = [];
							var jointsIds = skin.jointsIds;
							var bones = [];
							var boneInverses = [];
							var i, len = jointsIds.length;
							for (i = 0; i < len; i ++) {
								var jointId = jointsIds[i];
								var nodeForJoint = this.joints[jointId];
								var joint = this.resources.getEntry(nodeForJoint).object;
								if (joint) {
        	                                	
									joint.skin = threeMesh;
									bones.push(joint);
        	                                    
									var m = skin.inverseBindMatrices;
									var mat = new THREE.Matrix4().set(
        	                                            m[i * 16 + 0],  m[i * 16 + 4],  m[i * 16 + 8],  m[i * 16 + 12],
        	                                            m[i * 16 + 1],  m[i * 16 + 5],  m[i * 16 + 9],  m[i * 16 + 13],
        	                                            m[i * 16 + 2],  m[i * 16 + 6],  m[i * 16 + 10], m[i * 16 + 14],
        	                                            m[i * 16 + 3],  m[i * 16 + 7],  m[i * 16 + 11], m[i * 16 + 15]
        	                                        );
									boneInverses.push(mat);
        	                                    
								} else {
									console.log("WARNING: jointId:" + jointId + " cannot be found in skeleton:" + skeleton);
								}
							}

							threeMesh.bind(new THREE.Skeleton(bones, boneInverses, false));
						}
                                    
						if (threeMesh) {
							threeMesh.castShadow = true;
							node.add(threeMesh);
						}
                                    
					}, this);                            	
				}
                            
			}

                    
		}, this);
                    
	}
            }
        },
         
        buildSkins: {
            value: function(node) {

	if (node.instanceSkin)
        			this.buildSkin(node);
        		
	var children = node.children;
	if (children) {
		children.forEach( function(child) {
			this.buildSkins(child);
		}, this);
	}
            }
        },
        
        createMeshAnimations : {
        	value : function(root) {
	this.buildSkins(root);
        		}
        },        

        handleScene: {
            value: function(entryID, description, userInfo) {

	if (!description.nodes) {
		console.log("ERROR: invalid file required nodes property is missing from scene");
		return false;
	}

	description.nodes.forEach( function(nodeUID) {
		this.buildNodeHirerachy(nodeUID, userInfo.rootObj);
	}, this);

	if (this.delegate) {
		this.delegate.loadCompleted(userInfo.callback, userInfo.rootObj);
	}

	return true;
            }
        },

        handleImage: {
            value: function(entryID, description, userInfo) {
	this.resources.setEntry(entryID, null, description);
	return true;
            }
        },
        
        addNodeAnimationChannel : {
        	value : function(name, channel, interp) {
	if (!this.nodeAnimationChannels)
        			this.nodeAnimationChannels = {};
        		
	if (!this.nodeAnimationChannels[name]) {
		this.nodeAnimationChannels[name] = [];
	}
        		
	this.nodeAnimationChannels[name].push(interp);
        	},
        },
        
        createAnimations : {
        	value : function() {
	for (var name in this.nodeAnimationChannels) {
		var nodeAnimationChannels = this.nodeAnimationChannels[name];
		var i, len = nodeAnimationChannels.length;
        			//console.log(" animation channels for node " + name);
        			//for (i = 0; i < len; i++) {
        			//	console.log(nodeAnimationChannels[i]);
        			//}
		var anim = new THREE.glTFAnimation(nodeAnimationChannels);
		anim.name = "animation_" + name;
		this.animations.push(anim);        				
	}
        	}
        },
        
        buildAnimation: {
        	value : function(animation) {
        	
	var interps = [];
	            var i, len = animation.channels.length;
	            for (i = 0; i < len; i ++) {
	            	
		var channel = animation.channels[i];
		var sampler = animation.samplers[channel.sampler];
		if (sampler) {
	
			var input = animation.parameters[sampler.input];
			if (input && input.data) {
	            			
				var output = animation.parameters[sampler.output];
				if (output && output.data) {
	            				
					var target = channel.target;
					var node = this.resources.getEntry(target.id);
					if (node) {

						var path = target.path;
		            				
						if (path == "rotation")
		            				{
							convertAxisAngleToQuaternion(output.data, output.count);
						}
		            				
						var interp = {
			            					keys : input.data,
			            					values : output.data,
			            					count : input.count,
			            					target : node.object,
			            					path : path,
			            					type : sampler.interpolation
			            			};
			            			
						this.addNodeAnimationChannel(target.id, channel, interp);
						interps.push(interp);
					}
				}
			}
		}
	            }	            
        	}
        },
        
        handleAnimation: {
            value: function(entryID, description, userInfo) {
        	
	var self = this;
	            theLoader.animationsRequested ++;
	            var animation = new Animation();
	animation.name = entryID;
	            animation.onload = function() {
	            	// self.buildAnimation(animation);
		theLoader.animationsLoaded ++;
		theLoader.animations.push(animation);
		theLoader.checkComplete();
	            };	            
	            
	            animation.channels = description.channels;
	            animation.samplers = description.samplers;
	            this.resources.setEntry(entryID, animation, description);
	            var parameters = description.parameters;
	            if (!parameters) {
	                //FIXME: not implemented in delegate
		console.log("MISSING_PARAMETERS for animation:" + entryID);
		return false;
	            }
	
                // Load parameter buffers
	var params = Object.keys(parameters);
	params.forEach( function(param) {

		animation.totalParameters ++;
		var parameter = parameters[param];
		var accessor = this.resources.getEntry(parameter);
		if (!accessor)
                    	debugger;
		accessor = accessor.object;
		var bufferView = this.resources.getEntry(accessor.bufferView);
		var paramObject = {
                    		bufferView : bufferView,
                    		byteOffset : accessor.byteOffset,
                    		count : accessor.count,
                    		type : accessor.type,
                    		id : accessor.bufferView,
                    		name : param             
                    };
                    
		var paramContext = new AnimationParameterContext(paramObject, animation);

		var alreadyProcessedAttribute = THREE.GLTFLoaderUtils.getBuffer(paramObject, animationParameterDelegate, paramContext);
                    /*if(alreadyProcessedAttribute) {
                        vertexAttributeDelegate.resourceAvailable(alreadyProcessedAttribute, attribContext);
                    }*/
	}, this);

	            return true;
            }
        },

        handleAccessor: {
            value: function(entryID, description, userInfo) {
	    		// Save attribute entry
	    		this.resources.setEntry(entryID, description, description);
	return true;
            }
        },

        handleSkin: {
            value: function(entryID, description, userInfo) {
	    		// Save skin entry
        	
	var skin = {
        		};
        		
	var m = description.bindShapeMatrix;
	            skin.bindShapeMatrix = new THREE.Matrix4().fromArray( m );
	            
	            skin.jointsIds = description.joints;
	            var inverseBindMatricesDescription = description.inverseBindMatrices;
	            skin.inverseBindMatricesDescription = inverseBindMatricesDescription;
	            skin.inverseBindMatricesDescription.id = entryID + "_inverseBindMatrices";

	var bufferEntry = this.resources.getEntry(inverseBindMatricesDescription.bufferView);

	var paramObject = {
                		bufferView : bufferEntry,
                		byteOffset : inverseBindMatricesDescription.byteOffset,
                		count : inverseBindMatricesDescription.count,
                		type : inverseBindMatricesDescription.type,
                		id : inverseBindMatricesDescription.bufferView,
                		name : skin.inverseBindMatricesDescription.id             
                };
                
	            var context = new InverseBindMatricesContext(paramObject, skin);

	var alreadyProcessedAttribute = THREE.GLTFLoaderUtils.getBuffer(paramObject, inverseBindMatricesDelegate, context);

	            var bufferView = this.resources.getEntry(skin.inverseBindMatricesDescription.bufferView);
	            skin.inverseBindMatricesDescription.bufferView = 
	            	bufferView.object;
	    		this.resources.setEntry(entryID, skin, description);
	return true;
            }
        },

        handleSampler: {
            value: function(entryID, description, userInfo) {
	    		// Save attribute entry
	    		this.resources.setEntry(entryID, description, description);
	return true;
            }
        },

        handleTexture: {
            value: function(entryID, description, userInfo) {
	    		// Save attribute entry
	    		this.resources.setEntry(entryID, null, description);
	return true;
            }
        },
        
        handleError: {
            value: function(msg) {

	throw new Error(msg);
	return true;
        	}
        },
        
        _delegate: {
            value: new LoadDelegate,
            writable: true
        },

        delegate: {
            enumerable: true,
            get: function() {
	return this._delegate;
            },
            set: function(value) {
	this._delegate = value;
            }
        }
    });


    // Loader

	var Context = function(rootObj, callback) {
		this.rootObj = rootObj;
		this.callback = callback;
	};

	var rootObj = new THREE.Object3D();

	var self = this;
    
	var loader = Object.create(ThreeGLTFLoader);
	loader.initWithPath(url);
	loader.load(new Context(rootObj, 
    					function(obj) {
    					}), 
    			null);

	this.loader = loader;
	this.callback = callback;
	this.rootObj = rootObj;
	return rootObj;
}

THREE.glTFLoader.prototype.callLoadedCallback = function() {
	var result = {
			scene : this.rootObj,
			cameras : this.loader.cameras,
			animations : this.loader.animations,
	};
	
	this.callback(result);
}

THREE.glTFLoader.prototype.checkComplete = function() {
	if (this.meshesLoaded == this.meshesRequested 
			&& this.shadersLoaded == this.shadersRequested
			&& this.animationsLoaded == this.animationsRequested)
	{
		
		for (var i = 0; i < this.pendingMeshes.length; i ++) {
			var pending = this.pendingMeshes[i];
			pending.mesh.attachToNode(pending.node);
		}
		
		for (var i = 0; i < this.animationsLoaded; i ++) {
			var animation = this.animations[i];
			this.loader.buildAnimation(animation);
		}

		this.loader.createAnimations();
		this.loader.createMeshAnimations(this.rootObj);
        
		this.callLoadedCallback();
	}
}



