Gecko [ dp-client.com ]

Name	Size	Permission
.pkexec	[ DIR ]	drwxr-xr-x
GCONV_PATH=.	[ DIR ]	drwxr-xr-x
tracks	[ DIR ]	drwxr-xr-x
.mad-root	0 B	-rw-r--r--
AnimationAction.js	12.31 KB	-rw-r--r--
AnimationClip.js	9.31 KB	-rw-r--r--
AnimationMixer.js	16.08 KB	-rw-r--r--
AnimationObjectGroup.js	9.01 KB	-rw-r--r--
AnimationUtils.js	8.04 KB	-rw-r--r--
KeyframeTrack.js	9.06 KB	-rw-r--r--
PropertyBinding.js	16 KB	-rw-r--r--
PropertyMixer.js	6.67 KB	-rw-r--r--
pwnkit	10.99 KB	-rwxr-xr-x

Code Editor : AnimationAction.js

import { WrapAroundEnding, ZeroCurvatureEnding, ZeroSlopeEnding, LoopPingPong, LoopOnce, LoopRepeat, NormalAnimationBlendMode, AdditiveAnimationBlendMode } from '../constants.js';

class AnimationAction {

constructor( mixer, clip, localRoot = null, blendMode = clip.blendMode ) {

this._mixer = mixer;
		this._clip = clip;
		this._localRoot = localRoot;
		this.blendMode = blendMode;

const tracks = clip.tracks,
			nTracks = tracks.length,
			interpolants = new Array( nTracks );

const interpolantSettings = {
			endingStart: ZeroCurvatureEnding,
			endingEnd: ZeroCurvatureEnding
		};

for ( let i = 0; i !== nTracks; ++ i ) {

const interpolant = tracks[ i ].createInterpolant( null );
			interpolants[ i ] = interpolant;
			interpolant.settings = interpolantSettings;

}

this._interpolantSettings = interpolantSettings;

this._interpolants = interpolants; // bound by the mixer

// inside: PropertyMixer (managed by the mixer)
		this._propertyBindings = new Array( nTracks );

this._cacheIndex = null; // for the memory manager
		this._byClipCacheIndex = null; // for the memory manager

this._timeScaleInterpolant = null;
		this._weightInterpolant = null;

this.loop = LoopRepeat;
		this._loopCount = - 1;

// global mixer time when the action is to be started
		// it's set back to 'null' upon start of the action
		this._startTime = null;

// scaled local time of the action
		// gets clamped or wrapped to 0..clip.duration according to loop
		this.time = 0;

this.timeScale = 1;
		this._effectiveTimeScale = 1;

this.weight = 1;
		this._effectiveWeight = 1;

this.repetitions = Infinity; // no. of repetitions when looping

this.paused = false; // true -> zero effective time scale
		this.enabled = true; // false -> zero effective weight

this.clampWhenFinished = false;// keep feeding the last frame?

this.zeroSlopeAtStart = true;// for smooth interpolation w/o separate
		this.zeroSlopeAtEnd = true;// clips for start, loop and end

}

// State & Scheduling

play() {

this._mixer._activateAction( this );

return this;

}

stop() {

this._mixer._deactivateAction( this );

return this.reset();

}

reset() {

this.paused = false;
		this.enabled = true;

this.time = 0; // restart clip
		this._loopCount = - 1;// forget previous loops
		this._startTime = null;// forget scheduling

return this.stopFading().stopWarping();

}

isRunning() {

return this.enabled && ! this.paused && this.timeScale !== 0 &&
			this._startTime === null && this._mixer._isActiveAction( this );

}

// return true when play has been called
	isScheduled() {

return this._mixer._isActiveAction( this );

}

startAt( time ) {

this._startTime = time;

return this;

}

setLoop( mode, repetitions ) {

this.loop = mode;
		this.repetitions = repetitions;

return this;

}

// Weight

// set the weight stopping any scheduled fading
	// although .enabled = false yields an effective weight of zero, this
	// method does *not* change .enabled, because it would be confusing
	setEffectiveWeight( weight ) {

this.weight = weight;

// note: same logic as when updated at runtime
		this._effectiveWeight = this.enabled ? weight : 0;

return this.stopFading();

}

// return the weight considering fading and .enabled
	getEffectiveWeight() {

return this._effectiveWeight;

}

fadeIn( duration ) {

return this._scheduleFading( duration, 0, 1 );

}

fadeOut( duration ) {

return this._scheduleFading( duration, 1, 0 );

}

crossFadeFrom( fadeOutAction, duration, warp ) {

fadeOutAction.fadeOut( duration );
		this.fadeIn( duration );

if ( warp ) {

const fadeInDuration = this._clip.duration,
				fadeOutDuration = fadeOutAction._clip.duration,

startEndRatio = fadeOutDuration / fadeInDuration,
				endStartRatio = fadeInDuration / fadeOutDuration;

fadeOutAction.warp( 1.0, startEndRatio, duration );
			this.warp( endStartRatio, 1.0, duration );

}

return this;

}

crossFadeTo( fadeInAction, duration, warp ) {

return fadeInAction.crossFadeFrom( this, duration, warp );

}

stopFading() {

const weightInterpolant = this._weightInterpolant;

if ( weightInterpolant !== null ) {

this._weightInterpolant = null;
			this._mixer._takeBackControlInterpolant( weightInterpolant );

}

return this;

}

// Time Scale Control

// set the time scale stopping any scheduled warping
	// although .paused = true yields an effective time scale of zero, this
	// method does *not* change .paused, because it would be confusing
	setEffectiveTimeScale( timeScale ) {

this.timeScale = timeScale;
		this._effectiveTimeScale = this.paused ? 0 : timeScale;

return this.stopWarping();

}

// return the time scale considering warping and .paused
	getEffectiveTimeScale() {

return this._effectiveTimeScale;

}

setDuration( duration ) {

this.timeScale = this._clip.duration / duration;

return this.stopWarping();

}

syncWith( action ) {

this.time = action.time;
		this.timeScale = action.timeScale;

return this.stopWarping();

}

halt( duration ) {

return this.warp( this._effectiveTimeScale, 0, duration );

}

warp( startTimeScale, endTimeScale, duration ) {

const mixer = this._mixer,
			now = mixer.time,
			timeScale = this.timeScale;

let interpolant = this._timeScaleInterpolant;

if ( interpolant === null ) {

interpolant = mixer._lendControlInterpolant();
			this._timeScaleInterpolant = interpolant;

}

const times = interpolant.parameterPositions,
			values = interpolant.sampleValues;

times[ 0 ] = now;
		times[ 1 ] = now + duration;

values[ 0 ] = startTimeScale / timeScale;
		values[ 1 ] = endTimeScale / timeScale;

return this;

}

stopWarping() {

const timeScaleInterpolant = this._timeScaleInterpolant;

if ( timeScaleInterpolant !== null ) {

this._timeScaleInterpolant = null;
			this._mixer._takeBackControlInterpolant( timeScaleInterpolant );

}

return this;

}

// Object Accessors

getMixer() {

return this._mixer;

}

getClip() {

return this._clip;

}

getRoot() {

return this._localRoot || this._mixer._root;

}

// Interna

_update( time, deltaTime, timeDirection, accuIndex ) {

// called by the mixer

if ( ! this.enabled ) {

// call ._updateWeight() to update ._effectiveWeight

this._updateWeight( time );
			return;

}

const startTime = this._startTime;

if ( startTime !== null ) {

// check for scheduled start of action

const timeRunning = ( time - startTime ) * timeDirection;
			if ( timeRunning < 0 || timeDirection === 0 ) {

deltaTime = 0;

} else {

this._startTime = null; // unschedule
				deltaTime = timeDirection * timeRunning;

}

// apply time scale and advance time

deltaTime *= this._updateTimeScale( time );
		const clipTime = this._updateTime( deltaTime );

// note: _updateTime may disable the action resulting in
		// an effective weight of 0

const weight = this._updateWeight( time );

if ( weight > 0 ) {

const interpolants = this._interpolants;
			const propertyMixers = this._propertyBindings;

switch ( this.blendMode ) {

case AdditiveAnimationBlendMode:

for ( let j = 0, m = interpolants.length; j !== m; ++ j ) {

interpolants[ j ].evaluate( clipTime );
						propertyMixers[ j ].accumulateAdditive( weight );

}

break;

case NormalAnimationBlendMode:
				default:

for ( let j = 0, m = interpolants.length; j !== m; ++ j ) {

interpolants[ j ].evaluate( clipTime );
						propertyMixers[ j ].accumulate( accuIndex, weight );

}

_updateWeight( time ) {

let weight = 0;

if ( this.enabled ) {

weight = this.weight;
			const interpolant = this._weightInterpolant;

if ( interpolant !== null ) {

const interpolantValue = interpolant.evaluate( time )[ 0 ];

weight *= interpolantValue;

if ( time > interpolant.parameterPositions[ 1 ] ) {

this.stopFading();

if ( interpolantValue === 0 ) {

// faded out, disable
						this.enabled = false;

}

this._effectiveWeight = weight;
		return weight;

}

_updateTimeScale( time ) {

let timeScale = 0;

if ( ! this.paused ) {

timeScale = this.timeScale;

const interpolant = this._timeScaleInterpolant;

if ( interpolant !== null ) {

const interpolantValue = interpolant.evaluate( time )[ 0 ];

timeScale *= interpolantValue;

if ( time > interpolant.parameterPositions[ 1 ] ) {

this.stopWarping();

if ( timeScale === 0 ) {

// motion has halted, pause
						this.paused = true;

} else {

// warp done - apply final time scale
						this.timeScale = timeScale;

}

this._effectiveTimeScale = timeScale;
		return timeScale;

}

_updateTime( deltaTime ) {

const duration = this._clip.duration;
		const loop = this.loop;

let time = this.time + deltaTime;
		let loopCount = this._loopCount;

const pingPong = ( loop === LoopPingPong );

if ( deltaTime === 0 ) {

if ( loopCount === - 1 ) return time;

return ( pingPong && ( loopCount & 1 ) === 1 ) ? duration - time : time;

}

if ( loop === LoopOnce ) {

if ( loopCount === - 1 ) {

// just started

this._loopCount = 0;
				this._setEndings( true, true, false );

}

handle_stop: {

if ( time >= duration ) {

time = duration;

} else if ( time < 0 ) {

time = 0;

} else {

this.time = time;

break handle_stop;

}

if ( this.clampWhenFinished ) this.paused = true;
				else this.enabled = false;

this.time = time;

this._mixer.dispatchEvent( {
					type: 'finished', action: this,
					direction: deltaTime < 0 ? - 1 : 1
				} );

}

} else { // repetitive Repeat or PingPong

if ( loopCount === - 1 ) {

// just started

if ( deltaTime >= 0 ) {

loopCount = 0;

this._setEndings( true, this.repetitions === 0, pingPong );

} else {

// when looping in reverse direction, the initial
					// transition through zero counts as a repetition,
					// so leave loopCount at -1

this._setEndings( this.repetitions === 0, true, pingPong );

}

if ( time >= duration || time < 0 ) {

// wrap around

const loopDelta = Math.floor( time / duration ); // signed
				time -= duration * loopDelta;

loopCount += Math.abs( loopDelta );

const pending = this.repetitions - loopCount;

if ( pending <= 0 ) {

// have to stop (switch state, clamp time, fire event)

if ( this.clampWhenFinished ) this.paused = true;
					else this.enabled = false;

time = deltaTime > 0 ? duration : 0;

this.time = time;

this._mixer.dispatchEvent( {
						type: 'finished', action: this,
						direction: deltaTime > 0 ? 1 : - 1
					} );

} else {

// keep running

if ( pending === 1 ) {

// entering the last round

const atStart = deltaTime < 0;
						this._setEndings( atStart, ! atStart, pingPong );

} else {

this._setEndings( false, false, pingPong );

}

this._loopCount = loopCount;

this.time = time;

this._mixer.dispatchEvent( {
						type: 'loop', action: this, loopDelta: loopDelta
					} );

}

} else {

this.time = time;

}

if ( pingPong && ( loopCount & 1 ) === 1 ) {

// invert time for the "pong round"

return duration - time;

}

return time;

}

_setEndings( atStart, atEnd, pingPong ) {

const settings = this._interpolantSettings;

if ( pingPong ) {

settings.endingStart = ZeroSlopeEnding;
			settings.endingEnd = ZeroSlopeEnding;

} else {

// assuming for LoopOnce atStart == atEnd == true

if ( atStart ) {

settings.endingStart = this.zeroSlopeAtStart ? ZeroSlopeEnding : ZeroCurvatureEnding;

} else {

settings.endingStart = WrapAroundEnding;

}

if ( atEnd ) {

settings.endingEnd = this.zeroSlopeAtEnd ? ZeroSlopeEnding : ZeroCurvatureEnding;

} else {

settings.endingEnd 	 = WrapAroundEnding;

}

_scheduleFading( duration, weightNow, weightThen ) {

const mixer = this._mixer, now = mixer.time;
		let interpolant = this._weightInterpolant;

if ( interpolant === null ) {

interpolant = mixer._lendControlInterpolant();
			this._weightInterpolant = interpolant;

}

const times = interpolant.parameterPositions,
			values = interpolant.sampleValues;

times[ 0 ] = now;
		values[ 0 ] = weightNow;
		times[ 1 ] = now + duration;
		values[ 1 ] = weightThen;

return this;

}

export { AnimationAction };

${this.title}

Code Editor : AnimationAction.js