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

import { Quaternion } from '../math/Quaternion.js';

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;

// 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 );

}

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<i>'
	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

const buffer = this.buffer,
			stride = this.valueSize,
			offset = accuIndex * stride + stride;

let currentWeight = this.cumulativeWeight;

if ( currentWeight === 0 ) {

// accuN := incoming * weight

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

buffer[ offset + i ] = buffer[ i ];

}

currentWeight = weight;

} else {

// accuN := accuN + incoming * weight

currentWeight += weight;
			const mix = weight / currentWeight;
			this._mixBufferRegion( buffer, offset, 0, mix, stride );

}

this.cumulativeWeight = currentWeight;

}

// accumulate data in the 'incoming' region into 'add'
	accumulateAdditive( weight ) {

const buffer = this.buffer,
			stride = this.valueSize,
			offset = stride * this._addIndex;

if ( this.cumulativeWeightAdditive === 0 ) {

// add = identity

this._setIdentity();

}

// add := add + incoming * weight

this._mixBufferRegionAdditive( buffer, offset, 0, weight, stride );
		this.cumulativeWeightAdditive += weight;

}

// apply the state of 'accu<i>' to the binding when accus differ
	apply( accuIndex ) {

const stride = this.valueSize,
			buffer = this.buffer,
			offset = accuIndex * stride + stride,

weight = this.cumulativeWeight,
			weightAdditive = this.cumulativeWeightAdditive,

binding = this.binding;

this.cumulativeWeight = 0;
		this.cumulativeWeightAdditive = 0;

if ( weight < 1 ) {

// accuN := accuN + original * ( 1 - cumulativeWeight )

const originalValueOffset = stride * this._origIndex;

this._mixBufferRegion(
				buffer, offset, originalValueOffset, 1 - weight, stride );

}

if ( weightAdditive > 0 ) {

// accuN := accuN + additive accuN

this._mixBufferRegionAdditive( buffer, offset, this._addIndex * stride, 1, stride );

}

for ( let i = stride, e = stride + stride; i !== e; ++ i ) {

if ( buffer[ i ] !== buffer[ i + stride ] ) {

// value has changed -> update scene graph

binding.setValue( buffer, offset );
				break;

}

// remember the state of the bound property and copy it to both accus
	saveOriginalState() {

const binding = this.binding;

const buffer = this.buffer,
			stride = this.valueSize,

originalValueOffset = stride * this._origIndex;

binding.getValue( buffer, originalValueOffset );

// accu[0..1] := orig -- initially detect changes against the original
		for ( let i = stride, e = originalValueOffset; i !== e; ++ i ) {

buffer[ i ] = buffer[ originalValueOffset + ( i % stride ) ];

}

// Add to identity for additive
		this._setIdentity();

this.cumulativeWeight = 0;
		this.cumulativeWeightAdditive = 0;

}

// apply the state previously taken via 'saveOriginalState' to the binding
	restoreOriginalState() {

const originalValueOffset = this.valueSize * 3;
		this.binding.setValue( this.buffer, originalValueOffset );

}

_setAdditiveIdentityNumeric() {

const startIndex = this._addIndex * this.valueSize;
		const endIndex = startIndex + this.valueSize;

for ( let i = startIndex; i < endIndex; i ++ ) {

this.buffer[ i ] = 0;

}

_setAdditiveIdentityQuaternion() {

this._setAdditiveIdentityNumeric();
		this.buffer[ this._addIndex * this.valueSize + 3 ] = 1;

}

_setAdditiveIdentityOther() {

const startIndex = this._origIndex * this.valueSize;
		const targetIndex = this._addIndex * this.valueSize;

for ( let i = 0; i < this.valueSize; i ++ ) {

this.buffer[ targetIndex + i ] = this.buffer[ startIndex + i ];

}

// mix functions

_select( buffer, dstOffset, srcOffset, t, stride ) {

if ( t >= 0.5 ) {

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

buffer[ dstOffset + i ] = buffer[ srcOffset + i ];

}

_slerp( buffer, dstOffset, srcOffset, t ) {

Quaternion.slerpFlat( buffer, dstOffset, buffer, dstOffset, buffer, srcOffset, t );

}

_slerpAdditive( buffer, dstOffset, srcOffset, t, stride ) {

const workOffset = this._workIndex * stride;

// Store result in intermediate buffer offset
		Quaternion.multiplyQuaternionsFlat( buffer, workOffset, buffer, dstOffset, buffer, srcOffset );

// Slerp to the intermediate result
		Quaternion.slerpFlat( buffer, dstOffset, buffer, dstOffset, buffer, workOffset, t );

}

_lerp( buffer, dstOffset, srcOffset, t, stride ) {

const s = 1 - t;

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

const j = dstOffset + i;

buffer[ j ] = buffer[ j ] * s + buffer[ srcOffset + i ] * t;

}

_lerpAdditive( buffer, dstOffset, srcOffset, t, stride ) {

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

const j = dstOffset + i;

buffer[ j ] = buffer[ j ] + buffer[ srcOffset + i ] * t;

}

export { PropertyMixer };

${this.title}

Code Editor : PropertyMixer.js