npm - @playdrop/playdrop-cli - Versions diffs - 0.3.5-build.1 → 0.3.8-build.2 - Mend

@playdrop/playdrop-cli 0.3.5-build.1 → 0.3.8-build.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1288) hide show

package/node_modules/three/examples/jsm/loaders/KTXLoader.js CHANGED Viewed

@@ -3,21 +3,42 @@ import {
 } from 'three';
 /**
- * for description see https://www.khronos.org/opengles/sdk/tools/KTX/
- * for file layout see https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/
+ * A loader for the KTX texture compression format.
  *
- * ported from https://github.com/BabylonJS/Babylon.js/blob/master/src/Misc/khronosTextureContainer.ts
+ * References:
+ * - [The KTX File Format and Tools](https://www.khronos.org/opengles/sdk/tools/KTX/)
+ * - [Babylon.JS khronosTextureContainer.ts](https://github.com/BabylonJS/Babylon.js/blob/master/src/Misc/khronosTextureContainer.ts)
+ *
+ * ```js
+ * const loader = new KTXLoader();
+ *
+ * const map = loader.load( 'textures/compressed/lensflare_ASTC8x8.ktx' )
+ * map.colorSpace = THREE.SRGBColorSpace; // only for color textures
+ * ```
+ *
+ * @augments CompressedTextureLoader
+ * @three_import import { KTXLoader } from 'three/addons/loaders/KTXLoader.js';
  */
 class KTXLoader extends CompressedTextureLoader {
+	/**
+	 * Constructs a new KTX loader.
+	 *
+	 * @param {LoadingManager} [manager] - The loading manager.
+	 */
 	constructor( manager ) {
 		super( manager );
 	}
+	/**
+	 * Parses the given KTX texture data.
+	 *
+	 * @param {ArrayBuffer} buffer - The raw texture data.
+	 * @param {boolean} loadMipmaps - Whether to load mipmaps or not.
+	 * @return {CompressedTextureLoader~TexData} An object representing the parsed texture data.
+	 */
 	parse( buffer, loadMipmaps ) {
 		const ktx = new KhronosTextureContainer( buffer, 1 );
@@ -35,7 +56,6 @@ class KTXLoader extends CompressedTextureLoader {
 }
 const HEADER_LEN = 12 + ( 13 * 4 ); // identifier + header elements (not including key value meta-data pairs)
 // load types
 const COMPRESSED_2D = 0; // uses a gl.compressedTexImage2D()
@@ -46,10 +66,11 @@ const COMPRESSED_2D = 0; // uses a gl.compressedTexImage2D()
 class KhronosTextureContainer {
 	/**
-	 * @param {ArrayBuffer} arrayBuffer- contents of the KTX container file
-	 * @param {number} facesExpected- should be either 1 or 6, based whether a cube texture or or
-	 * @param {boolean} threeDExpected- provision for indicating that data should be a 3D texture, not implemented
-	 * @param {boolean} textureArrayExpected- provision for indicating that data should be a texture array, not implemented
+	 * @private
+	 * @param {ArrayBuffer} arrayBuffer - contents of the KTX container file
+	 * @param {number} facesExpected - should be either 1 or 6, based whether a cube texture or or
+	 * @param {boolean} threeDExpected - provision for indicating that data should be a 3D texture, not implemented
+	 * @param {boolean} textureArrayExpected - provision for indicating that data should be a texture array, not implemented
 	 */
 	constructor( arrayBuffer, facesExpected /*, threeDExpected, textureArrayExpected */ ) {

package/node_modules/three/examples/jsm/loaders/LDrawLoader.js CHANGED Viewed

@@ -10,10 +10,7 @@ import {
 	Matrix4,
 	Mesh,
 	MeshStandardMaterial,
-	ShaderMaterial,
 	SRGBColorSpace,
-	UniformsLib,
-	UniformsUtils,
 	Vector3,
 	Ray
 } from 'three';
@@ -45,134 +42,6 @@ const COLOR_SPACE_LDRAW = SRGBColorSpace;
 const _tempVec0 = new Vector3();
 const _tempVec1 = new Vector3();
-class LDrawConditionalLineMaterial extends ShaderMaterial {
-	constructor( parameters ) {
-		super( {
-			uniforms: UniformsUtils.merge( [
-				UniformsLib.fog,
-				{
-					diffuse: {
-						value: new Color()
-					},
-					opacity: {
-						value: 1.0
-					}
-				}
-			] ),
-			vertexShader: /* glsl */`
-				attribute vec3 control0;
-				attribute vec3 control1;
-				attribute vec3 direction;
-				varying float discardFlag;
-				#include <common>
-				#include <color_pars_vertex>
-				#include <fog_pars_vertex>
-				#include <logdepthbuf_pars_vertex>
-				#include <clipping_planes_pars_vertex>
-				void main() {
-					#include <color_vertex>
-					vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
-					gl_Position = projectionMatrix * mvPosition;
-					// Transform the line segment ends and control points into camera clip space
-					vec4 c0 = projectionMatrix * modelViewMatrix * vec4( control0, 1.0 );
-					vec4 c1 = projectionMatrix * modelViewMatrix * vec4( control1, 1.0 );
-					vec4 p0 = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-					vec4 p1 = projectionMatrix * modelViewMatrix * vec4( position + direction, 1.0 );
-					c0.xy /= c0.w;
-					c1.xy /= c1.w;
-					p0.xy /= p0.w;
-					p1.xy /= p1.w;
-					// Get the direction of the segment and an orthogonal vector
-					vec2 dir = p1.xy - p0.xy;
-					vec2 norm = vec2( -dir.y, dir.x );
-					// Get control point directions from the line
-					vec2 c0dir = c0.xy - p1.xy;
-					vec2 c1dir = c1.xy - p1.xy;
-					// If the vectors to the controls points are pointed in different directions away
-					// from the line segment then the line should not be drawn.
-					float d0 = dot( normalize( norm ), normalize( c0dir ) );
-					float d1 = dot( normalize( norm ), normalize( c1dir ) );
-					discardFlag = float( sign( d0 ) != sign( d1 ) );
-					#include <logdepthbuf_vertex>
-					#include <clipping_planes_vertex>
-					#include <fog_vertex>
-				}
-			`,
-			fragmentShader: /* glsl */`
-			uniform vec3 diffuse;
-			uniform float opacity;
-			varying float discardFlag;
-			#include <common>
-			#include <color_pars_fragment>
-			#include <fog_pars_fragment>
-			#include <logdepthbuf_pars_fragment>
-			#include <clipping_planes_pars_fragment>
-			void main() {
-				if ( discardFlag > 0.5 ) discard;
-				#include <clipping_planes_fragment>
-				vec3 outgoingLight = vec3( 0.0 );
-				vec4 diffuseColor = vec4( diffuse, opacity );
-				#include <logdepthbuf_fragment>
-				#include <color_fragment>
-				outgoingLight = diffuseColor.rgb; // simple shader
-				gl_FragColor = vec4( outgoingLight, diffuseColor.a );
-				#include <tonemapping_fragment>
-				#include <colorspace_fragment>
-				#include <fog_fragment>
-				#include <premultiplied_alpha_fragment>
-			}
-			`,
-		} );
-		Object.defineProperties( this, {
-			opacity: {
-				get: function () {
-					return this.uniforms.opacity.value;
-				},
-				set: function ( value ) {
-					this.uniforms.opacity.value = value;
-				}
-			},
-			color: {
-				get: function () {
-					return this.uniforms.diffuse.value;
-				}
-			}
-		} );
-		this.setValues( parameters );
-		this.isLDrawConditionalLineMaterial = true;
-	}
-}
 class ConditionalLineSegments extends LineSegments {
@@ -1877,10 +1746,45 @@ function createObject( loader, elements, elementSize, isConditionalSegments = fa
 }
-//
+/**
+ * A loader for the LDraw format.
+ *
+ * [LDraw](https://ldraw.org/} (LEGO Draw) is an [open format specification]{@link https://ldraw.org/article/218.html)
+ * for describing LEGO and other construction set 3D models.
+ *
+ * An LDraw asset (a text file usually with extension .ldr, .dat or .txt) can describe just a single construction
+ * piece, or an entire model. In the case of a model the LDraw file can reference other LDraw files, which are
+ * loaded from a library path set with `setPartsLibraryPath`. You usually download the LDraw official parts library,
+ * extract to a folder and point setPartsLibraryPath to it.
+ *
+ * Library parts will be loaded by trial and error in subfolders 'parts', 'p' and 'models'. These file accesses
+ * are not optimal for web environment, so a script tool has been made to pack an LDraw file with all its dependencies
+ * into a single file, which loads much faster. See section 'Packing LDraw models'. The LDrawLoader example loads
+ * several packed files. The official parts library is not included due to its large size.
+ *
+ * `LDrawLoader` supports the following extensions:
+ * - !COLOUR: Color and surface finish declarations.
+ * - BFC: Back Face Culling specification.
+ * - !CATEGORY: Model/part category declarations.
+ * - !KEYWORDS: Model/part keywords declarations.
+ *
+ * ```js
+ * const loader = new LDrawLoader();
+ * loader.setConditionalLineMaterial( LDrawConditionalLineMaterial ); // the type of line material depends on the used renderer
+ * const object = await loader.loadAsync( 'models/ldraw/officialLibrary/models/car.ldr_Packed.mpd' );
+ * scene.add( object );
+ * ```
+ *
+ * @augments Loader
+ * @three_import import { LDrawLoader } from 'three/addons/loaders/LDrawLoader.js';
+ */
 class LDrawLoader extends Loader {
+	/**
+	 * Constructs a new LDraw loader.
+	 *
+	 * @param {LoadingManager} [manager] - The loading manager.
+	 */
 	constructor( manager ) {
 		super( manager );
@@ -1897,24 +1801,32 @@ class LDrawLoader extends Loader {
 		// This object is a map from file names to paths. It agilizes the paths search. If it is not set then files will be searched by trial and error.
 		this.fileMap = {};
-		// Initializes the materials library with default materials
-		this.setMaterials( [] );
 		// If this flag is set to true the vertex normals will be smoothed.
 		this.smoothNormals = true;
 		// The path to load parts from the LDraw parts library from.
 		this.partsLibraryPath = '';
+		// this material type must be injected via setConditionalLineMaterial()
+		this.ConditionalLineMaterial = null;
 		// Material assigned to not available colors for meshes and edges
 		this.missingColorMaterial = new MeshStandardMaterial( { name: Loader.DEFAULT_MATERIAL_NAME, color: 0xFF00FF, roughness: 0.3, metalness: 0 } );
 		this.missingEdgeColorMaterial = new LineBasicMaterial( { name: Loader.DEFAULT_MATERIAL_NAME, color: 0xFF00FF } );
-		this.missingConditionalEdgeColorMaterial = new LDrawConditionalLineMaterial( { name: Loader.DEFAULT_MATERIAL_NAME, fog: true, color: 0xFF00FF } );
+		this.missingConditionalEdgeColorMaterial = null;
 		this.edgeMaterialCache.set( this.missingColorMaterial, this.missingEdgeColorMaterial );
 		this.conditionalEdgeMaterialCache.set( this.missingEdgeColorMaterial, this.missingConditionalEdgeColorMaterial );
 	}
+	/**
+	 * This method must be called prior to `load()` unless the model to load does not reference
+	 * library parts (usually it will be a model with all its parts packed in a single file).
+	 *
+	 * @param {string} path - Path to library parts files to load referenced parts from.
+	 * This is different from Loader.setPath, which indicates the path to load the main asset from.
+	 * @return {LDrawLoader} A reference to this loader.
+	 */
 	setPartsLibraryPath( path ) {
 		this.partsLibraryPath = path;
@@ -1922,6 +1834,33 @@ class LDrawLoader extends Loader {
 	}
+	/**
+	 * Sets the conditional line material type which depends on the used renderer.
+	 * Use {@link LDrawConditionalLineMaterial} when using `WebGLRenderer` and
+	 * {@link LDrawConditionalLineNodeMaterial} when using `WebGPURenderer`.
+	 *
+	 * @param {(LDrawConditionalLineMaterial.constructor|LDrawConditionalLineNodeMaterial.constructor)} type - The conditional line material type.
+	 * @return {LDrawLoader} A reference to this loader.
+	 */
+	setConditionalLineMaterial( type ) {
+		this.ConditionalLineMaterial = type;
+		this.missingConditionalEdgeColorMaterial = new this.ConditionalLineMaterial( { name: Loader.DEFAULT_MATERIAL_NAME, fog: true, color: 0xFF00FF } );
+		return this;
+	}
+	/**
+	 * This async method preloads materials from a single LDraw file. In the official
+	 * parts library there is a special file which is loaded always the first (LDConfig.ldr)
+	 * and contains all the standard color codes. This method is intended to be used with
+	 * not packed files, for example in an editor where materials are preloaded and parts
+	 * are loaded on demand.
+	 *
+	 * @async
+	 * @param {string} url - Path of the LDraw materials asset.
+	 * @return {Promise} A Promise that resolves when the preload has finished.
+	 */
 	async preloadMaterials( url ) {
 		const fileLoader = new FileLoader( this.manager );
@@ -1946,10 +1885,19 @@ class LDrawLoader extends Loader {
 		}
-		this.setMaterials( materials );
+		this.addMaterials( materials );
 	}
+	/**
+	 * Starts loading from the given URL and passes the loaded LDraw asset
+	 * to the `onLoad()` callback.
+	 *
+	 * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
+	 * @param {function(Group)} onLoad - Executed when the loading process has been finished.
+	 * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
+	 * @param {onErrorCallback} onError - Executed when errors occur.
+	 */
 	load( url, onLoad, onProgress, onError ) {
 		const fileLoader = new FileLoader( this.manager );
@@ -1958,8 +1906,11 @@ class LDrawLoader extends Loader {
 		fileLoader.setWithCredentials( this.withCredentials );
 		fileLoader.load( url, text => {
+			// Initializes the materials library with default materials
+			this.addDefaultMaterials();
 			this.partsCache
-				.parseModel( text, this.materialLibrary )
+				.parseModel( text )
 				.then( group => {
 					this.applyMaterialsToMesh( group, MAIN_COLOUR_CODE, this.materialLibrary, true );
@@ -1974,10 +1925,17 @@ class LDrawLoader extends Loader {
 	}
-	parse( text, onLoad ) {
+	/**
+	 * Parses the given LDraw data and returns the resulting group.
+	 *
+	 * @param {string} text - The raw VRML data as a string.
+	 * @param {function(Group)} onLoad - Executed when the loading/parsing process has been finished.
+	 * @param {onErrorCallback} onError - Executed when errors occur.
+	 */
+	parse( text, onLoad, onError ) {
 		this.partsCache
-			.parseModel( text, this.materialLibrary )
+			.parseModel( text )
 			.then( group => {
 				this.applyMaterialsToMesh( group, MAIN_COLOUR_CODE, this.materialLibrary, true );
@@ -1985,20 +1943,66 @@ class LDrawLoader extends Loader {
 				group.userData.fileName = '';
 				onLoad( group );
-			} );
+			} )
+			.catch( onError );
 	}
+	/**
+	 * Sets the loader's material library. This method clears existing
+	 * material definitions.
+	 *
+	 * @param {Array<Material>} materials - The materials to set.
+	 * @return {LDrawLoader} A reference to this loader.
+	 */
 	setMaterials( materials ) {
+		this.clearMaterials();
+		this.addMaterials( materials );
+		return this;
+	}
+	/**
+	 * Clears the loader's material library.
+	 *
+	 * @return {LDrawLoader} A reference to this loader.
+	 */
+	clearMaterials() {
 		this.materialLibrary = {};
 		this.materials = [];
+		return this;
+	}
+	/**
+	 * Adds a list of materials to the loader's material library.
+	 *
+	 * @param {Array<Material>} materials - The materials to add.
+	 * @return {LDrawLoader} A reference to this loader.
+	 */
+	addMaterials( materials ) {
 		for ( let i = 0, l = materials.length; i < l; i ++ ) {
 			this.addMaterial( materials[ i ] );
 		}
+		return this;
+	}
+	/**
+	 * Initializes the loader with default materials.
+	 *
+	 * @return {LDrawLoader} A reference to this loader.
+	 */
+	addDefaultMaterials() {
 		// Add default main triangle and line edge materials (used in pieces that can be colored with a main color)
 		this.addMaterial( this.parseColorMetaDirective( new LineParser( 'Main_Colour CODE 16 VALUE #FF8080 EDGE #333333' ) ) );
 		this.addMaterial( this.parseColorMetaDirective( new LineParser( 'Edge_Colour CODE 24 VALUE #A0A0A0 EDGE #333333' ) ) );
@@ -2007,6 +2011,14 @@ class LDrawLoader extends Loader {
 	}
+	/**
+	 * Sets a map which maps referenced library filenames to new filenames.
+	 * If a fileMap is not specified (the default), library parts will be accessed by trial and
+	 * error in subfolders 'parts', 'p' and 'models'.
+	 *
+	 * @param {Object<string,string>} fileMap - The file map to set.
+	 * @return {LDrawLoader} A reference to this loader.
+	 */
 	setFileMap( fileMap ) {
 		this.fileMap = fileMap;
@@ -2015,6 +2027,12 @@ class LDrawLoader extends Loader {
 	}
+	/**
+	 * Adds a single material to the loader's material library.
+	 *
+	 * @param {Material} material - The material to add.
+	 * @return {LDrawLoader} A reference to this loader.
+	 */
 	addMaterial( material ) {
 		// Adds a material to the material library which is on top of the parse scopes stack. And also to the materials array
@@ -2031,6 +2049,12 @@ class LDrawLoader extends Loader {
 	}
+	/**
+	 * Returns a material for the given color code.
+	 *
+	 * @param {string} colorCode - The color code.
+	 * @return {?Material} The material. Returns `null` if no material has been found.
+	 */
 	getMaterial( colorCode ) {
 		if ( colorCode.startsWith( '0x2' ) ) {
@@ -2108,7 +2132,7 @@ class LDrawLoader extends Loader {
 			} else if ( finalMaterialPass ) {
-				// see if we can get the final material from from the "getMaterial" function which will attempt to
+				// see if we can get the final material from the "getMaterial" function which will attempt to
 				// parse the "direct" colors
 				material = loader.getMaterial( colorCode );
 				if ( material === null ) {
@@ -2146,12 +2170,31 @@ class LDrawLoader extends Loader {
 	}
+	/**
+	 * Returns the Material for the main LDraw color.
+	 *
+	 * For an already loaded LDraw asset, returns the Material associated with the main color code.
+	 * This method can be useful to modify the main material of a model or part that exposes it.
+	 *
+	 * The main color code is the standard way to color an LDraw part. It is '16' for triangles and
+	 * '24' for edges. Usually a complete model will not expose the main color (that is, no part
+	 * uses the code '16' at the top level, because they are assigned other specific colors) An LDraw
+	 *  part file on the other hand will expose the code '16' to be colored, and can have additional
+	 * fixed colors.
+	 *
+	 * @return {?Material} The material. Returns `null` if no material has been found.
+	 */
 	getMainMaterial() {
 		return this.getMaterial( MAIN_COLOUR_CODE );
 	}
+	/**
+	 * Returns the material for the edges main LDraw color.
+	 *
+	 * @return {?Material} The material. Returns `null` if no material has been found.
+	 */
 	getMainEdgeMaterial() {
 		const mat = this.getMaterial( MAIN_EDGE_COLOUR_CODE );
@@ -2270,7 +2313,7 @@ class LDrawLoader extends Loader {
 						if ( ! parseLuminance( lineParser.getToken() ) ) {
-							throw new Error( 'LDrawLoader: Invalid luminance value in material definition' + LineParser.getLineNumberString() + '.' );
+							throw new Error( 'LDrawLoader: Invalid luminance value in material definition' + lineParser.getLineNumberString() + '.' );
 						}
@@ -2383,8 +2426,14 @@ class LDrawLoader extends Loader {
 			edgeMaterial.userData.code = code;
 			edgeMaterial.name = name + ' - Edge';
+			if ( this.ConditionalLineMaterial === null ) {
+				throw new Error( 'THREE.LDrawLoader: ConditionalLineMaterial type must be specified via .setConditionalLineMaterial().' );
+			}
 			// This is the material used for conditional edges
-			const conditionalEdgeMaterial = new LDrawConditionalLineMaterial( {
+			const conditionalEdgeMaterial = new this.ConditionalLineMaterial( {
 				fog: true,
 				transparent: isTransparent,

package/node_modules/three/examples/jsm/loaders/LUT3dlLoader.js CHANGED Viewed

@@ -1,42 +1,72 @@
-// http://download.autodesk.com/us/systemdocs/help/2011/lustre/index.html?url=./files/WSc4e151a45a3b785a24c3d9a411df9298473-7ffd.htm,topicNumber=d0e9492
-// https://community.foundry.com/discuss/topic/103636/format-spec-for-3dl?mode=Post&postID=895258
 import {
 	ClampToEdgeWrapping,
-	DataTexture,
 	Data3DTexture,
 	FileLoader,
-	FloatType,
 	LinearFilter,
 	Loader,
 	RGBAFormat,
 	UnsignedByteType,
 } from 'three';
+/**
+ * A loader for the 3DL LUT format.
+ *
+ * References:
+ * - [3D LUTs](http://download.autodesk.com/us/systemdocs/help/2011/lustre/index.html?url=./files/WSc4e151a45a3b785a24c3d9a411df9298473-7ffd.htm,topicNumber=d0e9492)
+ * - [Format Spec for .3dl](https://community.foundry.com/discuss/topic/103636/format-spec-for-3dl?mode=Post&postID=895258)
+ *
+ * ```js
+ * const loader = new LUT3dlLoader();
+ * const map = loader.loadAsync( 'luts/Presetpro-Cinematic.3dl' );
+ * ```
+ *
+ * @augments Loader
+ * @three_import import { LUT3dlLoader } from 'three/addons/loaders/LUT3dlLoader.js';
+ */
 export class LUT3dlLoader extends Loader {
+	/**
+	 * Constructs a new 3DL LUT loader.
+	 *
+	 * @param {LoadingManager} [manager] - The loading manager.
+	 */
 	constructor( manager ) {
 		super( manager );
+		/**
+		 * The texture type.
+		 *
+		 * @type {(UnsignedByteType|FloatType)}
+		 * @default UnsignedByteType
+		 */
 		this.type = UnsignedByteType;
 	}
+	/**
+	 * Sets the texture type.
+	 *
+	 * @param {(UnsignedByteType|FloatType)} type - The texture type to set.
+	 * @return {LUT3dlLoader} A reference to this loader.
+	 */
 	setType( type ) {
-		if ( type !== UnsignedByteType && type !== FloatType ) {
-			throw new Error( 'LUT3dlLoader: Unsupported type' );
-		}
 		this.type = type;
 		return this;
 	}
+	/**
+	 * Starts loading from the given URL and passes the loaded 3DL LUT asset
+	 * to the `onLoad()` callback.
+	 *
+	 * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
+	 * @param {function({size:number,texture3D:Data3DTexture})} onLoad - Executed when the loading process has been finished.
+	 * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
+	 * @param {onErrorCallback} onError - Executed when errors occur.
+	 */
 	load( url, onLoad, onProgress, onError ) {
 		const loader = new FileLoader( this.manager );
@@ -68,6 +98,12 @@ export class LUT3dlLoader extends Loader {
 	}
+	/**
+	 * Parses the given 3DL LUT data and returns the resulting 3D data texture.
+	 *
+	 * @param {string} input - The raw 3DL LUT data as a string.
+	 * @return {{size:number,texture3D:Data3DTexture}} The parsed 3DL LUT.
+	 */
 	parse( input ) {
 		const regExpGridInfo = /^[\d ]+$/m;
@@ -144,19 +180,6 @@ export class LUT3dlLoader extends Loader {
 		}
-		const texture = new DataTexture();
-		texture.image.data = data;
-		texture.image.width = size;
-		texture.image.height = size * size;
-		texture.format = RGBAFormat;
-		texture.type = this.type;
-		texture.magFilter = LinearFilter;
-		texture.minFilter = LinearFilter;
-		texture.wrapS = ClampToEdgeWrapping;
-		texture.wrapT = ClampToEdgeWrapping;
-		texture.generateMipmaps = false;
-		texture.needsUpdate = true;
 		const texture3D = new Data3DTexture();
 		texture3D.image.data = data;
 		texture3D.image.width = size;
@@ -174,7 +197,6 @@ export class LUT3dlLoader extends Loader {
 		return {
 			size,
-			texture,
 			texture3D,
 		};