super-three 0.147.1 → 0.154.0

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

@@ -1,5 +1,9 @@
-import Node from '../core/Node.js';
-import { float, vec3, add, mul, div, dot, normalize, abs, texture, positionWorld, normalWorld } from '../shadernode/ShaderNodeBaseElements.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { add } from '../math/OperatorNode.js';
+import { normalWorld } from '../accessors/NormalNode.js';
+import { positionWorld } from '../accessors/PositionNode.js';
+import { texture } from '../accessors/TextureNode.js';
+import { addNodeElement, nodeProxy, float, vec3 } from '../shadernode/ShaderNode.js';
 
 class TriplanarTexturesNode extends Node {
 
@@ -25,22 +29,22 @@ class TriplanarTexturesNode extends Node {
 		// Ref: https://github.com/keijiro/StandardTriplanar
 
 		// Blending factor of triplanar mapping
-		let bf = normalize( abs( normalNode ) );
-		bf = div( bf, dot( bf, vec3( 1.0 ) ) );
+		let bf = normalNode.abs().normalize();
+		bf = bf.div( bf.dot( vec3( 1.0 ) ) );
 
 		// Triplanar mapping
-		const tx = mul( positionNode.yz, scaleNode );
-		const ty = mul( positionNode.zx, scaleNode );
-		const tz = mul( positionNode.xy, scaleNode );
+		const tx = positionNode.yz.mul( scaleNode );
+		const ty = positionNode.zx.mul( scaleNode );
+		const tz = positionNode.xy.mul( scaleNode );
 
 		// Base color
 		const textureX = textureXNode.value;
 		const textureY = textureYNode !== null ? textureYNode.value : textureX;
 		const textureZ = textureZNode !== null ? textureZNode.value : textureX;
 
-		const cx = mul( texture( textureX, tx ), bf.x );
-		const cy = mul( texture( textureY, ty ), bf.y );
-		const cz = mul( texture( textureZ, tz ), bf.z );
+		const cx = texture( textureX, tx ).mul( bf.x );
+		const cy = texture( textureY, ty ).mul( bf.y );
+		const cz = texture( textureZ, tz ).mul( bf.z );
 
 		return add( cx, cy, cz );
 
@@ -49,3 +53,10 @@ class TriplanarTexturesNode extends Node {
 }
 
 export default TriplanarTexturesNode;
+
+export const triplanarTextures = nodeProxy( TriplanarTexturesNode );
+export const triplanarTexture = ( ...params ) => triplanarTextures( ...params );
+
+addNodeElement( 'triplanarTexture', triplanarTexture );
+
+addNodeClass( TriplanarTexturesNode );

package/examples/jsm/objects/GroundProjectedSkybox.js

@@ -0,0 +1,172 @@
+import { Mesh, IcosahedronGeometry, ShaderMaterial, DoubleSide } from 'three';
+
+/**
+ * Ground projected env map adapted from @react-three/drei.
+ * https://github.com/pmndrs/drei/blob/master/src/core/Environment.tsx
+ */
+class GroundProjectedSkybox extends Mesh {
+
+	constructor( texture, options = {} ) {
+
+		const isCubeMap = texture.isCubeTexture;
+
+		const defines = [
+			isCubeMap ? '#define ENVMAP_TYPE_CUBE' : ''
+		];
+
+		const vertexShader = /* glsl */ `
+			varying vec3 vWorldPosition;
+
+			void main() {
+
+				vec4 worldPosition = ( modelMatrix * vec4( position, 1.0 ) );
+				vWorldPosition = worldPosition.xyz;
+
+				gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+			}
+			`;
+		const fragmentShader = defines.join( '\n' ) + /* glsl */ `
+
+				varying vec3 vWorldPosition;
+
+				uniform float radius;
+				uniform float height;
+				uniform float angle;
+
+				#ifdef ENVMAP_TYPE_CUBE
+
+					uniform samplerCube map;
+
+				#else
+
+					uniform sampler2D map;
+
+				#endif
+
+				// From: https://www.shadertoy.com/view/4tsBD7
+				float diskIntersectWithBackFaceCulling( vec3 ro, vec3 rd, vec3 c, vec3 n, float r ) 
+				{
+
+					float d = dot ( rd, n );
+
+					if( d > 0.0 ) { return 1e6; }
+
+					vec3 o = ro - c;
+					float t = - dot( n, o ) / d;
+					vec3 q = o + rd * t;
+
+					return ( dot( q, q ) < r * r ) ? t : 1e6;
+
+				}
+
+				// From: https://www.iquilezles.org/www/articles/intersectors/intersectors.htm
+				float sphereIntersect( vec3 ro, vec3 rd, vec3 ce, float ra ) {
+
+					vec3 oc = ro - ce;
+					float b = dot( oc, rd );
+					float c = dot( oc, oc ) - ra * ra;
+					float h = b * b - c;
+
+					if( h < 0.0 ) { return -1.0; }
+
+					h = sqrt( h );
+
+					return - b + h;
+
+				}
+
+				vec3 project() {
+
+					vec3 p = normalize( vWorldPosition );
+					vec3 camPos = cameraPosition;
+					camPos.y -= height;
+
+					float intersection = sphereIntersect( camPos, p, vec3( 0.0 ), radius );
+					if( intersection > 0.0 ) {
+
+						vec3 h = vec3( 0.0, - height, 0.0 );
+						float intersection2 = diskIntersectWithBackFaceCulling( camPos, p, h, vec3( 0.0, 1.0, 0.0 ), radius );
+						p = ( camPos + min( intersection, intersection2 ) * p ) / radius;
+
+					} else {
+
+						p = vec3( 0.0, 1.0, 0.0 );
+
+					}
+
+					return p;
+
+				}
+
+				#include <common>
+
+				void main() {
+
+					vec3 projectedWorldPosition = project();
+
+					#ifdef ENVMAP_TYPE_CUBE
+
+						vec3 outcolor = textureCube( map, projectedWorldPosition ).rgb;
+
+					#else
+
+						vec3 direction = normalize( projectedWorldPosition );
+						vec2 uv = equirectUv( direction );
+						vec3 outcolor = texture2D( map, uv ).rgb;
+
+					#endif
+
+					gl_FragColor = vec4( outcolor, 1.0 );
+
+					#include <tonemapping_fragment>
+					#include <colorspace_fragment>
+
+				}
+				`;
+
+		const uniforms = {
+			map: { value: texture },
+			height: { value: options.height || 15 },
+			radius: { value: options.radius || 100 },
+		};
+
+		const geometry = new IcosahedronGeometry( 1, 16 );
+		const material = new ShaderMaterial( {
+			uniforms,
+			fragmentShader,
+			vertexShader,
+			side: DoubleSide,
+		} );
+
+		super( geometry, material );
+
+	}
+
+	set radius( radius ) {
+
+		this.material.uniforms.radius.value = radius;
+
+	}
+
+	get radius() {
+
+		return this.material.uniforms.radius.value;
+
+	}
+
+	set height( height ) {
+
+		this.material.uniforms.height.value = height;
+
+	}
+
+	get height() {
+
+		return this.material.uniforms.height.value;
+
+	}
+
+}
+
+export { GroundProjectedSkybox };

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

@@ -11,7 +11,7 @@ import {
 	WebGLRenderTarget,
 	HalfFloatType,
 	NoToneMapping,
-	LinearEncoding
+	LinearSRGBColorSpace
 } from 'three';
 
 class Reflector extends Mesh {
@@ -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
@@ -146,12 +147,12 @@ class Reflector extends Mesh {
 
 			const currentXrEnabled = renderer.xr.enabled;
 			const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
-			const currentOutputEncoding = renderer.outputEncoding;
+			const currentOutputColorSpace = renderer.outputColorSpace;
 			const currentToneMapping = renderer.toneMapping;
 
 			renderer.xr.enabled = false; // Avoid camera modification
 			renderer.shadowMap.autoUpdate = false; // Avoid re-computing shadows
-			renderer.outputEncoding = LinearEncoding;
+			renderer.outputColorSpace = LinearSRGBColorSpace;
 			renderer.toneMapping = NoToneMapping;
 
 			renderer.setRenderTarget( renderTarget );
@@ -163,7 +164,7 @@ class Reflector extends Mesh {
 
 			renderer.xr.enabled = currentXrEnabled;
 			renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
-			renderer.outputEncoding = currentOutputEncoding;
+			renderer.outputColorSpace = currentOutputColorSpace;
 			renderer.toneMapping = currentToneMapping;
 
 			renderer.setRenderTarget( currentRenderTarget );
@@ -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

@@ -10,7 +10,7 @@ import {
 	Vector3,
 	Vector4,
 	WebGLRenderTarget,
-	LinearEncoding,
+	LinearSRGBColorSpace,
 	NoToneMapping,
 	HalfFloatType
 } from 'three';
@@ -194,12 +194,12 @@ class Refractor extends Mesh {
 			const currentRenderTarget = renderer.getRenderTarget();
 			const currentXrEnabled = renderer.xr.enabled;
 			const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
-			const currentOutputEncoding = renderer.outputEncoding;
+			const currentOutputColorSpace = renderer.outputColorSpace;
 			const currentToneMapping = renderer.toneMapping;
 
 			renderer.xr.enabled = false; // avoid camera modification
 			renderer.shadowMap.autoUpdate = false; // avoid re-computing shadows
-			renderer.outputEncoding = LinearEncoding;
+			renderer.outputColorSpace = LinearSRGBColorSpace;
 			renderer.toneMapping = NoToneMapping;
 
 			renderer.setRenderTarget( renderTarget );
@@ -208,7 +208,7 @@ class Refractor extends Mesh {
 
 			renderer.xr.enabled = currentXrEnabled;
 			renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
-			renderer.outputEncoding = currentOutputEncoding;
+			renderer.outputColorSpace = currentOutputColorSpace;
 			renderer.toneMapping = currentToneMapping;
 			renderer.setRenderTarget( currentRenderTarget );
 
@@ -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/ShadowMesh.js

@@ -23,9 +23,9 @@ class ShadowMesh extends Mesh {
 			opacity: 0.6,
 			depthWrite: false,
 			stencilWrite: true,
-            		stencilFunc: EqualStencilFunc,
-            		stencilRef: 0,
-            		stencilZPass: IncrementStencilOp
+			stencilFunc: EqualStencilFunc,
+			stencilRef: 0,
+			stencilZPass: IncrementStencilOp
 
 		} );
 

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/AmmoPhysics.js

@@ -188,57 +188,56 @@ async function AmmoPhysics() {
 
 			const delta = ( time - lastTime ) / 1000;
 
-			// console.time( 'world.step' );
 			world.stepSimulation( delta, 10 );
-			// console.timeEnd( 'world.step' );
 
-		}
+			//
 
-		lastTime = time;
+			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 motionState = body.getMotionState();
+						motionState.getWorldTransform( worldTransform );
 
-					const body = bodies[ j ];
+						const position = worldTransform.getOrigin();
+						const quaternion = worldTransform.getRotation();
 
-					const motionState = body.getMotionState();
-					motionState.getWorldTransform( worldTransform );
+						compose( position, quaternion, array, j * 16 );
 
-					const position = worldTransform.getOrigin();
-					const quaternion = worldTransform.getRotation();
+					}
 
-					compose( position, quaternion, array, j * 16 );
+					mesh.instanceMatrix.needsUpdate = true;
+					mesh.computeBoundingSphere();
 
-				}
+				} else if ( mesh.isMesh ) {
 
-				mesh.instanceMatrix.needsUpdate = true;
+					const body = meshMap.get( mesh );
 
-			} else if ( mesh.isMesh ) {
-
-				const body = meshMap.get( mesh );
+					const motionState = body.getMotionState();
+					motionState.getWorldTransform( worldTransform );
 
-				const motionState = body.getMotionState();
-				motionState.getWorldTransform( worldTransform );
+					const position = worldTransform.getOrigin();
+					const quaternion = worldTransform.getRotation();
+					mesh.position.set( position.x(), position.y(), position.z() );
+					mesh.quaternion.set( quaternion.x(), quaternion.y(), quaternion.z(), quaternion.w() );
 
-				const position = worldTransform.getOrigin();
-				const quaternion = worldTransform.getRotation();
-				mesh.position.set( position.x(), position.y(), position.z() );
-				mesh.quaternion.set( quaternion.x(), quaternion.y(), quaternion.z(), quaternion.w() );
+				}
 
 			}
 
 		}
 
+		lastTime = time;
+
 	}
 
 	// animate