diff --git a/src/animation/AnimationClip.js b/src/animation/AnimationClip.js index 30bfb10a0aa1d1..58a904054fe0e8 100644 --- a/src/animation/AnimationClip.js +++ b/src/animation/AnimationClip.js @@ -9,104 +9,28 @@ import { VectorKeyframeTrack } from './tracks/VectorKeyframeTrack.js'; import { MathUtils } from '../math/MathUtils.js'; import { NormalAnimationBlendMode } from '../constants.js'; -function AnimationClip( name, duration = - 1, tracks, blendMode = NormalAnimationBlendMode ) { +class AnimationClip { - this.name = name; - this.tracks = tracks; - this.duration = duration; - this.blendMode = blendMode; + constructor( name, duration = - 1, tracks, blendMode = NormalAnimationBlendMode ) { - this.uuid = MathUtils.generateUUID(); - - // this means it should figure out its duration by scanning the tracks - if ( this.duration < 0 ) { - - this.resetDuration(); - - } - -} - -function getTrackTypeForValueTypeName( typeName ) { - - switch ( typeName.toLowerCase() ) { - - case 'scalar': - case 'double': - case 'float': - case 'number': - case 'integer': - - return NumberKeyframeTrack; - - case 'vector': - case 'vector2': - case 'vector3': - case 'vector4': - - return VectorKeyframeTrack; - - case 'color': - - return ColorKeyframeTrack; - - case 'quaternion': - - return QuaternionKeyframeTrack; - - case 'bool': - case 'boolean': - - return BooleanKeyframeTrack; - - case 'string': - - return StringKeyframeTrack; - - } - - throw new Error( 'THREE.KeyframeTrack: Unsupported typeName: ' + typeName ); - -} - -function parseKeyframeTrack( json ) { - - if ( json.type === undefined ) { - - throw new Error( 'THREE.KeyframeTrack: track type undefined, can not parse' ); - - } - - const trackType = getTrackTypeForValueTypeName( json.type ); - - if ( json.times === undefined ) { - - const times = [], values = []; - - AnimationUtils.flattenJSON( json.keys, times, values, 'value' ); - - json.times = times; - json.values = values; - - } + this.name = name; + this.tracks = tracks; + this.duration = duration; + this.blendMode = blendMode; - // derived classes can define a static parse method - if ( trackType.parse !== undefined ) { + this.uuid = MathUtils.generateUUID(); - return trackType.parse( json ); + // this means it should figure out its duration by scanning the tracks + if ( this.duration < 0 ) { - } else { + this.resetDuration(); - // by default, we assume a constructor compatible with the base - return new trackType( json.name, json.times, json.values, json.interpolation ); + } } -} - -Object.assign( AnimationClip, { - parse: function ( json ) { + static parse( json ) { const tracks = [], jsonTracks = json.tracks, @@ -118,14 +42,14 @@ Object.assign( AnimationClip, { } - const clip = new AnimationClip( json.name, json.duration, tracks, json.blendMode ); + const clip = new this( json.name, json.duration, tracks, json.blendMode ); clip.uuid = json.uuid; return clip; - }, + } - toJSON: function ( clip ) { + static toJSON( clip ) { const tracks = [], clipTracks = clip.tracks; @@ -148,9 +72,9 @@ Object.assign( AnimationClip, { return json; - }, + } - CreateFromMorphTargetSequence: function ( name, morphTargetSequence, fps, noLoop ) { + static CreateFromMorphTargetSequence( name, morphTargetSequence, fps, noLoop ) { const numMorphTargets = morphTargetSequence.length; const tracks = []; @@ -188,11 +112,11 @@ Object.assign( AnimationClip, { } - return new AnimationClip( name, - 1, tracks ); + return new this( name, - 1, tracks ); - }, + } - findByName: function ( objectOrClipArray, name ) { + static findByName( objectOrClipArray, name ) { let clipArray = objectOrClipArray; @@ -215,9 +139,9 @@ Object.assign( AnimationClip, { return null; - }, + } - CreateClipsFromMorphTargetSequences: function ( morphTargets, fps, noLoop ) { + static CreateClipsFromMorphTargetSequences( morphTargets, fps, noLoop ) { const animationToMorphTargets = {}; @@ -254,16 +178,16 @@ Object.assign( AnimationClip, { for ( const name in animationToMorphTargets ) { - clips.push( AnimationClip.CreateFromMorphTargetSequence( name, animationToMorphTargets[ name ], fps, noLoop ) ); + clips.push( this.CreateFromMorphTargetSequence( name, animationToMorphTargets[ name ], fps, noLoop ) ); } return clips; - }, + } // parse the animation.hierarchy format - parseAnimation: function ( animation, bones ) { + static parseAnimation( animation, bones ) { if ( ! animation ) { @@ -384,17 +308,13 @@ Object.assign( AnimationClip, { } - const clip = new AnimationClip( clipName, duration, tracks, blendMode ); + const clip = new this( clipName, duration, tracks, blendMode ); return clip; } -} ); - -Object.assign( AnimationClip.prototype, { - - resetDuration: function () { + resetDuration() { const tracks = this.tracks; let duration = 0; @@ -411,9 +331,9 @@ Object.assign( AnimationClip.prototype, { return this; - }, + } - trim: function () { + trim() { for ( let i = 0; i < this.tracks.length; i ++ ) { @@ -423,9 +343,9 @@ Object.assign( AnimationClip.prototype, { return this; - }, + } - validate: function () { + validate() { let valid = true; @@ -437,9 +357,9 @@ Object.assign( AnimationClip.prototype, { return valid; - }, + } - optimize: function () { + optimize() { for ( let i = 0; i < this.tracks.length; i ++ ) { @@ -449,9 +369,9 @@ Object.assign( AnimationClip.prototype, { return this; - }, + } - clone: function () { + clone() { const tracks = []; @@ -461,17 +381,93 @@ Object.assign( AnimationClip.prototype, { } - return new AnimationClip( this.name, this.duration, tracks, this.blendMode ); + return new this.constructor( this.name, this.duration, tracks, this.blendMode ); + + } + + toJSON() { + + return this.constructor.toJSON( this ); + + } + +} + +function getTrackTypeForValueTypeName( typeName ) { + + switch ( typeName.toLowerCase() ) { + + case 'scalar': + case 'double': + case 'float': + case 'number': + case 'integer': + + return NumberKeyframeTrack; + + case 'vector': + case 'vector2': + case 'vector3': + case 'vector4': + + return VectorKeyframeTrack; + + case 'color': + + return ColorKeyframeTrack; + + case 'quaternion': + + return QuaternionKeyframeTrack; + + case 'bool': + case 'boolean': + + return BooleanKeyframeTrack; + + case 'string': + + return StringKeyframeTrack; + + } + + throw new Error( 'THREE.KeyframeTrack: Unsupported typeName: ' + typeName ); + +} + +function parseKeyframeTrack( json ) { + + if ( json.type === undefined ) { + + throw new Error( 'THREE.KeyframeTrack: track type undefined, can not parse' ); + + } + + const trackType = getTrackTypeForValueTypeName( json.type ); - }, + if ( json.times === undefined ) { - toJSON: function () { + const times = [], values = []; - return AnimationClip.toJSON( this ); + AnimationUtils.flattenJSON( json.keys, times, values, 'value' ); + + json.times = times; + json.values = values; } -} ); + // derived classes can define a static parse method + if ( trackType.parse !== undefined ) { + return trackType.parse( json ); + + } else { + + // by default, we assume a constructor compatible with the base + return new trackType( json.name, json.times, json.values, json.interpolation ); + + } + +} export { AnimationClip }; diff --git a/src/animation/AnimationMixer.js b/src/animation/AnimationMixer.js index e812e43f30e057..53c01ce6997b2e 100644 --- a/src/animation/AnimationMixer.js +++ b/src/animation/AnimationMixer.js @@ -6,23 +6,21 @@ import { PropertyMixer } from './PropertyMixer.js'; import { AnimationClip } from './AnimationClip.js'; import { NormalAnimationBlendMode } from '../constants.js'; -function AnimationMixer( root ) { +class AnimationMixer extends EventDispatcher { - this._root = root; - this._initMemoryManager(); - this._accuIndex = 0; + constructor( root ) { - this.time = 0; + super(); - this.timeScale = 1.0; + this._root = root; + this._initMemoryManager(); + this._accuIndex = 0; + this.time = 0; + this.timeScale = 1.0; -} - -AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototype ), { - - constructor: AnimationMixer, + } - _bindAction: function ( action, prototypeAction ) { + _bindAction( action, prototypeAction ) { const root = action._localRoot || this._root, tracks = action._clip.tracks, @@ -89,9 +87,9 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy } - }, + } - _activateAction: function ( action ) { + _activateAction( action ) { if ( ! this._isActiveAction( action ) ) { @@ -131,9 +129,9 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy } - }, + } - _deactivateAction: function ( action ) { + _deactivateAction( action ) { if ( this._isActiveAction( action ) ) { @@ -157,11 +155,11 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy } - }, + } // Memory manager - _initMemoryManager: function () { + _initMemoryManager() { this._actions = []; // 'nActiveActions' followed by inactive ones this._nActiveActions = 0; @@ -226,18 +224,18 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy }; - }, + } // Memory management for AnimationAction objects - _isActiveAction: function ( action ) { + _isActiveAction( action ) { const index = action._cacheIndex; return index !== null && index < this._nActiveActions; - }, + } - _addInactiveAction: function ( action, clipUuid, rootUuid ) { + _addInactiveAction( action, clipUuid, rootUuid ) { const actions = this._actions, actionsByClip = this._actionsByClip; @@ -271,9 +269,9 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy actionsForClip.actionByRoot[ rootUuid ] = action; - }, + } - _removeInactiveAction: function ( action ) { + _removeInactiveAction( action ) { const actions = this._actions, lastInactiveAction = actions[ actions.length - 1 ], @@ -316,9 +314,9 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy this._removeInactiveBindingsForAction( action ); - }, + } - _removeInactiveBindingsForAction: function ( action ) { + _removeInactiveBindingsForAction( action ) { const bindings = action._propertyBindings; @@ -334,9 +332,9 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy } - }, + } - _lendAction: function ( action ) { + _lendAction( action ) { // [ active actions | inactive actions ] // [ active actions >| inactive actions ] @@ -357,9 +355,9 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy firstInactiveAction._cacheIndex = prevIndex; actions[ prevIndex ] = firstInactiveAction; - }, + } - _takeBackAction: function ( action ) { + _takeBackAction( action ) { // [ active actions | inactive actions ] // [ active actions |< inactive actions ] @@ -380,11 +378,11 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy lastActiveAction._cacheIndex = prevIndex; actions[ prevIndex ] = lastActiveAction; - }, + } // Memory management for PropertyMixer objects - _addInactiveBinding: function ( binding, rootUuid, trackName ) { + _addInactiveBinding( binding, rootUuid, trackName ) { const bindingsByRoot = this._bindingsByRootAndName, bindings = this._bindings; @@ -403,9 +401,9 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy binding._cacheIndex = bindings.length; bindings.push( binding ); - }, + } - _removeInactiveBinding: function ( binding ) { + _removeInactiveBinding( binding ) { const bindings = this._bindings, propBinding = binding.binding, @@ -429,9 +427,9 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy } - }, + } - _lendBinding: function ( binding ) { + _lendBinding( binding ) { const bindings = this._bindings, prevIndex = binding._cacheIndex, @@ -446,9 +444,9 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy firstInactiveBinding._cacheIndex = prevIndex; bindings[ prevIndex ] = firstInactiveBinding; - }, + } - _takeBackBinding: function ( binding ) { + _takeBackBinding( binding ) { const bindings = this._bindings, prevIndex = binding._cacheIndex, @@ -463,12 +461,12 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy lastActiveBinding._cacheIndex = prevIndex; bindings[ prevIndex ] = lastActiveBinding; - }, + } // Memory management of Interpolants for weight and time scale - _lendControlInterpolant: function () { + _lendControlInterpolant() { const interpolants = this._controlInterpolants, lastActiveIndex = this._nActiveControlInterpolants ++; @@ -488,9 +486,9 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy return interpolant; - }, + } - _takeBackControlInterpolant: function ( interpolant ) { + _takeBackControlInterpolant( interpolant ) { const interpolants = this._controlInterpolants, prevIndex = interpolant.__cacheIndex, @@ -505,14 +503,12 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy lastActiveInterpolant.__cacheIndex = prevIndex; interpolants[ prevIndex ] = lastActiveInterpolant; - }, - - _controlInterpolantsResultBuffer: new Float32Array( 1 ), + } // return an action for a clip optionally using a custom root target // object (this method allocates a lot of dynamic memory in case a // previously unknown clip/root combination is specified) - clipAction: function ( clip, optionalRoot, blendMode ) { + clipAction( clip, optionalRoot, blendMode ) { const root = optionalRoot || this._root, rootUuid = root.uuid; @@ -571,10 +567,10 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy return newAction; - }, + } // get an existing action - existingAction: function ( clip, optionalRoot ) { + existingAction( clip, optionalRoot ) { const root = optionalRoot || this._root, rootUuid = root.uuid, @@ -594,10 +590,10 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy return null; - }, + } // deactivates all previously scheduled actions - stopAllAction: function () { + stopAllAction() { const actions = this._actions, nActions = this._nActiveActions; @@ -610,10 +606,10 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy return this; - }, + } // advance the time and update apply the animation - update: function ( deltaTime ) { + update( deltaTime ) { deltaTime *= this.timeScale; @@ -648,10 +644,10 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy return this; - }, + } // Allows you to seek to a specific time in an animation. - setTime: function ( timeInSeconds ) { + setTime( timeInSeconds ) { this.time = 0; // Zero out time attribute for AnimationMixer object; for ( let i = 0; i < this._actions.length; i ++ ) { @@ -662,17 +658,17 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy return this.update( timeInSeconds ); // Update used to set exact time. Returns "this" AnimationMixer object. - }, + } // return this mixer's root target object - getRoot: function () { + getRoot() { return this._root; - }, + } // free all resources specific to a particular clip - uncacheClip: function ( clip ) { + uncacheClip( clip ) { const actions = this._actions, clipUuid = clip.uuid, @@ -711,10 +707,10 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy } - }, + } // free all resources specific to a particular root target object - uncacheRoot: function ( root ) { + uncacheRoot( root ) { const rootUuid = root.uuid, actionsByClip = this._actionsByClip; @@ -748,10 +744,10 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy } - }, + } // remove a targeted clip from the cache - uncacheAction: function ( clip, optionalRoot ) { + uncacheAction( clip, optionalRoot ) { const action = this.existingAction( clip, optionalRoot ); @@ -764,7 +760,8 @@ AnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototy } -} ); +} +AnimationMixer.prototype._controlInterpolantsResultBuffer = new Float32Array( 1 ); export { AnimationMixer }; diff --git a/src/animation/AnimationObjectGroup.js b/src/animation/AnimationObjectGroup.js index b5da1cb5614625..97040d6c82b0ed 100644 --- a/src/animation/AnimationObjectGroup.js +++ b/src/animation/AnimationObjectGroup.js @@ -30,61 +30,59 @@ import { MathUtils } from '../math/MathUtils.js'; * target group or directly, but not both. */ -function AnimationObjectGroup() { +class AnimationObjectGroup { - this.uuid = MathUtils.generateUUID(); + constructor() { - // cached objects followed by the active ones - this._objects = Array.prototype.slice.call( arguments ); + this.uuid = MathUtils.generateUUID(); - this.nCachedObjects_ = 0; // threshold - // note: read by PropertyBinding.Composite + // cached objects followed by the active ones + this._objects = Array.prototype.slice.call( arguments ); - const indices = {}; - this._indicesByUUID = indices; // for bookkeeping + this.nCachedObjects_ = 0; // threshold + // note: read by PropertyBinding.Composite - for ( let i = 0, n = arguments.length; i !== n; ++ i ) { + const indices = {}; + this._indicesByUUID = indices; // for bookkeeping - indices[ arguments[ i ].uuid ] = i; + for ( let i = 0, n = arguments.length; i !== n; ++ i ) { - } + indices[ arguments[ i ].uuid ] = i; - this._paths = []; // inside: string - this._parsedPaths = []; // inside: { we don't care, here } - this._bindings = []; // inside: Array< PropertyBinding > - this._bindingsIndicesByPath = {}; // inside: indices in these arrays + } - const scope = this; + this._paths = []; // inside: string + this._parsedPaths = []; // inside: { we don't care, here } + this._bindings = []; // inside: Array< PropertyBinding > + this._bindingsIndicesByPath = {}; // inside: indices in these arrays - this.stats = { + const scope = this; - objects: { - get total() { + this.stats = { - return scope._objects.length; + objects: { + get total() { - }, - get inUse() { + return scope._objects.length; - return this.total - scope.nCachedObjects_; + }, + get inUse() { - } - }, - get bindingsPerObject() { + return this.total - scope.nCachedObjects_; - return scope._bindings.length; - - } + } + }, + get bindingsPerObject() { - }; + return scope._bindings.length; -} + } -Object.assign( AnimationObjectGroup.prototype, { + }; - isAnimationObjectGroup: true, + } - add: function () { + add() { const objects = this._objects, indicesByUUID = this._indicesByUUID, @@ -170,9 +168,9 @@ Object.assign( AnimationObjectGroup.prototype, { this.nCachedObjects_ = nCachedObjects; - }, + } - remove: function () { + remove() { const objects = this._objects, indicesByUUID = this._indicesByUUID, @@ -219,10 +217,10 @@ Object.assign( AnimationObjectGroup.prototype, { this.nCachedObjects_ = nCachedObjects; - }, + } // remove & forget - uncache: function () { + uncache() { const objects = this._objects, indicesByUUID = this._indicesByUUID, @@ -309,11 +307,11 @@ Object.assign( AnimationObjectGroup.prototype, { this.nCachedObjects_ = nCachedObjects; - }, + } // Internal interface used by befriended PropertyBinding.Composite: - subscribe_: function ( path, parsedPath ) { + subscribe_( path, parsedPath ) { // returns an array of bindings for the given path that is changed // according to the contained objects in the group @@ -348,9 +346,9 @@ Object.assign( AnimationObjectGroup.prototype, { return bindingsForPath; - }, + } - unsubscribe_: function ( path ) { + unsubscribe_( path ) { // tells the group to forget about a property path and no longer // update the array previously obtained with 'subscribe_' @@ -382,7 +380,8 @@ Object.assign( AnimationObjectGroup.prototype, { } -} ); +} +AnimationObjectGroup.prototype.isAnimationObjectGroup = true; export { AnimationObjectGroup }; diff --git a/src/animation/PropertyMixer.js b/src/animation/PropertyMixer.js index 51ba3f4dc450e2..751c90d7e1b979 100644 --- a/src/animation/PropertyMixer.js +++ b/src/animation/PropertyMixer.js @@ -1,81 +1,81 @@ import { Quaternion } from '../math/Quaternion.js'; -function PropertyMixer( binding, typeName, valueSize ) { - - this.binding = binding; - this.valueSize = valueSize; - - let mixFunction, - mixFunctionAdditive, - setIdentity; - - // buffer layout: [ incoming | accu0 | accu1 | orig | addAccu | (optional work) ] - // - // interpolators can use .buffer as their .result - // the data then goes to 'incoming' - // - // 'accu0' and 'accu1' are used frame-interleaved for - // the cumulative result and are compared to detect - // changes - // - // 'orig' stores the original state of the property - // - // 'add' is used for additive cumulative results - // - // 'work' is optional and is only present for quaternion types. It is used - // to store intermediate quaternion multiplication results - - switch ( typeName ) { - - case 'quaternion': - mixFunction = this._slerp; - mixFunctionAdditive = this._slerpAdditive; - setIdentity = this._setAdditiveIdentityQuaternion; - - this.buffer = new Float64Array( valueSize * 6 ); - this._workIndex = 5; - break; - - case 'string': - case 'bool': - mixFunction = this._select; - - // Use the regular mix function and for additive on these types, - // additive is not relevant for non-numeric types - mixFunctionAdditive = this._select; - - setIdentity = this._setAdditiveIdentityOther; - - this.buffer = new Array( valueSize * 5 ); - break; - - default: - mixFunction = this._lerp; - mixFunctionAdditive = this._lerpAdditive; - setIdentity = this._setAdditiveIdentityNumeric; - - this.buffer = new Float64Array( valueSize * 5 ); +class PropertyMixer { + + constructor( binding, typeName, valueSize ) { + + this.binding = binding; + this.valueSize = valueSize; + + let mixFunction, + mixFunctionAdditive, + setIdentity; + + // buffer layout: [ incoming | accu0 | accu1 | orig | addAccu | (optional work) ] + // + // interpolators can use .buffer as their .result + // the data then goes to 'incoming' + // + // 'accu0' and 'accu1' are used frame-interleaved for + // the cumulative result and are compared to detect + // changes + // + // 'orig' stores the original state of the property + // + // 'add' is used for additive cumulative results + // + // 'work' is optional and is only present for quaternion types. It is used + // to store intermediate quaternion multiplication results + + switch ( typeName ) { + + case 'quaternion': + mixFunction = this._slerp; + mixFunctionAdditive = this._slerpAdditive; + setIdentity = this._setAdditiveIdentityQuaternion; + + this.buffer = new Float64Array( valueSize * 6 ); + this._workIndex = 5; + break; - } + case 'string': + case 'bool': + mixFunction = this._select; - this._mixBufferRegion = mixFunction; - this._mixBufferRegionAdditive = mixFunctionAdditive; - this._setIdentity = setIdentity; - this._origIndex = 3; - this._addIndex = 4; + // Use the regular mix function and for additive on these types, + // additive is not relevant for non-numeric types + mixFunctionAdditive = this._select; - this.cumulativeWeight = 0; - this.cumulativeWeightAdditive = 0; + setIdentity = this._setAdditiveIdentityOther; - this.useCount = 0; - this.referenceCount = 0; + this.buffer = new Array( valueSize * 5 ); + break; -} + default: + mixFunction = this._lerp; + mixFunctionAdditive = this._lerpAdditive; + setIdentity = this._setAdditiveIdentityNumeric; + + this.buffer = new Float64Array( valueSize * 5 ); + + } -Object.assign( PropertyMixer.prototype, { + this._mixBufferRegion = mixFunction; + this._mixBufferRegionAdditive = mixFunctionAdditive; + this._setIdentity = setIdentity; + this._origIndex = 3; + this._addIndex = 4; + + this.cumulativeWeight = 0; + this.cumulativeWeightAdditive = 0; + + this.useCount = 0; + this.referenceCount = 0; + + } // accumulate data in the 'incoming' region into 'accu' - accumulate: function ( accuIndex, weight ) { + accumulate( accuIndex, weight ) { // note: happily accumulating nothing when weight = 0, the caller knows // the weight and shouldn't have made the call in the first place @@ -110,10 +110,10 @@ Object.assign( PropertyMixer.prototype, { this.cumulativeWeight = currentWeight; - }, + } // accumulate data in the 'incoming' region into 'add' - accumulateAdditive: function ( weight ) { + accumulateAdditive( weight ) { const buffer = this.buffer, stride = this.valueSize, @@ -132,10 +132,10 @@ Object.assign( PropertyMixer.prototype, { this._mixBufferRegionAdditive( buffer, offset, 0, weight, stride ); this.cumulativeWeightAdditive += weight; - }, + } // apply the state of 'accu' to the binding when accus differ - apply: function ( accuIndex ) { + apply( accuIndex ) { const stride = this.valueSize, buffer = this.buffer, @@ -181,10 +181,10 @@ Object.assign( PropertyMixer.prototype, { } - }, + } // remember the state of the bound property and copy it to both accus - saveOriginalState: function () { + saveOriginalState() { const binding = this.binding; @@ -208,17 +208,17 @@ Object.assign( PropertyMixer.prototype, { this.cumulativeWeight = 0; this.cumulativeWeightAdditive = 0; - }, + } // apply the state previously taken via 'saveOriginalState' to the binding - restoreOriginalState: function () { + restoreOriginalState() { const originalValueOffset = this.valueSize * 3; this.binding.setValue( this.buffer, originalValueOffset ); - }, + } - _setAdditiveIdentityNumeric: function () { + _setAdditiveIdentityNumeric() { const startIndex = this._addIndex * this.valueSize; const endIndex = startIndex + this.valueSize; @@ -229,16 +229,16 @@ Object.assign( PropertyMixer.prototype, { } - }, + } - _setAdditiveIdentityQuaternion: function () { + _setAdditiveIdentityQuaternion() { this._setAdditiveIdentityNumeric(); this.buffer[ this._addIndex * this.valueSize + 3 ] = 1; - }, + } - _setAdditiveIdentityOther: function () { + _setAdditiveIdentityOther() { const startIndex = this._origIndex * this.valueSize; const targetIndex = this._addIndex * this.valueSize; @@ -249,12 +249,12 @@ Object.assign( PropertyMixer.prototype, { } - }, + } // mix functions - _select: function ( buffer, dstOffset, srcOffset, t, stride ) { + _select( buffer, dstOffset, srcOffset, t, stride ) { if ( t >= 0.5 ) { @@ -266,15 +266,15 @@ Object.assign( PropertyMixer.prototype, { } - }, + } - _slerp: function ( buffer, dstOffset, srcOffset, t ) { + _slerp( buffer, dstOffset, srcOffset, t ) { Quaternion.slerpFlat( buffer, dstOffset, buffer, dstOffset, buffer, srcOffset, t ); - }, + } - _slerpAdditive: function ( buffer, dstOffset, srcOffset, t, stride ) { + _slerpAdditive( buffer, dstOffset, srcOffset, t, stride ) { const workOffset = this._workIndex * stride; @@ -284,9 +284,9 @@ Object.assign( PropertyMixer.prototype, { // Slerp to the intermediate result Quaternion.slerpFlat( buffer, dstOffset, buffer, dstOffset, buffer, workOffset, t ); - }, + } - _lerp: function ( buffer, dstOffset, srcOffset, t, stride ) { + _lerp( buffer, dstOffset, srcOffset, t, stride ) { const s = 1 - t; @@ -298,9 +298,9 @@ Object.assign( PropertyMixer.prototype, { } - }, + } - _lerpAdditive: function ( buffer, dstOffset, srcOffset, t, stride ) { + _lerpAdditive( buffer, dstOffset, srcOffset, t, stride ) { for ( let i = 0; i !== stride; ++ i ) { @@ -312,7 +312,7 @@ Object.assign( PropertyMixer.prototype, { } -} ); +} export { PropertyMixer };