unity3d 摄像机抖动特效

摄像机抖动特效 在需要的地方调用CameraShake.Shake()方法就可以

 

public class CameraShake : MonoBehaviour
	{
		/// 
		/// The cameras to shake.
		/// 
		public List cameras										= new List();
		/// 
		/// The maximum number of shakes to perform.
		/// 
		public int numberOfShakes										= 2;
		/// 
		/// The amount to shake in each direction.
		/// 
		public Vector3 shakeAmount										= Vector3.one;
		/// 
		/// The amount to rotate in each direction.
		/// 
		public Vector3 rotationAmount									= Vector3.one;
		/// 
		/// The initial distance for the first shake.
		/// 
		public float distance											= 00.10f;
		/// 
		/// The speed multiplier for the shake.
		/// 
		public float speed												= 50.00f;
		/// 
		/// The decay speed (between 0 and 1). Higher values will stop shaking sooner.
		/// 
		public float decay												= 00.20f;
		/// 
		/// The modifier applied to speed in order to shake the GUI.
		/// 
		public float guiShakeModifier									= 01.00f;
		/// 
		/// If true, multiplies the final shake speed by the time scale.
		/// 
		public bool multiplyByTimeScale									= true;
		
		// Shake rect (for GUI)
		private Rect shakeRect;
		
		// States
		private bool shaking											= false;
		private bool cancelling											= false;

		internal class ShakeState
		{
			internal readonly Vector3 startPosition;
			internal readonly Quaternion startRotation;
			internal readonly Vector2 guiStartPosition;
			internal Vector3 shakePosition;
			internal Quaternion shakeRotation;
			internal Vector2 guiShakePosition;
			
			internal ShakeState(Vector3 position, Quaternion rotation, Vector2 guiPosition)
			{
				startPosition = position;
				startRotation = rotation;
				guiStartPosition = guiPosition;
				shakePosition = position;
				shakeRotation = rotation;
				guiShakePosition = guiPosition;
			}
		}
		private Dictionary> states				= new Dictionary>();
		private Dictionary shakeCount						= new Dictionary();
		
		// Minimum shake values
		private const bool checkForMinimumValues						= true;
		private const float minShakeValue								= 0.001f;
		private const float minRotationValue							= 0.001f;
		
		#region Singleton
		/// 
		/// The Camera Shake singleton instance.
		/// 
		public static CameraShake instance;	
		private void OnEnable()
		{
			if (cameras.Count < 1)
			{
				if (camera)
					cameras.Add(camera);
			}
			
			if (cameras.Count < 1)
			{
				if (Camera.main)
					cameras.Add(Camera.main);
			}
			
			if (cameras.Count < 1)
			{
				Debug.LogError("Camera Shake: No cameras assigned in the inspector!");
			}
			instance = this;
		}
		#endregion
		
		#region Static properties
		public static bool isShaking
		{
			get
			{
				return instance.IsShaking();
			}
		}
		public static bool isCancelling
		{
			get
			{
				return instance.IsCancelling();
			}
		}
		#endregion
		
		#region Static methods
		public static void Shake()
		{
			instance.DoShake();
		}		
		public static void Shake(int numberOfShakes, Vector3 shakeAmount, Vector3 rotationAmount, float distance, float speed, float decay, float guiShakeModifier, bool multiplyByTimeScale)
		{
			instance.DoShake(numberOfShakes, shakeAmount, rotationAmount, distance, speed, decay, guiShakeModifier, multiplyByTimeScale);
		}
		public static void Shake(System.Action callback)
		{
			instance.DoShake(callback);
		}		
		public static void Shake(int numberOfShakes, Vector3 shakeAmount, Vector3 rotationAmount, float distance, float speed, float decay, float guiShakeModifier, bool multiplyByTimeScale, System.Action callback)
		{
			instance.DoShake(numberOfShakes, shakeAmount, rotationAmount, distance, speed, decay, guiShakeModifier, multiplyByTimeScale, callback);
		}
		public static void CancelShake()
		{
			instance.DoCancelShake();
		}
		public static void CancelShake(float time)
		{
			instance.DoCancelShake(time);
		}
		
		public static void BeginShakeGUI()
		{
			instance.DoBeginShakeGUI();
		}
		public static void EndShakeGUI()
		{
			instance.DoEndShakeGUI();
		}	
		public static void BeginShakeGUILayout()
		{
			instance.DoBeginShakeGUILayout();
		}		
		public static void EndShakeGUILayout()
		{
			instance.DoEndShakeGUILayout();
		}
		#endregion
		
		#region Events
		/// 
		/// Occurs when a camera starts shaking.
		/// 
		public event System.Action cameraShakeStarted; 
		/// 
		/// Occurs when a camera has completely stopped shaking and has been reset to its original position.
		/// 
		public event System.Action allCameraShakesCompleted;
		#endregion
		
		#region Public methods
		public bool IsShaking()
		{	
			return shaking;
		}
		public bool IsCancelling()
		{
			return cancelling;
		}
		public void DoShake()
		{
			Vector3 seed = Random.insideUnitSphere;
			
			foreach(Camera cam in cameras)
			{
				StartCoroutine(DoShake_Internal(cam, seed, this.numberOfShakes, this.shakeAmount, this.rotationAmount, this.distance, this.speed, this.decay, this.guiShakeModifier, this.multiplyByTimeScale, null));
			}
		}
		public void DoShake(int numberOfShakes, Vector3 shakeAmount, Vector3 rotationAmount, float distance, float speed, float decay, float guiShakeModifier, bool multiplyByTimeScale)
		{
			Vector3 seed = Random.insideUnitSphere;
			
			foreach(Camera cam in cameras)
			{
				StartCoroutine(DoShake_Internal(cam, seed, numberOfShakes, shakeAmount, rotationAmount, distance, speed, decay, guiShakeModifier, multiplyByTimeScale, null));
			}
		}
		public void DoShake(System.Action callback)
		{
			Vector3 seed = Random.insideUnitSphere;
			
			foreach(Camera cam in cameras)
			{
				StartCoroutine(DoShake_Internal(cam, seed, this.numberOfShakes, this.shakeAmount, this.rotationAmount, this.distance, this.speed, this.decay, this.guiShakeModifier, this.multiplyByTimeScale, callback));
			}
		}
		public void DoShake(int numberOfShakes, Vector3 shakeAmount, Vector3 rotationAmount, float distance, float speed, float decay, float guiShakeModifier, bool multiplyByTimeScale, System.Action callback)
		{
			Vector3 seed = Random.insideUnitSphere;
			
			foreach(Camera cam in cameras)
			{
				StartCoroutine(DoShake_Internal(cam, seed, numberOfShakes, shakeAmount, rotationAmount, distance, speed, decay, guiShakeModifier, multiplyByTimeScale, callback));
			}
		}
		public void DoCancelShake()
		{
			if (shaking && !cancelling)
			{
				shaking = false;
				this.StopAllCoroutines();
				foreach(Camera cam in cameras)
				{
					if (shakeCount.ContainsKey(cam))
					{
						shakeCount[cam] = 0;
					}
					ResetState(cam.transform, cam);
				}
			}
		}
		public void DoCancelShake(float time)
		{
			if (shaking && !cancelling)
			{
				this.StopAllCoroutines();
				this.StartCoroutine(DoResetState(cameras, shakeCount, time));
			}
		}
		public void DoBeginShakeGUI()
		{
			CheckShakeRect();
			GUI.BeginGroup(shakeRect);
		}
		public void DoEndShakeGUI()
		{
			GUI.EndGroup();
		}	
		public void DoBeginShakeGUILayout()
		{
			CheckShakeRect();
			GUILayout.BeginArea(shakeRect);
		}	
		public void DoEndShakeGUILayout()
		{
			GUILayout.EndArea();
		}
		#endregion
		
		#region Private methods
		private void OnDrawGizmosSelected()
		{	
			foreach(Camera cam in cameras)
			{
				if (!cam)
					continue;
				
				if (IsShaking())
				{
					Vector3 offset = cam.worldToCameraMatrix.GetColumn(3);
					offset.z *= -1;
					offset = cam.transform.position + cam.transform.TransformPoint(offset);
					Quaternion rot = QuaternionFromMatrix(cam.worldToCameraMatrix.inverse * Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(1,1,-1)));
					Matrix4x4 matrix = Matrix4x4.TRS(offset, rot, cam.transform.lossyScale);
					Gizmos.matrix = matrix; 
				}
				else
				{
					Matrix4x4 matrix = Matrix4x4.TRS(cam.transform.position, cam.transform.rotation, cam.transform.lossyScale);
					Gizmos.matrix = matrix;
				}
				
				Gizmos.DrawWireCube(Vector3.zero, shakeAmount);
				
				Gizmos.color = Color.cyan;
				
				if (cam.isOrthoGraphic)
				{
					Vector3 pos = new Vector3(0, 0, (cam.near + cam.far) / 2f);
					Vector3 size = new Vector3(cam.orthographicSize / cam.aspect, cam.orthographicSize * 2f, cam.far - cam.near);
					Gizmos.DrawWireCube(pos, size);
				}
				else
				{
					Gizmos.DrawFrustum(Vector3.zero, cam.fov, cam.far, cam.near, (.7f / cam.aspect));
				}
			}
		}
		
		private IEnumerator DoShake_Internal(Camera cam, Vector3 seed, int numberOfShakes, Vector3 shakeAmount, Vector3 rotationAmount, float distance, float speed, float decay, float guiShakeModifier, bool multiplyByTimeScale, System.Action callback)
		{
			// Wait for async cancel operations to complete
			if (cancelling)
				yield return null;

			// Set random values
			var mod1 = seed.x > .5f ? 1 : -1;
			var mod2 = seed.y > .5f ? 1 : -1;
			var mod3 = seed.z > .5f ? 1 : -1;
			
			// First shake
			if (!shaking)
			{
				shaking = true;
				
				if (cameraShakeStarted != null)
					cameraShakeStarted();
			}
			
			if (shakeCount.ContainsKey(cam))
				shakeCount[cam]++;
			else
				shakeCount.Add(cam, 1);
			
			// Pixel width is always based on the first camera
			float pixelWidth = GetPixelWidth(cameras[0].transform, cameras[0]);
			
			// Set other values
			Transform cachedTransform = cam.transform;
			Vector3 camOffset = Vector3.zero;
			Quaternion camRot = Quaternion.identity;

			int currentShakes = numberOfShakes;
			float shakeDistance = distance;
			float rotationStrength = 1;
			
			float startTime = Time.time;
			float scale = multiplyByTimeScale ? Time.timeScale : 1;
			float pixelScale = pixelWidth * guiShakeModifier * scale;
			Vector3 start1 = Vector2.zero;
			Quaternion startR = Quaternion.identity;
			Vector2 start2 = Vector2.zero;
			
			ShakeState state = new ShakeState(cachedTransform.position, cachedTransform.rotation, new Vector2(shakeRect.x, shakeRect.y));
			List stateList;
			
			if (states.TryGetValue(cam, out stateList))
			{
				stateList.Add(state);
			}
			else
			{
				stateList = new List();
				stateList.Add(state);
				states.Add(cam, stateList);
			}
			
			// Main loop
			while (currentShakes > 0)
			{	
				if (checkForMinimumValues)
				{
					// Early break when rotation is less than the minimum value.
					if (rotationAmount.sqrMagnitude != 0 && rotationStrength <= minRotationValue)
						break;
					
					// Early break when shake amount is less than the minimum value.
					if (shakeAmount.sqrMagnitude != 0 && distance != 0 && shakeDistance <= minShakeValue)
						break;
				}
				
				var timer = (Time.time - startTime) * speed;
				
				state.shakePosition = start1 + new Vector3(
					mod1 * Mathf.Sin(timer) * (shakeAmount.x * shakeDistance * scale), 
					mod2 * Mathf.Cos(timer) * (shakeAmount.y * shakeDistance * scale), 
					mod3 * Mathf.Sin(timer) * (shakeAmount.z * shakeDistance * scale));
				
				state.shakeRotation = startR * Quaternion.Euler(
					mod1 * Mathf.Cos(timer) * (rotationAmount.x * rotationStrength * scale), 
					mod2 * Mathf.Sin(timer) * (rotationAmount.y * rotationStrength * scale),  
					mod3 * Mathf.Cos(timer) * (rotationAmount.z * rotationStrength * scale));
				
				state.guiShakePosition = new Vector2(
					start2.x - (mod1 * Mathf.Sin(timer) * (shakeAmount.x * shakeDistance * pixelScale)),
					start2.y - (mod2 * Mathf.Cos(timer) * (shakeAmount.y * shakeDistance * pixelScale)));
				
				camOffset = GetGeometricAvg(stateList, true);
				camRot = GetAvgRotation(stateList); 
				NormalizeQuaternion(ref camRot);
				
				Matrix4x4 m = Matrix4x4.TRS(camOffset, camRot, new Vector3(1, 1, -1));
        		
				cam.worldToCameraMatrix = m * cachedTransform.worldToLocalMatrix;
				
				var avg = GetGeometricAvg(stateList, false);

				shakeRect.x = avg.x;
				shakeRect.y = avg.y;

				if (timer > Mathf.PI * 2)
				{
					startTime = Time.time;
					shakeDistance *= (1 - Mathf.Clamp01(decay));
					rotationStrength *= (1 - Mathf.Clamp01(decay));
					currentShakes--;
				}
				yield return null;
			}
			
			// End conditions
			
			shakeCount[cam]--;
			
			// Last shake
			if (shakeCount[cam] == 0)
			{
				shaking = false;
				ResetState(cam.transform, cam);
				
				if (allCameraShakesCompleted != null)
				{
					allCameraShakesCompleted();
				}
			}
			else
			{
				stateList.Remove(state);
			}
			
			if (callback != null)
				callback();
		}
		private Vector3 GetGeometricAvg(List states, bool position)
		{	
			float x = 0, y = 0, z = 0, l = states.Count;
			
			foreach(ShakeState state in states)
			{
				if (position)
				{
					x -= state.shakePosition.x;
					y -= state.shakePosition.y;
					z -= state.shakePosition.z;
				}
				else
				{
					x += state.guiShakePosition.x;
					y += state.guiShakePosition.y;
				}
			}
			
			return new Vector3(x / l, y / l, z / l);
		}	
		private Quaternion GetAvgRotation(List states)
		{
			Quaternion avg = new Quaternion(0,0,0,0);
			
			foreach(ShakeState state in states)
			{
				if (Quaternion.Dot (state.shakeRotation, avg) > 0)
				{
					avg.x += state.shakeRotation.x;
					avg.y += state.shakeRotation.y;
					avg.z += state.shakeRotation.z;
					avg.w += state.shakeRotation.w;
				}
				else
				{
					avg.x += -state.shakeRotation.x;
					avg.y += -state.shakeRotation.y;
					avg.z += -state.shakeRotation.z;
					avg.w += -state.shakeRotation.w;
				}
			}
			
			var mag = Mathf.Sqrt(avg.x* avg.x + avg.y* avg.y + avg.z * avg.z + avg.w * avg.w);
			
			if (mag > 0.0001f)
			{
				avg.x /= mag;
				avg.y /= mag;
				avg.z /= mag;
				avg.w /= mag;
			}
			else
			{
				avg = states[0].shakeRotation;
			}
			
			return avg;
		}
		private void CheckShakeRect()
		{
			if (Screen.width != shakeRect.width || Screen.height != shakeRect.height)
			{

				shakeRect.width = Screen.width;
				shakeRect.height = Screen.height;
			}
		}
		private float GetPixelWidth(Transform cachedTransform, Camera cachedCamera)
		{
			var position = cachedTransform.position;
			var screenPos = cachedCamera.WorldToScreenPoint(position - cachedTransform.forward * .01f);
			var offset = Vector3.zero;

			if (screenPos.x > 0)
				offset = screenPos - Vector3.right;
			else
				offset = screenPos + Vector3.right;

			if (screenPos.y > 0)
				offset = screenPos - Vector3.up;
			else
				offset = screenPos + Vector3.up;

			offset = cachedCamera.ScreenToWorldPoint(offset);
			
			return 1f / (cachedTransform.InverseTransformPoint(position) - cachedTransform.InverseTransformPoint(offset)).magnitude;
		}
		private void ResetState(Transform cachedTransform, Camera cam)
		{
			cam.ResetWorldToCameraMatrix();
			
			shakeRect.x = 0;
			shakeRect.y = 0;
			
			states[cam].Clear();
		}
		private List offsetCache = new List(10);
		private List rotationCache = new List(10);
		private IEnumerator DoResetState(List cameras, Dictionary shakeCount, float time)
		{
			offsetCache.Clear();
			rotationCache.Clear();

			foreach(Camera cam in cameras)
			{
				offsetCache.Add((Vector3)((cam.worldToCameraMatrix * cam.transform.worldToLocalMatrix.inverse).GetColumn(3)));
				rotationCache.Add(QuaternionFromMatrix((cam.worldToCameraMatrix * cam.transform.worldToLocalMatrix.inverse).inverse * Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(1,1,-1))));
			
				if (shakeCount.ContainsKey(cam))
				{
					shakeCount[cam] = 0;
				}
				states[cam].Clear();
			}

			float t = 0;
			float x = shakeRect.x, y = shakeRect.y;
			cancelling = true;
			while (t < time)
			{
				int i = 0;
				foreach(Camera cam in cameras)
				{
					Transform cachedTransform = cam.transform;

					shakeRect.x = Mathf.Lerp(x, 0, t / time);
					shakeRect.y = Mathf.Lerp(y, 0, t / time);

					Vector3 pos = Vector3.Lerp(offsetCache[i], Vector3.zero, t / time);
					Quaternion rot = Quaternion.Slerp(rotationCache[i], cachedTransform.rotation, t / time);
					Matrix4x4 m = Matrix4x4.TRS(pos, rot, new Vector3(1, 1, -1));

					cam.worldToCameraMatrix = m * cachedTransform.worldToLocalMatrix;
					i++;
				}
				t += Time.deltaTime;
				yield return null;
			}

			foreach(Camera cam in cameras)
			{
				cam.ResetWorldToCameraMatrix();
				shakeRect.x = 0;
				shakeRect.y = 0;
			}
			this.shaking = false;
			this.cancelling = false;
		}
		#endregion
		
		#region Quaternion helpers
		private static Quaternion QuaternionFromMatrix(Matrix4x4 m)
		{
			return Quaternion.LookRotation(m.GetColumn(2), m.GetColumn(1));
		}
		private static void NormalizeQuaternion (ref Quaternion q)	
		{
			float sum = 0;	
			
			for (int i = 0; i < 4; ++i)
				sum += q[i] * q[i];
			
			float magnitudeInverse = 1 / Mathf.Sqrt(sum);
			
			for (int i = 0; i < 4; ++i)
				q[i] *= magnitudeInverse;
		}
		#endregion
	}