super-three 0.184.0 → 0.185.0

package/examples/jsm/libs/mikktspace.module.js

@@ -117,12 +117,37 @@ export let wasm;
 
 export let isReady = false;
 
-export const ready = fetch(wasmDataURI)
-    .then((res) => res.arrayBuffer())
-    .then((buffer) => WebAssembly.instantiate(buffer, {
-        './mikktspace_module_bg.js': {__wbindgen_string_new, __wbindgen_rethrow}
-    }))
-    .then((result) => {
-        wasm = result.instance.exports;
-        isReady = true;
-    });
+let readyPromise = null;
+
+function initialize() {
+
+	return fetch( wasmDataURI )
+		.then( ( res ) => res.arrayBuffer() )
+		.then( ( buffer ) => WebAssembly.instantiate( buffer, {
+			'./mikktspace_module_bg.js': { __wbindgen_string_new, __wbindgen_rethrow }
+		} ) )
+		.then( ( result ) => {
+
+			wasm = result.instance.exports;
+			isReady = true;
+
+		} );
+
+}
+
+export const ready = {
+	then: function ( onFulfilled, onRejected ) {
+
+		if ( readyPromise === null ) readyPromise = initialize();
+		return readyPromise.then( onFulfilled, onRejected );
+
+	}
+};
+
+export function dispose() {
+
+	wasm = null;
+	isReady = false;
+	readyPromise = null;
+
+}

package/examples/jsm/lighting/ClusteredLighting.js

@@ -0,0 +1,55 @@
+import { Lighting } from 'three/webgpu';
+import ClusteredLightsNode from '../tsl/lighting/ClusteredLightsNode.js';
+
+/**
+ * A custom lighting implementation based on Forward+ Clustered Shading that
+ * overwrites the default lighting system in {@link WebGPURenderer}. Suitable
+ * for 3D scenes with many point lights and real depth complexity — the view
+ * frustum is partitioned into a 3D cluster grid so only the lights actually
+ * reaching each fragment are evaluated.
+ *
+ * ```js
+ * const lighting = new ClusteredLighting();
+ * renderer.lighting = lighting; // set lighting system
+ * ```
+ *
+ * @augments Lighting
+ * @three_import import { ClusteredLighting } from 'three/addons/lighting/ClusteredLighting.js';
+ */
+export class ClusteredLighting extends Lighting {
+
+	/**
+	 * Constructs a new clustered lighting system.
+	 *
+	 * @param {number} [maxLights=1024] - Maximum number of point lights.
+	 * @param {number} [tileSize=32] - Screen tile size in pixels (cluster XY size).
+	 * @param {number} [zSlices=24] - Number of exponential depth slices.
+	 * @param {number} [maxLightsPerCluster=64] - Per-cluster light-list capacity.
+	 */
+	constructor( maxLights = 1024, tileSize = 32, zSlices = 24, maxLightsPerCluster = 64 ) {
+
+		super();
+
+		this.maxLights = maxLights;
+		this.tileSize = tileSize;
+		this.zSlices = zSlices;
+		this.maxLightsPerCluster = maxLightsPerCluster;
+
+	}
+
+	/**
+	 * Creates a new clustered lights node for the given array of lights.
+	 *
+	 * This method is called internally by the renderer and must be overwritten by
+	 * all custom lighting implementations.
+	 *
+	 * @param {Array<Light>} lights - The lights.
+	 * @return {ClusteredLightsNode} The clustered lights node.
+	 */
+	createNode( lights = [] ) {
+
+		return new ClusteredLightsNode( this.maxLights, this.tileSize, this.zSlices, this.maxLightsPerCluster ).setLights( lights );
+
+	}
+
+}

package/examples/jsm/lighting/LightProbeGrid.js

@@ -45,8 +45,8 @@ let _batchTargetProbes = 0;
 // Reusable temp objects
 const _position = /*@__PURE__*/ new Vector3();
 const _size = /*@__PURE__*/ new Vector3();
-const _savedViewport = /*@__PURE__*/ new Vector4();
-const _savedScissor = /*@__PURE__*/ new Vector4();
+const _currentViewport = /*@__PURE__*/ new Vector4();
+const _currentScissor = /*@__PURE__*/ new Vector4();
 
 // Number of padding texels added at each boundary of every sub-volume in the atlas.
 const ATLAS_PADDING = 1;
@@ -55,6 +55,9 @@ const ATLAS_PADDING = 1;
  * A 3D grid of L2 Spherical Harmonic irradiance probes that provides
  * position-dependent diffuse global illumination.
  *
+ * Note that this class can only be used with {@link WebGLRenderer}.
+ * A version for {@link WebGPURenderer} will be added at a later point.
+ *
  * All seven packed SH sub-volumes are stored in a **single** RGBA
  * `WebGL3DRenderTarget` using a texture-atlas layout along the Z axis.
  * Each sub-volume occupies `( nz + 2 )` atlas slices: one padding slice at
@@ -202,7 +205,10 @@ class LightProbeGrid extends Object3D {
 
 	/**
 	 * Bakes all probes by rendering cubemaps at each probe position
-	 * and projecting to L2 SH. Fully GPU-resident with zero CPU readback.
+	 * and projecting to L2 SH. Optionally iterates additional passes to
+	 * capture indirect bounces — each extra pass samples the previous pass's
+	 * atlas as indirect light, so a grid added to the scene before baking
+	 * accumulates one bounce per extra pass.
 	 *
 	 * @param {WebGLRenderer} renderer - The renderer.
 	 * @param {Scene} scene - The scene to render.
@@ -210,17 +216,16 @@ class LightProbeGrid extends Object3D {
 	 * @param {number} [options.cubemapSize=8] - Resolution of each cubemap face.
 	 * @param {number} [options.near=0.1] - Near plane for the cube camera.
 	 * @param {number} [options.far=100] - Far plane for the cube camera.
+	 * @param {number} [options.bounces=0] - Additional bounce passes after the initial direct pass.
 	 */
 	bake( renderer, scene, options = {} ) {
 
+		const { bounces = 0 } = options;
 		const { cubeRenderTarget, cubeCamera } = _ensureBakeResources( options );
 
 		this._ensureTextures();
 		this.updateBoundingBox();
 
-		// Prevent feedback: temporarily hide the volume during baking
-		this.visible = false;
-
 		const res = this.resolution;
 		const totalProbes = res.x * res.y * res.z;
 
@@ -228,109 +233,134 @@ class LightProbeGrid extends Object3D {
 		const batchTarget = _ensureBatchTarget( totalProbes );
 
 		// Save renderer state
-		const savedRenderTarget = renderer.getRenderTarget();
-		renderer.getViewport( _savedViewport );
-		renderer.getScissor( _savedScissor );
-		const savedScissorTest = renderer.getScissorTest();
+		const currentRenderTarget = renderer.getRenderTarget();
+		renderer.getViewport( _currentViewport );
+		renderer.getScissor( _currentScissor );
+		const currentScissorTest = renderer.getScissorTest();
 
-		// Clear pooled batch target so skipped probes read as zero
-		batchTarget.scissorTest = false;
-		batchTarget.viewport.set( 0, 0, 9, totalProbes );
-		renderer.setRenderTarget( batchTarget );
-		renderer.clear();
+		// Scene is static across the bake — update once and disable per-render auto updates.
+		const currentMatrixWorldAutoUpdate = scene.matrixWorldAutoUpdate;
+		if ( currentMatrixWorldAutoUpdate === true ) {
 
-		// const t0 = performance.now();
+			scene.updateMatrixWorld( true );
+			scene.matrixWorldAutoUpdate = false;
 
-		// Phase 1: Render cubemaps and project to SH into batch target
-		// Note: set viewport/scissor on the render target directly to avoid pixel ratio scaling
-		batchTarget.scissorTest = true;
+		}
 
-		// Disable shadow map auto-update during bake — lights don't move between probes.
-		// Force one shadow update on the first render so maps are initialized.
-		const savedShadowAutoUpdate = renderer.shadowMap.autoUpdate;
+		// Disable shadow map auto-update across all passes — lights don't move.
+		// Force a single shadow update on the first render so maps are initialized.
+		const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
 		renderer.shadowMap.autoUpdate = false;
 		renderer.shadowMap.needsUpdate = true;
 
-		for ( let iz = 0; iz < res.z; iz ++ ) {
+		_ensureRepackResources();
 
-			for ( let iy = 0; iy < res.y; iy ++ ) {
+		const paddedSlices = res.z + 2 * ATLAS_PADDING;
+		const rt = this._renderTarget;
 
-				for ( let ix = 0; ix < res.x; ix ++ ) {
+		// const t0 = performance.now();
 
-					const probeIndex = ix + iy * res.x + iz * res.x * res.y;
+		// Pass 0 captures direct light only (grid hidden, so probesSH is not sampled
+		// — the atlas at this point may be uninitialized or hold a prior bake).
+		// Each subsequent pass keeps the grid visible so the cube cameras read the
+		// previous pass's atlas as indirect light, accumulating one bounce per pass.
+		// Phase 1 writes to the batch target and Phase 2 only swaps it into the atlas
+		// at the very end of each pass, which gives an implicit ping-pong for free.
 
-					this.getProbePosition( ix, iy, iz, _position );
-					cubeCamera.position.copy( _position );
-					cubeCamera.update( renderer, scene );
+		for ( let pass = 0; pass <= bounces; pass ++ ) {
 
-					// SH projection
-					_shMaterial.uniforms.envMap.value = cubeRenderTarget.texture;
-					_mesh.material = _shMaterial;
-					batchTarget.viewport.set( 0, probeIndex, 9, 1 );
-					batchTarget.scissor.set( 0, probeIndex, 9, 1 );
-					renderer.setRenderTarget( batchTarget );
-					renderer.render( _scene, _camera );
+			this.visible = pass > 0;
+
+			// Clear pooled batch target so skipped probes read as zero
+			batchTarget.scissorTest = false;
+			batchTarget.viewport.set( 0, 0, 9, totalProbes );
+			renderer.setRenderTarget( batchTarget );
+			renderer.clear();
+
+			// Phase 1: Render cubemaps and project to SH into batch target
+			// Note: set viewport/scissor on the render target directly to avoid pixel ratio scaling
+			batchTarget.scissorTest = true;
+
+			for ( let iz = 0; iz < res.z; iz ++ ) {
+
+				for ( let iy = 0; iy < res.y; iy ++ ) {
+
+					for ( let ix = 0; ix < res.x; ix ++ ) {
+
+						const probeIndex = ix + iy * res.x + iz * res.x * res.y;
+
+						this.getProbePosition( ix, iy, iz, _position );
+						cubeCamera.position.copy( _position );
+						cubeCamera.update( renderer, scene );
+
+						// SH projection
+						_shMaterial.uniforms.envMap.value = cubeRenderTarget.texture;
+						_mesh.material = _shMaterial;
+						batchTarget.viewport.set( 0, probeIndex, 9, 1 );
+						batchTarget.scissor.set( 0, probeIndex, 9, 1 );
+						renderer.setRenderTarget( batchTarget );
+						renderer.render( _scene, _camera );
+
+					}
 
 				}
 
 			}
 
-		}
+			// Phase 2: Repack SH data from batch target into the atlas 3D texture (GPU-to-GPU).
+			//
+			// For each of the 7 packed sub-volumes (texture index t) we write:
+			//   - A leading padding slice  (copy of data slice iz = 0)
+			//   - All nz data slices       (iz = 0 … nz-1)
+			//   - A trailing padding slice (copy of data slice iz = nz-1)
+			//
+			// In the atlas the slices for sub-volume t occupy the range:
+			//   [ t * paddedSlices, t * paddedSlices + paddedSlices - 1 ]
+			// where paddedSlices = nz + 2 * ATLAS_PADDING.
 
-		renderer.shadowMap.autoUpdate = savedShadowAutoUpdate;
+			rt.scissorTest = false;
+			rt.viewport.set( 0, 0, res.x, res.y );
 
-		// Phase 2: Repack SH data from batch target into the atlas 3D texture (GPU-to-GPU).
-		//
-		// For each of the 7 packed sub-volumes (texture index t) we write:
-		//   - A leading padding slice  (copy of data slice iz = 0)
-		//   - All nz data slices       (iz = 0 … nz-1)
-		//   - A trailing padding slice (copy of data slice iz = nz-1)
-		//
-		// In the atlas the slices for sub-volume t occupy the range:
-		//   [ t * paddedSlices, t * paddedSlices + paddedSlices - 1 ]
-		// where paddedSlices = nz + 2 * ATLAS_PADDING.
+			for ( let t = 0; t < 7; t ++ ) {
 
-		_ensureRepackResources();
+				_repackMaterials[ t ].uniforms.batchTexture.value = batchTarget.texture;
+				_repackMaterials[ t ].uniforms.resolution.value.copy( res );
 
-		const paddedSlices = res.z + 2 * ATLAS_PADDING;
-		const rt = this._renderTarget;
-		rt.scissorTest = false;
-		rt.viewport.set( 0, 0, res.x, res.y );
+				// Write data slices
+				for ( let iz = 0; iz < res.z; iz ++ ) {
 
-		for ( let t = 0; t < 7; t ++ ) {
+					_repackMaterials[ t ].uniforms.sliceZ.value = iz;
+					_mesh.material = _repackMaterials[ t ];
+					renderer.setRenderTarget( rt, t * paddedSlices + ATLAS_PADDING + iz );
+					renderer.render( _scene, _camera );
 
-			_repackMaterials[ t ].uniforms.batchTexture.value = batchTarget.texture;
-			_repackMaterials[ t ].uniforms.resolution.value.copy( res );
+				}
 
-			// Write data slices
-			for ( let iz = 0; iz < res.z; iz ++ ) {
+				// Leading padding: copy of data slice iz = 0
+				_repackMaterials[ t ].uniforms.sliceZ.value = 0;
+				_mesh.material = _repackMaterials[ t ];
+				renderer.setRenderTarget( rt, t * paddedSlices );
+				renderer.render( _scene, _camera );
 
-				_repackMaterials[ t ].uniforms.sliceZ.value = iz;
+				// Trailing padding: copy of data slice iz = nz - 1
+				_repackMaterials[ t ].uniforms.sliceZ.value = res.z - 1;
 				_mesh.material = _repackMaterials[ t ];
-				renderer.setRenderTarget( rt, t * paddedSlices + ATLAS_PADDING + iz );
+				renderer.setRenderTarget( rt, t * paddedSlices + ATLAS_PADDING + res.z );
 				renderer.render( _scene, _camera );
 
 			}
 
-			// Leading padding: copy of data slice iz = 0
-			_repackMaterials[ t ].uniforms.sliceZ.value = 0;
-			_mesh.material = _repackMaterials[ t ];
-			renderer.setRenderTarget( rt, t * paddedSlices );
-			renderer.render( _scene, _camera );
-
-			// Trailing padding: copy of data slice iz = nz - 1
-			_repackMaterials[ t ].uniforms.sliceZ.value = res.z - 1;
-			_mesh.material = _repackMaterials[ t ];
-			renderer.setRenderTarget( rt, t * paddedSlices + ATLAS_PADDING + res.z );
-			renderer.render( _scene, _camera );
-
 		}
 
+		renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
+
 		// Restore renderer state
-		renderer.setRenderTarget( savedRenderTarget );
-		renderer.setViewport( _savedViewport );
-		renderer.setScissor( _savedScissor );
-		renderer.setScissorTest( savedScissorTest );
+		renderer.setRenderTarget( currentRenderTarget );
+		renderer.setViewport( _currentViewport );
+		renderer.setScissor( _currentScissor );
+		renderer.setScissorTest( currentScissorTest );
+
+		scene.matrixWorldAutoUpdate = currentMatrixWorldAutoUpdate;
 
 		// console.log( `LightProbeGrid: bake complete ${ ( performance.now() - t0 ).toFixed( 1 ) }ms` );
 

package/examples/jsm/lines/LineMaterial.js

@@ -10,7 +10,7 @@ UniformsLib.line = {
 
 	worldUnits: { value: 1 },
 	linewidth: { value: 1 },
-	resolution: { value: new Vector2( 1, 1 ) },
+	resolution: { value: new Vector2() },
 	dashOffset: { value: 0 },
 	dashScale: { value: 1 },
 	dashSize: { value: 1 },
@@ -70,18 +70,20 @@ ShaderLib[ 'line' ] = {
 
 		#endif
 
-		void trimSegment( const in vec4 start, inout vec4 end ) {
+		float trimSegmentAlpha( const in vec4 start, const in vec4 end ) {
 
-			// trim end segment so it terminates between the camera plane and the near plane
+			// compute the interpolation factor needed to trim the segment so it terminates
+			// between the camera plane and the near plane
 
 			// conservative estimate of the near plane
 			float a = projectionMatrix[ 2 ][ 2 ]; // 3nd entry in 3th column
 			float b = projectionMatrix[ 3 ][ 2 ]; // 3nd entry in 4th column
-			float nearEstimate = - 0.5 * b / a;
 
-			float alpha = ( nearEstimate - start.z ) / ( end.z - start.z );
+			// we need different nearEstimate formula for reversed and default depth buffer
+			// a is positive with a reversed depth buffer so it can be used for controlling the code flow
+			float nearEstimate = ( a > 0.0 ) ? ( - b / ( a + 1.0 ) ) : ( - 0.5 * b / a );
 
-			end.xyz = mix( start.xyz, end.xyz, alpha );
+			return ( nearEstimate - start.z ) / ( end.z - start.z );
 
 		}
 
@@ -93,19 +95,19 @@ ShaderLib[ 'line' ] = {
 
 			#endif
 
-			#ifdef USE_DASH
-
-				vLineDistance = ( position.y < 0.5 ) ? dashScale * instanceDistanceStart : dashScale * instanceDistanceEnd;
-				vUv = uv;
-
-			#endif
-
 			float aspect = resolution.x / resolution.y;
 
 			// camera space
 			vec4 start = modelViewMatrix * vec4( instanceStart, 1.0 );
 			vec4 end = modelViewMatrix * vec4( instanceEnd, 1.0 );
 
+			#ifdef USE_DASH
+
+				float lineDistanceStart = dashScale * instanceDistanceStart;
+				float lineDistanceEnd = dashScale * instanceDistanceEnd;
+
+			#endif
+
 			#ifdef WORLD_UNITS
 
 				worldStart = start.xyz;
@@ -128,16 +130,37 @@ ShaderLib[ 'line' ] = {
 
 				if ( start.z < 0.0 && end.z >= 0.0 ) {
 
-					trimSegment( start, end );
+					float alpha = trimSegmentAlpha( start, end );
+					end.xyz = mix( start.xyz, end.xyz, alpha );
+
+					#ifdef USE_DASH
+
+						lineDistanceEnd = mix( lineDistanceStart, lineDistanceEnd, alpha );
+
+					#endif
 
 				} else if ( end.z < 0.0 && start.z >= 0.0 ) {
 
-					trimSegment( end, start );
+					float alpha = trimSegmentAlpha( end, start );
+					start.xyz = mix( end.xyz, start.xyz, alpha );
+
+					#ifdef USE_DASH
+
+						lineDistanceStart = mix( lineDistanceEnd, lineDistanceStart, alpha );
+
+					#endif
 
 				}
 
 			}
 
+			#ifdef USE_DASH
+
+				vLineDistance = ( position.y < 0.5 ) ? lineDistanceStart : lineDistanceEnd;
+				vUv = uv;
+
+			#endif
+
 			// clip space
 			vec4 clipStart = projectionMatrix * start;
 			vec4 clipEnd = projectionMatrix * end;

package/examples/jsm/lines/LineSegments2.js

@@ -326,6 +326,14 @@ class LineSegments2 extends Mesh {
 
 		}
 
+		// early out if no resolution has been set (line was not rendered yet)
+
+		if ( worldUnits === false && ( this.material.resolution.x === 0 || this.material.resolution.y === 0 ) ) {
+
+			return;
+
+		}
+
 		const threshold = ( raycaster.params.Line2 !== undefined ) ? raycaster.params.Line2.threshold || 0 : 0;
 
 		_ray = raycaster.ray;

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

@@ -324,6 +324,14 @@ class LineSegments2 extends Mesh {
 
 		}
 
+		// early out if no resolution has been set (line was not rendered yet)
+
+		if ( worldUnits === false && ( this._resolution.x === 0 || this._resolution.y === 0 ) ) {
+
+			return;
+
+		}
+
 		const threshold = ( raycaster.params.Line2 !== undefined ) ? raycaster.params.Line2.threshold || 0 : 0;
 
 		_ray = raycaster.ray;

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

@@ -42,7 +42,7 @@ const _taskCache = new WeakMap();
  *
  * ```js
  * const loader = new Rhino3dmLoader();
- * loader.setLibraryPath( 'https://cdn.jsdelivr.net/npm/rhino3dm@8.0.1' );
+ * loader.setLibraryPath( 'https://cdn.jsdelivr.net/npm/rhino3dm@8.17.0/' );
  *
  * const object = await loader.loadAsync( 'models/3dm/Rhino_Logo.3dm' );
  * scene.add( object );

package/examples/jsm/loaders/DRACOLoader.js

@@ -8,11 +8,21 @@ import {
 	LinearSRGBColorSpace,
 	SRGBColorSpace,
 	InterleavedBuffer,
-	InterleavedBufferAttribute
+	InterleavedBufferAttribute,
+	LoaderUtils
 } from 'three';
 
 const _taskCache = new WeakMap();
 
+const WASM_BIN_URL = new URL( '../libs/draco/draco_decoder.wasm', import.meta.url ).toString();
+const WASM_JS_URL = new URL( '../libs/draco/draco_wasm_wrapper.js', import.meta.url ).toString();
+const JS_URL = new URL( '../libs/draco/draco_decoder.js', import.meta.url ).toString();
+
+const DRACO_GLTF_CONFIG = {
+	js: new URL( '../libs/draco/gltf/draco_wasm_wrapper.js', import.meta.url ).toString(),
+	wasm: new URL( '../libs/draco/gltf/draco_decoder.wasm', import.meta.url ).toString(),
+};
+
 /**
  * A loader for the Draco format.
  *
@@ -34,12 +44,10 @@ const _taskCache = new WeakMap();
  *
  * ```js
  * const loader = new DRACOLoader();
- * loader.setDecoderPath( '/examples/jsm/libs/draco/' );
- *
- * const geometry = await dracoLoader.loadAsync( 'models/draco/bunny.drc' );
+ * const geometry = await loader.loadAsync( 'models/draco/bunny.drc' );
  * geometry.computeVertexNormals(); // optional
  *
- * dracoLoader.dispose();
+ * loader.dispose();
  * ```
  *
  * @augments Loader
@@ -56,7 +64,11 @@ class DRACOLoader extends Loader {
 
 		super( manager );
 
-		this.decoderPath = '';
+		this.decoderPaths = {
+			js: WASM_JS_URL,
+			wasm: WASM_BIN_URL,
+			dep_js: JS_URL,
+		};
 		this.decoderConfig = {};
 		this.decoderBinary = null;
 		this.decoderPending = null;
@@ -84,12 +96,25 @@ class DRACOLoader extends Loader {
 	/**
 	 * Provides configuration for the decoder libraries. Configuration cannot be changed after decoding begins.
 	 *
-	 * @param {string} path - The decoder path.
+	 * @param {string|{js:string, wasm:string}} path - The decoder path, or a config object with explicit URLs for each decoder file.
 	 * @return {DRACOLoader} A reference to this loader.
 	 */
 	setDecoderPath( path ) {
 
-		this.decoderPath = path;
+		const { decoderPaths } = this;
+		if ( typeof path === 'object' ) {
+
+			decoderPaths.js = path.js;
+			decoderPaths.wasm = path.wasm;
+			decoderPaths.dep_js = null;
+
+		} else {
+
+			decoderPaths.js = LoaderUtils.resolveURL( 'draco_wasm_wrapper.js', path );
+			decoderPaths.wasm = LoaderUtils.resolveURL( 'draco_decoder.wasm', path );
+			decoderPaths.dep_js = LoaderUtils.resolveURL( 'draco_decoder.js', path );
+
+		}
 
 		return this;
 
@@ -98,11 +123,13 @@ class DRACOLoader extends Loader {
 	/**
 	 * Provides configuration for the decoder libraries. Configuration cannot be changed after decoding begins.
 	 *
+	 * @deprecated
 	 * @param {{type:('js'|'wasm')}} config - The decoder config.
 	 * @return {DRACOLoader} A reference to this loader.
 	 */
 	setDecoderConfig( config ) {
 
+		console.warn( 'THREE.DRACOLoader: setDecoderConfig to has been deprecated and will be removed in r194.' );
 		this.decoderConfig = config;
 
 		return this;
@@ -331,7 +358,6 @@ class DRACOLoader extends Loader {
 	_loadLibrary( url, responseType ) {
 
 		const loader = new FileLoader( this.manager );
-		loader.setPath( this.decoderPath );
 		loader.setResponseType( responseType );
 		loader.setWithCredentials( this.withCredentials );
 
@@ -358,14 +384,21 @@ class DRACOLoader extends Loader {
 		const useJS = typeof WebAssembly !== 'object' || this.decoderConfig.type === 'js';
 		const librariesPending = [];
 
+		const { decoderPaths } = this;
 		if ( useJS ) {
 
-			librariesPending.push( this._loadLibrary( 'draco_decoder.js', 'text' ) );
+			if ( decoderPaths.dep_js === null ) {
+
+				throw new Error( 'THREE.DRACOLoader: WebAssembly is required when using a custom decoder paths.' );
+
+			}
+
+			librariesPending.push( this._loadLibrary( decoderPaths.dep_js, 'text' ) );
 
 		} else {
 
-			librariesPending.push( this._loadLibrary( 'draco_wasm_wrapper.js', 'text' ) );
-			librariesPending.push( this._loadLibrary( 'draco_decoder.wasm', 'arraybuffer' ) );
+			librariesPending.push( this._loadLibrary( decoderPaths.js, 'text' ) );
+			librariesPending.push( this._loadLibrary( decoderPaths.wasm, 'arraybuffer' ) );
 
 		}
 
@@ -736,4 +769,4 @@ function DRACOWorker() {
 
 }
 
-export { DRACOLoader };
+export { DRACOLoader, DRACO_GLTF_CONFIG };