super-three 0.152.0 → 0.154.1

package/examples/jsm/nodes/utils/EquirectUVNode.js

@@ -1,5 +1,4 @@
 import TempNode from '../core/TempNode.js';
-import { negate } from '../math/MathNode.js';
 import { positionWorldDirection } from '../accessors/PositionNode.js';
 import { nodeProxy, vec2 } from '../shadernode/ShaderNode.js';
 import { addNodeClass } from '../core/Node.js';
@@ -16,10 +15,10 @@ class EquirectUVNode extends TempNode {
 
 	construct() {
 
-		const dir = negate( this.dirNode );
+		const dir = this.dirNode;
 
 		const u = dir.z.atan2( dir.x ).mul( 1 / ( Math.PI * 2 ) ).add( 0.5 );
-		const v = dir.y.clamp( - 1.0, 1.0 ).asin().mul( 1 / Math.PI ).add( 0.5 );
+		const v = dir.y.negate().clamp( - 1.0, 1.0 ).asin().mul( 1 / Math.PI ).add( 0.5 ); // @TODO: The use of negate() here could be an NDC issue.
 
 		return vec2( u, v );
 

package/examples/jsm/nodes/utils/LoopNode.js

@@ -0,0 +1,186 @@
+import Node, { addNodeClass } from '../core/Node.js';
+import { expression } from '../code/ExpressionNode.js';
+import { bypass } from '../core/BypassNode.js';
+import { context as contextNode } from '../core/ContextNode.js';
+import { addNodeElement, nodeObject, nodeArray } from '../shadernode/ShaderNode.js';
+
+class LoopNode extends Node {
+
+	constructor( params = [] ) {
+
+		super();
+
+		this.params = params;
+
+	}
+
+	getVarName( index ) {
+
+		return String.fromCharCode( 'i'.charCodeAt() + index );
+
+	}
+
+	getProperties( builder ) {
+
+		const properties = builder.getNodeProperties( this );
+
+		if ( properties.stackNode !== undefined ) return properties;
+
+		//
+
+		const inputs = {};
+
+		for ( let i = 0, l = this.params.length - 1; i < l; i ++ ) {
+
+			const prop = this.getVarName( i );
+
+			inputs[ prop ] = expression( prop, 'int' );
+
+		}
+
+		properties.returnsNode = this.params[ this.params.length - 1 ]( inputs, builder.addStack(), builder );
+		properties.stackNode = builder.removeStack();
+
+		return properties;
+
+	}
+
+	getNodeType( builder ) {
+
+		const { returnsNode } = this.getProperties( builder );
+
+		return returnsNode ? returnsNode.getNodeType( builder ) : 'void';
+
+	}
+
+	construct( builder ) {
+
+		// construct properties
+
+		this.getProperties( builder );
+
+	}
+
+	generate( builder ) {
+
+		const properties = this.getProperties( builder );
+
+		const context = { tempWrite: false };
+
+		const params = this.params;
+		const stackNode = properties.stackNode;
+
+		const returnsSnippet = properties.returnsNode ? properties.returnsNode.build( builder ) : '';
+
+		for ( let i = 0, l = params.length - 1; i < l; i ++ ) {
+
+			const param = params[ i ];
+			const property = this.getVarName( i );
+
+			let start = null, end = null, direction = null;
+
+			if ( param.isNode ) {
+
+				start = '0';
+				end = param.generate( builder, 'int' );
+				direction = 'forward';
+
+			} else {
+
+				start = param.start;
+				end = param.end;
+				direction = param.direction;
+
+				if ( typeof start === 'number' ) start = start.toString();
+				else if ( start && start.isNode ) start = start.generate( builder, 'int' );
+
+				if ( typeof end === 'number' ) end = end.toString();
+				else if ( end && end.isNode ) end = end.generate( builder, 'int' );
+
+				if ( start !== undefined && end === undefined ) {
+
+					start = start + ' - 1';
+					end = '0';
+					direction = 'backwards';
+
+				} else if ( end !== undefined && start === undefined ) {
+
+					start = '0';
+					direction = 'forward';
+
+				}
+
+				if ( direction === undefined ) {
+
+					if ( Number( start ) > Number( end ) ) {
+
+						direction = 'backwards';
+
+					} else {
+
+						direction = 'forward';
+
+					}
+
+				}
+
+			}
+
+			const internalParam = { start, end, direction };
+
+			//
+
+			const startSnippet = internalParam.start;
+			const endSnippet = internalParam.end;
+
+			let declarationSnippet = '';
+			let conditionalSnippet = '';
+			let updateSnippet = '';
+
+			declarationSnippet += builder.getVar( 'int', property ) + ' = ' + startSnippet;
+
+			if ( internalParam.direction === 'backwards' ) {
+
+				conditionalSnippet += property + ' >= ' + endSnippet;
+				updateSnippet += property + ' --';
+
+			} else {
+
+				// forward
+
+				conditionalSnippet += property + ' < ' + endSnippet;
+				updateSnippet += property + ' ++';
+
+			}
+
+			const forSnippet = `for ( ${ declarationSnippet }; ${ conditionalSnippet }; ${ updateSnippet } )`;
+
+			builder.addFlowCode( ( i === 0 ? '\n' : '' ) + builder.tab + forSnippet + ' {\n\n' ).addFlowTab();
+
+		}
+
+		const stackSnippet = contextNode( stackNode, context ).build( builder, 'void' );
+
+		builder.removeFlowTab().addFlowCode( '\n' + builder.tab + stackSnippet );
+
+		for ( let i = 0, l = this.params.length - 1; i < l; i ++ ) {
+
+			builder.addFlowCode( ( i === 0 ? '' : builder.tab ) + '}\n\n' ).removeFlowTab();
+
+		}
+
+		builder.addFlowTab();
+
+		return returnsSnippet;
+
+	}
+
+}
+
+export default LoopNode;
+
+export const loop = ( ...params ) => nodeObject( new LoopNode( nodeArray( params, 'int' ) ) );
+
+addNodeElement( 'loop', ( returns, ...params ) => bypass( returns, loop( ...params ) ) );
+
+addNodeClass( LoopNode );

package/examples/jsm/nodes/utils/TriplanarTexturesNode.js

@@ -55,7 +55,7 @@ class TriplanarTexturesNode extends Node {
 export default TriplanarTexturesNode;
 
 export const triplanarTextures = nodeProxy( TriplanarTexturesNode );
-export const triplanarTexture = ( texture, ...params ) => triplanarTextures( texture, texture, texture, ...params );
+export const triplanarTexture = ( ...params ) => triplanarTextures( ...params );
 
 addNodeElement( 'triplanarTexture', triplanarTexture );
 

package/examples/jsm/objects/GroundProjectedSkybox.js

@@ -120,7 +120,7 @@ class GroundProjectedSkybox extends Mesh {
 					gl_FragColor = vec4( outcolor, 1.0 );
 
 					#include <tonemapping_fragment>
-					#include <encodings_fragment>
+					#include <colorspace_fragment>
 
 				}
 				`;

package/examples/jsm/objects/Lensflare.js

@@ -11,8 +11,7 @@ import {
 	RawShaderMaterial,
 	Vector2,
 	Vector3,
-	Vector4,
-	RGBAFormat
+	Vector4
 } from 'three';
 
 class Lensflare extends Mesh {
@@ -34,8 +33,8 @@ class Lensflare extends Mesh {
 
 		// textures
 
-		const tempMap = new FramebufferTexture( 16, 16, RGBAFormat );
-		const occlusionMap = new FramebufferTexture( 16, 16, RGBAFormat );
+		const tempMap = new FramebufferTexture( 16, 16 );
+		const occlusionMap = new FramebufferTexture( 16, 16 );
 
 		// material
 

package/examples/jsm/objects/MarchingCubes.js

@@ -3,7 +3,9 @@ import {
 	BufferGeometry,
 	Color,
 	DynamicDrawUsage,
-	Mesh
+	Mesh,
+	Sphere,
+	Vector3
 } from 'three';
 
 /**
@@ -94,6 +96,8 @@ class MarchingCubes extends Mesh {
 
 			}
 
+			geometry.boundingSphere = new Sphere( new Vector3(), 1 );
+
 		};
 
 		///////////////////////

package/examples/jsm/objects/Reflector.js

@@ -54,6 +54,7 @@ class Reflector extends Mesh {
 		const renderTarget = new WebGLRenderTarget( textureWidth, textureHeight, { samples: multisample, type: HalfFloatType } );
 
 		const material = new ShaderMaterial( {
+			name: ( shader.name !== undefined ) ? shader.name : 'unspecified',
 			uniforms: UniformsUtils.clone( shader.uniforms ),
 			fragmentShader: shader.fragmentShader,
 			vertexShader: shader.vertexShader
@@ -201,6 +202,8 @@ class Reflector extends Mesh {
 
 Reflector.ReflectorShader = {
 
+	name: 'ReflectorShader',
+
 	uniforms: {
 
 		'color': {
@@ -261,7 +264,7 @@ Reflector.ReflectorShader = {
 			gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );
 
 			#include <tonemapping_fragment>
-			#include <encodings_fragment>
+			#include <colorspace_fragment>
 
 		}`
 };

package/examples/jsm/objects/Refractor.js

@@ -323,7 +323,7 @@ Refractor.RefractorShader = {
 			gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );
 
 			#include <tonemapping_fragment>
-			#include <encodings_fragment>
+			#include <colorspace_fragment>
 
 		}`
 

package/examples/jsm/objects/Sky.js

@@ -210,7 +210,7 @@ Sky.SkyShader = {
 			gl_FragColor = vec4( retColor, 1.0 );
 
 			#include <tonemapping_fragment>
-			#include <encodings_fragment>
+			#include <colorspace_fragment>
 
 		}`
 

package/examples/jsm/objects/Water.js

@@ -181,7 +181,8 @@ class Water extends Mesh {
 					gl_FragColor = vec4( outgoingLight, alpha );
 
 					#include <tonemapping_fragment>
-					#include <fog_fragment>
+					#include <colorspace_fragment>
+					#include <fog_fragment>	
 				}`
 
 		};

package/examples/jsm/objects/Water2.js

@@ -348,7 +348,7 @@ Water.WaterShader = {
 			gl_FragColor = vec4( color, 1.0 ) * mix( refractColor, reflectColor, reflectance );
 
 			#include <tonemapping_fragment>
-			#include <encodings_fragment>
+			#include <colorspace_fragment>
 			#include <fog_fragment>
 
 		}`

package/examples/jsm/offscreen/scene.js

@@ -45,6 +45,7 @@ function init( canvas, width, height, pixelRatio, path ) {
 		renderer = new THREE.WebGLRenderer( { antialias: true, canvas: canvas } );
 		renderer.setPixelRatio( pixelRatio );
 		renderer.setSize( width, height, false );
+		renderer.useLegacyLights = false;
 
 		animate();
 

package/examples/jsm/physics/RapierPhysics.js

@@ -1,79 +1,72 @@
-async function RapierPhysics() {
-
-	const RAPIER = await import( 'https://cdn.skypack.dev/@dimforge/rapier3d-compat@0.11.2' );
-	
-	await RAPIER.init();
+import { Clock, Vector3, Quaternion, Matrix4 } from 'three';
 
-	const frameRate = 60;
+const RAPIER_PATH = 'https://cdn.skypack.dev/@dimforge/rapier3d-compat@0.11.2';
 
-	// Docs: https://rapier.rs/docs/api/javascript/JavaScript3D/	
+const frameRate = 60;
 
-	const gravity = { x: 0.0, y: - 9.81, z: 0.0 };
-	const world = new RAPIER.World( gravity );
+const _scale = new Vector3( 1, 1, 1 );
+const ZERO = new Vector3();
 
-	function getCollider( geometry ) {
+let RAPIER = null;
 
-		const parameters = geometry.parameters;
+function getCollider( geometry ) {
 
-		// TODO change type to is*
+	const parameters = geometry.parameters;
 
-		if ( geometry.type === 'BoxGeometry' ) {
+	// TODO change type to is*
 
-			const sx = parameters.width !== undefined ? parameters.width / 2 : 0.5;
-			const sy = parameters.height !== undefined ? parameters.height / 2 : 0.5;
-			const sz = parameters.depth !== undefined ? parameters.depth / 2 : 0.5;
+	if ( geometry.type === 'BoxGeometry' ) {
 
-			return RAPIER.ColliderDesc.cuboid( sx, sy, sz );
+		const sx = parameters.width !== undefined ? parameters.width / 2 : 0.5;
+		const sy = parameters.height !== undefined ? parameters.height / 2 : 0.5;
+		const sz = parameters.depth !== undefined ? parameters.depth / 2 : 0.5;
 
-		} else if ( geometry.type === 'SphereGeometry' || geometry.type === 'IcosahedronGeometry' ) {
+		return RAPIER.ColliderDesc.cuboid( sx, sy, sz );
 
-			const radius = parameters.radius !== undefined ? parameters.radius : 1;
-
-			return RAPIER.ColliderDesc.ball( radius );
-
-		}
+	} else if ( geometry.type === 'SphereGeometry' || geometry.type === 'IcosahedronGeometry' ) {
 
-		return null;
+		const radius = parameters.radius !== undefined ? parameters.radius : 1;
+		return RAPIER.ColliderDesc.ball( radius );
 
 	}
 
-	const meshes = [];
-	const meshMap = new WeakMap();
+	return null;
 
-	function addMesh( mesh, mass = 0, restitution = 0 ) {
+}
 
-		const shape = getCollider( mesh.geometry );
+async function RapierPhysics() {
 
-		if ( shape !== null ) {
+	if ( RAPIER === null ) {
 
-			shape.setMass( mass );
-			shape.setRestitution( restitution );
-	
-			if ( mesh.isInstancedMesh ) {
+		RAPIER = await import( RAPIER_PATH );
+		await RAPIER.init();
 
-				handleInstancedMesh( mesh, mass, shape );
+	}
 
-			} else if ( mesh.isMesh ) {
+	// Docs: https://rapier.rs/docs/api/javascript/JavaScript3D/	
 
-				handleMesh( mesh, mass, shape );
+	const gravity = new Vector3( 0.0, - 9.81, 0.0 );
+	const world = new RAPIER.World( gravity );
 
-			}
+	const meshes = [];
+	const meshMap = new WeakMap();
 
-		}
+	const _vector = new Vector3();
+	const _quaternion = new Quaternion();
+	const _matrix = new Matrix4();
 
-	}
+	function addMesh( mesh, mass = 0, restitution = 0 ) {
 
-	function handleMesh( mesh, mass, shape ) {
+		const shape = getCollider( mesh.geometry );
 
-		const position = mesh.position;
-		const quaternion = mesh.quaternion;
+		if ( shape === null ) return;
 
-		const desc = mass > 0 ? RAPIER.RigidBodyDesc.dynamic() : RAPIER.RigidBodyDesc.fixed();
-		desc.setTranslation( position.x, position.y, position.z );
-		desc.setRotation( quaternion );
+		shape.setMass( mass );
+		shape.setRestitution( restitution );
 
-		const body = world.createRigidBody( desc );
-		world.createCollider( shape, body );
+		const body = mesh.isInstancedMesh
+							? createInstancedBody( mesh, mass, shape )
+							: createBody( mesh.position, mesh.quaternion, mass, shape );
 
 		if ( mass > 0 ) {
 
@@ -84,7 +77,7 @@ async function RapierPhysics() {
 
 	}
 
-	function handleInstancedMesh( mesh, mass, shape ) {
+	function createInstancedBody( mesh, mass, shape ) {
 
 		const array = mesh.instanceMatrix.array;
 
@@ -92,107 +85,103 @@ async function RapierPhysics() {
 
 		for ( let i = 0; i < mesh.count; i ++ ) {
 
-			const index = i * 16;
+			const position = _vector.fromArray( array, i * 16 + 12 );
+			bodies.push( createBody( position, null, mass, shape ) );
 
-			const desc = mass > 0 ? RAPIER.RigidBodyDesc.dynamic() : RAPIER.RigidBodyDesc.fixed();
-			desc.setTranslation( array[ index + 12 ], array[ index + 13 ], array[ index + 14 ] );
+		}
 
-			const body = world.createRigidBody( desc );
-			world.createCollider( shape, body );
+		return bodies;
 
-			bodies.push( body );
+	}
 
-		}
+	function createBody( position, quaternion, mass, shape ) {
 
-		if ( mass > 0 ) {
+		const desc = mass > 0 ? RAPIER.RigidBodyDesc.dynamic() : RAPIER.RigidBodyDesc.fixed();
+		desc.setTranslation( ...position );
+		if ( quaternion !== null ) desc.setRotation( quaternion );
 
-			meshes.push( mesh );
-			meshMap.set( mesh, bodies );
+		const body = world.createRigidBody( desc );
+		world.createCollider( shape, body );
 
-		}
+		return body;
 
 	}
 
-	const vector = { x: 0, y: 0, z: 0 };
-
 	function setMeshPosition( mesh, position, index = 0 ) {
 
+		let body = meshMap.get( mesh );
+
 		if ( mesh.isInstancedMesh ) {
 
-			const bodies = meshMap.get( mesh );
-			const body = bodies[ index ];
+			body = body[ index ];
 
-			body.setAngvel( vector );
-			body.setLinvel( vector );
-			body.setTranslation( position );
+		}
 
-		} else if ( mesh.isMesh ) {
+		body.setAngvel( ZERO );
+		body.setLinvel( ZERO );
+		body.setTranslation( position );
 
-			const body = meshMap.get( mesh );
+	}
 
-			body.setAngvel( vector );
-			body.setLinvel( vector );
-			body.setTranslation( position );
+	function setMeshVelocity( mesh, velocity, index = 0 ) {
 
-		}
+		let body = meshMap.get( mesh );
 
-	}
+		if ( mesh.isInstancedMesh ) {
 
-	//
+			body = body[ index ];
 
-	let lastTime = 0;
+		}
 
-	function step() {
+		body.setLinvel( velocity );
 
-		const time = performance.now();
+	}
 
-		if ( lastTime > 0 ) {
+	//
 
-			const delta = ( time - lastTime ) / 1000;
+	const clock = new Clock();
 
-			world.timestep = delta;
-			world.step();
+	function step() {
 
-			//
+		world.timestep = clock.getDelta();
+		world.step();
 
-			for ( let i = 0, l = meshes.length; i < l; i ++ ) {
+		//
 
-				const mesh = meshes[ i ];
+		for ( let i = 0, l = meshes.length; i < l; i ++ ) {
 
-				if ( mesh.isInstancedMesh ) {
+			const mesh = meshes[ i ];
 
-					const array = mesh.instanceMatrix.array;
-					const bodies = meshMap.get( mesh );
+			if ( mesh.isInstancedMesh ) {
 
-					for ( let j = 0; j < bodies.length; j ++ ) {
+				const array = mesh.instanceMatrix.array;
+				const bodies = meshMap.get( mesh );
 
-						const body = bodies[ j ];
+				for ( let j = 0; j < bodies.length; j ++ ) {
 
-						const position = body.translation();
-						const quaternion = body.rotation();
+					const body = bodies[ j ];
 
-						compose( position, quaternion, array, j * 16 );
+					const position = body.translation();
+					_quaternion.copy( body.rotation() );
 
-					}
+					_matrix.compose( position, _quaternion, _scale ).toArray( array, j * 16 );
 
-					mesh.instanceMatrix.needsUpdate = true;
-					mesh.computeBoundingSphere();
+				}
 
-				} else if ( mesh.isMesh ) {
+				mesh.instanceMatrix.needsUpdate = true;
+				mesh.computeBoundingSphere();
 
-					const body = meshMap.get( mesh );
+			} else {
 
-					mesh.position.copy( body.translation() );
-					mesh.quaternion.copy( body.rotation() );
+				const body = meshMap.get( mesh );
 
-				}
+				mesh.position.copy( body.translation() );
+				mesh.quaternion.copy( body.rotation() );
 
 			}
 
 		}
 
-		lastTime = time;
-
 	}
 
 	// animate
@@ -201,39 +190,10 @@ async function RapierPhysics() {
 
 	return {
 		addMesh: addMesh,
-		setMeshPosition: setMeshPosition
+		setMeshPosition: setMeshPosition,
+		setMeshVelocity: setMeshVelocity
 	};
 
 }
 
-function compose( position, quaternion, array, index ) {
-
-	const x = quaternion.x, y = quaternion.y, z = quaternion.z, w = quaternion.w;
-	const x2 = x + x, y2 = y + y, z2 = z + z;
-	const xx = x * x2, xy = x * y2, xz = x * z2;
-	const yy = y * y2, yz = y * z2, zz = z * z2;
-	const wx = w * x2, wy = w * y2, wz = w * z2;
-
-	array[ index + 0 ] = ( 1 - ( yy + zz ) );
-	array[ index + 1 ] = ( xy + wz );
-	array[ index + 2 ] = ( xz - wy );
-	array[ index + 3 ] = 0;
-
-	array[ index + 4 ] = ( xy - wz );
-	array[ index + 5 ] = ( 1 - ( xx + zz ) );
-	array[ index + 6 ] = ( yz + wx );
-	array[ index + 7 ] = 0;
-
-	array[ index + 8 ] = ( xz + wy );
-	array[ index + 9 ] = ( yz - wx );
-	array[ index + 10 ] = ( 1 - ( xx + yy ) );
-	array[ index + 11 ] = 0;
-
-	array[ index + 12 ] = position.x;
-	array[ index + 13 ] = position.y;
-	array[ index + 14 ] = position.z;
-	array[ index + 15 ] = 1;
-
-}
-
 export { RapierPhysics };