+scripts

1 files changed, 235 insertions, 0 deletions

diff --git a/Client/Assets/Scripts/XMainClient/XCustomShadow.cs b/Client/Assets/Scripts/XMainClient/XCustomShadow.cs
new file mode 100644
index 00000000..de712fc6
--- /dev/null
+++ b/Client/Assets/Scripts/XMainClient/XCustomShadow.cs
@@ -0,0 +1,235 @@
+using System;

+using UnityEngine;

+using XUtliPoolLib;

+

+namespace XMainClient

+{

+	[RequireComponent(typeof(Camera))]

+	public class XCustomShadow : MonoBehaviour

+	{

+		public int shadowChannel = 0;

+

+		public ShadowMapInfo shadowMapInfoRef = null;

+

+		public Camera m_shadowCamera = null;

+

+		private Transform m_shadowCameraTransformCache = null;

+

+		private Transform m_TargetTransformCache = null;

+

+		public Transform m_modifyEntityTransformCache = null;

+

+		public static float scale = 0.33f;

+

+		public float bias = 0.5f;

+

+		private Vector3 m_lastShadowPos = Vector3.zero;

+

+		private Transform m_lightTransformCache = null;

+

+		private Vector3 m_invLightForwardDir = new Vector3(0f, 0f, -1f);

+

+		private Vector3 m_lightRightDir = new Vector3(1f, 0f, 0f);

+

+		private Vector3 m_lightUpDir = new Vector3(0f, 1f, 0f);

+

+		public Matrix4x4 scaleBiasMatrix = Matrix4x4.identity;

+

+		private static Texture shadowMask = null;

+

+		public static XCustomShadow Create(Transform parent, ShadowMapInfo sg)

+		{

+			GameObject gameObject = new GameObject("ShadowProjector");

+			Camera camera = gameObject.AddComponent<Camera>();

+			XCustomShadow xcustomShadow = gameObject.AddComponent<XCustomShadow>();

+			xcustomShadow.m_shadowCamera = camera;

+			xcustomShadow.shadowMapInfoRef = sg;

+			xcustomShadow.m_shadowCameraTransformCache = gameObject.transform;

+			camera.useOcclusionCulling = false;

+			camera.clearFlags = (CameraClearFlags)2;

+			camera.backgroundColor = new Color(1f, 1f, 1f, 1f);

+			camera.farClipPlane = 5f;

+			camera.orthographicSize = 1.5f;

+			camera.orthographic = true;

+			camera.depth = -2f;

+			camera.cullingMask = 0;

+			camera.cullingMask |= 1 << XPlayer.PlayerLayer;

+			camera.targetTexture = sg.shadowMap;

+			camera.enabled = false;

+			xcustomShadow.enabled = false;

+			return xcustomShadow;

+		}

+

+		public void Begin(XGameObject target)

+		{

+			bool flag = this.OnTargetChange(target);

+			if (flag)

+			{

+				bool flag2 = this.m_shadowCamera != null;

+				if (flag2)

+				{

+					this.m_shadowCamera.orthographicSize = 1.5f;

+					this.scaleBiasMatrix = Matrix4x4.Scale(Vector3.one);

+					Shader shader = null;

+					int num = this.shadowChannel;

+					switch (num)

+					{

+					case 1:

+						shader = ShaderManager._maskR;

+						break;

+					case 2:

+						shader = ShaderManager._maskG;

+						break;

+					case 3:

+						break;

+					case 4:

+						shader = ShaderManager._maskB;

+						break;

+					default:

+						if (num == 8)

+						{

+							shader = ShaderManager._maskA;

+						}

+						break;

+					}

+					bool flag3 = shader != null;

+					if (flag3)

+					{

+						this.m_shadowCamera.SetReplacementShader(shader, "RenderType");

+						bool flag4 = XCustomShadow.shadowMask == null;

+						if (flag4)

+						{

+							XCustomShadow.shadowMask = XSingleton<XResourceLoaderMgr>.singleton.GetSharedResource<Texture>("Shader/Shadow/ShadowMask", ".png", true, false);

+							Shader.SetGlobalTexture("_ShadowMask", XCustomShadow.shadowMask);

+						}

+					}

+				}

+			}

+			bool flag5 = this.m_shadowCamera != null;

+			if (flag5)

+			{

+				this.m_shadowCamera.enabled = true;

+			}

+			base.enabled = true;

+		}

+

+		public void Clear(bool destroy)

+		{

+			bool flag = this.shadowMapInfoRef != null;

+			if (flag)

+			{

+				this.shadowMapInfoRef.FreeChannel(this.shadowChannel);

+				this.shadowMapInfoRef = null;

+			}

+			this.shadowChannel = 0;

+			this.m_lightTransformCache = null;

+			this.m_TargetTransformCache = null;

+			bool flag2 = this.m_shadowCamera != null;

+			if (flag2)

+			{

+				this.m_shadowCamera.enabled = false;

+			}

+			base.enabled = false;

+			if (destroy)

+			{

+				bool flag3 = this.m_shadowCamera != null;

+				if (flag3)

+				{

+					this.m_shadowCamera.targetTexture = null;

+				}

+				bool flag4 = XCustomShadow.shadowMask != null;

+				if (flag4)

+				{

+					XSingleton<XResourceLoaderMgr>.singleton.UnSafeDestroyShareResource("Shader/Shadow/ShadowMask", ".png", XCustomShadow.shadowMask, false);

+					XCustomShadow.shadowMask = null;

+					Shader.SetGlobalTexture("_ShadowMask", null);

+				}

+				this.m_shadowCameraTransformCache = null;

+				UnityEngine.Object.Destroy(base.gameObject);

+			}

+		}

+

+		public bool OnTargetChange(XGameObject target)

+		{

+			Transform transform = (target != null) ? target.Find("") : null;

+			bool flag = this.m_TargetTransformCache != transform;

+			bool result;

+			if (flag)

+			{

+				this.m_TargetTransformCache = transform;

+				this.m_lightTransformCache = null;

+				result = true;

+			}

+			else

+			{

+				result = false;

+			}

+			return result;

+		}

+

+		public void SetCullLayer(bool enable)

+		{

+			bool flag = this.m_shadowCamera != null;

+			if (flag)

+			{

+				this.m_shadowCamera.cullingMask = 0;

+				if (enable)

+				{

+					this.m_shadowCamera.cullingMask |= 1 << XPlayer.PlayerLayer;

+				}

+				else

+				{

+					this.m_shadowCamera.cullingMask |= int.MinValue;

+				}

+			}

+		}

+

+		private void Update()

+		{

+			bool flag = this.m_lightTransformCache == null;

+			if (flag)

+			{

+				Light mainLight = XQualitySetting.mainLight;

+				bool flag2 = mainLight != null;

+				if (flag2)

+				{

+					this.m_lightTransformCache = mainLight.transform;

+					bool flag3 = this.m_lightTransformCache != null;

+					if (flag3)

+					{

+						this.m_invLightForwardDir = -this.m_lightTransformCache.forward;

+						this.m_lightRightDir = this.m_lightTransformCache.right;

+						this.m_lightUpDir = this.m_lightTransformCache.up;

+					}

+				}

+			}

+			bool flag4 = this.m_shadowCameraTransformCache != null && this.m_lightTransformCache != null && this.m_TargetTransformCache != null;

+			if (flag4)

+			{

+				Vector3 position = this.m_shadowCameraTransformCache.position;

+				float num = this.m_lastShadowPos.x * position.x + this.m_lastShadowPos.y * position.y + this.m_lastShadowPos.z * position.z;

+				float num2 = Quaternion.Angle(this.m_shadowCameraTransformCache.rotation, this.m_lightTransformCache.rotation);

+				bool flag5 = num2 >= 5f || num > 0.5f;

+				if (flag5)

+				{

+					this.m_shadowCameraTransformCache.rotation = this.m_lightTransformCache.rotation;

+					this.m_shadowCameraTransformCache.position = this.m_TargetTransformCache.position + this.m_invLightForwardDir * 2f + this.m_lightRightDir * 0.4f + this.m_lightUpDir * 0.2f;

+					this.m_lastShadowPos = this.m_shadowCameraTransformCache.position;

+					this.scaleBiasMatrix[0, 0] = XCustomShadow.scale;

+					this.scaleBiasMatrix[1, 1] = XCustomShadow.scale;

+					this.scaleBiasMatrix[2, 2] = XCustomShadow.scale;

+					this.scaleBiasMatrix[0, 3] = this.bias;

+					this.scaleBiasMatrix[1, 3] = this.bias;

+					this.scaleBiasMatrix[2, 3] = this.bias;

+					Matrix4x4 matrix4x = this.scaleBiasMatrix * this.m_shadowCamera.worldToCameraMatrix;

+					Shader.SetGlobalMatrix("custom_World2Shadow", matrix4x);

+				}

+				bool flag6 = this.m_modifyEntityTransformCache != this.m_TargetTransformCache && this.m_modifyEntityTransformCache != null;

+				if (flag6)

+				{

+					this.m_TargetTransformCache = this.m_modifyEntityTransformCache;

+				}

+			}

+		}

+	}

+}