super-three 0.181.0 → 0.185.0

package/src/Three.TSL.js

@@ -7,7 +7,7 @@ export const BasicShadowFilter = TSL.BasicShadowFilter;
 export const Break = TSL.Break;
 export const Const = TSL.Const;
 export const Continue = TSL.Continue;
-export const DFGApprox = TSL.DFGApprox;
+export const DFGLUT = TSL.DFGLUT;
 export const D_GGX = TSL.D_GGX;
 export const Discard = TSL.Discard;
 export const EPSILON = TSL.EPSILON;
@@ -29,7 +29,6 @@ export const HALF_PI = TSL.HALF_PI;
 export const PointShadowFilter = TSL.PointShadowFilter;
 export const Return = TSL.Return;
 export const Schlick_to_F0 = TSL.Schlick_to_F0;
-export const ScriptableNodeResources = TSL.ScriptableNodeResources;
 export const ShaderNode = TSL.ShaderNode;
 export const Stack = TSL.Stack;
 export const Switch = TSL.Switch;
@@ -41,12 +40,14 @@ export const VarIntent = TSL.VarIntent;
 export const abs = TSL.abs;
 export const acesFilmicToneMapping = TSL.acesFilmicToneMapping;
 export const acos = TSL.acos;
+export const acosh = TSL.acosh;
 export const add = TSL.add;
 export const addMethodChaining = TSL.addMethodChaining;
 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,11 +55,11 @@ 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;
 export const atan = TSL.atan;
-export const atan2 = TSL.atan2;
+export const atanh = TSL.atanh;
 export const atomicAdd = TSL.atomicAdd;
 export const atomicAnd = TSL.atomicAnd;
 export const atomicFunc = TSL.atomicFunc;
@@ -98,8 +99,9 @@ export const bool = TSL.bool;
 export const buffer = TSL.buffer;
 export const bufferAttribute = TSL.bufferAttribute;
 export const bumpMap = TSL.bumpMap;
-export const burn = TSL.burn;
 export const builtin = TSL.builtin;
+export const builtinAOContext = TSL.builtinAOContext;
+export const builtinShadowContext = TSL.builtinShadowContext;
 export const bvec2 = TSL.bvec2;
 export const bvec3 = TSL.bvec3;
 export const bvec4 = TSL.bvec4;
@@ -125,6 +127,7 @@ export const clamp = TSL.clamp;
 export const clearcoat = TSL.clearcoat;
 export const clearcoatNormalView = TSL.clearcoatNormalView;
 export const clearcoatRoughness = TSL.clearcoatRoughness;
+export const clipSpace = TSL.clipSpace;
 export const code = TSL.code;
 export const color = TSL.color;
 export const colorSpaceToWorking = TSL.colorSpaceToWorking;
@@ -136,11 +139,14 @@ export const context = TSL.context;
 export const convert = TSL.convert;
 export const convertColorSpace = TSL.convertColorSpace;
 export const convertToTexture = TSL.convertToTexture;
+export const countLeadingZeros = TSL.countLeadingZeros;
+export const countOneBits = TSL.countOneBits;
+export const countTrailingZeros = TSL.countTrailingZeros;
 export const cos = TSL.cos;
+export const cosh = TSL.cosh;
 export const cross = TSL.cross;
 export const cubeTexture = TSL.cubeTexture;
 export const cubeTextureBase = TSL.cubeTextureBase;
-export const cubeToUV = TSL.cubeToUV;
 export const dFdx = TSL.dFdx;
 export const dFdy = TSL.dFdy;
 export const dashSize = TSL.dashSize;
@@ -165,17 +171,17 @@ export const directionToFaceDirection = TSL.directionToFaceDirection;
 export const dispersion = TSL.dispersion;
 export const distance = TSL.distance;
 export const div = TSL.div;
-export const dodge = TSL.dodge;
 export const dot = TSL.dot;
 export const drawIndex = TSL.drawIndex;
 export const dynamicBufferAttribute = TSL.dynamicBufferAttribute;
 export const element = TSL.element;
 export const emissive = TSL.emissive;
 export const equal = TSL.equal;
-export const equals = TSL.equals;
+export const equirectDirection = TSL.equirectDirection;
 export const equirectUV = TSL.equirectUV;
 export const exp = TSL.exp;
 export const exp2 = TSL.exp2;
+export const exponentialHeightFogFactor = TSL.exponentialHeightFogFactor;
 export const expression = TSL.expression;
 export const faceDirection = TSL.faceDirection;
 export const faceForward = TSL.faceForward;
@@ -199,6 +205,7 @@ export const getDistanceAttenuation = TSL.getDistanceAttenuation;
 export const getGeometryRoughness = TSL.getGeometryRoughness;
 export const getNormalFromDepth = TSL.getNormalFromDepth;
 export const interleavedGradientNoise = TSL.interleavedGradientNoise;
+export const vogelDiskSample = TSL.vogelDiskSample;
 export const getParallaxCorrectNormal = TSL.getParallaxCorrectNormal;
 export const getRoughness = TSL.getRoughness;
 export const getScreenPosition = TSL.getScreenPosition;
@@ -314,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;
@@ -372,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;
@@ -412,8 +419,13 @@ export const oscSquare = TSL.oscSquare;
 export const oscTriangle = TSL.oscTriangle;
 export const output = TSL.output;
 export const outputStruct = TSL.outputStruct;
-export const overlay = TSL.overlay;
 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;
@@ -461,6 +473,7 @@ export const remapClamp = TSL.remapClamp;
 export const renderGroup = TSL.renderGroup;
 export const renderOutput = TSL.renderOutput;
 export const rendererReference = TSL.rendererReference;
+export const replaceDefaultUV = TSL.replaceDefaultUV;
 export const rotate = TSL.rotate;
 export const rotateUV = TSL.rotateUV;
 export const roughness = TSL.roughness;
@@ -478,8 +491,6 @@ export const screenCoordinate = TSL.screenCoordinate;
 export const screenDPR = TSL.screenDPR;
 export const screenSize = TSL.screenSize;
 export const screenUV = TSL.screenUV;
-export const scriptable = TSL.scriptable;
-export const scriptableValue = TSL.scriptableValue;
 export const select = TSL.select;
 export const setCurrentStack = TSL.setCurrentStack;
 export const setName = TSL.setName;
@@ -495,6 +506,7 @@ export const shiftRight = TSL.shiftRight;
 export const shininess = TSL.shininess;
 export const sign = TSL.sign;
 export const sin = TSL.sin;
+export const sinh = TSL.sinh;
 export const sinc = TSL.sinc;
 export const skinning = TSL.skinning;
 export const smoothstep = TSL.smoothstep;
@@ -510,9 +522,8 @@ export const step = TSL.step;
 export const stepElement = TSL.stepElement;
 export const storage = TSL.storage;
 export const storageBarrier = TSL.storageBarrier;
-export const storageObject = TSL.storageObject;
 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;
@@ -540,6 +551,7 @@ export const subgroupShuffleXor = TSL.subgroupShuffleXor;
 export const subgroupSize = TSL.subgroupSize;
 export const subgroupXor = TSL.subgroupXor;
 export const tan = TSL.tan;
+export const tanh = TSL.tanh;
 export const tangentGeometry = TSL.tangentGeometry;
 export const tangentLocal = TSL.tangentLocal;
 export const tangentView = TSL.tangentView;
@@ -561,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;
@@ -579,6 +593,10 @@ export const uniformCubeTexture = TSL.uniformCubeTexture;
 export const uniformGroup = TSL.uniformGroup;
 export const uniformFlow = TSL.uniformFlow;
 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;
@@ -599,11 +617,14 @@ export const vibrance = TSL.vibrance;
 export const viewZToLogarithmicDepth = TSL.viewZToLogarithmicDepth;
 export const viewZToOrthographicDepth = TSL.viewZToOrthographicDepth;
 export const viewZToPerspectiveDepth = TSL.viewZToPerspectiveDepth;
+export const viewZToReversedOrthographicDepth = TSL.viewZToReversedOrthographicDepth;
+export const viewZToReversedPerspectiveDepth = TSL.viewZToReversedPerspectiveDepth;
 export const viewport = TSL.viewport;
 export const viewportCoordinate = TSL.viewportCoordinate;
 export const viewportDepthTexture = TSL.viewportDepthTexture;
 export const viewportLinearDepth = TSL.viewportLinearDepth;
 export const viewportMipTexture = TSL.viewportMipTexture;
+export const viewportOpaqueMipTexture = TSL.viewportOpaqueMipTexture;
 export const viewportResolution = TSL.viewportResolution;
 export const viewportSafeUV = TSL.viewportSafeUV;
 export const viewportSharedTexture = TSL.viewportSharedTexture;

package/src/Three.WebGPU.Nodes.js

@@ -2,11 +2,15 @@ export * from './Three.Core.js';
 
 export * from './materials/nodes/NodeMaterials.js';
 export { default as WebGPURenderer } from './renderers/webgpu/WebGPURenderer.Nodes.js';
+export { default as WebGPUBackend } from './renderers/webgpu/WebGPUBackend.js';
+export { default as WebGLBackend } from './renderers/webgl-fallback/WebGLBackend.js';
 export { default as Lighting } from './renderers/common/Lighting.js';
 export { default as BundleGroup } from './renderers/common/BundleGroup.js';
 export { default as QuadMesh } from './renderers/common/QuadMesh.js';
 export { default as PMREMGenerator } from './renderers/common/extras/PMREMGenerator.js';
+export { default as RenderPipeline } from './renderers/common/RenderPipeline.js';
 export { default as PostProcessing } from './renderers/common/PostProcessing.js';
+export { default as ReadbackBuffer } from './renderers/common/ReadbackBuffer.js';
 import * as RendererUtils from './renderers/common/RendererUtils.js';
 export { RendererUtils };
 export { default as StorageTexture } from './renderers/common/StorageTexture.js';
@@ -20,6 +24,7 @@ export { default as NodeObjectLoader } from './loaders/nodes/NodeObjectLoader.js
 export { default as NodeMaterialLoader } from './loaders/nodes/NodeMaterialLoader.js';
 export { default as InspectorBase } from './renderers/common/InspectorBase.js';
 export { default as CanvasTarget } from './renderers/common/CanvasTarget.js';
+export { default as BlendMode } from './renderers/common/BlendMode.js';
 export { ClippingGroup } from './objects/ClippingGroup.js';
 export * from './nodes/Nodes.js';
 import * as TSL from './nodes/TSL.js';

package/src/Three.WebGPU.js

@@ -2,13 +2,21 @@ export * from './Three.Core.js';
 
 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';
 export { default as QuadMesh } from './renderers/common/QuadMesh.js';
 export { default as PMREMGenerator } from './renderers/common/extras/PMREMGenerator.js';
+export { default as RenderPipeline } from './renderers/common/RenderPipeline.js';
 export { default as PostProcessing } from './renderers/common/PostProcessing.js';
+export { default as ReadbackBuffer } from './renderers/common/ReadbackBuffer.js';
 import * as RendererUtils from './renderers/common/RendererUtils.js';
 export { RendererUtils };
+export { default as CubeRenderTarget } from './renderers/common/CubeRenderTarget.js';
 export { default as StorageTexture } from './renderers/common/StorageTexture.js';
 export { default as Storage3DTexture } from './renderers/common/Storage3DTexture.js';
 export { default as StorageArrayTexture } from './renderers/common/StorageArrayTexture.js';
@@ -22,6 +30,11 @@ export { default as NodeObjectLoader } from './loaders/nodes/NodeObjectLoader.js
 export { default as NodeMaterialLoader } from './loaders/nodes/NodeMaterialLoader.js';
 export { default as InspectorBase } from './renderers/common/InspectorBase.js';
 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/Three.js

@@ -1,6 +1,7 @@
 export * from './Three.Core.js';
 
 export { WebGLRenderer } from './renderers/WebGLRenderer.js';
+export { WebGLCubeRenderTarget } from './renderers/WebGLCubeRenderTarget.js';
 export { ShaderLib } from './renderers/shaders/ShaderLib.js';
 export { UniformsLib } from './renderers/shaders/UniformsLib.js';
 export { UniformsUtils } from './renderers/shaders/UniformsUtils.js';

package/src/animation/AnimationAction.js

@@ -56,6 +56,7 @@ class AnimationAction {
 		this._byClipCacheIndex = null; // for the memory manager
 
 		this._timeScaleInterpolant = null;
+		this._restoreTimeScale = null;
 		this._weightInterpolant = null;
 
 		/**
@@ -343,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 );
 
@@ -511,6 +516,8 @@ class AnimationAction {
 
 		}
 
+		this._restoreTimeScale = null;
+
 		return this;
 
 	}
@@ -548,7 +555,7 @@ class AnimationAction {
 
 	}
 
-	// Interna
+	// Internal
 
 	_update( time, deltaTime, timeDirection, accuIndex ) {
 
@@ -683,8 +690,6 @@ class AnimationAction {
 
 				if ( time > interpolant.parameterPositions[ 1 ] ) {
 
-					this.stopWarping();
-
 					if ( timeScale === 0 ) {
 
 						// motion has halted, pause
@@ -692,11 +697,19 @@ class AnimationAction {
 
 					} else {
 
+						if ( this._restoreTimeScale !== null ) {
+
+							timeScale = this._restoreTimeScale;
+
+						}
+
 						// warp done - apply final time scale
 						this.timeScale = timeScale;
 
 					}
 
+					this.stopWarping();
+
 				}
 
 			}
@@ -847,6 +860,7 @@ class AnimationAction {
 
 			} else {
 
+				this._loopCount = loopCount;
 				this.time = time;
 
 			}
@@ -894,7 +908,7 @@ class AnimationAction {
 
 			} else {
 
-				settings.endingEnd 	 = WrapAroundEnding;
+				settings.endingEnd = WrapAroundEnding;
 
 			}
 

package/src/animation/AnimationClip.js

@@ -8,7 +8,6 @@ import { StringKeyframeTrack } from './tracks/StringKeyframeTrack.js';
 import { VectorKeyframeTrack } from './tracks/VectorKeyframeTrack.js';
 import { generateUUID } from '../math/MathUtils.js';
 import { NormalAnimationBlendMode } from '../constants.js';
-import { warn, error } from '../utils.js';
 
 /**
  * A reusable set of keyframe tracks which represent an animation.
@@ -295,144 +294,6 @@ class AnimationClip {
 
 	}
 
-	/**
-	 * Parses the `animation.hierarchy` format and returns a new animation clip.
-	 *
-	 * @static
-	 * @deprecated since r175.
-	 * @param {Object} animation - A serialized animation clip as JSON.
-	 * @param {Array<Bones>} bones - An array of bones.
-	 * @return {?AnimationClip} The new animation clip.
-	 */
-	static parseAnimation( animation, bones ) {
-
-		warn( 'AnimationClip: parseAnimation() is deprecated and will be removed with r185' );
-
-		if ( ! animation ) {
-
-			error( 'AnimationClip: No animation in JSONLoader data.' );
-			return null;
-
-		}
-
-		const addNonemptyTrack = function ( trackType, trackName, animationKeys, propertyName, destTracks ) {
-
-			// only return track if there are actually keys.
-			if ( animationKeys.length !== 0 ) {
-
-				const times = [];
-				const values = [];
-
-				AnimationUtils.flattenJSON( animationKeys, times, values, propertyName );
-
-				// empty keys are filtered out, so check again
-				if ( times.length !== 0 ) {
-
-					destTracks.push( new trackType( trackName, times, values ) );
-
-				}
-
-			}
-
-		};
-
-		const tracks = [];
-
-		const clipName = animation.name || 'default';
-		const fps = animation.fps || 30;
-		const blendMode = animation.blendMode;
-
-		// automatic length determination in AnimationClip.
-		let duration = animation.length || - 1;
-
-		const hierarchyTracks = animation.hierarchy || [];
-
-		for ( let h = 0; h < hierarchyTracks.length; h ++ ) {
-
-			const animationKeys = hierarchyTracks[ h ].keys;
-
-			// skip empty tracks
-			if ( ! animationKeys || animationKeys.length === 0 ) continue;
-
-			// process morph targets
-			if ( animationKeys[ 0 ].morphTargets ) {
-
-				// figure out all morph targets used in this track
-				const morphTargetNames = {};
-
-				let k;
-
-				for ( k = 0; k < animationKeys.length; k ++ ) {
-
-					if ( animationKeys[ k ].morphTargets ) {
-
-						for ( let m = 0; m < animationKeys[ k ].morphTargets.length; m ++ ) {
-
-							morphTargetNames[ animationKeys[ k ].morphTargets[ m ] ] = - 1;
-
-						}
-
-					}
-
-				}
-
-				// create a track for each morph target with all zero
-				// morphTargetInfluences except for the keys in which
-				// the morphTarget is named.
-				for ( const morphTargetName in morphTargetNames ) {
-
-					const times = [];
-					const values = [];
-
-					for ( let m = 0; m !== animationKeys[ k ].morphTargets.length; ++ m ) {
-
-						const animationKey = animationKeys[ k ];
-
-						times.push( animationKey.time );
-						values.push( ( animationKey.morphTarget === morphTargetName ) ? 1 : 0 );
-
-					}
-
-					tracks.push( new NumberKeyframeTrack( '.morphTargetInfluence[' + morphTargetName + ']', times, values ) );
-
-				}
-
-				duration = morphTargetNames.length * fps;
-
-			} else {
-
-				// ...assume skeletal animation
-
-				const boneName = '.bones[' + bones[ h ].name + ']';
-
-				addNonemptyTrack(
-					VectorKeyframeTrack, boneName + '.position',
-					animationKeys, 'pos', tracks );
-
-				addNonemptyTrack(
-					QuaternionKeyframeTrack, boneName + '.quaternion',
-					animationKeys, 'rot', tracks );
-
-				addNonemptyTrack(
-					VectorKeyframeTrack, boneName + '.scale',
-					animationKeys, 'scl', tracks );
-
-			}
-
-		}
-
-		if ( tracks.length === 0 ) {
-
-			return null;
-
-		}
-
-		const clip = new this( clipName, duration, tracks, blendMode );
-
-		return clip;
-
-	}
-
 	/**
 	 * Sets the duration of this clip to the duration of its longest keyframe track.
 	 *

package/src/animation/AnimationMixer.js

@@ -48,6 +48,12 @@ class AnimationMixer extends EventDispatcher {
 		 */
 		this.timeScale = 1.0;
 
+		if ( typeof __THREE_DEVTOOLS__ !== 'undefined' ) {
+
+			__THREE_DEVTOOLS__.dispatchEvent( new CustomEvent( 'observe', { detail: this } ) );
+
+		}
+
 	}
 
 	_bindAction( action, prototypeAction ) {

package/src/animation/AnimationUtils.js

@@ -1,5 +1,6 @@
 import { Quaternion } from '../math/Quaternion.js';
 import { AdditiveAnimationBlendMode } from '../constants.js';
+import { isTypedArray } from '../utils.js';
 
 /**
  * Converts an array to a specific type.
@@ -22,18 +23,6 @@ function convertArray( array, type ) {
 
 }
 
-/**
- * Returns `true` if the given object is a typed array.
- *
- * @param {any} object - The object to check.
- * @return {boolean} Whether the given object is a typed array.
- */
-function isTypedArray( object ) {
-
-	return ArrayBuffer.isView( object ) && ! ( object instanceof DataView );
-
-}
-
 /**
  * Returns an array by which times and values can be sorted.
  *

package/src/animation/KeyframeTrack.js

@@ -1,16 +1,18 @@
 import {
 	InterpolateLinear,
 	InterpolateSmooth,
-	InterpolateDiscrete
+	InterpolateDiscrete,
+	InterpolateBezier
 } from '../constants.js';
 import { CubicInterpolant } from '../math/interpolants/CubicInterpolant.js';
 import { LinearInterpolant } from '../math/interpolants/LinearInterpolant.js';
 import { DiscreteInterpolant } from '../math/interpolants/DiscreteInterpolant.js';
+import { BezierInterpolant } from '../math/interpolants/BezierInterpolant.js';
 import * as AnimationUtils from './AnimationUtils.js';
 import { warn, error } from '../utils.js';
 
 /**
- * Represents s a timed sequence of keyframes, which are composed of lists of
+ * Represents a timed sequence of keyframes, which are composed of lists of
  * times and related values, and which are used to animate a specific property
  * of an object.
  */
@@ -22,7 +24,7 @@ class KeyframeTrack {
 	 * @param {string} name - The keyframe track's name.
 	 * @param {Array<number>} times - A list of keyframe times.
 	 * @param {Array<number|string|boolean>} values - A list of keyframe values.
-	 * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} [interpolation] - The interpolation type.
+	 * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth|InterpolateBezier)} [interpolation] - The interpolation type.
 	 */
 	constructor( name, times, values, interpolation ) {
 
@@ -140,10 +142,37 @@ class KeyframeTrack {
 
 	}
 
+	/**
+	 * Factory method for creating a new Bezier interpolant.
+	 *
+	 * The Bezier interpolant requires tangent data to be set via the `settings` property
+	 * on the track before creating the interpolant. The settings should contain:
+	 * - `inTangents`: Float32Array with [time, value] pairs per keyframe per component
+	 * - `outTangents`: Float32Array with [time, value] pairs per keyframe per component
+	 *
+	 * @static
+	 * @param {TypedArray} [result] - The result buffer.
+	 * @return {BezierInterpolant} The new interpolant.
+	 */
+	InterpolantFactoryMethodBezier( result ) {
+
+		const interpolant = new BezierInterpolant( this.times, this.values, this.getValueSize(), result );
+
+		if ( this.settings ) {
+
+			interpolant.inTangents = this.settings.inTangents;
+			interpolant.outTangents = this.settings.outTangents;
+
+		}
+
+		return interpolant;
+
+	}
+
 	/**
 	 * Defines the interpolation factor method for this keyframe track.
 	 *
-	 * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} interpolation - The interpolation type.
+	 * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth|InterpolateBezier)} interpolation - The interpolation type.
 	 * @return {KeyframeTrack} A reference to this keyframe track.
 	 */
 	setInterpolation( interpolation ) {
@@ -170,6 +199,12 @@ class KeyframeTrack {
 
 				break;
 
+			case InterpolateBezier:
+
+				factoryMethod = this.InterpolantFactoryMethodBezier;
+
+				break;
+
 		}
 
 		if ( factoryMethod === undefined ) {
@@ -206,7 +241,7 @@ class KeyframeTrack {
 	/**
 	 * Returns the current interpolation type.
 	 *
-	 * @return {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} The interpolation type.
+	 * @return {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth|InterpolateBezier)} The interpolation type.
 	 */
 	getInterpolation() {
 
@@ -224,6 +259,10 @@ class KeyframeTrack {
 
 				return InterpolateSmooth;
 
+			case this.InterpolantFactoryMethodBezier:
+
+				return InterpolateBezier;
+
 		}
 
 	}
@@ -425,7 +464,7 @@ class KeyframeTrack {
 	 * Optimizes this keyframe track by removing equivalent sequential keys (which are
 	 * common in morph target sequences).
 	 *
-	 * @return {AnimationClip} A reference to this animation clip.
+	 * @return {KeyframeTrack} A reference to this keyframe track.
 	 */
 	optimize() {
 
@@ -565,7 +604,7 @@ class KeyframeTrack {
 /**
  * The value type name.
  *
- * @type {String}
+ * @type {string}
  * @default ''
  */
 KeyframeTrack.prototype.ValueTypeName = '';
@@ -589,7 +628,7 @@ KeyframeTrack.prototype.ValueBufferType = Float32Array;
 /**
  * The default interpolation type of this keyframe track.
  *
- * @type {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)}
+ * @type {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth|InterpolateBezier)}
  * @default InterpolateLinear
  */
 KeyframeTrack.prototype.DefaultInterpolation = InterpolateLinear;