private void OnDrawGizmos()
{
if (!this.isDebugDraw)
{
return;
}
if (Object.op_Implicit((Object)this.rootNode))
{
Gizmos.set_color(new Color(1f, 1f, 1f, 0.8f));
if (this.eyeTypeStates.Length > this.ptnDraw)
{
EyeTypeState eyeTypeState = this.eyeTypeStates[this.ptnDraw];
Gizmos.set_color(new Color(0.0f, 1f, 1f, 0.8f));
Vector3 vector3_1 = Vector3.op_Addition(this.rootNode.TransformDirection(Vector3.op_Multiply(Quaternion.op_Multiply(Quaternion.Euler(0.0f, eyeTypeState.hAngleLimit, 0.0f), Vector3.get_forward()), this.drawLineLength)), this.rootNode.get_position());
Gizmos.DrawLine(this.rootNode.get_position(), vector3_1);
Vector3 vector3_2 = Vector3.op_Addition(this.rootNode.TransformDirection(Vector3.op_Multiply(Quaternion.op_Multiply(Quaternion.Euler(0.0f, -eyeTypeState.hAngleLimit, 0.0f), Vector3.get_forward()), this.drawLineLength)), this.rootNode.get_position());
Gizmos.DrawLine(this.rootNode.get_position(), vector3_2);
Vector3 vector3_3 = Vector3.op_Addition(this.rootNode.TransformDirection(Vector3.op_Multiply(Quaternion.op_Multiply(Quaternion.Euler(eyeTypeState.vAngleLimit, 0.0f, 0.0f), Vector3.get_forward()), this.drawLineLength)), this.rootNode.get_position());
Gizmos.DrawLine(this.rootNode.get_position(), vector3_3);
Vector3 vector3_4 = Vector3.op_Addition(this.rootNode.TransformDirection(Vector3.op_Multiply(Quaternion.op_Multiply(Quaternion.Euler(-eyeTypeState.vAngleLimit, 0.0f, 0.0f), Vector3.get_forward()), this.drawLineLength)), this.rootNode.get_position());
Gizmos.DrawLine(this.rootNode.get_position(), vector3_4);
Gizmos.DrawLine(vector3_1, vector3_4);
Gizmos.DrawLine(vector3_4, vector3_2);
Gizmos.DrawLine(vector3_2, vector3_3);
Gizmos.DrawLine(vector3_3, vector3_1);
Gizmos.set_color(new Color(1f, 0.0f, 1f, 0.8f));
for (int index = 0; index < this.eyeObjs.Length; ++index)
{
Vector3 vector3_5 = Vector3.op_Addition(this.eyeObjs[index].eyeTransform.TransformDirection(Vector3.op_Multiply(Quaternion.op_Multiply(Quaternion.Euler(0.0f, eyeTypeState.minBendingAngle * (this.eyeObjs[index].eyeLR != EYE_LR.EYE_R ? -1f : 1f), 0.0f), Vector3.get_forward()), this.drawLineLength)), this.eyeObjs[index].eyeTransform.get_position());
Gizmos.DrawLine(this.eyeObjs[index].eyeTransform.get_position(), vector3_5);
Vector3 vector3_6 = Vector3.op_Addition(this.eyeObjs[index].eyeTransform.TransformDirection(Vector3.op_Multiply(Quaternion.op_Multiply(Quaternion.Euler(0.0f, eyeTypeState.maxBendingAngle * (this.eyeObjs[index].eyeLR != EYE_LR.EYE_R ? -1f : 1f), 0.0f), Vector3.get_forward()), this.drawLineLength)), this.eyeObjs[index].eyeTransform.get_position());
Gizmos.DrawLine(this.eyeObjs[index].eyeTransform.get_position(), vector3_6);
Vector3 vector3_7 = Vector3.op_Addition(this.eyeObjs[index].eyeTransform.TransformDirection(Vector3.op_Multiply(Quaternion.op_Multiply(Quaternion.Euler(eyeTypeState.upBendingAngle, 0.0f, 0.0f), Vector3.get_forward()), this.drawLineLength)), this.eyeObjs[index].eyeTransform.get_position());
Gizmos.DrawLine(this.eyeObjs[index].eyeTransform.get_position(), vector3_7);
Vector3 vector3_8 = Vector3.op_Addition(this.eyeObjs[index].eyeTransform.TransformDirection(Vector3.op_Multiply(Quaternion.op_Multiply(Quaternion.Euler(eyeTypeState.downBendingAngle, 0.0f, 0.0f), Vector3.get_forward()), this.drawLineLength)), this.eyeObjs[index].eyeTransform.get_position());
Gizmos.DrawLine(this.eyeObjs[index].eyeTransform.get_position(), vector3_8);
Gizmos.DrawLine(vector3_5, vector3_8);
Gizmos.DrawLine(vector3_8, vector3_6);
Gizmos.DrawLine(vector3_6, vector3_7);
Gizmos.DrawLine(vector3_7, vector3_5);
}
}
Gizmos.set_color(new Color(1f, 1f, 0.0f, 0.8f));
for (int index = 0; index < this.eyeObjs.Length; ++index)
{
Gizmos.DrawLine(this.eyeObjs[index].eyeTransform.get_position(), Vector3.op_Addition(this.eyeObjs[index].eyeTransform.get_position(), Vector3.op_Multiply(this.eyeObjs[index].eyeTransform.get_forward(), this.drawLineLength)));
}
}
Gizmos.set_color(Color.get_white());
}
// Token: 0x06008625 RID: 34341 RVA: 0x00346098 File Offset: 0x00344498
private void OnDrawGizmos()
{
if (!this.isDebugDraw)
{
return;
}
if (this.rootNode)
{
Gizmos.color = new Color(1f, 1f, 1f, 0.8f);
if (this.eyeTypeStates.Length > this.ptnDraw)
{
EyeTypeState eyeTypeState = this.eyeTypeStates[this.ptnDraw];
Gizmos.color = new Color(0f, 1f, 1f, 0.8f);
Vector3 vector = this.rootNode.TransformDirection(Quaternion.Euler(0f, eyeTypeState.hAngleLimit, 0f) * Vector3.forward * this.drawLineLength) + this.rootNode.position;
Gizmos.DrawLine(this.rootNode.position, vector);
Vector3 vector2 = this.rootNode.TransformDirection(Quaternion.Euler(0f, -eyeTypeState.hAngleLimit, 0f) * Vector3.forward * this.drawLineLength) + this.rootNode.position;
Gizmos.DrawLine(this.rootNode.position, vector2);
Vector3 vector3 = this.rootNode.TransformDirection(Quaternion.Euler(eyeTypeState.vAngleLimit, 0f, 0f) * Vector3.forward * this.drawLineLength) + this.rootNode.position;
Gizmos.DrawLine(this.rootNode.position, vector3);
Vector3 vector4 = this.rootNode.TransformDirection(Quaternion.Euler(-eyeTypeState.vAngleLimit, 0f, 0f) * Vector3.forward * this.drawLineLength) + this.rootNode.position;
Gizmos.DrawLine(this.rootNode.position, vector4);
Gizmos.DrawLine(vector, vector4);
Gizmos.DrawLine(vector4, vector2);
Gizmos.DrawLine(vector2, vector3);
Gizmos.DrawLine(vector3, vector);
Gizmos.color = new Color(1f, 0f, 1f, 0.8f);
for (int i = 0; i < this.eyeObjs.Length; i++)
{
vector = this.eyeObjs[i].eyeTransform.TransformDirection(Quaternion.Euler(0f, eyeTypeState.minBendingAngle * (float)((this.eyeObjs[i].eyeLR != EYE_LR.EYE_R) ? -1 : 1), 0f) * Vector3.forward * this.drawLineLength) + this.eyeObjs[i].eyeTransform.position;
Gizmos.DrawLine(this.eyeObjs[i].eyeTransform.position, vector);
vector2 = this.eyeObjs[i].eyeTransform.TransformDirection(Quaternion.Euler(0f, eyeTypeState.maxBendingAngle * (float)((this.eyeObjs[i].eyeLR != EYE_LR.EYE_R) ? -1 : 1), 0f) * Vector3.forward * this.drawLineLength) + this.eyeObjs[i].eyeTransform.position;
Gizmos.DrawLine(this.eyeObjs[i].eyeTransform.position, vector2);
vector3 = this.eyeObjs[i].eyeTransform.TransformDirection(Quaternion.Euler(eyeTypeState.upBendingAngle, 0f, 0f) * Vector3.forward * this.drawLineLength) + this.eyeObjs[i].eyeTransform.position;
Gizmos.DrawLine(this.eyeObjs[i].eyeTransform.position, vector3);
vector4 = this.eyeObjs[i].eyeTransform.TransformDirection(Quaternion.Euler(eyeTypeState.downBendingAngle, 0f, 0f) * Vector3.forward * this.drawLineLength) + this.eyeObjs[i].eyeTransform.position;
Gizmos.DrawLine(this.eyeObjs[i].eyeTransform.position, vector4);
Gizmos.DrawLine(vector, vector4);
Gizmos.DrawLine(vector4, vector2);
Gizmos.DrawLine(vector2, vector3);
Gizmos.DrawLine(vector3, vector);
}
}
Gizmos.color = new Color(1f, 1f, 0f, 0.8f);
for (int j = 0; j < this.eyeObjs.Length; j++)
{
Gizmos.DrawLine(this.eyeObjs[j].eyeTransform.position, this.eyeObjs[j].eyeTransform.position + this.eyeObjs[j].eyeTransform.forward * this.drawLineLength);
}
}
Gizmos.color = Color.white;
}
public void EyeUpdateCalc(Vector3 target, int ptnNo)
{
if (!this.initEnd)
{
if (!Object.op_Inequality((Object)this.targetObj, (Object)null) || !this.targetObj.get_activeSelf())
{
return;
}
this.targetObj.SetActive(false);
}
else
{
this.nowPtnNo = ptnNo;
if (!EyeLookCalc.isEnabled)
{
if (!Object.op_Inequality((Object)this.targetObj, (Object)null) || !this.targetObj.get_activeSelf())
{
return;
}
this.targetObj.SetActive(false);
}
else if ((double)Time.get_deltaTime() == 0.0)
{
if (!Object.op_Inequality((Object)this.targetObj, (Object)null) || !this.targetObj.get_activeSelf())
{
return;
}
this.targetObj.SetActive(false);
}
else
{
EyeTypeState eyeTypeState = this.eyeTypeStates[ptnNo];
EYE_LOOK_TYPE eyeLookType = this.eyeTypeStates[ptnNo].lookType;
if (eyeLookType == EYE_LOOK_TYPE.NO_LOOK)
{
this.eyeObjs[0].eyeTransform.set_localRotation(this.fixAngle[0]);
this.eyeObjs[1].eyeTransform.set_localRotation(this.fixAngle[1]);
if (!Object.op_Inequality((Object)this.targetObj, (Object)null) || !this.targetObj.get_activeSelf())
{
return;
}
this.targetObj.SetActive(false);
}
else
{
Vector3 vector3_1 = this.rootNode.InverseTransformPoint(target);
if ((double)((Vector3) ref vector3_1).get_magnitude() < (double)this.eyeTypeStates[ptnNo].nearDis)
{
vector3_1 = Vector3.op_Multiply(((Vector3) ref vector3_1).get_normalized(), this.eyeTypeStates[ptnNo].nearDis);
target = this.rootNode.TransformPoint(vector3_1);
}
Vector3 vector3_2;
((Vector3) ref vector3_2).\u002Ector((float)vector3_1.x, 0.0f, (float)vector3_1.z);
float num1 = Vector3.Dot(vector3_2, Vector3.get_forward());
float num2 = Vector3.Angle(vector3_2, Vector3.get_forward());
((Vector3) ref vector3_2).\u002Ector(0.0f, (float)vector3_1.y, (float)vector3_1.z);
float num3 = Vector3.Dot(vector3_2, Vector3.get_forward());
float num4 = Vector3.Angle(vector3_2, Vector3.get_forward());
if ((double)num1 < 0.0 || (double)num3 < 0.0 || ((double)num2 > (double)this.eyeTypeStates[ptnNo].hAngleLimit || (double)num4 > (double)this.eyeTypeStates[ptnNo].vAngleLimit))
{
eyeLookType = EYE_LOOK_TYPE.FORWARD;
}
if (eyeLookType == EYE_LOOK_TYPE.FORWARD)
{
target = Vector3.op_Addition(this.rootNode.get_position(), Vector3.op_Multiply(this.rootNode.get_forward(), this.eyeTypeStates[ptnNo].forntTagDis));
}
if (eyeLookType == EYE_LOOK_TYPE.CONTROL || this.eyeTypeStates[ptnNo].lookType == EYE_LOOK_TYPE.CONTROL)
{
if (Object.op_Inequality((Object)this.targetObj, (Object)null))
{
if (!this.targetObj.get_activeSelf())
{
this.targetObj.SetActive(true);
}
target = Vector3.MoveTowards(((Component)this.rootNode).get_transform().get_position(), this.targetObj.get_transform().get_position(), this.eyeTypeStates[ptnNo].forntTagDis);
this.targetObj.get_transform().set_position(Vector3.MoveTowards(((Component)this.rootNode).get_transform().get_position(), target, 0.5f));
}
}
else if (Object.op_Inequality((Object)this.targetObj, (Object)null))
{
this.targetObj.get_transform().set_position(Vector3.MoveTowards(((Component)this.rootNode).get_transform().get_position(), target, 0.5f));
if (this.targetObj.get_activeSelf())
{
this.targetObj.SetActive(false);
}
}
float num5 = -1f;
foreach (EyeObject eyeObj in this.eyeObjs)
{
eyeObj.eyeTransform.set_localRotation(eyeObj.origRotation);
Quaternion rotation = eyeObj.eyeTransform.get_parent().get_rotation();
Quaternion quaternion1 = Quaternion.Inverse(rotation);
Vector3 vector3_3 = Vector3.op_Subtraction(target, eyeObj.eyeTransform.get_position());
Vector3 normalized = ((Vector3) ref vector3_3).get_normalized();
Vector3 dirB = Quaternion.op_Multiply(quaternion1, normalized);
float num6 = EyeLookCalc.AngleAroundAxis(eyeObj.referenceLookDir, dirB, eyeObj.referenceUpDir);
Vector3 axis = Vector3.Cross(eyeObj.referenceUpDir, dirB);
float num7 = EyeLookCalc.AngleAroundAxis(Vector3.op_Subtraction(dirB, Vector3.Project(dirB, eyeObj.referenceUpDir)), dirB, axis);
float num8 = Mathf.Max(0.0f, Mathf.Abs(num6) - eyeTypeState.thresholdAngleDifference) * Mathf.Sign(num6);
float num9 = Mathf.Max(0.0f, Mathf.Abs(num7) - eyeTypeState.thresholdAngleDifference) * Mathf.Sign(num7);
float num10 = Mathf.Max(Mathf.Abs(num8) * Mathf.Abs(eyeTypeState.bendingMultiplier), Mathf.Abs(num6) - eyeTypeState.maxAngleDifference) * Mathf.Sign(num6) * Mathf.Sign(eyeTypeState.bendingMultiplier);
float num11 = Mathf.Max(Mathf.Abs(num9) * Mathf.Abs(eyeTypeState.bendingMultiplier), Mathf.Abs(num7) - eyeTypeState.maxAngleDifference) * Mathf.Sign(num7) * Mathf.Sign(eyeTypeState.bendingMultiplier);
float num12 = eyeTypeState.maxBendingAngle;
float num13 = eyeTypeState.minBendingAngle;
if (eyeObj.eyeLR == EYE_LR.EYE_R)
{
num12 = -eyeTypeState.minBendingAngle;
num13 = -eyeTypeState.maxBendingAngle;
}
float num14 = Mathf.Clamp(num10, num13, num12);
float num15 = Mathf.Clamp(num11, eyeTypeState.upBendingAngle, eyeTypeState.downBendingAngle);
Vector3 vector3_4 = Vector3.Cross(eyeObj.referenceUpDir, eyeObj.referenceLookDir);
if (eyeLookType == EYE_LOOK_TYPE.AWAY)
{
if ((double)num5 == -1.0)
{
float num16 = Mathf.Lerp(-1f, 1f, Mathf.InverseLerp(-this.eyeTypeStates[this.nowPtnNo].maxBendingAngle, -this.eyeTypeStates[this.nowPtnNo].minBendingAngle, eyeObj.angleH));
float num17 = Mathf.Lerp(-1f, 1f, Mathf.InverseLerp(-this.eyeTypeStates[this.nowPtnNo].maxBendingAngle, -this.eyeTypeStates[this.nowPtnNo].minBendingAngle, num14));
float num18 = num16 - num17;
if ((double)Mathf.Abs(num18) < (double)this.sorasiRate)
{
num5 = Mathf.InverseLerp(-1f, 1f, (double)num18 >= 0.0 ? ((double)num18 <= 0.0 ? num17 + this.sorasiRate : ((double)num17 <= (double)this.sorasiRate ? num17 + this.sorasiRate : num17 - this.sorasiRate)) : ((double)num17 >= -(double)this.sorasiRate ? num17 - this.sorasiRate : num17 + this.sorasiRate));
num14 = Mathf.Lerp(-this.eyeTypeStates[this.nowPtnNo].maxBendingAngle, -this.eyeTypeStates[this.nowPtnNo].minBendingAngle, num5);
}
else
{
num5 = Mathf.InverseLerp(-1f, 1f, num16);
num14 = eyeObj.angleH;
}
}
else
{
num14 = Mathf.Lerp(-this.eyeTypeStates[this.nowPtnNo].maxBendingAngle, -this.eyeTypeStates[this.nowPtnNo].minBendingAngle, num5);
}
num15 = -num15;
}
eyeObj.angleH = Mathf.Lerp(eyeObj.angleH, num14, Time.get_deltaTime() * eyeTypeState.leapSpeed);
eyeObj.angleV = Mathf.Lerp(eyeObj.angleV, num15, Time.get_deltaTime() * eyeTypeState.leapSpeed);
Vector3 vector3_5 = Quaternion.op_Multiply(Quaternion.op_Multiply(Quaternion.AngleAxis(eyeObj.angleH, eyeObj.referenceUpDir), Quaternion.AngleAxis(eyeObj.angleV, vector3_4)), eyeObj.referenceLookDir);
Vector3 referenceUpDir = eyeObj.referenceUpDir;
Vector3.OrthoNormalize(ref vector3_5, ref referenceUpDir);
Vector3 vector3_6 = vector3_5;
eyeObj.dirUp = Vector3.Slerp(eyeObj.dirUp, referenceUpDir, Time.get_deltaTime() * 5f);
Vector3.OrthoNormalize(ref vector3_6, ref eyeObj.dirUp);
Quaternion quaternion2 = Quaternion.op_Multiply(Quaternion.op_Multiply(rotation, Quaternion.LookRotation(vector3_6, eyeObj.dirUp)), Quaternion.Inverse(Quaternion.op_Multiply(rotation, Quaternion.LookRotation(eyeObj.referenceLookDir, eyeObj.referenceUpDir))));
eyeObj.eyeTransform.set_rotation(Quaternion.op_Multiply(quaternion2, eyeObj.eyeTransform.get_rotation()));
}
this.targetPos = target;
this.fixAngle[0] = this.eyeObjs[0].eyeTransform.get_localRotation();
this.fixAngle[1] = this.eyeObjs[1].eyeTransform.get_localRotation();
this.AngleHRateCalc();
this.angleVRate = this.AngleVRateCalc();
}
}
}
}
// Token: 0x06008627 RID: 34343 RVA: 0x003466A0 File Offset: 0x00344AA0
public void EyeUpdateCalc(Vector3 target, int ptnNo)
{
if (!this.initEnd)
{
if (this.targetObj != null && this.targetObj.activeSelf)
{
this.targetObj.SetActive(false);
}
return;
}
this.nowPtnNo = ptnNo;
if (!EyeLookCalc.isEnabled)
{
if (this.targetObj != null && this.targetObj.activeSelf)
{
this.targetObj.SetActive(false);
}
return;
}
if (Time.deltaTime == 0f)
{
if (this.targetObj != null && this.targetObj.activeSelf)
{
this.targetObj.SetActive(false);
}
return;
}
EyeTypeState eyeTypeState = this.eyeTypeStates[ptnNo];
EYE_LOOK_TYPE eye_LOOK_TYPE = this.eyeTypeStates[ptnNo].lookType;
if (eye_LOOK_TYPE == EYE_LOOK_TYPE.NO_LOOK)
{
this.eyeObjs[0].eyeTransform.localRotation = this.fixAngle[0];
this.eyeObjs[1].eyeTransform.localRotation = this.fixAngle[1];
if (this.targetObj != null && this.targetObj.activeSelf)
{
this.targetObj.SetActive(false);
}
return;
}
Vector3 position = this.rootNode.InverseTransformPoint(target);
float magnitude = position.magnitude;
if (magnitude < this.eyeTypeStates[ptnNo].nearDis)
{
position = position.normalized * this.eyeTypeStates[ptnNo].nearDis;
target = this.rootNode.TransformPoint(position);
}
Vector3 vector = new Vector3(position.x, 0f, position.z);
float num = Vector3.Dot(vector, Vector3.forward);
float num2 = Vector3.Angle(vector, Vector3.forward);
vector = new Vector3(0f, position.y, position.z);
float num3 = Vector3.Dot(vector, Vector3.forward);
float num4 = Vector3.Angle(vector, Vector3.forward);
if (num < 0f || num3 < 0f || num2 > this.eyeTypeStates[ptnNo].hAngleLimit || num4 > this.eyeTypeStates[ptnNo].vAngleLimit)
{
eye_LOOK_TYPE = EYE_LOOK_TYPE.FORWARD;
}
if (eye_LOOK_TYPE == EYE_LOOK_TYPE.FORWARD)
{
target = this.rootNode.position + this.rootNode.forward * this.eyeTypeStates[ptnNo].forntTagDis;
}
if (eye_LOOK_TYPE == EYE_LOOK_TYPE.CONTROL || this.eyeTypeStates[ptnNo].lookType == EYE_LOOK_TYPE.CONTROL)
{
if (this.targetObj != null)
{
if (!this.targetObj.activeSelf)
{
this.targetObj.SetActive(true);
}
target = Vector3.MoveTowards(this.rootNode.transform.position, this.targetObj.transform.position, this.eyeTypeStates[ptnNo].forntTagDis);
this.targetObj.transform.position = Vector3.MoveTowards(this.rootNode.transform.position, target, 0.5f);
}
}
else if (this.targetObj != null)
{
this.targetObj.transform.position = Vector3.MoveTowards(this.rootNode.transform.position, target, 0.5f);
if (this.targetObj.activeSelf)
{
this.targetObj.SetActive(false);
}
}
float num5 = -1f;
foreach (EyeObject eyeObject in this.eyeObjs)
{
eyeObject.eyeTransform.localRotation = eyeObject.origRotation;
Quaternion rotation = eyeObject.eyeTransform.parent.rotation;
Quaternion rotation2 = Quaternion.Inverse(rotation);
Vector3 normalized = (target - eyeObject.eyeTransform.position).normalized;
Vector3 vector2 = rotation2 * normalized;
float num6 = EyeLookCalc.AngleAroundAxis(eyeObject.referenceLookDir, vector2, eyeObject.referenceUpDir);
Vector3 axis = Vector3.Cross(eyeObject.referenceUpDir, vector2);
Vector3 dirA = vector2 - Vector3.Project(vector2, eyeObject.referenceUpDir);
float num7 = EyeLookCalc.AngleAroundAxis(dirA, vector2, axis);
float f = Mathf.Max(0f, Mathf.Abs(num6) - eyeTypeState.thresholdAngleDifference) * Mathf.Sign(num6);
float f2 = Mathf.Max(0f, Mathf.Abs(num7) - eyeTypeState.thresholdAngleDifference) * Mathf.Sign(num7);
num6 = Mathf.Max(Mathf.Abs(f) * Mathf.Abs(eyeTypeState.bendingMultiplier), Mathf.Abs(num6) - eyeTypeState.maxAngleDifference) * Mathf.Sign(num6) * Mathf.Sign(eyeTypeState.bendingMultiplier);
num7 = Mathf.Max(Mathf.Abs(f2) * Mathf.Abs(eyeTypeState.bendingMultiplier), Mathf.Abs(num7) - eyeTypeState.maxAngleDifference) * Mathf.Sign(num7) * Mathf.Sign(eyeTypeState.bendingMultiplier);
float max = eyeTypeState.maxBendingAngle;
float min = eyeTypeState.minBendingAngle;
if (eyeObject.eyeLR == EYE_LR.EYE_R)
{
max = -eyeTypeState.minBendingAngle;
min = -eyeTypeState.maxBendingAngle;
}
num6 = Mathf.Clamp(num6, min, max);
num7 = Mathf.Clamp(num7, eyeTypeState.upBendingAngle, eyeTypeState.downBendingAngle);
Vector3 axis2 = Vector3.Cross(eyeObject.referenceUpDir, eyeObject.referenceLookDir);
if (eye_LOOK_TYPE == EYE_LOOK_TYPE.AWAY)
{
if (num5 == -1f)
{
float num8 = Mathf.Lerp(-1f, 1f, Mathf.InverseLerp(-this.eyeTypeStates[this.nowPtnNo].maxBendingAngle, -this.eyeTypeStates[this.nowPtnNo].minBendingAngle, eyeObject.angleH));
float num9 = Mathf.Lerp(-1f, 1f, Mathf.InverseLerp(-this.eyeTypeStates[this.nowPtnNo].maxBendingAngle, -this.eyeTypeStates[this.nowPtnNo].minBendingAngle, num6));
float num10 = num8 - num9;
if (Mathf.Abs(num10) < this.sorasiRate)
{
if (num10 < 0f)
{
if (num9 < -this.sorasiRate)
{
num8 = num9 + this.sorasiRate;
}
else
{
num8 = num9 - this.sorasiRate;
}
}
else if (num10 > 0f)
{
if (num9 > this.sorasiRate)
{
num8 = num9 - this.sorasiRate;
}
else
{
num8 = num9 + this.sorasiRate;
}
}
else
{
num8 = num9 + this.sorasiRate;
}
num5 = Mathf.InverseLerp(-1f, 1f, num8);
num6 = Mathf.Lerp(-this.eyeTypeStates[this.nowPtnNo].maxBendingAngle, -this.eyeTypeStates[this.nowPtnNo].minBendingAngle, num5);
}
else
{
num5 = Mathf.InverseLerp(-1f, 1f, num8);
num6 = eyeObject.angleH;
}
}
else
{
num6 = Mathf.Lerp(-this.eyeTypeStates[this.nowPtnNo].maxBendingAngle, -this.eyeTypeStates[this.nowPtnNo].minBendingAngle, num5);
}
num7 = -num7;
}
eyeObject.angleH = Mathf.Lerp(eyeObject.angleH, num6, Time.deltaTime * eyeTypeState.leapSpeed);
eyeObject.angleV = Mathf.Lerp(eyeObject.angleV, num7, Time.deltaTime * eyeTypeState.leapSpeed);
vector2 = Quaternion.AngleAxis(eyeObject.angleH, eyeObject.referenceUpDir) * Quaternion.AngleAxis(eyeObject.angleV, axis2) * eyeObject.referenceLookDir;
Vector3 referenceUpDir = eyeObject.referenceUpDir;
Vector3.OrthoNormalize(ref vector2, ref referenceUpDir);
Vector3 forward = vector2;
eyeObject.dirUp = Vector3.Slerp(eyeObject.dirUp, referenceUpDir, Time.deltaTime * 5f);
Vector3.OrthoNormalize(ref forward, ref eyeObject.dirUp);
Quaternion lhs = rotation * Quaternion.LookRotation(forward, eyeObject.dirUp) * Quaternion.Inverse(rotation * Quaternion.LookRotation(eyeObject.referenceLookDir, eyeObject.referenceUpDir));
eyeObject.eyeTransform.rotation = lhs * eyeObject.eyeTransform.rotation;
}
this.targetPos = target;
this.fixAngle[0] = this.eyeObjs[0].eyeTransform.localRotation;
this.fixAngle[1] = this.eyeObjs[1].eyeTransform.localRotation;
this.AngleHRateCalc();
this.angleVRate = this.AngleVRateCalc();
}
