; const endIndex = referenceValueSize - referenceOffset; referenceValue = referenceTrack.values.slice( startIndex, endIndex ); } else if ( referenceTime >= referenceTrack.times[ lastIndex ] ) { // Reference frame is after the last keyframe, so just use the last keyframe const startIndex = lastIndex * referenceValueSize + referenceOffset; const endIndex = startIndex + referenceValueSize - referenceOffset; referenceValue = referenceTrack.values.slice( startIndex, endIndex ); } else { // Interpolate to the reference value const interpolant = referenceTrack.createInterpolant(); const startIndex = referenceOffset; const endIndex = referenceValueSize - referenceOffset; interpolant.evaluate( referenceTime ); referenceValue = interpolant.resultBuffer.slice( startIndex, endIndex ); } // Conjugate the quaternion if ( referenceTrackType === 'quaternion' ) { const referenceQuat = new Quaternion().fromArray( referenceValue ).normalize().conjugate(); referenceQuat.toArray( referenceValue ); } // Subtract the reference value from all of the track values const numTimes = targetTrack.times.length; for ( let j = 0; j < numTimes; ++ j ) { const valueStart = j * targetValueSize + targetOffset; if ( referenceTrackType === 'quaternion' ) { // Multiply the conjugate for quaternion track types Quaternion.multiplyQuaternionsFlat( targetTrack.values, valueStart, referenceValue, 0, targetTrack.values, valueStart ); } else { const valueEnd = targetValueSize - targetOffset * 2; // Subtract each value for all other numeric track types for ( let k = 0; k < valueEnd; ++ k ) { targetTrack.values[ valueStart + k ] -= referenceValue[ k ]; } } } } targetClip.blendMode = AdditiveAnimationBlendMode; return targetClip; } /** * A class with various methods to assist with animations. * * @hideconstructor */ class AnimationUtils { /** * Converts an array to a specific type * * @static * @param {TypedArray|Array} array - The array to convert. * @param {TypedArray.constructor} type - The constructor of a type array. * @return {TypedArray} The converted array */ static convertArray( array, type ) { return convertArray( array, type ); } /** * Returns `true` if the given object is a typed array. * * @static * @param {any} object - The object to check. * @return {boolean} Whether the given object is a typed array. */ static isTypedArray( object ) { return isTypedArray( object ); } /** * Returns `true` if the given keyframe track settings hold Bezier tangent data. * * @static * @param {?Object} settings - The settings of a keyframe track. * @return {boolean} Whether both tangent arrays are defined or not. */ static hasTangents( settings ) { return hasTangents( settings ); } /** * Returns an array by which times and values can be sorted. * * @static * @param {Array} times - The keyframe time values. * @return {Array} The array. */ static getKeyframeOrder( times ) { return getKeyframeOrder( times ); } /** * Sorts the given array by the previously computed order via `getKeyframeOrder()`. * * @static * @param {Array} values - The values to sort. * @param {number} stride - The stride. * @param {Array} order - The sort order. * @return {Array} The sorted values. */ static sortedArray( values, stride, order ) { return sortedArray( values, stride, order ); } /** * Used for parsing AOS keyframe formats. * * @static * @param {Array} jsonKeys - A list of JSON keyframes. * @param {Array} times - This array will be filled with keyframe times by this method. * @param {Array} values - This array will be filled with keyframe values by this method. * @param {string} valuePropertyName - The name of the property to use. */ static flattenJSON( jsonKeys, times, values, valuePropertyName ) { flattenJSON( jsonKeys, times, values, valuePropertyName ); } /** * Creates a new clip, containing only the segment of the original clip between the given frames. * * @static * @param {AnimationClip} sourceClip - The values to sort. * @param {string} name - The name of the clip. * @param {number} startFrame - The start frame. * @param {number} endFrame - The end frame. * @param {number} [fps=30] - The FPS. * @return {AnimationClip} The new sub clip. */ static subclip( sourceClip, name, startFrame, endFrame, fps = 30 ) { return subclip( sourceClip, name, startFrame, endFrame, fps ); } /** * Converts the keyframes of the given animation clip to an additive format. * * @static * @param {AnimationClip} targetClip - The clip to make additive. * @param {number} [referenceFrame=0] - The reference frame. * @param {AnimationClip} [referenceClip=targetClip] - The referen