super-three 0.163.0 → 0.164.0

package/examples/jsm/physics/JoltPhysics.js

@@ -0,0 +1,281 @@
+import { Clock, Vector3, Quaternion, Matrix4 } from 'three';
+
+const JOLT_PATH = 'https://cdn.jsdelivr.net/npm/jolt-physics@0.23.0/dist/jolt-physics.wasm-compat.js';
+
+const frameRate = 60;
+
+let Jolt = null;
+
+function getShape( 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 new Jolt.BoxShape( new Jolt.Vec3( sx, sy, sz ), 0.05 * Math.min( sx, sy, sz ), null );
+
+	} else if ( geometry.type === 'SphereGeometry' || geometry.type === 'IcosahedronGeometry' ) {
+
+		const radius = parameters.radius !== undefined ? parameters.radius : 1;
+
+		return new Jolt.SphereShape( radius, null );
+
+	}
+
+	return null;
+
+}
+
+// Object layers
+const LAYER_NON_MOVING = 0;
+const LAYER_MOVING = 1;
+const NUM_OBJECT_LAYERS = 2;
+
+function setupCollisionFiltering( settings ) {
+
+	let objectFilter = new Jolt.ObjectLayerPairFilterTable( NUM_OBJECT_LAYERS );
+	objectFilter.EnableCollision( LAYER_NON_MOVING, LAYER_MOVING );
+	objectFilter.EnableCollision( LAYER_MOVING, LAYER_MOVING );
+
+	const BP_LAYER_NON_MOVING = new Jolt.BroadPhaseLayer( 0 );
+	const BP_LAYER_MOVING = new Jolt.BroadPhaseLayer( 1 );
+	const NUM_BROAD_PHASE_LAYERS = 2;
+
+	let bpInterface = new Jolt.BroadPhaseLayerInterfaceTable( NUM_OBJECT_LAYERS, NUM_BROAD_PHASE_LAYERS );
+	bpInterface.MapObjectToBroadPhaseLayer( LAYER_NON_MOVING, BP_LAYER_NON_MOVING );
+	bpInterface.MapObjectToBroadPhaseLayer( LAYER_MOVING, BP_LAYER_MOVING );
+
+	settings.mObjectLayerPairFilter = objectFilter;
+	settings.mBroadPhaseLayerInterface = bpInterface;
+	settings.mObjectVsBroadPhaseLayerFilter = new Jolt.ObjectVsBroadPhaseLayerFilterTable( settings.mBroadPhaseLayerInterface, NUM_BROAD_PHASE_LAYERS, settings.mObjectLayerPairFilter, NUM_OBJECT_LAYERS );
+
+};
+
+async function JoltPhysics() {
+
+	if ( Jolt === null ) {
+
+		const { default: initJolt } = await import( JOLT_PATH );
+		Jolt = await initJolt();
+
+	}
+
+	const settings = new Jolt.JoltSettings();
+	setupCollisionFiltering( settings );
+
+	const jolt = new Jolt.JoltInterface( settings );
+	Jolt.destroy( settings );
+
+	const physicsSystem = jolt.GetPhysicsSystem();
+	const bodyInterface = physicsSystem.GetBodyInterface();
+
+	const meshes = [];
+	const meshMap = new WeakMap();
+
+	const _position = new Vector3();
+	const _quaternion = new Quaternion();
+	const _scale = new Vector3( 1, 1, 1 );
+
+	const _matrix = new Matrix4();
+
+	function addScene( scene ) {
+
+		scene.traverse( function ( child ) {
+
+			if ( child.isMesh ) {
+
+				const physics = child.userData.physics;
+
+				if ( physics ) {
+
+					addMesh( child, physics.mass, physics.restitution );
+
+				}
+
+			}
+
+		} );
+
+	}
+
+	function addMesh( mesh, mass = 0, restitution = 0 ) {
+
+		const shape = getShape( mesh.geometry );
+
+		if ( shape === null ) return;
+
+		const body = mesh.isInstancedMesh
+							? createInstancedBody( mesh, mass, restitution, shape )
+							: createBody( mesh.position, mesh.quaternion, mass, restitution, shape );
+
+		if ( mass > 0 ) {
+
+			meshes.push( mesh );
+			meshMap.set( mesh, body );
+
+		}
+
+	}
+
+	function createInstancedBody( mesh, mass, restitution, shape ) {
+
+		const array = mesh.instanceMatrix.array;
+
+		const bodies = [];
+
+		for ( let i = 0; i < mesh.count; i ++ ) {
+
+			const position = _position.fromArray( array, i * 16 + 12 );
+			const quaternion = _quaternion.setFromRotationMatrix( _matrix.fromArray( array, i * 16 ) ); // TODO Copilot did this
+			bodies.push( createBody( position, quaternion, mass, restitution, shape ) );
+
+		}
+
+		return bodies;
+
+	}
+
+	function createBody( position, rotation, mass, restitution, shape ) {
+
+		const pos = new Jolt.Vec3( position.x, position.y, position.z );
+		const rot = new Jolt.Quat( rotation.x, rotation.y, rotation.z, rotation.w );
+
+		const motion = mass > 0 ? Jolt.EMotionType_Dynamic : Jolt.EMotionType_Static;
+		const layer = mass > 0 ? LAYER_MOVING : LAYER_NON_MOVING;
+
+		const creationSettings = new Jolt.BodyCreationSettings( shape, pos, rot, motion, layer );
+		creationSettings.mRestitution = restitution;
+
+		const body = bodyInterface.CreateBody( creationSettings );
+
+		bodyInterface.AddBody( body.GetID(), Jolt.EActivation_Activate );
+
+		Jolt.destroy( creationSettings );
+
+		return body;
+
+	}
+
+	function setMeshPosition( mesh, position, index = 0 ) {
+
+		if ( mesh.isInstancedMesh ) {
+
+			const bodies = meshMap.get( mesh );
+
+			const body = bodies[ index ];
+
+			bodyInterface.RemoveBody( body.GetID() );
+			bodyInterface.DestroyBody( body.GetID() );
+
+			const physics = mesh.userData.physics;
+
+			let shape = body.GetShape();
+			let body2 = createBody( position, { x: 0, y: 0, z: 0, w: 1 }, physics.mass, physics.restitution, shape );
+
+			bodies[ index ] = body2;
+
+		} else {
+
+			// TODO: Implement this
+
+		}
+
+	}
+
+	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() {
+
+		let deltaTime = clock.getDelta();
+
+		// Don't go below 30 Hz to prevent spiral of death
+		deltaTime = Math.min( deltaTime, 1.0 / 30.0 );
+
+		// When running below 55 Hz, do 2 steps instead of 1
+		const numSteps = deltaTime > 1.0 / 55.0 ? 2 : 1;
+
+		// Step the physics world
+		jolt.Step( deltaTime, numSteps );
+
+		//
+
+		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.GetPosition();
+					const quaternion = body.GetRotation();
+
+					_position.set( position.GetX(), position.GetY(), position.GetZ() );
+					_quaternion.set( quaternion.GetX(), quaternion.GetY(), quaternion.GetZ(), quaternion.GetW() );
+
+					_matrix.compose( _position, _quaternion, _scale ).toArray( array, j * 16 );
+
+				}
+
+				mesh.instanceMatrix.needsUpdate = true;
+				mesh.computeBoundingSphere();
+
+			} else {
+
+				const body = meshMap.get( mesh );
+
+				const position = body.GetPosition();
+				const rotation = body.GetRotation();
+
+				mesh.position.set( position.GetX(), position.GetY(), position.GetZ() );
+				mesh.quaternion.set( rotation.GetX(), rotation.GetY(), rotation.GetZ(), rotation.GetW() );
+
+			}
+
+		}
+
+	}
+
+	// animate
+
+	setInterval( step, 1000 / frameRate );
+
+	return {
+		addScene: addScene,
+		addMesh: addMesh,
+		setMeshPosition: setMeshPosition,
+		setMeshVelocity: setMeshVelocity
+	};
+
+}
+
+export { JoltPhysics };

package/examples/jsm/postprocessing/RenderTransitionPass.js

@@ -0,0 +1,193 @@
+import {
+	HalfFloatType,
+	ShaderMaterial,
+	WebGLRenderTarget
+} from 'three';
+import { FullScreenQuad, Pass } from './Pass.js';
+
+class RenderTransitionPass extends Pass {
+
+	constructor( sceneA, cameraA, sceneB, cameraB ) {
+
+		super();
+
+		this.material = this.createMaterial();
+		this.fsQuad = new FullScreenQuad( this.material );
+
+		this.sceneA = sceneA;
+		this.cameraA = cameraA;
+		this.sceneB = sceneB;
+		this.cameraB = cameraB;
+
+		this.renderTargetA = new WebGLRenderTarget();
+		this.renderTargetA.texture.type = HalfFloatType;
+		this.renderTargetB = new WebGLRenderTarget();
+		this.renderTargetB.texture.type = HalfFloatType;
+
+	}
+
+	setTransition( value ) {
+
+		this.material.uniforms.mixRatio.value = value;
+
+	}
+
+	useTexture( value ) {
+
+		this.material.uniforms.useTexture.value = value ? 1 : 0;
+
+	}
+
+	setTexture( value ) {
+
+		this.material.uniforms.tMixTexture.value = value;
+
+	}
+
+	setTextureThreshold( value ) {
+
+		this.material.uniforms.threshold.value = value;
+
+	}
+
+	setSize( width, height ) {
+
+		this.renderTargetA.setSize( width, height );
+		this.renderTargetB.setSize( width, height );
+
+	}
+
+	render( renderer, writeBuffer ) {
+
+		const uniforms = this.fsQuad.material.uniforms;
+		const transition = uniforms.mixRatio.value;
+
+		// Prevent render both scenes when it's not necessary
+
+		if ( transition === 0 ) {
+
+			renderer.setRenderTarget( writeBuffer );
+			if ( this.clear ) renderer.clear();
+			renderer.render( this.sceneB, this.cameraB );
+
+		} else if ( transition === 1 ) {
+
+			renderer.setRenderTarget( writeBuffer );
+			if ( this.clear ) renderer.clear();
+			renderer.render( this.sceneA, this.cameraA );
+
+		} else {
+
+			// When 0 < transition < 1 render transition between two scenes
+
+			renderer.setRenderTarget( this.renderTargetA );
+			renderer.render( this.sceneA, this.cameraA );
+			renderer.setRenderTarget( this.renderTargetB );
+			renderer.render( this.sceneB, this.cameraB );
+
+			uniforms.tDiffuse1.value = this.renderTargetA.texture;
+			uniforms.tDiffuse2.value = this.renderTargetB.texture;
+
+			if ( this.renderToScreen ) {
+
+				renderer.setRenderTarget( null );
+				renderer.clear();
+
+			} else {
+
+				renderer.setRenderTarget( writeBuffer );
+				if ( this.clear ) renderer.clear();
+
+			}
+
+			this.fsQuad.render( renderer );
+
+		}
+
+	}
+
+	dispose() {
+
+		this.renderTargetA.dispose();
+		this.renderTargetB.dispose();
+		this.material.dispose();
+		this.fsQuad.dispose();
+
+	}
+
+	createMaterial() {
+
+		return new ShaderMaterial( {
+			uniforms: {
+				tDiffuse1: {
+					value: null
+				},
+				tDiffuse2: {
+					value: null
+				},
+				mixRatio: {
+					value: 0.0
+				},
+				threshold: {
+					value: 0.1
+				},
+				useTexture: {
+					value: 1
+				},
+				tMixTexture: {
+					value: null
+				}
+			},
+			vertexShader: /* glsl */`
+				varying vec2 vUv;
+
+				void main() {
+
+					vUv = vec2( uv.x, uv.y );
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+				}
+			`,
+			fragmentShader: /* glsl */`
+				uniform float mixRatio;
+
+				uniform sampler2D tDiffuse1;
+				uniform sampler2D tDiffuse2;
+				uniform sampler2D tMixTexture;
+
+				uniform int useTexture;
+				uniform float threshold;
+
+				varying vec2 vUv;
+
+				void main() {
+
+					vec4 texel1 = texture2D( tDiffuse1, vUv );
+					vec4 texel2 = texture2D( tDiffuse2, vUv );
+
+					if (useTexture == 1) {
+
+						vec4 transitionTexel = texture2D( tMixTexture, vUv );
+						float r = mixRatio * ( 1.0 + threshold * 2.0 ) - threshold;
+						float mixf = clamp( ( transitionTexel.r - r ) * ( 1.0 / threshold ), 0.0, 1.0 );
+
+						gl_FragColor = mix( texel1, texel2, mixf );
+
+					} else {
+
+						gl_FragColor = mix( texel2, texel1, mixRatio );
+
+					}
+
+					#include <tonemapping_fragment>
+					#include <colorspace_fragment>
+
+				}
+			`
+		} );
+
+	}
+
+}
+
+export { RenderTransitionPass };

package/examples/jsm/renderers/common/Background.js

@@ -1,6 +1,6 @@
 import DataMap from './DataMap.js';
 import Color4 from './Color4.js';
-import { Mesh, SphereGeometry, BackSide } from 'three';
+import { Mesh, SphereGeometry, BackSide, LinearSRGBColorSpace } from 'three';
 import { vec4, context, normalWorld, backgroundBlurriness, backgroundIntensity, NodeMaterial, modelViewProjection } from '../../nodes/Nodes.js';
 
 const _clearColor = new Color4();
@@ -27,14 +27,14 @@ class Background extends DataMap {
 
 			// no background settings, use clear color configuration from the renderer
 
-			renderer._clearColor.getRGB( _clearColor, this.renderer.currentColorSpace );
+			renderer._clearColor.getRGB( _clearColor, LinearSRGBColorSpace );
 			_clearColor.a = renderer._clearColor.a;
 
 		} else if ( background.isColor === true ) {
 
 			// background is an opaque color
 
-			background.getRGB( _clearColor, this.renderer.currentColorSpace );
+			background.getRGB( _clearColor, LinearSRGBColorSpace );
 			_clearColor.a = 1;
 
 			forceClear = true;

package/examples/jsm/renderers/common/ClippingContext.js

@@ -101,7 +101,7 @@ class ClippingContext {
 
 		if ( this !== parent && parent.version !== this.parentVersion ) {
 
-			this.globalClippingCount =  material.isShadowNodeMaterial ? 0 : parent.globalClippingCount;
+			this.globalClippingCount = material.isShadowNodeMaterial ? 0 : parent.globalClippingCount;
 			this.localClippingEnabled = parent.localClippingEnabled;
 			this.planes = Array.from( parent.planes );
 			this.parentVersion = parent.version;

package/examples/jsm/renderers/common/RenderList.js

@@ -123,7 +123,7 @@ class RenderList {
 
 		if ( object.occlusionTest === true ) this.occlusionQueryCount ++;
 
-		( material.transparent === true ? this.transparent : this.opaque ).push( renderItem );
+		( material.transparent === true || material.transmission > 0 ? this.transparent : this.opaque ).push( renderItem );
 
 	}
 

package/examples/jsm/renderers/common/RenderObject.js

@@ -2,6 +2,40 @@ import ClippingContext from './ClippingContext.js';
 
 let id = 0;
 
+function getKeys( obj ) {
+
+	const keys = Object.keys( obj );
+
+	let proto = Object.getPrototypeOf( obj );
+
+	while ( proto ) {
+
+		const descriptors = Object.getOwnPropertyDescriptors( proto );
+
+		for ( const key in descriptors ) {
+
+			if ( descriptors[ key ] !== undefined ) {
+
+				const descriptor = descriptors[ key ];
+
+				if ( descriptor && typeof descriptor.get === 'function' ) {
+
+					keys.push( key );
+
+				}
+
+			}
+
+		}
+
+		proto = Object.getPrototypeOf( proto );
+
+	}
+
+	return keys;
+
+}
+
 export default class RenderObject {
 
 	constructor( nodes, geometries, renderer, object, material, scene, camera, lightsNode, renderContext ) {
@@ -22,6 +56,8 @@ export default class RenderObject {
 		this.geometry = object.geometry;
 		this.version = material.version;
 
+		this.drawRange = null;
+
 		this.attributes = null;
 		this.pipeline = null;
 		this.vertexBuffers = null;
@@ -153,7 +189,7 @@ export default class RenderObject {
 
 		let cacheKey = material.customProgramCacheKey();
 
-		for ( const property in material ) {
+		for ( const property of getKeys( material ) ) {
 
 			if ( /^(is[A-Z]|_)|^(visible|version|uuid|name|opacity|userData)$/.test( property ) ) continue;
 
@@ -186,6 +222,12 @@ export default class RenderObject {
 
 		}
 
+		if ( object.isBatchedMesh ) {
+
+			cacheKey += object._matricesTexture.uuid + ',';
+
+		}
+
 		return cacheKey;
 
 	}