Merge pull request #7743 from sunag/dev

sea3d revision 4

examples/js/ShaderTerrain.js

@@ -84,8 +84,6 @@ THREE.ShaderTerrain = {
 			"varying vec3 vNormal;",
 			"varying vec2 vUv;",
 
-			"uniform vec3 ambientLightColor;",
-
 			"varying vec3 vViewPosition;",
 
 			THREE.ShaderChunk[ "common" ],

examples/js/loaders/sea3d/SEA3DDeflate.js

@@ -600,8 +600,8 @@ var zip_inflate_dynamic = function(buff, off, size) {
     if(zip_bl == 0)	// no literals or lengths
 	h.status = 1;
     if(h.status != 0) {
-	if(h.status == 1)
-	    ;// **incomplete literal tree**
+	/*if(h.status == 1)
+	    ;// **incomplete literal tree** */
 	return -1;		// incomplete code set
     }
     zip_tl = h.root;
@@ -619,9 +619,9 @@ var zip_inflate_dynamic = function(buff, off, size) {
 	return -1;
     }
 
-    if(h.status == 1) {
+    /*if(h.status == 1) {
 	;// **incomplete distance tree**
-    }
+    }*/
     if(h.status != 0)
 	return -1;
 

examples/js/loaders/sea3d/SEA3DLegacy.js

+/**
+ * 	SEA3D Legacy for Three.JS
+ * 	@author Sunag / http://www.sunag.com.br/
+ */
+
+'use strict';
+
+//
+//	Header
+//
+
+THREE.SEA3D.prototype._onHead = THREE.SEA3D.prototype.onHead;
+THREE.SEA3D.prototype._updateTransform = THREE.SEA3D.prototype.updateTransform;
+THREE.SEA3D.prototype._readVertexAnimation = THREE.SEA3D.prototype.readVertexAnimation;
+THREE.SEA3D.prototype._readGeometryBuffer = THREE.SEA3D.prototype.readGeometryBuffer;
+THREE.SEA3D.prototype._readLine = THREE.SEA3D.prototype.readLine;
+THREE.SEA3D.prototype._getSkeletonAnimation = THREE.SEA3D.prototype.getSkeletonAnimation;
+THREE.SEA3D.prototype._applyDefaultAnimation = THREE.SEA3D.prototype.applyDefaultAnimation;
+
+//
+//	Utils
+//
+
+THREE.SEA3D.prototype.isLegacy = function( sea ) {
+
+	var sea3d = sea.sea3d;
+
+	if ( sea3d.sign == 'S3D' && ! sea._legacy ) {
+
+		sea._legacy = sea3d.typeUnique[ sea.type ] == true;
+
+		return sea3d.config.legacy;
+
+	}
+
+	return false;
+
+};
+
+THREE.SEA3D.prototype.flipZVec3 = function( v ) {
+
+	if ( ! v ) return;
+
+	var i = 2; // z
+
+	while ( i < v.length ) {
+
+		v[ i ] = - v[ i ];
+
+		i += 3;
+
+	}
+
+	return v;
+
+};
+
+THREE.SEA3D.prototype.expandJoints = function( sea ) {
+
+	var numJoints = sea.numVertex * 4;
+
+	var joint = sea.isBig ? new Uint32Array( numJoints ) : new Uint16Array( numJoints );
+	var weight = new Float32Array( numJoints );
+
+	var w = 0, jpv = sea.jointPerVertex;
+
+	for ( var i = 0; i < sea.numVertex; i ++ ) {
+
+		var tjsIndex = i * 4;
+		var seaIndex = i * jpv;
+
+		joint[ tjsIndex ] = sea.joint[ seaIndex ];
+		if ( jpv > 1 ) joint[ tjsIndex + 1 ] = sea.joint[ seaIndex + 1 ];
+		if ( jpv > 2 ) joint[ tjsIndex + 2 ] = sea.joint[ seaIndex + 2 ];
+		if ( jpv > 3 ) joint[ tjsIndex + 3 ] = sea.joint[ seaIndex + 3 ];
+
+		weight[ tjsIndex ] = sea.weight[ seaIndex ];
+		if ( jpv > 1 ) weight[ tjsIndex + 1 ] = sea.weight[ seaIndex + 1 ];
+		if ( jpv > 2 ) weight[ tjsIndex + 2 ] = sea.weight[ seaIndex + 2 ];
+		if ( jpv > 3 ) weight[ tjsIndex + 3 ] = sea.weight[ seaIndex + 3 ];
+
+		w = weight[ tjsIndex ] + weight[ tjsIndex + 1 ] + weight[ tjsIndex + 2 ] + weight[ tjsIndex + 3 ];
+
+		weight[ tjsIndex ] += 1 - w;
+
+	}
+
+	sea.joint = joint;
+	sea.weight = weight;
+
+	sea.jointPerVertex = 4;
+
+};
+
+THREE.SEA3D.prototype.compressJoints = function( sea ) {
+
+	var numJoints = sea.numVertex * 4;
+
+	var joint = sea.isBig ? new Uint32Array( numJoints ) : new Uint16Array( numJoints );
+	var weight = new Float32Array( numJoints );
+
+	var w = 0, jpv = sea.jointPerVertex;
+
+	for ( var i = 0; i < sea.numVertex; i ++ ) {
+
+		var tjsIndex = i * 4;
+		var seaIndex = i * jpv;
+
+		joint[ tjsIndex ] = sea.joint[ seaIndex ];
+		joint[ tjsIndex + 1 ] = sea.joint[ seaIndex + 1 ];
+		joint[ tjsIndex + 2 ] = sea.joint[ seaIndex + 2 ];
+		joint[ tjsIndex + 3 ] = sea.joint[ seaIndex + 3 ];
+
+		weight[ tjsIndex ] = sea.weight[ seaIndex ];
+		weight[ tjsIndex + 1 ] = sea.weight[ seaIndex + 1 ];
+		weight[ tjsIndex + 2 ] = sea.weight[ seaIndex + 2 ];
+		weight[ tjsIndex + 3 ] = sea.weight[ seaIndex + 3 ];
+
+		w = weight[ tjsIndex ] + weight[ tjsIndex + 1 ] + weight[ tjsIndex + 2 ] + weight[ tjsIndex + 3 ];
+
+		weight[ tjsIndex ] += 1 - w;
+
+	}
+
+	sea.joint = joint;
+	sea.weight = weight;
+
+	sea.jointPerVertex = 4;
+
+};
+
+THREE.SEA3D.prototype.flipZIndex = function( v ) {
+
+	var i = 1; // y >-< z
+
+	while ( i < v.length ) {
+
+		var idx = v[ i + 1 ];
+		v[ i + 1 ] = v[ i ];
+		v[ i ] = idx;
+
+		i += 3;
+
+	}
+
+	return v;
+
+};
+
+THREE.SEA3D.prototype.flipMatrixBone = function( mtx ) {
+
+	var zero = new THREE.Vector3();
+	var buf1 = new THREE.Matrix4();
+
+	return function( mtx ) {
+
+		buf1.copy( mtx );
+
+		mtx.setPosition( zero );
+		mtx.multiplyMatrices( THREE.SEA3D.MTXBUF.makeRotationZ( THREE.Math.degToRad( 180 ) ), mtx );
+		mtx.makeRotationFromQuaternion( THREE.SEA3D.QUABUF.setFromRotationMatrix( mtx ) );
+
+		var pos = THREE.SEA3D.VECBUF.setFromMatrixPosition( buf1 );
+		pos.z = - pos.z;
+		mtx.setPosition( pos );
+
+		return mtx;
+
+	};
+
+}();
+
+THREE.SEA3D.prototype.flipMatrixScale = function( local, global, parent, parentGlobal ) {
+
+	var pos = new THREE.Vector3();
+	var qua = new THREE.Quaternion();
+	var slc = new THREE.Vector3();
+
+	return function( local, global, parent, parentGlobal ) {
+
+		if ( parent ) local.multiplyMatrices( parent, local );
+
+		local.decompose( pos, qua, slc );
+
+		slc.z = - slc.z;
+
+		if ( global ) {
+
+			slc.y = - slc.y;
+			slc.x = - slc.x;
+
+		}
+
+		local.compose( pos, qua, slc );
+
+		if ( parent ) {
+
+			parent = parent.clone();
+
+			this.flipMatrixScale( parent, parentGlobal );
+
+			local.multiplyMatrices( parent.getInverse( parent ), local );
+
+		}
+
+		return local;
+
+	};
+
+}();
+
+//
+//	Legacy
+//
+
+THREE.SEA3D.prototype.updateAnimationSet = function( obj3d ) {
+
+	var buf1 = new THREE.Matrix4();
+	var buf2 = new THREE.Matrix4();
+
+	var pos = new THREE.Vector3();
+	var qua = new THREE.Quaternion();
+	var slc = new THREE.Vector3();
+
+	var to_pos = new THREE.Vector3();
+	var to_qua = new THREE.Quaternion();
+	var to_slc = new THREE.Vector3();
+
+	return function( obj3d ) {
+
+		var anmSet = obj3d.animation.animationSet;
+		var relative = obj3d.animation.relative;
+		var anms = anmSet.animations;
+
+		if ( anmSet.flip && ! anms.length )
+			return;
+
+		var dataList = anms[ 0 ].dataList,
+			t_anm = [];
+
+		for ( var i = 0; i < dataList.length; i ++ ) {
+
+			var data = dataList[ i ];
+			var raw = dataList[ i ].data;
+			var kind = data.kind;
+			var numFrames = raw.length / data.blockLength;
+
+			switch ( kind ) {
+				case SEA3D.Animation.POSITION:
+				case SEA3D.Animation.ROTATION:
+				case SEA3D.Animation.SCALE:
+					t_anm.push( {
+						kind : kind,
+						numFrames : numFrames,
+						raw : raw
+					} );
+					break;
+			}
+
+		}
+
+		if ( t_anm.length > 0 ) {
+
+			var numFrames = t_anm[ 0 ].numFrames,
+				parent = undefined;
+
+			if ( obj3d.animation.relative ) {
+
+				buf1.identity();
+				parent = this.flipMatrixScale( buf2.copy( obj3d.matrixWorld ) );
+
+			}
+			else {
+
+				if ( obj3d.parent ) {
+
+					parent = this.flipMatrixScale( buf2.copy( obj3d.parent.matrixWorld ) );
+
+				}
+
+				this.flipMatrixScale( buf1.copy( obj3d.matrix ), false, parent );
+
+			}
+
+			buf1.decompose( pos, qua, slc );
+
+			for ( var f = 0, t, c; f < numFrames; f ++ ) {
+
+				for ( t = 0; t < t_anm.length; t ++ ) {
+
+					var raw = t_anm[ t ].raw,
+						kind = t_anm[ t ].kind;
+
+					switch ( kind ) {
+						case SEA3D.Animation.POSITION:
+
+							c = f * 3;
+
+							pos.set(
+								raw[ c ],
+								raw[ c + 1 ],
+								raw[ c + 2 ]
+							);
+
+							break;
+
+						case SEA3D.Animation.ROTATION:
+
+							c = f * 4;
+
+							qua.set(
+								raw[ c ],
+								raw[ c + 1 ],
+								raw[ c + 2 ],
+								raw[ c + 3 ]
+							);
+
+							break;
+
+						case SEA3D.Animation.SCALE:
+
+							c = f * 4;
+
+							slc.set(
+								raw[ c ],
+								raw[ c + 1 ],
+								raw[ c + 2 ]
+							);
+
+							break;
+
+					}
+
+				}
+
+				buf1.compose( pos, qua, slc );
+
+				this.flipMatrixScale( buf1, false, buf2 );
+
+				buf1.decompose( to_pos, to_qua, to_slc );
+
+				for ( t = 0; t < t_anm.length; t ++ ) {
+
+					var raw = t_anm[ t ].raw,
+						kind = t_anm[ t ].kind;
+
+					switch ( kind ) {
+						case SEA3D.Animation.POSITION:
+
+							c = f * 3;
+
+							raw[ c ] = to_pos.x;
+							raw[ c + 1 ] = to_pos.y;
+							raw[ c + 2 ] = to_pos.z;
+
+							break;
+
+						case SEA3D.Animation.ROTATION:
+
+							c = f * 4;
+
+							raw[ c ] = to_qua.x;
+							raw[ c + 1 ] = to_qua.y;
+							raw[ c + 2 ] = to_qua.z;
+							raw[ c + 3 ] = to_qua.w;
+
+							break;
+
+						case SEA3D.Animation.SCALE:
+
+							c = f * 3;
+
+							raw[ c ] = to_slc.x;
+							raw[ c + 1 ] = to_slc.y;
+							raw[ c + 2 ] = to_slc.z;
+
+							break;
+					}
+
+				}
+
+			}
+
+		}
+
+		anmSet.flip = true;
+
+	};
+
+}();
+
+
+THREE.SEA3D.prototype.applyDefaultAnimation = function( sea, animatorClass ) {
+
+	this._applyDefaultAnimation( sea, animatorClass );
+
+	if ( this.isLegacy( sea ) && sea.tag.animation ) {
+
+		this.updateAnimationSet( sea.tag );
+
+	}
+
+};
+
+THREE.SEA3D.prototype.updateTransform = function( obj3d, sea ) {
+
+	var buf1 = new THREE.Matrix4();
+	var identity = new THREE.Matrix4();
+
+	return function( obj3d, sea ) {
+
+		if ( this.isLegacy( sea ) ) {
+
+			if ( sea.transform ) buf1.elements.set( sea.transform );
+			else buf1.makeTranslation( sea.position.x, sea.position.y, sea.position.z );
+
+			this.flipMatrixScale(
+				buf1, false,
+				obj3d.parent ? obj3d.parent.matrixWorld : identity,
+				obj3d.parent instanceof THREE.Bone
+			);
+
+			obj3d.position.setFromMatrixPosition( buf1 );
+			obj3d.scale.setFromMatrixScale( buf1 );
+
+			// ignore rotation scale
+
+			buf1.scale( THREE.SEA3D.VECBUF.set( 1 / obj3d.scale.x, 1 / obj3d.scale.y, 1 / obj3d.scale.z ) );
+			obj3d.rotation.setFromRotationMatrix( buf1 );
+
+			obj3d.updateMatrixWorld();
+
+		}
+		else {
+
+			this._updateTransform( obj3d, sea );
+
+		}
+
+	};
+
+}();
+
+THREE.SEA3D.prototype.readSkeleton = function( sea ) {
+
+	var mtx_tmp_inv = new THREE.Matrix4(),
+		mtx_local = new THREE.Matrix4(),
+		mtx_parent = new THREE.Matrix4(),
+		pos = new THREE.Vector3(),
+		qua = new THREE.Quaternion();
+
+	return function( sea ) {
+
+		var bones = [],
+			isLegacy = sea.sea3d.config.legacy;
+
+		for ( var i = 0; i < sea.joint.length; i ++ ) {
+
+			var bone = sea.joint[ i ]
+
+			// get world inverse matrix
+
+			mtx_tmp_inv.elements = bone.inverseBindMatrix;
+
+			// convert to world matrix
+
+			mtx_local.getInverse( mtx_tmp_inv );
+
+			// convert to three.js order
+
+			if ( isLegacy ) this.flipMatrixBone( mtx_local );
+
+			if ( bone.parentIndex > - 1 ) {
+
+				// to world
+
+				mtx_tmp_inv.elements = sea.joint[ bone.parentIndex ].inverseBindMatrix;
+				mtx_parent.getInverse( mtx_tmp_inv );
+
+				// convert parent to three.js order
+
+				if ( isLegacy ) this.flipMatrixBone( mtx_parent );
+
+				// to local
+
+				mtx_parent.getInverse( mtx_parent );
+
+				mtx_local.multiplyMatrices( mtx_parent, mtx_local );
+
+			}
+
+			// apply matrix
+
+			pos.setFromMatrixPosition( mtx_local );
+			qua.setFromRotationMatrix( mtx_local );
+
+			bones[ i ] = {
+				name: bone.name,
+				pos: [ pos.x, pos.y, pos.z ],
+				rotq: [ qua.x, qua.y, qua.z, qua.w ],
+				parent: bone.parentIndex
+			};
+
+		}
+
+		return sea.tag = bones;
+
+	};
+
+}();
+
+THREE.SEA3D.prototype.getSkeletonAnimation = function( sea, skl ) {
+
+	if ( this.isLegacy( sea ) ) return this.getSkeletonAnimationLegacy( sea, skl );
+	else return this._getSkeletonAnimation( sea, skl );
+
+};
+
+THREE.SEA3D.prototype.getSkeletonAnimationLegacy = function( sea, skl ) {
+
+	var mtx_tmp_inv = new THREE.Matrix4(),
+		mtx_local = new THREE.Matrix4(),
+		mtx_global = new THREE.Matrix4(),
+		mtx_parent = new THREE.Matrix4();
+
+	return function( sea, skl ) {
+
+		if ( sea.tag ) return sea.tag;
+
+		var animations = [],
+			delta = sea.frameRate / 1000,
+			scale = [ 1, 1, 1 ];
+
+		for ( var i = 0; i < sea.sequence.length; i ++ ) {
+
+			var seq = sea.sequence[ i ];
+
+			var start = seq.start;
+			var end = start + seq.count;
+			var ns = sea.name + "/" + seq.name;
+
+			var animation = {
+				name: ns,
+				repeat: seq.repeat,
+				fps: sea.frameRate,
+				JIT: 0,
+				length: delta * ( seq.count - 1 ),
+				hierarchy: []
+			};
+
+			var numJoints = sea.numJoints,
+				raw = sea.raw;
+
+			for ( var j = 0; j < numJoints; j ++ ) {
+
+				var bone = skl.joint[ j ],
+					node = { parent: bone.parentIndex, keys: [] },
+					keys = node.keys,
+					time = 0;
+
+				for ( var frame = start; frame < end; frame ++ ) {
+
+					var idx = ( frame * numJoints * 7 ) + ( j * 7 );
+
+					mtx_local.makeRotationFromQuaternion( THREE.SEA3D.QUABUF.set( raw[ idx + 3 ], raw[ idx + 4 ], raw[ idx + 5 ], raw[ idx + 6 ] ) );
+					mtx_local.setPosition( THREE.SEA3D.VECBUF.set( raw[ idx ], raw[ idx + 1 ], raw[ idx + 2 ] ) );
+
+					if ( bone.parentIndex > - 1 ) {
+
+						// to global
+
+						mtx_tmp_inv.elements = skl.joint[ bone.parentIndex ].inverseBindMatrix;
+
+						mtx_parent.getInverse( mtx_tmp_inv );
+
+						mtx_global.multiplyMatrices( mtx_parent, mtx_local );
+
+						// convert to three.js matrix
+
+						this.flipMatrixBone( mtx_global );
+
+						// flip parent inverse
+
+						this.flipMatrixBone( mtx_parent );
+
+						// to local
+
+						mtx_parent.getInverse( mtx_parent );
+
+						mtx_local.multiplyMatrices( mtx_parent, mtx_global );
+
+					}
+					else {
+
+						this.flipMatrixBone( mtx_local );
+
+					}
+
+					var posQ = THREE.SEA3D.VECBUF.setFromMatrixPosition( mtx_local );
+					var newQ = THREE.SEA3D.QUABUF.setFromRotationMatrix( mtx_local );
+
+					keys.push( {
+						time: time,
+						pos: [ posQ.x, posQ.y, posQ.z ],
+						rot: [ newQ.x, newQ.y, newQ.z, newQ.w ],
+						scl: scale
+					} );
+
+					time += delta;
+
+				}
+
+				animation.hierarchy[ j ] = node;
+
+			}
+
+			animations.push( animation );
+
+		}
+
+		return sea.tag = animations;
+
+	};
+
+}();
+
+THREE.SEA3D.prototype.readVertexAnimation = function( sea ) {
+
+	if ( this.isLegacy( sea ) ) {
+
+		for ( var i = 0, l = sea.frame.length; i < l; i ++ ) {
+
+			var frame = sea.frame[ i ];
+
+			this.flipZVec3( frame.vertex );
+			this.flipZVec3( frame.normal );
+
+		}
+
+	}
+
+	this._readVertexAnimation( sea );
+
+};
+
+THREE.SEA3D.prototype.readGeometryBuffer = function( sea ) {
+
+	if ( this.isLegacy( sea ) ) {
+
+		this.flipZVec3( sea.vertex );
+		this.flipZVec3( sea.normal );
+
+		this.flipZIndex( sea.indexes );
+
+		if ( sea.jointPerVertex > 4 ) this.compressJoints( sea );
+		else if ( sea.jointPerVertex < 4 ) this.expandJoints( sea );
+
+	}
+
+	this._readGeometryBuffer( sea );
+
+};
+
+THREE.SEA3D.prototype.readLines = function( sea ) {
+
+	if ( this.isLegacy( sea ) ) {
+
+		this.flipZVec3( sea.vertex );
+
+	}
+
+	this._readLines( sea );
+
+};
+
+THREE.SEA3D.prototype.onHead = function( args ) {
+
+	// TODO: Ignore sign
+
+};
+
+THREE.SEA3D.EXTENSIONS.push( function() {
+
+	// CONFIG
+
+	this.config.legacy = this.config.legacy == undefined ? true : this.config.legacy;
+
+	this.file.typeRead[ SEA3D.Skeleton.prototype.type ] = this.readSkeleton;
+
+} );

examples/js/loaders/sea3d/SEA3DLoader.js

@@ -22,6 +22,7 @@ THREE.SEA3D = function( config ) {
 	if ( this.config.timeLimit == undefined ) this.config.timeLimit = 10;
 	if ( this.config.streaming == undefined ) this.config.streaming = true;
 	if ( this.config.lights == undefined ) this.config.lights = true;
+	if ( this.config.useVertexTexture == undefined ) this.config.useVertexTexture = true;
 
 };
 
@@ -58,6 +59,10 @@ THREE.SEA3D.RTT_SIZE = 512;
 //	Shader
 //
 
+//
+//	Shader
+//
+
 THREE.SEA3D.ShaderLib = {};
 
 THREE.SEA3D.ShaderLib.replaceCode = function( src, target, replace ) {
@@ -92,7 +97,6 @@ THREE.SEA3D.ShaderLib.fragStdMtl = THREE.SEA3D.ShaderLib.replaceCode( THREE.Shad
 	'vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveLight * diffuse;'
 ] );
 
-
 //
 //	Standard Material
 //
@@ -106,32 +110,42 @@ THREE.SEA3D.StandardMaterial = function () {
 THREE.SEA3D.StandardMaterial.prototype = Object.create( THREE.MeshPhongMaterial.prototype );
 THREE.SEA3D.StandardMaterial.prototype.constructor = THREE.SEA3D.StandardMaterial;
 
-THREE.SEA3D.StandardMaterial.prototype.copy = function ( source ) {
-
-	THREE.MeshPhongMaterial.prototype.copy.call( this, source );
+THREE.SEA3D.StandardMaterial.prototype.lightMapUV = 1;
 
-	return this;
 
-};
+THREE.SEA3D.StandardMaterial.prototype.__defineSetter__( "__webglShader", function( val ) {
 
-THREE.SEA3D.StandardMaterial.prototype.clone = function() {
+	val.fragmentShader = THREE.SEA3D.ShaderLib.fragStdMtl;
 
-	return new THREE.SEA3D.StandardMaterial().copy( this );
+	if ( this.lightMapUV == 0 ) {
 
-};
+		val.fragmentShader = THREE.SEA3D.ShaderLib.replaceCode( val.fragmentShader, "texture2D( aoMap, vUv2 )", "texture2D( aoMap, vUv )" );
 
-THREE.SEA3D.StandardMaterial.prototype.__defineSetter__( "__webglShader", function( val ) {
+	}
 
-	val.fragmentShader = THREE.SEA3D.ShaderLib.fragStdMtl;
 	this.__webglShader__ = val;
 
-} )
+} );
 
 THREE.SEA3D.StandardMaterial.prototype.__defineGetter__( "__webglShader", function() {
 
 	return this.__webglShader__;
 
-} )
+} );
+
+THREE.SEA3D.StandardMaterial.prototype.copy = function ( source ) {
+
+	THREE.MeshPhongMaterial.prototype.copy.call( this, source );
+
+	return this;
+
+};
+
+THREE.SEA3D.StandardMaterial.prototype.clone = function() {
+
+	return new this.constructor().copy( this );
+
+};
 
 //
 //	Container
@@ -248,7 +262,7 @@ THREE.SEA3D.Dummy.MATERIAL = new THREE.MeshBasicMaterial( { wireframe: true, col
 
 THREE.SEA3D.Dummy.prototype.clone = function ( object ) {
 
-	return new THREE.SEA3D.Dummy( this.width, this.height, this.depth ).copy( this );
+	return new this.constructor( this.width, this.height, this.depth ).copy( this );
 
 };
 
@@ -299,7 +313,7 @@ THREE.SEA3D.Mesh.prototype.copy = function ( source ) {
 
 THREE.SEA3D.Mesh.prototype.clone = function ( object ) {
 
-	return new THREE.SEA3D.Mesh( this.geometry, this.material ).copy( this );
+	return new this.constructor( this.geometry, this.material ).copy( this );
 
 };
 
@@ -362,36 +376,28 @@ THREE.SEA3D.SkinnedMesh.prototype.resume = function() {
 
 THREE.SEA3D.SkinnedMesh.prototype.play = function( name, crossfade, offset ) {
 
-	this.previousAnimation = this.currentAnimation;
-	this.currentAnimation = this.animations[ name ];
+	var animation = this.animations[ name ];
 
-	if ( ! this.currentAnimation )
+	if ( ! animation )
 		throw new Error( 'Animation "' + name + '" not found.' );
 
-	if ( this.previousAnimation && this.previousAnimation !== this.currentAnimation && crossfade > 0 ) {
-
-		this.previousAnimation.play( this.previousAnimation.currentTime, this.previousAnimation.weight );
-		this.currentAnimation.play( offset !== undefined ? offset : this.currentAnimation.currentTime, this.currentAnimation.weight );
-
-		THREE.SEA3D.AnimationHandler.addCrossfade( this, crossfade );
-
-	} else {
-
-		this.currentAnimation.play( offset !== undefined ? offset : this.currentAnimation.currentTime, 1 );
+	animation.play( offset !== undefined ? offset : animation.currentTime, animation.weight );
 
-	}
+	this.currentAnimation = animation;
 
 	this.isPlaying = true;
 
+	THREE.SEA3D.AnimationHandler.addCrossfade( this, crossfade !== undefined ? crossfade : 0 );
+
 };
 
 THREE.SEA3D.SkinnedMesh.prototype.setAnimations = function( animations ) {
 
-	this.animations = [];
-	this.weightSchedule = [];
-	this.warpSchedule = [];
-
 	var nsIndex = animations[ 0 ].name.indexOf( "/" ) + 1;
+
+	this.animations = [];
+	this.easeSpeed = 2;
+	this.blendMethod = SEA3D.AnimationBlendMethod.LINEAR;
 	this.animationNamespace = animations[ 0 ].name.substring( 0, nsIndex );
 
 	for ( var i = 0; i < animations.length; i ++ ) {
@@ -429,25 +435,9 @@ THREE.SEA3D.SkinnedMesh.prototype.copy = function ( source ) {
 	if ( this.animation )
 		this.animation = source.animation.clone( this );
 
-	this.animations = [];
-
-	if ( source.geometry.animations ) {
-
-		var refAnimations = source.geometry.animations;
-		var nsIndex = refAnimations[ 0 ].name.indexOf( "/" ) + 1;
-
-		for ( var i = 0; i < refAnimations.length; i ++ ) {
-
-			var name = refAnimations[ i ].name.substring( nsIndex );
-			var data = refAnimations[ i ];
-
-			data.initialized = false;
-
-			this.animations[ i ] = new THREE.SEA3D.Animation( this, data );
-			this.animations[ i ].loop = refAnimations[ i ].repeat;
-			this.animations[ i ].name = name;
+	if ( this.geometry.animations ) {
 
-		}
+		this.setAnimations( this.geometry.animations );
 
 	}
 
@@ -457,7 +447,7 @@ THREE.SEA3D.SkinnedMesh.prototype.copy = function ( source ) {
 
 THREE.SEA3D.SkinnedMesh.prototype.clone = function ( object ) {
 
-	return new THREE.SEA3D.SkinnedMesh( this.geometry, this.material, this.useVertexTexture ).copy( this );
+	return new this.constructor( this.geometry, this.material, this.useVertexTexture ).copy( this );
 
 };
 
@@ -533,7 +523,7 @@ THREE.SEA3D.VertexAnimationMesh.prototype.stop = function() {
 
 THREE.SEA3D.VertexAnimationMesh.prototype.clone = function ( object ) {
 
-	return new THREE.SEA3D.VertexAnimationMesh( this.geometry, this.material, this.fps ).copy( this );
+	return new this.constructor( this.geometry, this.material, this.fps ).copy( this );
 
 };
 
@@ -572,32 +562,64 @@ THREE.SEA3D.AnimationHandler = {
 
 	update : function( dt ) {
 
-		var i, cf = THREE.SEA3D.AnimationHandler.crossfade, ups = THREE.SEA3D.AnimationHandler.updates;
+		var i, j, cf = THREE.SEA3D.AnimationHandler.crossfade, ups = THREE.SEA3D.AnimationHandler.updates;
 
 		// crossfade
+
 		i = 0;
 		while ( i < cf.length ) {
 
-			var mesh = cf[ i ];
+			var mesh = cf[ i ],
+				len = mesh.animations.length,
+				weight = 1,
+				delta = Math.abs( dt ) / mesh.crossfade;
 
-			mesh.currentAnimation.weight += dt / mesh.crossfade;
+			if ( mesh.blendMethod === SEA3D.AnimationBlendMethod.EASING ) {
 
-			if ( mesh.currentAnimation.weight > 1 ) {
+				delta *= mesh.easeSpeed;
 
-				mesh.previousAnimation.weight = 0;
-				mesh.currentAnimation.weight = 1;
+			}
 
-				if ( mesh.onCrossfadeComplete ) mesh.onCrossfadeComplete( mesh );
+			while ( len ) {
+
+				var state = mesh.animations[ -- len ];
+
+				if ( state.weight > 0 && state != mesh.currentAnimation ) {
+
+					if ( mesh.blendMethod === SEA3D.AnimationBlendMethod.LINEAR ) {
+
+						state.weight -= delta;
+
+					}
+					else if ( mesh.blendMethod === SEA3D.AnimationBlendMethod.EASING ) {
+
+						state.weight -= state.weight * delta;
+
+					}
+
+					if ( state.weight < 0 ) state.weight = 0;
+
+					weight -= state.weight;
+
+				}
+
+			}
+
+			if ( weight < 0 ) weight = 0;
+
+			mesh.currentAnimation.weight = weight;
+
+			if ( weight == 1 ) {
 
 				cf.splice( i, 1 );
 
 				delete mesh.crossfade;
 
+				if ( mesh.onCrossfadeComplete ) mesh.onCrossfadeComplete( mesh );
+
 			}
 			else ++ i;
 
-			mesh.previousAnimation.weight = 1 - mesh.currentAnimation.weight;
-
 		}
 
 		// updates
@@ -614,15 +636,40 @@ THREE.SEA3D.AnimationHandler = {
 
 	addCrossfade : function( mesh, crossfade ) {
 
-		if ( mesh.crossfade !== undefined ) {
+		var fadelist = THREE.SEA3D.AnimationHandler.crossfade;
+
+		if ( crossfade > 0 )
+		{
+
+			if ( ! mesh.crossfade ) fadelist.push( mesh );
 
-			THREE.SEA3D.AnimationHandler.crossfade.splice( THREE.SEA3D.AnimationHandler.crossfade.indexOf( mesh ), 1 );
+			mesh.crossfade = crossfade;
 
 		}
+		else
+		{
+
+			var len = mesh.animations.length;
+
+			while ( len ) {
+
+				mesh.animations[ -- len ].weight = 0;
+
+			}
+
+			if ( mesh.crossfade ) {
+
+				fadelist.splice( fadelist.indexOf( mesh ), 1 );
+
+				delete mesh.crossfade;
+
+				if ( mesh.onCrossfadeComplete ) mesh.onCrossfadeComplete( mesh );
+
+			}
 
-		mesh.crossfade = crossfade;
+			mesh.currentAnimation.weight = 1;
 
-		THREE.SEA3D.AnimationHandler.crossfade.push( mesh );
+		}
 
 	},
 
@@ -638,7 +685,7 @@ THREE.SEA3D.AnimationHandler = {
 
 		if ( index !== - 1 ) {
 
-			THREE.SEA3D.AnimationHandler.crossfade.splice( THREE.SEA3D.AnimationHandler.updates.indexOf( func ), 1 );
+			THREE.SEA3D.AnimationHandler.updates.splice( THREE.SEA3D.AnimationHandler.updates.indexOf( func ), 1 );
 
 		}
 
@@ -681,6 +728,7 @@ THREE.SEA3D.Animation.prototype.reset = function() {
 
 THREE.SEA3D.MTXBUF = new THREE.Matrix4();
 THREE.SEA3D.VECBUF = new THREE.Vector3();
+THREE.SEA3D.QUABUF = new THREE.Quaternion();
 
 THREE.SEA3D.prototype.setShadowMap = function( light, opacity ) {
 
@@ -688,7 +736,7 @@ THREE.SEA3D.prototype.setShadowMap = function( light, opacity ) {
 	light.shadowMapHeight = 2048;
 
 	light.castShadow = true;
-	light.shadowDarkness = opacity !== undefined ? opacity : 1;
+	light.shadowDarkness = opacity == undefined ? 1 : opacity;
 
 };
 
@@ -871,6 +919,8 @@ THREE.SEA3D.prototype.addSceneObject = function( sea ) {
 	else if ( this.config.container )
 		this.config.container.add( obj3d );
 
+	obj3d.visible = sea.visible;
+
 };
 
 THREE.SEA3D.prototype.createObjectURL = function( raw, mime ) {
@@ -1104,6 +1154,7 @@ THREE.SEA3D.prototype.readGeometryBuffer = function( sea ) {
 	for ( var i = 0; i < sea.groups.length; i ++ ) {
 
 		var g = sea.groups[ i ];
+
 		geo.addGroup( g.start, g.count, i );
 
 	}
@@ -1127,8 +1178,8 @@ THREE.SEA3D.prototype.readGeometryBuffer = function( sea ) {
 
 	if ( sea.joint ) {
 
-		geo.addAttribute( 'skinIndex', new THREE.Float32Attribute( sea.joint, 4 ) );
-		geo.addAttribute( 'skinWeight', new THREE.Float32Attribute( sea.weight, 4 ) );
+		geo.addAttribute( 'skinIndex', new THREE.Float32Attribute( sea.joint, sea.jointPerVertex ) );
+		geo.addAttribute( 'skinWeight', new THREE.Float32Attribute( sea.weight, sea.jointPerVertex ) );
 
 	}
 
@@ -1262,6 +1313,7 @@ THREE.SEA3D.prototype.readMesh = function( sea ) {
 		var mod = sea.modifiers[ i ];
 
 		switch ( mod.type ) {
+			case SEA3D.Skeleton.prototype.type:
 			case SEA3D.SkeletonLocal.prototype.type:
 				skeleton = mod;
 
@@ -1339,7 +1391,7 @@ THREE.SEA3D.prototype.readMesh = function( sea ) {
 
 	if ( skeleton ) {
 
-		mesh = new THREE.SEA3D.SkinnedMesh( geo, mat, false );
+		mesh = new THREE.SEA3D.SkinnedMesh( geo, mat, this.config.useVertexTexture );
 
 		if ( skeletonAnimation ) {
 
@@ -1448,39 +1500,14 @@ THREE.SEA3D.prototype.readCubeRender = function( sea ) {
 
 THREE.SEA3D.prototype.readImage = function( sea ) {
 
-	var image = new Image(), texture = new THREE.Texture(), scope = this;
-
+	var image = new Image(), texture = new THREE.Texture();
+	image.src = this.bufferToTexture( sea.data.buffer );
+	
 	texture.name = sea.name;
 	texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
 	texture.flipY = false;
-
-	image.onload = function () {
-
-		if ( ! scope.isPowerOfTwo( image.width ) ||
-			! scope.isPowerOfTwo( image.height ) ) {
-
-			var width = scope.nearestPowerOfTwo( image.width ),
-				height = scope.nearestPowerOfTwo( image.height );
-
-			var canvas = document.createElement( "canvas" );
-
-			canvas.width = width;
-			canvas.height = height;
-
-			var ctx = canvas.getContext( "2d" );
-
-			ctx.drawImage( image, 0, 0, width, height );
-
-			image = canvas;
-
-		}
-
-		texture.image = image;
-		texture.needsUpdate = true;
-
-	}
-
-	image.src = this.bufferToTexture( sea.data.buffer );
+	texture.image = image;
+	texture.needsUpdate = true;
 
 	this.domain.textures = this.textures = this.textures || [];
 	this.textures.push( this.objects[ "tex/" + sea.name ] = sea.tag = texture );
@@ -1573,6 +1600,15 @@ THREE.SEA3D.prototype.readTextureURL = function( sea ) {
 
 THREE.SEA3D.SCRIPT = new SEA3D.ScriptManager();
 
+THREE.SEA3D.SCRIPT.dispatchUpdate = function( delta ) {
+
+	this.dispatchEvent( {
+		type : "update",
+		delta : delta
+	} );
+
+};
+
 THREE.SEA3D.Domain = function( id, objects, container, extensions ) {
 
 	SEA3D.Domain.call( this, id );
@@ -1884,6 +1920,8 @@ THREE.SEA3D.prototype.materialTechnique =
 		if ( tech.blendMode == "multiply" ) mat.aoMap = tech.texture.tag;
 		else mat.lightMap = tech.texture.tag;
 
+		mat.lightMapUV = tech.channel;
+
 	}
 
 	return techniques;
@@ -2026,7 +2064,7 @@ THREE.SEA3D.prototype.readCamera = function( sea ) {
 	var camera = new THREE.SEA3D.Camera( sea.fov );
 	camera.name = sea.name;
 
-	this.domain.cameras = this.cameras = this.camera || [];
+	this.domain.cameras = this.cameras = this.cameras || [];
 	this.cameras.push( this.objects[ "cam/" + sea.name ] = sea.tag = camera );
 
 	this.addSceneObject( sea );
@@ -2084,8 +2122,7 @@ THREE.SEA3D.prototype.getSkeletonAnimation = function( sea, skl ) {
 	if ( sea.tag ) return sea.tag;
 
 	var animations = [],
-		delta = sea.frameRate / 1000,
-		scale = [ 1, 1, 1 ];
+		delta = ( 1000 / sea.frameRate ) / 1000;
 
 	for ( var i = 0; i < sea.sequence.length; i ++ ) {
 
@@ -2122,7 +2159,7 @@ THREE.SEA3D.prototype.getSkeletonAnimation = function( sea, skl ) {
 					time: time,
 					pos: [ raw[ idx ], raw[ idx + 1 ], raw[ idx + 2 ] ],
 					rot: [ raw[ idx + 3 ], raw[ idx + 4 ], raw[ idx + 5 ], raw[ idx + 6 ] ],
-					scl: scale
+					scl: [ 1, 1, 1 ]
 				} );
 
 				time += delta;
@@ -2388,7 +2425,7 @@ THREE.SEA3D.prototype.onHead = function( args ) {
 
 	if ( args.sign != 'TJS' ) {
 
-		throw "Sign '" + args.sign + "' not supported! Use SEA3D Studio to export.";
+		throw new Error( "Sign '" + args.sign + "' not supported! Use SEA3D Studio to publish or SEA3DLegacy.js" );
 
 	}
 
@@ -2402,6 +2439,7 @@ THREE.SEA3D.prototype.loadBytes = function( data ) {
 
 	this.file = new SEA3D.File();
 	this.file.scope = this;
+	this.file.config = this.config;
 	this.file.streaming = this.config.streaming;
 	this.file.timeLimit = this.config.timeLimit;
 	this.file.onProgress = this.onLoadProgress;

src/Three.Legacy.js

@@ -727,3 +727,7 @@ THREE.TextGeometry = function () {
 	console.error( 'THREE.FontUtils has been moved to /examples/js/utils/FontUtils.js' );
 
 };
+
+//
+
+THREE.MeshFaceMaterial = THREE.MultiMaterial;

src/materials/MultiMaterial.js

@@ -65,7 +65,3 @@ THREE.MultiMaterial.prototype = {
 	}
 
 };
-
-// backwards compatibility
-
-THREE.MeshFaceMaterial = THREE.MultiMaterial;

src/renderers/WebGLRenderer.js

@@ -1314,7 +1314,7 @@ THREE.WebGLRenderer = function ( parameters ) {
 
 						var geometry = objects.update( object );
 
-						if ( material instanceof THREE.MeshFaceMaterial ) {
+						if ( material instanceof THREE.MultiMaterial ) {
 
 							var groups = geometry.groups;
 							var materials = material.materials;