super-three 0.184.0 → 0.185.0

package/examples/jsm/utils/BufferGeometryUtils.js

@@ -39,13 +39,13 @@ function computeMikkTSpaceTangents( geometry, MikkTSpace, negateSign = true ) {
 
 	if ( ! MikkTSpace || ! MikkTSpace.isReady ) {
 
-		throw new Error( 'BufferGeometryUtils: Initialized MikkTSpace library required.' );
+		throw new Error( 'THREE.BufferGeometryUtils: Initialized MikkTSpace library required.' );
 
 	}
 
 	if ( ! geometry.hasAttribute( 'position' ) || ! geometry.hasAttribute( 'normal' ) || ! geometry.hasAttribute( 'uv' ) ) {
 
-		throw new Error( 'BufferGeometryUtils: Tangents require "position", "normal", and "uv" attributes.' );
+		throw new Error( 'THREE.BufferGeometryUtils: Tangents require "position", "normal", and "uv" attributes.' );
 
 	}
 
@@ -1314,105 +1314,172 @@ function mergeGroups( geometry ) {
  */
 function toCreasedNormals( geometry, creaseAngle = Math.PI / 3 /* 60 degrees */ ) {
 
+	// BufferGeometry.toNonIndexed() warns if the geometry is non-indexed
+	// and returns the original geometry
+	const resultGeometry = geometry.index ? geometry.toNonIndexed() : geometry;
+	const posAttr = resultGeometry.attributes.position;
+	const vertexCount = posAttr.count;
+
+	let positions;
+
+	if ( posAttr.isBufferAttribute === true && posAttr.itemSize === 3 && posAttr.normalized === false ) {
+
+		positions = posAttr.array;
+
+	} else {
+
+		// flatten the position buffer so the math below operates on plain numbers
+		positions = new Float64Array( vertexCount * 3 );
+
+		for ( let i = 0; i < vertexCount; i ++ ) {
+
+			positions[ 3 * i + 0 ] = posAttr.getX( i );
+			positions[ 3 * i + 1 ] = posAttr.getY( i );
+			positions[ 3 * i + 2 ] = posAttr.getZ( i );
+
+		}
+
+	}
+
 	const creaseDot = Math.cos( creaseAngle );
 	const hashMultiplier = ( 1 + 1e-10 ) * 1e2;
+	const faceCount = vertexCount / 3;
+
+	// compute the normal of each face
+	const faceNormals = new Float64Array( faceCount * 3 );
+	for ( let f = 0; f < faceCount; f ++ ) {
+
+		const f9 = 9 * f;
+		const ax = positions[ f9 + 0 ], ay = positions[ f9 + 1 ], az = positions[ f9 + 2 ];
+		const bx = positions[ f9 + 3 ], by = positions[ f9 + 4 ], bz = positions[ f9 + 5 ];
+		const cx = positions[ f9 + 6 ], cy = positions[ f9 + 7 ], cz = positions[ f9 + 8 ];
 
-	// reusable vectors
-	const verts = [ new Vector3(), new Vector3(), new Vector3() ];
-	const tempVec1 = new Vector3();
-	const tempVec2 = new Vector3();
-	const tempNorm = new Vector3();
-	const tempNorm2 = new Vector3();
+		const v1x = cx - bx, v1y = cy - by, v1z = cz - bz;
+		const v2x = ax - bx, v2y = ay - by, v2z = az - bz;
 
-	// hashes a vector
-	function hashVertex( v ) {
+		const nx = v1y * v2z - v1z * v2y;
+		const ny = v1z * v2x - v1x * v2z;
+		const nz = v1x * v2y - v1y * v2x;
 
-		const x = ~ ~ ( v.x * hashMultiplier );
-		const y = ~ ~ ( v.y * hashMultiplier );
-		const z = ~ ~ ( v.z * hashMultiplier );
-		return `${x},${y},${z}`;
+		const invLength = 1 / ( Math.sqrt( nx * nx + ny * ny + nz * nz ) || 1 );
+		faceNormals[ 3 * f + 0 ] = nx * invLength;
+		faceNormals[ 3 * f + 1 ] = ny * invLength;
+		faceNormals[ 3 * f + 2 ] = nz * invLength;
 
 	}
 
-	// BufferGeometry.toNonIndexed() warns if the geometry is non-indexed
-	// and returns the original geometry
-	const resultGeometry = geometry.index ? geometry.toNonIndexed() : geometry;
-	const posAttr = resultGeometry.attributes.position;
-	const vertexMap = {};
+	// assign an id to each vertex, sharing the id between vertices with the same
+	// quantized position via an open-addressed hash table (slots hold id + 1, 0 means empty)
+	const vertexIds = new Int32Array( vertexCount );
+	const quantized = new Int32Array( vertexCount * 3 );
 
-	// find all the normals shared by commonly located vertices
-	for ( let i = 0, l = posAttr.count / 3; i < l; i ++ ) {
+	let tableSize = 1;
+	while ( tableSize < vertexCount * 2 ) tableSize <<= 1;
+	const tableMask = tableSize - 1;
+	const table = new Int32Array( tableSize );
+
+	let uniqueCount = 0;
+	for ( let i = 0; i < vertexCount; i ++ ) {
 
 		const i3 = 3 * i;
-		const a = verts[ 0 ].fromBufferAttribute( posAttr, i3 + 0 );
-		const b = verts[ 1 ].fromBufferAttribute( posAttr, i3 + 1 );
-		const c = verts[ 2 ].fromBufferAttribute( posAttr, i3 + 2 );
+		const qx = ~ ~ ( positions[ i3 + 0 ] * hashMultiplier );
+		const qy = ~ ~ ( positions[ i3 + 1 ] * hashMultiplier );
+		const qz = ~ ~ ( positions[ i3 + 2 ] * hashMultiplier );
 
-		tempVec1.subVectors( c, b );
-		tempVec2.subVectors( a, b );
+		let slot = ( Math.imul( qx, 73856093 ) ^ Math.imul( qy, 19349663 ) ^ Math.imul( qz, 83492791 ) ) & tableMask;
 
-		// add the normal to the map for all vertices
-		const normal = new Vector3().crossVectors( tempVec1, tempVec2 ).normalize();
-		for ( let n = 0; n < 3; n ++ ) {
+		while ( true ) {
+
+			const id = table[ slot ];
+
+			if ( id === 0 ) {
+
+				const q3 = 3 * uniqueCount;
+				quantized[ q3 + 0 ] = qx;
+				quantized[ q3 + 1 ] = qy;
+				quantized[ q3 + 2 ] = qz;
+
+				table[ slot ] = uniqueCount + 1;
+				vertexIds[ i ] = uniqueCount ++;
+				break;
+
+			}
+
+			const q3 = 3 * ( id - 1 );
 
-			const vert = verts[ n ];
-			const hash = hashVertex( vert );
-			if ( ! ( hash in vertexMap ) ) {
+			if ( quantized[ q3 + 0 ] === qx && quantized[ q3 + 1 ] === qy && quantized[ q3 + 2 ] === qz ) {
 
-				vertexMap[ hash ] = [];
+				vertexIds[ i ] = id - 1;
+				break;
 
 			}
 
-			vertexMap[ hash ].push( normal );
+			slot = ( slot + 1 ) & tableMask;
 
 		}
 
 	}
 
-	// average normals from all vertices that share a common location if they are within the
-	// provided crease threshold
-	const normalArray = new Float32Array( posAttr.count * 3 );
-	const normAttr = new BufferAttribute( normalArray, 3, false );
-	for ( let i = 0, l = posAttr.count / 3; i < l; i ++ ) {
+	// bucket the faces surrounding each unique vertex position
+	const bucketOffsets = new Int32Array( uniqueCount + 1 );
+	for ( let i = 0; i < vertexCount; i ++ ) bucketOffsets[ vertexIds[ i ] + 1 ] ++;
+	for ( let i = 0; i < uniqueCount; i ++ ) bucketOffsets[ i + 1 ] += bucketOffsets[ i ];
 
-		// get the face normal for this vertex
-		const i3 = 3 * i;
-		const a = verts[ 0 ].fromBufferAttribute( posAttr, i3 + 0 );
-		const b = verts[ 1 ].fromBufferAttribute( posAttr, i3 + 1 );
-		const c = verts[ 2 ].fromBufferAttribute( posAttr, i3 + 2 );
+	const bucketFaces = new Int32Array( vertexCount );
+	const bucketCursors = bucketOffsets.slice( 0, uniqueCount );
+	for ( let f = 0; f < faceCount; f ++ ) {
+
+		const f3 = 3 * f;
+		bucketFaces[ bucketCursors[ vertexIds[ f3 + 0 ] ] ++ ] = f;
+		bucketFaces[ bucketCursors[ vertexIds[ f3 + 1 ] ] ++ ] = f;
+		bucketFaces[ bucketCursors[ vertexIds[ f3 + 2 ] ] ++ ] = f;
 
-		tempVec1.subVectors( c, b );
-		tempVec2.subVectors( a, b );
+	}
+
+	// average the normals of the faces surrounding each vertex if they are within the
+	// provided crease threshold
+	const normalArray = new Float32Array( vertexCount * 3 );
+	for ( let f = 0; f < faceCount; f ++ ) {
 
-		tempNorm.crossVectors( tempVec1, tempVec2 ).normalize();
+		const f3 = 3 * f;
+		const nx = faceNormals[ f3 + 0 ];
+		const ny = faceNormals[ f3 + 1 ];
+		const nz = faceNormals[ f3 + 2 ];
 
-		// average all normals that meet the threshold and set the normal value
 		for ( let n = 0; n < 3; n ++ ) {
 
-			const vert = verts[ n ];
-			const hash = hashVertex( vert );
-			const otherNormals = vertexMap[ hash ];
-			tempNorm2.set( 0, 0, 0 );
+			const i = f3 + n;
+			const id = vertexIds[ i ];
+
+			let sumX = 0, sumY = 0, sumZ = 0;
+
+			for ( let k = bucketOffsets[ id ], end = bucketOffsets[ id + 1 ]; k < end; k ++ ) {
 
-			for ( let k = 0, lk = otherNormals.length; k < lk; k ++ ) {
+				const o3 = 3 * bucketFaces[ k ];
+				const ox = faceNormals[ o3 + 0 ];
+				const oy = faceNormals[ o3 + 1 ];
+				const oz = faceNormals[ o3 + 2 ];
 
-				const otherNorm = otherNormals[ k ];
-				if ( tempNorm.dot( otherNorm ) > creaseDot ) {
+				if ( nx * ox + ny * oy + nz * oz > creaseDot ) {
 
-					tempNorm2.add( otherNorm );
+					sumX += ox;
+					sumY += oy;
+					sumZ += oz;
 
 				}
 
 			}
 
-			tempNorm2.normalize();
-			normAttr.setXYZ( i3 + n, tempNorm2.x, tempNorm2.y, tempNorm2.z );
+			const invLength = 1 / ( Math.sqrt( sumX * sumX + sumY * sumY + sumZ * sumZ ) || 1 );
+			normalArray[ 3 * i + 0 ] = sumX * invLength;
+			normalArray[ 3 * i + 1 ] = sumY * invLength;
+			normalArray[ 3 * i + 2 ] = sumZ * invLength;
 
 		}
 
 	}
 
-	resultGeometry.setAttribute( 'normal', normAttr );
+	resultGeometry.setAttribute( 'normal', new BufferAttribute( normalArray, 3, false ) );
 	return resultGeometry;
 
 }

package/examples/jsm/utils/GeometryCompressionUtils.js

@@ -509,7 +509,7 @@ function quantizedEncodeUV( array, bytes ) {
 
 	}
 
-	decodeMat.scale(
+	decodeMat.makeScale(
 		( max[ 0 ] - min[ 0 ] ) / segments,
 		( max[ 1 ] - min[ 1 ] ) / segments
 	);

package/examples/jsm/utils/SceneOptimizer.js

@@ -442,7 +442,7 @@ class SceneOptimizer {
 	 */
 	toInstancingMesh() {
 
-		throw new Error( 'InstancedMesh optimization not implemented yet' );
+		throw new Error( 'THREE.SceneOptimizer: InstancedMesh optimization not implemented yet' );
 
 	}
 

package/examples/jsm/webxr/ARButton.js

@@ -1,7 +1,7 @@
 /**
  * A utility class for creating a button that allows to initiate
  * immersive AR sessions based on WebXR. The button can be created
- * with a factory method and then appended ot the website's DOM.
+ * with a factory method and then appended to the website's DOM.
  *
  * ```js
  * document.body.appendChild( ARButton.createButton( renderer ) );

package/examples/jsm/webxr/WebGLXRFallback.js

@@ -0,0 +1,89 @@
+/**
+ * Sets up a construction-time WebGL fallback for WebGPU XR examples.
+ *
+ * @param {WebGPURenderer} renderer - The initial renderer.
+ * @param {Function} createFallbackRenderer - A function that returns a new renderer with a WebGL backend.
+ * @param {Function} onFallback - A function that installs the new renderer in the app.
+ */
+function setupWebGLXRFallback( renderer, createFallbackRenderer, onFallback = () => {} ) {
+
+	let currentRenderer = renderer;
+	const patchedRenderers = new WeakSet();
+
+	function patchRenderer( renderer ) {
+
+		if ( patchedRenderers.has( renderer ) ) return;
+
+		patchedRenderers.add( renderer );
+
+		const setSession = renderer.xr.setSession.bind( renderer.xr );
+
+		renderer.xr.setSession = async function ( session ) {
+
+			if ( renderer !== currentRenderer ) {
+
+				return currentRenderer.xr.setSession( session );
+
+			}
+
+			if ( session !== null && renderer.backend.isWebGPUBackend === true && session.enabledFeatures.includes( 'webgpu' ) === false ) {
+
+				return switchToFallbackRenderer( session, renderer );
+
+			}
+
+			try {
+
+				return await setSession( session );
+
+			} catch ( error ) {
+
+				if ( session === null || renderer.backend.isWebGPUBackend !== true ) {
+
+					throw error;
+
+				}
+
+				return switchToFallbackRenderer( session, renderer );
+
+			}
+
+		};
+
+	}
+
+	async function switchToFallbackRenderer( session, renderer ) {
+
+		if ( renderer.initialized === false ) await renderer.init();
+
+		const fallbackRenderer = createFallbackRenderer( renderer );
+
+		if ( fallbackRenderer.backend.isWebGLBackend !== true ) {
+
+			throw new Error( 'THREE.WebGLXRFallback: createFallbackRenderer() must return a renderer with a WebGL backend.' );
+
+		}
+
+		const animationLoop = renderer.getAnimationLoop();
+
+		fallbackRenderer.xr.enabled = renderer.xr.enabled;
+		fallbackRenderer.xr.cameraAutoUpdate = renderer.xr.cameraAutoUpdate;
+		fallbackRenderer.xr.setFramebufferScaleFactor( renderer.xr.getFramebufferScaleFactor() );
+		fallbackRenderer.xr.setReferenceSpaceType( renderer.xr.getReferenceSpaceType() );
+
+		if ( animationLoop !== null ) await fallbackRenderer.setAnimationLoop( animationLoop );
+
+		await onFallback( fallbackRenderer, renderer );
+
+		currentRenderer = fallbackRenderer;
+		patchRenderer( fallbackRenderer );
+
+		return fallbackRenderer.xr.setSession( session );
+
+	}
+
+	patchRenderer( renderer );
+
+}
+
+export { setupWebGLXRFallback };

package/examples/jsm/webxr/XRControllerModelFactory.js

@@ -353,7 +353,7 @@ class XRControllerModelFactory {
 
 					if ( ! this.gltfLoader ) {
 
-						throw new Error( 'GLTFLoader not set.' );
+						throw new Error( 'THREE.XRControllerModelFactory: GLTFLoader not set.' );
 
 					}
 
@@ -372,7 +372,7 @@ class XRControllerModelFactory {
 					null,
 					() => {
 
-						throw new Error( `Asset ${controllerModel.motionController.assetUrl} missing or malformed.` );
+						throw new Error( `THREE.XRControllerModelFactory: Asset ${controllerModel.motionController.assetUrl} missing or malformed.` );
 
 					} );
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "super-three",
-  "version": "0.184.0",
+  "version": "0.185.0",
   "description": "JavaScript 3D library",
   "type": "module",
   "main": "./build/three.cjs",
@@ -28,7 +28,6 @@
   "files": [
     "build",
     "examples/jsm",
-    "examples/fonts",
     "LICENSE",
     "package.json",
     "README.md",
@@ -60,8 +59,10 @@
     "lint-utils": "eslint utils",
     "lint": "npm run lint-core",
     "lint-fix": "npm run lint-core -- --fix && npm run lint-addons -- --fix && npm run lint-examples -- --fix && npm run lint-editor -- --fix && npm run lint-manual -- --fix && npm run lint-test -- --fix && npm run lint-utils -- --fix",
-    "test-unit": "qunit test/unit/three.source.unit.js",
-    "test-unit-addons": "qunit test/unit/three.addons.unit.js",
+    "test-unit": "node test/unit/puppeteer.unit.js --testPage=UnitTests.html --mode=headless",
+    "test-unit-headful": "node test/unit/puppeteer.unit.js --testPage=UnitTests.html --mode=headful",
+    "test-unit-addons": "node test/unit/puppeteer.unit.js --testPage=UnitTestsAddons.html --mode=headless",
+    "test-unit-addons-headful": "node test/unit/puppeteer.unit.js --testPage=UnitTestsAddons.html --mode=headful",
     "test-e2e": "node test/e2e/puppeteer.js",
     "test-e2e-cov": "node test/e2e/check-coverage.js",
     "test-e2e-webgpu": "node test/e2e/puppeteer.js --webgpu",
@@ -98,14 +99,13 @@
     "eslint-config-mdcs": "^5.0.0",
     "eslint-plugin-compat": "^7.0.0",
     "eslint-plugin-html": "^8.1.3",
-    "eslint-plugin-jsdoc": "^62.0.0",
+    "eslint-plugin-jsdoc": "^63.0.0",
     "globals": "^17.0.0",
     "jpeg-js": "^0.4.4",
     "jsdoc": "^4.0.5",
     "magic-string": "^0.30.0",
     "pngjs": "^7.0.0",
-    "puppeteer": "^24.40.0",
-    "qunit": "^2.19.4",
+    "puppeteer": "^25.0.0",
     "rollup": "^4.6.0",
     "turndown": "^7.2.2"
   },

package/src/Three.TSL.js

@@ -47,6 +47,7 @@ export const addNodeElement = TSL.addNodeElement;
 export const agxToneMapping = TSL.agxToneMapping;
 export const all = TSL.all;
 export const alphaT = TSL.alphaT;
+export const ambientOcclusion = TSL.ambientOcclusion;
 export const and = TSL.and;
 export const anisotropy = TSL.anisotropy;
 export const anisotropyB = TSL.anisotropyB;
@@ -54,7 +55,6 @@ export const anisotropyT = TSL.anisotropyT;
 export const any = TSL.any;
 export const append = TSL.append;
 export const array = TSL.array;
-export const arrayBuffer = TSL.arrayBuffer;
 export const asin = TSL.asin;
 export const asinh = TSL.asinh;
 export const assign = TSL.assign;
@@ -177,6 +177,7 @@ export const dynamicBufferAttribute = TSL.dynamicBufferAttribute;
 export const element = TSL.element;
 export const emissive = TSL.emissive;
 export const equal = TSL.equal;
+export const equirectDirection = TSL.equirectDirection;
 export const equirectUV = TSL.equirectUV;
 export const exp = TSL.exp;
 export const exp2 = TSL.exp2;
@@ -320,7 +321,6 @@ export const min = TSL.min;
 export const mix = TSL.mix;
 export const mixElement = TSL.mixElement;
 export const mod = TSL.mod;
-export const modInt = TSL.modInt;
 export const modelDirection = TSL.modelDirection;
 export const modelNormalMatrix = TSL.modelNormalMatrix;
 export const modelPosition = TSL.modelPosition;
@@ -378,6 +378,7 @@ export const mx_worley_noise_float = TSL.mx_worley_noise_float;
 export const mx_worley_noise_vec2 = TSL.mx_worley_noise_vec2;
 export const mx_worley_noise_vec3 = TSL.mx_worley_noise_vec3;
 export const negate = TSL.negate;
+export const negateOnBackSide = TSL.negateOnBackSide;
 export const neutralToneMapping = TSL.neutralToneMapping;
 export const nodeArray = TSL.nodeArray;
 export const nodeImmutable = TSL.nodeImmutable;
@@ -419,9 +420,12 @@ export const oscTriangle = TSL.oscTriangle;
 export const output = TSL.output;
 export const outputStruct = TSL.outputStruct;
 export const overloadingFn = TSL.overloadingFn;
+export const overrideNode = TSL.overrideNode;
+export const overrideNodes = TSL.overrideNodes;
 export const packHalf2x16 = TSL.packHalf2x16;
 export const packSnorm2x16 = TSL.packSnorm2x16;
 export const packUnorm2x16 = TSL.packUnorm2x16;
+export const packNormalToRGB = TSL.packNormalToRGB;
 export const parabola = TSL.parabola;
 export const parallaxDirection = TSL.parallaxDirection;
 export const parallaxUV = TSL.parallaxUV;
@@ -519,7 +523,7 @@ export const stepElement = TSL.stepElement;
 export const storage = TSL.storage;
 export const storageBarrier = TSL.storageBarrier;
 export const storageTexture = TSL.storageTexture;
-export const string = TSL.string;
+export const storageTexture3D = TSL.storageTexture3D;
 export const struct = TSL.struct;
 export const sub = TSL.sub;
 export const subgroupAdd = TSL.subgroupAdd;
@@ -569,6 +573,8 @@ export const toneMappingExposure = TSL.toneMappingExposure;
 export const toonOutlinePass = TSL.toonOutlinePass;
 export const transformDirection = TSL.transformDirection;
 export const transformNormal = TSL.transformNormal;
+export const transformNormalByInverseViewMatrix = TSL.transformNormalByInverseViewMatrix;
+export const transformNormalByViewMatrix = TSL.transformNormalByViewMatrix;
 export const transformNormalToView = TSL.transformNormalToView;
 export const transformedClearcoatNormalView = TSL.transformedClearcoatNormalView;
 export const transformedNormalView = TSL.transformedNormalView;
@@ -590,6 +596,7 @@ export const uniformTexture = TSL.uniformTexture;
 export const unpackHalf2x16 = TSL.unpackHalf2x16;
 export const unpackSnorm2x16 = TSL.unpackSnorm2x16;
 export const unpackUnorm2x16 = TSL.unpackUnorm2x16;
+export const unpackRGBToNormal = TSL.unpackRGBToNormal;
 export const unpremultiplyAlpha = TSL.unpremultiplyAlpha;
 export const userData = TSL.userData;
 export const uv = TSL.uv;

package/src/Three.WebGPU.js

@@ -4,6 +4,8 @@ export * from './materials/nodes/NodeMaterials.js';
 export { default as WebGPURenderer } from './renderers/webgpu/WebGPURenderer.js';
 export { default as WebGPUBackend } from './renderers/webgpu/WebGPUBackend.js';
 export { default as WebGLBackend } from './renderers/webgl-fallback/WebGLBackend.js';
+export { default as Renderer } from './renderers/common/Renderer.js';
+export { default as Backend } from './renderers/common/Backend.js';
 export { default as WebGLCapabilities } from './renderers/webgl-fallback/utils/WebGLCapabilities.js';
 export { default as Lighting } from './renderers/common/Lighting.js';
 export { default as BundleGroup } from './renderers/common/BundleGroup.js';
@@ -31,6 +33,8 @@ export { default as CanvasTarget } from './renderers/common/CanvasTarget.js';
 export { default as BlendMode } from './renderers/common/BlendMode.js';
 export { default as GLSLNodeBuilder } from './renderers/webgl-fallback/nodes/GLSLNodeBuilder.js';
 export { default as BasicNodeLibrary } from './renderers/webgpu/nodes/BasicNodeLibrary.js';
+export { default as StandardNodeLibrary } from './renderers/webgpu/nodes/StandardNodeLibrary.js';
+export { default as WGSLNodeBuilder } from './renderers/webgpu/nodes/WGSLNodeBuilder.js';
 export { ClippingGroup } from './objects/ClippingGroup.js';
 export * from './nodes/Nodes.js';
 import * as TSL from './nodes/TSL.js';

package/src/animation/AnimationAction.js

@@ -41,15 +41,6 @@ class AnimationAction {
 
 			const interpolant = tracks[ i ].createInterpolant( null );
 			interpolants[ i ] = interpolant;
-
-			// preserve interpolant settings (like tangent data from BezierInterpolant)
-
-			if ( interpolant.settings ) {
-
-				Object.assign( interpolantSettings, interpolant.settings );
-
-			}
-
 			interpolant.settings = interpolantSettings;
 
 		}
@@ -65,6 +56,7 @@ class AnimationAction {
 		this._byClipCacheIndex = null; // for the memory manager
 
 		this._timeScaleInterpolant = null;
+		this._restoreTimeScale = null;
 		this._weightInterpolant = null;
 
 		/**
@@ -352,6 +344,10 @@ class AnimationAction {
 				startEndRatio = fadeOutDuration / fadeInDuration,
 				endStartRatio = fadeInDuration / fadeOutDuration;
 
+
+			fadeOutAction._restoreTimeScale = fadeOutAction.timeScale;
+			this._restoreTimeScale = this.timeScale;
+
 			fadeOutAction.warp( 1.0, startEndRatio, duration );
 			this.warp( endStartRatio, 1.0, duration );
 
@@ -520,6 +516,8 @@ class AnimationAction {
 
 		}
 
+		this._restoreTimeScale = null;
+
 		return this;
 
 	}
@@ -692,8 +690,6 @@ class AnimationAction {
 
 				if ( time > interpolant.parameterPositions[ 1 ] ) {
 
-					this.stopWarping();
-
 					if ( timeScale === 0 ) {
 
 						// motion has halted, pause
@@ -701,11 +697,19 @@ class AnimationAction {
 
 					} else {
 
+						if ( this._restoreTimeScale !== null ) {
+
+							timeScale = this._restoreTimeScale;
+
+						}
+
 						// warp done - apply final time scale
 						this.timeScale = timeScale;
 
 					}
 
+					this.stopWarping();
+
 				}
 
 			}