super-three 0.136.0 → 0.141.0

package/examples/jsm/utils/LDrawUtils.js

@@ -0,0 +1,202 @@
+import {
+	BufferAttribute,
+	BufferGeometry,
+	Group,
+	LineSegments,
+	Matrix3,
+	Mesh
+} from 'three';
+
+import { mergeBufferGeometries } from './BufferGeometryUtils.js';
+
+class LDrawUtils {
+
+	static mergeObject( object ) {
+
+		// Merges geometries in object by materials and returns new object. Use on not indexed geometries.
+		// The object buffers reference the old object ones.
+		// Special treatment is done to the conditional lines generated by LDrawLoader.
+
+		function extractGroup( geometry, group, elementSize, isConditionalLine ) {
+
+			// Extracts a group from a geometry as a new geometry (with attribute buffers referencing original buffers)
+
+			const newGeometry = new BufferGeometry();
+
+			const originalPositions = geometry.getAttribute( 'position' ).array;
+			const originalNormals = elementSize === 3 ? geometry.getAttribute( 'normal' ).array : null;
+
+			const numVertsGroup = Math.min( group.count, Math.floor( originalPositions.length / 3 ) - group.start );
+			const vertStart = group.start * 3;
+			const vertEnd = ( group.start + numVertsGroup ) * 3;
+
+			const positions = originalPositions.subarray( vertStart, vertEnd );
+			const normals = originalNormals !== null ? originalNormals.subarray( vertStart, vertEnd ) : null;
+
+			newGeometry.setAttribute( 'position', new BufferAttribute( positions, 3 ) );
+			if ( normals !== null ) newGeometry.setAttribute( 'normal', new BufferAttribute( normals, 3 ) );
+
+			if ( isConditionalLine ) {
+
+				const controlArray0 = geometry.getAttribute( 'control0' ).array.subarray( vertStart, vertEnd );
+				const controlArray1 = geometry.getAttribute( 'control1' ).array.subarray( vertStart, vertEnd );
+				const directionArray = geometry.getAttribute( 'direction' ).array.subarray( vertStart, vertEnd );
+
+				newGeometry.setAttribute( 'control0', new BufferAttribute( controlArray0, 3, false ) );
+				newGeometry.setAttribute( 'control1', new BufferAttribute( controlArray1, 3, false ) );
+				newGeometry.setAttribute( 'direction', new BufferAttribute( directionArray, 3, false ) );
+
+			}
+
+			return newGeometry;
+
+		}
+
+		function addGeometry( mat, geometry, geometries ) {
+
+			const geoms = geometries[ mat.uuid ];
+			if ( ! geoms ) {
+
+				geometries[ mat.uuid ] = {
+					mat: mat,
+					arr: [ geometry ]
+				};
+
+			} else {
+
+				geoms.arr.push( geometry );
+
+			}
+
+		}
+
+		function permuteAttribute( attribute, elemSize ) {
+
+			// Permutes first two vertices of each attribute element
+
+			if ( ! attribute ) return;
+
+			const verts = attribute.array;
+			const numVerts = Math.floor( verts.length / 3 );
+			let offset = 0;
+			for ( let i = 0; i < numVerts; i ++ ) {
+
+				const x = verts[ offset ];
+				const y = verts[ offset + 1 ];
+				const z = verts[ offset + 2 ];
+
+				verts[ offset ] = verts[ offset + 3 ];
+				verts[ offset + 1 ] = verts[ offset + 4 ];
+				verts[ offset + 2 ] = verts[ offset + 5 ];
+
+				verts[ offset + 3 ] = x;
+				verts[ offset + 4 ] = y;
+				verts[ offset + 5 ] = z;
+
+				offset += elemSize * 3;
+
+			}
+
+		}
+
+		// Traverse the object hierarchy collecting geometries and transforming them to world space
+
+		const meshGeometries = {};
+		const linesGeometries = {};
+		const condLinesGeometries = {};
+
+		object.updateMatrixWorld( true );
+		const normalMatrix = new Matrix3();
+
+		object.traverse( c => {
+
+			if ( c.isMesh | c.isLineSegments ) {
+
+				const elemSize = c.isMesh ? 3 : 2;
+
+				const geometry = c.geometry.clone();
+				const matrixIsInverted = c.matrixWorld.determinant() < 0;
+				if ( matrixIsInverted ) {
+
+					permuteAttribute( geometry.attributes.position, elemSize );
+					permuteAttribute( geometry.attributes.normal, elemSize );
+
+				}
+
+				geometry.applyMatrix4( c.matrixWorld );
+
+				if ( c.isConditionalLine ) {
+
+					geometry.attributes.control0.applyMatrix4( c.matrixWorld );
+					geometry.attributes.control1.applyMatrix4( c.matrixWorld );
+					normalMatrix.getNormalMatrix( c.matrixWorld );
+					geometry.attributes.direction.applyNormalMatrix( normalMatrix );
+
+				}
+
+				const geometries = c.isMesh ? meshGeometries : ( c.isConditionalLine ? condLinesGeometries : linesGeometries );
+
+				if ( Array.isArray( c.material ) ) {
+
+					for ( const groupIndex in geometry.groups ) {
+
+						const group = geometry.groups[ groupIndex ];
+						const mat = c.material[ group.materialIndex ];
+						const newGeometry = extractGroup( geometry, group, elemSize, c.isConditionalLine );
+						addGeometry( mat, newGeometry, geometries );
+
+					}
+
+				} else {
+
+					addGeometry( c.material, geometry, geometries );
+
+				}
+
+			}
+
+		} );
+
+		// Create object with merged geometries
+
+		const mergedObject = new Group();
+
+		const meshMaterialsIds = Object.keys( meshGeometries );
+		for ( const meshMaterialsId of meshMaterialsIds ) {
+
+			const meshGeometry = meshGeometries[ meshMaterialsId ];
+			const mergedGeometry = mergeBufferGeometries( meshGeometry.arr );
+			mergedObject.add( new Mesh( mergedGeometry, meshGeometry.mat ) );
+
+		}
+
+		const linesMaterialsIds = Object.keys( linesGeometries );
+		for ( const linesMaterialsId of linesMaterialsIds ) {
+
+			const lineGeometry = linesGeometries[ linesMaterialsId ];
+			const mergedGeometry = mergeBufferGeometries( lineGeometry.arr );
+			mergedObject.add( new LineSegments( mergedGeometry, lineGeometry.mat ) );
+
+		}
+
+		const condLinesMaterialsIds = Object.keys( condLinesGeometries );
+		for ( const condLinesMaterialsId of condLinesMaterialsIds ) {
+
+			const condLineGeometry = condLinesGeometries[ condLinesMaterialsId ];
+			const mergedGeometry = mergeBufferGeometries( condLineGeometry.arr );
+			const condLines = new LineSegments( mergedGeometry, condLineGeometry.mat );
+			condLines.isConditionalLine = true;
+			mergedObject.add( condLines );
+
+		}
+
+		mergedObject.userData.constructionStep = 0;
+		mergedObject.userData.numConstructionSteps = 1;
+
+		return mergedObject;
+
+	}
+
+}
+
+export { LDrawUtils };

package/examples/jsm/utils/SceneUtils.js

@@ -1,9 +1,11 @@
 import {
 	Group,
-	Mesh
+	Mesh,
+	BufferAttribute,
+	BufferGeometry
 } from 'three';
 
-
+import { mergeGroups } from './BufferGeometryUtils.js';
 
 function createMeshesFromInstancedMesh( instancedMesh ) {
 
@@ -31,6 +33,77 @@ function createMeshesFromInstancedMesh( instancedMesh ) {
 
 }
 
+function createMeshesFromMultiMaterialMesh( mesh ) {
+
+	if ( Array.isArray( mesh.material ) === false ) {
+
+		console.warn( 'THREE.SceneUtils.createMeshesFromMultiMaterialMesh(): The given mesh has no multiple materials.' );
+		return mesh;
+
+	}
+
+	const object = new Group();
+	object.copy( mesh );
+
+	// merge groups (which automatically sorts them)
+
+	const geometry = mergeGroups( mesh.geometry );
+
+	const index = geometry.index;
+	const groups = geometry.groups;
+	const attributeNames = Object.keys( geometry.attributes );
+
+	// create a mesh for each group by extracting the buffer data into a new geometry
+
+	for ( let i = 0; i < groups.length; i ++ ) {
+
+		const group = groups[ i ];
+
+		const start = group.start;
+		const end = start + group.count;
+
+		const newGeometry = new BufferGeometry();
+		const newMaterial = mesh.material[ group.materialIndex ];
+
+		// process all buffer attributes
+
+		for ( let j = 0; j < attributeNames.length; j ++ ) {
+
+			const name = attributeNames[ j ];
+			const attribute = geometry.attributes[ name ];
+			const itemSize = attribute.itemSize;
+
+			const newLength = group.count * itemSize;
+			const type = attribute.array.constructor;
+
+			const newArray = new type( newLength );
+			const newAttribute = new BufferAttribute( newArray, itemSize );
+
+			for ( let k = start, n = 0; k < end; k ++, n ++ ) {
+
+				const ind = index.getX( k );
+
+				if ( itemSize >= 1 ) newAttribute.setX( n, attribute.getX( ind ) );
+				if ( itemSize >= 2 ) newAttribute.setY( n, attribute.getY( ind ) );
+				if ( itemSize >= 3 ) newAttribute.setZ( n, attribute.getZ( ind ) );
+				if ( itemSize >= 4 ) newAttribute.setW( n, attribute.getW( ind ) );
+
+			}
+
+
+			newGeometry.setAttribute( name, newAttribute );
+
+		}
+
+		const newMesh = new Mesh( newGeometry, newMaterial );
+		object.add( newMesh );
+
+	}
+
+	return object;
+
+}
+
 function createMultiMaterialObject( geometry, materials ) {
 
 	const group = new Group();
@@ -65,6 +138,7 @@ function attach( child, scene, parent ) {
 
 export {
 	createMeshesFromInstancedMesh,
+	createMeshesFromMultiMaterialMesh,
 	createMultiMaterialObject,
 	detach,
 	attach,

package/examples/jsm/utils/SkeletonUtils.js

@@ -87,7 +87,7 @@ function retarget( target, source, options = {} ) {
 			bone = bones[ i ];
 			name = options.names[ bone.name ] || bone.name;
 
-			if ( options.offsets && options.offsets[ name ] ) {
+			if ( options.offsets[ name ] ) {
 
 				bone.matrix.multiply( options.offsets[ name ] );
 

package/examples/jsm/utils/UVsDebug.js

@@ -42,51 +42,42 @@ function UVsDebug( geometry, size = 1024 ) {
 	ctx.fillStyle = 'rgb( 255, 255, 255 )';
 	ctx.fillRect( 0, 0, width, height );
 
-	if ( geometry.isGeometry ) {
+	const index = geometry.index;
+	const uvAttribute = geometry.attributes.uv;
 
-		console.error( 'THREE.UVsDebug no longer supports Geometry. Use THREE.BufferGeometry instead.' );
-		return;
+	if ( index ) {
 
-	} else {
-
-		const index = geometry.index;
-		const uvAttribute = geometry.attributes.uv;
-
-		if ( index ) {
+		// indexed geometry
 
-			// indexed geometry
+		for ( let i = 0, il = index.count; i < il; i += 3 ) {
 
-			for ( let i = 0, il = index.count; i < il; i += 3 ) {
+			face[ 0 ] = index.getX( i );
+			face[ 1 ] = index.getX( i + 1 );
+			face[ 2 ] = index.getX( i + 2 );
 
-				face[ 0 ] = index.getX( i );
-				face[ 1 ] = index.getX( i + 1 );
-				face[ 2 ] = index.getX( i + 2 );
+			uvs[ 0 ].fromBufferAttribute( uvAttribute, face[ 0 ] );
+			uvs[ 1 ].fromBufferAttribute( uvAttribute, face[ 1 ] );
+			uvs[ 2 ].fromBufferAttribute( uvAttribute, face[ 2 ] );
 
-				uvs[ 0 ].fromBufferAttribute( uvAttribute, face[ 0 ] );
-				uvs[ 1 ].fromBufferAttribute( uvAttribute, face[ 1 ] );
-				uvs[ 2 ].fromBufferAttribute( uvAttribute, face[ 2 ] );
+			processFace( face, uvs, i / 3 );
 
-				processFace( face, uvs, i / 3 );
-
-			}
-
-		} else {
+		}
 
-			// non-indexed geometry
+	} else {
 
-			for ( let i = 0, il = uvAttribute.count; i < il; i += 3 ) {
+		// non-indexed geometry
 
-				face[ 0 ] = i;
-				face[ 1 ] = i + 1;
-				face[ 2 ] = i + 2;
+		for ( let i = 0, il = uvAttribute.count; i < il; i += 3 ) {
 
-				uvs[ 0 ].fromBufferAttribute( uvAttribute, face[ 0 ] );
-				uvs[ 1 ].fromBufferAttribute( uvAttribute, face[ 1 ] );
-				uvs[ 2 ].fromBufferAttribute( uvAttribute, face[ 2 ] );
+			face[ 0 ] = i;
+			face[ 1 ] = i + 1;
+			face[ 2 ] = i + 2;
 
-				processFace( face, uvs, i / 3 );
+			uvs[ 0 ].fromBufferAttribute( uvAttribute, face[ 0 ] );
+			uvs[ 1 ].fromBufferAttribute( uvAttribute, face[ 1 ] );
+			uvs[ 2 ].fromBufferAttribute( uvAttribute, face[ 2 ] );
 
-			}
+			processFace( face, uvs, i / 3 );
 
 		}
 

package/examples/jsm/webxr/ARButton.js

@@ -8,11 +8,11 @@ class ARButton {
 
 			if ( sessionInit.domOverlay === undefined ) {
 
-				var overlay = document.createElement( 'div' );
+				const overlay = document.createElement( 'div' );
 				overlay.style.display = 'none';
 				document.body.appendChild( overlay );
 
-				var svg = document.createElementNS( 'http://www.w3.org/2000/svg', 'svg' );
+				const svg = document.createElementNS( 'http://www.w3.org/2000/svg', 'svg' );
 				svg.setAttribute( 'width', 38 );
 				svg.setAttribute( 'height', 38 );
 				svg.style.position = 'absolute';
@@ -25,7 +25,7 @@ class ARButton {
 				} );
 				overlay.appendChild( svg );
 
-				var path = document.createElementNS( 'http://www.w3.org/2000/svg', 'path' );
+				const path = document.createElementNS( 'http://www.w3.org/2000/svg', 'path' );
 				path.setAttribute( 'd', 'M 12,12 L 28,28 M 28,12 12,28' );
 				path.setAttribute( 'stroke', '#fff' );
 				path.setAttribute( 'stroke-width', 2 );
@@ -133,6 +133,16 @@ class ARButton {
 
 		}
 
+		function showARNotAllowed( exception ) {
+
+			disableButton();
+
+			console.warn( 'Exception when trying to call xr.isSessionSupported', exception );
+
+			button.textContent = 'AR NOT ALLOWED';
+
+		}
+
 		function stylizeElement( element ) {
 
 			element.style.position = 'absolute';
@@ -161,7 +171,7 @@ class ARButton {
 
 				supported ? showStartAR() : showARNotSupported();
 
-			} ).catch( showARNotSupported );
+			} ).catch( showARNotAllowed );
 
 			return button;
 

package/examples/jsm/webxr/OculusHandPointerModel.js

@@ -62,7 +62,7 @@ class OculusHandPointerModel extends THREE.Object3D {
 	_drawVerticesRing( vertices, baseVector, ringIndex ) {
 
 		const segmentVector = baseVector.clone();
-		for ( var i = 0; i < POINTER_SEGMENTS; i ++ ) {
+		for ( let i = 0; i < POINTER_SEGMENTS; i ++ ) {
 
 			segmentVector.applyAxisAngle( ZAXIS, ( Math.PI * 2 ) / POINTER_SEGMENTS );
 			const vid = ringIndex * POINTER_SEGMENTS + i;
@@ -91,7 +91,7 @@ class OculusHandPointerModel extends THREE.Object3D {
 			Math.cos( ( Math.PI * POINTER_HEMISPHERE_ANGLE ) / 180 ) * rearRadius,
 			0
 		);
-		for ( var i = 0; i < POINTER_RINGS; i ++ ) {
+		for ( let i = 0; i < POINTER_RINGS; i ++ ) {
 
 			this._drawVerticesRing( vertices, rearBase, i + 1 );
 			rearBase.applyAxisAngle(
@@ -127,7 +127,7 @@ class OculusHandPointerModel extends THREE.Object3D {
 
 	createPointer() {
 
-		var i, j;
+		let i, j;
 		const vertices = new Array(
 			( ( POINTER_RINGS + 1 ) * POINTER_SEGMENTS + 2 ) * 3
 		).fill( 0 );

package/examples/jsm/webxr/Text2D.js

@@ -19,7 +19,7 @@ function createText( message, height ) {
 
 	const texture = new THREE.Texture( canvas );
 	texture.needsUpdate = true;
-	//var spriteAlignment = new THREE.Vector2(0,0) ;
+
 	const material = new THREE.MeshBasicMaterial( {
 		color: 0xffffff,
 		side: THREE.DoubleSide,

package/examples/jsm/webxr/VRButton.js

@@ -104,6 +104,16 @@ class VRButton {
 
 		}
 
+		function showVRNotAllowed( exception ) {
+
+			disableButton();
+
+			console.warn( 'Exception when trying to call xr.isSessionSupported', exception );
+
+			button.textContent = 'VR NOT ALLOWED';
+
+		}
+
 		function stylizeElement( element ) {
 
 			element.style.position = 'absolute';
@@ -132,7 +142,13 @@ class VRButton {
 
 				supported ? showEnterVR() : showWebXRNotFound();
 
-			} );
+				if ( supported && VRButton.xrSessionIsGranted ) {
+
+					button.click();
+
+				}
+
+			} ).catch( showVRNotAllowed );
 
 			return button;
 
@@ -164,6 +180,28 @@ class VRButton {
 
 	}
 
+	static xrSessionIsGranted = false;
+
+	static registerSessionGrantedListener() {
+
+		if ( 'xr' in navigator ) {
+
+			// WebXRViewer (based on Firefox) has a bug where addEventListener
+			// throws a silent exception and aborts execution entirely.
+			if ( /WebXRViewer\//i.test( navigator.userAgent ) ) return;
+
+			navigator.xr.addEventListener( 'sessiongranted', () => {
+
+				VRButton.xrSessionIsGranted = true;
+
+			} );
+
+		}
+
+	}
+
 }
 
+VRButton.registerSessionGrantedListener();
+
 export { VRButton };

package/examples/jsm/webxr/XREstimatedLight.js

@@ -69,6 +69,8 @@ class SessionLightProbe {
 
 				textureProperties.__webglTexture = cubeMap;
 
+				this.xrLight.environment.needsPMREMUpdate = true;
+
 			}
 
 		}

package/examples/jsm/webxr/XRHandMeshModel.js

@@ -90,13 +90,9 @@ class XRHandMeshModel {
 
 					const position = XRJoint.position;
 
-					if ( bone ) {
-
-						bone.position.copy( position );
-						bone.quaternion.copy( XRJoint.quaternion );
-						// bone.scale.setScalar( XRJoint.jointRadius || defaultRadius );
-
-					}
+					bone.position.copy( position );
+					bone.quaternion.copy( XRJoint.quaternion );
+					// bone.scale.setScalar( XRJoint.jointRadius || defaultRadius );
 
 				}
 

package/examples/jsm/webxr/XRHandModelFactory.js

@@ -83,10 +83,13 @@ class XRHandModelFactory {
 
 			}
 
+			controller.visible = true;
+
 		} );
 
 		controller.addEventListener( 'disconnected', () => {
 
+			controller.visible = false;
 			// handModel.motionController = null;
 			// handModel.remove( scene );
 			// scene = null;