3169 lines
56 KiB
JavaScript
3169 lines
56 KiB
JavaScript
/**
|
|
* SEA3D SDK
|
|
* @author Sunag / http://www.sunag.com.br/
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var SEA3D = { VERSION: 18100 };
|
|
|
|
SEA3D.getVersion = function () {
|
|
|
|
// Max = 16777215 - VV.S.S.BB | V = Version | S = Subversion | B = Buildversion
|
|
var v = SEA3D.VERSION.toString(), l = v.length;
|
|
return v.substring( 0, l - 4 ) + "." + v.substring( l - 4, l - 3 ) + "." + v.substring( l - 3, l - 2 ) + "." + parseFloat( v.substring( l - 2, l ) ).toString();
|
|
|
|
};
|
|
|
|
console.log( 'SEA3D ' + SEA3D.getVersion() );
|
|
|
|
//
|
|
// STREAM : STANDARD DATA-IO ( LITTLE-ENDIAN )
|
|
//
|
|
|
|
SEA3D.Stream = function ( buffer ) {
|
|
|
|
this.position = 0;
|
|
this.buffer = buffer || new ArrayBuffer();
|
|
|
|
};
|
|
|
|
SEA3D.Stream.NONE = 0;
|
|
|
|
// 1D = 0 at 31
|
|
SEA3D.Stream.BOOLEAN = 1;
|
|
|
|
SEA3D.Stream.BYTE = 2;
|
|
SEA3D.Stream.UBYTE = 3;
|
|
|
|
SEA3D.Stream.SHORT = 4;
|
|
SEA3D.Stream.USHORT = 5;
|
|
|
|
SEA3D.Stream.INT24 = 6;
|
|
SEA3D.Stream.UINT24 = 7;
|
|
|
|
SEA3D.Stream.INT = 8;
|
|
SEA3D.Stream.UINT = 9;
|
|
|
|
SEA3D.Stream.FLOAT = 10;
|
|
SEA3D.Stream.DOUBLE = 11;
|
|
SEA3D.Stream.DECIMAL = 12;
|
|
|
|
// 2D = 32 at 63
|
|
|
|
// 3D = 64 at 95
|
|
SEA3D.Stream.VECTOR3D = 74;
|
|
|
|
// 4D = 96 at 127
|
|
SEA3D.Stream.VECTOR4D = 106;
|
|
|
|
// Undefined Size = 128 at 255
|
|
SEA3D.Stream.STRING_TINY = 128;
|
|
SEA3D.Stream.STRING_SHORT = 129;
|
|
SEA3D.Stream.STRING_LONG = 130;
|
|
|
|
SEA3D.Stream.ASSET = 200;
|
|
SEA3D.Stream.GROUP = 255;
|
|
|
|
SEA3D.Stream.BLEND_MODE = [
|
|
"normal", "add", "subtract", "multiply", "dividing", "mix", "alpha", "screen", "darken",
|
|
"overlay", "colorburn", "linearburn", "lighten", "colordodge", "lineardodge",
|
|
"softlight", "hardlight", "pinlight", "spotlight", "spotlightblend", "hardmix",
|
|
"average", "difference", "exclusion", "hue", "saturation", "color", "value",
|
|
"linearlight", "grainextract", "reflect", "glow", "darkercolor", "lightercolor", "phoenix", "negation"
|
|
];
|
|
|
|
SEA3D.Stream.INTERPOLATION_TABLE = [
|
|
"normal", "linear",
|
|
"sine.in", "sine.out", "sine.inout",
|
|
"cubic.in", "cubic.out", "cubic.inout",
|
|
"quint.in", "quint.out", "quint.inout",
|
|
"circ.in", "circ.out", "circ.inout",
|
|
"back.in", "back.out", "back.inout",
|
|
"quad.in", "quad.out", "quad.inout",
|
|
"quart.in", "quart.out", "quart.inout",
|
|
"expo.in", "expo.out", "expo.inout",
|
|
"elastic.in", "elastic.out", "elastic.inout",
|
|
"bounce.in", "bounce.out", "bounce.inout"
|
|
];
|
|
|
|
SEA3D.Stream.sizeOf = function ( kind ) {
|
|
|
|
if ( kind == 0 ) return 0;
|
|
else if ( kind >= 1 && kind <= 31 ) return 1;
|
|
else if ( kind >= 32 && kind <= 63 ) return 2;
|
|
else if ( kind >= 64 && kind <= 95 ) return 3;
|
|
else if ( kind >= 96 && kind <= 125 ) return 4;
|
|
return - 1;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype = {
|
|
|
|
constructor: SEA3D.Stream,
|
|
|
|
set buffer( val ) {
|
|
|
|
this.buf = val;
|
|
this.length = val.byteLength;
|
|
this.data = new DataView( val );
|
|
|
|
},
|
|
|
|
get buffer() {
|
|
|
|
return this.buf;
|
|
|
|
},
|
|
|
|
get bytesAvailable() {
|
|
|
|
return this.length - this.position;
|
|
|
|
}
|
|
};
|
|
|
|
SEA3D.Stream.prototype.getByte = function ( pos ) {
|
|
|
|
return this.data.getInt8( pos );
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readBytes = function ( len ) {
|
|
|
|
var buf = this.buf.slice( this.position, this.position + len );
|
|
this.position += len;
|
|
return buf;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readByte = function () {
|
|
|
|
return this.data.getInt8( this.position ++ );
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readUByte = function () {
|
|
|
|
return this.data.getUint8( this.position ++ );
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readBool = function () {
|
|
|
|
return this.data.getInt8( this.position ++ ) != 0;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readShort = function () {
|
|
|
|
var v = this.data.getInt16( this.position, true );
|
|
this.position += 2;
|
|
return v;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readUShort = function () {
|
|
|
|
var v = this.data.getUint16( this.position, true );
|
|
this.position += 2;
|
|
return v;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readUInt24 = function () {
|
|
|
|
var v = this.data.getUint32( this.position, true ) & 0xFFFFFF;
|
|
this.position += 3;
|
|
return v;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readUInt24F = function () {
|
|
|
|
return this.readUShort() | ( this.readUByte() << 16 );
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readInt = function () {
|
|
|
|
var v = this.data.getInt32( this.position, true );
|
|
this.position += 4;
|
|
return v;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readUInt = function () {
|
|
|
|
var v = this.data.getUint32( this.position, true );
|
|
this.position += 4;
|
|
return v;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readFloat = function () {
|
|
|
|
var v = this.data.getFloat32( this.position, true );
|
|
this.position += 4;
|
|
return v;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readUInteger = function () {
|
|
|
|
var v = this.readUByte(),
|
|
r = v & 0x7F;
|
|
|
|
if ( ( v & 0x80 ) != 0 ) {
|
|
|
|
v = this.readUByte();
|
|
r |= ( v & 0x7F ) << 7;
|
|
|
|
if ( ( v & 0x80 ) != 0 ) {
|
|
|
|
v = this.readUByte();
|
|
r |= ( v & 0x7F ) << 13;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return r;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readVector2 = function () {
|
|
|
|
return { x: this.readFloat(), y: this.readFloat() };
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readVector3 = function () {
|
|
|
|
return { x: this.readFloat(), y: this.readFloat(), z: this.readFloat() };
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readVector4 = function () {
|
|
|
|
return { x: this.readFloat(), y: this.readFloat(), z: this.readFloat(), w: this.readFloat() };
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readMatrix = function () {
|
|
|
|
var mtx = new Float32Array( 16 );
|
|
|
|
mtx[ 0 ] = this.readFloat();
|
|
mtx[ 1 ] = this.readFloat();
|
|
mtx[ 2 ] = this.readFloat();
|
|
mtx[ 3 ] = 0.0;
|
|
mtx[ 4 ] = this.readFloat();
|
|
mtx[ 5 ] = this.readFloat();
|
|
mtx[ 6 ] = this.readFloat();
|
|
mtx[ 7 ] = 0.0;
|
|
mtx[ 8 ] = this.readFloat();
|
|
mtx[ 9 ] = this.readFloat();
|
|
mtx[ 10 ] = this.readFloat();
|
|
mtx[ 11 ] = 0.0;
|
|
mtx[ 12 ] = this.readFloat();
|
|
mtx[ 13 ] = this.readFloat();
|
|
mtx[ 14 ] = this.readFloat();
|
|
mtx[ 15 ] = 1.0;
|
|
|
|
return mtx;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readUTF8 = function ( len ) {
|
|
|
|
var buffer = this.readBytes( len );
|
|
|
|
if ( window.TextDecoder ) {
|
|
|
|
return new TextDecoder().decode( buffer );
|
|
|
|
} else {
|
|
|
|
return decodeURIComponent( escape( String.fromCharCode.apply( null, new Uint8Array( buffer ) ) ) );
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readExt = function () {
|
|
|
|
return this.readUTF8( 4 ).replace( /\0/g, "" );
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readUTF8Tiny = function () {
|
|
|
|
return this.readUTF8( this.readUByte() );
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readUTF8Short = function () {
|
|
|
|
return this.readUTF8( this.readUShort() );
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readUTF8Long = function () {
|
|
|
|
return this.readUTF8( this.readUInt() );
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readUByteArray = function ( length ) {
|
|
|
|
var v = new Uint8Array( length );
|
|
|
|
SEA3D.Stream.memcpy(
|
|
v.buffer,
|
|
0,
|
|
this.buffer,
|
|
this.position,
|
|
length
|
|
);
|
|
|
|
this.position += length;
|
|
|
|
return v;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readUShortArray = function ( length ) {
|
|
|
|
var v = new Uint16Array( length ),
|
|
len = length * 2;
|
|
|
|
SEA3D.Stream.memcpy(
|
|
v.buffer,
|
|
0,
|
|
this.buffer,
|
|
this.position,
|
|
len
|
|
);
|
|
|
|
this.position += len;
|
|
|
|
return v;
|
|
|
|
};
|
|
|
|
|
|
SEA3D.Stream.prototype.readUInt24Array = function ( length ) {
|
|
|
|
var v = new Uint32Array( length );
|
|
|
|
for ( var i = 0; i < length; i ++ ) {
|
|
|
|
v[ i ] = this.readUInt24();
|
|
|
|
}
|
|
|
|
return v;
|
|
|
|
};
|
|
|
|
|
|
SEA3D.Stream.prototype.readUIntArray = function ( length ) {
|
|
|
|
var v = new Uint32Array( length ),
|
|
len = length * 4;
|
|
|
|
SEA3D.Stream.memcpy(
|
|
v.buffer,
|
|
0,
|
|
this.buffer,
|
|
this.position,
|
|
len
|
|
);
|
|
|
|
this.position += len;
|
|
|
|
return v;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readFloatArray = function ( length ) {
|
|
|
|
var v = new Float32Array( length ),
|
|
len = length * 4;
|
|
|
|
SEA3D.Stream.memcpy(
|
|
v.buffer,
|
|
0,
|
|
this.buffer,
|
|
this.position,
|
|
len
|
|
);
|
|
|
|
this.position += len;
|
|
|
|
return v;
|
|
|
|
};
|
|
|
|
|
|
SEA3D.Stream.prototype.readBlendMode = function () {
|
|
|
|
return SEA3D.Stream.BLEND_MODE[ this.readUByte() ];
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readInterpolation = function () {
|
|
|
|
return SEA3D.Stream.INTERPOLATION_TABLE[ this.readUByte() ];
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readTags = function ( callback ) {
|
|
|
|
var numTag = this.readUByte();
|
|
|
|
for ( var i = 0; i < numTag; ++ i ) {
|
|
|
|
var kind = this.readUShort();
|
|
var size = this.readUInt();
|
|
var pos = this.position;
|
|
|
|
callback( kind, this, size );
|
|
|
|
this.position = pos += size;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readProperties = function ( sea3d ) {
|
|
|
|
var count = this.readUByte(),
|
|
props = {}, types = {};
|
|
|
|
props.__type = types;
|
|
|
|
for ( var i = 0; i < count; i ++ ) {
|
|
|
|
var name = this.readUTF8Tiny(),
|
|
type = this.readUByte();
|
|
|
|
types[ name ] = type;
|
|
props[ name ] = type == SEA3D.Stream.GROUP ? this.readProperties( sea3d ) : this.readToken( type, sea3d );
|
|
|
|
}
|
|
|
|
return props;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readAnimationList = function ( sea3d ) {
|
|
|
|
var list = [],
|
|
count = this.readUByte();
|
|
|
|
var i = 0;
|
|
while ( i < count ) {
|
|
|
|
var attrib = this.readUByte(),
|
|
anm = {};
|
|
|
|
anm.relative = ( attrib & 1 ) != 0;
|
|
|
|
if ( attrib & 2 ) anm.timeScale = this.readFloat();
|
|
|
|
anm.tag = sea3d.getObject( this.readUInt() );
|
|
|
|
list[ i ++ ] = anm;
|
|
|
|
}
|
|
|
|
return list;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readScriptList = function ( sea3d ) {
|
|
|
|
var list = [],
|
|
count = this.readUByte();
|
|
|
|
var i = 0;
|
|
while ( i < count ) {
|
|
|
|
var attrib = this.readUByte(),
|
|
script = {};
|
|
|
|
script.priority = ( attrib & 1 ) | ( attrib & 2 );
|
|
|
|
if ( attrib & 4 ) {
|
|
|
|
var numParams = this.readUByte();
|
|
|
|
script.params = {};
|
|
|
|
for ( var j = 0; j < numParams; j ++ ) {
|
|
|
|
var name = this.readUTF8Tiny();
|
|
|
|
script.params[ name ] = this.readObject( sea3d );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ( attrib & 8 ) {
|
|
|
|
script.method = this.readUTF8Tiny();
|
|
|
|
}
|
|
|
|
script.tag = sea3d.getObject( this.readUInt() );
|
|
|
|
list[ i ++ ] = script;
|
|
|
|
}
|
|
|
|
return list;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readObject = function ( sea3d ) {
|
|
|
|
return this.readToken( this.readUByte(), sea3d );
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readToken = function ( type, sea3d ) {
|
|
|
|
switch ( type ) {
|
|
|
|
// 1D
|
|
case SEA3D.Stream.BOOLEAN:
|
|
return this.readBool();
|
|
break;
|
|
|
|
case SEA3D.Stream.UBYTE:
|
|
return this.readUByte();
|
|
break;
|
|
|
|
case SEA3D.Stream.USHORT:
|
|
return this.readUShort();
|
|
break;
|
|
|
|
case SEA3D.Stream.UINT24:
|
|
return this.readUInt24();
|
|
break;
|
|
|
|
case SEA3D.Stream.INT:
|
|
return this.readInt();
|
|
break;
|
|
|
|
case SEA3D.Stream.UINT:
|
|
return this.readUInt();
|
|
break;
|
|
|
|
case SEA3D.Stream.FLOAT:
|
|
return this.readFloat();
|
|
break;
|
|
|
|
// 3D
|
|
case SEA3D.Stream.VECTOR3D:
|
|
return this.readVector3();
|
|
break;
|
|
|
|
// 4D
|
|
case SEA3D.Stream.VECTOR4D:
|
|
return this.readVector4();
|
|
break;
|
|
|
|
// Undefined Values
|
|
case SEA3D.Stream.STRING_TINY:
|
|
return this.readUTF8Tiny();
|
|
break;
|
|
|
|
case SEA3D.Stream.STRING_SHORT:
|
|
return this.readUTF8Short();
|
|
break;
|
|
|
|
case SEA3D.Stream.STRING_LONG:
|
|
return this.readUTF8Long();
|
|
break;
|
|
|
|
case SEA3D.Stream.ASSET:
|
|
var asset = this.readUInt();
|
|
return asset > 0 ? sea3d.getObject( asset - 1 ).tag : null;
|
|
break;
|
|
|
|
default:
|
|
console.error( "DataType not found!" );
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.readVector = function ( type, length, offset ) {
|
|
|
|
var size = SEA3D.Stream.sizeOf( type ),
|
|
i = offset * size,
|
|
count = i + ( length * size );
|
|
|
|
switch ( type ) {
|
|
|
|
// 1D
|
|
case SEA3D.Stream.BOOLEAN:
|
|
|
|
return this.readUByteArray( count );
|
|
|
|
|
|
case SEA3D.Stream.UBYTE:
|
|
|
|
return this.readUByteArray( count );
|
|
|
|
|
|
case SEA3D.Stream.USHORT:
|
|
|
|
return this.readUShortArray( count );
|
|
|
|
|
|
case SEA3D.Stream.UINT24:
|
|
|
|
return this.readUInt24Array( count );
|
|
|
|
|
|
case SEA3D.Stream.UINT:
|
|
|
|
return this.readUIntArray( count );
|
|
|
|
|
|
case SEA3D.Stream.FLOAT:
|
|
|
|
return this.readFloatArray( count );
|
|
|
|
|
|
// 3D
|
|
case SEA3D.Stream.VECTOR3D:
|
|
|
|
return this.readFloatArray( count );
|
|
|
|
|
|
// 4D
|
|
case SEA3D.Stream.VECTOR4D:
|
|
|
|
return this.readFloatArray( count );
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.append = function ( data ) {
|
|
|
|
var tmp = new ArrayBuffer( this.data.byteLength + data.byteLength );
|
|
tmp.set( new ArrayBuffer( this.data ), 0 );
|
|
tmp.set( new ArrayBuffer( data ), this.data.byteLength );
|
|
this.data = tmp;
|
|
|
|
};
|
|
|
|
SEA3D.Stream.prototype.concat = function ( position, length ) {
|
|
|
|
return new SEA3D.Stream( this.buffer.slice( position, position + length ) );
|
|
|
|
};
|
|
|
|
/**
|
|
* @author DataStream.js
|
|
*/
|
|
|
|
SEA3D.Stream.memcpy = function ( dst, dstOffset, src, srcOffset, byteLength ) {
|
|
|
|
var dstU8 = new Uint8Array( dst, dstOffset, byteLength );
|
|
var srcU8 = new Uint8Array( src, srcOffset, byteLength );
|
|
|
|
dstU8.set( srcU8 );
|
|
|
|
};
|
|
|
|
//
|
|
// UByteArray
|
|
//
|
|
|
|
SEA3D.UByteArray = function () {
|
|
|
|
this.ubytes = [];
|
|
this.length = 0;
|
|
|
|
};
|
|
|
|
SEA3D.UByteArray.prototype = {
|
|
constructor: SEA3D.UByteArray,
|
|
|
|
add: function ( ubytes ) {
|
|
|
|
this.ubytes.push( ubytes );
|
|
this.length += ubytes.byteLength;
|
|
|
|
},
|
|
|
|
toBuffer: function () {
|
|
|
|
var memcpy = new Uint8Array( this.length );
|
|
|
|
for ( var i = 0, offset = 0; i < this.ubytes.length; i ++ ) {
|
|
|
|
memcpy.set( this.ubytes[ i ], offset );
|
|
offset += this.ubytes[ i ].byteLength;
|
|
|
|
}
|
|
|
|
return memcpy.buffer;
|
|
|
|
}
|
|
};
|
|
|
|
//
|
|
// Math
|
|
//
|
|
|
|
SEA3D.Math = {
|
|
DEGREES: 180 / Math.PI,
|
|
RADIANS: Math.PI / 180
|
|
};
|
|
|
|
SEA3D.Math.angle = function ( val ) {
|
|
|
|
var ang = 180,
|
|
inv = val < 0;
|
|
|
|
val = ( inv ? - val : val ) % 360;
|
|
|
|
if ( val > ang ) {
|
|
|
|
val = - ang + ( val - ang );
|
|
|
|
}
|
|
|
|
return ( inv ? - val : val );
|
|
|
|
};
|
|
|
|
SEA3D.Math.lerpAngle = function ( val, tar, t ) {
|
|
|
|
if ( Math.abs( val - tar ) > 180 ) {
|
|
|
|
if ( val > tar ) {
|
|
|
|
tar += 360;
|
|
|
|
} else {
|
|
|
|
tar -= 360;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
val += ( tar - val ) * t;
|
|
|
|
return SEA3D.Math.angle( val );
|
|
|
|
};
|
|
|
|
SEA3D.Math.lerpColor = function ( val, tar, t ) {
|
|
|
|
var a0 = val >> 24 & 0xff,
|
|
r0 = val >> 16 & 0xff,
|
|
g0 = val >> 8 & 0xff,
|
|
b0 = val & 0xff;
|
|
|
|
var a1 = tar >> 24 & 0xff,
|
|
r1 = tar >> 16 & 0xff,
|
|
g1 = tar >> 8 & 0xff,
|
|
b1 = tar & 0xff;
|
|
|
|
a0 += ( a1 - a0 ) * t;
|
|
r0 += ( r1 - r0 ) * t;
|
|
g0 += ( g1 - g0 ) * t;
|
|
b0 += ( b1 - b0 ) * t;
|
|
|
|
return a0 << 24 | r0 << 16 | g0 << 8 | b0;
|
|
|
|
};
|
|
|
|
SEA3D.Math.lerp = function ( val, tar, t ) {
|
|
|
|
return val + ( ( tar - val ) * t );
|
|
|
|
};
|
|
|
|
SEA3D.Math.lerp1x = function ( val, tar, t ) {
|
|
|
|
val[ 0 ] += ( tar[ 0 ] - val[ 0 ] ) * t;
|
|
|
|
};
|
|
|
|
SEA3D.Math.lerp3x = function ( val, tar, t ) {
|
|
|
|
val[ 0 ] += ( tar[ 0 ] - val[ 0 ] ) * t;
|
|
val[ 1 ] += ( tar[ 1 ] - val[ 1 ] ) * t;
|
|
val[ 2 ] += ( tar[ 2 ] - val[ 2 ] ) * t;
|
|
|
|
};
|
|
|
|
SEA3D.Math.lerpAng1x = function ( val, tar, t ) {
|
|
|
|
val[ 0 ] = SEA3D.Math.lerpAngle( val[ 0 ], tar[ 0 ], t );
|
|
|
|
};
|
|
|
|
SEA3D.Math.lerpColor1x = function ( val, tar, t ) {
|
|
|
|
val[ 0 ] = SEA3D.Math.lerpColor( val[ 0 ], tar[ 0 ], t );
|
|
|
|
};
|
|
|
|
SEA3D.Math.lerpQuat4x = function ( val, tar, t ) {
|
|
|
|
var x1 = val[ 0 ],
|
|
y1 = val[ 1 ],
|
|
z1 = val[ 2 ],
|
|
w1 = val[ 3 ];
|
|
|
|
var x2 = tar[ 0 ],
|
|
y2 = tar[ 1 ],
|
|
z2 = tar[ 2 ],
|
|
w2 = tar[ 3 ];
|
|
|
|
var x, y, z, w, l;
|
|
|
|
// shortest direction
|
|
if ( x1 * x2 + y1 * y2 + z1 * z2 + w1 * w2 < 0 ) {
|
|
|
|
x2 = - x2;
|
|
y2 = - y2;
|
|
z2 = - z2;
|
|
w2 = - w2;
|
|
|
|
}
|
|
|
|
x = x1 + t * ( x2 - x1 );
|
|
y = y1 + t * ( y2 - y1 );
|
|
z = z1 + t * ( z2 - z1 );
|
|
w = w1 + t * ( w2 - w1 );
|
|
|
|
l = 1.0 / Math.sqrt( w * w + x * x + y * y + z * z );
|
|
val[ 0 ] = x * l;
|
|
val[ 1 ] = y * l;
|
|
val[ 2 ] = z * l;
|
|
val[ 3 ] = w * l;
|
|
|
|
};
|
|
|
|
//
|
|
// Timer
|
|
//
|
|
|
|
SEA3D.Timer = function () {
|
|
|
|
this.time = this.start = Date.now();
|
|
|
|
};
|
|
|
|
SEA3D.Timer.prototype = {
|
|
constructor: SEA3D.Timer,
|
|
|
|
get now() {
|
|
|
|
return Date.now();
|
|
|
|
},
|
|
|
|
get deltaTime() {
|
|
|
|
return Date.now() - this.time;
|
|
|
|
},
|
|
|
|
get elapsedTime() {
|
|
|
|
return Date.now() - this.start;
|
|
|
|
},
|
|
|
|
update: function () {
|
|
|
|
this.time = Date.now();
|
|
|
|
}
|
|
};
|
|
|
|
//
|
|
// Object
|
|
//
|
|
|
|
SEA3D.Object = function ( name, data, type, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.type = type;
|
|
this.sea3d = sea3d;
|
|
|
|
};
|
|
|
|
//
|
|
// Geometry Base
|
|
//
|
|
|
|
SEA3D.GeometryBase = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.attrib = data.readUShort();
|
|
|
|
this.isBig = ( this.attrib & 1 ) != 0;
|
|
|
|
// variable uint
|
|
data.readVInt = this.isBig ? data.readUInt : data.readUShort;
|
|
|
|
this.numVertex = data.readVInt();
|
|
|
|
this.length = this.numVertex * 3;
|
|
|
|
};
|
|
|
|
//
|
|
// Geometry
|
|
//
|
|
|
|
SEA3D.Geometry = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.GeometryBase.call( this, name, data, sea3d );
|
|
|
|
var i, j, len;
|
|
|
|
// NORMAL
|
|
if ( this.attrib & 4 ) {
|
|
|
|
this.normal = data.readFloatArray( this.length );
|
|
|
|
}
|
|
|
|
// TANGENT
|
|
if ( this.attrib & 8 ) {
|
|
|
|
this.tangent = data.readFloatArray( this.length );
|
|
|
|
}
|
|
|
|
// UV
|
|
if ( this.attrib & 32 ) {
|
|
|
|
this.uv = [];
|
|
this.uv.length = data.readUByte();
|
|
|
|
len = this.numVertex * 2;
|
|
|
|
i = 0;
|
|
while ( i < this.uv.length ) {
|
|
|
|
// UV VERTEX DATA
|
|
this.uv[ i ++ ] = data.readFloatArray( len );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// JOINT-INDEXES / WEIGHTS
|
|
if ( this.attrib & 64 ) {
|
|
|
|
this.jointPerVertex = data.readUByte();
|
|
|
|
var jntLen = this.numVertex * this.jointPerVertex;
|
|
|
|
this.joint = data.readUShortArray( jntLen );
|
|
this.weight = data.readFloatArray( jntLen );
|
|
|
|
}
|
|
|
|
// VERTEX_COLOR
|
|
if ( this.attrib & 128 ) {
|
|
|
|
var colorAttrib = data.readUByte();
|
|
|
|
this.numColor = ( ( ( colorAttrib & 64 ) >> 6 ) | ( ( colorAttrib & 128 ) >> 6 ) ) + 1;
|
|
|
|
this.color = [];
|
|
|
|
for ( i = 0, len = colorAttrib & 15; i < len; i ++ ) {
|
|
|
|
this.color.push( data.readFloatArray( this.numVertex * this.numColor ) );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// VERTEX
|
|
this.vertex = data.readFloatArray( this.length );
|
|
|
|
// SUB-MESHES
|
|
var count = data.readUByte();
|
|
|
|
this.groups = [];
|
|
|
|
if ( this.attrib & 1024 ) {
|
|
|
|
// INDEXES
|
|
for ( i = 0, len = 0; i < count; i ++ ) {
|
|
|
|
j = data.readVInt() * 3;
|
|
|
|
this.groups.push( {
|
|
start: len,
|
|
count: j,
|
|
} );
|
|
|
|
len += j;
|
|
|
|
}
|
|
|
|
this.indexes = this.isBig ? data.readUIntArray( len ) : data.readUShortArray( len );
|
|
|
|
} else {
|
|
|
|
// INDEXES
|
|
var stride = this.isBig ? 4 : 2,
|
|
bytearray = new SEA3D.UByteArray();
|
|
|
|
for ( i = 0, j = 0; i < count; i ++ ) {
|
|
|
|
len = data.readVInt() * 3;
|
|
|
|
this.groups.push( {
|
|
start: j,
|
|
count: len,
|
|
} );
|
|
|
|
j += len;
|
|
|
|
bytearray.add( data.readUByteArray( len * stride ) );
|
|
|
|
}
|
|
|
|
this.indexes = this.isBig ? new Uint32Array( bytearray.toBuffer() ) : new Uint16Array( bytearray.toBuffer() );
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.Geometry.prototype = Object.create( SEA3D.GeometryBase.prototype );
|
|
SEA3D.Geometry.prototype.constructor = SEA3D.Geometry;
|
|
|
|
SEA3D.Geometry.prototype.type = "geo";
|
|
|
|
//
|
|
// Object3D
|
|
//
|
|
|
|
SEA3D.Object3D = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.isStatic = false;
|
|
this.visible = true;
|
|
|
|
this.attrib = data.readUShort();
|
|
|
|
if ( this.attrib & 1 ) this.parent = sea3d.getObject( data.readUInt() );
|
|
|
|
if ( this.attrib & 2 ) this.animations = data.readAnimationList( sea3d );
|
|
|
|
if ( this.attrib & 4 ) this.scripts = data.readScriptList( sea3d );
|
|
|
|
if ( this.attrib & 16 ) this.attributes = sea3d.getObject( data.readUInt() );
|
|
|
|
if ( this.attrib & 32 ) {
|
|
|
|
var objectType = data.readUByte();
|
|
|
|
this.isStatic = ( objectType & 1 ) != 0;
|
|
this.visible = ( objectType & 2 ) == 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.Object3D.prototype.readTag = function ( kind, data, size ) {
|
|
|
|
};
|
|
|
|
//
|
|
// Entity3D
|
|
//
|
|
|
|
SEA3D.Entity3D = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.Object3D.call( this, name, data, sea3d );
|
|
|
|
this.castShadows = true;
|
|
|
|
if ( this.attrib & 64 ) {
|
|
|
|
var lightType = data.readUByte();
|
|
|
|
this.castShadows = ( lightType & 1 ) == 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.Entity3D.prototype = Object.create( SEA3D.Object3D.prototype );
|
|
SEA3D.Entity3D.prototype.constructor = SEA3D.Entity3D;
|
|
|
|
//
|
|
// Sound3D
|
|
//
|
|
|
|
SEA3D.Sound3D = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.Object3D.call( this, name, data, sea3d );
|
|
|
|
this.autoPlay = ( this.attrib & 64 ) != 0;
|
|
|
|
if ( this.attrib & 128 ) this.mixer = sea3d.getObject( data.readUInt() );
|
|
|
|
this.sound = sea3d.getObject( data.readUInt() );
|
|
this.volume = data.readFloat();
|
|
|
|
};
|
|
|
|
SEA3D.Sound3D.prototype = Object.create( SEA3D.Object3D.prototype );
|
|
SEA3D.Sound3D.prototype.constructor = SEA3D.Sound3D;
|
|
|
|
//
|
|
// Sound Point
|
|
//
|
|
|
|
SEA3D.SoundPoint = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.Sound3D.call( this, name, data, sea3d );
|
|
|
|
this.position = data.readVector3();
|
|
this.distance = data.readFloat();
|
|
|
|
data.readTags( this.readTag.bind( this ) );
|
|
|
|
};
|
|
|
|
SEA3D.SoundPoint.prototype = Object.create( SEA3D.Sound3D.prototype );
|
|
SEA3D.SoundPoint.prototype.constructor = SEA3D.SoundPoint;
|
|
|
|
SEA3D.SoundPoint.prototype.type = "sp";
|
|
|
|
//
|
|
// Container3D
|
|
//
|
|
|
|
SEA3D.Container3D = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.Object3D.call( this, name, data, sea3d );
|
|
|
|
this.transform = data.readMatrix();
|
|
|
|
data.readTags( this.readTag.bind( this ) );
|
|
|
|
};
|
|
|
|
SEA3D.Container3D.prototype = Object.create( SEA3D.Object3D.prototype );
|
|
SEA3D.Container3D.prototype.constructor = SEA3D.Container3D;
|
|
|
|
SEA3D.Container3D.prototype.type = "c3d";
|
|
|
|
//
|
|
// Script URL
|
|
//
|
|
|
|
SEA3D.ScriptURL = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.url = data.readUTF8( data.length );
|
|
|
|
};
|
|
|
|
SEA3D.ScriptURL.prototype.type = "src";
|
|
|
|
//
|
|
// Texture URL
|
|
//
|
|
|
|
SEA3D.TextureURL = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.url = data.readUTF8( data.length );
|
|
|
|
};
|
|
|
|
SEA3D.TextureURL.prototype.type = "urlT";
|
|
|
|
//
|
|
// CubeMap URL
|
|
//
|
|
|
|
SEA3D.CubeMapURL = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.faces = [];
|
|
|
|
for ( var i = 0; i < 6; i ++ ) {
|
|
|
|
this.faces[ i ] = data.readUTF8Tiny();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.CubeMapURL.prototype.type = "cURL";
|
|
|
|
//
|
|
// Actions
|
|
//
|
|
|
|
SEA3D.Actions = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.count = data.readUInt();
|
|
this.actions = [];
|
|
|
|
for ( var i = 0; i < this.count; i ++ ) {
|
|
|
|
var flag = data.readUByte();
|
|
var kind = data.readUShort();
|
|
|
|
var size = data.readUShort();
|
|
|
|
var position = data.position;
|
|
var act = this.actions[ i ] = { kind: kind };
|
|
|
|
// range of animation
|
|
if ( flag & 1 ) {
|
|
|
|
// start and count in frames
|
|
act.range = [ data.readUInt(), data.readUInt() ];
|
|
|
|
}
|
|
|
|
// time
|
|
if ( flag & 2 ) {
|
|
|
|
act.time = data.readUInt();
|
|
|
|
}
|
|
|
|
// easing
|
|
if ( flag & 4 ) {
|
|
|
|
act.intrpl = data.readInterpolation();
|
|
|
|
if ( act.intrpl.indexOf( 'back.' ) == 0 ) {
|
|
|
|
act.intrplParam0 = data.readFloat();
|
|
|
|
} else if ( act.intrpl.indexOf( 'elastic.' ) == 0 ) {
|
|
|
|
act.intrplParam0 = data.readFloat();
|
|
act.intrplParam1 = data.readFloat();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
switch ( kind ) {
|
|
|
|
case SEA3D.Actions.RTT_TARGET:
|
|
act.source = sea3d.getObject( data.readUInt() );
|
|
act.target = sea3d.getObject( data.readUInt() );
|
|
break;
|
|
|
|
case SEA3D.Actions.LOOK_AT:
|
|
act.source = sea3d.getObject( data.readUInt() );
|
|
act.target = sea3d.getObject( data.readUInt() );
|
|
break;
|
|
|
|
case SEA3D.Actions.PLAY_SOUND:
|
|
act.sound = sea3d.getObject( data.readUInt() );
|
|
act.offset = data.readUInt();
|
|
break;
|
|
|
|
case SEA3D.Actions.PLAY_ANIMATION:
|
|
act.object = sea3d.getObject( data.readUInt() );
|
|
act.name = data.readUTF8Tiny();
|
|
break;
|
|
|
|
case SEA3D.Actions.FOG:
|
|
act.color = data.readUInt24();
|
|
act.min = data.readFloat();
|
|
act.max = data.readFloat();
|
|
break;
|
|
|
|
case SEA3D.Actions.ENVIRONMENT:
|
|
act.texture = sea3d.getObject( data.readUInt() );
|
|
break;
|
|
|
|
case SEA3D.Actions.ENVIRONMENT_COLOR:
|
|
act.color = data.readUInt24F();
|
|
break;
|
|
|
|
case SEA3D.Actions.CAMERA:
|
|
act.camera = sea3d.getObject( data.readUInt() );
|
|
break;
|
|
|
|
case SEA3D.Actions.SCRIPTS:
|
|
act.scripts = data.readScriptList( sea3d );
|
|
break;
|
|
|
|
case SEA3D.Actions.CLASS_OF:
|
|
act.classof = sea3d.getObject( data.readUInt() );
|
|
break;
|
|
|
|
case SEA3D.Actions.ATTRIBUTES:
|
|
act.attributes = sea3d.getObject( data.readUInt() );
|
|
break;
|
|
|
|
default:
|
|
console.log( "Action \"" + kind + "\" not found." );
|
|
break;
|
|
|
|
}
|
|
|
|
data.position = position + size;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.Actions.SCENE = 0;
|
|
SEA3D.Actions.ENVIRONMENT_COLOR = 1;
|
|
SEA3D.Actions.ENVIRONMENT = 2;
|
|
SEA3D.Actions.FOG = 3;
|
|
SEA3D.Actions.PLAY_ANIMATION = 4;
|
|
SEA3D.Actions.PLAY_SOUND = 5;
|
|
SEA3D.Actions.ANIMATION_AUDIO_SYNC = 6;
|
|
SEA3D.Actions.LOOK_AT = 7;
|
|
SEA3D.Actions.RTT_TARGET = 8;
|
|
SEA3D.Actions.CAMERA = 9;
|
|
SEA3D.Actions.SCRIPTS = 10;
|
|
SEA3D.Actions.CLASS_OF = 11;
|
|
SEA3D.Actions.ATTRIBUTES = 12;
|
|
|
|
SEA3D.Actions.prototype.type = "act";
|
|
|
|
//
|
|
// Properties
|
|
//
|
|
|
|
SEA3D.Properties = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.tag = data.readProperties( sea3d );
|
|
this.tag.__name = name;
|
|
|
|
};
|
|
|
|
SEA3D.Properties.prototype.type = "prop";
|
|
|
|
//
|
|
// File Info
|
|
//
|
|
|
|
SEA3D.FileInfo = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.tag = data.readProperties( sea3d );
|
|
this.tag.__name = name;
|
|
|
|
sea3d.info = this.tag;
|
|
|
|
};
|
|
|
|
SEA3D.FileInfo.prototype.type = "info";
|
|
|
|
//
|
|
// Java Script
|
|
//
|
|
|
|
SEA3D.JavaScript = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.src = data.readUTF8( data.length );
|
|
|
|
};
|
|
|
|
SEA3D.JavaScript.prototype.type = "js";
|
|
|
|
//
|
|
// Java Script Method
|
|
//
|
|
|
|
SEA3D.JavaScriptMethod = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
var count = data.readUShort();
|
|
|
|
this.methods = {};
|
|
|
|
for ( var i = 0; i < count; i ++ ) {
|
|
|
|
var flag = data.readUByte();
|
|
var method = data.readUTF8Tiny();
|
|
|
|
this.methods[ method ] = {
|
|
src: data.readUTF8Long()
|
|
};
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.JavaScriptMethod.prototype.type = "jsm";
|
|
|
|
//
|
|
// GLSL
|
|
//
|
|
|
|
SEA3D.GLSL = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.src = data.readUTF8( data.length );
|
|
|
|
};
|
|
|
|
SEA3D.GLSL.prototype.type = "glsl";
|
|
|
|
//
|
|
// Dummy
|
|
//
|
|
|
|
SEA3D.Dummy = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.Object3D.call( this, name, data, sea3d );
|
|
|
|
this.transform = data.readMatrix();
|
|
|
|
this.width = data.readFloat();
|
|
this.height = data.readFloat();
|
|
this.depth = data.readFloat();
|
|
|
|
data.readTags( this.readTag.bind( this ) );
|
|
|
|
};
|
|
|
|
SEA3D.Dummy.prototype = Object.create( SEA3D.Object3D.prototype );
|
|
SEA3D.Dummy.prototype.constructor = SEA3D.Dummy;
|
|
|
|
SEA3D.Dummy.prototype.type = "dmy";
|
|
|
|
//
|
|
// Line
|
|
//
|
|
|
|
SEA3D.Line = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.Object3D.call( this, name, data, sea3d );
|
|
|
|
this.count = ( this.attrib & 64 ? data.readUInt() : data.readUShort() ) * 3;
|
|
this.closed = ( this.attrib & 128 ) != 0;
|
|
this.transform = data.readMatrix();
|
|
|
|
this.vertex = [];
|
|
|
|
var i = 0;
|
|
while ( i < this.count ) {
|
|
|
|
this.vertex[ i ++ ] = data.readFloat();
|
|
|
|
}
|
|
|
|
data.readTags( this.readTag.bind( this ) );
|
|
|
|
};
|
|
|
|
SEA3D.Line.prototype = Object.create( SEA3D.Object3D.prototype );
|
|
SEA3D.Line.prototype.constructor = SEA3D.Line;
|
|
|
|
SEA3D.Line.prototype.type = "line";
|
|
|
|
//
|
|
// Sprite
|
|
//
|
|
|
|
SEA3D.Sprite = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.Object3D.call( this, name, data, sea3d );
|
|
|
|
if ( this.attrib & 256 ) {
|
|
|
|
this.material = sea3d.getObject( data.readUInt() );
|
|
|
|
}
|
|
|
|
this.position = data.readVector3();
|
|
|
|
this.width = data.readFloat();
|
|
this.height = data.readFloat();
|
|
|
|
data.readTags( this.readTag.bind( this ) );
|
|
|
|
};
|
|
|
|
SEA3D.Sprite.prototype = Object.create( SEA3D.Object3D.prototype );
|
|
SEA3D.Sprite.prototype.constructor = SEA3D.Sprite;
|
|
|
|
SEA3D.Sprite.prototype.type = "m2d";
|
|
|
|
//
|
|
// Mesh
|
|
//
|
|
|
|
SEA3D.Mesh = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.Entity3D.call( this, name, data, sea3d );
|
|
|
|
// MATERIAL
|
|
if ( this.attrib & 256 ) {
|
|
|
|
this.material = [];
|
|
|
|
var len = data.readUByte();
|
|
|
|
if ( len == 1 ) this.material[ 0 ] = sea3d.getObject( data.readUInt() );
|
|
else {
|
|
|
|
var i = 0;
|
|
while ( i < len ) {
|
|
|
|
var matIndex = data.readUInt();
|
|
|
|
if ( matIndex > 0 ) this.material[ i ++ ] = sea3d.getObject( matIndex - 1 );
|
|
else this.material[ i ++ ] = undefined;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ( this.attrib & 512 ) {
|
|
|
|
this.modifiers = [];
|
|
|
|
var len = data.readUByte();
|
|
|
|
for ( var i = 0; i < len; i ++ ) {
|
|
|
|
this.modifiers[ i ] = sea3d.getObject( data.readUInt() );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ( this.attrib & 1024 ) {
|
|
|
|
this.reference = {
|
|
type: data.readUByte(),
|
|
ref: sea3d.getObject( data.readUInt() )
|
|
};
|
|
|
|
}
|
|
|
|
this.transform = data.readMatrix();
|
|
|
|
this.geometry = sea3d.getObject( data.readUInt() );
|
|
|
|
data.readTags( this.readTag.bind( this ) );
|
|
|
|
};
|
|
|
|
SEA3D.Mesh.prototype = Object.create( SEA3D.Entity3D.prototype );
|
|
SEA3D.Mesh.prototype.constructor = SEA3D.Mesh;
|
|
|
|
SEA3D.Mesh.prototype.type = "m3d";
|
|
|
|
//
|
|
// Skeleton
|
|
//
|
|
|
|
SEA3D.Skeleton = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
var length = data.readUShort();
|
|
|
|
this.joint = [];
|
|
|
|
for ( var i = 0; i < length; i ++ ) {
|
|
|
|
this.joint[ i ] = {
|
|
name: data.readUTF8Tiny(),
|
|
parentIndex: data.readUShort() - 1,
|
|
inverseBindMatrix: data.readMatrix()
|
|
};
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.Skeleton.prototype.type = "skl";
|
|
|
|
//
|
|
// Skeleton Local
|
|
//
|
|
|
|
SEA3D.SkeletonLocal = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
var length = data.readUShort();
|
|
|
|
this.joint = [];
|
|
|
|
for ( var i = 0; i < length; i ++ ) {
|
|
|
|
this.joint[ i ] = {
|
|
name: data.readUTF8Tiny(),
|
|
parentIndex: data.readUShort() - 1,
|
|
// POSITION XYZ
|
|
x: data.readFloat(),
|
|
y: data.readFloat(),
|
|
z: data.readFloat(),
|
|
// QUATERNION XYZW
|
|
qx: data.readFloat(),
|
|
qy: data.readFloat(),
|
|
qz: data.readFloat(),
|
|
qw: data.readFloat()
|
|
};
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.SkeletonLocal.prototype.type = "sklq";
|
|
|
|
//
|
|
// Animation Base
|
|
//
|
|
|
|
SEA3D.AnimationBase = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
var flag = data.readUByte();
|
|
|
|
this.sequence = [];
|
|
|
|
if ( flag & 1 ) {
|
|
|
|
var count = data.readUShort();
|
|
|
|
for ( var i = 0; i < count; i ++ ) {
|
|
|
|
flag = data.readUByte();
|
|
|
|
this.sequence[ i ] = {
|
|
name: data.readUTF8Tiny(),
|
|
start: data.readUInt(),
|
|
count: data.readUInt(),
|
|
repeat: ( flag & 1 ) != 0,
|
|
intrpl: ( flag & 2 ) == 0
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
this.frameRate = data.readUByte();
|
|
this.numFrames = data.readUInt();
|
|
|
|
// no contains sequence
|
|
if ( this.sequence.length == 0 ) {
|
|
|
|
this.sequence[ 0 ] = { name: "root", start: 0, count: this.numFrames, repeat: true, intrpl: true };
|
|
|
|
}
|
|
|
|
};
|
|
|
|
//
|
|
// Animation
|
|
//
|
|
|
|
SEA3D.Animation = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.AnimationBase.call( this, name, data, sea3d );
|
|
|
|
this.dataList = [];
|
|
|
|
for ( var i = 0, l = data.readUByte(); i < l; i ++ ) {
|
|
|
|
var kind = data.readUShort(),
|
|
type = data.readUByte();
|
|
|
|
var anmRaw = data.readVector( type, this.numFrames, 0 );
|
|
|
|
this.dataList.push( {
|
|
kind: kind,
|
|
type: type,
|
|
blockSize: SEA3D.Stream.sizeOf( type ),
|
|
data: anmRaw
|
|
} );
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.Animation.POSITION = 0;
|
|
SEA3D.Animation.ROTATION = 1;
|
|
SEA3D.Animation.SCALE = 2;
|
|
SEA3D.Animation.COLOR = 3;
|
|
SEA3D.Animation.MULTIPLIER = 4;
|
|
SEA3D.Animation.ATTENUATION_START = 5;
|
|
SEA3D.Animation.ATTENUATION_END = 6;
|
|
SEA3D.Animation.FOV = 7;
|
|
SEA3D.Animation.OFFSET_U = 8;
|
|
SEA3D.Animation.OFFSET_V = 9;
|
|
SEA3D.Animation.SCALE_U = 10;
|
|
SEA3D.Animation.SCALE_V = 11;
|
|
SEA3D.Animation.ANGLE = 12;
|
|
SEA3D.Animation.ALPHA = 13;
|
|
SEA3D.Animation.VOLUME = 14;
|
|
|
|
SEA3D.Animation.DefaultLerpFuncs = [
|
|
SEA3D.Math.lerp3x, // POSITION
|
|
SEA3D.Math.lerpQuat4x, // ROTATION
|
|
SEA3D.Math.lerp3x, // SCALE
|
|
SEA3D.Math.lerpColor1x, // COLOR
|
|
SEA3D.Math.lerp1x, // MULTIPLIER
|
|
SEA3D.Math.lerp1x, // ATTENUATION_START
|
|
SEA3D.Math.lerp1x, // ATTENUATION_END
|
|
SEA3D.Math.lerp1x, // FOV
|
|
SEA3D.Math.lerp1x, // OFFSET_U
|
|
SEA3D.Math.lerp1x, // OFFSET_V
|
|
SEA3D.Math.lerp1x, // SCALE_U
|
|
SEA3D.Math.lerp1x, // SCALE_V
|
|
SEA3D.Math.lerpAng1x, // ANGLE
|
|
SEA3D.Math.lerp1x, // ALPHA
|
|
SEA3D.Math.lerp1x // VOLUME
|
|
];
|
|
|
|
SEA3D.Animation.prototype = Object.create( SEA3D.AnimationBase.prototype );
|
|
SEA3D.Animation.prototype.constructor = SEA3D.Animation;
|
|
|
|
SEA3D.Animation.prototype.type = "anm";
|
|
|
|
//
|
|
// Skeleton Animation
|
|
//
|
|
|
|
SEA3D.SkeletonAnimation = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.AnimationBase.call( this, name, data, sea3d );
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.numJoints = data.readUShort();
|
|
|
|
this.raw = data.readFloatArray( this.numFrames * this.numJoints * 7 );
|
|
|
|
};
|
|
|
|
SEA3D.SkeletonAnimation.prototype.type = "skla";
|
|
|
|
//
|
|
// Morph
|
|
//
|
|
|
|
SEA3D.Morph = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.GeometryBase.call( this, name, data, sea3d );
|
|
|
|
var useVertex = ( this.attrib & 2 ) != 0;
|
|
var useNormal = ( this.attrib & 4 ) != 0;
|
|
|
|
var nodeCount = data.readUShort();
|
|
|
|
this.node = [];
|
|
|
|
for ( var i = 0; i < nodeCount; i ++ ) {
|
|
|
|
var nodeName = data.readUTF8Tiny(),
|
|
verts, norms;
|
|
|
|
if ( useVertex ) verts = data.readFloatArray( this.length );
|
|
if ( useNormal ) norms = data.readFloatArray( this.length );
|
|
|
|
this.node[ i ] = { vertex: verts, normal: norms, name: nodeName };
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.Morph.prototype = Object.create( SEA3D.GeometryBase.prototype );
|
|
SEA3D.Morph.prototype.constructor = SEA3D.Morph;
|
|
|
|
SEA3D.Morph.prototype.type = "mph";
|
|
|
|
//
|
|
// Vertex Animation
|
|
//
|
|
|
|
SEA3D.VertexAnimation = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.AnimationBase.call( this, name, data, sea3d );
|
|
|
|
var flags = data.readUByte();
|
|
|
|
this.isBig = ( flags & 1 ) != 0;
|
|
|
|
data.readVInt = this.isBig ? data.readUInt : data.readUShort;
|
|
|
|
this.numVertex = data.readVInt();
|
|
|
|
this.length = this.numVertex * 3;
|
|
|
|
var useVertex = ( flags & 2 ) != 0;
|
|
var useNormal = ( flags & 4 ) != 0;
|
|
|
|
this.frame = [];
|
|
|
|
var i, verts, norms;
|
|
|
|
for ( i = 0; i < this.numFrames; i ++ ) {
|
|
|
|
if ( useVertex ) verts = data.readFloatArray( this.length );
|
|
if ( useNormal ) norms = data.readFloatArray( this.length );
|
|
|
|
this.frame[ i ] = { vertex: verts, normal: norms };
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.VertexAnimation.prototype = Object.create( SEA3D.AnimationBase.prototype );
|
|
SEA3D.VertexAnimation.prototype.constructor = SEA3D.VertexAnimation;
|
|
|
|
SEA3D.VertexAnimation.prototype.type = "vtxa";
|
|
|
|
//
|
|
// Camera
|
|
//
|
|
|
|
SEA3D.Camera = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.Object3D.call( this, name, data, sea3d );
|
|
|
|
if ( this.attrib & 64 ) {
|
|
|
|
this.dof = {
|
|
distance: data.readFloat(),
|
|
range: data.readFloat()
|
|
};
|
|
|
|
}
|
|
|
|
this.transform = data.readMatrix();
|
|
|
|
this.fov = data.readFloat();
|
|
|
|
data.readTags( this.readTag.bind( this ) );
|
|
|
|
};
|
|
|
|
SEA3D.Camera.prototype = Object.create( SEA3D.Object3D.prototype );
|
|
SEA3D.Camera.prototype.constructor = SEA3D.Camera;
|
|
|
|
SEA3D.Camera.prototype.type = "cam";
|
|
|
|
//
|
|
// Orthographic Camera
|
|
//
|
|
|
|
SEA3D.OrthographicCamera = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.Object3D.call( this, name, data, sea3d );
|
|
|
|
this.transform = data.readMatrix();
|
|
|
|
this.height = data.readFloat();
|
|
|
|
data.readTags( this.readTag.bind( this ) );
|
|
|
|
};
|
|
|
|
SEA3D.OrthographicCamera.prototype = Object.create( SEA3D.Object3D.prototype );
|
|
SEA3D.OrthographicCamera.prototype.constructor = SEA3D.OrthographicCamera;
|
|
|
|
SEA3D.OrthographicCamera.prototype.type = "camo";
|
|
|
|
//
|
|
// Joint Object
|
|
//
|
|
|
|
SEA3D.JointObject = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.Object3D.call( this, name, data, sea3d );
|
|
|
|
this.target = sea3d.getObject( data.readUInt() );
|
|
this.joint = data.readUShort();
|
|
|
|
data.readTags( this.readTag.bind( this ) );
|
|
|
|
};
|
|
|
|
SEA3D.JointObject.prototype = Object.create( SEA3D.Object3D.prototype );
|
|
SEA3D.JointObject.prototype.constructor = SEA3D.JointObject;
|
|
|
|
SEA3D.JointObject.prototype.type = "jnt";
|
|
|
|
//
|
|
// Light
|
|
//
|
|
|
|
SEA3D.Light = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.Object3D.call( this, name, data, sea3d );
|
|
|
|
this.attenStart = Number.MAX_VALUE;
|
|
this.attenEnd = Number.MAX_VALUE;
|
|
|
|
if ( this.attrib & 64 ) {
|
|
|
|
var shadowHeader = data.readUByte();
|
|
|
|
this.shadow = {};
|
|
|
|
this.shadow.opacity = shadowHeader & 1 ? data.readFloat() : 1;
|
|
this.shadow.color = shadowHeader & 2 ? data.readUInt24() : 0x000000;
|
|
|
|
}
|
|
|
|
if ( this.attrib & 512 ) {
|
|
|
|
this.attenStart = data.readFloat();
|
|
this.attenEnd = data.readFloat();
|
|
|
|
}
|
|
|
|
this.color = data.readUInt24();
|
|
this.multiplier = data.readFloat();
|
|
|
|
};
|
|
|
|
SEA3D.Light.prototype = Object.create( SEA3D.Object3D.prototype );
|
|
SEA3D.Light.prototype.constructor = SEA3D.Light;
|
|
|
|
//
|
|
// Point Light
|
|
//
|
|
|
|
SEA3D.PointLight = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.Light.call( this, name, data, sea3d );
|
|
|
|
if ( this.attrib & 128 ) {
|
|
|
|
this.attenuation = {
|
|
start: data.readFloat(),
|
|
end: data.readFloat()
|
|
};
|
|
|
|
}
|
|
|
|
this.position = data.readVector3();
|
|
|
|
data.readTags( this.readTag.bind( this ) );
|
|
|
|
};
|
|
|
|
SEA3D.PointLight.prototype = Object.create( SEA3D.Light.prototype );
|
|
SEA3D.PointLight.prototype.constructor = SEA3D.PointLight;
|
|
|
|
SEA3D.PointLight.prototype.type = "plht";
|
|
|
|
//
|
|
// Hemisphere Light
|
|
//
|
|
|
|
SEA3D.HemisphereLight = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.Light.call( this, name, data, sea3d );
|
|
|
|
if ( this.attrib & 128 ) {
|
|
|
|
this.attenuation = {
|
|
start: data.readFloat(),
|
|
end: data.readFloat()
|
|
};
|
|
|
|
}
|
|
|
|
this.secondColor = data.readUInt24();
|
|
|
|
data.readTags( this.readTag.bind( this ) );
|
|
|
|
};
|
|
|
|
SEA3D.HemisphereLight.prototype = Object.create( SEA3D.Light.prototype );
|
|
SEA3D.HemisphereLight.prototype.constructor = SEA3D.HemisphereLight;
|
|
|
|
SEA3D.HemisphereLight.prototype.type = "hlht";
|
|
|
|
//
|
|
// Ambient Light
|
|
//
|
|
|
|
SEA3D.AmbientLight = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.Light.call( this, name, data, sea3d );
|
|
|
|
data.readTags( this.readTag.bind( this ) );
|
|
|
|
};
|
|
|
|
SEA3D.AmbientLight.prototype = Object.create( SEA3D.Light.prototype );
|
|
SEA3D.AmbientLight.prototype.constructor = SEA3D.AmbientLight;
|
|
|
|
SEA3D.AmbientLight.prototype.type = "alht";
|
|
|
|
//
|
|
// Directional Light
|
|
//
|
|
|
|
SEA3D.DirectionalLight = function ( name, data, sea3d ) {
|
|
|
|
SEA3D.Light.call( this, name, data, sea3d );
|
|
|
|
this.transform = data.readMatrix();
|
|
|
|
data.readTags( this.readTag.bind( this ) );
|
|
|
|
};
|
|
|
|
SEA3D.DirectionalLight.prototype = Object.create( SEA3D.Light.prototype );
|
|
SEA3D.DirectionalLight.prototype.constructor = SEA3D.DirectionalLight;
|
|
|
|
SEA3D.DirectionalLight.prototype.type = "dlht";
|
|
|
|
//
|
|
// Material
|
|
//
|
|
|
|
SEA3D.Material = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.technique = [];
|
|
this.tecniquesDict = {};
|
|
|
|
this.attrib = data.readUShort();
|
|
|
|
this.alpha = 1;
|
|
this.blendMode = "normal";
|
|
|
|
this.physical = false;
|
|
this.anisotropy = false;
|
|
|
|
this.bothSides = ( this.attrib & 1 ) != 0;
|
|
|
|
this.receiveLights = ( this.attrib & 2 ) == 0;
|
|
this.receiveShadows = ( this.attrib & 4 ) == 0;
|
|
this.receiveFog = ( this.attrib & 8 ) == 0;
|
|
|
|
this.repeat = ( this.attrib & 16 ) == 0;
|
|
|
|
if ( this.attrib & 32 )
|
|
this.alpha = data.readFloat();
|
|
|
|
if ( this.attrib & 64 )
|
|
this.blendMode = data.readBlendMode();
|
|
|
|
if ( this.attrib & 128 )
|
|
this.animations = data.readAnimationList( sea3d );
|
|
|
|
this.depthWrite = ( this.attrib & 256 ) == 0;
|
|
this.depthTest = ( this.attrib & 512 ) == 0;
|
|
|
|
this.premultipliedAlpha = ( this.attrib & 1024 ) != 0;
|
|
|
|
var count = data.readUByte();
|
|
|
|
for ( var i = 0; i < count; ++ i ) {
|
|
|
|
var kind = data.readUShort();
|
|
var size = data.readUShort();
|
|
var pos = data.position;
|
|
var tech, methodAttrib;
|
|
|
|
switch ( kind ) {
|
|
|
|
case SEA3D.Material.PHONG:
|
|
tech = {
|
|
ambientColor: data.readUInt24(),
|
|
diffuseColor: data.readUInt24(),
|
|
specularColor: data.readUInt24(),
|
|
|
|
specular: data.readFloat(),
|
|
gloss: data.readFloat()
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.PHYSICAL:
|
|
tech = {
|
|
color: data.readUInt24(),
|
|
roughness: data.readFloat(),
|
|
metalness: data.readFloat()
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.ANISOTROPIC:
|
|
break;
|
|
|
|
case SEA3D.Material.COMPOSITE_TEXTURE:
|
|
tech = {
|
|
composite: sea3d.getObject( data.readUInt() )
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.DIFFUSE_MAP:
|
|
tech = {
|
|
texture: sea3d.getObject( data.readUInt() )
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.SPECULAR_MAP:
|
|
tech = {
|
|
texture: sea3d.getObject( data.readUInt() )
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.NORMAL_MAP:
|
|
tech = {
|
|
texture: sea3d.getObject( data.readUInt() )
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.REFLECTION:
|
|
case SEA3D.Material.FRESNEL_REFLECTION:
|
|
tech = {
|
|
texture: sea3d.getObject( data.readUInt() ),
|
|
alpha: data.readFloat()
|
|
};
|
|
|
|
if ( kind == SEA3D.Material.FRESNEL_REFLECTION ) {
|
|
|
|
tech.power = data.readFloat();
|
|
tech.normal = data.readFloat();
|
|
|
|
}
|
|
break;
|
|
|
|
case SEA3D.Material.REFRACTION:
|
|
tech = {
|
|
texture: sea3d.getObject( data.readUInt() ),
|
|
alpha: data.readFloat(),
|
|
ior: data.readFloat()
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.RIM:
|
|
tech = {
|
|
color: data.readUInt24(),
|
|
strength: data.readFloat(),
|
|
power: data.readFloat(),
|
|
blendMode: data.readBlendMode()
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.LIGHT_MAP:
|
|
tech = {
|
|
texture: sea3d.getObject( data.readUInt() ),
|
|
channel: data.readUByte(),
|
|
blendMode: data.readBlendMode()
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.DETAIL_MAP:
|
|
tech = {
|
|
texture: sea3d.getObject( data.readUInt() ),
|
|
scale: data.readFloat(),
|
|
blendMode: data.readBlendMode()
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.CEL:
|
|
tech = {
|
|
color: data.readUInt24(),
|
|
levels: data.readUByte(),
|
|
size: data.readFloat(),
|
|
specularCutOff: data.readFloat(),
|
|
smoothness: data.readFloat()
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.TRANSLUCENT:
|
|
tech = {
|
|
translucency: data.readFloat(),
|
|
scattering: data.readFloat()
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.BLEND_NORMAL_MAP:
|
|
methodAttrib = data.readUByte();
|
|
|
|
tech = {
|
|
texture: sea3d.getObject( data.readUInt() ),
|
|
secondaryTexture: sea3d.getObject( data.readUInt() )
|
|
};
|
|
|
|
if ( methodAttrib & 1 ) {
|
|
|
|
tech.offsetX0 = data.readFloat();
|
|
tech.offsetY0 = data.readFloat();
|
|
|
|
tech.offsetX1 = data.readFloat();
|
|
tech.offsetY1 = data.readFloat();
|
|
|
|
} else {
|
|
|
|
tech.offsetX0 = tech.offsetY0 =
|
|
tech.offsetX1 = tech.offsetY1 = 0;
|
|
|
|
}
|
|
|
|
tech.animate = methodAttrib & 2;
|
|
break;
|
|
|
|
case SEA3D.Material.MIRROR_REFLECTION:
|
|
tech = {
|
|
texture: sea3d.getObject( data.readUInt() ),
|
|
alpha: data.readFloat()
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.AMBIENT_MAP:
|
|
tech = {
|
|
texture: sea3d.getObject( data.readUInt() )
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.ALPHA_MAP:
|
|
tech = {
|
|
texture: sea3d.getObject( data.readUInt() )
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.EMISSIVE:
|
|
tech = {
|
|
color: data.readUInt24()
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.EMISSIVE_MAP:
|
|
tech = {
|
|
texture: sea3d.getObject( data.readUInt() )
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.ROUGHNESS_MAP:
|
|
case SEA3D.Material.METALNESS_MAP:
|
|
tech = {
|
|
texture: sea3d.getObject( data.readUInt() )
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.VERTEX_COLOR:
|
|
tech = {
|
|
blendMode: data.readBlendMode()
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.WRAP_LIGHTING:
|
|
tech = {
|
|
color: data.readUInt24(),
|
|
strength: data.readFloat()
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.COLOR_REPLACE:
|
|
methodAttrib = data.readUByte();
|
|
|
|
tech = {
|
|
red: data.readUInt24(),
|
|
green: data.readUInt24(),
|
|
blue: data.readUInt24F()
|
|
};
|
|
|
|
if ( methodAttrib & 1 ) tech.mask = sea3d.getObject( data.readUInt() );
|
|
|
|
if ( methodAttrib & 2 ) tech.alpha = data.readFloat();
|
|
|
|
break;
|
|
|
|
case SEA3D.Material.REFLECTION_SPHERICAL:
|
|
tech = {
|
|
texture: sea3d.getObject( data.readUInt() ),
|
|
alpha: data.readFloat()
|
|
};
|
|
break;
|
|
|
|
case SEA3D.Material.REFLECTIVITY:
|
|
methodAttrib = data.readUByte();
|
|
|
|
tech = {
|
|
strength: data.readFloat()
|
|
};
|
|
|
|
if ( methodAttrib & 1 ) tech.mask = sea3d.getObject( data.readUInt() );
|
|
|
|
break;
|
|
|
|
case SEA3D.Material.CLEAR_COAT:
|
|
tech = {
|
|
strength: data.readFloat(),
|
|
roughness: data.readFloat()
|
|
};
|
|
break;
|
|
|
|
default:
|
|
console.warn( "SEA3D: MaterialTechnique not found:", kind.toString( 16 ) );
|
|
|
|
data.position = pos += size;
|
|
continue;
|
|
|
|
}
|
|
|
|
tech.kind = kind;
|
|
|
|
this.technique.push( tech );
|
|
this.tecniquesDict[ kind ] = tech;
|
|
|
|
data.position = pos += size;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.Material.PHONG = 0;
|
|
SEA3D.Material.COMPOSITE_TEXTURE = 1;
|
|
SEA3D.Material.DIFFUSE_MAP = 2;
|
|
SEA3D.Material.SPECULAR_MAP = 3;
|
|
SEA3D.Material.REFLECTION = 4;
|
|
SEA3D.Material.REFRACTION = 5;
|
|
SEA3D.Material.NORMAL_MAP = 6;
|
|
SEA3D.Material.FRESNEL_REFLECTION = 7;
|
|
SEA3D.Material.RIM = 8;
|
|
SEA3D.Material.LIGHT_MAP = 9;
|
|
SEA3D.Material.DETAIL_MAP = 10;
|
|
SEA3D.Material.CEL = 11;
|
|
SEA3D.Material.TRANSLUCENT = 12;
|
|
SEA3D.Material.BLEND_NORMAL_MAP = 13;
|
|
SEA3D.Material.MIRROR_REFLECTION = 14;
|
|
SEA3D.Material.AMBIENT_MAP = 15;
|
|
SEA3D.Material.ALPHA_MAP = 16;
|
|
SEA3D.Material.EMISSIVE_MAP = 17;
|
|
SEA3D.Material.VERTEX_COLOR = 18;
|
|
SEA3D.Material.WRAP_LIGHTING = 19;
|
|
SEA3D.Material.COLOR_REPLACE = 20;
|
|
SEA3D.Material.REFLECTION_SPHERICAL = 21;
|
|
SEA3D.Material.ANISOTROPIC = 22;
|
|
SEA3D.Material.EMISSIVE = 23;
|
|
SEA3D.Material.PHYSICAL = 24;
|
|
SEA3D.Material.ROUGHNESS_MAP = 25;
|
|
SEA3D.Material.METALNESS_MAP = 26;
|
|
SEA3D.Material.REFLECTIVITY = 27;
|
|
SEA3D.Material.CLEAR_COAT = 28;
|
|
|
|
SEA3D.Material.prototype.type = "mat";
|
|
|
|
//
|
|
// Composite
|
|
//
|
|
|
|
SEA3D.Composite = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
var layerCount = data.readUByte();
|
|
|
|
this.layer = [];
|
|
|
|
for ( var i = 0; i < layerCount; i ++ ) {
|
|
|
|
this.layer[ i ] = new SEA3D.Composite.prototype.Layer( data, sea3d );
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.Composite.prototype.getLayerByName = function ( name ) {
|
|
|
|
for ( var i = 0; i < this.layer.length; i ++ ) {
|
|
|
|
if ( this.layer[ i ].name == name ) {
|
|
|
|
return this.layer[ i ];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.Composite.prototype.Layer = function ( data, sea3d ) {
|
|
|
|
var attrib = data.readUShort();
|
|
|
|
if ( attrib & 1 ) this.texture = new SEA3D.Composite.LayerBitmap( data, sea3d );
|
|
else this.color = data.readUInt24();
|
|
|
|
if ( attrib & 2 ) {
|
|
|
|
this.mask = new SEA3D.Composite.LayerBitmap( data, sea3d );
|
|
|
|
}
|
|
|
|
if ( attrib & 4 ) {
|
|
|
|
this.name = data.readUTF8Tiny();
|
|
|
|
}
|
|
|
|
this.blendMode = attrib & 8 ? data.readBlendMode() : "normal";
|
|
|
|
this.opacity = attrib & 16 ? data.readFloat() : 1;
|
|
|
|
};
|
|
|
|
SEA3D.Composite.LayerBitmap = function ( data, sea3d ) {
|
|
|
|
this.map = sea3d.getObject( data.readUInt() );
|
|
|
|
var attrib = data.readUShort();
|
|
|
|
this.channel = attrib & 1 ? data.readUByte() : 0;
|
|
this.repeat = attrib & 2 == 0;
|
|
this.offsetU = attrib & 4 ? data.readFloat() : 0;
|
|
this.offsetV = attrib & 8 ? data.readFloat() : 0;
|
|
this.scaleU = attrib & 16 ? data.readFloat() : 1;
|
|
this.scaleV = attrib & 32 ? data.readFloat() : 1;
|
|
this.rotation = attrib & 64 ? data.readFloat() : 0;
|
|
|
|
if ( attrib & 128 ) this.animation = data.readAnimationList( sea3d );
|
|
|
|
};
|
|
|
|
SEA3D.Composite.prototype.type = "ctex";
|
|
|
|
//
|
|
// Planar Render
|
|
//
|
|
|
|
SEA3D.PlanarRender = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.attrib = data.readUByte();
|
|
|
|
this.quality = ( this.attrib & 1 ) | ( this.attrib & 2 );
|
|
this.transform = data.readMatrix();
|
|
|
|
};
|
|
|
|
SEA3D.PlanarRender.prototype.type = "rttp";
|
|
|
|
//
|
|
// Cube Render
|
|
//
|
|
|
|
SEA3D.CubeRender = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.attrib = data.readUByte();
|
|
|
|
this.quality = ( this.attrib & 1 ) | ( this.attrib & 2 );
|
|
this.position = data.readVector3();
|
|
|
|
};
|
|
|
|
SEA3D.CubeRender.prototype.type = "rttc";
|
|
|
|
//
|
|
// Cube Maps
|
|
//
|
|
|
|
SEA3D.CubeMap = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.transparent = false;
|
|
|
|
var ext = data.readExt();
|
|
|
|
this.faces = [];
|
|
|
|
for ( var i = 0; i < 6; i ++ ) {
|
|
|
|
var size = data.readUInt();
|
|
|
|
this.faces[ i ] = data.concat( data.position, size );
|
|
|
|
data.position += size;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.CubeMap.prototype.type = "cmap";
|
|
|
|
//
|
|
// JPEG
|
|
//
|
|
|
|
SEA3D.JPEG = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.transparent = false;
|
|
|
|
};
|
|
|
|
SEA3D.JPEG.prototype.type = "jpg";
|
|
|
|
//
|
|
// JPEG_XR
|
|
//
|
|
|
|
SEA3D.JPEG_XR = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.transparent = true;
|
|
|
|
};
|
|
|
|
SEA3D.JPEG_XR.prototype.type = "wdp";
|
|
|
|
//
|
|
// PNG
|
|
//
|
|
|
|
SEA3D.PNG = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.transparent = data.getByte( 25 ) == 0x06;
|
|
|
|
};
|
|
|
|
SEA3D.PNG.prototype.type = "png";
|
|
|
|
//
|
|
// GIF
|
|
//
|
|
|
|
SEA3D.GIF = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
this.transparent = data.getByte( 11 ) > 0;
|
|
|
|
};
|
|
|
|
SEA3D.GIF.prototype.type = "gif";
|
|
|
|
//
|
|
// OGG
|
|
//
|
|
|
|
SEA3D.OGG = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
};
|
|
|
|
SEA3D.OGG.prototype.type = "ogg";
|
|
|
|
//
|
|
// MP3
|
|
//
|
|
|
|
SEA3D.MP3 = function ( name, data, sea3d ) {
|
|
|
|
this.name = name;
|
|
this.data = data;
|
|
this.sea3d = sea3d;
|
|
|
|
};
|
|
|
|
SEA3D.MP3.prototype.type = "mp3";
|
|
|
|
//
|
|
// FILE FORMAT
|
|
//
|
|
|
|
SEA3D.File = function ( config ) {
|
|
|
|
this.config = {
|
|
streaming: true,
|
|
timeLimit: 60
|
|
};
|
|
|
|
if ( config ) {
|
|
|
|
if ( config.streaming !== undefined ) this.config.streaming = config.streaming;
|
|
if ( config.timeLimit !== undefined ) this.config.timeLimit = config.timeLimit;
|
|
|
|
}
|
|
|
|
this.version = SEA3D.VERSION;
|
|
this.objects = [];
|
|
this.typeClass = {};
|
|
this.typeRead = {};
|
|
this.typeUnique = {};
|
|
this.position =
|
|
this.dataPosition = 0;
|
|
this.scope = this;
|
|
|
|
// SEA3D
|
|
this.addClass( SEA3D.FileInfo, true );
|
|
this.addClass( SEA3D.Geometry, true );
|
|
this.addClass( SEA3D.Mesh );
|
|
this.addClass( SEA3D.Sprite );
|
|
this.addClass( SEA3D.Material );
|
|
this.addClass( SEA3D.Composite );
|
|
this.addClass( SEA3D.PointLight );
|
|
this.addClass( SEA3D.DirectionalLight );
|
|
this.addClass( SEA3D.HemisphereLight );
|
|
this.addClass( SEA3D.AmbientLight );
|
|
this.addClass( SEA3D.Skeleton, true );
|
|
this.addClass( SEA3D.SkeletonLocal, true );
|
|
this.addClass( SEA3D.SkeletonAnimation, true );
|
|
this.addClass( SEA3D.JointObject );
|
|
this.addClass( SEA3D.Camera );
|
|
this.addClass( SEA3D.OrthographicCamera );
|
|
this.addClass( SEA3D.Morph, true );
|
|
this.addClass( SEA3D.VertexAnimation, true );
|
|
this.addClass( SEA3D.CubeMap, true );
|
|
this.addClass( SEA3D.Animation );
|
|
this.addClass( SEA3D.Dummy );
|
|
this.addClass( SEA3D.Line );
|
|
this.addClass( SEA3D.SoundPoint );
|
|
this.addClass( SEA3D.PlanarRender );
|
|
this.addClass( SEA3D.CubeRender );
|
|
this.addClass( SEA3D.Actions );
|
|
this.addClass( SEA3D.Container3D );
|
|
this.addClass( SEA3D.Properties );
|
|
|
|
// URL BASED
|
|
this.addClass( SEA3D.ScriptURL, true );
|
|
this.addClass( SEA3D.TextureURL, true );
|
|
this.addClass( SEA3D.CubeMapURL, true );
|
|
|
|
// UNIVERSAL
|
|
this.addClass( SEA3D.JPEG, true );
|
|
this.addClass( SEA3D.JPEG_XR, true );
|
|
this.addClass( SEA3D.PNG, true );
|
|
this.addClass( SEA3D.GIF, true );
|
|
this.addClass( SEA3D.OGG, true );
|
|
this.addClass( SEA3D.MP3, true );
|
|
this.addClass( SEA3D.JavaScript, true );
|
|
this.addClass( SEA3D.JavaScriptMethod, true );
|
|
this.addClass( SEA3D.GLSL, true );
|
|
|
|
// Extensions
|
|
|
|
var i = SEA3D.File.Extensions.length;
|
|
|
|
while ( i -- ) {
|
|
|
|
SEA3D.File.Extensions[ i ].call( this );
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.File.Extensions = [];
|
|
SEA3D.File.CompressionLibs = {};
|
|
SEA3D.File.DecompressionMethod = {};
|
|
|
|
SEA3D.File.setExtension = function ( callback ) {
|
|
|
|
SEA3D.File.Extensions.push( callback );
|
|
|
|
};
|
|
|
|
SEA3D.File.setDecompressionEngine = function ( id, name, method ) {
|
|
|
|
SEA3D.File.CompressionLibs[ id ] = name;
|
|
SEA3D.File.DecompressionMethod[ id ] = method;
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.addClass = function ( clazz, unique ) {
|
|
|
|
this.typeClass[ clazz.prototype.type ] = clazz;
|
|
this.typeUnique[ clazz.prototype.type ] = unique === true;
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.readHead = function () {
|
|
|
|
if ( this.stream.bytesAvailable < 16 )
|
|
return false;
|
|
|
|
if ( this.stream.readUTF8( 3 ) != "SEA" )
|
|
throw new Error( "Invalid SEA3D format." );
|
|
|
|
this.sign = this.stream.readUTF8( 3 );
|
|
|
|
this.version = this.stream.readUInt24();
|
|
|
|
if ( this.stream.readUByte() != 0 ) {
|
|
|
|
throw new Error( "Protection algorithm not compatible." );
|
|
|
|
}
|
|
|
|
this.compressionID = this.stream.readUByte();
|
|
|
|
this.compressionAlgorithm = SEA3D.File.CompressionLibs[ this.compressionID ];
|
|
this.decompressionMethod = SEA3D.File.DecompressionMethod[ this.compressionID ];
|
|
|
|
if ( this.compressionID > 0 && ! this.decompressionMethod ) {
|
|
|
|
throw new Error( "Compression algorithm not compatible." );
|
|
|
|
}
|
|
|
|
this.length = this.stream.readUInt();
|
|
|
|
this.dataPosition = this.stream.position;
|
|
|
|
this.objects.length = 0;
|
|
|
|
this.state = this.readBody;
|
|
|
|
if ( this.onHead ) {
|
|
|
|
this.onHead( {
|
|
file: this,
|
|
sign: this.sign
|
|
} );
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.getObject = function ( index ) {
|
|
|
|
return this.objects[ index ];
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.getObjectByName = function ( name ) {
|
|
|
|
return this.objects[ name ];
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.readSEAObject = function () {
|
|
|
|
if ( this.stream.bytesAvailable < 4 )
|
|
return null;
|
|
|
|
var size = this.stream.readUInt();
|
|
var position = this.stream.position;
|
|
|
|
if ( this.stream.bytesAvailable < size )
|
|
return null;
|
|
|
|
var flag = this.stream.readUByte();
|
|
var type = this.stream.readExt();
|
|
var meta = null;
|
|
|
|
var name = flag & 1 ? this.stream.readUTF8Tiny() : "",
|
|
compressed = ( flag & 2 ) != 0,
|
|
streaming = ( flag & 4 ) != 0;
|
|
|
|
if ( flag & 8 ) {
|
|
|
|
var metalen = this.stream.readUShort();
|
|
var metabytes = this.stream.concat( this.stream.position, metalen );
|
|
|
|
this.stream.position += metalen;
|
|
|
|
if ( compressed && this.decompressionMethod ) {
|
|
|
|
metabytes.buffer = this.decompressionMethod( metabytes.buffer );
|
|
|
|
}
|
|
|
|
meta = metabytes.readProperties( this );
|
|
|
|
}
|
|
|
|
size -= this.stream.position - position;
|
|
position = this.stream.position;
|
|
|
|
var data = this.stream.concat( position, size ),
|
|
obj;
|
|
|
|
if ( this.typeClass[ type ] ) {
|
|
|
|
if ( compressed && this.decompressionMethod ) {
|
|
|
|
data.buffer = this.decompressionMethod( data.buffer );
|
|
|
|
}
|
|
|
|
obj = new this.typeClass[ type ]( name, data, this );
|
|
|
|
if ( ( this.config.streaming && streaming || this.config.forceStreaming ) && this.typeRead[ type ] ) {
|
|
|
|
this.typeRead[ type ].call( this.scope, obj );
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
obj = new SEA3D.Object( name, data, type, this );
|
|
|
|
console.warn( "SEA3D: Unknown format \"" + type + "\" of file \"" + name + "\". Add a module referring for this format." );
|
|
|
|
}
|
|
|
|
obj.streaming = streaming;
|
|
obj.metadata = meta;
|
|
|
|
this.objects.push( this.objects[ obj.name + "." + obj.type ] = obj );
|
|
|
|
this.dataPosition = position + size;
|
|
|
|
++ this.position;
|
|
|
|
return obj;
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.isDone = function () {
|
|
|
|
return this.position == this.length;
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.readBody = function () {
|
|
|
|
this.timer.update();
|
|
|
|
if ( ! this.resume ) return false;
|
|
|
|
while ( this.position < this.length ) {
|
|
|
|
if ( this.timer.deltaTime < this.config.timeLimit ) {
|
|
|
|
this.stream.position = this.dataPosition;
|
|
|
|
var sea = this.readSEAObject();
|
|
|
|
if ( sea ) this.dispatchCompleteObject( sea );
|
|
else return false;
|
|
|
|
} else return false;
|
|
|
|
}
|
|
|
|
this.state = this.readComplete;
|
|
|
|
return true;
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.initParse = function () {
|
|
|
|
this.timer = new SEA3D.Timer();
|
|
this.position = 0;
|
|
this.resume = true;
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.parse = function () {
|
|
|
|
this.initParse();
|
|
|
|
if ( isFinite( this.config.timeLimit ) ) setTimeout( this.parseObject.bind( this ), 10 );
|
|
else this.parseObject();
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.parseObject = function () {
|
|
|
|
this.timer.update();
|
|
|
|
while ( this.position < this.length && this.timer.deltaTime < this.config.timeLimit ) {
|
|
|
|
var obj = this.objects[ this.position ++ ],
|
|
type = obj.type;
|
|
|
|
if ( ! this.typeUnique[ type ] ) delete obj.tag;
|
|
|
|
if ( ( obj.streaming || this.config.forceStreaming ) && this.typeRead[ type ] ) {
|
|
|
|
if ( obj.tag == undefined ) {
|
|
|
|
this.typeRead[ type ].call( this.scope, obj );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ( this.position == this.length ) {
|
|
|
|
var elapsedTime = this.timer.elapsedTime;
|
|
var message = elapsedTime + "ms, " + this.objects.length + " objects";
|
|
|
|
if ( this.onParseComplete ) {
|
|
|
|
this.onParseComplete( {
|
|
file: this,
|
|
timeTotal: elapsedTime,
|
|
message: message
|
|
} );
|
|
|
|
} else console.log( "SEA3D Parse Complete:", message );
|
|
|
|
} else {
|
|
|
|
if ( this.onParseProgress ) {
|
|
|
|
this.onParseProgress( {
|
|
file: this,
|
|
loaded: this.position,
|
|
total: this.length
|
|
} );
|
|
|
|
}
|
|
|
|
setTimeout( this.parseObject.bind( this ), 10 );
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.readComplete = function () {
|
|
|
|
this.stream.position = this.dataPosition;
|
|
|
|
if ( this.stream.readUInt24F() != 0x5EA3D1 )
|
|
console.warn( "SEA3D file is corrupted." );
|
|
|
|
delete this.state;
|
|
|
|
return false;
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.readState = function () {
|
|
|
|
while ( this.state() ) continue;
|
|
|
|
if ( this.state ) {
|
|
|
|
requestAnimationFrame( this.readState.bind( this ) );
|
|
|
|
this.dispatchProgress();
|
|
|
|
} else {
|
|
|
|
this.dispatchComplete();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.read = function ( buffer ) {
|
|
|
|
if ( ! buffer ) throw new Error( "No data found." );
|
|
|
|
this.initParse();
|
|
|
|
this.stream = new SEA3D.Stream( buffer );
|
|
this.state = this.readHead;
|
|
|
|
this.readState();
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.dispatchCompleteObject = function ( obj ) {
|
|
|
|
if ( ! this.onCompleteObject ) return;
|
|
|
|
this.onCompleteObject( {
|
|
file: this,
|
|
object: obj
|
|
} );
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.dispatchProgress = function () {
|
|
|
|
if ( ! this.onProgress ) return;
|
|
|
|
this.onProgress( {
|
|
file: this,
|
|
loaded: this.position,
|
|
total: this.length
|
|
} );
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.dispatchDownloadProgress = function ( position, length ) {
|
|
|
|
if ( ! this.onDownloadProgress ) return;
|
|
|
|
this.onDownloadProgress( {
|
|
file: this,
|
|
loaded: position,
|
|
total: length
|
|
} );
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.dispatchComplete = function () {
|
|
|
|
var elapsedTime = this.timer.elapsedTime;
|
|
var message = elapsedTime + "ms, " + this.objects.length + " objects";
|
|
|
|
if ( this.onComplete ) this.onComplete( {
|
|
file: this,
|
|
timeTotal: elapsedTime,
|
|
message: message
|
|
} );
|
|
else console.log( "SEA3D:", message );
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.dispatchError = function ( id, message ) {
|
|
|
|
if ( this.onError ) this.onError( { file: this, id: id, message: message } );
|
|
else console.error( "SEA3D: #" + id, message );
|
|
|
|
};
|
|
|
|
SEA3D.File.prototype.load = function ( url ) {
|
|
|
|
var file = this,
|
|
xhr = new XMLHttpRequest();
|
|
|
|
xhr.open( "GET", url, true );
|
|
xhr.responseType = 'arraybuffer';
|
|
|
|
xhr.onprogress = function ( e ) {
|
|
|
|
if ( e.lengthComputable ) {
|
|
|
|
file.dispatchDownloadProgress( e.loaded, e.total );
|
|
|
|
}
|
|
|
|
};
|
|
|
|
xhr.onreadystatechange = function () {
|
|
|
|
if ( xhr.readyState === 2 ) {
|
|
//xhr.getResponseHeader("Content-Length");
|
|
} else if ( xhr.readyState === 3 ) {
|
|
// progress
|
|
} else if ( xhr.readyState === 4 ) {
|
|
|
|
if ( xhr.status === 200 || xhr.status === 0 ) {
|
|
|
|
// complete
|
|
file.read( this.response );
|
|
|
|
} else {
|
|
|
|
this.dispatchError( 1001, "Couldn't load [" + url + "] [" + xhr.status + "]" );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
xhr.send();
|
|
|
|
};
|