Merge pull request #16496 from Mugen87/dev32

JSM: More modules and TS files for loaders.

docs/manual/en/introduction/Import-via-modules.html

@@ -111,13 +111,18 @@
 				</li>
 				<li>loaders
 					<ul>
+						<li>BabylonLoader</li>
 						<li>BVHLoader</li>
 						<li>ColladaLoader</li>
+						<li>DDSLoader</li>
+						<li>EXRLoader</li>
 						<li>FBXLoader</li>
 						<li>GLTFLoader</li>
 						<li>MTLLoader</li>
 						<li>OBJLoader</li>
 						<li>PCDLoader</li>
+						<li>PDBLoader</li>
+						<li>PlayCanvasLoader</li>
 						<li>PLYLoader</li>
 						<li>STLLoader</li>
 						<li>SVGLoader</li>

examples/js/loaders/EXRLoader.js

@@ -83,14 +83,14 @@ THREE.EXRLoader.prototype = Object.create( THREE.DataTextureLoader.prototype );
 
 THREE.EXRLoader.prototype._parser = function ( buffer ) {
 
-	const USHORT_RANGE = (1 << 16);
-	const BITMAP_SIZE = (USHORT_RANGE >> 3);
+	const USHORT_RANGE = ( 1 << 16 );
+	const BITMAP_SIZE = ( USHORT_RANGE >> 3 );
 
-	const HUF_ENCBITS = 16;  // literal (value) bit length
-	const HUF_DECBITS = 14;  // decoding bit size (>= 8)
+	const HUF_ENCBITS = 16; // literal (value) bit length
+	const HUF_DECBITS = 14; // decoding bit size (>= 8)
 
-	const HUF_ENCSIZE = (1 << HUF_ENCBITS) + 1;  // encoding table size
-	const HUF_DECSIZE = 1 << HUF_DECBITS;        // decoding table size
+	const HUF_ENCSIZE = ( 1 << HUF_ENCBITS ) + 1; // encoding table size
+	const HUF_DECSIZE = 1 << HUF_DECBITS; // decoding table size
 	const HUF_DECMASK = HUF_DECSIZE - 1;
 
 	const SHORT_ZEROCODE_RUN = 59;
@@ -157,6 +157,7 @@ THREE.EXRLoader.prototype._parser = function ( buffer ) {
 		getBitsReturn.l = ( c >> lc ) & ( ( 1 << nBits ) - 1 );
 		getBitsReturn.c = c;
 		getBitsReturn.lc = lc;
+
 	}
 
 	const hufTableBuffer = new Array( 59 );
@@ -249,9 +250,17 @@ THREE.EXRLoader.prototype._parser = function ( buffer ) {
 
 	}
 
-	function hufLength( code ) { return code & 63; }
+	function hufLength( code ) {
+
+		return code & 63;
+
+	}
 
-	function hufCode( code ) { return code >> 6; }
+	function hufCode( code ) {
+
+		return code >> 6;
+
+	}
 
 	function hufBuildDecTable( hcode, im, iM, hdecod ) {
 
@@ -355,7 +364,7 @@ THREE.EXRLoader.prototype._parser = function ( buffer ) {
 			lc -= 8;
 
 			var cs = ( c >> lc );
-			var cs = new Uint8Array([cs])[0];
+			var cs = new Uint8Array( [ cs ] )[ 0 ];
 
 			if ( outBufferOffset.value + cs > outBufferEndOffset ) {
 
@@ -365,7 +374,7 @@ THREE.EXRLoader.prototype._parser = function ( buffer ) {
 
 			var s = outBuffer[ outBufferOffset.value - 1 ];
 
-			while ( cs-- > 0 ) {
+			while ( cs -- > 0 ) {
 
 				outBuffer[ outBufferOffset.value ++ ] = s;
 
@@ -805,7 +814,7 @@ THREE.EXRLoader.prototype._parser = function ( buffer ) {
 
 	function parseUint32( dataView, offset ) {
 
-		var Uint32 = dataView.getUint32(offset.value, true);
+		var Uint32 = dataView.getUint32( offset.value, true );
 
 		offset.value = offset.value + INT32_SIZE;
 
@@ -815,7 +824,7 @@ THREE.EXRLoader.prototype._parser = function ( buffer ) {
 
 	function parseUint8Array( uInt8Array, offset ) {
 
-		var Uint8 = uInt8Array[offset.value];
+		var Uint8 = uInt8Array[ offset.value ];
 
 		offset.value = offset.value + INT8_SIZE;
 
@@ -825,7 +834,7 @@ THREE.EXRLoader.prototype._parser = function ( buffer ) {
 
 	function parseUint8( dataView, offset ) {
 
-		var Uint8 = dataView.getUint8(offset.value);
+		var Uint8 = dataView.getUint8( offset.value );
 
 		offset.value = offset.value + INT8_SIZE;
 
@@ -835,7 +844,7 @@ THREE.EXRLoader.prototype._parser = function ( buffer ) {
 
 	function parseFloat32( dataView, offset ) {
 
-		var float = dataView.getFloat32(offset.value, true);
+		var float = dataView.getFloat32( offset.value, true );
 
 		offset.value += FLOAT32_SIZE;
 
@@ -873,7 +882,7 @@ THREE.EXRLoader.prototype._parser = function ( buffer ) {
 
 	function parseFloat16( buffer, offset ) {
 
-		return decodeFloat16( parseUint16( buffer, offset) );
+		return decodeFloat16( parseUint16( buffer, offset ) );
 
 	}
 
@@ -1021,8 +1030,8 @@ THREE.EXRLoader.prototype._parser = function ( buffer ) {
 
 	}
 
-	var bufferDataView = new DataView(buffer);
-	var uInt8Array = new Uint8Array(buffer);
+	var bufferDataView = new DataView( buffer );
+	var uInt8Array = new Uint8Array( buffer );
 
 	var EXRHeader = {};
 

examples/jsm/loaders/BabylonLoader.d.ts

@@ -0,0 +1,14 @@
+import {
+  LoadingManager,
+  Scene
+} from '../../../src/Three';
+
+export class BabylonLoader {
+  constructor(manager?: LoadingManager);
+  manager: LoadingManager;
+  path: string;
+
+  load(url: string, onLoad: (scene: Scene) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
+  parse(json: object): Scene;
+  setPath(value: string): this;
+}

examples/jsm/loaders/BabylonLoader.js

@@ -0,0 +1,273 @@
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author Mugen87 / https://github.com/Mugen87
+ */
+
+import {
+	BufferGeometry,
+	DefaultLoadingManager,
+	DirectionalLight,
+	FileLoader,
+	Float32BufferAttribute,
+	Group,
+	HemisphereLight,
+	Mesh,
+	MeshPhongMaterial,
+	PerspectiveCamera,
+	PointLight,
+	Scene,
+	SpotLight
+} from "../../../build/three.module.js";
+
+var BabylonLoader = function ( manager ) {
+
+	this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;
+
+};
+
+BabylonLoader.prototype = {
+
+	constructor: BabylonLoader,
+
+	load: function ( url, onLoad, onProgress, onError ) {
+
+		var scope = this;
+
+		var loader = new FileLoader( scope.manager );
+		loader.setPath( scope.path );
+		loader.load( url, function ( text ) {
+
+			onLoad( scope.parse( JSON.parse( text ) ) );
+
+		}, onProgress, onError );
+
+	},
+
+	setPath: function ( value ) {
+
+		this.path = value;
+		return this;
+
+	},
+
+	parse: function ( json ) {
+
+		function parseMaterials( json ) {
+
+			var materials = {};
+
+			for ( var i = 0, l = json.materials.length; i < l; i ++ ) {
+
+				var data = json.materials[ i ];
+
+				var material = new MeshPhongMaterial();
+				material.name = data.name;
+				material.color.fromArray( data.diffuse );
+				material.emissive.fromArray( data.emissive );
+				material.specular.fromArray( data.specular );
+				material.shininess = data.specularPower;
+				material.opacity = data.alpha;
+
+				materials[ data.id ] = material;
+
+			}
+
+			if ( json.multiMaterials ) {
+
+				for ( var i = 0, l = json.multiMaterials.length; i < l; i ++ ) {
+
+					var data = json.multiMaterials[ i ];
+
+					console.warn( 'THREE.BabylonLoader: Multi materials not yet supported.' );
+
+					materials[ data.id ] = new MeshPhongMaterial();
+
+				}
+
+			}
+
+			return materials;
+
+		}
+
+		function parseGeometry( json ) {
+
+			var geometry = new BufferGeometry();
+
+			var indices = json.indices;
+			var positions = json.positions;
+			var normals = json.normals;
+			var uvs = json.uvs;
+
+			// indices
+
+			geometry.setIndex( indices );
+
+			// positions
+
+			for ( var j = 2, jl = positions.length; j < jl; j += 3 ) {
+
+				positions[ j ] = - positions[ j ];
+
+			}
+
+			geometry.addAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );
+
+			// normals
+
+			if ( normals ) {
+
+				for ( var j = 2, jl = normals.length; j < jl; j += 3 ) {
+
+					normals[ j ] = - normals[ j ];
+
+				}
+
+				geometry.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+
+			}
+
+			// uvs
+
+			if ( uvs ) {
+
+				geometry.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
+
+			}
+
+			// offsets
+
+			var subMeshes = json.subMeshes;
+
+			if ( subMeshes ) {
+
+				for ( var j = 0, jl = subMeshes.length; j < jl; j ++ ) {
+
+					var subMesh = subMeshes[ j ];
+
+					geometry.addGroup( subMesh.indexStart, subMesh.indexCount );
+
+				}
+
+			}
+
+			return geometry;
+
+		}
+
+		function parseObjects( json, materials ) {
+
+			var objects = {};
+			var scene = new Scene();
+
+			var cameras = json.cameras;
+
+			for ( var i = 0, l = cameras.length; i < l; i ++ ) {
+
+				var data = cameras[ i ];
+
+				var camera = new PerspectiveCamera( ( data.fov / Math.PI ) * 180, 1.33, data.minZ, data.maxZ );
+
+				camera.name = data.name;
+				camera.position.fromArray( data.position );
+				if ( data.rotation ) camera.rotation.fromArray( data.rotation );
+
+				objects[ data.id ] = camera;
+
+			}
+
+			var lights = json.lights;
+
+			for ( var i = 0, l = lights.length; i < l; i ++ ) {
+
+				var data = lights[ i ];
+
+				var light;
+
+				switch ( data.type ) {
+
+					case 0:
+						light = new PointLight();
+						break;
+
+					case 1:
+						light = new DirectionalLight();
+						break;
+
+					case 2:
+						light = new SpotLight();
+						break;
+
+					case 3:
+						light = new HemisphereLight();
+						break;
+
+				}
+
+				light.name = data.name;
+				if ( data.position ) light.position.set( data.position[ 0 ], data.position[ 1 ], - data.position[ 2 ] );
+				light.color.fromArray( data.diffuse );
+				if ( data.groundColor ) light.groundColor.fromArray( data.groundColor );
+				if ( data.intensity ) light.intensity = data.intensity;
+
+				objects[ data.id ] = light;
+
+				scene.add( light );
+
+			}
+
+			var meshes = json.meshes;
+
+			for ( var i = 0, l = meshes.length; i < l; i ++ ) {
+
+				var data = meshes[ i ];
+
+				var object;
+
+				if ( data.indices ) {
+
+					var geometry = parseGeometry( data );
+
+					object = new Mesh( geometry, materials[ data.materialId ] );
+
+				} else {
+
+					object = new Group();
+
+				}
+
+				object.name = data.name;
+				object.position.set( data.position[ 0 ], data.position[ 1 ], - data.position[ 2 ] );
+				object.rotation.fromArray( data.rotation );
+				if ( data.rotationQuaternion ) object.quaternion.fromArray( data.rotationQuaternion );
+				object.scale.fromArray( data.scaling );
+				// object.visible = data.isVisible;
+
+				if ( data.parentId ) {
+
+					objects[ data.parentId ].add( object );
+
+				} else {
+
+					scene.add( object );
+
+				}
+
+				objects[ data.id ] = object;
+
+			}
+
+			return scene;
+
+		}
+
+		var materials = parseMaterials( json );
+		var scene = parseObjects( json, materials );
+
+		return scene;
+
+	}
+
+};
+
+export { BabylonLoader };

examples/jsm/loaders/DDSLoader.d.ts

@@ -0,0 +1,21 @@
+import {
+  LoadingManager,
+  CompressedTextureLoader,
+  PixelFormat,
+  CompressedPixelFormat
+} from '../../../src/Three';
+
+export interface DDS {
+  mipmaps: object[];
+  width: number;
+  height: number;
+  format: PixelFormat | CompressedPixelFormat;
+  mipmapCount: number;
+	isCubemap: boolean;
+}
+
+export class DDSLoader extends CompressedTextureLoader {
+  constructor(manager?: LoadingManager);
+
+  parse(buffer: ArrayBuffer, loadMipmaps: boolean) : DDS;
+}

examples/jsm/loaders/DDSLoader.js

@@ -0,0 +1,283 @@
+/*
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+import {
+	CompressedTextureLoader,
+	RGBAFormat,
+	RGBA_S3TC_DXT3_Format,
+	RGBA_S3TC_DXT5_Format,
+	RGB_ETC1_Format,
+	RGB_S3TC_DXT1_Format
+} from "../../../build/three.module.js";
+
+var DDSLoader = function ( manager ) {
+
+	CompressedTextureLoader.call( this, manager );
+
+	this._parser = DDSLoader.parse;
+
+};
+
+DDSLoader.prototype = Object.create( CompressedTextureLoader.prototype );
+DDSLoader.prototype.constructor = DDSLoader;
+
+DDSLoader.parse = function ( buffer, loadMipmaps ) {
+
+	var dds = { mipmaps: [], width: 0, height: 0, format: null, mipmapCount: 1 };
+
+	// Adapted from @toji's DDS utils
+	// https://github.com/toji/webgl-texture-utils/blob/master/texture-util/dds.js
+
+	// All values and structures referenced from:
+	// http://msdn.microsoft.com/en-us/library/bb943991.aspx/
+
+	var DDS_MAGIC = 0x20534444;
+
+	var DDSD_CAPS = 0x1,
+		DDSD_HEIGHT = 0x2,
+		DDSD_WIDTH = 0x4,
+		DDSD_PITCH = 0x8,
+		DDSD_PIXELFORMAT = 0x1000,
+		DDSD_MIPMAPCOUNT = 0x20000,
+		DDSD_LINEARSIZE = 0x80000,
+		DDSD_DEPTH = 0x800000;
+
+	var DDSCAPS_COMPLEX = 0x8,
+		DDSCAPS_MIPMAP = 0x400000,
+		DDSCAPS_TEXTURE = 0x1000;
+
+	var DDSCAPS2_CUBEMAP = 0x200,
+		DDSCAPS2_CUBEMAP_POSITIVEX = 0x400,
+		DDSCAPS2_CUBEMAP_NEGATIVEX = 0x800,
+		DDSCAPS2_CUBEMAP_POSITIVEY = 0x1000,
+		DDSCAPS2_CUBEMAP_NEGATIVEY = 0x2000,
+		DDSCAPS2_CUBEMAP_POSITIVEZ = 0x4000,
+		DDSCAPS2_CUBEMAP_NEGATIVEZ = 0x8000,
+		DDSCAPS2_VOLUME = 0x200000;
+
+	var DDPF_ALPHAPIXELS = 0x1,
+		DDPF_ALPHA = 0x2,
+		DDPF_FOURCC = 0x4,
+		DDPF_RGB = 0x40,
+		DDPF_YUV = 0x200,
+		DDPF_LUMINANCE = 0x20000;
+
+	function fourCCToInt32( value ) {
+
+		return value.charCodeAt( 0 ) +
+			( value.charCodeAt( 1 ) << 8 ) +
+			( value.charCodeAt( 2 ) << 16 ) +
+			( value.charCodeAt( 3 ) << 24 );
+
+	}
+
+	function int32ToFourCC( value ) {
+
+		return String.fromCharCode(
+			value & 0xff,
+			( value >> 8 ) & 0xff,
+			( value >> 16 ) & 0xff,
+			( value >> 24 ) & 0xff
+		);
+
+	}
+
+	function loadARGBMip( buffer, dataOffset, width, height ) {
+
+		var dataLength = width * height * 4;
+		var srcBuffer = new Uint8Array( buffer, dataOffset, dataLength );
+		var byteArray = new Uint8Array( dataLength );
+		var dst = 0;
+		var src = 0;
+		for ( var y = 0; y < height; y ++ ) {
+
+			for ( var x = 0; x < width; x ++ ) {
+
+				var b = srcBuffer[ src ]; src ++;
+				var g = srcBuffer[ src ]; src ++;
+				var r = srcBuffer[ src ]; src ++;
+				var a = srcBuffer[ src ]; src ++;
+				byteArray[ dst ] = r; dst ++;	//r
+				byteArray[ dst ] = g; dst ++;	//g
+				byteArray[ dst ] = b; dst ++;	//b
+				byteArray[ dst ] = a; dst ++;	//a
+
+			}
+
+		}
+		return byteArray;
+
+	}
+
+	var FOURCC_DXT1 = fourCCToInt32( "DXT1" );
+	var FOURCC_DXT3 = fourCCToInt32( "DXT3" );
+	var FOURCC_DXT5 = fourCCToInt32( "DXT5" );
+	var FOURCC_ETC1 = fourCCToInt32( "ETC1" );
+
+	var headerLengthInt = 31; // The header length in 32 bit ints
+
+	// Offsets into the header array
+
+	var off_magic = 0;
+
+	var off_size = 1;
+	var off_flags = 2;
+	var off_height = 3;
+	var off_width = 4;
+
+	var off_mipmapCount = 7;
+
+	var off_pfFlags = 20;
+	var off_pfFourCC = 21;
+	var off_RGBBitCount = 22;
+	var off_RBitMask = 23;
+	var off_GBitMask = 24;
+	var off_BBitMask = 25;
+	var off_ABitMask = 26;
+
+	var off_caps = 27;
+	var off_caps2 = 28;
+	var off_caps3 = 29;
+	var off_caps4 = 30;
+
+	// Parse header
+
+	var header = new Int32Array( buffer, 0, headerLengthInt );
+
+	if ( header[ off_magic ] !== DDS_MAGIC ) {
+
+		console.error( 'THREE.DDSLoader.parse: Invalid magic number in DDS header.' );
+		return dds;
+
+	}
+
+	if ( ! header[ off_pfFlags ] & DDPF_FOURCC ) {
+
+		console.error( 'THREE.DDSLoader.parse: Unsupported format, must contain a FourCC code.' );
+		return dds;
+
+	}
+
+	var blockBytes;
+
+	var fourCC = header[ off_pfFourCC ];
+
+	var isRGBAUncompressed = false;
+
+	switch ( fourCC ) {
+
+		case FOURCC_DXT1:
+
+			blockBytes = 8;
+			dds.format = RGB_S3TC_DXT1_Format;
+			break;
+
+		case FOURCC_DXT3:
+
+			blockBytes = 16;
+			dds.format = RGBA_S3TC_DXT3_Format;
+			break;
+
+		case FOURCC_DXT5:
+
+			blockBytes = 16;
+			dds.format = RGBA_S3TC_DXT5_Format;
+			break;
+
+		case FOURCC_ETC1:
+
+			blockBytes = 8;
+			dds.format = RGB_ETC1_Format;
+			break;
+
+		default:
+
+			if ( header[ off_RGBBitCount ] === 32
+				&& header[ off_RBitMask ] & 0xff0000
+				&& header[ off_GBitMask ] & 0xff00
+				&& header[ off_BBitMask ] & 0xff
+				&& header[ off_ABitMask ] & 0xff000000 ) {
+
+				isRGBAUncompressed = true;
+				blockBytes = 64;
+				dds.format = RGBAFormat;
+
+			} else {
+
+				console.error( 'THREE.DDSLoader.parse: Unsupported FourCC code ', int32ToFourCC( fourCC ) );
+				return dds;
+
+			}
+
+	}
+
+	dds.mipmapCount = 1;
+
+	if ( header[ off_flags ] & DDSD_MIPMAPCOUNT && loadMipmaps !== false ) {
+
+		dds.mipmapCount = Math.max( 1, header[ off_mipmapCount ] );
+
+	}
+
+	var caps2 = header[ off_caps2 ];
+	dds.isCubemap = caps2 & DDSCAPS2_CUBEMAP ? true : false;
+	if ( dds.isCubemap && (
+		! ( caps2 & DDSCAPS2_CUBEMAP_POSITIVEX ) ||
+		! ( caps2 & DDSCAPS2_CUBEMAP_NEGATIVEX ) ||
+		! ( caps2 & DDSCAPS2_CUBEMAP_POSITIVEY ) ||
+		! ( caps2 & DDSCAPS2_CUBEMAP_NEGATIVEY ) ||
+		! ( caps2 & DDSCAPS2_CUBEMAP_POSITIVEZ ) ||
+		! ( caps2 & DDSCAPS2_CUBEMAP_NEGATIVEZ )
+	) ) {
+
+		console.error( 'THREE.DDSLoader.parse: Incomplete cubemap faces' );
+		return dds;
+
+	}
+
+	dds.width = header[ off_width ];
+	dds.height = header[ off_height ];
+
+	var dataOffset = header[ off_size ] + 4;
+
+	// Extract mipmaps buffers
+
+	var faces = dds.isCubemap ? 6 : 1;
+
+	for ( var face = 0; face < faces; face ++ ) {
+
+		var width = dds.width;
+		var height = dds.height;
+
+		for ( var i = 0; i < dds.mipmapCount; i ++ ) {
+
+			if ( isRGBAUncompressed ) {
+
+				var byteArray = loadARGBMip( buffer, dataOffset, width, height );
+				var dataLength = byteArray.length;
+
+			} else {
+
+				var dataLength = Math.max( 4, width ) / 4 * Math.max( 4, height ) / 4 * blockBytes;
+				var byteArray = new Uint8Array( buffer, dataOffset, dataLength );
+
+			}
+
+			var mipmap = { "data": byteArray, "width": width, "height": height };
+			dds.mipmaps.push( mipmap );
+
+			dataOffset += dataLength;
+
+			width = Math.max( width >> 1, 1 );
+			height = Math.max( height >> 1, 1 );
+
+		}
+
+	}
+
+	return dds;
+
+};
+
+export { DDSLoader };

examples/jsm/loaders/EXRLoader.d.ts

@@ -0,0 +1,21 @@
+import {
+  LoadingManager,
+  DataTextureLoader,
+  TextureDataType,
+  PixelFormat
+} from '../../../src/Three';
+
+export interface EXR {
+  header: object;
+  width: number;
+  height: number;
+  data: Float32Array;
+  format: PixelFormat;
+  type: TextureDataType;
+}
+
+export class EXRLoader extends DataTextureLoader {
+  constructor(manager?: LoadingManager);
+
+  parse(buffer: ArrayBuffer) : EXR;
+}

examples/jsm/loaders/EXRLoader.js

@@ -0,0 +1,1203 @@
+/**
+ * @author Richard M. / https://github.com/richardmonette
+ *
+ * OpenEXR loader which, currently, supports reading 16 bit half data, in either
+ * uncompressed or PIZ wavelet compressed form.
+ *
+ * Referred to the original Industrial Light & Magic OpenEXR implementation and the TinyEXR / Syoyo Fujita
+ * implementation, so I have preserved their copyright notices.
+ */
+
+import {
+	DataTextureLoader,
+	DefaultLoadingManager,
+	FloatType,
+	RGBAFormat,
+	RGBFormat
+} from "../../../build/three.module.js";
+
+// /*
+// Copyright (c) 2014 - 2017, Syoyo Fujita
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of the Syoyo Fujita nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// */
+
+// // TinyEXR contains some OpenEXR code, which is licensed under ------------
+
+// ///////////////////////////////////////////////////////////////////////////
+// //
+// // Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
+// // Digital Ltd. LLC
+// //
+// // All rights reserved.
+// //
+// // Redistribution and use in source and binary forms, with or without
+// // modification, are permitted provided that the following conditions are
+// // met:
+// // *       Redistributions of source code must retain the above copyright
+// // notice, this list of conditions and the following disclaimer.
+// // *       Redistributions in binary form must reproduce the above
+// // copyright notice, this list of conditions and the following disclaimer
+// // in the documentation and/or other materials provided with the
+// // distribution.
+// // *       Neither the name of Industrial Light & Magic nor the names of
+// // its contributors may be used to endorse or promote products derived
+// // from this software without specific prior written permission.
+// //
+// // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// //
+// ///////////////////////////////////////////////////////////////////////////
+
+// // End of OpenEXR license -------------------------------------------------
+
+var EXRLoader = function ( manager ) {
+
+	this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;
+
+};
+
+EXRLoader.prototype = Object.create( DataTextureLoader.prototype );
+
+EXRLoader.prototype._parser = function ( buffer ) {
+
+	const USHORT_RANGE = ( 1 << 16 );
+	const BITMAP_SIZE = ( USHORT_RANGE >> 3 );
+
+	const HUF_ENCBITS = 16; // literal (value) bit length
+	const HUF_DECBITS = 14; // decoding bit size (>= 8)
+
+	const HUF_ENCSIZE = ( 1 << HUF_ENCBITS ) + 1; // encoding table size
+	const HUF_DECSIZE = 1 << HUF_DECBITS; // decoding table size
+	const HUF_DECMASK = HUF_DECSIZE - 1;
+
+	const SHORT_ZEROCODE_RUN = 59;
+	const LONG_ZEROCODE_RUN = 63;
+	const SHORTEST_LONG_RUN = 2 + LONG_ZEROCODE_RUN - SHORT_ZEROCODE_RUN;
+	const LONGEST_LONG_RUN = 255 + SHORTEST_LONG_RUN;
+
+	const BYTES_PER_HALF = 2;
+
+	const ULONG_SIZE = 8;
+	const FLOAT32_SIZE = 4;
+	const INT32_SIZE = 4;
+	const INT16_SIZE = 2;
+	const INT8_SIZE = 1;
+
+	function reverseLutFromBitmap( bitmap, lut ) {
+
+		var k = 0;
+
+		for ( var i = 0; i < USHORT_RANGE; ++ i ) {
+
+			if ( ( i == 0 ) || ( bitmap[ i >> 3 ] & ( 1 << ( i & 7 ) ) ) ) {
+
+				lut[ k ++ ] = i;
+
+			}
+
+		}
+
+		var n = k - 1;
+
+		while ( k < USHORT_RANGE ) lut[ k ++ ] = 0;
+
+		return n;
+
+	}
+
+	function hufClearDecTable( hdec ) {
+
+		for ( var i = 0; i < HUF_DECSIZE; i ++ ) {
+
+			hdec[ i ] = {};
+			hdec[ i ].len = 0;
+			hdec[ i ].lit = 0;
+			hdec[ i ].p = null;
+
+		}
+
+	}
+
+	const getBitsReturn = { l: 0, c: 0, lc: 0 };
+
+	function getBits( nBits, c, lc, uInt8Array, inOffset ) {
+
+		while ( lc < nBits ) {
+
+			c = ( c << 8 ) | parseUint8Array( uInt8Array, inOffset );
+			lc += 8;
+
+		}
+
+		lc -= nBits;
+
+		getBitsReturn.l = ( c >> lc ) & ( ( 1 << nBits ) - 1 );
+		getBitsReturn.c = c;
+		getBitsReturn.lc = lc;
+
+	}
+
+	const hufTableBuffer = new Array( 59 );
+
+	function hufCanonicalCodeTable( hcode ) {
+
+		for ( var i = 0; i <= 58; ++ i ) hufTableBuffer[ i ] = 0;
+		for ( var i = 0; i < HUF_ENCSIZE; ++ i ) hufTableBuffer[ hcode[ i ] ] += 1;
+
+		var c = 0;
+
+		for ( var i = 58; i > 0; -- i ) {
+
+			var nc = ( ( c + hufTableBuffer[ i ] ) >> 1 );
+			hufTableBuffer[ i ] = c;
+			c = nc;
+
+		}
+
+		for ( var i = 0; i < HUF_ENCSIZE; ++ i ) {
+
+			var l = hcode[ i ];
+			if ( l > 0 ) hcode[ i ] = l | ( hufTableBuffer[ l ] ++ << 6 );
+
+		}
+
+	}
+
+	function hufUnpackEncTable( uInt8Array, inDataView, inOffset, ni, im, iM, hcode ) {
+
+		var p = inOffset;
+		var c = 0;
+		var lc = 0;
+
+		for ( ; im <= iM; im ++ ) {
+
+			if ( p.value - inOffset.value > ni ) return false;
+
+			getBits( 6, c, lc, uInt8Array, p );
+
+			var l = getBitsReturn.l;
+			c = getBitsReturn.c;
+			lc = getBitsReturn.lc;
+
+			hcode[ im ] = l;
+
+			if ( l == LONG_ZEROCODE_RUN ) {
+
+				if ( p.value - inOffset.value > ni ) {
+
+					throw 'Something wrong with hufUnpackEncTable';
+
+				}
+
+				getBits( 8, c, lc, uInt8Array, p );
+
+				var zerun = getBitsReturn.l + SHORTEST_LONG_RUN;
+				c = getBitsReturn.c;
+				lc = getBitsReturn.lc;
+
+				if ( im + zerun > iM + 1 ) {
+
+					throw 'Something wrong with hufUnpackEncTable';
+
+				}
+
+				while ( zerun -- ) hcode[ im ++ ] = 0;
+
+				im --;
+
+			} else if ( l >= SHORT_ZEROCODE_RUN ) {
+
+				var zerun = l - SHORT_ZEROCODE_RUN + 2;
+
+				if ( im + zerun > iM + 1 ) {
+
+					throw 'Something wrong with hufUnpackEncTable';
+
+				}
+
+				while ( zerun -- ) hcode[ im ++ ] = 0;
+
+				im --;
+
+			}
+
+		}
+
+		hufCanonicalCodeTable( hcode );
+
+	}
+
+	function hufLength( code ) {
+
+		return code & 63;
+
+	}
+
+	function hufCode( code ) {
+
+		return code >> 6;
+
+	}
+
+	function hufBuildDecTable( hcode, im, iM, hdecod ) {
+
+		for ( ; im <= iM; im ++ ) {
+
+			var c = hufCode( hcode[ im ] );
+			var l = hufLength( hcode[ im ] );
+
+			if ( c >> l ) {
+
+				throw 'Invalid table entry';
+
+			}
+
+			if ( l > HUF_DECBITS ) {
+
+				var pl = hdecod[ ( c >> ( l - HUF_DECBITS ) ) ];
+
+				if ( pl.len ) {
+
+					throw 'Invalid table entry';
+
+				}
+
+				pl.lit ++;
+
+				if ( pl.p ) {
+
+					var p = pl.p;
+					pl.p = new Array( pl.lit );
+
+					for ( var i = 0; i < pl.lit - 1; ++ i ) {
+
+						pl.p[ i ] = p[ i ];
+
+					}
+
+				} else {
+
+					pl.p = new Array( 1 );
+
+				}
+
+				pl.p[ pl.lit - 1 ] = im;
+
+			} else if ( l ) {
+
+				var plOffset = 0;
+
+				for ( var i = 1 << ( HUF_DECBITS - l ); i > 0; i -- ) {
+
+					var pl = hdecod[ ( c << ( HUF_DECBITS - l ) ) + plOffset ];
+
+					if ( pl.len || pl.p ) {
+
+						throw 'Invalid table entry';
+
+					}
+
+					pl.len = l;
+					pl.lit = im;
+
+					plOffset ++;
+
+				}
+
+			}
+
+		}
+
+		return true;
+
+	}
+
+	const getCharReturn = { c: 0, lc: 0 };
+
+	function getChar( c, lc, uInt8Array, inOffset ) {
+
+		c = ( c << 8 ) | parseUint8Array( uInt8Array, inOffset );
+		lc += 8;
+
+		getCharReturn.c = c;
+		getCharReturn.lc = lc;
+
+	}
+
+	const getCodeReturn = { c: 0, lc: 0 };
+
+	function getCode( po, rlc, c, lc, uInt8Array, inDataView, inOffset, outBuffer, outBufferOffset, outBufferEndOffset ) {
+
+		if ( po == rlc ) {
+
+			if ( lc < 8 ) {
+
+				getChar( c, lc, uInt8Array, inOffset );
+				c = getCharReturn.c;
+				lc = getCharReturn.lc;
+
+			}
+
+			lc -= 8;
+
+			var cs = ( c >> lc );
+			var cs = new Uint8Array( [ cs ] )[ 0 ];
+
+			if ( outBufferOffset.value + cs > outBufferEndOffset ) {
+
+				return false;
+
+			}
+
+			var s = outBuffer[ outBufferOffset.value - 1 ];
+
+			while ( cs -- > 0 ) {
+
+				outBuffer[ outBufferOffset.value ++ ] = s;
+
+			}
+
+		} else if ( outBufferOffset.value < outBufferEndOffset ) {
+
+			outBuffer[ outBufferOffset.value ++ ] = po;
+
+		} else {
+
+			return false;
+
+		}
+
+		getCodeReturn.c = c;
+		getCodeReturn.lc = lc;
+
+	}
+
+	var NBITS = 16;
+	var A_OFFSET = 1 << ( NBITS - 1 );
+	var M_OFFSET = 1 << ( NBITS - 1 );
+	var MOD_MASK = ( 1 << NBITS ) - 1;
+
+	function UInt16( value ) {
+
+		return ( value & 0xFFFF );
+
+	}
+
+	function Int16( value ) {
+
+		var ref = UInt16( value );
+		return ( ref > 0x7FFF ) ? ref - 0x10000 : ref;
+
+	}
+
+	const wdec14Return = { a: 0, b: 0 };
+
+	function wdec14( l, h ) {
+
+		var ls = Int16( l );
+		var hs = Int16( h );
+
+		var hi = hs;
+		var ai = ls + ( hi & 1 ) + ( hi >> 1 );
+
+		var as = ai;
+		var bs = ai - hi;
+
+		wdec14Return.a = as;
+		wdec14Return.b = bs;
+
+	}
+
+	function wav2Decode( j, buffer, nx, ox, ny, oy, mx ) {
+
+		var n = ( nx > ny ) ? ny : nx;
+		var p = 1;
+		var p2;
+
+		while ( p <= n ) p <<= 1;
+
+		p >>= 1;
+		p2 = p;
+		p >>= 1;
+
+		while ( p >= 1 ) {
+
+			var py = 0;
+			var ey = py + oy * ( ny - p2 );
+			var oy1 = oy * p;
+			var oy2 = oy * p2;
+			var ox1 = ox * p;
+			var ox2 = ox * p2;
+			var i00, i01, i10, i11;
+
+			for ( ; py <= ey; py += oy2 ) {
+
+				var px = py;
+				var ex = py + ox * ( nx - p2 );
+
+				for ( ; px <= ex; px += ox2 ) {
+
+					var p01 = px + ox1;
+					var p10 = px + oy1;
+					var p11 = p10 + ox1;
+
+					wdec14( buffer[ px + j ], buffer[ p10 + j ] );
+
+					i00 = wdec14Return.a;
+					i10 = wdec14Return.b;
+
+					wdec14( buffer[ p01 + j ], buffer[ p11 + j ] );
+
+					i01 = wdec14Return.a;
+					i11 = wdec14Return.b;
+
+					wdec14( i00, i01 );
+
+					buffer[ px + j ] = wdec14Return.a;
+					buffer[ p01 + j ] = wdec14Return.b;
+
+					wdec14( i10, i11 );
+
+					buffer[ p10 + j ] = wdec14Return.a;
+					buffer[ p11 + j ] = wdec14Return.b;
+
+				}
+
+				if ( nx & p ) {
+
+					var p10 = px + oy1;
+
+					wdec14( buffer[ px + j ], buffer[ p10 + j ] );
+
+					i00 = wdec14Return.a;
+					buffer[ p10 + j ] = wdec14Return.b;
+
+					buffer[ px + j ] = i00;
+
+				}
+
+			}
+
+			if ( ny & p ) {
+
+				var px = py;
+				var ex = py + ox * ( nx - p2 );
+
+				for ( ; px <= ex; px += ox2 ) {
+
+					var p01 = px + ox1;
+
+					wdec14( buffer[ px + j ], buffer[ p01 + j ] );
+
+					i00 = wdec14Return.a;
+					buffer[ p01 + j ] = wdec14Return.b;
+
+					buffer[ px + j ] = i00;
+
+				}
+
+			}
+
+			p2 = p;
+			p >>= 1;
+
+		}
+
+		return py;
+
+	}
+
+	function hufDecode( encodingTable, decodingTable, uInt8Array, inDataView, inOffset, ni, rlc, no, outBuffer, outOffset ) {
+
+		var c = 0;
+		var lc = 0;
+		var outBufferEndOffset = no;
+		var inOffsetEnd = Math.trunc( inOffset.value + ( ni + 7 ) / 8 );
+
+		while ( inOffset.value < inOffsetEnd ) {
+
+			getChar( c, lc, uInt8Array, inOffset );
+
+			c = getCharReturn.c;
+			lc = getCharReturn.lc;
+
+			while ( lc >= HUF_DECBITS ) {
+
+				var index = ( c >> ( lc - HUF_DECBITS ) ) & HUF_DECMASK;
+				var pl = decodingTable[ index ];
+
+				if ( pl.len ) {
+
+					lc -= pl.len;
+
+					getCode( pl.lit, rlc, c, lc, uInt8Array, inDataView, inOffset, outBuffer, outOffset, outBufferEndOffset );
+
+					c = getCodeReturn.c;
+					lc = getCodeReturn.lc;
+
+				} else {
+
+					if ( ! pl.p ) {
+
+						throw 'hufDecode issues';
+
+					}
+
+					var j;
+
+					for ( j = 0; j < pl.lit; j ++ ) {
+
+						var l = hufLength( encodingTable[ pl.p[ j ] ] );
+
+						while ( lc < l && inOffset.value < inOffsetEnd ) {
+
+							getChar( c, lc, uInt8Array, inOffset );
+
+							c = getCharReturn.c;
+							lc = getCharReturn.lc;
+
+						}
+
+						if ( lc >= l ) {
+
+							if ( hufCode( encodingTable[ pl.p[ j ] ] ) == ( ( c >> ( lc - l ) ) & ( ( 1 << l ) - 1 ) ) ) {
+
+								lc -= l;
+
+								getCode( pl.p[ j ], rlc, c, lc, uInt8Array, inDataView, inOffset, outBuffer, outOffset, outBufferEndOffset );
+
+								c = getCodeReturn.c;
+								lc = getCodeReturn.lc;
+
+								break;
+
+							}
+
+						}
+
+					}
+
+					if ( j == pl.lit ) {
+
+						throw 'hufDecode issues';
+
+					}
+
+				}
+
+			}
+
+		}
+
+		var i = ( 8 - ni ) & 7;
+
+		c >>= i;
+		lc -= i;
+
+		while ( lc > 0 ) {
+
+			var pl = decodingTable[ ( c << ( HUF_DECBITS - lc ) ) & HUF_DECMASK ];
+
+			if ( pl.len ) {
+
+				lc -= pl.len;
+
+				getCode( pl.lit, rlc, c, lc, uInt8Array, inDataView, inOffset, outBuffer, outOffset, outBufferEndOffset );
+
+				c = getCodeReturn.c;
+				lc = getCodeReturn.lc;
+
+			} else {
+
+				throw 'hufDecode issues';
+
+			}
+
+		}
+
+		return true;
+
+	}
+
+	function hufUncompress( uInt8Array, inDataView, inOffset, nCompressed, outBuffer, outOffset, nRaw ) {
+
+		var initialInOffset = inOffset.value;
+
+		var im = parseUint32( inDataView, inOffset );
+		var iM = parseUint32( inDataView, inOffset );
+
+		inOffset.value += 4;
+
+		var nBits = parseUint32( inDataView, inOffset );
+
+		inOffset.value += 4;
+
+		if ( im < 0 || im >= HUF_ENCSIZE || iM < 0 || iM >= HUF_ENCSIZE ) {
+
+			throw 'Something wrong with HUF_ENCSIZE';
+
+		}
+
+		var freq = new Array( HUF_ENCSIZE );
+		var hdec = new Array( HUF_DECSIZE );
+
+		hufClearDecTable( hdec );
+
+		var ni = nCompressed - ( inOffset.value - initialInOffset );
+
+		hufUnpackEncTable( uInt8Array, inDataView, inOffset, ni, im, iM, freq );
+
+		if ( nBits > 8 * ( nCompressed - ( inOffset.value - initialInOffset ) ) ) {
+
+			throw 'Something wrong with hufUncompress';
+
+		}
+
+		hufBuildDecTable( freq, im, iM, hdec );
+
+		hufDecode( freq, hdec, uInt8Array, inDataView, inOffset, nBits, iM, nRaw, outBuffer, outOffset );
+
+	}
+
+	function applyLut( lut, data, nData ) {
+
+		for ( var i = 0; i < nData; ++ i ) {
+
+			data[ i ] = lut[ data[ i ] ];
+
+		}
+
+	}
+
+	function decompressPIZ( outBuffer, outOffset, uInt8Array, inDataView, inOffset, tmpBufSize, num_channels, exrChannelInfos, dataWidth, num_lines ) {
+
+		var bitmap = new Uint8Array( BITMAP_SIZE );
+
+		var minNonZero = parseUint16( inDataView, inOffset );
+		var maxNonZero = parseUint16( inDataView, inOffset );
+
+		if ( maxNonZero >= BITMAP_SIZE ) {
+
+			throw 'Something is wrong with PIZ_COMPRESSION BITMAP_SIZE';
+
+		}
+
+		if ( minNonZero <= maxNonZero ) {
+
+			for ( var i = 0; i < maxNonZero - minNonZero + 1; i ++ ) {
+
+				bitmap[ i + minNonZero ] = parseUint8( inDataView, inOffset );
+
+			}
+
+		}
+
+		var lut = new Uint16Array( USHORT_RANGE );
+		var maxValue = reverseLutFromBitmap( bitmap, lut );
+
+		var length = parseUint32( inDataView, inOffset );
+
+		hufUncompress( uInt8Array, inDataView, inOffset, length, outBuffer, outOffset, tmpBufSize );
+
+		var pizChannelData = new Array( num_channels );
+
+		var outBufferEnd = 0;
+
+		for ( var i = 0; i < num_channels; i ++ ) {
+
+			var exrChannelInfo = exrChannelInfos[ i ];
+
+			var pixelSize = 2; // assumes HALF_FLOAT
+
+			pizChannelData[ i ] = {};
+			pizChannelData[ i ][ 'start' ] = outBufferEnd;
+			pizChannelData[ i ][ 'end' ] = pizChannelData[ i ][ 'start' ];
+			pizChannelData[ i ][ 'nx' ] = dataWidth;
+			pizChannelData[ i ][ 'ny' ] = num_lines;
+			pizChannelData[ i ][ 'size' ] = 1;
+
+			outBufferEnd += pizChannelData[ i ].nx * pizChannelData[ i ].ny * pizChannelData[ i ].size;
+
+		}
+
+		var fooOffset = 0;
+
+		for ( var i = 0; i < num_channels; i ++ ) {
+
+			for ( var j = 0; j < pizChannelData[ i ].size; ++ j ) {
+
+				fooOffset += wav2Decode(
+					j + fooOffset,
+					outBuffer,
+					pizChannelData[ i ].nx,
+					pizChannelData[ i ].size,
+					pizChannelData[ i ].ny,
+					pizChannelData[ i ].nx * pizChannelData[ i ].size,
+					maxValue
+				);
+
+			}
+
+		}
+
+		applyLut( lut, outBuffer, outBufferEnd );
+
+		return true;
+
+	}
+
+	function parseNullTerminatedString( buffer, offset ) {
+
+		var uintBuffer = new Uint8Array( buffer );
+		var endOffset = 0;
+
+		while ( uintBuffer[ offset.value + endOffset ] != 0 ) {
+
+			endOffset += 1;
+
+		}
+
+		var stringValue = new TextDecoder().decode(
+			uintBuffer.slice( offset.value, offset.value + endOffset )
+		);
+
+		offset.value = offset.value + endOffset + 1;
+
+		return stringValue;
+
+	}
+
+	function parseFixedLengthString( buffer, offset, size ) {
+
+		var stringValue = new TextDecoder().decode(
+			new Uint8Array( buffer ).slice( offset.value, offset.value + size )
+		);
+
+		offset.value = offset.value + size;
+
+		return stringValue;
+
+	}
+
+	function parseUlong( dataView, offset ) {
+
+		var uLong = dataView.getUint32( 0, true );
+
+		offset.value = offset.value + ULONG_SIZE;
+
+		return uLong;
+
+	}
+
+	function parseUint32( dataView, offset ) {
+
+		var Uint32 = dataView.getUint32( offset.value, true );
+
+		offset.value = offset.value + INT32_SIZE;
+
+		return Uint32;
+
+	}
+
+	function parseUint8Array( uInt8Array, offset ) {
+
+		var Uint8 = uInt8Array[ offset.value ];
+
+		offset.value = offset.value + INT8_SIZE;
+
+		return Uint8;
+
+	}
+
+	function parseUint8( dataView, offset ) {
+
+		var Uint8 = dataView.getUint8( offset.value );
+
+		offset.value = offset.value + INT8_SIZE;
+
+		return Uint8;
+
+	}
+
+	function parseFloat32( dataView, offset ) {
+
+		var float = dataView.getFloat32( offset.value, true );
+
+		offset.value += FLOAT32_SIZE;
+
+		return float;
+
+	}
+
+	// https://stackoverflow.com/questions/5678432/decompressing-half-precision-floats-in-javascript
+	function decodeFloat16( binary ) {
+
+		var exponent = ( binary & 0x7C00 ) >> 10,
+			fraction = binary & 0x03FF;
+
+		return ( binary >> 15 ? - 1 : 1 ) * (
+			exponent ?
+				(
+					exponent === 0x1F ?
+						fraction ? NaN : Infinity :
+						Math.pow( 2, exponent - 15 ) * ( 1 + fraction / 0x400 )
+				) :
+				6.103515625e-5 * ( fraction / 0x400 )
+		);
+
+	}
+
+	function parseUint16( dataView, offset ) {
+
+		var Uint16 = dataView.getUint16( offset.value, true );
+
+		offset.value += INT16_SIZE;
+
+		return Uint16;
+
+	}
+
+	function parseFloat16( buffer, offset ) {
+
+		return decodeFloat16( parseUint16( buffer, offset ) );
+
+	}
+
+	function parseChlist( dataView, buffer, offset, size ) {
+
+		var startOffset = offset.value;
+		var channels = [];
+
+		while ( offset.value < ( startOffset + size - 1 ) ) {
+
+			var name = parseNullTerminatedString( buffer, offset );
+			var pixelType = parseUint32( dataView, offset ); // TODO: Cast this to UINT, HALF or FLOAT
+			var pLinear = parseUint8( dataView, offset );
+			offset.value += 3; // reserved, three chars
+			var xSampling = parseUint32( dataView, offset );
+			var ySampling = parseUint32( dataView, offset );
+
+			channels.push( {
+				name: name,
+				pixelType: pixelType,
+				pLinear: pLinear,
+				xSampling: xSampling,
+				ySampling: ySampling
+			} );
+
+		}
+
+		offset.value += 1;
+
+		return channels;
+
+	}
+
+	function parseChromaticities( dataView, offset ) {
+
+		var redX = parseFloat32( dataView, offset );
+		var redY = parseFloat32( dataView, offset );
+		var greenX = parseFloat32( dataView, offset );
+		var greenY = parseFloat32( dataView, offset );
+		var blueX = parseFloat32( dataView, offset );
+		var blueY = parseFloat32( dataView, offset );
+		var whiteX = parseFloat32( dataView, offset );
+		var whiteY = parseFloat32( dataView, offset );
+
+		return { redX: redX, redY: redY, greenX: greenX, greenY: greenY, blueX: blueX, blueY: blueY, whiteX: whiteX, whiteY: whiteY };
+
+	}
+
+	function parseCompression( dataView, offset ) {
+
+		var compressionCodes = [
+			'NO_COMPRESSION',
+			'RLE_COMPRESSION',
+			'ZIPS_COMPRESSION',
+			'ZIP_COMPRESSION',
+			'PIZ_COMPRESSION',
+			'PXR24_COMPRESSION',
+			'B44_COMPRESSION',
+			'B44A_COMPRESSION',
+			'DWAA_COMPRESSION',
+			'DWAB_COMPRESSION'
+		];
+
+		var compression = parseUint8( dataView, offset );
+
+		return compressionCodes[ compression ];
+
+	}
+
+	function parseBox2i( dataView, offset ) {
+
+		var xMin = parseUint32( dataView, offset );
+		var yMin = parseUint32( dataView, offset );
+		var xMax = parseUint32( dataView, offset );
+		var yMax = parseUint32( dataView, offset );
+
+		return { xMin: xMin, yMin: yMin, xMax: xMax, yMax: yMax };
+
+	}
+
+	function parseLineOrder( dataView, offset ) {
+
+		var lineOrders = [
+			'INCREASING_Y'
+		];
+
+		var lineOrder = parseUint8( dataView, offset );
+
+		return lineOrders[ lineOrder ];
+
+	}
+
+	function parseV2f( dataView, offset ) {
+
+		var x = parseFloat32( dataView, offset );
+		var y = parseFloat32( dataView, offset );
+
+		return [ x, y ];
+
+	}
+
+	function parseValue( dataView, buffer, offset, type, size ) {
+
+		if ( type === 'string' || type === 'iccProfile' ) {
+
+			return parseFixedLengthString( buffer, offset, size );
+
+		} else if ( type === 'chlist' ) {
+
+			return parseChlist( dataView, buffer, offset, size );
+
+		} else if ( type === 'chromaticities' ) {
+
+			return parseChromaticities( dataView, offset );
+
+		} else if ( type === 'compression' ) {
+
+			return parseCompression( dataView, offset );
+
+		} else if ( type === 'box2i' ) {
+
+			return parseBox2i( dataView, offset );
+
+		} else if ( type === 'lineOrder' ) {
+
+			return parseLineOrder( dataView, offset );
+
+		} else if ( type === 'float' ) {
+
+			return parseFloat32( dataView, offset );
+
+		} else if ( type === 'v2f' ) {
+
+			return parseV2f( dataView, offset );
+
+		} else if ( type === 'int' ) {
+
+			return parseUint32( dataView, offset );
+
+		} else {
+
+			throw 'Cannot parse value for unsupported type: ' + type;
+
+		}
+
+	}
+
+	var bufferDataView = new DataView( buffer );
+	var uInt8Array = new Uint8Array( buffer );
+
+	var EXRHeader = {};
+
+	var magic = bufferDataView.getUint32( 0, true );
+	var versionByteZero = bufferDataView.getUint8( 4, true );
+	var fullMask = bufferDataView.getUint8( 5, true );
+
+	// start of header
+
+	var offset = { value: 8 }; // start at 8, after magic stuff
+
+	var keepReading = true;
+
+	while ( keepReading ) {
+
+		var attributeName = parseNullTerminatedString( buffer, offset );
+
+		if ( attributeName == 0 ) {
+
+			keepReading = false;
+
+		} else {
+
+			var attributeType = parseNullTerminatedString( buffer, offset );
+			var attributeSize = parseUint32( bufferDataView, offset );
+			var attributeValue = parseValue( bufferDataView, buffer, offset, attributeType, attributeSize );
+
+			EXRHeader[ attributeName ] = attributeValue;
+
+		}
+
+	}
+
+	// offsets
+
+	var dataWindowHeight = EXRHeader.dataWindow.yMax + 1;
+	var scanlineBlockSize = 1; // 1 for NO_COMPRESSION
+
+	if ( EXRHeader.compression === 'PIZ_COMPRESSION' ) {
+
+		scanlineBlockSize = 32;
+
+	}
+
+	var numBlocks = dataWindowHeight / scanlineBlockSize;
+
+	for ( var i = 0; i < numBlocks; i ++ ) {
+
+		var scanlineOffset = parseUlong( bufferDataView, offset );
+
+	}
+
+	// we should be passed the scanline offset table, start reading pixel data
+
+	var width = EXRHeader.dataWindow.xMax - EXRHeader.dataWindow.xMin + 1;
+	var height = EXRHeader.dataWindow.yMax - EXRHeader.dataWindow.yMin + 1;
+	var numChannels = EXRHeader.channels.length;
+
+	var byteArray = new Float32Array( width * height * numChannels );
+
+	var channelOffsets = {
+		R: 0,
+		G: 1,
+		B: 2,
+		A: 3
+	};
+
+	if ( EXRHeader.compression === 'NO_COMPRESSION' ) {
+
+		for ( var y = 0; y < height; y ++ ) {
+
+			var y_scanline = parseUint32( bufferDataView, offset );
+			var dataSize = parseUint32( bufferDataView, offset );
+
+			for ( var channelID = 0; channelID < EXRHeader.channels.length; channelID ++ ) {
+
+				var cOff = channelOffsets[ EXRHeader.channels[ channelID ].name ];
+
+				if ( EXRHeader.channels[ channelID ].pixelType === 1 ) {
+
+					// HALF
+					for ( var x = 0; x < width; x ++ ) {
+
+						var val = parseFloat16( bufferDataView, offset );
+
+						byteArray[ ( ( ( height - y_scanline ) * ( width * numChannels ) ) + ( x * numChannels ) ) + cOff ] = val;
+
+					}
+
+				} else {
+
+					throw 'EXRLoader._parser: unsupported pixelType ' + EXRHeader.channels[ channelID ].pixelType + '. Only pixelType is 1 (HALF) is supported.';
+
+				}
+
+			}
+
+		}
+
+	} else if ( EXRHeader.compression === 'PIZ_COMPRESSION' ) {
+
+		for ( var scanlineBlockIdx = 0; scanlineBlockIdx < height / scanlineBlockSize; scanlineBlockIdx ++ ) {
+
+			var line_no = parseUint32( bufferDataView, offset );
+			var data_len = parseUint32( bufferDataView, offset );
+
+			var tmpBufferSize = width * scanlineBlockSize * ( EXRHeader.channels.length * BYTES_PER_HALF );
+			var tmpBuffer = new Uint16Array( tmpBufferSize );
+			var tmpOffset = { value: 0 };
+
+			decompressPIZ( tmpBuffer, tmpOffset, uInt8Array, bufferDataView, offset, tmpBufferSize, numChannels, EXRHeader.channels, width, scanlineBlockSize );
+
+			for ( var line_y = 0; line_y < scanlineBlockSize; line_y ++ ) {
+
+				for ( var channelID = 0; channelID < EXRHeader.channels.length; channelID ++ ) {
+
+					var cOff = channelOffsets[ EXRHeader.channels[ channelID ].name ];
+
+					if ( EXRHeader.channels[ channelID ].pixelType === 1 ) {
+
+						// HALF
+						for ( var x = 0; x < width; x ++ ) {
+
+							var val = decodeFloat16( tmpBuffer[ ( channelID * ( scanlineBlockSize * width ) ) + ( line_y * width ) + x ] );
+
+							var true_y = line_y + ( scanlineBlockIdx * scanlineBlockSize );
+
+							byteArray[ ( ( ( height - true_y ) * ( width * numChannels ) ) + ( x * numChannels ) ) + cOff ] = val;
+
+						}
+
+					} else {
+
+						throw 'EXRLoader._parser: unsupported pixelType ' + EXRHeader.channels[ channelID ].pixelType + '. Only pixelType is 1 (HALF) is supported.';
+
+					}
+
+				}
+
+			}
+
+		}
+
+	} else {
+
+		throw 'EXRLoader._parser: ' + EXRHeader.compression + ' is unsupported';
+
+	}
+
+	return {
+		header: EXRHeader,
+		width: width,
+		height: height,
+		data: byteArray,
+		format: EXRHeader.channels.length == 4 ? RGBAFormat : RGBFormat,
+		type: FloatType
+	};
+
+};
+
+export { EXRLoader };

examples/jsm/loaders/PDBLoader.d.ts

@@ -0,0 +1,25 @@
+import {
+  BufferGeometry,
+  LoadingManager
+} from '../../../src/Three';
+
+export interface PDB {
+  geometryAtoms: BufferGeometry;
+  geometryBonds: BufferGeometry;
+  json: {
+    atoms: any[][],
+    bonds: number[][]
+  }
+}
+
+
+export class PDBLoader {
+  constructor(manager?: LoadingManager);
+  manager: LoadingManager;
+  path: string;
+
+  load(url: string, onLoad: (pdb: PDB) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
+  setPath(path: string) : this;
+
+  parse(text: string) : PDB;
+}

examples/jsm/loaders/PlayCanvasLoader.d.ts

@@ -0,0 +1,14 @@
+import {
+  LoadingManager,
+  Group
+} from '../../../src/Three';
+
+export class PlayCanvasLoader {
+  constructor(manager?: LoadingManager);
+  manager: LoadingManager;
+  path: string;
+
+  load(url: string, onLoad: (group: Group) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
+  parse(json: object): Group;
+  setPath(value: string): this;
+}

examples/jsm/loaders/PlayCanvasLoader.js

@@ -0,0 +1,218 @@
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author Mugen87 / https://github.com/Mugen87
+ */
+
+import {
+	BufferGeometry,
+	DefaultLoadingManager,
+	Euler,
+	FileLoader,
+	Float32BufferAttribute,
+	Group,
+	Mesh,
+	MeshPhongMaterial,
+	Uint16BufferAttribute,
+	Uint8BufferAttribute
+} from "../../../build/three.module.js";
+
+var PlayCanvasLoader = function ( manager ) {
+
+	this.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;
+
+};
+
+PlayCanvasLoader.prototype = {
+
+	constructor: PlayCanvasLoader,
+
+	load: function ( url, onLoad, onProgress, onError ) {
+
+		var scope = this;
+
+		var loader = new FileLoader( scope.manager );
+		loader.setPath( scope.path );
+		loader.load( url, function ( text ) {
+
+			onLoad( scope.parse( JSON.parse( text ) ) );
+
+		}, onProgress, onError );
+
+	},
+
+	setPath: function ( value ) {
+
+		this.path = value;
+		return this;
+
+	},
+
+	parse: function ( json ) {
+
+		function parseVertices( data ) {
+
+			var attributes = {};
+
+			// create a buffer attribute for each array that contains vertex information
+
+			for ( var name in data ) {
+
+				var array = data[ name ];
+
+				var type = array.type;
+				var size = array.components;
+
+				var attribute;
+
+				switch ( type ) {
+
+					case 'float32':
+						attribute = new Float32BufferAttribute( array.data, size );
+						break;
+
+					case 'uint8':
+						attribute = new Uint8BufferAttribute( array.data, size );
+						break;
+
+					case 'uint16':
+						attribute = new Uint16BufferAttribute( array.data, size );
+						break;
+
+					default:
+						console.log( 'THREE.PlayCanvasLoader: Array type "%s" not yet supported.', type );
+
+				}
+
+				attributes[ name ] = attribute;
+
+			}
+
+			data._attributes = attributes;
+
+		}
+
+		function parseMeshes( data ) {
+
+			// create buffer geometry
+
+			var geometry = new BufferGeometry();
+
+			geometry.setIndex( data.indices );
+
+			var attributes = model.vertices[ data.vertices ]._attributes;
+
+			for ( var name in attributes ) {
+
+				var attribute = attributes[ name ];
+
+				if ( name === 'texCoord0' ) name = 'uv';
+
+				geometry.addAttribute( name, attribute );
+
+			}
+
+			data._geometry = geometry;
+
+		}
+
+		function parseMeshInstances( data ) {
+
+			var node = model.nodes[ data.node ];
+			var mesh = model.meshes[ data.mesh ];
+
+			if ( node._geometries === undefined ) {
+
+				node._geometries = [];
+
+			}
+
+			node._geometries.push( mesh._geometry );
+
+		}
+
+		function parseNodes( data ) {
+
+			var object = new Group();
+
+			var geometries = data._geometries;
+
+			if ( geometries !== undefined ) {
+
+				var material = new MeshPhongMaterial();
+
+				for ( var i = 0, l = geometries.length; i < l; i ++ ) {
+
+					var geometry = geometries[ i ];
+
+					object.add( new Mesh( geometry, material ) );
+
+				}
+
+			}
+
+			for ( var i = 0, l = data.rotation.length; i < l; i ++ ) {
+
+				data.rotation[ i ] *= Math.PI / 180;
+
+			}
+
+			//
+
+			object.name = data.name;
+
+			object.position.fromArray( data.position );
+			object.quaternion.setFromEuler( new Euler().fromArray( data.rotation ) );
+			object.scale.fromArray( data.scale );
+
+			data._object = object;
+
+		}
+
+		//
+
+		var model = json.model;
+
+		for ( var i = 0, l = model.vertices.length; i < l; i ++ ) {
+
+			parseVertices( model.vertices[ i ] );
+
+		}
+
+		for ( var i = 0, l = model.meshes.length; i < l; i ++ ) {
+
+			parseMeshes( model.meshes[ i ] );
+
+		}
+
+		for ( var i = 0, l = model.meshInstances.length; i < l; i ++ ) {
+
+			parseMeshInstances( model.meshInstances[ i ] );
+
+		}
+
+		for ( var i = 0, l = model.nodes.length; i < l; i ++ ) {
+
+			parseNodes( model.nodes[ i ] );
+
+		}
+
+		// setup scene hierarchy
+
+		for ( var i = 0, l = model.parents.length; i < l; i ++ ) {
+
+			var parent = model.parents[ i ];
+
+			if ( parent === - 1 ) continue;
+
+			model.nodes[ parent ]._object.add( model.nodes[ i ]._object );
+
+
+		}
+
+		return model.nodes[ 0 ]._object;
+
+	}
+
+};
+
+export { PlayCanvasLoader };

utils/modularize.js

@@ -32,13 +32,18 @@ var files = [
 	{ path: 'exporters/STLExporter.js', dependencies: [], ignoreList: [] },
 	{ path: 'exporters/TypedGeometryExporter.js', dependencies: [], ignoreList: [] },
 
+	{ path: 'loaders/BabylonLoader.js', dependencies: [], ignoreList: [] },
 	{ path: 'loaders/BVHLoader.js', dependencies: [], ignoreList: [ 'Bones' ] },
 	{ path: 'loaders/ColladaLoader.js', dependencies: [ { name: 'TGALoader', path: 'loaders/TGALoader.js' } ], ignoreList: [] },
+	{ path: 'loaders/DDSLoader.js', dependencies: [], ignoreList: [] },
+	{ path: 'loaders/EXRLoader.js', dependencies: [], ignoreList: [] },
 	{ path: 'loaders/FBXLoader.js', dependencies: [ { name: 'TGALoader', path: 'loaders/TGALoader.js' }, { name: 'NURBSCurve', path: 'curves/NURBSCurve.js' } ], ignoreList: [] },
 	{ path: 'loaders/GLTFLoader.js', dependencies: [], ignoreList: [ 'NoSide', 'Matrix2', 'DDSLoader' ] },
 	{ path: 'loaders/MTLLoader.js', dependencies: [], ignoreList: [ 'BackSide', 'DoubleSide', 'ClampToEdgeWrapping', 'MirroredRepeatWrapping' ] },
 	{ path: 'loaders/OBJLoader.js', dependencies: [], ignoreList: [] },
 	{ path: 'loaders/PCDLoader.js', dependencies: [], ignoreList: [] },
+	{ path: 'loaders/PDBLoader.js', dependencies: [], ignoreList: [] },
+	{ path: 'loaders/PlayCanvasLoader.js', dependencies: [], ignoreList: [] },
 	{ path: 'loaders/PLYLoader.js', dependencies: [], ignoreList: [ 'Mesh' ] },
 	{ path: 'loaders/STLLoader.js', dependencies: [], ignoreList: [ 'Mesh', 'MeshPhongMaterial', 'VertexColors' ] },
 	{ path: 'loaders/SVGLoader.js', dependencies: [], ignoreList: [] },
@@ -133,7 +138,7 @@ function convert( path, exampleDependencies, ignoreList ) {
 
 	// constants
 
-	contents = contents.replace( /(\'?)THREE\.([a-zA-Z0-9]+)/g, function ( match, p1, p2 ) {
+	contents = contents.replace( /(\'?)THREE\.([a-zA-Z0-9_]+)/g, function ( match, p1, p2 ) {
 
 		if ( ignoreList.includes( p2 ) ) return match;
 		if ( p1 === '\'' ) return match; // Inside a string