private bool CalcAutoRotation(
FakeTransform _ftransBlend,
FakeTransform _ftransBase,
Transform _transRef,
CSwayParamDetail _Detail)
{
Quaternion.get_identity();
float num1 = 1f;
float num2 = 1f;
double num3;
float num4 = (float)(num3 = 1.0);
float num5 = 0.0f;
num4 = 0.0f;
float num6 = Vector3.Dot(Vector3.get_up(), _transRef.get_up());
float num7 = Vector3.Dot(Vector3.get_up(), _transRef.get_forward());
float num8 = Vector3.Dot(Vector3.get_up(), _transRef.get_right());
float num9 = Mathf.Abs(num6);
if ((double)num7 > 0.0)
{
num1 = -1f;
}
float num10 = Mathf.Abs(num7);
if ((double)num8 > 0.0)
{
num2 = -1f;
}
float num11 = Mathf.Abs(num8);
float num12 = Mathf.InverseLerp(1f, 0.0f, num9) * Mathf.InverseLerp(0.0f, 1f, num11);
float fAutoRot1 = _Detail.fAutoRot;
if ((double)num2 < 0.0)
{
fAutoRot1 *= -1f;
}
float num13 = Mathf.Lerp(0.0f, fAutoRot1, num12);
if (!_Detail.bAutoRotUp || (double)num1 > 0.0)
{
float num14 = Mathf.InverseLerp(1f, 0.0f, num9) * Mathf.InverseLerp(0.0f, 1f, num10);
float fAutoRot2 = _Detail.fAutoRot;
if (!((double)num1 <= 0.0 ? !this.m_bLR : this.m_bLR))
{
fAutoRot2 *= -1f;
}
num5 = Mathf.Lerp(0.0f, fAutoRot2, num14);
}
Quaternion quaternion = Quaternion.AngleAxis(MathfEx.ToDegree(num5 + num13), Vector3.get_up());
_ftransBlend.Rot = Quaternion.op_Multiply(_ftransBase.Rot, quaternion);
_ftransBlend.Pos = _ftransBase.Pos;
_ftransBlend.Scale = _ftransBase.Scale;
return(true);
}
private bool MoveLimit(int _nIdx)
{
CSwayParamDetail cswayParamDetail = this.m_Param.listDetail[_nIdx];
SpringCtrl.CSpringPoint cspringPoint = this.m_listSpringCtrl[_nIdx].listPoint[0];
cspringPoint.vPos.x = (__Null)(double)Mathf.Clamp((float)cspringPoint.vPos.x, (float)cswayParamDetail.vLimitMinT.x, (float)cswayParamDetail.vLimitMaxT.x);
cspringPoint.vPos.y = (__Null)(double)Mathf.Clamp((float)cspringPoint.vPos.y, (float)cswayParamDetail.vLimitMinT.y, (float)cswayParamDetail.vLimitMaxT.y);
cspringPoint.vPos.z = (__Null)(double)Mathf.Clamp((float)cspringPoint.vPos.z, (float)cswayParamDetail.vLimitMinT.z, (float)cswayParamDetail.vLimitMaxT.z);
return(true);
}
private bool TransformRotateAndTrans(
FakeTransform _ftransResult,
CBoneData _Bone,
int _nIdx,
FakeTransform _ftransBaseT,
FakeTransform _ftransBaseR)
{
FakeTransform fakeTransform1 = new FakeTransform();
CSwayParamDetail cswayParamDetail = this.m_Param.listDetail[_nIdx];
Quaternion quaternion1 = Quaternion.AngleAxis((float)this.m_listRot[_nIdx].x * _Bone.fScaleR, Vector3.get_right());
Quaternion quaternion2 = Quaternion.AngleAxis((float)this.m_listRot[_nIdx].y * _Bone.fScaleR, Vector3.get_up());
fakeTransform1.Rot = Quaternion.op_Multiply(quaternion1, quaternion2);
Vector3 vector3;
((Vector3) ref vector3).\u002Ector(_Bone.fScaleT, _Bone.fScaleT, _Bone.fScaleT);
if (this.m_listSpringCtrl[_nIdx].listPoint[0].vPos.y >= 0.0)
{
vector3.y = (__Null)(double)_Bone.fScaleYT;
}
fakeTransform1.Pos = Vector3.Scale(this.m_listSpringCtrl[_nIdx].listPoint[0].vPos, vector3);
FakeTransform fakeTransform2 = fakeTransform1;
fakeTransform2.Pos = Vector3.op_Addition(fakeTransform2.Pos, _ftransBaseT.Pos);
float num1;
float num2;
float num3;
if (fakeTransform1.Pos.z > 0.0)
{
float num4 = Mathf.InverseLerp(0.0f, (float)cswayParamDetail.vLimitMaxT.z, (float)fakeTransform1.Pos.z);
num1 = Mathf.Lerp(1f, cswayParamDetail.fCrushZMax, num4) * (float)cswayParamDetail.vAddS.z;
float num5 = Mathf.Lerp(1f, cswayParamDetail.fCrushXYMin, num4);
num2 = num5 * (float)cswayParamDetail.vAddS.y;
num3 = num5 * (float)cswayParamDetail.vAddS.x;
}
else
{
float num4 = Mathf.InverseLerp(0.0f, (float)cswayParamDetail.vLimitMinT.z, (float)fakeTransform1.Pos.z);
num1 = Mathf.Lerp(1f, cswayParamDetail.fCrushZMin, num4) * (float)cswayParamDetail.vAddS.z;
float num5 = Mathf.Lerp(1f, cswayParamDetail.fCrushXYMax, num4);
num2 = num5 * (float)cswayParamDetail.vAddS.y;
num3 = num5 * (float)cswayParamDetail.vAddS.x;
}
_ftransResult.Rot = Quaternion.op_Multiply(fakeTransform1.Rot, _ftransBaseR.Rot);
_ftransResult.Pos = fakeTransform1.Pos;
_ftransResult.Scale = Vector3.Scale(new Vector3(num3, num2, num1), _ftransBaseR.Scale);
return(true);
}
private bool CalcBlendMatrixT(
FakeTransform _ftransBlend,
CBoneData _Bone,
bool _bWorld,
CSwayParamDetail _Detail)
{
CFrameInfo cframeInfo1 = _Bone.listLocater[(int)_Bone.anLocaterTIdx[0]];
CFrameInfo cframeInfo2 = _Bone.listLocater[(int)_Bone.anLocaterTIdx[1]];
FakeTransform target = new FakeTransform();
FakeTransform fakeTransform1 = new FakeTransform();
FakeTransform fakeTransform2 = new FakeTransform();
target.Pos = cframeInfo1.transFrame.get_localPosition();
target.Rot = cframeInfo1.transFrame.get_localRotation();
target.Scale = cframeInfo1.transFrame.get_localScale();
fakeTransform1.Pos = cframeInfo2.transFrame.get_localPosition();
fakeTransform1.Rot = cframeInfo2.transFrame.get_localRotation();
fakeTransform1.Scale = cframeInfo2.transFrame.get_localScale();
if (this.m_bLR)
{
((Vector3) ref fakeTransform2.Pos).Set((float)-_Detail.vAddT.x, (float)_Detail.vAddT.y, (float)_Detail.vAddT.z);
}
else
{
((Vector3) ref fakeTransform2.Pos).Set((float)_Detail.vAddT.x, (float)_Detail.vAddT.y, (float)_Detail.vAddT.z);
}
FakeTransform fakeTransform3 = target;
fakeTransform3.Pos = Vector3.op_Addition(fakeTransform3.Pos, fakeTransform2.Pos);
FakeTransform fakeTransform4 = fakeTransform1;
fakeTransform4.Pos = Vector3.op_Addition(fakeTransform4.Pos, fakeTransform2.Pos);
if (_bWorld)
{
target.Pos = cframeInfo1.transParent.TransformPoint(target.Pos);
target.Rot = cframeInfo1.transFrame.get_rotation();
fakeTransform1.Pos = cframeInfo2.transParent.TransformPoint(fakeTransform1.Pos);
fakeTransform1.Rot = cframeInfo2.transFrame.get_rotation();
}
if ((int)_Bone.anLocaterTIdx[0] == (int)_Bone.anLocaterTIdx[1])
{
_ftransBlend = (FakeTransform)target.DeepCopy();
return(true);
}
_ftransBlend.Pos = Vector3.Lerp(target.Pos, fakeTransform1.Pos, _Bone.fLerp);
_ftransBlend.Rot = Quaternion.Slerp(target.Rot, fakeTransform1.Rot, _Bone.fLerp);
_ftransBlend.Scale = Vector3.Lerp(target.Scale, fakeTransform1.Scale, _Bone.fLerp);
return(true);
}
private bool CalcForce(Transform _transFrame, int _nIdx)
{
CSwayParamDetail cswayParamDetail = this.m_Param.listDetail[_nIdx];
Vector3 vector3_1 = Vector3.op_Subtraction(this.m_listOldWorldPos[_nIdx], _transFrame.get_position());
this.m_listOldWorldPos[_nIdx] = _transFrame.get_position();
if ((double)((Vector3) ref vector3_1).get_sqrMagnitude() > (double)Mathf.Pow(cswayParamDetail.fForceLimit, 2f))
{
vector3_1 = Vector3.op_Multiply(((Vector3) ref vector3_1).get_normalized(), cswayParamDetail.fForceLimit);
}
Vector3 vector3_2 = Vector3.op_Multiply(vector3_1, cswayParamDetail.fForceScale);
this.m_listSpringCtrl[_nIdx].setAutoForce = _transFrame.InverseTransformDirection(vector3_2);
return(true);
}
private bool TransformRotate(
FakeTransform _ftransResult,
CBoneData _Bone,
int _nIdx,
FakeTransform _ftransBaseT,
FakeTransform _ftransBaseR)
{
FakeTransform fakeTransform = new FakeTransform();
CSwayParamDetail cswayParamDetail = this.m_Param.listDetail[_nIdx];
Quaternion quaternion1 = Quaternion.AngleAxis((float)this.m_listRot[_nIdx].x * _Bone.fScaleR, Vector3.get_right());
Quaternion quaternion2 = Quaternion.AngleAxis((float)this.m_listRot[_nIdx].y * _Bone.fScaleR, Vector3.get_up());
fakeTransform.Rot = Quaternion.op_Multiply(quaternion1, quaternion2);
_ftransResult.Rot = Quaternion.op_Multiply(fakeTransform.Rot, _ftransBaseR.Rot);
_ftransResult.Pos = _ftransBaseR.Pos;
_ftransResult.Scale = Vector3.Scale(cswayParamDetail.vAddS, _ftransBaseR.Scale);
return(true);
}
private bool CalcRot(int _nIdx)
{
CSwayParamDetail cswayParamDetail = this.m_Param.listDetail[_nIdx];
SpringCtrl.CSpringPoint cspringPoint = this.m_listSpringCtrl[_nIdx].listPoint[0];
this.m_listRot[_nIdx] = Vector3.get_zero();
int index1 = cspringPoint.vPos.y < 0.0 ? 1 : 0;
int index2 = cspringPoint.vPos.x < 0.0 ? 1 : 0;
float num1 = 0.0f;
float num2 = 0.0f;
float[] numArray1 = new float[2]
{
(float)cswayParamDetail.vLimitMaxT.y,
(float)cswayParamDetail.vLimitMinT.y
};
float[] numArray2 = new float[2]
{
(float)cswayParamDetail.vLimitMaxT.x,
(float)cswayParamDetail.vLimitMinT.x
};
float[] numArray3 = new float[2]
{
(float)cswayParamDetail.vLimitMaxR.y,
(float)cswayParamDetail.vLimitMinR.y
};
float[] numArray4 = new float[2]
{
(float)cswayParamDetail.vLimitMaxR.x,
(float)cswayParamDetail.vLimitMinR.x
};
if ((double)numArray1[index1] == 1.0)
{
num1 = (float)-cspringPoint.vPos.y / numArray1[index1];
}
if ((double)numArray2[index2] == 1.0)
{
num2 = (float)cspringPoint.vPos.x / numArray2[index2];
}
Vector3 vector3 = this.m_listRot[_nIdx];
((Vector3) ref vector3).Set(numArray4[index1] * num1, numArray3[index2] * num2, 0.0f);
return(true);
}
private bool CalcBlendMatrixR(
FakeTransform _ftransBlend,
CBoneData _Bone,
bool _bWorld,
CSwayParamDetail _Detail,
bool _bAddRot,
bool _bRot)
{
CFrameInfo cframeInfo1 = _Bone.listLocater[(int)_Bone.anLocaterRIdx[0]];
CFrameInfo cframeInfo2 = _Bone.listLocater[(int)_Bone.anLocaterRIdx[1]];
CFrameInfo reference = _Bone.Reference;
FakeTransform fakeTransform1 = new FakeTransform();
FakeTransform fakeTransform2 = new FakeTransform();
FakeTransform fakeTransform3 = new FakeTransform();
FakeTransform fakeTransform4 = new FakeTransform();
fakeTransform1.Pos = cframeInfo1.transFrame.get_localPosition();
fakeTransform1.Rot = cframeInfo1.transFrame.get_localRotation();
fakeTransform1.Scale = cframeInfo1.transFrame.get_localScale();
fakeTransform2.Pos = cframeInfo2.transFrame.get_localPosition();
fakeTransform2.Rot = cframeInfo2.transFrame.get_localRotation();
fakeTransform2.Scale = cframeInfo2.transFrame.get_localScale();
if (this.m_bLR)
{
((Vector3) ref fakeTransform3.Pos).Set((float)-_Detail.vAddT.x, (float)_Detail.vAddT.y, (float)_Detail.vAddT.z);
}
else
{
((Vector3) ref fakeTransform3.Pos).Set((float)_Detail.vAddT.x, (float)_Detail.vAddT.y, (float)_Detail.vAddT.z);
}
FakeTransform fakeTransform5 = fakeTransform1;
fakeTransform5.Pos = Vector3.op_Addition(fakeTransform5.Pos, fakeTransform3.Pos);
FakeTransform fakeTransform6 = fakeTransform2;
fakeTransform6.Pos = Vector3.op_Addition(fakeTransform6.Pos, fakeTransform3.Pos);
if (_bWorld)
{
fakeTransform1.Pos = cframeInfo1.transParent.TransformPoint(fakeTransform1.Pos);
fakeTransform1.Rot = cframeInfo1.transFrame.get_rotation();
fakeTransform2.Pos = cframeInfo2.transParent.TransformPoint(fakeTransform2.Pos);
fakeTransform2.Rot = cframeInfo2.transFrame.get_rotation();
}
if ((int)_Bone.anLocaterRIdx[0] == (int)_Bone.anLocaterRIdx[1])
{
fakeTransform4.Rot = _bAddRot ? (!this.m_bLR ? Quaternion.Euler((float)_Detail.vAddR.x, (float)_Detail.vAddR.y, (float)_Detail.vAddR.z) : Quaternion.Euler((float)_Detail.vAddR.x, (float)-_Detail.vAddR.y, (float)_Detail.vAddR.z)) : Quaternion.get_identity();
FakeTransform fakeTransform7 = fakeTransform4;
fakeTransform7.Rot = Quaternion.op_Multiply(fakeTransform7.Rot, fakeTransform1.Rot);
fakeTransform4.Pos = fakeTransform1.Pos;
fakeTransform4.Scale = fakeTransform1.Scale;
if (!_bRot || Object.op_Equality((Object)reference.transFrame, (Object)null))
{
_ftransBlend = (FakeTransform)fakeTransform4.DeepCopy();
}
else
{
this.CalcAutoRotation(_ftransBlend, fakeTransform4, reference.transFrame, _Detail);
}
return(true);
}
_ftransBlend.Pos = Vector3.Lerp(fakeTransform1.Pos, fakeTransform2.Pos, _Bone.fLerp);
_ftransBlend.Rot = Quaternion.Slerp(fakeTransform1.Rot, fakeTransform2.Rot, _Bone.fLerp);
_ftransBlend.Scale = Vector3.Lerp(fakeTransform1.Scale, fakeTransform2.Scale, _Bone.fLerp);
fakeTransform4.Rot = _bAddRot ? (!this.m_bLR ? Quaternion.Euler((float)_Detail.vAddR.x, (float)_Detail.vAddR.y, (float)_Detail.vAddR.z) : Quaternion.Euler((float)_Detail.vAddR.x, (float)-_Detail.vAddR.y, (float)_Detail.vAddR.z)) : Quaternion.get_identity();
FakeTransform fakeTransform8 = _ftransBlend;
fakeTransform8.Rot = Quaternion.op_Multiply(fakeTransform8.Rot, fakeTransform4.Rot);
if (_bRot && Object.op_Inequality((Object)reference.transFrame, (Object)null))
{
this.CalcAutoRotation(_ftransBlend, _ftransBlend, reference.transFrame, _Detail);
}
return(true);
}
