public override void FadeOut()
{
var result = this.bonePose.result;
result.rotation = DrangonTransform.NormalizeRadian(result.rotation);
result.skew = DrangonTransform.NormalizeRadian(result.skew);
}
/// <private/>
public DrangonTransform Minus(DrangonTransform value)
{
this.x -= value.x;
this.y -= value.y;
this.skew -= value.skew;
this.rotation -= value.rotation;
this.scaleX /= value.scaleX;
this.scaleY /= value.scaleY;
return(this);
}
/// <private/>
public DrangonTransform CopyFrom(DrangonTransform value)
{
this.x = value.x;
this.y = value.y;
this.skew = value.skew;
this.rotation = value.rotation;
this.scaleX = value.scaleX;
this.scaleY = value.scaleY;
return(this);
}
/// <private/>
public DrangonTransform Add(DrangonTransform value)
{
this.x += value.x;
this.y += value.y;
this.skew += value.skew;
this.rotation += value.rotation;
this.scaleX *= value.scaleX;
this.scaleY *= value.scaleY;
return(this);
}
/// <private/>
protected override void _OnClear()
{
this.globalTransformMatrix.Identity();
this.global.Identity();
this.offset.Identity();
this.origin = null; //
this.userData = null;
this._globalDirty = false;
this._armature = null; //
}
private void _ComputeA()
{
var ikGlobal = this._target.global;
var global = this._root.global;
var globalTransformMatrix = this._root.globalTransformMatrix;
var radian = (float)Math.Atan2(ikGlobal.y - global.y, ikGlobal.x - global.x);
if (global.scaleX < 0.0f)
{
radian += (float)Math.PI;
}
global.rotation += DrangonTransform.NormalizeRadian(radian - global.rotation) * this._weight;
global.ToMatrix(globalTransformMatrix);
}
/// <internal/>
/// <private/>
public void GetCacheFrame(Matrix globalTransformMatrix, DrangonTransform transform, int arrayOffset)
{
var dataArray = this.parent.cachedFrames;
globalTransformMatrix.a = dataArray[arrayOffset];
globalTransformMatrix.b = dataArray[arrayOffset + 1];
globalTransformMatrix.c = dataArray[arrayOffset + 2];
globalTransformMatrix.d = dataArray[arrayOffset + 3];
globalTransformMatrix.tx = dataArray[arrayOffset + 4];
globalTransformMatrix.ty = dataArray[arrayOffset + 5];
transform.rotation = dataArray[arrayOffset + 6];
transform.skew = dataArray[arrayOffset + 7];
transform.scaleX = dataArray[arrayOffset + 8];
transform.scaleY = dataArray[arrayOffset + 9];
transform.x = globalTransformMatrix.tx;
transform.y = globalTransformMatrix.ty;
}
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 = DrangonTransform.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;
}
}
/// <internal/>
/// <private/>
public int SetCacheFrame(Matrix globalTransformMatrix, DrangonTransform transform)
{
var dataArray = this.parent.cachedFrames;
var arrayOffset = dataArray.Count;
dataArray.ResizeList(arrayOffset + 10, 0.0f);
dataArray[arrayOffset] = globalTransformMatrix.a;
dataArray[arrayOffset + 1] = globalTransformMatrix.b;
dataArray[arrayOffset + 2] = globalTransformMatrix.c;
dataArray[arrayOffset + 3] = globalTransformMatrix.d;
dataArray[arrayOffset + 4] = globalTransformMatrix.tx;
dataArray[arrayOffset + 5] = globalTransformMatrix.ty;
dataArray[arrayOffset + 6] = transform.rotation;
dataArray[arrayOffset + 7] = transform.skew;
dataArray[arrayOffset + 8] = transform.scaleX;
dataArray[arrayOffset + 9] = transform.scaleY;
return(arrayOffset);
}
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)Math.Sqrt(lLL);
var dX = global.x - parentGlobal.x;
var dY = global.y - parentGlobal.y;
var lPP = dX * dX + dY * dY;
var lP = (float)Math.Sqrt(lPP);
var rawRadian = global.rotation;
var rawParentRadian = parentGlobal.rotation;
var rawRadianA = (float)Math.Atan2(dY, dX);
dX = ikGlobal.x - parentGlobal.x;
dY = ikGlobal.y - parentGlobal.y;
var lTT = dX * dX + dY * dY;
var lT = (float)Math.Sqrt(lTT);
var radianA = 0.0f;
if (lL + lP <= lT || lT + lL <= lP || lT + lP <= lL)
{
radianA = (float)Math.Atan2(ikGlobal.y - parentGlobal.y, ikGlobal.x - parentGlobal.x);
if (lL + lP <= lT)
{
}
else if (lP < lL)
{
radianA += (float)Math.PI;
}
}
else
{
var h = (lPP - lLL + lTT) / (2.0f * lTT);
var r = (float)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)Math.Atan2(global.y - parentGlobal.y, global.x - parentGlobal.x);
}
var dR = DrangonTransform.NormalizeRadian(radianA - rawRadianA);
parentGlobal.rotation = rawParentRadian + dR * this._weight;
parentGlobal.ToMatrix(parent.globalTransformMatrix);
//
var currentRadianA = rawRadianA + dR * this._weight;
global.x = parentGlobal.x + (float)Math.Cos(currentRadianA) * lP;
global.y = parentGlobal.y + (float)Math.Sin(currentRadianA) * lP;
//
var radianB = (float)Math.Atan2(ikGlobal.y - global.y, ikGlobal.x - global.x);
if (global.scaleX < 0.0f)
{
radianB += (float)Math.PI;
}
global.rotation = parentGlobal.rotation + rawRadian - rawParentRadian + DrangonTransform.NormalizeRadian(radianB - dR - rawRadian) * this._weight;
global.ToMatrix(globalTransformMatrix);
}
