Doodle3D-Slicer/three.js-master/examples/js/loaders/AWDLoader.js
2015-06-12 15:58:26 +02:00

1227 lines
24 KiB
JavaScript
Executable File

/**
* Author: Pierre Lepers
* Date: 09/12/2013 17:21
*/
THREE.AWDLoader = (function () {
var UNCOMPRESSED = 0,
DEFLATE = 1,
LZMA = 2,
AWD_FIELD_INT8 = 1,
AWD_FIELD_INT16 = 2,
AWD_FIELD_INT32 = 3,
AWD_FIELD_UINT8 = 4,
AWD_FIELD_UINT16 = 5,
AWD_FIELD_UINT32 = 6,
AWD_FIELD_FLOAT32 = 7,
AWD_FIELD_FLOAT64 = 8,
AWD_FIELD_BOOL = 21,
AWD_FIELD_COLOR = 22,
AWD_FIELD_BADDR = 23,
AWD_FIELD_STRING = 31,
AWD_FIELD_BYTEARRAY = 32,
AWD_FIELD_VECTOR2x1 = 41,
AWD_FIELD_VECTOR3x1 = 42,
AWD_FIELD_VECTOR4x1 = 43,
AWD_FIELD_MTX3x2 = 44,
AWD_FIELD_MTX3x3 = 45,
AWD_FIELD_MTX4x3 = 46,
AWD_FIELD_MTX4x4 = 47,
BOOL = 21,
COLOR = 22,
BADDR = 23,
INT8 = 1,
INT16 = 2,
INT32 = 3,
UINT8 = 4,
UINT16 = 5,
UINT32 = 6,
FLOAT32 = 7,
FLOAT64 = 8;
var littleEndian = true;
// ResourcesLoader
// =============
// handle loading for external resources
function ResourcesLoader( awdUrl ) {
this._baseDir = awdUrl.substr( 0, awdUrl.lastIndexOf( '/' ) + 1 );
this._loadingManager = new THREE.LoadingManager();
}
ResourcesLoader.prototype = {
loadTexture : function( path ) {
var tex = new THREE.Texture();
var loader = new THREE.ImageLoader( this._loadingManager );
loader.load( this._baseDir + path, function( image ) {
tex.image = image;
tex.needsUpdate = true;
});
return tex;
}
}
function Block() {
this.id = 0;
this.data = null;
}
function AWDLoader( showStatus ) {
THREE.Loader.call( this, showStatus );
this.trunk = new THREE.Object3D();
this.materialFactory = undefined;
this._resourceLoader = null;
this._url = '';
this._data;
this._ptr = 0;
this._version = [];
this._streaming = false;
this._optimized_for_accuracy = false;
this._compression = 0;
this._bodylen = 0xFFFFFFFF;
this._blocks = [ new Block() ];
this._accuracyMatrix = false;
this._accuracyGeo = false;
this._accuracyProps = false;
};
AWDLoader.prototype = Object.create( THREE.Loader.prototype );
AWDLoader.prototype.constructor = AWDLoader;
AWDLoader.prototype.load = function ( url, callback ) {
var that = this;
this._url = url;
var xhr = new XMLHttpRequest();
xhr.open( "GET", url, true );
xhr.responseType = 'arraybuffer';
xhr.onreadystatechange = function () {
if ( xhr.readyState == 4 ) {
if ( xhr.status == 200 || xhr.status == 0 ) {
that.parse( xhr.response );
callback( that.trunk );
} else {
console.error( 'AWDLoader: Couldn\'t load ' + url + ' (' + xhr.status + ')' );
}
}
};
xhr.send( null );
};
AWDLoader.prototype.parse = function ( data ) {
var blen = data.byteLength;
this._ptr = 0;
this._data = new DataView( data );
this._parseHeader( );
if ( this._compression != 0 ) {
console.error( 'compressed AWD not supported' );
}
if (!this._streaming && this._bodylen != data.byteLength - this._ptr ) {
console.error('AWDLoader: body len does not match file length', this._bodylen, blen - this._ptr);
}
while ( this._ptr < blen ) {
this.parseNextBlock();
}
return this.trunk;
}
AWDLoader.prototype.parseNextBlock = function ( ) {
var assetData,
ns, type, len, block,
blockId = this.readU32(),
ns = this.readU8(),
type = this.readU8(),
flags = this.readU8(),
len = this.readU32();
switch (type) {
case 1:
assetData = this.parseMeshData(len);
break;
case 22:
assetData = this.parseContainer(len);
break;
case 23:
assetData = this.parseMeshInstance(len);
break;
case 81:
assetData = this.parseMaterial(len);
break;
case 82:
assetData = this.parseTexture(len);
break;
case 101:
assetData = this.parseSkeleton(len);
break;
// case 111:
// assetData = this.parseMeshPoseAnimation(len, true);
// break;
case 112:
assetData = this.parseMeshPoseAnimation(len, false);
break;
case 113:
assetData = this.parseVertexAnimationSet(len);
break;
case 102:
assetData = this.parseSkeletonPose(len);
break;
case 103:
assetData = this.parseSkeletonAnimation(len);
break;
case 122:
assetData = this.parseAnimatorSet(len);
break;
// case 121:
// assetData = parseUVAnimation(len);
// break;
default:
//debug('Ignoring block!',type, len);
this._ptr += len;
break;
}
// Store block reference for later use
this._blocks[blockId] = block = new Block();
block.data = assetData;
block.id = blockId;
}
AWDLoader.prototype._parseHeader = function () {
var version = this._version,
awdmagic =
( this.readU8()<<16)
| ( this.readU8()<<8 )
| this.readU8();
if ( awdmagic != 4282180 )
throw new Error( "AWDLoader - bad magic" );
version[0] = this.readU8();
version[1] = this.readU8();
var flags = this.readU16();
this._streaming = (flags & 0x1) == 0x1;
if ((version[0] === 2) && (version[1] === 1)) {
this._accuracyMatrix = (flags & 0x2) === 0x2;
this._accuracyGeo = (flags & 0x4) === 0x4;
this._accuracyProps = (flags & 0x8) === 0x8;
}
this._geoNrType = this._accuracyGeo ? FLOAT64 : FLOAT32;
this._matrixNrType = this._accuracyMatrix ? FLOAT64 : FLOAT32;
this._propsNrType = this._accuracyProps ? FLOAT64 : FLOAT32;
this._optimized_for_accuracy = (flags & 0x2) === 0x2;
this._compression = this.readU8();
this._bodylen = this.readU32();
}
AWDLoader.prototype.parseContainer = function ( len ) {
var parent,
ctr = new THREE.Object3D(),
par_id = this.readU32(),
mtx = this.parseMatrix4();
ctr.name = this.readUTF();
ctr.applyMatrix( mtx );
parent = this._blocks[par_id].data || this.trunk;
parent.add(ctr);
this.parseProperties({
1:this._matrixNrType,
2:this._matrixNrType,
3:this._matrixNrType,
4:UINT8
});
ctr.extra = this.parseUserAttributes();
return ctr;
}
AWDLoader.prototype.parseMeshInstance = function ( len ) {
var name,
mesh, geometries, meshLen, meshes,
par_id, data_id,
mtx,
materials, mat, mat_id,
num_materials,
materials_parsed,
parent,
i;
par_id = this.readU32();
mtx = this.parseMatrix4();
name = this.readUTF();
data_id = this.readU32();
num_materials = this.readU16();
geometries = this.getBlock( data_id );
materials = [];
materials_parsed = 0;
for ( i = 0; i < num_materials; i ++) {
mat_id = this.readU32();
mat = this.getBlock( mat_id );
materials.push( mat );
}
meshLen = geometries.length
meshes = [];
// TODO : BufferGeometry don't support "geometryGroups" for now.
// so we create sub meshes for each groups
if ( meshLen > 1 ) {
mesh = new THREE.Object3D()
for ( i = 0; i < meshLen; i ++) {
var sm = new THREE.Mesh( geometries[i] );
meshes.push( sm );
mesh.add( sm );
}
}
else {
mesh = new THREE.Mesh( geometries[0] );
meshes.push( mesh );
}
mesh.applyMatrix( mtx );
mesh.name = name;
parent = this.getBlock( par_id ) || this.trunk;
parent.add( mesh );
var matLen = materials.length;
var maxLen = Math.max( meshLen, matLen);
for ( i = 0; i < maxLen; i ++ )
meshes[ i%meshLen ].material = materials[ i % matLen ];
// Ignore for now
this.parseProperties( null );
mesh.extra = this.parseUserAttributes();
return mesh;
}
AWDLoader.prototype.parseMaterial = function ( len ) {
var name,
type,
props,
mat,
attributes,
finalize,
num_methods,
methods_parsed;
name = this.readUTF();
type = this.readU8();
num_methods = this.readU8();
//log( "AWDLoader parseMaterial ",name )
// Read material numerical properties
// (1=color, 2=bitmap url, 11=alpha_blending, 12=alpha_threshold, 13=repeat)
props = this.parseProperties({
1: AWD_FIELD_INT32,
2: AWD_FIELD_BADDR,
11: AWD_FIELD_BOOL,
12: AWD_FIELD_FLOAT32,
13: AWD_FIELD_BOOL
});
methods_parsed = 0;
while ( methods_parsed < num_methods ) {
var method_type = this.readU16();
this.parseProperties( null );
this.parseUserAttributes();
}
attributes = this.parseUserAttributes();
if ( this.materialFactory !== undefined ) {
mat = this.materialFactory( name );
if ( mat ) return mat;
}
mat = new THREE.MeshPhongMaterial();
if (type === 1) { // Color material
mat.color.setHex( props.get(1, 0xcccccc) );
}
else if (type === 2) { // Bitmap material
var tex_addr = props.get(2, 0);
mat.map = this.getBlock( tex_addr );
}
mat.extra = attributes;
mat.alphaThreshold = props.get(12, 0.0);
mat.repeat = props.get(13, false);
return mat;
}
AWDLoader.prototype.parseTexture = function( len ) {
var name = this.readUTF(),
type = this.readU8(),
asset,
data_len;
// External
if (type === 0) {
data_len = this.readU32();
var url = this.readUTFBytes(data_len);
console.log( url );
asset = this.loadTexture( url );
} else {
// embed texture not supported
}
// Ignore for now
this.parseProperties( null );
this.parseUserAttributes();
return asset;
}
AWDLoader.prototype.loadTexture = function( url ) {
if ( null === this._resourceLoader )
this._resourceLoader = new ResourcesLoader( this._url );
return this._resourceLoader.loadTexture( url );
}
// broken : skeleton pose format is different than threejs one
AWDLoader.prototype.parseSkeleton = function(len) // Array<Bone>
{
var name = this.readUTF(),
num_joints = this.readU16(),
skeleton = [],
joints_parsed = 0;
this.parseProperties( null );
while (joints_parsed < num_joints) {
var joint, ibp;
// Ignore joint id
this.readU16();
joint = new THREE.Bone();
joint.parent = this.readU16() - 1; // 0=null in AWD
joint.name = this.readUTF();
ibp = this.parseMatrix4();
joint.skinMatrix = ibp;
// Ignore joint props/attributes for now
this.parseProperties(null);
this.parseUserAttributes();
skeleton.push(joint);
joints_parsed ++;
}
// Discard attributes for now
this.parseUserAttributes();
return skeleton;
}
AWDLoader.prototype.parseSkeletonPose = function(blockID)
{
var name = this.readUTF();
var num_joints = this.readU16();
this.parseProperties(null);
// debug( 'parse Skeleton Pose. joints : ' + num_joints);
var pose = [];
var joints_parsed = 0;
while (joints_parsed < num_joints) {
var joint_pose;
var has_transform; //:uint;
var mtx_data;
has_transform = this.readU8();
if (has_transform === 1) {
mtx_data = this.parseMatrix4();
} else
{
mtx_data = new THREE.Matrix4();
}
pose[joints_parsed] = mtx_data;
joints_parsed ++;
}
// Skip attributes for now
this.parseUserAttributes();
return pose
}
AWDLoader.prototype.parseSkeletonAnimation = function(blockID)
{
var frame_dur;
var pose_addr;
var pose;
var name = this.readUTF();
var clip = [];
var num_frames = this.readU16();
this.parseProperties(null);
var frames_parsed = 0;
var returnedArray;
// debug( 'parse Skeleton Animation. frames : ' + num_frames);
while (frames_parsed < num_frames) {
pose_addr = this.readU32();
frame_dur = this.readU16();
pose = this._blocks[pose_addr].data
// debug( 'pose address ',pose[2].elements[12],pose[2].elements[13],pose[2].elements[14] );
clip.push( {
pose : pose,
duration : frame_dur
} );
frames_parsed ++;
}
if (clip.length == 0) {
// debug("Could not this SkeletonClipNode, because no Frames where set.");
return;
}
// Ignore attributes for now
this.parseUserAttributes();
return clip;
}
AWDLoader.prototype.parseVertexAnimationSet = function(len)
{
var poseBlockAdress,
name = this.readUTF(),
num_frames = this.readU16(),
props = this.parseProperties({ 1:UINT16 }),
frames_parsed = 0,
skeletonFrames = [];
while (frames_parsed < num_frames) {
poseBlockAdress = this.readU32();
skeletonFrames.push(this._blocks[poseBlockAdress].data);
frames_parsed ++;
}
this.parseUserAttributes();
return skeletonFrames;
}
AWDLoader.prototype.parseAnimatorSet = function(len)
{
var targetMesh;
var animSetBlockAdress; //:int
var targetAnimationSet; //:AnimationSetBase;
var outputString = ""; //:String = "";
var name = this.readUTF();
var type = this.readU16();
var props = this.parseProperties({ 1:BADDR });
animSetBlockAdress = this.readU32();
var targetMeshLength = this.readU16();
var meshAdresses = []; //:Vector.<uint> = new Vector.<uint>;
for (var i = 0; i < targetMeshLength; i ++)
meshAdresses.push( this.readU32() );
var activeState = this.readU16();
var autoplay = Boolean(this.readU8());
this.parseUserAttributes();
this.parseUserAttributes();
var returnedArray;
var targetMeshes = []; //:Vector.<Mesh> = new Vector.<Mesh>;
for (i = 0; i < meshAdresses.length; i ++) {
// returnedArray = getAssetByID(meshAdresses[i], [AssetType.MESH]);
// if (returnedArray[0])
targetMeshes.push(this._blocks[meshAdresses[i]].data);
}
targetAnimationSet = this._blocks[animSetBlockAdress].data
var thisAnimator;
if (type == 1) {
thisAnimator = {
animationSet : targetAnimationSet,
skeleton : this._blocks[props.get(1, 0)].data
};
} else if (type == 2) {
// debug( "vertex Anim???");
}
for (i = 0; i < targetMeshes.length; i ++) {
targetMeshes[i].animator = thisAnimator;
}
// debug("Parsed a Animator: Name = " + name);
return thisAnimator;
}
AWDLoader.prototype.parseMeshData = function ( len ) {
var name = this.readUTF(),
num_subs = this.readU16(),
geom,
subs_parsed = 0,
props,
buffer,
skinW, skinI,
geometries = [];
props = this.parseProperties({
1: this._geoNrType,
2: this._geoNrType
});
// Loop through sub meshes
while (subs_parsed < num_subs) {
var sm_len, sm_end, attrib;
geom = new THREE.BufferGeometry();
geom.name = name;
geometries.push( geom );
sm_len = this.readU32();
sm_end = this._ptr + sm_len;
// Ignore for now
this.parseProperties({ 1:this._geoNrType, 2:this._geoNrType });
// Loop through data streams
while ( this._ptr < sm_end ) {
var idx = 0,
str_type = this.readU8(),
str_ftype = this.readU8(),
str_len = this.readU32(),
str_end = str_len + this._ptr;
// VERTICES
// ------------------
if ( str_type === 1 ) {
buffer = new Float32Array( ( str_len / 12 ) * 3 );
attrib = new THREE.BufferAttribute( buffer, 3 );
geom.addAttribute( 'position', attrib );
idx = 0;
while (this._ptr < str_end) {
buffer[idx] = -this.readF32();
buffer[idx + 1] = this.readF32();
buffer[idx + 2] = this.readF32();
idx+=3;
}
}
// INDICES
// -----------------
else if (str_type === 2) {
buffer = new Uint16Array( str_len / 2 );
attrib = new THREE.BufferAttribute( buffer, 1 );
geom.addAttribute( 'index', attrib );
geom.offsets.push({
start: 0,
index: 0,
count: str_len / 2
});
idx = 0;
while (this._ptr < str_end) {
buffer[idx + 1] = this.readU16();
buffer[idx] = this.readU16();
buffer[idx + 2] = this.readU16();
idx+=3;
}
}
// UVS
// -------------------
else if (str_type === 3) {
buffer = new Float32Array( ( str_len / 8 ) * 2 );
attrib = new THREE.BufferAttribute( buffer, 2 );
geom.addAttribute( 'uv', attrib );
idx = 0;
while (this._ptr < str_end) {
buffer[idx] = this.readF32();
buffer[idx + 1] = 1.0 - this.readF32();
idx+=2;
}
}
// NORMALS
else if (str_type === 4) {
buffer = new Float32Array( ( str_len / 12 ) * 3 );
attrib = new THREE.BufferAttribute( buffer, 3 );
geom.addAttribute( 'normal', attrib );
idx = 0;
while (this._ptr < str_end) {
buffer[idx] = -this.readF32();
buffer[idx + 1] = this.readF32();
buffer[idx + 2] = this.readF32();
idx+=3;
}
}
// else if (str_type == 6) {
// skinI = new Float32Array( str_len>>1 );
// idx = 0
// while (this._ptr < str_end) {
// skinI[idx] = this.readU16();
// idx++;
// }
// }
// else if (str_type == 7) {
// skinW = new Float32Array( str_len>>2 );
// idx = 0;
// while (this._ptr < str_end) {
// skinW[idx] = this.readF32();
// idx++;
// }
// }
else {
this._ptr = str_end;
}
}
this.parseUserAttributes();
geom.computeBoundingSphere();
subs_parsed ++;
}
//geom.computeFaceNormals();
this.parseUserAttributes();
//finalizeAsset(geom, name);
return geometries;
}
AWDLoader.prototype.parseMeshPoseAnimation = function(len, poseOnly)
{
var num_frames = 1,
num_submeshes,
frames_parsed,
subMeshParsed,
frame_dur,
x, y, z,
str_len,
str_end,
geom,
subGeom,
idx = 0,
clip = {},
indices,
verts,
num_Streams,
streamsParsed,
streamtypes = [],
props,
thisGeo,
name = this.readUTF(),
geoAdress = this.readU32();
var mesh = this.getBlock( geoAdress );
if (mesh == null) {
console.log( "parseMeshPoseAnimation target mesh not found at:", geoAdress );
return;
}
geom = mesh.geometry;
geom.morphTargets = [];
if (!poseOnly)
num_frames = this.readU16();
num_submeshes = this.readU16();
num_Streams = this.readU16();
// debug("VA num_frames : ", num_frames );
// debug("VA num_submeshes : ", num_submeshes );
// debug("VA numstreams : ", num_Streams );
streamsParsed = 0;
while (streamsParsed < num_Streams) {
streamtypes.push(this.readU16());
streamsParsed ++;
}
props = this.parseProperties({ 1:BOOL, 2:BOOL });
clip.looping = props.get(1, true);
clip.stitchFinalFrame = props.get(2, false);
frames_parsed = 0;
while (frames_parsed < num_frames) {
frame_dur = this.readU16();
subMeshParsed = 0;
while (subMeshParsed < num_submeshes) {
streamsParsed = 0;
str_len = this.readU32();
str_end = this._ptr + str_len;
while (streamsParsed < num_Streams) {
if (streamtypes[streamsParsed] == 1) {
//geom.addAttribute( 'morphTarget'+frames_parsed, Float32Array, str_len/12, 3 );
var buffer = new Float32Array(str_len / 4);
geom.morphTargets.push( {
array : buffer
});
//buffer = geom.attributes['morphTarget'+frames_parsed].array
idx = 0;
while ( this._ptr < str_end ) {
buffer[idx] = this.readF32();
buffer[idx + 1] = this.readF32();
buffer[idx + 2] = this.readF32();
idx += 3;
}
subMeshParsed ++;
} else
this._ptr = str_end;
streamsParsed ++;
}
}
frames_parsed ++;
}
this.parseUserAttributes();
return null;
}
AWDLoader.prototype.getBlock = function ( id ) {
return this._blocks[id].data;
},
AWDLoader.prototype.parseMatrix4 = function ( ) {
var mtx = new THREE.Matrix4();
var e = mtx.elements;
e[0] = this.readF32();
e[1] = this.readF32();
e[2] = this.readF32();
e[3] = 0.0;
//e[3] = 0.0;
e[4] = this.readF32();
e[5] = this.readF32();
e[6] = this.readF32();
//e[7] = this.readF32();
e[7] = 0.0;
e[8] = this.readF32();
e[9] = this.readF32();
e[10] = this.readF32();
//e[11] = this.readF32();
e[11] = 0.0;
e[12] = -this.readF32();
e[13] = this.readF32();
e[14] = this.readF32();
//e[15] = this.readF32();
e[15] = 1.0;
return mtx;
}
AWDLoader.prototype.parseProperties = function ( expected ) {
var list_len = this.readU32();
var list_end = this._ptr + list_len;
var props = new AWDProperties();
if ( expected ) {
while ( this._ptr < list_end ) {
var key = this.readU16();
var len = this.readU32();
var type;
if ( expected.hasOwnProperty( key ) ) {
type = expected[ key ];
props.set( key, this.parseAttrValue( type, len ) );
} else {
this._ptr += len;
}
}
}
return props;
};
AWDLoader.prototype.parseUserAttributes = function ( ) {
// skip for now
this._ptr = this.readU32() + this._ptr;
return null;
};
AWDLoader.prototype.parseAttrValue = function ( type, len ) {
var elem_len;
var read_func;
switch (type) {
case AWD_FIELD_INT8:
elem_len = 1;
read_func = this.readI8;
break;
case AWD_FIELD_INT16:
elem_len = 2;
read_func = this.readI16;
break;
case AWD_FIELD_INT32:
elem_len = 4;
read_func = this.readI32;
break;
case AWD_FIELD_BOOL:
case AWD_FIELD_UINT8:
elem_len = 1;
read_func = this.readU8;
break;
case AWD_FIELD_UINT16:
elem_len = 2;
read_func = this.readU16;
break;
case AWD_FIELD_UINT32:
case AWD_FIELD_BADDR:
elem_len = 4;
read_func = this.readU32;
break;
case AWD_FIELD_FLOAT32:
elem_len = 4;
read_func = this.readF32;
break;
case AWD_FIELD_FLOAT64:
elem_len = 8;
read_func = this.readF64;
break;
case AWD_FIELD_VECTOR2x1:
case AWD_FIELD_VECTOR3x1:
case AWD_FIELD_VECTOR4x1:
case AWD_FIELD_MTX3x2:
case AWD_FIELD_MTX3x3:
case AWD_FIELD_MTX4x3:
case AWD_FIELD_MTX4x4:
elem_len = 8;
read_func = this.readF64;
break;
}
if (elem_len < len) {
var list;
var num_read;
var num_elems;
list = [];
num_read = 0;
num_elems = len / elem_len;
while (num_read < num_elems) {
list.push(read_func.call( this ) );
num_read ++;
}
return list;
}
else {
return read_func.call( this );
}
}
AWDLoader.prototype.readU8 = function () {
return this._data.getUint8( this._ptr ++ );
}
AWDLoader.prototype.readI8 = function () {
return this._data.getInt8( this._ptr ++ );
}
AWDLoader.prototype.readU16 = function () {
var a = this._data.getUint16( this._ptr, littleEndian );
this._ptr += 2;
return a;
}
AWDLoader.prototype.readI16 = function () {
var a = this._data.getInt16( this._ptr, littleEndian );
this._ptr += 2;
return a;
}
AWDLoader.prototype.readU32 = function () {
var a = this._data.getUint32( this._ptr, littleEndian );
this._ptr += 4;
return a;
}
AWDLoader.prototype.readI32 = function () {
var a = this._data.getInt32( this._ptr, littleEndian );
this._ptr += 4;
return a;
}
AWDLoader.prototype.readF32 = function () {
var a = this._data.getFloat32( this._ptr, littleEndian );
this._ptr += 4;
return a;
}
AWDLoader.prototype.readF64 = function () {
var a = this._data.getFloat64( this._ptr, littleEndian );
this._ptr += 8;
return a;
}
/**
* Converts a UTF-8 byte array to JavaScript's 16-bit Unicode.
* @param {Array.<number>} bytes UTF-8 byte array.
* @return {string} 16-bit Unicode string.
*/
AWDLoader.prototype.readUTF = function () {
var len = this.readU16();
return this.readUTFBytes( len );
};
/**
* Converts a UTF-8 byte array to JavaScript's 16-bit Unicode.
* @param {Array.<number>} bytes UTF-8 byte array.
* @return {string} 16-bit Unicode string.
*/
AWDLoader.prototype.readUTFBytes = function ( len ) {
// TODO(user): Use native implementations if/when available
var out = [], c = 0;
while ( out.length < len ) {
var c1 = this._data.getUint8( this._ptr ++, littleEndian );
if (c1 < 128) {
out[c ++] = String.fromCharCode(c1);
} else if (c1 > 191 && c1 < 224) {
var c2 = this._data.getUint8( this._ptr ++, littleEndian );
out[c ++] = String.fromCharCode((c1 & 31) << 6 | c2 & 63);
} else {
var c2 = this._data.getUint8( this._ptr ++, littleEndian );
var c3 = this._data.getUint8( this._ptr ++, littleEndian );
out[c ++] = String.fromCharCode(
(c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63
);
}
}
return out.join('');
};
AWDProperties = function() {}
AWDProperties.prototype = {
set : function(key, value)
{
this[key] = value;
},
get : function(key, fallback)
{
if ( this.hasOwnProperty(key) )
return this[key];
else return fallback;
}
}
return AWDLoader;
})();