@awayjs/graphics
Version:
AwayJS graphics classes
115 lines (114 loc) • 4.69 kB
JavaScript
import { __extends } from "tslib";
import { Quaternion } from '@awayjs/core';
import { JointPose } from '../data/JointPose';
import { SkeletonPose } from '../data/SkeletonPose';
import { AnimationStateBase } from './AnimationStateBase';
/**
*
*/
var SkeletonDifferenceState = /** @class */ (function (_super) {
__extends(SkeletonDifferenceState, _super);
function SkeletonDifferenceState(animator, skeletonAnimationNode) {
var _this = _super.call(this, animator, skeletonAnimationNode) || this;
_this._blendWeight = 0;
_this._skeletonPose = new SkeletonPose();
_this._skeletonPoseDirty = true;
_this._skeletonAnimationNode = skeletonAnimationNode;
_this._baseInput = animator.getAnimationState(_this._skeletonAnimationNode.baseInput);
_this._differenceInput = animator.getAnimationState(_this._skeletonAnimationNode.differenceInput);
return _this;
}
Object.defineProperty(SkeletonDifferenceState.prototype, "blendWeight", {
/**
* Defines a fractional value between 0 and 1 representing the blending ratio between the base input (0) and difference input (1),
* used to produce the skeleton pose output.
*
* @see #baseInput
* @see #differenceInput
*/
get: function () {
return this._blendWeight;
},
set: function (value) {
this._blendWeight = value;
this._pPositionDeltaDirty = true;
this._skeletonPoseDirty = true;
},
enumerable: false,
configurable: true
});
/**
* @inheritDoc
*/
SkeletonDifferenceState.prototype.phase = function (value) {
this._skeletonPoseDirty = true;
this._pPositionDeltaDirty = true;
this._baseInput.phase(value);
this._baseInput.phase(value);
};
/**
* @inheritDoc
*/
SkeletonDifferenceState.prototype._pUpdateTime = function (time) {
this._skeletonPoseDirty = true;
this._baseInput.update(time);
this._differenceInput.update(time);
_super.prototype._pUpdateTime.call(this, time);
};
/**
* Returns the current skeleton pose of the animation in the clip based on the internal playhead position.
*/
SkeletonDifferenceState.prototype.getSkeletonPose = function (skeleton) {
if (this._skeletonPoseDirty)
this.updateSkeletonPose(skeleton);
return this._skeletonPose;
};
/**
* @inheritDoc
*/
SkeletonDifferenceState.prototype._pUpdatePositionDelta = function () {
this._pPositionDeltaDirty = false;
var deltA = this._baseInput.positionDelta;
var deltB = this._differenceInput.positionDelta;
this.positionDelta.x = deltA.x + this._blendWeight * deltB.x;
this.positionDelta.y = deltA.y + this._blendWeight * deltB.y;
this.positionDelta.z = deltA.z + this._blendWeight * deltB.z;
};
/**
* Updates the output skeleton pose of the node based on the blendWeight value between base input and difference input nodes.
*
* @param skeleton The skeleton used by the animator requesting the ouput pose.
*/
SkeletonDifferenceState.prototype.updateSkeletonPose = function (skeleton) {
this._skeletonPoseDirty = false;
var endPose;
var endPoses = this._skeletonPose.jointPoses;
var basePoses = this._baseInput.getSkeletonPose(skeleton).jointPoses;
var diffPoses = this._differenceInput.getSkeletonPose(skeleton).jointPoses;
var base, diff;
var basePos, diffPos;
var tr;
var numJoints = skeleton.numJoints;
// :s
if (endPoses.length != numJoints)
endPoses.length = numJoints;
for (var i = 0; i < numJoints; ++i) {
endPose = endPoses[i];
if (endPose == null)
endPose = endPoses[i] = new JointPose();
base = basePoses[i];
diff = diffPoses[i];
basePos = base.translation;
diffPos = diff.translation;
SkeletonDifferenceState._tempQuat.multiply(diff.orientation, base.orientation);
endPose.orientation.lerp(base.orientation, SkeletonDifferenceState._tempQuat, this._blendWeight);
tr = endPose.translation;
tr.x = basePos.x + this._blendWeight * diffPos.x;
tr.y = basePos.y + this._blendWeight * diffPos.y;
tr.z = basePos.z + this._blendWeight * diffPos.z;
}
};
SkeletonDifferenceState._tempQuat = new Quaternion();
return SkeletonDifferenceState;
}(AnimationStateBase));
export { SkeletonDifferenceState };