public override void FadeOut()
{
var result = this.bonePose.result;
result.rotation = Transform.NormalizeRadian(result.rotation);
result.skew = Transform.NormalizeRadian(result.skew);
}
private void _ComputeA()
{
var ikGlobal = this._target.global;
var global = this._root.global;
var globalTransformMatrix = this._root.globalTransformMatrix;
var radian = (float)System.Math.Atan2(ikGlobal.y - global.y, ikGlobal.x - global.x);
if (global.scaleX < 0.0f)
{
radian += (float)System.Math.PI;
}
global.rotation += Transform.NormalizeRadian(radian - global.rotation) * this._weight;
global.ToMatrix(globalTransformMatrix);
}
private void _getTimelineFrameMatrix(AnimationData animation,BoneTimelineData timeline,float position,Transform transform) // Support 2.x ~ 3.x data.
{
var frameIndex = (int)Math.Floor(position * animation.frameCount / animation.duration);
if (timeline.frames.Count == 1 || frameIndex >= timeline.frames.Count)
{
transform.CopyFrom(timeline.frames[0].transform);
}
else
{
var frame = timeline.frames[frameIndex];
float tweenProgress = 0.0f;
if (frame.tweenEasing != DragonBones.NO_TWEEN)
{
tweenProgress = (position - frame.position) / frame.duration;
if (frame.tweenEasing != 0.0f)
{
tweenProgress = TweenTimelineState <BoneFrameData,BoneTimelineData> ._getEasingValue(tweenProgress,frame.tweenEasing);
}
}
else if (frame.curve != null)
{
tweenProgress = (position - frame.position) / frame.duration;
tweenProgress = TweenTimelineState <BoneFrameData,BoneTimelineData> ._getCurveEasingValue(tweenProgress,frame.curve);
}
var nextFrame = frame.next;
transform.x = nextFrame.transform.x - frame.transform.x;
transform.y = nextFrame.transform.y - frame.transform.y;
transform.skewX = Transform.NormalizeRadian(nextFrame.transform.skewX - frame.transform.skewX);
transform.skewY = Transform.NormalizeRadian(nextFrame.transform.skewY - frame.transform.skewY);
transform.scaleX = nextFrame.transform.scaleX - frame.transform.scaleX;
transform.scaleY = nextFrame.transform.scaleY - frame.transform.scaleY;
transform.x = frame.transform.x + transform.x * tweenProgress;
transform.y = frame.transform.y + transform.y * tweenProgress;
transform.skewX = frame.transform.skewX + transform.skewX * tweenProgress;
transform.skewY = frame.transform.skewY + transform.skewY * tweenProgress;
transform.scaleX = frame.transform.scaleX + transform.scaleX * tweenProgress;
transform.scaleY = frame.transform.scaleY + transform.scaleY * tweenProgress;
}
transform.Add(timeline.originTransform);
}
protected override void _OnArriveAtFrame()
{
base._OnArriveAtFrame();
if (this._timelineData != null)
{
var valueOffset = this._animationData.frameFloatOffset + this._frameValueOffset + this._frameIndex * 2;
var frameFloatArray = this._dragonBonesData.frameFloatArray;
var current = this.bonePose.current;
var delta = this.bonePose.delta;
current.rotation = frameFloatArray[valueOffset++];
current.skew = frameFloatArray[valueOffset++];
if (this._tweenState == TweenState.Always)
{
if (this._frameIndex == this._frameCount - 1)
{
valueOffset = this._animationData.frameFloatOffset + this._frameValueOffset;
delta.rotation = Transform.NormalizeRadian(frameFloatArray[valueOffset++] - current.rotation);
}
else
{
delta.rotation = frameFloatArray[valueOffset++] - current.rotation;
}
delta.skew = frameFloatArray[valueOffset++] - current.skew;
}
else
{
delta.rotation = 0.0f;
delta.skew = 0.0f;
}
}
else
{
// Pose.
var current = this.bonePose.current;
var delta = this.bonePose.delta;
current.rotation = 0.0f;
current.skew = 0.0f;
delta.rotation = 0.0f;
delta.skew = 0.0f;
}
}
override public void FadeOut()
{
_transform.skewX = Transform.NormalizeRadian(_transform.skewX);
_transform.skewY = Transform.NormalizeRadian(_transform.skewY);
}
override protected void _onArriveAtFrame()
{
base._onArriveAtFrame();
_tweenTransform = TweenType.Once;
_tweenRotate = TweenType.Once;
_tweenScale = TweenType.Once;
if (_keyFrameCount > 1 && (_tweenEasing != DragonBones.NO_TWEEN || _curve != null))
{
var currentTransform = _currentFrame.transform;
var nextFrame = _currentFrame.next;
var nextTransform = nextFrame.transform;
// Transform.
_durationTransform.x = nextTransform.x - currentTransform.x;
_durationTransform.y = nextTransform.y - currentTransform.y;
if (_durationTransform.x != 0.0f || _durationTransform.y != 0.0f)
{
_tweenTransform = TweenType.Always;
}
// Rotate.
var tweenRotate = _currentFrame.tweenRotate;
if (tweenRotate != DragonBones.NO_TWEEN)
{
if (tweenRotate != 0.0f)
{
if (tweenRotate > 0.0f ? nextTransform.skewY >= currentTransform.skewY : nextTransform.skewY <= currentTransform.skewY)
{
tweenRotate = tweenRotate > 0.0f ? tweenRotate - 1.0f : tweenRotate + 1.0f;
}
_durationTransform.skewX = nextTransform.skewX - currentTransform.skewX + DragonBones.PI_D * tweenRotate;
_durationTransform.skewY = nextTransform.skewY - currentTransform.skewY + DragonBones.PI_D * tweenRotate;
}
else
{
_durationTransform.skewX = Transform.NormalizeRadian(nextTransform.skewX - currentTransform.skewX);
_durationTransform.skewY = Transform.NormalizeRadian(nextTransform.skewY - currentTransform.skewY);
}
if (_durationTransform.skewX != 0.0f || _durationTransform.skewY != 0.0f)
{
_tweenRotate = TweenType.Always;
}
}
else
{
_durationTransform.skewX = 0.0f;
_durationTransform.skewY = 0.0f;
}
// Scale.
if (_currentFrame.tweenScale)
{
_durationTransform.scaleX = nextTransform.scaleX - currentTransform.scaleX;
_durationTransform.scaleY = nextTransform.scaleY - currentTransform.scaleY;
if (_durationTransform.scaleX != 0.0f || _durationTransform.scaleY != 0.0f)
{
_tweenScale = TweenType.Always;
}
}
else
{
_durationTransform.scaleX = 0.0f;
_durationTransform.scaleY = 0.0f;
}
}
else
{
_durationTransform.x = 0.0f;
_durationTransform.y = 0.0f;
_durationTransform.skewX = 0.0f;
_durationTransform.skewY = 0.0f;
_durationTransform.scaleX = 0.0f;
_durationTransform.scaleY = 0.0f;
}
}
private void _ComputeB()
{
var boneLength = this._bone.boneData.length;
var parent = this._root as Bone;
var ikGlobal = this._target.global;
var parentGlobal = parent.global;
var global = this._bone.global;
var globalTransformMatrix = this._bone.globalTransformMatrix;
var x = globalTransformMatrix.a * boneLength;
var y = globalTransformMatrix.b * boneLength;
var lLL = x * x + y * y;
var lL = (float)System.Math.Sqrt(lLL);
var dX = global.x - parentGlobal.x;
var dY = global.y - parentGlobal.y;
var lPP = dX * dX + dY * dY;
var lP = (float)System.Math.Sqrt(lPP);
var rawRadian = global.rotation;
var rawParentRadian = parentGlobal.rotation;
var rawRadianA = (float)System.Math.Atan2(dY, dX);
dX = ikGlobal.x - parentGlobal.x;
dY = ikGlobal.y - parentGlobal.y;
var lTT = dX * dX + dY * dY;
var lT = (float)System.Math.Sqrt(lTT);
var radianA = 0.0f;
if (lL + lP <= lT || lT + lL <= lP || lT + lP <= lL)
{
radianA = (float)System.Math.Atan2(ikGlobal.y - parentGlobal.y, ikGlobal.x - parentGlobal.x);
if (lL + lP <= lT)
{
}
else if (lP < lL)
{
radianA += (float)System.Math.PI;
}
}
else
{
var h = (lPP - lLL + lTT) / (2.0f * lTT);
var r = (float)System.Math.Sqrt(lPP - h * h * lTT) / lT;
var hX = parentGlobal.x + (dX * h);
var hY = parentGlobal.y + (dY * h);
var rX = -dY * r;
var rY = dX * r;
var isPPR = false;
var parentParent = parent.parent;
if (parentParent != null)
{
var parentParentMatrix = parentParent.globalTransformMatrix;
isPPR = parentParentMatrix.a * parentParentMatrix.d - parentParentMatrix.b * parentParentMatrix.c < 0.0f;
}
if (isPPR != this._bendPositive)
{
global.x = hX - rX;
global.y = hY - rY;
}
else
{
global.x = hX + rX;
global.y = hY + rY;
}
radianA = (float)System.Math.Atan2(global.y - parentGlobal.y, global.x - parentGlobal.x);
}
var dR = Transform.NormalizeRadian(radianA - rawRadianA);
parentGlobal.rotation = rawParentRadian + dR * this._weight;
parentGlobal.ToMatrix(parent.globalTransformMatrix);
//
var currentRadianA = rawRadianA + dR * this._weight;
global.x = parentGlobal.x + (float)System.Math.Cos(currentRadianA) * lP;
global.y = parentGlobal.y + (float)System.Math.Sin(currentRadianA) * lP;
//
var radianB = (float)System.Math.Atan2(ikGlobal.y - global.y, ikGlobal.x - global.x);
if (global.scaleX < 0.0f)
{
radianB += (float)System.Math.PI;
}
global.rotation = parentGlobal.rotation + rawRadian - rawParentRadian + Transform.NormalizeRadian(radianB - dR - rawRadian) * this._weight;
global.ToMatrix(globalTransformMatrix);
}
