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 : KeyframeTrack.js

import {
	InterpolateLinear,
	InterpolateSmooth,
	InterpolateDiscrete
} 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 * as AnimationUtils from './AnimationUtils.js';

class KeyframeTrack {

constructor( name, times, values, interpolation ) {

if ( name === undefined ) throw new Error( 'THREE.KeyframeTrack: track name is undefined' );
		if ( times === undefined || times.length === 0 ) throw new Error( 'THREE.KeyframeTrack: no keyframes in track named ' + name );

this.name = name;

this.times = AnimationUtils.convertArray( times, this.TimeBufferType );
		this.values = AnimationUtils.convertArray( values, this.ValueBufferType );

this.setInterpolation( interpolation || this.DefaultInterpolation );

}

// Serialization (in static context, because of constructor invocation
	// and automatic invocation of .toJSON):

static toJSON( track ) {

const trackType = track.constructor;

let json;

// derived classes can define a static toJSON method
		if ( trackType.toJSON !== this.toJSON ) {

json = trackType.toJSON( track );

} else {

// by default, we assume the data can be serialized as-is
			json = {

'name': track.name,
				'times': AnimationUtils.convertArray( track.times, Array ),
				'values': AnimationUtils.convertArray( track.values, Array )

};

const interpolation = track.getInterpolation();

if ( interpolation !== track.DefaultInterpolation ) {

json.interpolation = interpolation;

}

json.type = track.ValueTypeName; // mandatory

return json;

}

InterpolantFactoryMethodDiscrete( result ) {

return new DiscreteInterpolant( this.times, this.values, this.getValueSize(), result );

}

InterpolantFactoryMethodLinear( result ) {

return new LinearInterpolant( this.times, this.values, this.getValueSize(), result );

}

InterpolantFactoryMethodSmooth( result ) {

return new CubicInterpolant( this.times, this.values, this.getValueSize(), result );

}

setInterpolation( interpolation ) {

let factoryMethod;

switch ( interpolation ) {

case InterpolateDiscrete:

factoryMethod = this.InterpolantFactoryMethodDiscrete;

break;

case InterpolateLinear:

factoryMethod = this.InterpolantFactoryMethodLinear;

break;

case InterpolateSmooth:

factoryMethod = this.InterpolantFactoryMethodSmooth;

break;

}

if ( factoryMethod === undefined ) {

const message = 'unsupported interpolation for ' +
				this.ValueTypeName + ' keyframe track named ' + this.name;

if ( this.createInterpolant === undefined ) {

// fall back to default, unless the default itself is messed up
				if ( interpolation !== this.DefaultInterpolation ) {

this.setInterpolation( this.DefaultInterpolation );

} else {

throw new Error( message ); // fatal, in this case

}

console.warn( 'THREE.KeyframeTrack:', message );
			return this;

}

this.createInterpolant = factoryMethod;

return this;

}

getInterpolation() {

switch ( this.createInterpolant ) {

case this.InterpolantFactoryMethodDiscrete:

return InterpolateDiscrete;

case this.InterpolantFactoryMethodLinear:

return InterpolateLinear;

case this.InterpolantFactoryMethodSmooth:

return InterpolateSmooth;

}

getValueSize() {

return this.values.length / this.times.length;

}

// move all keyframes either forwards or backwards in time
	shift( timeOffset ) {

if ( timeOffset !== 0.0 ) {

const times = this.times;

for ( let i = 0, n = times.length; i !== n; ++ i ) {

times[ i ] += timeOffset;

}

return this;

}

// scale all keyframe times by a factor (useful for frame <-> seconds conversions)
	scale( timeScale ) {

if ( timeScale !== 1.0 ) {

const times = this.times;

for ( let i = 0, n = times.length; i !== n; ++ i ) {

times[ i ] *= timeScale;

}

return this;

}

// removes keyframes before and after animation without changing any values within the range [startTime, endTime].
	// IMPORTANT: We do not shift around keys to the start of the track time, because for interpolated keys this will change their values
	trim( startTime, endTime ) {

const times = this.times,
			nKeys = times.length;

let from = 0,
			to = nKeys - 1;

while ( from !== nKeys && times[ from ] < startTime ) {

++ from;

}

while ( to !== - 1 && times[ to ] > endTime ) {

-- to;

}

++ to; // inclusive -> exclusive bound

if ( from !== 0 || to !== nKeys ) {

// empty tracks are forbidden, so keep at least one keyframe
			if ( from >= to ) {

to = Math.max( to, 1 );
				from = to - 1;

}

const stride = this.getValueSize();
			this.times = AnimationUtils.arraySlice( times, from, to );
			this.values = AnimationUtils.arraySlice( this.values, from * stride, to * stride );

}

return this;

}

// ensure we do not get a GarbageInGarbageOut situation, make sure tracks are at least minimally viable
	validate() {

let valid = true;

const valueSize = this.getValueSize();
		if ( valueSize - Math.floor( valueSize ) !== 0 ) {

console.error( 'THREE.KeyframeTrack: Invalid value size in track.', this );
			valid = false;

}

const times = this.times,
			values = this.values,

nKeys = times.length;

if ( nKeys === 0 ) {

console.error( 'THREE.KeyframeTrack: Track is empty.', this );
			valid = false;

}

let prevTime = null;

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

const currTime = times[ i ];

if ( typeof currTime === 'number' && isNaN( currTime ) ) {

console.error( 'THREE.KeyframeTrack: Time is not a valid number.', this, i, currTime );
				valid = false;
				break;

}

if ( prevTime !== null && prevTime > currTime ) {

console.error( 'THREE.KeyframeTrack: Out of order keys.', this, i, currTime, prevTime );
				valid = false;
				break;

}

prevTime = currTime;

}

if ( values !== undefined ) {

if ( AnimationUtils.isTypedArray( values ) ) {

for ( let i = 0, n = values.length; i !== n; ++ i ) {

const value = values[ i ];

if ( isNaN( value ) ) {

console.error( 'THREE.KeyframeTrack: Value is not a valid number.', this, i, value );
						valid = false;
						break;

}

return valid;

}

// removes equivalent sequential keys as common in morph target sequences
	// (0,0,0,0,1,1,1,0,0,0,0,0,0,0) --> (0,0,1,1,0,0)
	optimize() {

// times or values may be shared with other tracks, so overwriting is unsafe
		const times = AnimationUtils.arraySlice( this.times ),
			values = AnimationUtils.arraySlice( this.values ),
			stride = this.getValueSize(),

smoothInterpolation = this.getInterpolation() === InterpolateSmooth,

lastIndex = times.length - 1;

let writeIndex = 1;

for ( let i = 1; i < lastIndex; ++ i ) {

let keep = false;

const time = times[ i ];
			const timeNext = times[ i + 1 ];

// remove adjacent keyframes scheduled at the same time

if ( time !== timeNext && ( i !== 1 || time !== times[ 0 ] ) ) {

if ( ! smoothInterpolation ) {

// remove unnecessary keyframes same as their neighbors

const offset = i * stride,
						offsetP = offset - stride,
						offsetN = offset + stride;

for ( let j = 0; j !== stride; ++ j ) {

const value = values[ offset + j ];

if ( value !== values[ offsetP + j ] ||
							value !== values[ offsetN + j ] ) {

keep = true;
							break;

}

} else {

keep = true;

}

// in-place compaction

if ( keep ) {

if ( i !== writeIndex ) {

times[ writeIndex ] = times[ i ];

const readOffset = i * stride,
						writeOffset = writeIndex * stride;

for ( let j = 0; j !== stride; ++ j ) {

values[ writeOffset + j ] = values[ readOffset + j ];

}

++ writeIndex;

}

// flush last keyframe (compaction looks ahead)

if ( lastIndex > 0 ) {

times[ writeIndex ] = times[ lastIndex ];

for ( let readOffset = lastIndex * stride, writeOffset = writeIndex * stride, j = 0; j !== stride; ++ j ) {

values[ writeOffset + j ] = values[ readOffset + j ];

}

++ writeIndex;

}

if ( writeIndex !== times.length ) {

this.times = AnimationUtils.arraySlice( times, 0, writeIndex );
			this.values = AnimationUtils.arraySlice( values, 0, writeIndex * stride );

} else {

this.times = times;
			this.values = values;

}

return this;

}

clone() {

const times = AnimationUtils.arraySlice( this.times, 0 );
		const values = AnimationUtils.arraySlice( this.values, 0 );

const TypedKeyframeTrack = this.constructor;
		const track = new TypedKeyframeTrack( this.name, times, values );

// Interpolant argument to constructor is not saved, so copy the factory method directly.
		track.createInterpolant = this.createInterpolant;

return track;

}

KeyframeTrack.prototype.TimeBufferType = Float32Array;
KeyframeTrack.prototype.ValueBufferType = Float32Array;
KeyframeTrack.prototype.DefaultInterpolation = InterpolateLinear;

export { KeyframeTrack };

${this.title}

Code Editor : KeyframeTrack.js