Doodle3D-Slicer/three.js-master/examples/js/loaders/AWDLoader.js

/**
 * 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;

})();