super-three 0.136.1 → 0.144.0

package/examples/js/helpers/ViewHelper.js

@@ -0,0 +1,266 @@
+( function () {
+
+	const vpTemp = new THREE.Vector4();
+
+	class ViewHelper extends THREE.Object3D {
+
+		constructor( editorCamera, dom ) {
+
+			super();
+			this.isViewHelper = true;
+			this.animating = false;
+			this.controls = null;
+			const color1 = new THREE.Color( '#ff3653' );
+			const color2 = new THREE.Color( '#8adb00' );
+			const color3 = new THREE.Color( '#2c8fff' );
+			const interactiveObjects = [];
+			const raycaster = new THREE.Raycaster();
+			const mouse = new THREE.Vector2();
+			const dummy = new THREE.Object3D();
+			const camera = new THREE.OrthographicCamera( - 2, 2, 2, - 2, 0, 4 );
+			camera.position.set( 0, 0, 2 );
+			const geometry = new THREE.BoxGeometry( 0.8, 0.05, 0.05 ).translate( 0.4, 0, 0 );
+			const xAxis = new THREE.Mesh( geometry, getAxisMaterial( color1 ) );
+			const yAxis = new THREE.Mesh( geometry, getAxisMaterial( color2 ) );
+			const zAxis = new THREE.Mesh( geometry, getAxisMaterial( color3 ) );
+			yAxis.rotation.z = Math.PI / 2;
+			zAxis.rotation.y = - Math.PI / 2;
+			this.add( xAxis );
+			this.add( zAxis );
+			this.add( yAxis );
+			const posXAxisHelper = new THREE.Sprite( getSpriteMaterial( color1, 'X' ) );
+			posXAxisHelper.userData.type = 'posX';
+			const posYAxisHelper = new THREE.Sprite( getSpriteMaterial( color2, 'Y' ) );
+			posYAxisHelper.userData.type = 'posY';
+			const posZAxisHelper = new THREE.Sprite( getSpriteMaterial( color3, 'Z' ) );
+			posZAxisHelper.userData.type = 'posZ';
+			const negXAxisHelper = new THREE.Sprite( getSpriteMaterial( color1 ) );
+			negXAxisHelper.userData.type = 'negX';
+			const negYAxisHelper = new THREE.Sprite( getSpriteMaterial( color2 ) );
+			negYAxisHelper.userData.type = 'negY';
+			const negZAxisHelper = new THREE.Sprite( getSpriteMaterial( color3 ) );
+			negZAxisHelper.userData.type = 'negZ';
+			posXAxisHelper.position.x = 1;
+			posYAxisHelper.position.y = 1;
+			posZAxisHelper.position.z = 1;
+			negXAxisHelper.position.x = - 1;
+			negXAxisHelper.scale.setScalar( 0.8 );
+			negYAxisHelper.position.y = - 1;
+			negYAxisHelper.scale.setScalar( 0.8 );
+			negZAxisHelper.position.z = - 1;
+			negZAxisHelper.scale.setScalar( 0.8 );
+			this.add( posXAxisHelper );
+			this.add( posYAxisHelper );
+			this.add( posZAxisHelper );
+			this.add( negXAxisHelper );
+			this.add( negYAxisHelper );
+			this.add( negZAxisHelper );
+			interactiveObjects.push( posXAxisHelper );
+			interactiveObjects.push( posYAxisHelper );
+			interactiveObjects.push( posZAxisHelper );
+			interactiveObjects.push( negXAxisHelper );
+			interactiveObjects.push( negYAxisHelper );
+			interactiveObjects.push( negZAxisHelper );
+			const point = new THREE.Vector3();
+			const dim = 128;
+			const turnRate = 2 * Math.PI; // turn rate in angles per second
+
+			this.render = function ( renderer ) {
+
+				this.quaternion.copy( editorCamera.quaternion ).invert();
+				this.updateMatrixWorld();
+				point.set( 0, 0, 1 );
+				point.applyQuaternion( editorCamera.quaternion );
+
+				if ( point.x >= 0 ) {
+
+					posXAxisHelper.material.opacity = 1;
+					negXAxisHelper.material.opacity = 0.5;
+
+				} else {
+
+					posXAxisHelper.material.opacity = 0.5;
+					negXAxisHelper.material.opacity = 1;
+
+				}
+
+				if ( point.y >= 0 ) {
+
+					posYAxisHelper.material.opacity = 1;
+					negYAxisHelper.material.opacity = 0.5;
+
+				} else {
+
+					posYAxisHelper.material.opacity = 0.5;
+					negYAxisHelper.material.opacity = 1;
+
+				}
+
+				if ( point.z >= 0 ) {
+
+					posZAxisHelper.material.opacity = 1;
+					negZAxisHelper.material.opacity = 0.5;
+
+				} else {
+
+					posZAxisHelper.material.opacity = 0.5;
+					negZAxisHelper.material.opacity = 1;
+
+				} //
+
+
+				const x = dom.offsetWidth - dim;
+				renderer.clearDepth();
+				renderer.getViewport( vpTemp );
+				renderer.setViewport( x, 0, dim, dim );
+				renderer.render( this, camera );
+				renderer.setViewport( vpTemp.x, vpTemp.y, vpTemp.z, vpTemp.w );
+
+			};
+
+			const targetPosition = new THREE.Vector3();
+			const targetQuaternion = new THREE.Quaternion();
+			const q1 = new THREE.Quaternion();
+			const q2 = new THREE.Quaternion();
+			let radius = 0;
+
+			this.handleClick = function ( event ) {
+
+				if ( this.animating === true ) return false;
+				const rect = dom.getBoundingClientRect();
+				const offsetX = rect.left + ( dom.offsetWidth - dim );
+				const offsetY = rect.top + ( dom.offsetHeight - dim );
+				mouse.x = ( event.clientX - offsetX ) / ( rect.width - offsetX ) * 2 - 1;
+				mouse.y = - ( ( event.clientY - offsetY ) / ( rect.bottom - offsetY ) ) * 2 + 1;
+				raycaster.setFromCamera( mouse, camera );
+				const intersects = raycaster.intersectObjects( interactiveObjects );
+
+				if ( intersects.length > 0 ) {
+
+					const intersection = intersects[ 0 ];
+					const object = intersection.object;
+					prepareAnimationData( object, this.controls.center );
+					this.animating = true;
+					return true;
+
+				} else {
+
+					return false;
+
+				}
+
+			};
+
+			this.update = function ( delta ) {
+
+				const step = delta * turnRate;
+				const focusPoint = this.controls.center; // animate position by doing a slerp and then scaling the position on the unit sphere
+
+				q1.rotateTowards( q2, step );
+				editorCamera.position.set( 0, 0, 1 ).applyQuaternion( q1 ).multiplyScalar( radius ).add( focusPoint ); // animate orientation
+
+				editorCamera.quaternion.rotateTowards( targetQuaternion, step );
+
+				if ( q1.angleTo( q2 ) === 0 ) {
+
+					this.animating = false;
+
+				}
+
+			};
+
+			function prepareAnimationData( object, focusPoint ) {
+
+				switch ( object.userData.type ) {
+
+					case 'posX':
+						targetPosition.set( 1, 0, 0 );
+						targetQuaternion.setFromEuler( new THREE.Euler( 0, Math.PI * 0.5, 0 ) );
+						break;
+
+					case 'posY':
+						targetPosition.set( 0, 1, 0 );
+						targetQuaternion.setFromEuler( new THREE.Euler( - Math.PI * 0.5, 0, 0 ) );
+						break;
+
+					case 'posZ':
+						targetPosition.set( 0, 0, 1 );
+						targetQuaternion.setFromEuler( new THREE.Euler() );
+						break;
+
+					case 'negX':
+						targetPosition.set( - 1, 0, 0 );
+						targetQuaternion.setFromEuler( new THREE.Euler( 0, - Math.PI * 0.5, 0 ) );
+						break;
+
+					case 'negY':
+						targetPosition.set( 0, - 1, 0 );
+						targetQuaternion.setFromEuler( new THREE.Euler( Math.PI * 0.5, 0, 0 ) );
+						break;
+
+					case 'negZ':
+						targetPosition.set( 0, 0, - 1 );
+						targetQuaternion.setFromEuler( new THREE.Euler( 0, Math.PI, 0 ) );
+						break;
+
+					default:
+						console.error( 'ViewHelper: Invalid axis.' );
+
+				} //
+
+
+				radius = editorCamera.position.distanceTo( focusPoint );
+				targetPosition.multiplyScalar( radius ).add( focusPoint );
+				dummy.position.copy( focusPoint );
+				dummy.lookAt( editorCamera.position );
+				q1.copy( dummy.quaternion );
+				dummy.lookAt( targetPosition );
+				q2.copy( dummy.quaternion );
+
+			}
+
+			function getAxisMaterial( color ) {
+
+				return new THREE.MeshBasicMaterial( {
+					color: color,
+					toneMapped: false
+				} );
+
+			}
+
+			function getSpriteMaterial( color, text = null ) {
+
+				const canvas = document.createElement( 'canvas' );
+				canvas.width = 64;
+				canvas.height = 64;
+				const context = canvas.getContext( '2d' );
+				context.beginPath();
+				context.arc( 32, 32, 16, 0, 2 * Math.PI );
+				context.closePath();
+				context.fillStyle = color.getStyle();
+				context.fill();
+
+				if ( text !== null ) {
+
+					context.font = '24px Arial';
+					context.textAlign = 'center';
+					context.fillStyle = '#000000';
+					context.fillText( text, 32, 41 );
+
+				}
+
+				const texture = new THREE.CanvasTexture( canvas );
+				return new THREE.SpriteMaterial( {
+					map: texture,
+					toneMapped: false
+				} );
+
+			}
+
+		}
+
+	}
+
+	THREE.ViewHelper = ViewHelper;
+
+} )();

package/examples/js/interactive/HTMLMesh.js

@@ -8,13 +8,14 @@
 			const geometry = new THREE.PlaneGeometry( texture.image.width * 0.001, texture.image.height * 0.001 );
 			const material = new THREE.MeshBasicMaterial( {
 				map: texture,
-				toneMapped: false
+				toneMapped: false,
+				transparent: true
 			} );
 			super( geometry, material );
 
 			function onEvent( event ) {
 
-				material.map.dispatchEvent( event );
+				material.map.dispatchDOMEvent( event );
 
 			}
 
@@ -23,6 +24,18 @@
 			this.addEventListener( 'mouseup', onEvent );
 			this.addEventListener( 'click', onEvent );
 
+			this.dispose = function () {
+
+				geometry.dispose();
+				material.dispose();
+				material.map.dispose();
+				this.removeEventListener( 'mousedown', onEvent );
+				this.removeEventListener( 'mousemove', onEvent );
+				this.removeEventListener( 'mouseup', onEvent );
+				this.removeEventListener( 'click', onEvent );
+
+			};
+
 		}
 
 	}
@@ -36,14 +49,36 @@
 			this.anisotropy = 16;
 			this.encoding = THREE.sRGBEncoding;
 			this.minFilter = THREE.LinearFilter;
-			this.magFilter = THREE.LinearFilter;
+			this.magFilter = THREE.LinearFilter; // Create an observer on the DOM, and run html2canvas update in the next loop
+
+			const observer = new MutationObserver( () => {
+
+				if ( ! this.scheduleUpdate ) {
+
+					// ideally should use xr.requestAnimationFrame, here setTimeout to avoid passing the renderer
+					this.scheduleUpdate = setTimeout( () => this.update(), 16 );
+
+				}
+
+			} );
+			const config = {
+				attributes: true,
+				childList: true,
+				subtree: true,
+				characterData: true
+			};
+			observer.observe( dom, config );
+			this.observer = observer;
 
 		}
 
-		dispatchEvent( event ) {
+		dispatchDOMEvent( event ) {
+
+			if ( event.data ) {
 
-			htmlevent( this.dom, event.type, event.data.x, event.data.y );
-			this.update();
+				htmlevent( this.dom, event.type, event.data.x, event.data.y );
+
+			}
 
 		}
 
@@ -51,6 +86,20 @@
 
 			this.image = html2canvas( this.dom );
 			this.needsUpdate = true;
+			this.scheduleUpdate = null;
+
+		}
+
+		dispose() {
+
+			if ( this.observer ) {
+
+				this.observer.disconnect();
+
+			}
+
+			this.scheduleUpdate = clearTimeout( this.scheduleUpdate );
+			super.dispose();
 
 		}
 
@@ -61,12 +110,13 @@
 
 	function html2canvas( element ) {
 
-		var range = document.createRange();
+		const range = document.createRange();
+		const color = new THREE.Color();
 
 		function Clipper( context ) {
 
-			var clips = [];
-			var isClipping = false;
+			const clips = [];
+			let isClipping = false;
 
 			function doClip() {
 
@@ -78,14 +128,14 @@
 				}
 
 				if ( clips.length === 0 ) return;
-				var minX = - Infinity,
+				let minX = - Infinity,
 					minY = - Infinity;
-				var maxX = Infinity,
+				let maxX = Infinity,
 					maxY = Infinity;
 
-				for ( var i = 0; i < clips.length; i ++ ) {
+				for ( let i = 0; i < clips.length; i ++ ) {
 
-					var clip = clips[ i ];
+					const clip = clips[ i ];
 					minX = Math.max( minX, clip.x );
 					minY = Math.max( minY, clip.y );
 					maxX = Math.min( maxX, clip.x + clip.width );
@@ -128,24 +178,39 @@
 
 				}
 
-				context.font = style.fontSize + ' ' + style.fontFamily;
+				context.font = style.fontWeight + ' ' + style.fontSize + ' ' + style.fontFamily;
 				context.textBaseline = 'top';
 				context.fillStyle = style.color;
-				context.fillText( string, x, y );
+				context.fillText( string, x, y + parseFloat( style.fontSize ) * 0.1 );
 
 			}
 
 		}
 
+		function buildRectPath( x, y, w, h, r ) {
+
+			if ( w < 2 * r ) r = w / 2;
+			if ( h < 2 * r ) r = h / 2;
+			context.beginPath();
+			context.moveTo( x + r, y );
+			context.arcTo( x + w, y, x + w, y + h, r );
+			context.arcTo( x + w, y + h, x, y + h, r );
+			context.arcTo( x, y + h, x, y, r );
+			context.arcTo( x, y, x + w, y, r );
+			context.closePath();
+
+		}
+
 		function drawBorder( style, which, x, y, width, height ) {
 
-			var borderWidth = style[ which + 'Width' ];
-			var borderStyle = style[ which + 'Style' ];
-			var borderColor = style[ which + 'Color' ];
+			const borderWidth = style[ which + 'Width' ];
+			const borderStyle = style[ which + 'Style' ];
+			const borderColor = style[ which + 'Color' ];
 
 			if ( borderWidth !== '0px' && borderStyle !== 'none' && borderColor !== 'transparent' && borderColor !== 'rgba(0, 0, 0, 0)' ) {
 
 				context.strokeStyle = borderColor;
+				context.lineWidth = parseFloat( borderWidth );
 				context.beginPath();
 				context.moveTo( x, y );
 				context.lineTo( x + width, y + height );
@@ -157,55 +222,184 @@
 
 		function drawElement( element, style ) {
 
-			var x = 0,
+			let x = 0,
 				y = 0,
 				width = 0,
 				height = 0;
 
-			if ( element.nodeType === 3 ) {
+			if ( element.nodeType === Node.TEXT_NODE ) {
 
 				// text
 				range.selectNode( element );
-				var rect = range.getBoundingClientRect();
+				const rect = range.getBoundingClientRect();
 				x = rect.left - offset.left - 0.5;
 				y = rect.top - offset.top - 0.5;
 				width = rect.width;
 				height = rect.height;
 				drawText( style, x, y, element.nodeValue.trim() );
 
+			} else if ( element.nodeType === Node.COMMENT_NODE ) {
+
+				return;
+
+			} else if ( element instanceof HTMLCanvasElement ) {
+
+				// Canvas element
+				if ( element.style.display === 'none' ) return;
+				context.save();
+				const dpr = window.devicePixelRatio;
+				context.scale( 1 / dpr, 1 / dpr );
+				context.drawImage( element, 0, 0 );
+				context.restore();
+
 			} else {
 
 				if ( element.style.display === 'none' ) return;
-				var rect = element.getBoundingClientRect();
+				const rect = element.getBoundingClientRect();
 				x = rect.left - offset.left - 0.5;
 				y = rect.top - offset.top - 0.5;
 				width = rect.width;
 				height = rect.height;
-				style = window.getComputedStyle( element );
-				var backgroundColor = style.backgroundColor;
+				style = window.getComputedStyle( element ); // Get the border of the element used for fill and border
+
+				buildRectPath( x, y, width, height, parseFloat( style.borderRadius ) );
+				const backgroundColor = style.backgroundColor;
 
 				if ( backgroundColor !== 'transparent' && backgroundColor !== 'rgba(0, 0, 0, 0)' ) {
 
 					context.fillStyle = backgroundColor;
-					context.fillRect( x, y, width, height );
+					context.fill();
+
+				} // If all the borders match then stroke the round rectangle
+
+
+				const borders = [ 'borderTop', 'borderLeft', 'borderBottom', 'borderRight' ];
+				let match = true;
+				let prevBorder = null;
+
+				for ( const border of borders ) {
+
+					if ( prevBorder !== null ) {
+
+						match = style[ border + 'Width' ] === style[ prevBorder + 'Width' ] && style[ border + 'Color' ] === style[ prevBorder + 'Color' ] && style[ border + 'Style' ] === style[ prevBorder + 'Style' ];
+
+					}
+
+					if ( match === false ) break;
+					prevBorder = border;
 
 				}
 
-				drawBorder( style, 'borderTop', x, y, width, 0 );
-				drawBorder( style, 'borderLeft', x, y, 0, height );
-				drawBorder( style, 'borderBottom', x, y + height, width, 0 );
-				drawBorder( style, 'borderRight', x + width, y, 0, height );
+				if ( match === true ) {
+
+					// They all match so stroke the rectangle from before allows for border-radius
+					const width = parseFloat( style.borderTopWidth );
+
+					if ( style.borderTopWidth !== '0px' && style.borderTopStyle !== 'none' && style.borderTopColor !== 'transparent' && style.borderTopColor !== 'rgba(0, 0, 0, 0)' ) {
+
+						context.strokeStyle = style.borderTopColor;
+						context.lineWidth = width;
+						context.stroke();
+
+					}
 
-				if ( element.type === 'color' || element.type === 'text' ) {
+				} else {
 
-					clipper.add( {
-						x: x,
-						y: y,
-						width: width,
-						height: height
-					} );
-					drawText( style, x + parseInt( style.paddingLeft ), y + parseInt( style.paddingTop ), element.value );
-					clipper.remove();
+					// Otherwise draw individual borders
+					drawBorder( style, 'borderTop', x, y, width, 0 );
+					drawBorder( style, 'borderLeft', x, y, 0, height );
+					drawBorder( style, 'borderBottom', x, y + height, width, 0 );
+					drawBorder( style, 'borderRight', x + width, y, 0, height );
+
+				}
+
+				if ( element instanceof HTMLInputElement ) {
+
+					let accentColor = style.accentColor;
+					if ( accentColor === undefined || accentColor === 'auto' ) accentColor = style.color;
+					color.set( accentColor );
+					const luminance = Math.sqrt( 0.299 * color.r ** 2 + 0.587 * color.g ** 2 + 0.114 * color.b ** 2 );
+					const accentTextColor = luminance < 0.5 ? 'white' : '#111111';
+
+					if ( element.type === 'radio' ) {
+
+						buildRectPath( x, y, width, height, height );
+						context.fillStyle = 'white';
+						context.strokeStyle = accentColor;
+						context.lineWidth = 1;
+						context.fill();
+						context.stroke();
+
+						if ( element.checked ) {
+
+							buildRectPath( x + 2, y + 2, width - 4, height - 4, height );
+							context.fillStyle = accentColor;
+							context.strokeStyle = accentTextColor;
+							context.lineWidth = 2;
+							context.fill();
+							context.stroke();
+
+						}
+
+					}
+
+					if ( element.type === 'checkbox' ) {
+
+						buildRectPath( x, y, width, height, 2 );
+						context.fillStyle = element.checked ? accentColor : 'white';
+						context.strokeStyle = element.checked ? accentTextColor : accentColor;
+						context.lineWidth = 1;
+						context.stroke();
+						context.fill();
+
+						if ( element.checked ) {
+
+							const currentTextAlign = context.textAlign;
+							context.textAlign = 'center';
+							const properties = {
+								color: accentTextColor,
+								fontFamily: style.fontFamily,
+								fontSize: height + 'px',
+								fontWeight: 'bold'
+							};
+							drawText( properties, x + width / 2, y, '✔' );
+							context.textAlign = currentTextAlign;
+
+						}
+
+					}
+
+					if ( element.type === 'range' ) {
+
+						const [ min, max, value ] = [ 'min', 'max', 'value' ].map( property => parseFloat( element[ property ] ) );
+						const position = ( value - min ) / ( max - min ) * ( width - height );
+						buildRectPath( x, y + height / 4, width, height / 2, height / 4 );
+						context.fillStyle = accentTextColor;
+						context.strokeStyle = accentColor;
+						context.lineWidth = 1;
+						context.fill();
+						context.stroke();
+						buildRectPath( x, y + height / 4, position + height / 2, height / 2, height / 4 );
+						context.fillStyle = accentColor;
+						context.fill();
+						buildRectPath( x + position, y, height, height, height / 2 );
+						context.fillStyle = accentColor;
+						context.fill();
+
+					}
+
+					if ( element.type === 'color' || element.type === 'text' || element.type === 'number' ) {
+
+						clipper.add( {
+							x: x,
+							y: y,
+							width: width,
+							height: height
+						} );
+						drawText( style, x + parseInt( style.paddingLeft ), y + parseInt( style.paddingTop ), element.value );
+						clipper.remove();
+
+					}
 
 				}
 
@@ -217,7 +411,7 @@
     */
 
 
-			var isClipping = style.overflow === 'auto' || style.overflow === 'hidden';
+			const isClipping = style.overflow === 'auto' || style.overflow === 'hidden';
 			if ( isClipping ) clipper.add( {
 				x: x,
 				y: y,
@@ -225,7 +419,7 @@
 				height: height
 			} );
 
-			for ( var i = 0; i < element.childNodes.length; i ++ ) {
+			for ( let i = 0; i < element.childNodes.length; i ++ ) {
 
 				drawElement( element.childNodes[ i ], style );
 
@@ -275,7 +469,7 @@
 
 		function traverse( element ) {
 
-			if ( element.nodeType !== 3 ) {
+			if ( element.nodeType !== Node.TEXT_NODE && element.nodeType !== Node.COMMENT_NODE ) {
 
 				const rect = element.getBoundingClientRect();
 
@@ -283,9 +477,22 @@
 
 					element.dispatchEvent( new MouseEvent( event, mouseEventInit ) );
 
+					if ( element instanceof HTMLInputElement && element.type === 'range' && ( event === 'mousedown' || event === 'click' ) ) {
+
+						const [ min, max ] = [ 'min', 'max' ].map( property => parseFloat( element[ property ] ) );
+						const width = rect.width;
+						const offsetX = x - rect.x;
+						const proportion = offsetX / width;
+						element.value = min + ( max - min ) * proportion;
+						element.dispatchEvent( new InputEvent( 'input', {
+							bubbles: true
+						} ) );
+
+					}
+
 				}
 
-				for ( var i = 0; i < element.childNodes.length; i ++ ) {
+				for ( let i = 0; i < element.childNodes.length; i ++ ) {
 
 					traverse( element.childNodes[ i ] );