@needle-tools/three 0.146.10 → 0.153.1

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': {

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 );
 

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

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

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

package/examples/jsm/physics/RapierPhysics.js

@@ -0,0 +1,199 @@
+import { Clock, Vector3, Quaternion, Matrix4 } from 'three';
+
+const RAPIER_PATH = 'https://cdn.skypack.dev/@dimforge/rapier3d-compat@0.11.2';
+
+const frameRate = 60;
+
+const _scale = new Vector3( 1, 1, 1 );
+const ZERO = new Vector3();
+
+let RAPIER = null;
+
+function getCollider( geometry ) {
+
+	const parameters = geometry.parameters;
+
+	// TODO change type to is*
+
+	if ( geometry.type === 'BoxGeometry' ) {
+
+		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;
+
+		return RAPIER.ColliderDesc.cuboid( sx, sy, sz );
+
+	} else if ( geometry.type === 'SphereGeometry' || geometry.type === 'IcosahedronGeometry' ) {
+
+		const radius = parameters.radius !== undefined ? parameters.radius : 1;
+		return RAPIER.ColliderDesc.ball( radius );
+
+	}
+
+	return null;
+
+}
+
+async function RapierPhysics() {
+
+	if ( RAPIER === null ) {
+
+		RAPIER = await import( RAPIER_PATH );
+		await RAPIER.init();
+
+	}
+
+	// Docs: https://rapier.rs/docs/api/javascript/JavaScript3D/	
+
+	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 ) {
+
+		const shape = getCollider( mesh.geometry );
+
+		if ( shape === null ) return;
+
+		shape.setMass( mass );
+		shape.setRestitution( restitution );
+
+		const body = mesh.isInstancedMesh
+							? createInstancedBody( mesh, mass, shape )
+							: createBody( mesh.position, mesh.quaternion, mass, shape );
+
+		if ( mass > 0 ) {
+
+			meshes.push( mesh );
+			meshMap.set( mesh, body );
+
+		}
+
+	}
+
+	function createInstancedBody( mesh, mass, shape ) {
+
+		const array = mesh.instanceMatrix.array;
+
+		const bodies = [];
+
+		for ( let i = 0; i < mesh.count; i ++ ) {
+
+			const position = _vector.fromArray( array, i * 16 + 12 );
+			bodies.push( createBody( position, null, mass, shape ) );
+
+		}
+
+		return bodies;
+
+	}
+
+	function createBody( position, quaternion, mass, shape ) {
+
+		const desc = mass > 0 ? RAPIER.RigidBodyDesc.dynamic() : RAPIER.RigidBodyDesc.fixed();
+		desc.setTranslation( ...position );
+		if ( quaternion !== null ) desc.setRotation( quaternion );
+
+		const body = world.createRigidBody( desc );
+		world.createCollider( shape, body );
+
+		return body;
+
+	}
+
+	function setMeshPosition( mesh, position, index = 0 ) {
+
+		let body = meshMap.get( mesh );
+
+		if ( mesh.isInstancedMesh ) {
+
+			body = body[ index ];
+
+		}
+
+		body.setAngvel( ZERO );
+		body.setLinvel( ZERO );
+		body.setTranslation( position );
+
+	}
+
+	function setMeshVelocity( mesh, velocity, index = 0 ) {
+
+		let body = meshMap.get( mesh );
+
+		if ( mesh.isInstancedMesh ) {
+
+			body = body[ index ];
+
+		}
+
+		body.setLinvel( velocity );
+
+	}
+
+	//
+
+	const clock = new Clock();
+
+	function step() {
+
+		world.timestep = clock.getDelta();
+		world.step();
+
+		//
+
+		for ( let i = 0, l = meshes.length; i < l; i ++ ) {
+
+			const mesh = meshes[ i ];
+
+			if ( mesh.isInstancedMesh ) {
+
+				const array = mesh.instanceMatrix.array;
+				const bodies = meshMap.get( mesh );
+
+				for ( let j = 0; j < bodies.length; j ++ ) {
+
+					const body = bodies[ j ];
+
+					const position = body.translation();
+					_quaternion.copy( body.rotation() );
+
+					_matrix.compose( position, _quaternion, _scale ).toArray( array, j * 16 );
+
+				}
+
+				mesh.instanceMatrix.needsUpdate = true;
+				mesh.computeBoundingSphere();
+
+			} else {
+
+				const body = meshMap.get( mesh );
+
+				mesh.position.copy( body.translation() );
+				mesh.quaternion.copy( body.rotation() );
+
+			}
+
+		}
+
+	}
+
+	// animate
+
+	setInterval( step, 1000 / frameRate );
+
+	return {
+		addMesh: addMesh,
+		setMeshPosition: setMeshPosition,
+		setMeshVelocity: setMeshVelocity
+	};
+
+}
+
+export { RapierPhysics };

package/examples/jsm/postprocessing/AfterimagePass.js

@@ -1,4 +1,5 @@
 import {
+	HalfFloatType,
 	MeshBasicMaterial,
 	NearestFilter,
 	ShaderMaterial,
@@ -14,8 +15,6 @@ class AfterimagePass extends Pass {
 
 		super();
 
-		if ( AfterimageShader === undefined ) console.error( 'THREE.AfterimagePass relies on AfterimageShader' );
-
 		this.shader = AfterimageShader;
 
 		this.uniforms = UniformsUtils.clone( this.shader.uniforms );
@@ -24,10 +23,12 @@ class AfterimagePass extends Pass {
 
 		this.textureComp = new WebGLRenderTarget( window.innerWidth, window.innerHeight, {
 			magFilter: NearestFilter,
+			type: HalfFloatType
 		} );
 
 		this.textureOld = new WebGLRenderTarget( window.innerWidth, window.innerHeight, {
 			magFilter: NearestFilter,
+			type: HalfFloatType
 		} );
 
 		this.compFsMaterial = new ShaderMaterial( {

package/examples/jsm/postprocessing/BloomPass.js

@@ -1,5 +1,6 @@
 import {
 	AdditiveBlending,
+	HalfFloatType,
 	ShaderMaterial,
 	UniformsUtils,
 	Vector2,
@@ -16,9 +17,9 @@ class BloomPass extends Pass {
 
 		// render targets
 
-		this.renderTargetX = new WebGLRenderTarget(); // will be resized later
+		this.renderTargetX = new WebGLRenderTarget( 1, 1, { type: HalfFloatType } ); // will be resized later
 		this.renderTargetX.texture.name = 'BloomPass.x';
-		this.renderTargetY = new WebGLRenderTarget(); // will be resized later
+		this.renderTargetY = new WebGLRenderTarget( 1, 1, { type: HalfFloatType } ); // will be resized later
 		this.renderTargetY.texture.name = 'BloomPass.y';
 
 		// combine material
@@ -29,6 +30,7 @@ class BloomPass extends Pass {
 
 		this.materialCombine = new ShaderMaterial( {
 
+			name: CombineShader.name,
 			uniforms: this.combineUniforms,
 			vertexShader: CombineShader.vertexShader,
 			fragmentShader: CombineShader.fragmentShader,
@@ -39,8 +41,6 @@ class BloomPass extends Pass {
 
 		// convolution material
 
-		if ( ConvolutionShader === undefined ) console.error( 'THREE.BloomPass relies on ConvolutionShader' );
-
 		const convolutionShader = ConvolutionShader;
 
 		this.convolutionUniforms = UniformsUtils.clone( convolutionShader.uniforms );
@@ -50,6 +50,7 @@ class BloomPass extends Pass {
 
 		this.materialConvolution = new ShaderMaterial( {
 
+			name: convolutionShader.name,
 			uniforms: this.convolutionUniforms,
 			vertexShader: convolutionShader.vertexShader,
 			fragmentShader: convolutionShader.fragmentShader,
@@ -128,6 +129,8 @@ class BloomPass extends Pass {
 
 const CombineShader = {
 
+	name: 'CombineShader',
+
 	uniforms: {
 
 		'tDiffuse': { value: null },

package/examples/jsm/postprocessing/BokehPass.js

@@ -1,5 +1,6 @@
 import {
 	Color,
+	HalfFloatType,
 	MeshDepthMaterial,
 	NearestFilter,
 	NoBlending,
@@ -33,7 +34,8 @@ class BokehPass extends Pass {
 
 		this.renderTargetDepth = new WebGLRenderTarget( 1, 1, { // will be resized later
 			minFilter: NearestFilter,
-			magFilter: NearestFilter
+			magFilter: NearestFilter,
+			type: HalfFloatType
 		} );
 
 		this.renderTargetDepth.texture.name = 'BokehPass.depth';
@@ -46,12 +48,6 @@ class BokehPass extends Pass {
 
 		// bokeh material
 
-		if ( BokehShader === undefined ) {
-
-			console.error( 'THREE.BokehPass relies on BokehShader' );
-
-		}
-
 		const bokehShader = BokehShader;
 		const bokehUniforms = UniformsUtils.clone( bokehShader.uniforms );
 
@@ -72,7 +68,6 @@ class BokehPass extends Pass {
 		} );
 
 		this.uniforms = bokehUniforms;
-		this.needsSwap = false;
 
 		this.fsQuad = new FullScreenQuad( this.materialBokeh );
 

package/examples/jsm/postprocessing/DotScreenPass.js

@@ -11,8 +11,6 @@ class DotScreenPass extends Pass {
 
 		super();
 
-		if ( DotScreenShader === undefined ) console.error( 'THREE.DotScreenPass relies on DotScreenShader' );
-
 		const shader = DotScreenShader;
 
 		this.uniforms = UniformsUtils.clone( shader.uniforms );
@@ -23,6 +21,7 @@ class DotScreenPass extends Pass {
 
 		this.material = new ShaderMaterial( {
 
+			name: shader.name,
 			uniforms: this.uniforms,
 			vertexShader: shader.vertexShader,
 			fragmentShader: shader.fragmentShader

package/examples/jsm/postprocessing/EffectComposer.js

@@ -1,9 +1,6 @@
 import {
-	BufferGeometry,
 	Clock,
-	Float32BufferAttribute,
-	Mesh,
-	OrthographicCamera,
+	HalfFloatType,
 	Vector2,
 	WebGLRenderTarget
 } from 'three';
@@ -18,19 +15,19 @@ class EffectComposer {
 
 		this.renderer = renderer;
 
+		this._pixelRatio = renderer.getPixelRatio();
+
 		if ( renderTarget === undefined ) {
 
 			const size = renderer.getSize( new Vector2() );
-			this._pixelRatio = renderer.getPixelRatio();
 			this._width = size.width;
 			this._height = size.height;
 
-			renderTarget = new WebGLRenderTarget( this._width * this._pixelRatio, this._height * this._pixelRatio );
+			renderTarget = new WebGLRenderTarget( this._width * this._pixelRatio, this._height * this._pixelRatio, { type: HalfFloatType } );
 			renderTarget.texture.name = 'EffectComposer.rt1';
 
 		} else {
 
-			this._pixelRatio = 1;
 			this._width = renderTarget.width;
 			this._height = renderTarget.height;
 
@@ -47,20 +44,6 @@ class EffectComposer {
 
 		this.passes = [];
 
-		// dependencies
-
-		if ( CopyShader === undefined ) {
-
-			console.error( 'THREE.EffectComposer relies on CopyShader' );
-
-		}
-
-		if ( ShaderPass === undefined ) {
-
-			console.error( 'THREE.EffectComposer relies on ShaderPass' );
-
-		}
-
 		this.copyPass = new ShaderPass( CopyShader );
 
 		this.clock = new Clock();
@@ -243,77 +226,4 @@ class EffectComposer {
 
 }
 
-
-class Pass {
-
-	constructor() {
-
-		// if set to true, the pass is processed by the composer
-		this.enabled = true;
-
-		// if set to true, the pass indicates to swap read and write buffer after rendering
-		this.needsSwap = true;
-
-		// if set to true, the pass clears its buffer before rendering
-		this.clear = false;
-
-		// if set to true, the result of the pass is rendered to screen. This is set automatically by EffectComposer.
-		this.renderToScreen = false;
-
-	}
-
-	setSize( /* width, height */ ) {}
-
-	render( /* renderer, writeBuffer, readBuffer, deltaTime, maskActive */ ) {
-
-		console.error( 'THREE.Pass: .render() must be implemented in derived pass.' );
-
-	}
-
-}
-
-// Helper for passes that need to fill the viewport with a single quad.
-
-const _camera = new OrthographicCamera( - 1, 1, 1, - 1, 0, 1 );
-
-// https://github.com/mrdoob/three.js/pull/21358
-
-const _geometry = new BufferGeometry();
-_geometry.setAttribute( 'position', new Float32BufferAttribute( [ - 1, 3, 0, - 1, - 1, 0, 3, - 1, 0 ], 3 ) );
-_geometry.setAttribute( 'uv', new Float32BufferAttribute( [ 0, 2, 0, 0, 2, 0 ], 2 ) );
-
-class FullScreenQuad {
-
-	constructor( material ) {
-
-		this._mesh = new Mesh( _geometry, material );
-
-	}
-
-	dispose() {
-
-		this._mesh.geometry.dispose();
-
-	}
-
-	render( renderer ) {
-
-		renderer.render( this._mesh, _camera );
-
-	}
-
-	get material() {
-
-		return this._mesh.material;
-
-	}
-
-	set material( value ) {
-
-		this._mesh.material = value;
-
-	}
-
-}
-
-export { EffectComposer, Pass, FullScreenQuad };
+export { EffectComposer };