super-three 0.133.3 → 0.136.0

package/examples/js/loaders/EXRLoader.js

@@ -106,39 +106,6 @@
 			const LOSSY_DCT = 1;
 			const RLE = 2;
 			const logBase = Math.pow( 2.7182818, 2.2 );
-			var tmpDataView = new DataView( new ArrayBuffer( 8 ) );
-
-			function frexp( value ) {
-
-				if ( value === 0 ) return [ value, 0 ];
-				tmpDataView.setFloat64( 0, value );
-				var bits = tmpDataView.getUint32( 0 ) >>> 20 & 0x7FF;
-
-				if ( bits === 0 ) {
-
-					// denormal
-					tmpDataView.setFloat64( 0, value * Math.pow( 2, 64 ) ); // exp + 64
-
-					bits = ( tmpDataView.getUint32( 0 ) >>> 20 & 0x7FF ) - 64;
-
-				}
-
-				var exponent = bits - 1022;
-				var mantissa = ldexp( value, - exponent );
-				return [ mantissa, exponent ];
-
-			}
-
-			function ldexp( mantissa, exponent ) {
-
-				var steps = Math.min( 3, Math.ceil( Math.abs( exponent ) / 1023 ) );
-				var result = mantissa;
-
-				for ( var i = 0; i < steps; i ++ ) result *= Math.pow( 2, Math.floor( ( exponent + i ) / steps ) );
-
-				return result;
-
-			}
 
 			function reverseLutFromBitmap( bitmap, lut ) {
 
@@ -1207,8 +1174,7 @@
 				var inOffset = {
 					value: info.offset.value
 				};
-				var tmpBufSize = info.width * scanlineBlockSize * ( EXRHeader.channels.length * info.type );
-				var outBuffer = new Uint16Array( tmpBufSize );
+				var outBuffer = new Uint16Array( info.width * info.scanlineBlockSize * ( info.channels * info.type ) );
 				var bitmap = new Uint8Array( BITMAP_SIZE ); // Setup channel info
 
 				var outBufferEnd = 0;
@@ -1365,7 +1331,7 @@
 				var inOffset = {
 					value: info.offset.value
 				};
-				var outBuffer = new Uint8Array( info.width * info.lines * ( EXRHeader.channels.length * info.type * INT16_SIZE ) ); // Read compression header information
+				var outBuffer = new Uint8Array( info.width * info.lines * ( info.channels * info.type * INT16_SIZE ) ); // Read compression header information
 
 				var dwaHeader = {
 					version: parseInt64( inDataView, inOffset ),
@@ -1592,14 +1558,6 @@
 
 			}
 
-			function parseUlong( dataView, offset ) {
-
-				var uLong = dataView.getUint32( 0, true );
-				offset.value = offset.value + ULONG_SIZE;
-				return uLong;
-
-			}
-
 			function parseRational( dataView, offset ) {
 
 				var x = parseInt32( dataView, offset );
@@ -1857,283 +1815,266 @@
 
 			}
 
-			var bufferDataView = new DataView( buffer );
-			var uInt8Array = new Uint8Array( buffer );
-			var EXRHeader = {};
-			bufferDataView.getUint32( 0, true ); // magic
-
-			bufferDataView.getUint8( 4, true ); // versionByteZero
-
-			bufferDataView.getUint8( 5, true ); // fullMask
-			// start of header
-
-			var offset = {
-				value: 8
-			}; // start at 8, after magic stuff
-
-			var keepReading = true;
+			function parseHeader( dataView, buffer, offset ) {
 
-			while ( keepReading ) {
+				const EXRHeader = {};
+				if ( dataView.getUint32( 0, true ) != 20000630 ) // magic
+					throw 'THREE.EXRLoader: provided file doesn\'t appear to be in OpenEXR format.';
+				EXRHeader.version = dataView.getUint8( 4, true );
+				const spec = dataView.getUint8( 5, true ); // fullMask
 
-				var attributeName = parseNullTerminatedString( buffer, offset );
+				EXRHeader.spec = {
+					singleTile: !! ( spec & 1 ),
+					longName: !! ( spec & 2 ),
+					deepFormat: !! ( spec & 4 ),
+					multiPart: !! ( spec & 8 )
+				}; // start of header
 
-				if ( attributeName == 0 ) {
+				offset.value = 8; // start at 8 - after pre-amble
 
-					keepReading = false;
+				var keepReading = true;
 
-				} else {
+				while ( keepReading ) {
 
-					var attributeType = parseNullTerminatedString( buffer, offset );
-					var attributeSize = parseUint32( bufferDataView, offset );
-					var attributeValue = parseValue( bufferDataView, buffer, offset, attributeType, attributeSize );
+					var attributeName = parseNullTerminatedString( buffer, offset );
 
-					if ( attributeValue === undefined ) {
+					if ( attributeName == 0 ) {
 
-						console.warn( `EXRLoader.parse: skipped unknown header attribute type \'${attributeType}\'.` );
+						keepReading = false;
 
 					} else {
 
-						EXRHeader[ attributeName ] = attributeValue;
-
-					}
-
-				}
-
-			} // offsets
+						var attributeType = parseNullTerminatedString( buffer, offset );
+						var attributeSize = parseUint32( dataView, offset );
+						var attributeValue = parseValue( dataView, buffer, offset, attributeType, attributeSize );
 
+						if ( attributeValue === undefined ) {
 
-			var dataWindowHeight = EXRHeader.dataWindow.yMax + 1;
-			var uncompress;
-			var scanlineBlockSize;
+							console.warn( `EXRLoader.parse: skipped unknown header attribute type \'${attributeType}\'.` );
 
-			switch ( EXRHeader.compression ) {
-
-				case 'NO_COMPRESSION':
-					scanlineBlockSize = 1;
-					uncompress = uncompressRAW;
-					break;
+						} else {
 
-				case 'RLE_COMPRESSION':
-					scanlineBlockSize = 1;
-					uncompress = uncompressRLE;
-					break;
+							EXRHeader[ attributeName ] = attributeValue;
 
-				case 'ZIPS_COMPRESSION':
-					scanlineBlockSize = 1;
-					uncompress = uncompressZIP;
-					break;
+						}
 
-				case 'ZIP_COMPRESSION':
-					scanlineBlockSize = 16;
-					uncompress = uncompressZIP;
-					break;
+					}
 
-				case 'PIZ_COMPRESSION':
-					scanlineBlockSize = 32;
-					uncompress = uncompressPIZ;
-					break;
+				}
 
-				case 'PXR24_COMPRESSION':
-					scanlineBlockSize = 16;
-					uncompress = uncompressPXR;
-					break;
+				if ( spec != 0 ) {
 
-				case 'DWAA_COMPRESSION':
-					scanlineBlockSize = 32;
-					uncompress = uncompressDWA;
-					break;
+					console.error( 'EXRHeader:', EXRHeader );
+					throw 'THREE.EXRLoader: provided file is currently unsupported.';
 
-				case 'DWAB_COMPRESSION':
-					scanlineBlockSize = 256;
-					uncompress = uncompressDWA;
-					break;
+				}
 
-				default:
-					throw 'EXRLoader.parse: ' + EXRHeader.compression + ' is unsupported';
+				return EXRHeader;
 
 			}
 
-			var size_t;
-			var getValue; // mixed pixelType not supported
+			function setupDecoder( EXRHeader, dataView, uInt8Array, offset, outputType ) {
 
-			var pixelType = EXRHeader.channels[ 0 ].pixelType;
+				const EXRDecoder = {
+					size: 0,
+					viewer: dataView,
+					array: uInt8Array,
+					offset: offset,
+					width: EXRHeader.dataWindow.xMax - EXRHeader.dataWindow.xMin + 1,
+					height: EXRHeader.dataWindow.yMax - EXRHeader.dataWindow.yMin + 1,
+					channels: EXRHeader.channels.length,
+					bytesPerLine: null,
+					lines: null,
+					inputSize: null,
+					type: EXRHeader.channels[ 0 ].pixelType,
+					uncompress: null,
+					getter: null,
+					format: null,
+					encoding: null
+				};
 
-			if ( pixelType === 1 ) {
+				switch ( EXRHeader.compression ) {
 
-				// half
-				switch ( this.type ) {
+					case 'NO_COMPRESSION':
+						EXRDecoder.lines = 1;
+						EXRDecoder.uncompress = uncompressRAW;
+						break;
 
-					case THREE.UnsignedByteType:
-					case THREE.FloatType:
-						getValue = parseFloat16;
-						size_t = INT16_SIZE;
+					case 'RLE_COMPRESSION':
+						EXRDecoder.lines = 1;
+						EXRDecoder.uncompress = uncompressRLE;
 						break;
 
-					case THREE.HalfFloatType:
-						getValue = parseUint16;
-						size_t = INT16_SIZE;
+					case 'ZIPS_COMPRESSION':
+						EXRDecoder.lines = 1;
+						EXRDecoder.uncompress = uncompressZIP;
 						break;
 
-				}
+					case 'ZIP_COMPRESSION':
+						EXRDecoder.lines = 16;
+						EXRDecoder.uncompress = uncompressZIP;
+						break;
 
-			} else if ( pixelType === 2 ) {
+					case 'PIZ_COMPRESSION':
+						EXRDecoder.lines = 32;
+						EXRDecoder.uncompress = uncompressPIZ;
+						break;
 
-				// float
-				switch ( this.type ) {
+					case 'PXR24_COMPRESSION':
+						EXRDecoder.lines = 16;
+						EXRDecoder.uncompress = uncompressPXR;
+						break;
 
-					case THREE.UnsignedByteType:
-					case THREE.FloatType:
-						getValue = parseFloat32;
-						size_t = FLOAT32_SIZE;
+					case 'DWAA_COMPRESSION':
+						EXRDecoder.lines = 32;
+						EXRDecoder.uncompress = uncompressDWA;
 						break;
 
-					case THREE.HalfFloatType:
-						getValue = decodeFloat32;
-						size_t = FLOAT32_SIZE;
+					case 'DWAB_COMPRESSION':
+						EXRDecoder.lines = 256;
+						EXRDecoder.uncompress = uncompressDWA;
+						break;
+
+					default:
+						throw 'EXRLoader.parse: ' + EXRHeader.compression + ' is unsupported';
 
 				}
 
-			} else {
+				EXRDecoder.scanlineBlockSize = EXRDecoder.lines;
 
-				throw 'EXRLoader.parse: unsupported pixelType ' + pixelType + ' for ' + EXRHeader.compression + '.';
+				if ( EXRDecoder.type == 1 ) {
 
-			}
+					// half
+					switch ( outputType ) {
 
-			var numBlocks = dataWindowHeight / scanlineBlockSize;
+						case THREE.FloatType:
+							EXRDecoder.getter = parseFloat16;
+							EXRDecoder.inputSize = INT16_SIZE;
+							break;
 
-			for ( var i = 0; i < numBlocks; i ++ ) {
+						case THREE.HalfFloatType:
+							EXRDecoder.getter = parseUint16;
+							EXRDecoder.inputSize = INT16_SIZE;
+							break;
 
-				parseUlong( bufferDataView, offset ); // scanlineOffset
+					}
 
-			} // we should be passed the scanline offset table, start reading pixel data
+				} else if ( EXRDecoder.type == 2 ) {
 
+					// float
+					switch ( outputType ) {
 
-			var width = EXRHeader.dataWindow.xMax - EXRHeader.dataWindow.xMin + 1;
-			var height = EXRHeader.dataWindow.yMax - EXRHeader.dataWindow.yMin + 1; // Firefox only supports RGBA (half) float textures
-			// var numChannels = EXRHeader.channels.length;
+						case THREE.FloatType:
+							EXRDecoder.getter = parseFloat32;
+							EXRDecoder.inputSize = FLOAT32_SIZE;
+							break;
 
-			var numChannels = 4;
-			var size = width * height * numChannels; // Fill initially with 1s for the alpha value if the texture is not RGBA, RGB values will be overwritten
+						case THREE.HalfFloatType:
+							EXRDecoder.getter = decodeFloat32;
+							EXRDecoder.inputSize = FLOAT32_SIZE;
 
-			switch ( this.type ) {
+					}
 
-				case THREE.UnsignedByteType:
-				case THREE.FloatType:
-					var byteArray = new Float32Array( size );
+				} else {
 
-					if ( EXRHeader.channels.length < numChannels ) {
+					throw 'EXRLoader.parse: unsupported pixelType ' + EXRDecoder.type + ' for ' + EXRHeader.compression + '.';
 
-						byteArray.fill( 1, 0, size );
+				}
 
-					}
+				EXRDecoder.blockCount = ( EXRHeader.dataWindow.yMax + 1 ) / EXRDecoder.scanlineBlockSize;
 
-					break;
+				for ( var i = 0; i < EXRDecoder.blockCount; i ++ ) parseInt64( dataView, offset ); // scanlineOffset
+				// we should be passed the scanline offset table, ready to start reading pixel data.
+				// RGB images will be converted to RGBA format, preventing software emulation in select devices.
 
-				case THREE.HalfFloatType:
-					var byteArray = new Uint16Array( size );
 
-					if ( EXRHeader.channels.length < numChannels ) {
+				EXRDecoder.outputChannels = EXRDecoder.channels == 3 ? 4 : EXRDecoder.channels;
+				const size = EXRDecoder.width * EXRDecoder.height * EXRDecoder.outputChannels;
 
-						byteArray.fill( 0x3C00, 0, size ); // Uint16Array holds half float data, 0x3C00 is 1
+				switch ( outputType ) {
 
-					}
+					case THREE.FloatType:
+						EXRDecoder.byteArray = new Float32Array( size ); // Fill initially with 1s for the alpha value if the texture is not RGBA, RGB values will be overwritten
 
-					break;
+						if ( EXRDecoder.channels < EXRDecoder.outputChannels ) EXRDecoder.byteArray.fill( 1, 0, size );
+						break;
 
-				default:
-					console.error( 'THREE.EXRLoader: unsupported type: ', this.type );
-					break;
+					case THREE.HalfFloatType:
+						EXRDecoder.byteArray = new Uint16Array( size );
+						if ( EXRDecoder.channels < EXRDecoder.outputChannels ) EXRDecoder.byteArray.fill( 0x3C00, 0, size ); // Uint16Array holds half float data, 0x3C00 is 1
 
-			}
+						break;
 
-			var channelOffsets = {
-				R: 0,
-				G: 1,
-				B: 2,
-				A: 3
-			};
-			var compressionInfo = {
-				size: 0,
-				width: width,
-				lines: scanlineBlockSize,
-				offset: offset,
-				array: uInt8Array,
-				viewer: bufferDataView,
-				type: pixelType,
-				channels: EXRHeader.channels.length
-			};
-			var line;
-			var size;
-			var viewer;
-			var tmpOffset = {
-				value: 0
-			};
+					default:
+						console.error( 'THREE.EXRLoader: unsupported type: ', outputType );
+						break;
 
-			for ( var scanlineBlockIdx = 0; scanlineBlockIdx < height / scanlineBlockSize; scanlineBlockIdx ++ ) {
+				}
 
-				line = parseUint32( bufferDataView, offset ); // line_no
+				EXRDecoder.bytesPerLine = EXRDecoder.width * EXRDecoder.inputSize * EXRDecoder.channels;
 
-				size = parseUint32( bufferDataView, offset ); // data_len
+				if ( EXRDecoder.outputChannels == 4 ) {
 
-				compressionInfo.lines = line + scanlineBlockSize > height ? height - line : scanlineBlockSize;
-				compressionInfo.offset = offset;
-				compressionInfo.size = size;
-				viewer = uncompress( compressionInfo );
-				offset.value += size;
+					EXRDecoder.format = THREE.RGBAFormat;
+					EXRDecoder.encoding = THREE.LinearEncoding;
 
-				for ( var line_y = 0; line_y < scanlineBlockSize; line_y ++ ) {
+				} else {
 
-					var true_y = line_y + scanlineBlockIdx * scanlineBlockSize;
-					if ( true_y >= height ) break;
+					EXRDecoder.format = THREE.RedFormat;
+					EXRDecoder.encoding = THREE.LinearEncoding;
 
-					for ( var channelID = 0; channelID < EXRHeader.channels.length; channelID ++ ) {
+				}
 
-						var cOff = channelOffsets[ EXRHeader.channels[ channelID ].name ];
+				return EXRDecoder;
 
-						for ( var x = 0; x < width; x ++ ) {
+			} // start parsing file [START]
 
-							var idx = line_y * ( EXRHeader.channels.length * width ) + channelID * width + x;
-							tmpOffset.value = idx * size_t;
-							var val = getValue( viewer, tmpOffset );
-							byteArray[ ( height - 1 - true_y ) * ( width * numChannels ) + x * numChannels + cOff ] = val;
 
-						}
+			const bufferDataView = new DataView( buffer );
+			const uInt8Array = new Uint8Array( buffer );
+			const offset = {
+				value: 0
+			}; // get header information and validate format.
 
-					}
+			const EXRHeader = parseHeader( bufferDataView, buffer, offset ); // get input compression information and prepare decoding.
 
-				}
+			const EXRDecoder = setupDecoder( EXRHeader, bufferDataView, uInt8Array, offset, this.type );
+			const tmpOffset = {
+				value: 0
+			};
+			const channelOffsets = {
+				R: 0,
+				G: 1,
+				B: 2,
+				A: 3,
+				Y: 0
+			};
 
-			}
+			for ( let scanlineBlockIdx = 0; scanlineBlockIdx < EXRDecoder.height / EXRDecoder.scanlineBlockSize; scanlineBlockIdx ++ ) {
 
-			if ( this.type === THREE.UnsignedByteType ) {
+				const line = parseUint32( bufferDataView, offset ); // line_no
 
-				let v, i;
-				const size = byteArray.length;
-				const RGBEArray = new Uint8Array( size );
+				EXRDecoder.size = parseUint32( bufferDataView, offset ); // data_len
 
-				for ( let h = 0; h < height; ++ h ) {
+				EXRDecoder.lines = line + EXRDecoder.scanlineBlockSize > EXRDecoder.height ? EXRDecoder.height - line : EXRDecoder.scanlineBlockSize;
+				const isCompressed = EXRDecoder.size < EXRDecoder.lines * EXRDecoder.bytesPerLine;
+				const viewer = isCompressed ? EXRDecoder.uncompress( EXRDecoder ) : uncompressRAW( EXRDecoder );
+				offset.value += EXRDecoder.size;
 
-					for ( let w = 0; w < width; ++ w ) {
+				for ( let line_y = 0; line_y < EXRDecoder.scanlineBlockSize; line_y ++ ) {
 
-						i = h * width * 4 + w * 4;
-						const red = byteArray[ i ];
-						const green = byteArray[ i + 1 ];
-						const blue = byteArray[ i + 2 ];
-						v = red > green ? red : green;
-						v = blue > v ? blue : v;
+					const true_y = line_y + scanlineBlockIdx * EXRDecoder.scanlineBlockSize;
+					if ( true_y >= EXRDecoder.height ) break;
 
-						if ( v < 1e-32 ) {
+					for ( let channelID = 0; channelID < EXRDecoder.channels; channelID ++ ) {
 
-							RGBEArray[ i ] = RGBEArray[ i + 1 ] = RGBEArray[ i + 2 ] = RGBEArray[ i + 3 ] = 0;
+						const cOff = channelOffsets[ EXRHeader.channels[ channelID ].name ];
 
-						} else {
+						for ( let x = 0; x < EXRDecoder.width; x ++ ) {
 
-							const res = frexp( v );
-							v = res[ 0 ] * 256 / v;
-							RGBEArray[ i ] = red * v;
-							RGBEArray[ i + 1 ] = green * v;
-							RGBEArray[ i + 2 ] = blue * v;
-							RGBEArray[ i + 3 ] = res[ 1 ] + 128;
+							tmpOffset.value = ( line_y * ( EXRDecoder.channels * EXRDecoder.width ) + channelID * EXRDecoder.width + x ) * EXRDecoder.inputSize;
+							const outIndex = ( EXRDecoder.height - 1 - true_y ) * ( EXRDecoder.width * EXRDecoder.outputChannels ) + x * EXRDecoder.outputChannels + cOff;
+							EXRDecoder.byteArray[ outIndex ] = EXRDecoder.getter( viewer, tmpOffset );
 
 						}
 
@@ -2141,17 +2082,15 @@
 
 				}
 
-				byteArray = RGBEArray;
-
 			}
 
-			const format = this.type === THREE.UnsignedByteType ? THREE.RGBEFormat : numChannels === 4 ? THREE.RGBAFormat : THREE.RGBFormat;
 			return {
 				header: EXRHeader,
-				width: width,
-				height: height,
-				data: byteArray,
-				format: format,
+				width: EXRDecoder.width,
+				height: EXRDecoder.height,
+				data: EXRDecoder.byteArray,
+				format: EXRDecoder.format,
+				encoding: EXRDecoder.encoding,
 				type: this.type
 			};
 
@@ -2168,27 +2107,11 @@
 
 			function onLoadCallback( texture, texData ) {
 
-				switch ( texture.type ) {
-
-					case THREE.UnsignedByteType:
-						texture.encoding = THREE.RGBEEncoding;
-						texture.minFilter = THREE.NearestFilter;
-						texture.magFilter = THREE.NearestFilter;
-						texture.generateMipmaps = false;
-						texture.flipY = false;
-						break;
-
-					case THREE.FloatType:
-					case THREE.HalfFloatType:
-						texture.encoding = THREE.LinearEncoding;
-						texture.minFilter = THREE.LinearFilter;
-						texture.magFilter = THREE.LinearFilter;
-						texture.generateMipmaps = false;
-						texture.flipY = false;
-						break;
-
-				}
-
+				texture.encoding = texData.encoding;
+				texture.minFilter = THREE.LinearFilter;
+				texture.magFilter = THREE.LinearFilter;
+				texture.generateMipmaps = false;
+				texture.flipY = false;
 				if ( onLoad ) onLoad( texture, texData );
 
 			}

package/examples/js/loaders/FBXLoader.js

@@ -9,11 +9,10 @@
  *  Morph normals / blend shape normals
  *
  * FBX format references:
- * 	https://wiki.blender.org/index.php/User:Mont29/Foundation/FBX_File_Structure
- * 	http://help.autodesk.com/view/FBX/2017/ENU/?guid=__cpp_ref_index_html (C++ SDK reference)
+ * 	https://help.autodesk.com/view/FBX/2017/ENU/?guid=__cpp_ref_index_html (C++ SDK reference)
  *
- * 	Binary format specification:
- *		https://code.blender.org/2013/08/fbx-binary-file-format-specification/
+ * Binary format specification:
+ *	https://code.blender.org/2013/08/fbx-binary-file-format-specification/
  */
 
 	let fbxTree;
@@ -1310,7 +1309,7 @@
 
 				for ( const nodeID in BindPoseNode ) {
 
-					if ( BindPoseNode[ nodeID ].attrType === 'BindPose' ) {
+					if ( BindPoseNode[ nodeID ].attrType === 'BindPose' && BindPoseNode[ nodeID ].NbPoseNodes > 0 ) {
 
 						const poseNodes = BindPoseNode[ nodeID ].PoseNode;