super-three 0.136.0 → 0.141.0

package/examples/jsm/exporters/KTX2Exporter.js

@@ -0,0 +1,281 @@
+import {
+	FloatType,
+	HalfFloatType,
+	UnsignedByteType,
+	RGBAFormat,
+	RGFormat,
+	RGIntegerFormat,
+	RedFormat,
+	RedIntegerFormat,
+	LinearEncoding,
+	sRGBEncoding,
+	DataTexture,
+	REVISION,
+} from 'three';
+
+import {
+	write,
+	KTX2Container,
+	KHR_DF_CHANNEL_RGBSDA_ALPHA,
+	KHR_DF_CHANNEL_RGBSDA_BLUE,
+	KHR_DF_CHANNEL_RGBSDA_GREEN,
+	KHR_DF_CHANNEL_RGBSDA_RED,
+	KHR_DF_MODEL_RGBSDA,
+	KHR_DF_PRIMARIES_BT709,
+	KHR_DF_SAMPLE_DATATYPE_FLOAT,
+	KHR_DF_SAMPLE_DATATYPE_LINEAR,
+	KHR_DF_SAMPLE_DATATYPE_SIGNED,
+	KHR_DF_TRANSFER_LINEAR,
+	KHR_DF_TRANSFER_SRGB,
+	VK_FORMAT_R16_SFLOAT,
+	VK_FORMAT_R16G16_SFLOAT,
+	VK_FORMAT_R16G16B16A16_SFLOAT,
+	VK_FORMAT_R32_SFLOAT,
+	VK_FORMAT_R32G32_SFLOAT,
+	VK_FORMAT_R32G32B32A32_SFLOAT,
+	VK_FORMAT_R8_SRGB,
+	VK_FORMAT_R8_UNORM,
+	VK_FORMAT_R8G8_SRGB,
+	VK_FORMAT_R8G8_UNORM,
+	VK_FORMAT_R8G8B8A8_SRGB,
+	VK_FORMAT_R8G8B8A8_UNORM,
+ } from '../libs/ktx-parse.module.js';
+
+const VK_FORMAT_MAP = {
+
+	[RGBAFormat]: {
+		[FloatType]: {
+			[LinearEncoding]: VK_FORMAT_R32G32B32A32_SFLOAT,
+		},
+		[HalfFloatType]: {
+			[LinearEncoding]: VK_FORMAT_R16G16B16A16_SFLOAT,
+		},
+		[UnsignedByteType]: {
+			[LinearEncoding]: VK_FORMAT_R8G8B8A8_UNORM,
+			[sRGBEncoding]: VK_FORMAT_R8G8B8A8_SRGB,
+		},
+	},
+
+	[RGFormat]: {
+		[FloatType]: {
+			[LinearEncoding]: VK_FORMAT_R32G32_SFLOAT,
+		},
+		[HalfFloatType]: {
+			[LinearEncoding]: VK_FORMAT_R16G16_SFLOAT,
+		},
+		[UnsignedByteType]: {
+			[LinearEncoding]: VK_FORMAT_R8G8_UNORM,
+			[sRGBEncoding]: VK_FORMAT_R8G8_SRGB,
+		},
+	},
+
+	[RedFormat]: {
+		[FloatType]: {
+			[LinearEncoding]: VK_FORMAT_R32_SFLOAT,
+		},
+		[HalfFloatType]: {
+			[LinearEncoding]: VK_FORMAT_R16_SFLOAT,
+		},
+		[UnsignedByteType]: {
+			[LinearEncoding]: VK_FORMAT_R8_SRGB,
+			[sRGBEncoding]: VK_FORMAT_R8_UNORM,
+		},
+	},
+
+};
+
+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,
+
+};
+
+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.';
+const ERROR_TYPE = 'THREE.KTX2Exporter: Supported types are FloatType, HalfFloatType, or UnsignedByteType."';
+const ERROR_ENCODING = 'THREE.KTX2Exporter: Supported encodings are sRGB (UnsignedByteType only) or Linear.';
+
+export class KTX2Exporter {
+
+	parse( arg1, arg2 ) {
+
+		let texture;
+
+		if ( arg1.isDataTexture || arg1.isData3DTexture ) {
+
+			texture = arg1;
+
+		} else if ( arg1.isWebGLRenderer && arg2.isWebGLRenderTarget ) {
+
+			texture = toDataTexture( arg1, arg2 );
+
+		} else {
+
+			throw new Error( ERROR_INPUT );
+
+		}
+
+		if ( VK_FORMAT_MAP[ texture.format ] === undefined ) {
+
+			throw new Error( ERROR_FORMAT );
+
+		}
+
+		if ( VK_FORMAT_MAP[ texture.format ][ texture.type ] === undefined ) {
+
+			throw new Error( ERROR_TYPE );
+
+		}
+
+		if ( VK_FORMAT_MAP[ texture.format ][ texture.type ][ texture.encoding ] === undefined ) {
+
+			throw new Error( ERROR_ENCODING );
+
+		}
+
+		//
+
+		const array = texture.image.data;
+		const channelCount = getChannelCount( texture );
+		const container = new KTX2Container();
+
+		container.vkFormat = VK_FORMAT_MAP[ texture.format ][ texture.type ][ texture.encoding ];
+		container.typeSize = array.BYTES_PER_ELEMENT;
+		container.pixelWidth = texture.image.width;
+		container.pixelHeight = texture.image.height;
+
+		if ( texture.isData3DTexture ) {
+
+			container.pixelDepth = texture.image.depth;
+
+		}
+
+		//
+
+		const basicDesc = container.dataFormatDescriptor[ 0 ];
+
+		// TODO: After `texture.encoding` is replaced, distinguish between
+		// non-color data (unspecified model and primaries) and sRGB or Linear-sRGB colors.
+		basicDesc.colorModel = KHR_DF_MODEL_RGBSDA;
+		basicDesc.colorPrimaries = KHR_DF_PRIMARIES_BT709;
+		basicDesc.transferFunction = texture.encoding === sRGBEncoding
+			? KHR_DF_TRANSFER_SRGB
+			: KHR_DF_TRANSFER_LINEAR;
+
+		basicDesc.texelBlockDimension = [ 0, 0, 0, 0 ];
+
+		basicDesc.bytesPlane = [
+
+			container.typeSize * channelCount, 0, 0, 0, 0, 0, 0, 0,
+
+		];
+
+		for ( let i = 0; i < channelCount; ++ i ) {
+
+			let channelType = KHR_DF_CHANNEL_MAP[ i ];
+
+			if ( texture.encoding === LinearEncoding ) {
+
+				channelType |= KHR_DF_SAMPLE_DATATYPE_LINEAR;
+
+			}
+
+			if ( texture.type === FloatType || texture.type === HalfFloatType ) {
+
+				channelType |= KHR_DF_SAMPLE_DATATYPE_FLOAT;
+				channelType |= KHR_DF_SAMPLE_DATATYPE_SIGNED;
+
+			}
+
+			basicDesc.samples.push( {
+
+				channelType: channelType,
+				bitOffset: i * array.BYTES_PER_ELEMENT,
+				bitLength: array.BYTES_PER_ELEMENT * 8 - 1,
+				samplePosition: [0, 0, 0, 0],
+				sampleLower: texture.type === UnsignedByteType ? 0 : -1,
+				sampleUpper: texture.type === UnsignedByteType ? 255 : 1,
+
+			} );
+
+		}
+
+		//
+
+		container.levels = [ {
+
+			levelData: new Uint8Array( array.buffer, array.byteOffset, array.byteLength ),
+			uncompressedByteLength: array.byteLength,
+
+		} ];
+
+		//
+
+		container.keyValue['KTXwriter'] = `three.js ${ REVISION }`;
+
+		//
+
+		return write( container, { keepWriter: true } );
+
+	}
+
+}
+
+function toDataTexture( renderer, rtt ) {
+
+	const channelCount = getChannelCount( rtt.texture );
+
+	let view;
+
+	if ( rtt.texture.type === FloatType ) {
+
+		view = new Float32Array( rtt.width * rtt.height * channelCount );
+
+	} else if ( rtt.texture.type === HalfFloatType ) {
+
+		view = new Uint16Array( rtt.width * rtt.height * channelCount );
+
+	} else if ( rtt.texture.type === UnsignedByteType ) {
+
+		view = new Uint8Array( rtt.width * rtt.height * channelCount );
+
+	} else {
+
+		throw new Error( ERROR_TYPE );
+
+	}
+
+	renderer.readRenderTargetPixels( rtt, 0, 0, rtt.width, rtt.height, view );
+
+	return new DataTexture( view, rtt.width, rt.height, rtt.texture.format, rtt.texture.type );
+
+}
+
+function getChannelCount( texture ) {
+
+	switch ( texture.format ) {
+
+		case RGBAFormat:
+
+			return 4;
+
+		case RGFormat:
+		case RGIntegerFormat:
+
+			return 2;
+
+		case RedFormat:
+		case RedIntegerFormat:
+
+			return 1;
+
+		default:
+
+			throw new Error( ERROR_FORMAT );
+
+	}
+
+}

package/examples/jsm/exporters/MMDExporter.js

@@ -186,7 +186,7 @@ function unicodeToShiftjis( str ) {
 
 		if ( value === undefined ) {
 
-			throw 'cannot convert charcode 0x' + code.toString( 16 );
+			throw new Error( 'cannot convert charcode 0x' + code.toString( 16 ) );
 
 		} else if ( value > 0xff ) {
 

package/examples/jsm/exporters/OBJExporter.js

@@ -60,9 +60,7 @@ class OBJExporter {
 
 				for ( let i = 0, l = vertices.count; i < l; i ++, nbVertex ++ ) {
 
-					vertex.x = vertices.getX( i );
-					vertex.y = vertices.getY( i );
-					vertex.z = vertices.getZ( i );
+					vertex.fromBufferAttribute( vertices, i );
 
 					// transform the vertex to world space
 					vertex.applyMatrix4( mesh.matrixWorld );
@@ -80,8 +78,7 @@ class OBJExporter {
 
 				for ( let i = 0, l = uvs.count; i < l; i ++, nbVertexUvs ++ ) {
 
-					uv.x = uvs.getX( i );
-					uv.y = uvs.getY( i );
+					uv.fromBufferAttribute( uvs, i );
 
 					// transform the uv to export format
 					output += 'vt ' + uv.x + ' ' + uv.y + '\n';
@@ -98,9 +95,7 @@ class OBJExporter {
 
 				for ( let i = 0, l = normals.count; i < l; i ++, nbNormals ++ ) {
 
-					normal.x = normals.getX( i );
-					normal.y = normals.getY( i );
-					normal.z = normals.getZ( i );
+					normal.fromBufferAttribute( normals, i );
 
 					// transform the normal to world space
 					normal.applyMatrix3( normalMatrixWorld ).normalize();
@@ -180,9 +175,7 @@ class OBJExporter {
 
 				for ( let i = 0, l = vertices.count; i < l; i ++, nbVertex ++ ) {
 
-					vertex.x = vertices.getX( i );
-					vertex.y = vertices.getY( i );
-					vertex.z = vertices.getZ( i );
+					vertex.fromBufferAttribute( vertices, i );
 
 					// transform the vertex to world space
 					vertex.applyMatrix4( line.matrixWorld );
@@ -251,7 +244,7 @@ class OBJExporter {
 
 					if ( colors !== undefined ) {
 
-						color.fromBufferAttribute( colors, i );
+						color.fromBufferAttribute( colors, i ).convertLinearToSRGB();
 
 						output += ' ' + color.r + ' ' + color.g + ' ' + color.b;
 
@@ -261,17 +254,17 @@ class OBJExporter {
 
 				}
 
-			}
+				output += 'p ';
 
-			output += 'p ';
+				for ( let j = 1, l = vertices.count; j <= l; j ++ ) {
 
-			for ( let j = 1, l = vertices.count; j <= l; j ++ ) {
+					output += ( indexVertex + j ) + ' ';
 
-				output += ( indexVertex + j ) + ' ';
+				}
 
-			}
+				output += '\n';
 
-			output += '\n';
+			}
 
 			// update index
 			indexVertex += nbVertex;

package/examples/jsm/exporters/PLYExporter.js

@@ -1,6 +1,7 @@
 import {
 	Matrix3,
-	Vector3
+	Vector3,
+	Color
 } from 'three';
 
 /**
@@ -112,6 +113,7 @@ class PLYExporter {
 
 		} );
 
+		const tempColor = new Color();
 		const includeIndices = excludeAttributes.indexOf( 'index' ) === - 1;
 		includeNormals = includeNormals && excludeAttributes.indexOf( 'normal' ) === - 1;
 		includeColors = includeColors && excludeAttributes.indexOf( 'color' ) === - 1;
@@ -225,9 +227,7 @@ class PLYExporter {
 
 				for ( let i = 0, l = vertices.count; i < l; i ++ ) {
 
-					vertex.x = vertices.getX( i );
-					vertex.y = vertices.getY( i );
-					vertex.z = vertices.getZ( i );
+					vertex.fromBufferAttribute( vertices, i );
 
 					vertex.applyMatrix4( mesh.matrixWorld );
 
@@ -247,9 +247,7 @@ class PLYExporter {
 
 						if ( normals != null ) {
 
-							vertex.x = normals.getX( i );
-							vertex.y = normals.getY( i );
-							vertex.z = normals.getZ( i );
+							vertex.fromBufferAttribute( normals, i );
 
 							vertex.applyMatrix3( normalMatrixWorld ).normalize();
 
@@ -288,7 +286,7 @@ class PLYExporter {
 							output.setFloat32( vOffset, uvs.getY( i ), options.littleEndian );
 							vOffset += 4;
 
-						} else if ( includeUVs !== false ) {
+						} else {
 
 							output.setFloat32( vOffset, 0, options.littleEndian );
 							vOffset += 4;
@@ -305,13 +303,17 @@ class PLYExporter {
 
 						if ( colors != null ) {
 
-							output.setUint8( vOffset, Math.floor( colors.getX( i ) * 255 ) );
+							tempColor
+								.fromBufferAttribute( colors, i )
+								.convertLinearToSRGB();
+
+							output.setUint8( vOffset, Math.floor( tempColor.r * 255 ) );
 							vOffset += 1;
 
-							output.setUint8( vOffset, Math.floor( colors.getY( i ) * 255 ) );
+							output.setUint8( vOffset, Math.floor( tempColor.g * 255 ) );
 							vOffset += 1;
 
-							output.setUint8( vOffset, Math.floor( colors.getZ( i ) * 255 ) );
+							output.setUint8( vOffset, Math.floor( tempColor.b * 255 ) );
 							vOffset += 1;
 
 						} else {
@@ -405,9 +407,7 @@ class PLYExporter {
 				// form each line
 				for ( let i = 0, l = vertices.count; i < l; i ++ ) {
 
-					vertex.x = vertices.getX( i );
-					vertex.y = vertices.getY( i );
-					vertex.z = vertices.getZ( i );
+					vertex.fromBufferAttribute( vertices, i );
 
 					vertex.applyMatrix4( mesh.matrixWorld );
 
@@ -423,9 +423,7 @@ class PLYExporter {
 
 						if ( normals != null ) {
 
-							vertex.x = normals.getX( i );
-							vertex.y = normals.getY( i );
-							vertex.z = normals.getZ( i );
+							vertex.fromBufferAttribute( normals, i );
 
 							vertex.applyMatrix3( normalMatrixWorld ).normalize();
 
@@ -451,7 +449,7 @@ class PLYExporter {
 								uvs.getX( i ) + ' ' +
 								uvs.getY( i );
 
-						} else if ( includeUVs !== false ) {
+						} else {
 
 							line += ' 0 0';
 
@@ -464,10 +462,14 @@ class PLYExporter {
 
 						if ( colors != null ) {
 
+							tempColor
+								.fromBufferAttribute( colors, i )
+								.convertLinearToSRGB();
+
 							line += ' ' +
-								Math.floor( colors.getX( i ) * 255 ) + ' ' +
-								Math.floor( colors.getY( i ) * 255 ) + ' ' +
-								Math.floor( colors.getZ( i ) * 255 );
+								Math.floor( tempColor.r * 255 ) + ' ' +
+								Math.floor( tempColor.g * 255 ) + ' ' +
+								Math.floor( tempColor.b * 255 );
 
 						} else {
 

package/examples/jsm/exporters/USDZExporter.js

@@ -402,6 +402,7 @@ function buildMaterial( material, textures ) {
             float outputs:g
             float outputs:b
             float3 outputs:rgb
+            ${ material.transparent || material.alphaTest > 0.0 ? 'float outputs:a' : '' }
         }`;
 
 	}
@@ -410,6 +411,17 @@ function buildMaterial( material, textures ) {
 
 		inputs.push( `${ pad }color3f inputs:diffuseColor.connect = </Materials/Material_${ material.id }/Texture_${ material.map.id }_diffuse.outputs:rgb>` );
 
+		if ( material.transparent ) {
+
+			inputs.push( `${ pad }float inputs:opacity.connect = </Materials/Material_${ material.id }/Texture_${ material.map.id }_diffuse.outputs:a>` );
+
+		} else if ( material.alphaTest > 0.0 ) {
+
+			inputs.push( `${ pad }float inputs:opacity.connect = </Materials/Material_${ material.id }/Texture_${ material.map.id }_diffuse.outputs:a>` );
+			inputs.push( `${ pad }float inputs:opacityThreshold = ${material.alphaTest}` );
+
+		}
+
 		samplers.push( buildTexture( material.map, 'diffuse', material.color ) );
 
 	} else {

package/examples/jsm/geometries/ConvexGeometry.js

@@ -6,7 +6,7 @@ import { ConvexHull } from '../math/ConvexHull.js';
 
 class ConvexGeometry extends BufferGeometry {
 
-	constructor( points ) {
+	constructor( points = [] ) {
 
 		super();
 

package/examples/jsm/geometries/DecalGeometry.js

@@ -64,13 +64,6 @@ class DecalGeometry extends BufferGeometry {
 
 			// handle different geometry types
 
-			if ( mesh.geometry.isGeometry === true ) {
-
-				console.error( 'THREE.DecalGeometry no longer supports THREE.Geometry. Use BufferGeometry instead.' );
-				return;
-
-			}
-
 			const geometry = mesh.geometry;
 
 			const positionAttribute = geometry.attributes.position;

package/examples/jsm/geometries/LightningStrike.js

@@ -115,6 +115,8 @@ class LightningStrike extends BufferGeometry {
 
 		super();
 
+		this.isLightningStrike = true;
+
 		this.type = 'LightningStrike';
 
 		// Set parameters, and set undefined parameters to default values
@@ -1001,8 +1003,6 @@ class LightningStrike extends BufferGeometry {
 
 }
 
-LightningStrike.prototype.isLightningStrike = true;
-
 // Ray states
 LightningStrike.RAY_INITIALIZED = 0;
 LightningStrike.RAY_UNBORN = 1;

package/examples/jsm/geometries/ParametricGeometries.js

@@ -210,9 +210,9 @@ ParametricGeometries.SphereGeometry = class SphereGeometry extends ParametricGeo
 			u *= Math.PI;
 			v *= 2 * Math.PI;
 
-			var x = size * Math.sin( u ) * Math.cos( v );
-			var y = size * Math.sin( u ) * Math.sin( v );
-			var z = size * Math.cos( u );
+			const x = size * Math.sin( u ) * Math.cos( v );
+			const y = size * Math.sin( u ) * Math.sin( v );
+			const z = size * Math.cos( u );
 
 			target.set( x, y, z );
 

package/examples/jsm/geometries/TextGeometry.js

@@ -16,7 +16,6 @@
  */
 
 import {
-	BufferGeometry,
 	ExtrudeGeometry
 } from 'three';
 
@@ -26,26 +25,27 @@ class TextGeometry extends ExtrudeGeometry {
 
 		const font = parameters.font;
 
-		if ( ! ( font && font.isFont ) ) {
+		if ( font === undefined ) {
 
-			console.error( 'THREE.TextGeometry: font parameter is not an instance of THREE.Font.' );
-			return new BufferGeometry();
+			super(); // generate default extrude geometry
 
-		}
+		} else {
+
+			const shapes = font.generateShapes( text, parameters.size );
 
-		const shapes = font.generateShapes( text, parameters.size );
+			// translate parameters to ExtrudeGeometry API
 
-		// translate parameters to ExtrudeGeometry API
+			parameters.depth = parameters.height !== undefined ? parameters.height : 50;
 
-		parameters.depth = parameters.height !== undefined ? parameters.height : 50;
+			// defaults
 
-		// defaults
+			if ( parameters.bevelThickness === undefined ) parameters.bevelThickness = 10;
+			if ( parameters.bevelSize === undefined ) parameters.bevelSize = 8;
+			if ( parameters.bevelEnabled === undefined ) parameters.bevelEnabled = false;
 
-		if ( parameters.bevelThickness === undefined ) parameters.bevelThickness = 10;
-		if ( parameters.bevelSize === undefined ) parameters.bevelSize = 8;
-		if ( parameters.bevelEnabled === undefined ) parameters.bevelEnabled = false;
+			super( shapes, parameters );
 
-		super( shapes, parameters );
+		}
 
 		this.type = 'TextGeometry';
 

package/examples/jsm/helpers/OctreeHelper.js

@@ -0,0 +1,58 @@
+import {
+	LineSegments,
+	BufferGeometry,
+	Float32BufferAttribute,
+	LineBasicMaterial
+} from 'three';
+
+class OctreeHelper extends LineSegments {
+
+	constructor( octree, color = 0xffff00 ) {
+
+		const vertices = [];
+
+		function traverse( tree ) {
+
+			for ( let i = 0; i < tree.length; i ++ ) {
+
+				const min = tree[ i ].box.min;
+				const max = tree[ i ].box.max;
+
+				vertices.push( max.x, max.y, max.z ); vertices.push( min.x, max.y, max.z ); // 0, 1
+				vertices.push( min.x, max.y, max.z ); vertices.push( min.x, min.y, max.z ); // 1, 2
+				vertices.push( min.x, min.y, max.z ); vertices.push( max.x, min.y, max.z ); // 2, 3
+				vertices.push( max.x, min.y, max.z ); vertices.push( max.x, max.y, max.z ); // 3, 0
+
+				vertices.push( max.x, max.y, min.z ); vertices.push( min.x, max.y, min.z ); // 4, 5
+				vertices.push( min.x, max.y, min.z ); vertices.push( min.x, min.y, min.z ); // 5, 6
+				vertices.push( min.x, min.y, min.z ); vertices.push( max.x, min.y, min.z ); // 6, 7
+				vertices.push( max.x, min.y, min.z ); vertices.push( max.x, max.y, min.z ); // 7, 4
+
+				vertices.push( max.x, max.y, max.z ); vertices.push( max.x, max.y, min.z ); // 0, 4
+				vertices.push( min.x, max.y, max.z ); vertices.push( min.x, max.y, min.z ); // 1, 5
+				vertices.push( min.x, min.y, max.z ); vertices.push( min.x, min.y, min.z ); // 2, 6
+				vertices.push( max.x, min.y, max.z ); vertices.push( max.x, min.y, min.z ); // 3, 7
+
+				traverse( tree[ i ].subTrees );
+
+			}
+
+		}
+
+		traverse( octree.subTrees );
+
+		const geometry = new BufferGeometry();
+		geometry.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+
+		super( geometry, new LineBasicMaterial( { color: color, toneMapped: false } ) );
+
+		this.octree = octree;
+		this.color = color;
+
+		this.type = 'OctreeHelper';
+
+	}
+
+}
+
+export { OctreeHelper };