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(); }