super-three 0.135.0 → 0.136.0

package/examples/jsm/loaders/EXRLoader.js

@@ -5,12 +5,8 @@ import {
 	HalfFloatType,
 	LinearEncoding,
 	LinearFilter,
-	NearestFilter,
-	RGBAFormat,
-	RGBEEncoding,
-	RGBEFormat,
-	RGBFormat,
-	UnsignedByteType
+	RedFormat,
+	RGBAFormat
 } from 'three';
 import * as fflate from '../libs/fflate.module.js';
 
@@ -132,41 +128,6 @@ class EXRLoader extends DataTextureLoader {
 
 		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 ) {
 
 			var k = 0;
@@ -1312,8 +1273,7 @@ class EXRLoader extends DataTextureLoader {
 			var inDataView = info.viewer;
 			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
@@ -1333,6 +1293,7 @@ class EXRLoader extends DataTextureLoader {
 			}
 
 			// Read range compression data
+
 			var minNonZero = parseUint16( inDataView, inOffset );
 			var maxNonZero = parseUint16( inDataView, inOffset );
 
@@ -1489,7 +1450,7 @@ class EXRLoader extends DataTextureLoader {
 
 			var inDataView = info.viewer;
 			var inOffset = { value: info.offset.value };
-			var outBuffer = new Uint8Array( info.width * info.lines * ( EXRHeader.channels.length * info.type * INT16_SIZE ) );
+			var outBuffer = new Uint8Array( info.width * info.lines * ( info.channels * info.type * INT16_SIZE ) );
 
 			// Read compression header information
 			var dwaHeader = {
@@ -1737,16 +1698,6 @@ class EXRLoader extends DataTextureLoader {
 
 		}
 
-		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 );
@@ -2037,311 +1988,271 @@ class EXRLoader extends DataTextureLoader {
 
 		}
 
-		var bufferDataView = new DataView( buffer );
-		var uInt8Array = new Uint8Array( buffer );
+		function parseHeader( dataView, buffer, offset ) {
 
-		var EXRHeader = {};
+			const EXRHeader = {};
 
-		bufferDataView.getUint32( 0, true ); // magic
-		bufferDataView.getUint8( 4, true ); // versionByteZero
-		bufferDataView.getUint8( 5, true ); // fullMask
+			if ( dataView.getUint32( 0, true ) != 20000630 ) // magic
+				throw 'THREE.EXRLoader: provided file doesn\'t appear to be in OpenEXR format.';
 
-		// start of header
+			EXRHeader.version = dataView.getUint8( 4, true );
 
-		var offset = { value: 8 }; // start at 8, after magic stuff
+			const spec = dataView.getUint8( 5, true ); // fullMask
 
-		var keepReading = true;
-
-		while ( keepReading ) {
+			EXRHeader.spec = {
+				singleTile: !! ( spec & 1 ),
+				longName: !! ( spec & 2 ),
+				deepFormat: !! ( spec & 4 ),
+				multiPart: !! ( spec & 8 ),
+			};
 
-			var attributeName = parseNullTerminatedString( buffer, offset );
+			// 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;
+					var attributeType = parseNullTerminatedString( buffer, offset );
+					var attributeSize = parseUint32( dataView, offset );
+					var attributeValue = parseValue( dataView, buffer, offset, attributeType, attributeSize );
 
-				}
-
-			}
-
-		}
-
-		// offsets
-		var dataWindowHeight = EXRHeader.dataWindow.yMax + 1;
-
-		var uncompress;
-		var scanlineBlockSize;
-
-		switch ( EXRHeader.compression ) {
-
-			case 'NO_COMPRESSION':
-
-				scanlineBlockSize = 1;
-				uncompress = uncompressRAW;
-				break;
-
-			case 'RLE_COMPRESSION':
-
-				scanlineBlockSize = 1;
-				uncompress = uncompressRLE;
-				break;
-
-			case 'ZIPS_COMPRESSION':
-
-				scanlineBlockSize = 1;
-				uncompress = uncompressZIP;
-				break;
+					if ( attributeValue === undefined ) {
 
-			case 'ZIP_COMPRESSION':
+						console.warn( `EXRLoader.parse: skipped unknown header attribute type \'${attributeType}\'.` );
 
-				scanlineBlockSize = 16;
-				uncompress = uncompressZIP;
-				break;
-
-			case 'PIZ_COMPRESSION':
-
-				scanlineBlockSize = 32;
-				uncompress = uncompressPIZ;
-				break;
+					} else {
 
-			case 'PXR24_COMPRESSION':
+						EXRHeader[ attributeName ] = attributeValue;
 
-				scanlineBlockSize = 16;
-				uncompress = uncompressPXR;
-				break;
+					}
 
-			case 'DWAA_COMPRESSION':
+				}
 
-				scanlineBlockSize = 32;
-				uncompress = uncompressDWA;
-				break;
+			}
 
-			case 'DWAB_COMPRESSION':
+			if ( spec != 0 ) {
 
-				scanlineBlockSize = 256;
-				uncompress = uncompressDWA;
-				break;
+				console.error( 'EXRHeader:', EXRHeader );
+				throw 'THREE.EXRLoader: provided file is currently unsupported.';
 
-			default:
+			}
 
-				throw 'EXRLoader.parse: ' + EXRHeader.compression + ' is unsupported';
+			return EXRHeader;
 
 		}
 
-		var size_t;
-		var getValue;
+		function setupDecoder( EXRHeader, dataView, uInt8Array, offset, outputType ) {
 
-		// mixed pixelType not supported
-		var pixelType = EXRHeader.channels[ 0 ].pixelType;
-
-		if ( pixelType === 1 ) { // half
-
-			switch ( this.type ) {
+			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,
+			};
 
-				case UnsignedByteType:
-				case FloatType:
+			switch ( EXRHeader.compression ) {
 
-					getValue = parseFloat16;
-					size_t = INT16_SIZE;
+				case 'NO_COMPRESSION':
+					EXRDecoder.lines = 1;
+					EXRDecoder.uncompress = uncompressRAW;
 					break;
 
-				case HalfFloatType:
-
-					getValue = parseUint16;
-					size_t = INT16_SIZE;
+				case 'RLE_COMPRESSION':
+					EXRDecoder.lines = 1;
+					EXRDecoder.uncompress = uncompressRLE;
 					break;
 
-			}
+				case 'ZIPS_COMPRESSION':
+					EXRDecoder.lines = 1;
+					EXRDecoder.uncompress = uncompressZIP;
+					break;
 
-		} else if ( pixelType === 2 ) { // float
+				case 'ZIP_COMPRESSION':
+					EXRDecoder.lines = 16;
+					EXRDecoder.uncompress = uncompressZIP;
+					break;
 
-			switch ( this.type ) {
+				case 'PIZ_COMPRESSION':
+					EXRDecoder.lines = 32;
+					EXRDecoder.uncompress = uncompressPIZ;
+					break;
 
-				case UnsignedByteType:
-				case FloatType:
+				case 'PXR24_COMPRESSION':
+					EXRDecoder.lines = 16;
+					EXRDecoder.uncompress = uncompressPXR;
+					break;
 
-					getValue = parseFloat32;
-					size_t = FLOAT32_SIZE;
+				case 'DWAA_COMPRESSION':
+					EXRDecoder.lines = 32;
+					EXRDecoder.uncompress = uncompressDWA;
 					break;
 
-				case HalfFloatType:
+				case 'DWAB_COMPRESSION':
+					EXRDecoder.lines = 256;
+					EXRDecoder.uncompress = uncompressDWA;
+					break;
 
-					getValue = decodeFloat32;
-					size_t = FLOAT32_SIZE;
+				default:
+					throw 'EXRLoader.parse: ' + EXRHeader.compression + ' is unsupported';
 
 			}
 
-		} else {
-
-			throw 'EXRLoader.parse: unsupported pixelType ' + pixelType + ' for ' + EXRHeader.compression + '.';
-
-		}
-
-		var numBlocks = dataWindowHeight / scanlineBlockSize;
-
-		for ( var i = 0; i < numBlocks; i ++ ) {
-
-			parseUlong( bufferDataView, offset ); // scanlineOffset
-
-		}
-
-		// 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;
-		// Firefox only supports RGBA (half) float textures
-		// var numChannels = EXRHeader.channels.length;
-		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
-		switch ( this.type ) {
+			EXRDecoder.scanlineBlockSize = EXRDecoder.lines;
 
-			case UnsignedByteType:
-			case FloatType:
+			if ( EXRDecoder.type == 1 ) {
 
-				var byteArray = new Float32Array( size );
+				// half
+				switch ( outputType ) {
 
-				if ( EXRHeader.channels.length < numChannels ) {
+					case FloatType:
+						EXRDecoder.getter = parseFloat16;
+						EXRDecoder.inputSize = INT16_SIZE;
+						break;
 
-					byteArray.fill( 1, 0, size );
+					case HalfFloatType:
+						EXRDecoder.getter = parseUint16;
+						EXRDecoder.inputSize = INT16_SIZE;
+						break;
 
 				}
 
-				break;
-
-			case HalfFloatType:
+			} else if ( EXRDecoder.type == 2 ) {
 
-				var byteArray = new Uint16Array( size );
+				// float
+				switch ( outputType ) {
 
-				if ( EXRHeader.channels.length < numChannels ) {
+					case FloatType:
+						EXRDecoder.getter = parseFloat32;
+						EXRDecoder.inputSize = FLOAT32_SIZE;
+						break;
 
-					byteArray.fill( 0x3C00, 0, size ); // Uint16Array holds half float data, 0x3C00 is 1
+					case HalfFloatType:
+						EXRDecoder.getter = decodeFloat32;
+						EXRDecoder.inputSize = FLOAT32_SIZE;
 
 				}
 
-				break;
-
-			default:
+			} else {
 
-				console.error( 'THREE.EXRLoader: unsupported type: ', this.type );
-				break;
+				throw 'EXRLoader.parse: unsupported pixelType ' + EXRDecoder.type + ' for ' + EXRHeader.compression + '.';
 
-		}
+			}
 
-		var channelOffsets = {
-			R: 0,
-			G: 1,
-			B: 2,
-			A: 3
-		};
+			EXRDecoder.blockCount = ( EXRHeader.dataWindow.yMax + 1 ) / EXRDecoder.scanlineBlockSize;
 
-		var compressionInfo = {
+			for ( var i = 0; i < EXRDecoder.blockCount; i ++ )
+				parseInt64( dataView, offset ); // scanlineOffset
 
-			size: 0,
-			width: width,
-			lines: scanlineBlockSize,
+			// we should be passed the scanline offset table, ready to start reading pixel data.
 
-			offset: offset,
-			array: uInt8Array,
-			viewer: bufferDataView,
+			// RGB images will be converted to RGBA format, preventing software emulation in select devices.
+			EXRDecoder.outputChannels = ( ( EXRDecoder.channels == 3 ) ? 4 : EXRDecoder.channels );
+			const size = EXRDecoder.width * EXRDecoder.height * EXRDecoder.outputChannels;
 
-			type: pixelType,
-			channels: EXRHeader.channels.length,
+			switch ( outputType ) {
 
-		};
+				case FloatType:
+					EXRDecoder.byteArray = new Float32Array( size );
 
-		var line;
-		var size;
-		var viewer;
-		var tmpOffset = { value: 0 };
+					// Fill initially with 1s for the alpha value if the texture is not RGBA, RGB values will be overwritten
+					if ( EXRDecoder.channels < EXRDecoder.outputChannels )
+						EXRDecoder.byteArray.fill( 1, 0, size );
 
-		for ( var scanlineBlockIdx = 0; scanlineBlockIdx < height / scanlineBlockSize; scanlineBlockIdx ++ ) {
+					break;
 
-			line = parseUint32( bufferDataView, offset ); // line_no
-			size = parseUint32( bufferDataView, offset ); // data_len
+				case HalfFloatType:
+					EXRDecoder.byteArray = new Uint16Array( size );
 
-			compressionInfo.lines = ( line + scanlineBlockSize > height ) ? height - line : scanlineBlockSize;
-			compressionInfo.offset = offset;
-			compressionInfo.size = size;
+					if ( EXRDecoder.channels < EXRDecoder.outputChannels )
+						EXRDecoder.byteArray.fill( 0x3C00, 0, size ); // Uint16Array holds half float data, 0x3C00 is 1
 
-			viewer = uncompress( compressionInfo );
+					break;
 
-			offset.value += size;
+				default:
+					console.error( 'THREE.EXRLoader: unsupported type: ', outputType );
+					break;
 
-			for ( var line_y = 0; line_y < scanlineBlockSize; line_y ++ ) {
+			}
 
-				var true_y = line_y + ( scanlineBlockIdx * scanlineBlockSize );
+			EXRDecoder.bytesPerLine = EXRDecoder.width * EXRDecoder.inputSize * EXRDecoder.channels;
 
-				if ( true_y >= height ) break;
+			if ( EXRDecoder.outputChannels == 4 ) {
 
-				for ( var channelID = 0; channelID < EXRHeader.channels.length; channelID ++ ) {
+				EXRDecoder.format = RGBAFormat;
+				EXRDecoder.encoding = LinearEncoding;
 
-					var cOff = channelOffsets[ EXRHeader.channels[ channelID ].name ];
+			} else {
 
-					for ( var x = 0; x < width; x ++ ) {
+				EXRDecoder.format = RedFormat;
+				EXRDecoder.encoding = LinearEncoding;
 
-						var idx = ( line_y * ( EXRHeader.channels.length * width ) ) + ( channelID * width ) + x;
-						tmpOffset.value = idx * size_t;
+			}
 
-						var val = getValue( viewer, tmpOffset );
+			return EXRDecoder;
 
-						byteArray[ ( ( ( height - 1 - true_y ) * ( width * numChannels ) ) + ( x * numChannels ) ) + cOff ] = val;
+		}
 
-					}
+		// start parsing file [START]
 
-				}
+		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 );
 
-		if ( this.type === UnsignedByteType ) {
+		const tmpOffset = { value: 0 };
+		const channelOffsets = { R: 0, G: 1, B: 2, A: 3, Y: 0 };
 
-			let v, i;
-			const size = byteArray.length;
-			const RGBEArray = new Uint8Array( size );
+		for ( let scanlineBlockIdx = 0; scanlineBlockIdx < EXRDecoder.height / EXRDecoder.scanlineBlockSize; scanlineBlockIdx ++ ) {
 
-			for ( let h = 0; h < height; ++ h ) {
+			const line = parseUint32( bufferDataView, offset ); // line_no
+			EXRDecoder.size = parseUint32( bufferDataView, offset ); // data_len
+			EXRDecoder.lines = ( ( line + EXRDecoder.scanlineBlockSize > EXRDecoder.height ) ? ( EXRDecoder.height - line ) : EXRDecoder.scanlineBlockSize );
 
-				for ( let w = 0; w < width; ++ w ) {
+			const isCompressed = EXRDecoder.size < EXRDecoder.lines * EXRDecoder.bytesPerLine;
+			const viewer = isCompressed ? EXRDecoder.uncompress( EXRDecoder ) : uncompressRAW( EXRDecoder );
 
-					i = h * width * 4 + w * 4;
+			offset.value += EXRDecoder.size;
 
-					const red = byteArray[ i ];
-					const green = byteArray[ i + 1 ];
-					const blue = byteArray[ i + 2 ];
+			for ( let line_y = 0; line_y < EXRDecoder.scanlineBlockSize; line_y ++ ) {
 
-					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 );
 
 					}
 
@@ -2349,19 +2260,16 @@ class EXRLoader extends DataTextureLoader {
 
 			}
 
-			byteArray = RGBEArray;
-
 		}
 
-		const format = ( this.type === UnsignedByteType ) ? RGBEFormat : ( numChannels === 4 ) ? RGBAFormat : RGBFormat;
-
 		return {
 			header: EXRHeader,
-			width: width,
-			height: height,
-			data: byteArray,
-			format: format,
-			type: this.type
+			width: EXRDecoder.width,
+			height: EXRDecoder.height,
+			data: EXRDecoder.byteArray,
+			format: EXRDecoder.format,
+			encoding: EXRDecoder.encoding,
+			type: this.type,
 		};
 
 	}
@@ -2377,28 +2285,11 @@ class EXRLoader extends DataTextureLoader {
 
 		function onLoadCallback( texture, texData ) {
 
-			switch ( texture.type ) {
-
-				case UnsignedByteType:
-
-					texture.encoding = RGBEEncoding;
-					texture.minFilter = NearestFilter;
-					texture.magFilter = NearestFilter;
-					texture.generateMipmaps = false;
-					texture.flipY = false;
-					break;
-
-				case FloatType:
-				case HalfFloatType:
-
-					texture.encoding = LinearEncoding;
-					texture.minFilter = LinearFilter;
-					texture.magFilter = LinearFilter;
-					texture.generateMipmaps = false;
-					texture.flipY = false;
-					break;
-
-			}
+			texture.encoding = texData.encoding;
+			texture.minFilter = LinearFilter;
+			texture.magFilter = LinearFilter;
+			texture.generateMipmaps = false;
+			texture.flipY = false;
 
 			if ( onLoad ) onLoad( texture, texData );
 

package/examples/jsm/loaders/FBXLoader.js

@@ -53,11 +53,10 @@ import { NURBSCurve } from '../curves/NURBSCurve.js';
  *  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/
  */
 
 

package/examples/jsm/loaders/GLTFLoader.js

@@ -1445,7 +1445,7 @@ class GLTFTextureTransformExtension {
 /**
  * Specular-Glossiness Extension
  *
- * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness
+ * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Archived/KHR_materials_pbrSpecularGlossiness
  */
 
 /**
@@ -2253,7 +2253,7 @@ class GLTFParser {
 
 		// Use an ImageBitmapLoader if imageBitmaps are supported. Moves much of the
 		// expensive work of uploading a texture to the GPU off the main thread.
-		if ( typeof createImageBitmap !== 'undefined' && /Firefox/.test( navigator.userAgent ) === false ) {
+		if ( typeof createImageBitmap !== 'undefined' && /Firefox|Safari/.test( navigator.userAgent ) === false ) {
 
 			this.textureLoader = new ImageBitmapLoader( this.options.manager );