super-three 0.147.1 → 0.154.0

package/examples/jsm/loaders/lwo/IFFParser.js

@@ -32,7 +32,6 @@
  *
  **/
 
-import { LoaderUtils } from 'three';
 import { LWO2Parser } from './LWO2Parser.js';
 import { LWO3Parser } from './LWO3Parser.js';
 
@@ -908,6 +907,8 @@ function DataViewReader( buffer ) {
 
 	this.dv = new DataView( buffer );
 	this.offset = 0;
+	this._textDecoder = new TextDecoder();
+	this._bytes = new Uint8Array( buffer );
 
 }
 
@@ -1065,35 +1066,34 @@ DataViewReader.prototype = {
 
 		if ( size === 0 ) return;
 
-		// note: safari 9 doesn't support Uint8Array.indexOf; create intermediate array instead
-		var a = [];
-
-		if ( size ) {
+		const start = this.offset;
 
-			for ( var i = 0; i < size; i ++ ) {
+		let result;
+		let length;
 
-				a[ i ] = this.getUint8();
+		if ( size ) {
 
-			}
+			length = size;
+			result = this._textDecoder.decode( new Uint8Array( this.dv.buffer, start, size ) );
 
 		} else {
 
-			var currentChar;
-			var len = 0;
-
-			while ( currentChar !== 0 ) {
+			// use 1:1 mapping of buffer to avoid redundant new array creation.
+			length = this._bytes.indexOf( 0, start ) - start;
 
-				currentChar = this.getUint8();
-				if ( currentChar !== 0 ) a.push( currentChar );
-				len ++;
+			result = this._textDecoder.decode( new Uint8Array( this.dv.buffer, start, length ) );
 
-			}
+			// account for null byte in length
+			length ++;
 
-			if ( ! isEven( len + 1 ) ) this.getUint8(); // if string with terminating nullbyte is uneven, extra nullbyte is added
+			// if string with terminating nullbyte is uneven, extra nullbyte is added, skip that too
+			length += length % 2;
 
 		}
 
-		return LoaderUtils.decodeText( new Uint8Array( a ) );
+		this.skip( length );
+
+		return result;
 
 	},
 
@@ -1211,7 +1211,7 @@ function stringOffset( string ) {
 // printBuffer( this.reader.dv.buffer, this.reader.offset, length );
 function printBuffer( buffer, from, to ) {
 
-	console.log( LoaderUtils.decodeText( new Uint8Array( buffer, from, to ) ) );
+	console.log( new TextDecoder().decode( new Uint8Array( buffer, from, to ) ) );
 
 }
 

package/examples/jsm/materials/MeshGouraudMaterial.js

@@ -37,7 +37,6 @@ const GouraudShader = {
 
 		#include <common>
 		#include <uv_pars_vertex>
-		#include <uv2_pars_vertex>
 		#include <envmap_pars_vertex>
 		#include <bsdfs>
 		#include <lights_pars_begin>
@@ -52,7 +51,6 @@ const GouraudShader = {
 		void main() {
 
 			#include <uv_vertex>
-			#include <uv2_vertex>
 			#include <color_vertex>
 			#include <morphcolor_vertex>
 
@@ -221,7 +219,6 @@ const GouraudShader = {
 		#include <dithering_pars_fragment>
 		#include <color_pars_fragment>
 		#include <uv_pars_fragment>
-		#include <uv2_pars_fragment>
 		#include <map_pars_fragment>
 		#include <alphamap_pars_fragment>
 		#include <alphatest_pars_fragment>
@@ -291,9 +288,9 @@ const GouraudShader = {
 
 			#include <envmap_fragment>
 
-			#include <output_fragment>
+			#include <opaque_fragment>
 			#include <tonemapping_fragment>
-			#include <encodings_fragment>
+			#include <colorspace_fragment>
 			#include <fog_fragment>
 			#include <premultiplied_alpha_fragment>
 			#include <dithering_fragment>

package/examples/jsm/math/Lut.js

@@ -1,5 +1,6 @@
 import {
 	Color,
+	LinearSRGBColorSpace,
 	MathUtils
 } from 'three';
 
@@ -75,8 +76,8 @@ class Lut {
 					const min = this.map[ j ][ 0 ];
 					const max = this.map[ j + 1 ][ 0 ];
 
-					minColor.set( this.map[ j ][ 1 ] );
-					maxColor.set( this.map[ j + 1 ][ 1 ] );
+					minColor.setHex( this.map[ j ][ 1 ], LinearSRGBColorSpace );
+					maxColor.setHex( this.map[ j + 1 ][ 1 ], LinearSRGBColorSpace );
 
 					const color = new Color().lerpColors( minColor, maxColor, ( alpha - min ) / ( max - min ) );
 
@@ -165,8 +166,8 @@ class Lut {
 					const min = this.map[ j - 1 ][ 0 ];
 					const max = this.map[ j ][ 0 ];
 
-					minColor.set( this.map[ j - 1 ][ 1 ] );
-					maxColor.set( this.map[ j ][ 1 ] );
+					minColor.setHex( this.map[ j - 1 ][ 1 ], LinearSRGBColorSpace );
+					maxColor.setHex( this.map[ j ][ 1 ], LinearSRGBColorSpace );
 
 					finalColor.lerpColors( minColor, maxColor, ( i - min ) / ( max - min ) );
 

package/examples/jsm/math/MeshSurfaceSampler.js

@@ -1,5 +1,6 @@
 import {
 	Triangle,
+	Vector2,
 	Vector3
 } from 'three';
 
@@ -16,32 +17,20 @@ import {
 
 const _face = new Triangle();
 const _color = new Vector3();
+const _uva = new Vector2(), _uvb = new Vector2(), _uvc = new Vector2();
 
 class MeshSurfaceSampler {
 
 	constructor( mesh ) {
 
-		let geometry = mesh.geometry;
-
-		if ( ! geometry.isBufferGeometry || geometry.attributes.position.itemSize !== 3 ) {
-
-			throw new Error( 'THREE.MeshSurfaceSampler: Requires BufferGeometry triangle mesh.' );
-
-		}
-
-		if ( geometry.index ) {
-
-			console.warn( 'THREE.MeshSurfaceSampler: Converting geometry to non-indexed BufferGeometry.' );
-
-			geometry = geometry.toNonIndexed();
-
-		}
-
-		this.geometry = geometry;
+		this.geometry = mesh.geometry;
 		this.randomFunction = Math.random;
 
+		this.indexAttribute = this.geometry.index;
 		this.positionAttribute = this.geometry.getAttribute( 'position' );
+		this.normalAttribute = this.geometry.getAttribute( 'normal' );
 		this.colorAttribute = this.geometry.getAttribute( 'color' );
+		this.uvAttribute = this.geometry.getAttribute( 'uv' );
 		this.weightAttribute = null;
 
 		this.distribution = null;
@@ -58,49 +47,62 @@ class MeshSurfaceSampler {
 
 	build() {
 
+		const indexAttribute = this.indexAttribute;
 		const positionAttribute = this.positionAttribute;
 		const weightAttribute = this.weightAttribute;
 
-		const faceWeights = new Float32Array( positionAttribute.count / 3 );
+		const totalFaces = indexAttribute ? ( indexAttribute.count / 3 ) : ( positionAttribute.count / 3 );
+		const faceWeights = new Float32Array( totalFaces );
 
 		// Accumulate weights for each mesh face.
 
-		for ( let i = 0; i < positionAttribute.count; i += 3 ) {
+		for ( let i = 0; i < totalFaces; i ++ ) {
 
 			let faceWeight = 1;
 
+			let i0 = 3 * i;
+			let i1 = 3 * i + 1;
+			let i2 = 3 * i + 2;
+
+			if ( indexAttribute ) {
+
+				i0 = indexAttribute.getX( i0 );
+				i1 = indexAttribute.getX( i1 );
+				i2 = indexAttribute.getX( i2 );
+
+			}
+
 			if ( weightAttribute ) {
 
-				faceWeight = weightAttribute.getX( i )
-					+ weightAttribute.getX( i + 1 )
-					+ weightAttribute.getX( i + 2 );
+				faceWeight = weightAttribute.getX( i0 )
+					+ weightAttribute.getX( i1 )
+					+ weightAttribute.getX( i2 );
 
 			}
 
-			_face.a.fromBufferAttribute( positionAttribute, i );
-			_face.b.fromBufferAttribute( positionAttribute, i + 1 );
-			_face.c.fromBufferAttribute( positionAttribute, i + 2 );
+			_face.a.fromBufferAttribute( positionAttribute, i0 );
+			_face.b.fromBufferAttribute( positionAttribute, i1 );
+			_face.c.fromBufferAttribute( positionAttribute, i2 );
 			faceWeight *= _face.getArea();
 
-			faceWeights[ i / 3 ] = faceWeight;
+			faceWeights[ i ] = faceWeight;
 
 		}
 
 		// Store cumulative total face weights in an array, where weight index
 		// corresponds to face index.
 
-		this.distribution = new Float32Array( positionAttribute.count / 3 );
-
+		const distribution = new Float32Array( totalFaces );
 		let cumulativeTotal = 0;
 
-		for ( let i = 0; i < faceWeights.length; i ++ ) {
+		for ( let i = 0; i < totalFaces; i ++ ) {
 
 			cumulativeTotal += faceWeights[ i ];
-
-			this.distribution[ i ] = cumulativeTotal;
+			distribution[ i ] = cumulativeTotal;
 
 		}
 
+		this.distribution = distribution;
 		return this;
 
 	}
@@ -112,13 +114,17 @@ class MeshSurfaceSampler {
 
 	}
 
-	sample( targetPosition, targetNormal, targetColor ) {
+	sample( targetPosition, targetNormal, targetColor, targetUV ) {
 
-		const cumulativeTotal = this.distribution[ this.distribution.length - 1 ];
+		const faceIndex = this.sampleFaceIndex();
+		return this.sampleFace( faceIndex, targetPosition, targetNormal, targetColor, targetUV );
 
-		const faceIndex = this.binarySearch( this.randomFunction() * cumulativeTotal );
+	}
+
+	sampleFaceIndex() {
 
-		return this.sampleFace( faceIndex, targetPosition, targetNormal, targetColor );
+		const cumulativeTotal = this.distribution[ this.distribution.length - 1 ];
+		return this.binarySearch( this.randomFunction() * cumulativeTotal );
 
 	}
 
@@ -156,7 +162,7 @@ class MeshSurfaceSampler {
 
 	}
 
-	sampleFace( faceIndex, targetPosition, targetNormal, targetColor ) {
+	sampleFace( faceIndex, targetPosition, targetNormal, targetColor, targetUV ) {
 
 		let u = this.randomFunction();
 		let v = this.randomFunction();
@@ -168,9 +174,22 @@ class MeshSurfaceSampler {
 
 		}
 
-		_face.a.fromBufferAttribute( this.positionAttribute, faceIndex * 3 );
-		_face.b.fromBufferAttribute( this.positionAttribute, faceIndex * 3 + 1 );
-		_face.c.fromBufferAttribute( this.positionAttribute, faceIndex * 3 + 2 );
+		// get the vertex attribute indices
+		const indexAttribute = this.indexAttribute;
+		let i0 = faceIndex * 3;
+		let i1 = faceIndex * 3 + 1;
+		let i2 = faceIndex * 3 + 2;
+		if ( indexAttribute ) {
+
+			i0 = indexAttribute.getX( i0 );
+			i1 = indexAttribute.getX( i1 );
+			i2 = indexAttribute.getX( i2 );
+
+		}
+
+		_face.a.fromBufferAttribute( this.positionAttribute, i0 );
+		_face.b.fromBufferAttribute( this.positionAttribute, i1 );
+		_face.c.fromBufferAttribute( this.positionAttribute, i2 );
 
 		targetPosition
 			.set( 0, 0, 0 )
@@ -180,15 +199,26 @@ class MeshSurfaceSampler {
 
 		if ( targetNormal !== undefined ) {
 
-			_face.getNormal( targetNormal );
+			if ( this.normalAttribute !== undefined ) {
+
+				_face.a.fromBufferAttribute( this.normalAttribute, i0 );
+				_face.b.fromBufferAttribute( this.normalAttribute, i1 );
+				_face.c.fromBufferAttribute( this.normalAttribute, i2 );
+				targetNormal.set( 0, 0, 0 ).addScaledVector( _face.a, u ).addScaledVector( _face.b, v ).addScaledVector( _face.c, 1 - ( u + v ) ).normalize();
+
+			} else {
+
+				_face.getNormal( targetNormal );
+
+			}
 
 		}
 
 		if ( targetColor !== undefined && this.colorAttribute !== undefined ) {
 
-			_face.a.fromBufferAttribute( this.colorAttribute, faceIndex * 3 );
-			_face.b.fromBufferAttribute( this.colorAttribute, faceIndex * 3 + 1 );
-			_face.c.fromBufferAttribute( this.colorAttribute, faceIndex * 3 + 2 );
+			_face.a.fromBufferAttribute( this.colorAttribute, i0 );
+			_face.b.fromBufferAttribute( this.colorAttribute, i1 );
+			_face.c.fromBufferAttribute( this.colorAttribute, i2 );
 
 			_color
 				.set( 0, 0, 0 )
@@ -202,6 +232,15 @@ class MeshSurfaceSampler {
 
 		}
 
+		if ( targetUV !== undefined && this.uvAttribute !== undefined ) {
+
+			_uva.fromBufferAttribute( this.uvAttribute, i0 );
+			_uvb.fromBufferAttribute( this.uvAttribute, i1 );
+			_uvc.fromBufferAttribute( this.uvAttribute, i2 );
+			targetUV.set( 0, 0 ).addScaledVector( _uva, u ).addScaledVector( _uvb, v ).addScaledVector( _uvc, 1 - ( u + v ) );
+
+		}
+
 		return this;
 
 	}

package/examples/jsm/misc/ConvexObjectBreaker.js

@@ -19,7 +19,7 @@ import { ConvexGeometry } from '../geometries/ConvexGeometry.js';
  *
  * Requisites for the object:
  *
- *  - Mesh object must have a BufferGeometry (not Geometry) and a Material
+ *  - Mesh object must have a buffer geometry and a material
  *
  *  - Vertex normals must be planar (not smoothed)
  *
@@ -70,16 +70,10 @@ class ConvexObjectBreaker {
 
 	prepareBreakableObject( object, mass, velocity, angularVelocity, breakable ) {
 
-		// object is a Object3d (normally a Mesh), must have a BufferGeometry, and it must be convex.
+		// object is a Object3d (normally a Mesh), must have a buffer geometry, and it must be convex.
 		// Its material property is propagated to its children (sub-pieces)
 		// mass must be > 0
 
-		if ( ! object.geometry.isBufferGeometry ) {
-
-			console.error( 'THREE.ConvexObjectBreaker.prepareBreakableObject(): Parameter object must have a BufferGeometry.' );
-
-		}
-
 		const userData = object.userData;
 		userData.mass = mass;
 		userData.velocity = velocity.clone();

package/examples/jsm/misc/GPUComputationRenderer.js

@@ -3,7 +3,7 @@ import {
 	ClampToEdgeWrapping,
 	DataTexture,
 	FloatType,
-	LinearEncoding,
+	LinearSRGBColorSpace,
 	Mesh,
 	NearestFilter,
 	NoToneMapping,
@@ -301,7 +301,7 @@ class GPUComputationRenderer {
 
 				const variable = variables[ i ];
 
-				variable.initialValueTexture?.dispose();
+				if ( variable.initialValueTexture ) variable.initialValueTexture.dispose();
 
 				const renderTargets = variable.renderTargets;
 
@@ -332,6 +332,7 @@ class GPUComputationRenderer {
 			uniforms = uniforms || {};
 
 			const material = new ShaderMaterial( {
+				name: 'GPUComputationShader',
 				uniforms: uniforms,
 				vertexShader: getPassThroughVertexShader(),
 				fragmentShader: computeFragmentShader
@@ -399,12 +400,12 @@ class GPUComputationRenderer {
 
 			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;
 
 			mesh.material = material;
@@ -414,7 +415,7 @@ class GPUComputationRenderer {
 
 			renderer.xr.enabled = currentXrEnabled;
 			renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
-			renderer.outputEncoding = currentOutputEncoding;
+			renderer.outputColorSpace = currentOutputColorSpace;
 			renderer.toneMapping = currentToneMapping;
 
 			renderer.setRenderTarget( currentRenderTarget );

package/examples/jsm/misc/MD2Character.js

@@ -6,7 +6,7 @@ import {
 	Object3D,
 	TextureLoader,
 	UVMapping,
-	sRGBEncoding
+	SRGBColorSpace
 } from 'three';
 import { MD2Loader } from '../loaders/MD2Loader.js';
 
@@ -73,7 +73,7 @@ class MD2Character {
 				textures[ i ] = textureLoader.load( baseUrl + textureUrls[ i ], checkLoadingComplete );
 				textures[ i ].mapping = UVMapping;
 				textures[ i ].name = textureUrls[ i ];
-				textures[ i ].encoding = sRGBEncoding;
+				textures[ i ].colorSpace = SRGBColorSpace;
 
 			}
 

package/examples/jsm/misc/MD2CharacterComplex.js

@@ -5,7 +5,7 @@ import {
 	Object3D,
 	TextureLoader,
 	UVMapping,
-	sRGBEncoding
+	SRGBColorSpace
 } from 'three';
 import { MD2Loader } from '../loaders/MD2Loader.js';
 import { MorphBlendMesh } from '../misc/MorphBlendMesh.js';
@@ -157,7 +157,7 @@ class MD2CharacterComplex {
 				textures[ i ] = textureLoader.load( baseUrl + textureUrls[ i ], checkLoadingComplete );
 				textures[ i ].mapping = UVMapping;
 				textures[ i ].name = textureUrls[ i ];
-				textures[ i ].encoding = sRGBEncoding;
+				textures[ i ].colorSpace = SRGBColorSpace;
 
 			}
 

package/examples/jsm/misc/ProgressiveLightMap.js

@@ -36,6 +36,7 @@ class ProgressiveLightMap {
 		const format = /(Android|iPad|iPhone|iPod)/g.test( navigator.userAgent ) ? THREE.HalfFloatType : THREE.FloatType;
 		this.progressiveLightMap1 = new THREE.WebGLRenderTarget( this.res, this.res, { type: format } );
 		this.progressiveLightMap2 = new THREE.WebGLRenderTarget( this.res, this.res, { type: format } );
+		this.progressiveLightMap2.texture.channel = 1;
 
 		// Inject some spicy new logic into a standard phong material
 		this.uvMat = new THREE.MeshPhongMaterial();
@@ -45,17 +46,18 @@ class ProgressiveLightMap {
 			// Vertex Shader: Set Vertex Positions to the Unwrapped UV Positions
 			shader.vertexShader =
 				'#define USE_LIGHTMAP\n' +
+				'#define LIGHTMAP_UV uv1\n' +
 				shader.vertexShader.slice( 0, - 1 ) +
-				'	gl_Position = vec4((uv2 - 0.5) * 2.0, 1.0, 1.0); }';
+				'	gl_Position = vec4((LIGHTMAP_UV - 0.5) * 2.0, 1.0, 1.0); }';
 
 			// Fragment Shader: Set Pixels to average in the Previous frame's Shadows
 			const bodyStart = shader.fragmentShader.indexOf( 'void main() {' );
 			shader.fragmentShader =
-				'varying vec2 vUv2;\n' +
+				'#define USE_LIGHTMAP\n' +
 				shader.fragmentShader.slice( 0, bodyStart ) +
 				'	uniform sampler2D previousShadowMap;\n	uniform float averagingWindow;\n' +
 				shader.fragmentShader.slice( bodyStart - 1, - 1 ) +
-				`\nvec3 texelOld = texture2D(previousShadowMap, vUv2).rgb;
+				`\nvec3 texelOld = texture2D(previousShadowMap, vLightMapUv).rgb;
 				gl_FragColor.rgb = mix(texelOld, gl_FragColor.rgb, 1.0/averagingWindow);
 			}`;
 
@@ -75,7 +77,7 @@ class ProgressiveLightMap {
 	}
 
 	/**
-	 * Sets these objects' materials' lightmaps and modifies their uv2's.
+	 * Sets these objects' materials' lightmaps and modifies their uv1's.
 	 * @param {Object3D} objects An array of objects and lights to set up your lightmap.
 	 */
 	addObjectsToLightMap( objects ) {
@@ -128,16 +130,16 @@ class ProgressiveLightMap {
 		const dimensions = potpack( this.uv_boxes );
 		this.uv_boxes.forEach( ( box ) => {
 
-			const uv2 = objects[ box.index ].geometry.getAttribute( 'uv' ).clone();
-			for ( let i = 0; i < uv2.array.length; i += uv2.itemSize ) {
+			const uv1 = objects[ box.index ].geometry.getAttribute( 'uv' ).clone();
+			for ( let i = 0; i < uv1.array.length; i += uv1.itemSize ) {
 
-				uv2.array[ i ] = ( uv2.array[ i ] + box.x + padding ) / dimensions.w;
-				uv2.array[ i + 1 ] = ( uv2.array[ i + 1 ] + box.y + padding ) / dimensions.h;
+				uv1.array[ i ] = ( uv1.array[ i ] + box.x + padding ) / dimensions.w;
+				uv1.array[ i + 1 ] = ( uv1.array[ i + 1 ] + box.y + padding ) / dimensions.h;
 
 			}
 
-			objects[ box.index ].geometry.setAttribute( 'uv2', uv2 );
-			objects[ box.index ].geometry.getAttribute( 'uv2' ).needsUpdate = true;
+			objects[ box.index ].geometry.setAttribute( 'uv1', uv1 );
+			objects[ box.index ].geometry.getAttribute( 'uv1' ).needsUpdate = true;
 
 		} );
 

package/examples/jsm/misc/RollerCoaster.js

@@ -1,8 +1,10 @@
 import {
 	BufferAttribute,
 	BufferGeometry,
+	Color,
 	Quaternion,
 	Raycaster,
+	SRGBColorSpace,
 	Vector3
 } from 'three';
 
@@ -513,6 +515,8 @@ class TreesGeometry extends BufferGeometry {
 		const raycaster = new Raycaster();
 		raycaster.ray.direction.set( 0, - 1, 0 );
 
+		const _color = new Color();
+
 		for ( let i = 0; i < 2000; i ++ ) {
 
 			const x = Math.random() * 500 - 250;
@@ -544,7 +548,9 @@ class TreesGeometry extends BufferGeometry {
 
 			for ( let j = 0; j < 6; j ++ ) {
 
-				colors.push( 0.2 + random, 0.4 + random, 0 );
+				_color.setRGB( 0.2 + random, 0.4 + random, 0, SRGBColorSpace );
+
+				colors.push( _color.r, _color.g, _color.b );
 
 			}
 

package/examples/jsm/misc/Volume.js

@@ -194,10 +194,18 @@ class Volume {
 		this.sliceList = [];
 
 
+		/**
+		 * @member {boolean} segmentation in segmentation mode, it can load 16-bits nrrds correctly
+		 */
+		this.segmentation = false;
+
+
 		/**
 		 * @member {Array} RASDimensions This array holds the dimensions of the volume in the RAS space
 		 */
 
+
+
 	}
 
 	/**
@@ -332,13 +340,20 @@ class Volume {
 
 		}
 
-		firstDirection.applyMatrix4( volume.inverseMatrix ).normalize();
+
+		let iLength, jLength;
+
+		if( ! this.segmentation ) {
+
+			firstDirection.applyMatrix4( volume.inverseMatrix ).normalize();
+			secondDirection.applyMatrix4( volume.inverseMatrix ).normalize();
+			axisInIJK.applyMatrix4( volume.inverseMatrix ).normalize();
+
+		}
 		firstDirection.arglet = 'i';
-		secondDirection.applyMatrix4( volume.inverseMatrix ).normalize();
 		secondDirection.arglet = 'j';
-		axisInIJK.applyMatrix4( volume.inverseMatrix ).normalize();
-		const iLength = Math.floor( Math.abs( firstDirection.dot( dimensions ) ) );
-		const jLength = Math.floor( Math.abs( secondDirection.dot( dimensions ) ) );
+		iLength = Math.floor( Math.abs( firstDirection.dot( dimensions ) ) );
+		jLength = Math.floor( Math.abs( secondDirection.dot( dimensions ) ) );
 		const planeWidth = Math.abs( iLength * firstSpacing );
 		const planeHeight = Math.abs( jLength * secondSpacing );
 

package/examples/jsm/misc/VolumeSlice.js

@@ -5,7 +5,8 @@ import {
 	Mesh,
 	MeshBasicMaterial,
 	PlaneGeometry,
-	Texture
+	Texture,
+	SRGBColorSpace
 } from 'three';
 
 /**
@@ -68,6 +69,7 @@ class VolumeSlice {
 		const canvasMap = new Texture( this.canvas );
 		canvasMap.minFilter = LinearFilter;
 		canvasMap.wrapS = canvasMap.wrapT = ClampToEdgeWrapping;
+		canvasMap.colorSpace = SRGBColorSpace;
 		const material = new MeshBasicMaterial( { map: canvasMap, side: DoubleSide, transparent: true } );
 		/**
 		 * @member {Mesh} mesh The mesh ready to get used in the scene

package/examples/jsm/modifiers/CurveModifier.js

@@ -270,6 +270,7 @@ export class InstancedFlow extends Flow {
 			count
 		);
 		mesh.instanceMatrix.setUsage( DynamicDrawUsage );
+		mesh.frustumCulled = false;
 		super( mesh, curveCount );
 
 		this.offsets = new Array( count ).fill( 0 );