diff options
| author | chai <chaifix@163.com> | 2021-01-25 14:28:30 +0800 |
|---|---|---|
| committer | chai <chaifix@163.com> | 2021-01-25 14:28:30 +0800 |
| commit | 6eb915c129fc90c6f4c82ae097dd6ffad5239efc (patch) | |
| tree | 7dd2be50edf41f36b60fac84696e731c13afe617 /Client/Assets/Scripts/XMainClient/XCameraEx.cs | |
+scripts
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XCameraEx.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XCameraEx.cs | 1092 |
1 files changed, 1092 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/XCameraEx.cs b/Client/Assets/Scripts/XMainClient/XCameraEx.cs new file mode 100644 index 00000000..d3c59b47 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XCameraEx.cs @@ -0,0 +1,1092 @@ +using System;
+using System.Collections.Generic;
+using UnityEngine;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal sealed class XCameraEx : XObject
+ {
+ public XCameraSoloComponent Solo
+ {
+ get
+ {
+ return this._solo;
+ }
+ }
+
+ public XCameraMotionComponent Motion
+ {
+ get
+ {
+ return this._motion;
+ }
+ }
+
+ public XCameraCollisonComponent Collision
+ {
+ get
+ {
+ return this._collision;
+ }
+ }
+
+ public XCameraIntellectiveFollow Tail
+ {
+ get
+ {
+ return this._tail;
+ }
+ }
+
+ public XCameraCloseUpComponent CloseUp
+ {
+ get
+ {
+ return this._closeup;
+ }
+ }
+
+ public XCameraVAdjustComponent VAdjust
+ {
+ get
+ {
+ return this._adjust;
+ }
+ }
+
+ public XCameraWallComponent Wall
+ {
+ get
+ {
+ return this._wall;
+ }
+ }
+
+ public Camera UnityCamera
+ {
+ get
+ {
+ return this._camera;
+ }
+ }
+
+ public bool IsCloseUp
+ {
+ get
+ {
+ bool flag = this._closeup != null;
+ return flag && this._closeup.Execute && !this._closeup.Ending;
+ }
+ }
+
+ public bool IsDuringCloseUp
+ {
+ get
+ {
+ bool flag = this._closeup != null;
+ return flag && this._closeup.Execute;
+ }
+ }
+
+ public float Offset
+ {
+ get
+ {
+ return this._dis;
+ }
+ set
+ {
+ this._dis = value;
+ }
+ }
+
+ public float TargetOffset
+ {
+ get
+ {
+ return this._tdis;
+ }
+ set
+ {
+ this._tdis = value;
+ }
+ }
+
+ public float DefaultOffset
+ {
+ get
+ {
+ return this._default_dis;
+ }
+ set
+ {
+ this._default_dis = value;
+ }
+ }
+
+ public float Root_R_X_Default
+ {
+ get
+ {
+ return this._idle_root_rotation_x_default;
+ }
+ set
+ {
+ this._idle_root_rotation_x_default = value;
+ }
+ }
+
+ public float Root_R_Y_Default
+ {
+ get
+ {
+ return this._idle_root_rotation_y_default;
+ }
+ set
+ {
+ this._idle_root_rotation_y_default = value;
+ }
+ }
+
+ public float Root_R_X_Target
+ {
+ get
+ {
+ return this._idle_root_rotation_x_target;
+ }
+ set
+ {
+ this._idle_root_rotation_x_target = value;
+ }
+ }
+
+ public float Root_R_X
+ {
+ get
+ {
+ return this._idle_root_rotation_x;
+ }
+ set
+ {
+ this._idle_root_rotation_x = value;
+ }
+ }
+
+ public float Root_R_Y
+ {
+ get
+ {
+ return this._idle_root_rotation_y;
+ }
+ set
+ {
+ this._idle_root_rotation_y = value;
+ }
+ }
+
+ public float Root_R_Y_Target
+ {
+ get
+ {
+ return this._idle_root_rotation_y_target;
+ }
+ set
+ {
+ this._idle_root_rotation_y_target = value;
+ }
+ }
+
+ public float InitFOV
+ {
+ get
+ {
+ return this._field_of_view;
+ }
+ }
+
+ public XCameraMotionData ActiveMotion
+ {
+ get
+ {
+ return this._active_motion;
+ }
+ set
+ {
+ this._active_motion = value;
+ }
+ }
+
+ public Animator Ator
+ {
+ get
+ {
+ return this._ator;
+ }
+ }
+
+ public Transform CameraTrans
+ {
+ get
+ {
+ return this._cameraTransform;
+ }
+ }
+
+ public Vector3 Position
+ {
+ get
+ {
+ return this._cameraTransform.position;
+ }
+ }
+
+ public Quaternion Rotaton
+ {
+ get
+ {
+ return this._cameraTransform.rotation;
+ }
+ }
+
+ public XEntity Target
+ {
+ get
+ {
+ return (this._active_target == null || this._active_target.Deprecated) ? null : this._active_target;
+ }
+ set
+ {
+ this._active_target = value;
+ }
+ }
+
+ public bool IsLookAt
+ {
+ get
+ {
+ return this._active_motion.LookAt_Target;
+ }
+ }
+
+ public bool RootReady
+ {
+ get
+ {
+ return this._root_pos_inited;
+ }
+ set
+ {
+ this._root_pos_inited = value;
+ }
+ }
+
+ public Vector3 Anchor
+ {
+ get
+ {
+ return (this.Target != null) ? (this.Target.MoveObj.Position + this._dummyObject.transform.position) : Vector3.zero;
+ }
+ }
+
+ public Vector3 ProxyCameraPos
+ {
+ get
+ {
+ return this._dummyCamera_pos;
+ }
+ }
+
+ public Vector3 ProxyCameraRot
+ {
+ get
+ {
+ return this._dummyCamera_rot;
+ }
+ }
+
+ public float ProxyIdleXRot
+ {
+ get
+ {
+ return this._idle_root_basic_x;
+ }
+ }
+
+ public static bool OperationV = true;
+
+ public static bool OperationH = true;
+
+ public static float MaxV = 80f;
+
+ public static float MinV = -80f;
+
+ private float _dis = 0f;
+
+ private float _tdis = 0f;
+
+ private float _basic_dis = 4.2f;
+
+ private float _default_dis = 4.2f;
+
+ private GameObject _cameraObject = null;
+
+ private GameObject _dummyObject = null;
+
+ private Transform _dummyCamera = null;
+
+ private Transform _cameraTransform = null;
+
+ private Animator _ator = null;
+
+ private AnimatorOverrideController _overrideController;
+
+ private List<Type> _added_component = new List<Type>();
+
+ private Camera _camera = null;
+
+ private bool _inited = false;
+
+ private float _elapsed = 0f;
+
+ private bool _damp = false;
+
+ private float _damp_delta = 0f;
+
+ private Vector3 _damp_dir = Vector3.zero;
+
+ private bool _root_pos_inited = false;
+
+ private Vector3 _root_pos = Vector3.zero;
+
+ private Quaternion _idle_root_rotation = Quaternion.identity;
+
+ private float _idle_root_basic_x = 0f;
+
+ private bool _init_idle_root_basic_x = false;
+
+ private float _idle_root_rotation_x_default = 0f;
+
+ private float _idle_root_rotation_x_target = 0f;
+
+ private float _idle_root_rotation_x = 0f;
+
+ private float _idle_root_rotation_y = 0f;
+
+ private float _idle_root_rotation_y_default = 0f;
+
+ private float _idle_root_rotation_y_target = 0f;
+
+ private Vector3 _last_dummyCamera_pos = Vector3.zero;
+
+ private Vector3 _dummyCamera_pos = Vector3.zero;
+
+ private Vector3 _dummyCamera_rot = Vector3.forward;
+
+ private Quaternion _dummyCamera_quat = Quaternion.identity;
+
+ private Vector3 _v_self_p = Vector3.zero;
+
+ private Quaternion _q_self_r = Quaternion.identity;
+
+ private readonly float _damp_factor = 0.3f;
+
+ private XCameraMotionData _active_motion = new XCameraMotionData();
+
+ private XEntity _active_target = null;
+
+ private float _field_of_view = 45f;
+
+ private XCameraSoloComponent _solo = null;
+
+ private XCameraMotionComponent _motion = null;
+
+ private XCameraCollisonComponent _collision = null;
+
+ private XCameraIntellectiveFollow _tail = null;
+
+ private XCameraVAdjustComponent _adjust = null;
+
+ private XCameraWallComponent _wall = null;
+
+ private XCameraCloseUpComponent _closeup = null;
+
+ public enum XStatus
+ {
+ None,
+ Idle,
+ Solo,
+ Effect
+ }
+
+ public bool PreInstall(GameObject camera, bool bHall = false)
+ {
+ bool inited = this._inited;
+ bool result;
+ if (inited)
+ {
+ result = true;
+ }
+ else
+ {
+ this._cameraObject = camera;
+ bool flag = null != this._cameraObject;
+ if (flag)
+ {
+ this._init_idle_root_basic_x = false;
+ this._camera = this._cameraObject.GetComponent<Camera>();
+ this._camera.enabled = true;
+ this._cameraTransform = this._cameraObject.transform;
+ bool flag2 = this._dummyObject == null;
+ if (flag2)
+ {
+ this._dummyObject = (XSingleton<XResourceLoaderMgr>.singleton.CreateFromPrefab("Prefabs/DummyCamera", true, false) as GameObject);
+ this._dummyObject.name = "Dummy Camera";
+ }
+ this._dummyCamera = this._dummyObject.transform.GetChild(0);
+ this._ator = this._dummyObject.GetComponent<Animator>();
+ bool flag3 = this._overrideController == null;
+ if (flag3)
+ {
+ this._overrideController = new AnimatorOverrideController();
+ }
+ this._overrideController.runtimeAnimatorController = this._ator.runtimeAnimatorController;
+ this._ator.runtimeAnimatorController = this._overrideController;
+ this._dummyObject.SetActive(true);
+ this.FixedRatio();
+ this._added_component.Clear();
+ result = true;
+ }
+ else
+ {
+ result = false;
+ }
+ }
+ return result;
+ }
+
+ public bool Installed()
+ {
+ bool inited = this._inited;
+ bool result;
+ if (inited)
+ {
+ result = true;
+ }
+ else
+ {
+ this._solo = (base.GetXComponent(XCameraSoloComponent.uuID) as XCameraSoloComponent);
+ this._motion = (base.GetXComponent(XCameraMotionComponent.uuID) as XCameraMotionComponent);
+ this._collision = (base.GetXComponent(XCameraCollisonComponent.uuID) as XCameraCollisonComponent);
+ this._tail = (base.GetXComponent(XCameraIntellectiveFollow.uuID) as XCameraIntellectiveFollow);
+ this._adjust = (base.GetXComponent(XCameraVAdjustComponent.uuID) as XCameraVAdjustComponent);
+ this._wall = (base.GetXComponent(XCameraWallComponent.uuID) as XCameraWallComponent);
+ this._closeup = (base.GetXComponent(XCameraCloseUpComponent.uuID) as XCameraCloseUpComponent);
+ this.Motion.Attached();
+ this._root_pos_inited = false;
+ this._dis = (this._tdis = this._default_dis);
+ this._inited = true;
+ this._field_of_view = this._cameraObject.GetComponent<Camera>().fieldOfView;
+ result = true;
+ }
+ return result;
+ }
+
+ public override void Uninitilize()
+ {
+ bool flag = !this._inited;
+ if (!flag)
+ {
+ XResourceLoaderMgr.SafeDestroy(ref this._dummyObject, false);
+ this._active_target = null;
+ this.SolidCancel();
+ this._camera = null;
+ this._cameraTransform = null;
+ this._inited = false;
+ this._solo = null;
+ this._motion = null;
+ this._collision = null;
+ this._tail = null;
+ this._adjust = null;
+ this._wall = null;
+ this._closeup = null;
+ base.Uninitilize();
+ this._overrideController = null;
+ }
+ }
+
+ private void FixedRatio()
+ {
+ float num = (float)(XSingleton<XGameUI>.singleton.Base_UI_Width + 2) / (float)XSingleton<XGameUI>.singleton.Base_UI_Height;
+ float num2 = (float)Screen.width / (float)Screen.height;
+ float num3 = num2 / num;
+ bool flag = num3 < 1f;
+ if (flag)
+ {
+ Rect rect = this._camera.rect;
+ rect.width = 1f;
+ rect.height = num3;
+ rect.x = 0f;
+ rect.y = (1f - num3) / 2f;
+ this._camera.rect = rect;
+ }
+ else
+ {
+ float num4 = 1f / num3;
+ Rect rect2 = this._camera.rect;
+ rect2.width = num4;
+ rect2.height = 1f;
+ rect2.x = (1f - num4) / 2f;
+ rect2.y = 0f;
+ this._camera.rect = rect2;
+ }
+ }
+
+ public bool IsVisibleFromCamera(XEntity entity, bool fully)
+ {
+ Plane[] planes = GeometryUtility.CalculateFrustumPlanes(this._camera);
+ return entity.EngineObject.TestVisibleWithFrustum(planes, fully);
+ }
+
+ public void Damp()
+ {
+ this._damp = true;
+ this._elapsed = 0f;
+ }
+
+ public void AddComponent<T>() where T : Component
+ {
+ Type typeFromHandle = typeof(T);
+ bool flag = !this._added_component.Contains(typeFromHandle);
+ if (flag)
+ {
+ this._camera.gameObject.AddComponent<T>();
+ this._added_component.Add(typeFromHandle);
+ }
+ }
+
+ public void OverrideAnimClip(string motion, AnimationClip clip)
+ {
+ bool flag = clip != null;
+ if (flag)
+ {
+ bool flag2 = this._overrideController[motion] != clip;
+ if (flag2)
+ {
+ this._overrideController[motion] = clip;
+ }
+ }
+ else
+ {
+ this._overrideController[motion] = null;
+ }
+ }
+
+ public void SyncTarget()
+ {
+ this._q_self_r = ((this.Target == null) ? Quaternion.identity : this.Target.MoveObj.Rotation);
+ this._v_self_p = ((this.Target == null) ? Vector3.zero : this.Target.MoveObj.Position);
+ }
+
+ public void LookAtTarget()
+ {
+ bool flag = this.Target != null;
+ if (flag)
+ {
+ this._cameraTransform.LookAt(this.Target.MoveObj.Position + ((this._dummyObject == null) ? Vector3.zero : this._dummyObject.transform.position));
+ }
+ }
+
+ public void ReCaleRoot(bool OnSolo = false)
+ {
+ bool flag = this._active_motion.MotionType == CameraMotionType.CameraBased;
+ if (flag)
+ {
+ if (OnSolo)
+ {
+ this._idle_root_rotation = Quaternion.Euler(this._idle_root_rotation_x, this._idle_root_rotation.eulerAngles.y, 0f);
+ }
+ else
+ {
+ this._idle_root_rotation = Quaternion.Euler(this._idle_root_rotation_x, this._idle_root_rotation_y, 0f);
+ }
+ this._root_pos = this._idle_root_rotation * this._dummyCamera.position;
+ }
+ }
+
+ public void AdjustRoot()
+ {
+ this._idle_root_rotation_x = this._idle_root_rotation.eulerAngles.x;
+ this._idle_root_rotation_y = this.CameraTrans.rotation.eulerAngles.y;
+ }
+
+ public void XRotate(float addation)
+ {
+ bool flag = this.Target is XPlayer && addation != 0f;
+ if (flag)
+ {
+ this._idle_root_rotation_x += addation;
+ float num = this._idle_root_basic_x + this._idle_root_rotation_x;
+ bool flag2 = num > XCameraEx.MaxV;
+ if (flag2)
+ {
+ this._idle_root_rotation_x = XCameraEx.MaxV - this._idle_root_basic_x;
+ }
+ else
+ {
+ bool flag3 = num < XCameraEx.MinV;
+ if (flag3)
+ {
+ this._idle_root_rotation_x = XCameraEx.MinV - this._idle_root_basic_x;
+ }
+ }
+ this.ReCaleRoot(false);
+ }
+ }
+
+ public void YRotate(float addation)
+ {
+ bool flag = this.Target is XPlayer && addation != 0f;
+ if (flag)
+ {
+ this._idle_root_rotation_y += addation;
+ this.ReCaleRoot(false);
+ }
+ }
+
+ public void XRotateEx(float x)
+ {
+ bool flag = this.Target is XPlayer;
+ if (flag)
+ {
+ this._idle_root_rotation_x = x;
+ x = this._idle_root_basic_x + this._idle_root_rotation_x;
+ bool flag2 = x > XCameraEx.MaxV;
+ if (flag2)
+ {
+ this._idle_root_rotation_x = XCameraEx.MaxV - this._idle_root_basic_x;
+ }
+ else
+ {
+ bool flag3 = x < XCameraEx.MinV;
+ if (flag3)
+ {
+ this._idle_root_rotation_x = XCameraEx.MinV - this._idle_root_basic_x;
+ }
+ }
+ this.ReCaleRoot(false);
+ }
+ }
+
+ public void YRotateEx(float y)
+ {
+ bool flag = this.Target is XPlayer;
+ if (flag)
+ {
+ this._idle_root_rotation_y = y;
+ this.ReCaleRoot(false);
+ }
+ }
+
+ public void XRotateExBarely(float addation)
+ {
+ bool flag = this._active_motion.MotionType == CameraMotionType.CameraBased && (this.Target is XPlayer || this.Target is XEmpty);
+ if (flag)
+ {
+ this._idle_root_rotation_x += addation;
+ float num = this._idle_root_basic_x + this._idle_root_rotation_x;
+ bool flag2 = num > XCameraEx.MaxV;
+ if (flag2)
+ {
+ this._idle_root_rotation_x = XCameraEx.MaxV - this._idle_root_basic_x;
+ }
+ else
+ {
+ bool flag3 = num < XCameraEx.MinV;
+ if (flag3)
+ {
+ this._idle_root_rotation_x = XCameraEx.MinV - this._idle_root_basic_x;
+ }
+ }
+ this._idle_root_rotation = Quaternion.Euler(this._idle_root_rotation_x, this._idle_root_rotation.eulerAngles.y, 0f);
+ this._root_pos = this._idle_root_rotation * this._dummyCamera.position;
+ }
+ }
+
+ public void YRotateExBarely(float y)
+ {
+ bool flag = this._active_motion.MotionType == CameraMotionType.CameraBased;
+ if (flag)
+ {
+ this._idle_root_rotation = Quaternion.Euler(this._idle_root_rotation.eulerAngles.x, y, 0f);
+ this._root_pos = this._idle_root_rotation * this._dummyCamera.position;
+ }
+ }
+
+ public override void PostUpdate(float fDeltaT)
+ {
+ bool flag = this.Tail != null && XOperationData.Is3DMode();
+ if (flag)
+ {
+ this.Tail.TailUpdate(fDeltaT);
+ }
+ bool flag2 = !this._root_pos_inited;
+ if (flag2)
+ {
+ Vector3 vector = Vector3.Cross(this._dummyCamera.forward, this._dummyCamera.up);
+ this._dummyCamera_quat = Quaternion.LookRotation(vector, this._dummyCamera.up);
+ this._dummyCamera_rot = this._dummyCamera_quat.eulerAngles;
+ bool flag3 = !this._init_idle_root_basic_x;
+ if (flag3)
+ {
+ this._idle_root_basic_x = this._dummyCamera_rot.x;
+ this._basic_dis = (this._dummyCamera.position - this._dummyObject.transform.position).magnitude;
+ }
+ bool autoSync_At_Begin = this._active_motion.AutoSync_At_Begin;
+ if (autoSync_At_Begin)
+ {
+ this.SyncTarget();
+ }
+ CameraMotionType motionType = this._active_motion.MotionType;
+ if (motionType != CameraMotionType.AnchorBased)
+ {
+ if (motionType == CameraMotionType.CameraBased)
+ {
+ this._idle_root_rotation = ((this.Target is XPlayer) ? Quaternion.Euler(this._idle_root_rotation_x, this._idle_root_rotation_y, 0f) : ((this.Target is XEmpty && !XCameraEx.OperationV) ? Quaternion.Euler(this._idle_root_rotation_x, 0f, 0f) : Quaternion.identity));
+ }
+ }
+ else
+ {
+ this._idle_root_rotation = Quaternion.identity;
+ }
+ this._root_pos = this._idle_root_rotation * this._dummyCamera.position;
+ this._root_pos_inited = true;
+ this._init_idle_root_basic_x = true;
+ }
+ this.InnerUpdateEx();
+ base.PostUpdate(fDeltaT);
+ bool flag4 = this._closeup != null;
+ if (flag4)
+ {
+ this._closeup.CloseUpdate(fDeltaT);
+ }
+ bool flag5 = this._motion != null;
+ if (flag5)
+ {
+ this._motion.MotionUpdate(fDeltaT);
+ }
+ }
+
+ public bool BackToPlayer()
+ {
+ bool operationH = XCameraEx.OperationH;
+ bool result;
+ if (operationH)
+ {
+ XSingleton<XScene>.singleton.GameCamera.Root_R_Y_Default = XSingleton<XEntityMgr>.singleton.Player.EngineObject.Rotation.eulerAngles.y;
+ XSingleton<XScene>.singleton.GameCamera.Root_R_Y = XSingleton<XScene>.singleton.GameCamera.Root_R_Y_Default;
+ bool flag = XSingleton<XScene>.singleton.GameCamera.Wall != null;
+ if (flag)
+ {
+ XSingleton<XScene>.singleton.GameCamera.Wall.TargetY = XSingleton<XScene>.singleton.GameCamera.Root_R_Y_Default;
+ }
+ result = true;
+ }
+ else
+ {
+ result = false;
+ }
+ return result;
+ }
+
+ public void FovBack()
+ {
+ bool flag = XSingleton<XCutScene>.singleton.IsPlaying && XSingleton<XEntityMgr>.singleton.Boss != null;
+ if (flag)
+ {
+ uint fov = (XSingleton<XEntityMgr>.singleton.Boss.Attributes as XOthersAttributes).Fov;
+ bool flag2 = fov > 0u;
+ if (flag2)
+ {
+ float num = Mathf.Tan(0.0174532924f * this._field_of_view * 0.5f) * this.TargetOffset;
+ this.TargetOffset = num / Mathf.Tan(0.0174532924f * fov * 0.5f);
+ this.DefaultOffset = this.TargetOffset;
+ this._field_of_view = fov;
+ }
+ }
+ this._cameraObject.GetComponent<Camera>().fieldOfView = this._field_of_view;
+ }
+
+ public void SolidBlack()
+ {
+ this._camera.clearFlags = (CameraClearFlags)2;
+ this._camera.backgroundColor = Color.black;
+ this._camera.cullingMask = 7106048;
+ }
+
+ public void SolidCancel()
+ {
+ bool flag = this._camera == null;
+ if (!flag)
+ {
+ this._camera.clearFlags = (CameraClearFlags)1;
+ XQualitySetting.XSetting currentQualitySetting = XQualitySetting.GetCurrentQualitySetting();
+ this._camera.cullingMask = -1;
+ this._camera.cullingMask &= ~(XQualitySetting._QualityHighLayerOffset | XQualitySetting._QualityNormalLayerOffset);
+ this._camera.cullingMask |= currentQualitySetting._CullMask;
+ this._camera.cullingMask &= ~XQualitySetting._InvisiblityLayerOffset;
+ this._camera.cullingMask &= ~XQualitySetting._UILayerOffset;
+ }
+ }
+
+ public void TrySolo()
+ {
+ bool flag = this._solo == null || XSingleton<XEntityMgr>.singleton.Player == null;
+ if (!flag)
+ {
+ bool flag2 = !XEntity.ValideEntity(this._solo.Target);
+ if (flag2)
+ {
+ this._solo.Stop();
+ }
+ bool flag3 = this._solo.SoloState == XCameraSoloComponent.XCameraSoloState.Stop;
+ if (flag3)
+ {
+ XEntity xentity = null;
+ List<XEntity> opponent = XSingleton<XEntityMgr>.singleton.GetOpponent(XSingleton<XScene>.singleton.bSpectator ? XSingleton<XEntityMgr>.singleton.Player.WatchTo : XSingleton<XEntityMgr>.singleton.Player);
+ for (int i = 0; i < opponent.Count; i++)
+ {
+ bool flag4 = XSingleton<XSceneMgr>.singleton.Is1V1Scene();
+ if (flag4)
+ {
+ bool flag5 = opponent[i].IsRole && XEntity.ValideEntity(opponent[i]);
+ if (flag5)
+ {
+ xentity = opponent[i];
+ break;
+ }
+ }
+ else
+ {
+ bool soloShow = opponent[i].Attributes.SoloShow;
+ if (soloShow)
+ {
+ xentity = opponent[i];
+ break;
+ }
+ }
+ }
+ bool flag6 = xentity != null;
+ if (flag6)
+ {
+ XCameraSoloEventArgs @event = XEventPool<XCameraSoloEventArgs>.GetEvent();
+ @event.Target = xentity;
+ @event.Firer = this;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ }
+ }
+ }
+ }
+
+ public void SetSightType()
+ {
+ float num = XSingleton<XOperationData>.singleton.CameraAngle;
+ float cameraDistance = XSingleton<XOperationData>.singleton.CameraDistance;
+ XCameraEx.OperationH = XSingleton<XOperationData>.singleton.AllowHorizontal;
+ XCameraEx.OperationV = XSingleton<XOperationData>.singleton.AllowVertical;
+ XCameraEx.MaxV = XSingleton<XOperationData>.singleton.MaxVertical;
+ XCameraEx.MinV = XSingleton<XOperationData>.singleton.MinVertical;
+ bool flag = XCameraEx.MaxV < XCameraEx.MinV;
+ if (flag)
+ {
+ XCameraEx.MaxV = XCameraEx.MinV;
+ }
+ bool flag2 = num > XCameraEx.MaxV;
+ if (flag2)
+ {
+ num = XCameraEx.MaxV;
+ }
+ bool flag3 = num < XCameraEx.MinV;
+ if (flag3)
+ {
+ num = XCameraEx.MinV;
+ }
+ bool flag4 = false;
+ bool flag5 = !XCameraEx.OperationH || XSingleton<XOperationData>.singleton.OffSolo;
+ if (flag5)
+ {
+ bool flag6 = this._solo != null && this._solo.SoloState != XCameraSoloComponent.XCameraSoloState.Stop;
+ if (flag6)
+ {
+ flag4 = true;
+ this._solo.Stop();
+ this.Target = XSingleton<XEntityMgr>.singleton.Player;
+ }
+ }
+ bool flag7 = this._adjust != null;
+ if (flag7)
+ {
+ this._adjust.Enabled = (XOperationData.Is3DMode() && !XCameraEx.OperationV);
+ }
+ bool flag8 = this._wall != null && !XCameraEx.OperationH;
+ if (flag8)
+ {
+ this.YRotate(this._wall.TargetY - this.Root_R_Y);
+ }
+ this.Root_R_X_Default = num - this._idle_root_basic_x;
+ this.Root_R_X_Target = this.Root_R_X_Default;
+ this.DefaultOffset = cameraDistance;
+ this.TargetOffset = cameraDistance;
+ this.Root_R_X = this.Root_R_X_Target;
+ bool flag9 = XCameraEx.OperationH && !XSingleton<XOperationData>.singleton.OffSolo;
+ if (flag9)
+ {
+ this.TrySolo();
+ }
+ bool flag10 = !flag4;
+ if (flag10)
+ {
+ this.ReCaleRoot(this._solo != null && this._solo.SoloState == XCameraSoloComponent.XCameraSoloState.Executing);
+ }
+ }
+
+ private void InnerPosition()
+ {
+ Vector3 vector = this._dummyCamera.position;
+ bool flag = this._active_motion.MotionType == CameraMotionType.CameraBased && (this.Target is XPlayer || this.Target is XEmpty);
+ if (flag)
+ {
+ Vector3 vector2 = this._dummyCamera.position - this._dummyObject.transform.position;
+ float num = vector2.magnitude;
+ vector2.Normalize();
+ bool flag2 = vector2.z > 0f;
+ if (flag2)
+ {
+ num = -num;
+ vector2 = -vector2;
+ }
+ float num2 = num - this._basic_dis;
+ float num3 = this.TargetOffset + num2;
+ bool flag3 = num3 <= 0f;
+ if (flag3)
+ {
+ num3 = 0.1f;
+ }
+ vector = this._dummyObject.transform.position + num3 * vector2;
+ }
+ this._dummyCamera_pos = this._idle_root_rotation * (vector - this._dummyObject.transform.position) + this._dummyObject.transform.position;
+ bool damp = this._damp;
+ if (damp)
+ {
+ this._damp_dir = this._dummyCamera_pos - this._last_dummyCamera_pos;
+ bool flag4 = this._elapsed == 0f;
+ if (flag4)
+ {
+ this._damp_delta = this._damp_dir.magnitude;
+ }
+ this._damp_dir.Normalize();
+ bool flag5 = this._elapsed > this._damp_factor;
+ if (flag5)
+ {
+ this._elapsed = this._damp_factor;
+ this._damp = false;
+ }
+ this._dummyCamera_pos -= this._damp_dir * (this._damp_delta * ((this._damp_factor - this._elapsed) / this._damp_factor));
+ this._elapsed += Time.deltaTime;
+ }
+ this._last_dummyCamera_pos = this._dummyCamera_pos;
+ }
+
+ private void InnerUpdateEx()
+ {
+ this.InnerPosition();
+ Quaternion quaternion = Quaternion.identity;
+ bool flag = this.Target != null;
+ if (flag)
+ {
+ quaternion = this.Target.MoveObj.Rotation;
+ }
+ bool flag2 = this._active_motion.MotionType == CameraMotionType.AnchorBased && this.Target != null;
+ if (flag2)
+ {
+ this._q_self_r = quaternion;
+ }
+ Quaternion quaternion2 = (this.Target == null) ? Quaternion.identity : quaternion;
+ Vector3 vector = (this.Target == null) ? Vector3.zero : this.Target.MoveObj.Position;
+ Vector3 vector2 = Vector3.Cross(this._dummyCamera.forward, this._dummyCamera.up);
+ this._dummyCamera_quat = Quaternion.LookRotation(vector2, this._dummyCamera.up);
+ this._dummyCamera_rot = this._dummyCamera_quat.eulerAngles;
+ Vector3 vector3 = this._dummyCamera_pos - this._root_pos;
+ Vector3 vector4 = (this._active_motion.AutoSync_At_Begin ? this._q_self_r : Quaternion.identity) * this._root_pos;
+ vector3 = (this._active_motion.AutoSync_At_Begin ? this._q_self_r : Quaternion.identity) * vector3;
+ bool flag3 = !this._active_motion.LookAt_Target;
+ if (flag3)
+ {
+ this._cameraTransform.rotation = (this._active_motion.AutoSync_At_Begin ? this._q_self_r : Quaternion.identity) * this._idle_root_rotation * this._dummyCamera_quat;
+ }
+ vector4 += (this._active_motion.Follow_Position ? vector : (this._active_motion.AutoSync_At_Begin ? this._v_self_p : Vector3.zero));
+ CameraMotionSpace coordinate = this._active_motion.Coordinate;
+ if (coordinate != CameraMotionSpace.World)
+ {
+ if (coordinate == CameraMotionSpace.Self)
+ {
+ vector4 += (this._active_motion.Follow_Position ? Quaternion.identity : quaternion2) * vector3;
+ }
+ }
+ else
+ {
+ vector4 += vector3;
+ }
+ this._cameraTransform.position = vector4;
+ bool lookAt_Target = this._active_motion.LookAt_Target;
+ if (lookAt_Target)
+ {
+ this.LookAtTarget();
+ }
+ }
+
+ public void SetCameraLayer(int layer, bool add)
+ {
+ if (add)
+ {
+ this._camera.cullingMask |= 1 << layer;
+ }
+ else
+ {
+ this._camera.cullingMask &= ~(1 << layer);
+ }
+ }
+
+ public void SetCameraLayer(int layermask)
+ {
+ this._camera.cullingMask = layermask;
+ }
+
+ public int GetCameraLayer()
+ {
+ return this._camera.cullingMask;
+ }
+
+ public void SetSolidBlack(bool enabled)
+ {
+ if (enabled)
+ {
+ this._camera.clearFlags = (CameraClearFlags)2;
+ this._camera.backgroundColor = Color.black;
+ }
+ else
+ {
+ this._camera.clearFlags = (CameraClearFlags)1;
+ }
+ }
+
+ public void SetReplaceCameraShader(Shader shader)
+ {
+ bool flag = shader != null && this._camera != null;
+ if (flag)
+ {
+ this._camera.SetReplacementShader(shader, "RenderType");
+ }
+ }
+ }
+}
|