super-three 0.169.0 → 0.170.0

package/examples/jsm/exporters/KTX2Exporter.js

@@ -1,4 +1,5 @@
 import {
+	ColorManagement,
 	FloatType,
 	HalfFloatType,
 	UnsignedByteType,
@@ -10,6 +11,7 @@ import {
 	NoColorSpace,
 	LinearSRGBColorSpace,
 	SRGBColorSpace,
+	SRGBTransfer,
 	DataTexture,
 	REVISION,
 } from 'three';
@@ -43,6 +45,13 @@ import {
 	VK_FORMAT_R8G8B8A8_UNORM,
 } from '../libs/ktx-parse.module.js';
 
+/**
+ * References:
+ * - https://github.khronos.org/KTX-Specification/ktxspec.v2.html
+ * - https://registry.khronos.org/DataFormat/specs/1.3/dataformat.1.3.html
+ * - https://github.com/donmccurdy/KTX-Parse
+ */
+
 const VK_FORMAT_MAP = {
 
 	[ RGBAFormat ]: {
@@ -95,14 +104,23 @@ const VK_FORMAT_MAP = {
 
 };
 
-const KHR_DF_CHANNEL_MAP = {
+const KHR_DF_CHANNEL_MAP = [
 
-	0: KHR_DF_CHANNEL_RGBSDA_RED,
-	1: KHR_DF_CHANNEL_RGBSDA_GREEN,
-	2: KHR_DF_CHANNEL_RGBSDA_BLUE,
-	3: KHR_DF_CHANNEL_RGBSDA_ALPHA,
+	KHR_DF_CHANNEL_RGBSDA_RED,
+	KHR_DF_CHANNEL_RGBSDA_GREEN,
+	KHR_DF_CHANNEL_RGBSDA_BLUE,
+	KHR_DF_CHANNEL_RGBSDA_ALPHA,
 
-};
+];
+
+// TODO: sampleLower and sampleUpper may change based on color space.
+const KHR_DF_CHANNEL_SAMPLE_LOWER_UPPER = {
+
+	[ FloatType ]: [ 0xbf800000, 0x3f800000 ],
+	[ HalfFloatType ]: [ 0xbf800000, 0x3f800000 ],
+	[ UnsignedByteType ]: [ 0, 255 ],
+
+}
 
 const ERROR_INPUT = 'THREE.KTX2Exporter: Supported inputs are DataTexture, Data3DTexture, or WebGLRenderer and WebGLRenderTarget.';
 const ERROR_FORMAT = 'THREE.KTX2Exporter: Supported formats are RGBAFormat, RGFormat, or RedFormat.';
@@ -172,7 +190,7 @@ export class KTX2Exporter {
 		basicDesc.colorPrimaries = texture.colorSpace === NoColorSpace
 			? KHR_DF_PRIMARIES_UNSPECIFIED
 			: KHR_DF_PRIMARIES_BT709;
-		basicDesc.transferFunction = texture.colorSpace === SRGBColorSpace
+		basicDesc.transferFunction = ColorManagement.getTransfer( texture.colorSpace ) === SRGBTransfer
 			? KHR_DF_TRANSFER_SRGB
 			: KHR_DF_TRANSFER_LINEAR;
 
@@ -188,7 +206,8 @@ export class KTX2Exporter {
 
 			let channelType = KHR_DF_CHANNEL_MAP[ i ];
 
-			if ( texture.colorSpace === LinearSRGBColorSpace || texture.colorSpace === NoColorSpace ) {
+			// Assign KHR_DF_SAMPLE_DATATYPE_LINEAR if the channel is linear _and_ differs from the transfer function.
+			if ( channelType === KHR_DF_CHANNEL_RGBSDA_ALPHA && basicDesc.transferFunction !== KHR_DF_TRANSFER_LINEAR ) {
 
 				channelType |= KHR_DF_SAMPLE_DATATYPE_LINEAR;
 
@@ -204,11 +223,11 @@ export class KTX2Exporter {
 			basicDesc.samples.push( {
 
 				channelType: channelType,
-				bitOffset: i * array.BYTES_PER_ELEMENT,
+				bitOffset: i * array.BYTES_PER_ELEMENT * 8,
 				bitLength: array.BYTES_PER_ELEMENT * 8 - 1,
 				samplePosition: [ 0, 0, 0, 0 ],
-				sampleLower: texture.type === UnsignedByteType ? 0 : - 1,
-				sampleUpper: texture.type === UnsignedByteType ? 255 : 1,
+				sampleLower: KHR_DF_CHANNEL_SAMPLE_LOWER_UPPER[ texture.type ][ 0 ],
+				sampleUpper: KHR_DF_CHANNEL_SAMPLE_LOWER_UPPER[ texture.type ][ 1 ],
 
 			} );
 
@@ -269,7 +288,11 @@ async function toDataTexture( renderer, rtt ) {
 
 	}
 
-	return new DataTexture( view, rtt.width, rtt.height, rtt.texture.format, rtt.texture.type );
+	const texture = new DataTexture( view, rtt.width, rtt.height, rtt.texture.format, rtt.texture.type );
+
+	texture.colorSpace = rtt.texture.colorSpace;
+
+	return texture;
 
 }
 

package/examples/jsm/exporters/MMDExporter.js

@@ -12,6 +12,12 @@ import { MMDParser } from '../libs/mmdparser.module.js';
 
 class MMDExporter {
 
+	constructor() {
+
+		console.warn( 'THREE.MMDExporter: The module has been deprecated and will be removed with r172. Please migrate to https://github.com/takahirox/three-mmd-loader instead.' );
+
+	}
+
 	/* TODO: implement
 	// mesh -> pmd
 	this.parsePmd = function ( object ) {

package/examples/jsm/exporters/USDZExporter.js

@@ -9,10 +9,20 @@ import {
 	zipSync,
 } from '../libs/fflate.module.js';
 
-import { decompress } from './../utils/TextureUtils.js';
-
 class USDZExporter {
 
+	constructor() {
+
+		this.textureUtils = null;
+
+	}
+
+	setTextureUtils( utils ) {
+
+		this.textureUtils = utils;
+
+	}
+
 	parse( scene, onDone, onError, options ) {
 
 		this.parseAsync( scene, options ).then( onDone ).catch( onError );
@@ -98,7 +108,15 @@ class USDZExporter {
 
 			if ( texture.isCompressedTexture === true ) {
 
-				texture = decompress( texture );
+				if ( this.textureUtils === null ) {
+
+					throw new Error( 'THREE.USDZExporter: setTextureUtils() must be called to process compressed textures.' );
+
+				} else {
+
+					texture = await this.textureUtils.decompress( texture );
+
+				}
 
 			}
 

package/examples/jsm/geometries/DecalGeometry.js

@@ -55,9 +55,16 @@ class DecalGeometry extends BufferGeometry {
 		// build geometry
 
 		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
-		this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
 		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
 
+		if ( normals.length > 0 ) {
+
+			this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+
+		}
+
+		//
+
 		function generate() {
 
 			let decalVertices = [];
@@ -86,9 +93,17 @@ class DecalGeometry extends BufferGeometry {
 				for ( let i = 0; i < index.count; i ++ ) {
 
 					vertex.fromBufferAttribute( positionAttribute, index.getX( i ) );
-					normal.fromBufferAttribute( normalAttribute, index.getX( i ) );
 
-					pushDecalVertex( decalVertices, vertex, normal );
+					if ( normalAttribute ) {
+
+						normal.fromBufferAttribute( normalAttribute, index.getX( i ) );
+						pushDecalVertex( decalVertices, vertex, normal );
+
+					} else {
+
+						pushDecalVertex( decalVertices, vertex );
+
+					}
 
 				}
 
@@ -99,9 +114,17 @@ class DecalGeometry extends BufferGeometry {
 				for ( let i = 0; i < positionAttribute.count; i ++ ) {
 
 					vertex.fromBufferAttribute( positionAttribute, i );
-					normal.fromBufferAttribute( normalAttribute, i );
 
-					pushDecalVertex( decalVertices, vertex, normal );
+					if ( normalAttribute ) {
+
+						normal.fromBufferAttribute( normalAttribute, i );
+						pushDecalVertex( decalVertices, vertex, normal );
+
+					} else {
+
+						pushDecalVertex( decalVertices, vertex );
+
+					}
 
 				}
 
@@ -136,22 +159,34 @@ class DecalGeometry extends BufferGeometry {
 				// now create vertex and normal buffer data
 
 				vertices.push( decalVertex.position.x, decalVertex.position.y, decalVertex.position.z );
-				normals.push( decalVertex.normal.x, decalVertex.normal.y, decalVertex.normal.z );
+
+				if ( decalVertex.normal !== null ) {
+
+					normals.push( decalVertex.normal.x, decalVertex.normal.y, decalVertex.normal.z );
+
+				}
 
 			}
 
 		}
 
-		function pushDecalVertex( decalVertices, vertex, normal ) {
+		function pushDecalVertex( decalVertices, vertex, normal = null ) {
 
 			// transform the vertex to world space, then to projector space
 
 			vertex.applyMatrix4( mesh.matrixWorld );
 			vertex.applyMatrix4( projectorMatrixInverse );
 
-			normal.applyNormalMatrix( normalMatrix );
+			if ( normal ) {
+
+				normal.applyNormalMatrix( normalMatrix );
+				decalVertices.push( new DecalVertex( vertex.clone(), normal.clone() ) );
+
+			} else {
 
-			decalVertices.push( new DecalVertex( vertex.clone(), normal.clone() ) );
+				decalVertices.push( new DecalVertex( vertex.clone() ) );
+
+			}
 
 		}
 
@@ -313,18 +348,25 @@ class DecalGeometry extends BufferGeometry {
 
 			const s0 = d0 / ( d0 - d1 );
 
-			const v = new DecalVertex(
-				new Vector3(
-					v0.position.x + s0 * ( v1.position.x - v0.position.x ),
-					v0.position.y + s0 * ( v1.position.y - v0.position.y ),
-					v0.position.z + s0 * ( v1.position.z - v0.position.z )
-				),
-				new Vector3(
+			const position = new Vector3(
+				v0.position.x + s0 * ( v1.position.x - v0.position.x ),
+				v0.position.y + s0 * ( v1.position.y - v0.position.y ),
+				v0.position.z + s0 * ( v1.position.z - v0.position.z )
+			);
+
+			let normal = null;
+
+			if ( v0.normal !== null && v1.normal !== null ) {
+
+				normal = new Vector3(
 					v0.normal.x + s0 * ( v1.normal.x - v0.normal.x ),
 					v0.normal.y + s0 * ( v1.normal.y - v0.normal.y ),
 					v0.normal.z + s0 * ( v1.normal.z - v0.normal.z )
-				)
-			);
+				);
+
+			}
+
+			const v = new DecalVertex( position, normal );
 
 			// need to clip more values (texture coordinates)? do it this way:
 			// intersectpoint.value = a.value + s * ( b.value - a.value );
@@ -341,7 +383,7 @@ class DecalGeometry extends BufferGeometry {
 
 class DecalVertex {
 
-	constructor( position, normal ) {
+	constructor( position, normal = null ) {
 
 		this.position = position;
 		this.normal = normal;
@@ -350,7 +392,10 @@ class DecalVertex {
 
 	clone() {
 
-		return new this.constructor( this.position.clone(), this.normal.clone() );
+		const position = this.position.clone();
+		const normal = ( this.normal !== null ) ? this.normal.clone() : null;
+
+		return new this.constructor( position, normal );
 
 	}
 

package/examples/jsm/geometries/InstancedPointsGeometry.js

@@ -78,6 +78,8 @@ class InstancedPointsGeometry extends InstancedBufferGeometry {
 		this.computeBoundingBox();
 		this.computeBoundingSphere();
 
+		this.instanceCount = points.length / 3;
+
 		return this;
 
 	}

package/examples/jsm/helpers/TextureHelperGPU.js

@@ -0,0 +1,175 @@
+import {
+	BoxGeometry,
+	BufferAttribute,
+	Mesh,
+	PlaneGeometry,
+	Vector3,
+} from 'three';
+import { NodeMaterial, texture as textureNode, cubeTexture, texture3D, float, vec4 } from 'three/tsl';
+import { mergeGeometries } from '../utils/BufferGeometryUtils.js';
+
+class TextureHelper extends Mesh {
+
+	constructor( texture, width = 1, height = 1, depth = 1 ) {
+
+		const material = new NodeMaterial();
+		material.name = 'TextureHelper';
+
+		let colorNode;
+
+		if ( texture.isCubeTexture ) {
+
+			colorNode = cubeTexture( texture );
+
+		} else if ( texture.isData3DTexture || texture.isCompressed3DTexture ) {
+
+			colorNode = texture3D( texture );
+
+		} else {
+
+			colorNode = textureNode( texture );
+
+		}
+
+		const alphaNode = float( getAlpha( texture ) );
+
+		material.colorNode = vec4( colorNode.rgb, alphaNode );
+
+		const geometry = texture.isCubeTexture
+			? createCubeGeometry( width, height, depth )
+			: createSliceGeometry( texture, width, height, depth );
+
+		super( geometry, material );
+
+		this.texture = texture;
+		this.type = 'TextureHelper';
+
+	}
+
+	dispose() {
+
+		this.geometry.dispose();
+		this.material.dispose();
+
+	}
+
+}
+
+function getImageCount( texture ) {
+
+	if ( texture.isCubeTexture ) {
+
+		return 6;
+
+	} else if ( texture.isDataArrayTexture || texture.isCompressedArrayTexture ) {
+
+		return texture.image.depth;
+
+	} else if ( texture.isData3DTexture || texture.isCompressed3DTexture ) {
+
+		return texture.image.depth;
+
+	} else {
+
+		return 1;
+
+	}
+
+}
+
+function getAlpha( texture ) {
+
+	if ( texture.isCubeTexture ) {
+
+		return 1;
+
+	} else if ( texture.isDataArrayTexture || texture.isCompressedArrayTexture ) {
+
+		return Math.max( 1 / texture.image.depth, 0.25 );
+
+	} else if ( texture.isData3DTexture || texture.isCompressed3DTexture ) {
+
+		return Math.max( 1 / texture.image.depth, 0.25 );
+
+	} else {
+
+		return 1;
+
+	}
+
+}
+
+function createCubeGeometry( width, height, depth ) {
+
+	const geometry = new BoxGeometry( width, height, depth );
+
+	const position = geometry.attributes.position;
+	const uv = geometry.attributes.uv;
+	const uvw = new BufferAttribute( new Float32Array( uv.count * 3 ), 3 );
+
+	const _direction = new Vector3();
+
+	for ( let j = 0, jl = uv.count; j < jl; ++ j ) {
+
+		_direction.fromBufferAttribute( position, j ).normalize();
+
+		const u = _direction.x;
+		const v = _direction.y;
+		const w = _direction.z;
+
+		uvw.setXYZ( j, u, v, w );
+
+	}
+
+	geometry.deleteAttribute( 'uv' );
+	geometry.setAttribute( 'uv', uvw );
+
+	return geometry;
+
+}
+
+function createSliceGeometry( texture, width, height, depth ) {
+
+	const sliceCount = getImageCount( texture );
+
+	const geometries = [];
+
+	for ( let i = 0; i < sliceCount; ++ i ) {
+
+		const geometry = new PlaneGeometry( width, height );
+
+		if ( sliceCount > 1 ) {
+
+			geometry.translate( 0, 0, depth * ( i / ( sliceCount - 1 ) - 0.5 ) );
+
+		}
+
+		const uv = geometry.attributes.uv;
+		const uvw = new BufferAttribute( new Float32Array( uv.count * 3 ), 3 );
+
+		for ( let j = 0, jl = uv.count; j < jl; ++ j ) {
+
+			const u = uv.getX( j );
+			const v = texture.flipY ? uv.getY( j ) : 1 - uv.getY( j );
+			const w = sliceCount === 1
+				? 1
+				: texture.isDataArrayTexture || texture.isCompressedArrayTexture
+					? i
+					: i / ( sliceCount - 1 );
+
+			uvw.setXYZ( j, u, v, w );
+
+		}
+
+		geometry.deleteAttribute( 'uv' );
+		geometry.setAttribute( 'uv', uvw );
+
+		geometries.push( geometry );
+
+	}
+
+	return mergeGeometries( geometries );
+
+}
+
+export { TextureHelper };

package/examples/jsm/interactive/HTMLMesh.js

@@ -62,6 +62,7 @@ class HTMLTexture extends CanvasTexture {
 		this.colorSpace = SRGBColorSpace;
 		this.minFilter = LinearFilter;
 		this.magFilter = LinearFilter;
+		this.generateMipmaps = false;
 
 		// Create an observer on the DOM, and run html2canvas update in the next loop
 		const observer = new MutationObserver( () => {

package/examples/jsm/lighting/TiledLighting.js

@@ -0,0 +1,18 @@
+import { Lighting } from 'three';
+import { tiledLights } from '../tsl/lighting/TiledLightsNode.js';
+
+export class TiledLighting extends Lighting {
+
+	constructor() {
+
+		super();
+
+	}
+
+	createNode( lights = [] ) {
+
+		return tiledLights().setLights( lights );
+
+	}
+
+}

package/examples/jsm/lights/RectAreaLightTexturesLib.js

@@ -71,7 +71,7 @@ class RectAreaLightTexturesLib {
 		LTC_HALF_2.needsUpdate = true;
 
 		this.LTC_HALF_1 = LTC_HALF_1;
-		this.LTC_HALF_1 = LTC_HALF_2;
+		this.LTC_HALF_2 = LTC_HALF_2;
 
 		this.LTC_FLOAT_1 = LTC_FLOAT_1;
 		this.LTC_FLOAT_2 = LTC_FLOAT_2;

package/examples/jsm/lines/LineMaterial.js

@@ -405,12 +405,17 @@ ShaderLib[ 'line' ] = {
 
 class LineMaterial extends ShaderMaterial {
 
+
+	static get type() {
+
+		return 'LineMaterial';
+
+	}
+
 	constructor( parameters ) {
 
 		super( {
 
-			type: 'LineMaterial',
-
 			uniforms: UniformsUtils.clone( ShaderLib[ 'line' ].uniforms ),
 
 			vertexShader: ShaderLib[ 'line' ].vertexShader,

package/examples/jsm/lines/LineSegmentsGeometry.js

@@ -82,6 +82,8 @@ class LineSegmentsGeometry extends InstancedBufferGeometry {
 		this.setAttribute( 'instanceStart', new InterleavedBufferAttribute( instanceBuffer, 3, 0 ) ); // xyz
 		this.setAttribute( 'instanceEnd', new InterleavedBufferAttribute( instanceBuffer, 3, 3 ) ); // xyz
 
+		this.instanceCount = this.attributes.instanceStart.count;
+
 		//
 
 		this.computeBoundingBox();

package/examples/jsm/lines/webgpu/LineSegments2.js

@@ -13,8 +13,6 @@ import {
 } from 'three';
 import { LineSegmentsGeometry } from '../../lines/LineSegmentsGeometry.js';
 
-const _viewport = new Vector4();
-
 const _start = new Vector3();
 const _end = new Vector3();
 
@@ -358,19 +356,6 @@ class LineSegments2 extends Mesh {
 
 	}
 
-	onBeforeRender( renderer ) {
-
-		const uniforms = this.material.uniforms;
-
-		if ( uniforms && uniforms.resolution ) {
-
-			renderer.getViewport( _viewport );
-			this.material.uniforms.resolution.value.set( _viewport.z, _viewport.w );
-
-		}
-
-	}
-
 }
 
 export { LineSegments2 };

package/examples/jsm/lines/webgpu/Wireframe.js

@@ -0,0 +1,56 @@
+import {
+	InstancedInterleavedBuffer,
+	InterleavedBufferAttribute,
+	Line2NodeMaterial,
+	Mesh,
+	Vector3
+} from 'three';
+import { LineSegmentsGeometry } from '../../lines/LineSegmentsGeometry.js';
+
+const _start = new Vector3();
+const _end = new Vector3();
+
+class Wireframe extends Mesh {
+
+	constructor( geometry = new LineSegmentsGeometry(), material = new Line2NodeMaterial( { color: Math.random() * 0xffffff } ) ) {
+
+		super( geometry, material );
+
+		this.isWireframe = true;
+
+		this.type = 'Wireframe';
+
+	}
+
+	// for backwards-compatibility, but could be a method of LineSegmentsGeometry...
+
+	computeLineDistances() {
+
+		const geometry = this.geometry;
+
+		const instanceStart = geometry.attributes.instanceStart;
+		const instanceEnd = geometry.attributes.instanceEnd;
+		const lineDistances = new Float32Array( 2 * instanceStart.count );
+
+		for ( let i = 0, j = 0, l = instanceStart.count; i < l; i ++, j += 2 ) {
+
+			_start.fromBufferAttribute( instanceStart, i );
+			_end.fromBufferAttribute( instanceEnd, i );
+
+			lineDistances[ j ] = ( j === 0 ) ? 0 : lineDistances[ j - 1 ];
+			lineDistances[ j + 1 ] = lineDistances[ j ] + _start.distanceTo( _end );
+
+		}
+
+		const instanceDistanceBuffer = new InstancedInterleavedBuffer( lineDistances, 2, 1 ); // d0, d1
+
+		geometry.setAttribute( 'instanceDistanceStart', new InterleavedBufferAttribute( instanceDistanceBuffer, 1, 0 ) ); // d0
+		geometry.setAttribute( 'instanceDistanceEnd', new InterleavedBufferAttribute( instanceDistanceBuffer, 1, 1 ) ); // d1
+
+		return this;
+
+	}
+
+}
+
+export { Wireframe };

package/examples/jsm/loaders/3DMLoader.js

@@ -745,6 +745,7 @@ class Rhino3dmLoader extends Loader {
 
 				const texture = new CanvasTexture( ctx.canvas );
 				texture.minFilter = LinearFilter;
+				texture.generateMipmaps = false;
 				texture.wrapS = ClampToEdgeWrapping;
 				texture.wrapT = ClampToEdgeWrapping;