super-three 0.152.0 → 0.154.1

package/examples/jsm/renderers/webgpu/utils/WebGPUUtils.js

@@ -0,0 +1,92 @@
+import { GPUPrimitiveTopology, GPUTextureFormat } from './WebGPUConstants.js';
+
+class WebGPUUtils {
+
+	constructor( backend ) {
+
+		this.backend = backend;
+
+	}
+
+	getCurrentDepthStencilFormat( renderContext ) {
+
+		let format;
+
+		if ( renderContext.depthTexture !== null ) {
+
+			format = this.getTextureFormatGPU( renderContext.depthTexture );
+
+		} else if ( renderContext.depth && renderContext.stencil ) {
+
+			format = GPUTextureFormat.Depth24PlusStencil8;
+
+		} else if ( renderContext.depth ) {
+
+			format = GPUTextureFormat.Depth24Plus;
+
+		}
+
+		return format;
+
+	}
+
+	getTextureFormatGPU( texture ) {
+
+		return this.backend.get( texture ).texture.format;
+
+	}
+
+	getCurrentColorFormat( renderContext ) {
+
+		let format;
+
+		if ( renderContext.texture !== null ) {
+
+			format = this.getTextureFormatGPU( renderContext.texture );
+
+		} else {
+
+			format = GPUTextureFormat.BGRA8Unorm; // default context format
+
+		}
+
+		return format;
+
+	}
+
+	getCurrentColorSpace( renderContext ) {
+
+		if ( renderContext.texture !== null ) {
+
+			return renderContext.texture.colorSpace;
+
+		}
+
+		return this.backend.renderer.outputColorSpace;
+
+	}
+
+	getPrimitiveTopology( object, material ) {
+
+		if ( object.isPoints ) return GPUPrimitiveTopology.PointList;
+		else if ( object.isLineSegments || ( object.isMesh && material.wireframe === true ) ) return GPUPrimitiveTopology.LineList;
+		else if ( object.isLine ) return GPUPrimitiveTopology.LineStrip;
+		else if ( object.isMesh ) return GPUPrimitiveTopology.TriangleList;
+
+	}
+
+	getSampleCount( renderContext ) {
+
+		if ( renderContext.texture !== null ) {
+
+			return 1;
+
+		}
+
+		return this.backend.parameters.sampleCount;
+
+	}
+
+}
+
+export default WebGPUUtils;

package/examples/jsm/shaders/BleachBypassShader.js

@@ -6,6 +6,8 @@
 
 const BleachBypassShader = {
 
+	name: 'BleachBypassShader',
+
 	uniforms: {
 
 		'tDiffuse': { value: null },

package/examples/jsm/shaders/BlendShader.js

@@ -38,8 +38,7 @@ const BlendShader = {
 
 			vec4 texel1 = texture2D( tDiffuse1, vUv );
 			vec4 texel2 = texture2D( tDiffuse2, vUv );
-			gl_FragColor = mix( texel1, texel2, mixRatio );
-			gl_FragColor.a *= opacity;
+			gl_FragColor = opacity * mix( texel1, texel2, mixRatio );
 
 		}`
 

package/examples/jsm/shaders/BokehShader2.js

@@ -345,6 +345,9 @@ const BokehShader = {
 
 			gl_FragColor.rgb = col;
 			gl_FragColor.a = 1.0;
+
+			#include <tonemapping_fragment>
+			#include <colorspace_fragment>
 		}`
 
 };

package/examples/jsm/shaders/ColorifyShader.js

@@ -8,6 +8,8 @@ import {
 
 const ColorifyShader = {
 
+	name: 'ColorifyShader',
+
 	uniforms: {
 
 		'tDiffuse': { value: null },

package/examples/jsm/shaders/ConvolutionShader.js

@@ -9,6 +9,8 @@ import {
 
 const ConvolutionShader = {
 
+	name: 'ConvolutionShader',
+
 	defines: {
 
 		'KERNEL_SIZE_FLOAT': '25.0',

package/examples/jsm/shaders/CopyShader.js

@@ -4,6 +4,8 @@
 
 const CopyShader = {
 
+	name: 'CopyShader',
+
 	uniforms: {
 
 		'tDiffuse': { value: null },
@@ -32,8 +34,8 @@ const CopyShader = {
 
 		void main() {
 
-			gl_FragColor = texture2D( tDiffuse, vUv );
-			gl_FragColor.a *= opacity;
+			vec4 texel = texture2D( tDiffuse, vUv );
+			gl_FragColor = opacity * texel;
 
 
 		}`

package/examples/jsm/shaders/DotScreenShader.js

@@ -10,6 +10,8 @@ import {
 
 const DotScreenShader = {
 
+	name: 'DotScreenShader',
+
 	uniforms: {
 
 		'tDiffuse': { value: null },

package/examples/jsm/shaders/ExposureShader.js

@@ -0,0 +1,44 @@
+/**
+ * Exposure shader
+ */
+
+const ExposureShader = {
+
+	name: 'ExposureShader',
+
+	uniforms: {
+
+		'tDiffuse': { value: null },
+		'exposure': { value: 1.0 }
+
+	},
+
+	vertexShader: /* glsl */`
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`,
+
+	fragmentShader: /* glsl */`
+
+		uniform float exposure;
+
+		uniform sampler2D tDiffuse;
+
+		varying vec2 vUv;
+
+		void main() {
+
+			gl_FragColor = texture2D( tDiffuse, vUv );
+			gl_FragColor.rgb *= exposure;
+
+		}`
+
+};
+
+export { ExposureShader };

package/examples/jsm/shaders/FilmShader.js

@@ -20,6 +20,8 @@
 
 const FilmShader = {
 
+	name: 'FilmShader',
+
 	uniforms: {
 
 		'tDiffuse': { value: null },

package/examples/jsm/shaders/GammaCorrectionShader.js

@@ -5,6 +5,8 @@
 
 const GammaCorrectionShader = {
 
+	name: 'GammaCorrectionShader',
+
 	uniforms: {
 
 		'tDiffuse': { value: null }

package/examples/jsm/shaders/HorizontalBlurShader.js

@@ -9,6 +9,8 @@
 
 const HorizontalBlurShader = {
 
+	name: 'HorizontalBlurShader',
+
 	uniforms: {
 
 		'tDiffuse': { value: null },

package/examples/jsm/shaders/OutputShader.js

@@ -0,0 +1,61 @@
+const OutputShader = {
+
+	uniforms: {
+
+		'tDiffuse': { value: null },
+		'toneMappingExposure': { value: 1 }
+
+	},
+
+	vertexShader: /* glsl */`
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`,
+
+	fragmentShader: /* glsl */`
+
+		uniform sampler2D tDiffuse;
+
+		#include <tonemapping_pars_fragment>
+
+		varying vec2 vUv;
+
+		void main() {
+
+			gl_FragColor = texture2D( tDiffuse, vUv );
+
+			// tone mapping
+
+			#ifdef LINEAR_TONE_MAPPING
+
+				gl_FragColor.rgb = LinearToneMapping( gl_FragColor.rgb );
+
+			#elif defined( REINHARD_TONE_MAPPING )
+
+				gl_FragColor.rgb = ReinhardToneMapping( gl_FragColor.rgb );
+
+			#elif defined( CINEON_TONE_MAPPING )
+
+				gl_FragColor.rgb = OptimizedCineonToneMapping( gl_FragColor.rgb );
+
+			#elif defined( ACES_FILMIC_TONE_MAPPING )
+
+				gl_FragColor.rgb = ACESFilmicToneMapping( gl_FragColor.rgb );
+
+			#endif
+
+			// color space
+
+			gl_FragColor = LinearTosRGB( gl_FragColor );
+
+		}`
+
+};
+
+export { OutputShader };

package/examples/jsm/shaders/RGBShiftShader.js

@@ -10,6 +10,8 @@
 
 const RGBShiftShader = {
 
+	name: 'RGBShiftShader',
+
 	uniforms: {
 
 		'tDiffuse': { value: null },

package/examples/jsm/shaders/SepiaShader.js

@@ -6,6 +6,8 @@
 
 const SepiaShader = {
 
+	name: 'SepiaShader',
+
 	uniforms: {
 
 		'tDiffuse': { value: null },

package/examples/jsm/shaders/ToonShader.js

@@ -78,7 +78,9 @@ const ToonShader1 = {
 
 				gl_FragColor = vec4( 1.0 - 2.0 * ( 1.0 - intensity ) * ( 1.0 - uBaseColor ), 1.0 );
 
-		}
+			}
+
+			#include <colorspace_fragment>
 
 		}`
 
@@ -146,6 +148,8 @@ const ToonShader2 = {
 
 			}
 
+			#include <colorspace_fragment>
+
 		}`
 
 };
@@ -240,6 +244,8 @@ const ToonShaderHatching = {
 
 			}
 
+			#include <colorspace_fragment>
+
 		}`
 
 };
@@ -286,12 +292,12 @@ const ToonShaderDotted = {
 
 		void main() {
 
-		float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);
-		vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;
+			float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);
+			vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;
 
-		gl_FragColor = vec4( uBaseColor, 1.0 );
+			gl_FragColor = vec4( uBaseColor, 1.0 );
 
-		if ( length(lightWeighting) < 1.00 ) {
+			if ( length(lightWeighting) < 1.00 ) {
 
 				if ( ( mod(gl_FragCoord.x, 4.001) + mod(gl_FragCoord.y, 4.0) ) > 6.00 ) {
 
@@ -311,6 +317,8 @@ const ToonShaderDotted = {
 
 			}
 
+			#include <colorspace_fragment>
+
 		}`
 
 };

package/examples/jsm/shaders/VerticalBlurShader.js

@@ -9,6 +9,8 @@
 
 const VerticalBlurShader = {
 
+	name: 'VerticalBlurShader',
+
 	uniforms: {
 
 		'tDiffuse': { value: null },

package/examples/jsm/shaders/VignetteShader.js

@@ -6,6 +6,8 @@
 
 const VignetteShader = {
 
+	name: 'VignetteShader',
+
 	uniforms: {
 
 		'tDiffuse': { value: null },

package/examples/jsm/shaders/WaterRefractionShader.js

@@ -76,13 +76,16 @@ const WaterRefractionShader = {
 
 			// new uv coords
 
-		 vec4 uv = vec4( vUvRefraction );
-		 uv.xy += distortion;
+			vec4 uv = vec4( vUvRefraction );
+			uv.xy += distortion;
 
 			vec4 base = texture2DProj( tDiffuse, uv );
 
 			gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );
 
+			#include <tonemapping_fragment>
+			#include <colorspace_fragment>
+
 		}`
 
 };

package/examples/jsm/utils/BufferGeometryUtils.js

@@ -304,6 +304,7 @@ function mergeAttributes( attributes ) {
 	let TypedArray;
 	let itemSize;
 	let normalized;
+	let gpuType = - 1;
 	let arrayLength = 0;
 
 	for ( let i = 0; i < attributes.length; ++ i ) {
@@ -341,6 +342,14 @@ function mergeAttributes( attributes ) {
 
 		}
 
+		if ( gpuType === - 1 ) gpuType = attribute.gpuType;
+		if ( gpuType !== attribute.gpuType ) {
+
+			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.gpuType must be consistent across matching attributes.' );
+			return null;
+
+		}
+
 		arrayLength += attribute.array.length;
 
 	}
@@ -356,7 +365,14 @@ function mergeAttributes( attributes ) {
 
 	}
 
-	return new BufferAttribute( array, itemSize, normalized );
+	const result = new BufferAttribute( array, itemSize, normalized );
+	if ( gpuType !== undefined ) {
+
+		result.gpuType = gpuType;
+
+	}
+
+	return result;
 
 }
 

package/examples/jsm/utils/TextureUtils.js

@@ -0,0 +1,86 @@
+import {
+	PlaneGeometry,
+	ShaderMaterial,
+	Uniform,
+	Mesh,
+	PerspectiveCamera,
+	Scene,
+	WebGLRenderer,
+	Texture,
+	SRGBColorSpace
+} from 'three';
+
+let _renderer;
+let fullscreenQuadGeometry;
+let fullscreenQuadMaterial;
+let fullscreenQuad;
+
+export function decompress( texture, maxTextureSize = Infinity, renderer = null ) {
+
+	if ( ! fullscreenQuadGeometry ) fullscreenQuadGeometry = new PlaneGeometry( 2, 2, 1, 1 );
+	if ( ! fullscreenQuadMaterial ) fullscreenQuadMaterial = new ShaderMaterial( {
+		uniforms: { blitTexture: new Uniform( texture ) },
+		vertexShader: `
+            varying vec2 vUv;
+            void main(){
+                vUv = uv;
+                gl_Position = vec4(position.xy * 1.0,0.,.999999);
+            }`,
+		fragmentShader: `
+            uniform sampler2D blitTexture; 
+            varying vec2 vUv;
+
+            void main(){ 
+                gl_FragColor = vec4(vUv.xy, 0, 1);
+                
+                #ifdef IS_SRGB
+                gl_FragColor = LinearTosRGB( texture2D( blitTexture, vUv) );
+                #else
+                gl_FragColor = texture2D( blitTexture, vUv);
+                #endif
+            }`
+	} );
+
+	fullscreenQuadMaterial.uniforms.blitTexture.value = texture;
+	fullscreenQuadMaterial.defines.IS_SRGB = texture.colorSpace == SRGBColorSpace;
+	fullscreenQuadMaterial.needsUpdate = true;
+
+	if ( ! fullscreenQuad ) {
+
+		fullscreenQuad = new Mesh( fullscreenQuadGeometry, fullscreenQuadMaterial );
+		fullscreenQuad.frustrumCulled = false;
+
+	}
+
+	const _camera = new PerspectiveCamera();
+	const _scene = new Scene();
+	_scene.add( fullscreenQuad );
+
+	if ( ! renderer ) {
+
+		renderer = _renderer = new WebGLRenderer( { antialias: false } );
+
+	}
+
+	renderer.setSize( Math.min( texture.image.width, maxTextureSize ), Math.min( texture.image.height, maxTextureSize ) );
+	renderer.clear();
+	renderer.render( _scene, _camera );
+
+	const readableTexture = new Texture( renderer.domElement );
+
+	readableTexture.minFilter = texture.minFilter;
+	readableTexture.magFilter = texture.magFilter;
+	readableTexture.wrapS = texture.wrapS;
+	readableTexture.wrapT = texture.wrapT;
+	readableTexture.name = texture.name;
+
+	if ( _renderer ) {
+
+		_renderer.dispose();
+		_renderer = null;
+
+	}
+
+	return readableTexture;
+
+}

package/examples/jsm/webxr/OculusHandPointerModel.js

@@ -13,8 +13,8 @@ const POINTER_LENGTH = 0.035;
 const POINTER_SEGMENTS = 16;
 const POINTER_RINGS = 12;
 const POINTER_HEMISPHERE_ANGLE = 110;
-const YAXIS = new THREE.Vector3( 0, 1, 0 );
-const ZAXIS = new THREE.Vector3( 0, 0, 1 );
+const YAXIS = /* @__PURE__ */ new THREE.Vector3( 0, 1, 0 );
+const ZAXIS = /* @__PURE__ */ new THREE.Vector3( 0, 0, 1 );
 
 const CURSOR_RADIUS = 0.02;
 const CURSOR_MAX_DISTANCE = 1.5;
@@ -27,9 +27,10 @@ class OculusHandPointerModel extends THREE.Object3D {
 
 		this.hand = hand;
 		this.controller = controller;
+
+		// Unused
 		this.motionController = null;
 		this.envMap = null;
-
 		this.mesh = null;
 
 		this.pointerGeometry = null;
@@ -43,24 +44,36 @@ class OculusHandPointerModel extends THREE.Object3D {
 
 		this.raycaster = null;
 
-		hand.addEventListener( 'connected', ( event ) => {
+		this._onConnected = this._onConnected.bind( this );
+		this._onDisconnected = this._onDisconnected.bind( this );
+		this.hand.addEventListener( 'connected', this._onConnected );
+		this.hand.addEventListener( 'disconnected', this._onDisconnected );
 
-			const xrInputSource = event.data;
+	}
 
-			if ( xrInputSource.hand ) {
+	_onConnected( event ) {
 
-				this.visible = true;
-				this.xrInputSource = xrInputSource;
+		const xrInputSource = event.data;
+		if ( xrInputSource.hand ) {
 
-				if ( this.pointerObject === null ) {
+			this.visible = true;
+			this.xrInputSource = xrInputSource;
 
-					this.createPointer();
+			this.createPointer();
 
-				}
+		}
 
-			}
+	}
+
+	_onDisconnected() {
 
-		} );
+		this.visible = false;
+		this.xrInputSource = null;
+
+		this.pointerGeometry.dispose();
+		this.pointerMesh.material.dispose();
+
+		this.clear();
 
 	}
 
@@ -387,6 +400,14 @@ class OculusHandPointerModel extends THREE.Object3D {
 
 	}
 
+	dispose() {
+
+		this._onDisconnected();
+		this.hand.removeEventListener( 'connected', this._onConnected );
+		this.hand.removeEventListener( 'disconnected', this._onDisconnected );
+
+	}
+
 }
 
 export { OculusHandPointerModel };

package/examples/jsm/webxr/XRHandPrimitiveModel.js

@@ -34,6 +34,7 @@ class XRHandPrimitiveModel {
 		const material = new MeshStandardMaterial();
 
 		this.handMesh = new InstancedMesh( geometry, material, 30 );
+		this.handMesh.frustumCulled = false;
 		this.handMesh.instanceMatrix.setUsage( DynamicDrawUsage ); // will be updated every frame
 		this.handMesh.castShadow = true;
 		this.handMesh.receiveShadow = true;