Upload of code snippets

Author: tmmvn

CCamera.cs

@@ -0,0 +1,96 @@
+using System;
+using UnityEngine;
+
+	[RequireComponent(typeof(Camera))]
+	public class CCamera : MonoBehaviour {
+
+		[Serializable]
+		public abstract class Module : MonoBehaviour
+		{
+			protected Transform cameraTarget;
+			public bool smoothCamera;
+			public float smoothMoveSpeed;
+			public float smoothRotationSpeed;
+
+			public void SetCameraTarget(Transform newTarget)
+			{
+				cameraTarget = newTarget;
+			}
+
+			public virtual void UpdateCamera(out Vector3 cameraPos, out Quaternion cameraRot)
+			{
+				if (!cameraTarget)
+				{
+					cameraPos = Vector3.zero;
+					cameraRot = Quaternion.identity;
+					return;
+				}
+				cameraPos = cameraTarget.position;
+				cameraRot = cameraTarget.rotation;            
+			}
+
+			public virtual void Initialize(Transform cameraTransform)
+			{
+
+			}
+		}
+
+		public Transform			cameraTarget;
+
+		[SerializeField]
+		public Module[]		cameras;
+
+		private Module				activeCamera;
+
+		private int							activeCameraIndex;
+
+		private void Awake()
+		{
+			if (cameras == null
+			    || cameras[0] == null)
+			{
+				Debug.LogWarning("No default camera module set up. Destroying " + gameObject + " because of this.");
+				Destroy(gameObject);
+				return;
+			}
+			
+			activeCameraIndex = 0;
+			SwitchToCamera(activeCameraIndex);
+		}
+
+		private void SwitchToCamera(int index)
+		{
+			cameras[index].SetCameraTarget(cameraTarget);
+			cameras[index].Initialize(transform);
+			activeCamera = cameras[index];
+		}
+
+		private void LateUpdate()
+		{
+			if (!activeCamera) return;
+			var cameraPos = transform.position;
+			var cameraRot = transform.rotation;
+			activeCamera.UpdateCamera(out cameraPos, out cameraRot);
+			if (!activeCamera.smoothCamera)
+			{
+				transform.position = cameraPos;
+				transform.rotation = cameraRot;
+			}
+			else
+			{
+				transform.position = Vector3.Lerp(transform.position, cameraPos, Time.deltaTime * activeCamera.smoothMoveSpeed);
+				transform.rotation = Quaternion.Lerp(transform.rotation, cameraRot, Time.deltaTime * activeCamera.smoothRotationSpeed);
+			}
+		}
+
+		public void SwitchCamera()
+		{
+			if (activeCameraIndex < cameras.Length)
+				activeCameraIndex++;
+			else
+				activeCameraIndex = 0;
+		
+			SwitchToCamera(activeCameraIndex);
+		}
+	}
+

CXRayView.cs

@@ -0,0 +1,63 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+	public class CXRayView : MonoBehaviour {
+
+		public Material alphaMaterial;
+
+		public LayerMask blockLayer;
+		public string blockTag;
+		private Dictionary<GameObject, Material> hiddenObjects;
+
+		private void Awake()
+		{
+			hiddenObjects = new Dictionary<GameObject, Material>();
+		}
+
+		private void LateUpdate()
+		{
+			var checkDir = PlayerController.ControlledCharacter.transform.position - transform.position;
+			var checkDistance = checkDir.magnitude;
+			checkDir.Normalize();
+		
+			var blockers = Physics.RaycastAll(transform.position, checkDir, checkDistance, blockLayer);
+
+			if(blockers.Length > 0)
+			{
+				foreach (var t in blockers)
+				{
+					var hitObject = t.transform.gameObject;
+				
+					if (hitObject.tag != blockTag)
+						continue;
+
+					if (hiddenObjects.ContainsKey(hitObject))
+						continue;
+
+					var renderer = hitObject.GetComponentInChildren<Renderer>();
+					if (!renderer) continue;
+					var oldMaterial = renderer.sharedMaterial;
+					hiddenObjects.Add(hitObject, oldMaterial);
+					renderer.material = alphaMaterial;
+					renderer.material.mainTexture = oldMaterial.mainTexture;
+				}
+			}
+
+			var keys = new GameObject[hiddenObjects.Keys.Count];
+			hiddenObjects.Keys.CopyTo(keys, 0);
+
+			foreach (var t in keys)
+			{
+				var bFound = blockers.Select(t1 => t1.transform.gameObject).Any(hitObject => hitObject == t);
+
+				if (bFound) continue;
+				Material restoredMaterial;
+				hiddenObjects.TryGetValue(t, out restoredMaterial);
+				var renderer = t.GetComponentInChildren<Renderer>();
+				renderer.material = restoredMaterial;
+				hiddenObjects.Remove(t);
+			}
+		}
+	}
+

CameraScript.cs

@@ -0,0 +1,50 @@
+using UnityEngine;
+using System.Collections;
+
+public class CCamera : MonoBehaviour {
+
+	CameraSpot[] cameraSpots;
+	ParticleEmitter emitter;
+
+	void Awake()
+	{
+		int i = 1;
+		int spotCount = GameObject.FindGameObjectsWithTag("CameraSpot").Length;
+
+		cameraSpots = new CameraSpot[spotCount];
+
+		while (GameObject.Find("CameraSpot" + i.ToString()) != null && i <= spotCount)
+		{
+			cameraSpots[i-1] = GameObject.Find("CameraSpot" + i.ToString()).GetComponent<CameraSpot>();
+			i++;
+		}
+
+		transform.position = cameraSpots[0].position;
+		transform.rotation = cameraSpots[0].rotation;
+
+		emitter = GetComponentInChildren<ParticleEmitter>();
+	}
+
+	void Start()
+	{
+		GetComponent<Camera>().orthographicSize *= UIScaler.uiScaleHeight;
+	}
+
+	public void SwitchCamera(int spot)
+	{
+		transform.position = cameraSpots[spot-1].position;
+		transform.rotation = cameraSpots[spot-1].rotation;
+	}
+
+	public void EnableTransition()
+	{
+		emitter.emit = true;
+		AudioManager.Manager.PlayFX(AudioManager.AudioType.BUBBLESOUND);
+		Invoke("DisableTransition", 2.0f);
+	}
+
+	void DisableTransition()
+	{
+		emitter.emit = false;
+	}
+}

CameraSpot.cs

@@ -0,0 +1,15 @@
+using UnityEngine;
+using System.Collections;
+
+public class CameraSpot : MonoBehaviour {
+
+	public Vector3 position { get; private set; }
+	public Transform defaultLookAt;
+	public Quaternion rotation { get; private set; }
+
+	void Awake()
+	{
+		position = transform.position;
+		rotation = Quaternion.LookRotation(defaultLookAt.position - position);
+	}
+}

FaceCamera.cs

@@ -0,0 +1,16 @@
+using UnityEngine;
+
+    public class FaceCamera : MonoBehaviour {
+        private Transform					cameraTransform;
+        
+        private void Start()
+        {
+            cameraTransform = Camera.main.transform;
+        }
+
+        private void LateUpdate()
+        {
+            transform.LookAt(cameraTransform);
+        }
+    }
+

GameCamera.cs

@@ -0,0 +1,41 @@
+using UnityEngine;
+
+public class GameCamera : MonoBehaviour
+{
+    private Transform _cameraTarget;
+
+    public float cameraDistance;
+
+    private Vector3 _startDirection;
+
+    private void Start()
+    {
+        _cameraTarget = GameObject.FindGameObjectWithTag(
+            "Player").transform;
+        _startDirection = Quaternion.Euler(
+            transform.eulerAngles) * Vector3.forward;
+    }
+
+    private void LateUpdate()
+    {
+        Vector3 desiredCameraPosition;
+        Quaternion desiredCameraRotation;
+
+        CalculateCameraTransform(
+            out desiredCameraPosition,
+            out desiredCameraRotation);
+        var myTransform = transform;
+        myTransform.position = desiredCameraPosition;
+        myTransform.rotation = desiredCameraRotation;
+    }
+
+    private void CalculateCameraTransform(
+        out Vector3 cameraPosition,
+        out Quaternion cameraRotation)
+    {
+        var position = _cameraTarget.position;
+        cameraPosition = position - _startDirection * cameraDistance;
+        cameraRotation = Quaternion.LookRotation(
+            position - cameraPosition);
+    }
+}

Gradient.cs

@@ -0,0 +1,102 @@
+using UnityEngine;
+
+[RequireComponent(typeof(Camera))]
+public class Gradient : MonoBehaviour
+{
+	public Color lightColor;
+	public Color darkColor;
+	public Color darkestColor;
+	public int gradientLayer = 7;
+	public float stepSize = 0.05f;
+	
+	Color topColor;
+	Color bottomColor;
+	Color topTargetColor;
+	Color bottomTargetColor;
+
+	Mesh gradientMesh;
+
+	void Awake()
+	{
+		gradientLayer = Mathf.Clamp(gradientLayer, 0, 31);
+		
+		GetComponent<Camera>().clearFlags = CameraClearFlags.Depth;
+		GetComponent<Camera>().cullingMask = GetComponent<Camera>().cullingMask & ~(1 << gradientLayer);
+		
+		Camera gradientCamera = new GameObject("Gradient Camera", typeof(Camera)).GetComponent<Camera>();
+		gradientCamera.depth = GetComponent<Camera>().depth - 1;
+		gradientCamera.cullingMask = 1 << gradientLayer;
+
+		gradientMesh = new Mesh();
+		gradientMesh.vertices = new Vector3[4] { new Vector3(-100f, .577f, 1f), new Vector3(100f, .577f, 1f), new Vector3(-100f, -.577f, 1f), new Vector3(100f, -.577f, 1f) };
+		gradientMesh.colors = new Color[4] { lightColor, lightColor, darkColor, darkColor };
+
+		topColor = lightColor;
+		bottomColor = darkColor;
+		topTargetColor = lightColor;
+		bottomTargetColor = darkColor;
+		gradientMesh.triangles = new int[6] { 0, 1, 2, 1, 3, 2 };
+
+		Material gradientMaterial = new Material("Shader \"Vertex Color Only\"{Subshader{BindChannels{Bind \"vertex\", vertex Bind \"color\", color}Pass{}}}");
+
+		GameObject BackGround = new GameObject("BackGround", typeof(MeshFilter), typeof(MeshRenderer));
+
+		((MeshFilter)BackGround.GetComponent(typeof(MeshFilter))).mesh = gradientMesh;
+		BackGround.GetComponent<Renderer>().material = gradientMaterial;
+		BackGround.layer = gradientLayer;
+	}
+
+	public void DeepenGradient()
+	{
+		topTargetColor = bottomColor;
+
+		bottomTargetColor.r -= stepSize;
+		if (bottomTargetColor.r < darkestColor.r)
+			bottomTargetColor.r = darkestColor.r;
+		
+		bottomTargetColor.g -= stepSize;
+		if (bottomTargetColor.g < darkestColor.g)
+			bottomTargetColor.g = darkestColor.g;
+		
+		bottomTargetColor.b -= stepSize;
+		if (bottomTargetColor.b < darkestColor.b)
+			bottomTargetColor.b = darkestColor.b;
+
+		topTargetColor.a = 1.0f;
+		bottomTargetColor.a = 1.0f;
+	}
+
+	public void LightenGradient()
+	{
+		bottomTargetColor = darkColor;
+		topTargetColor = lightColor;
+	}
+
+	void MaintainGradient()
+	{
+		bool bChangedColors = false;
+
+		if (topColor != topTargetColor)
+		{
+			topColor = Color.Lerp(topColor, topTargetColor, Time.deltaTime * stepSize);
+			bChangedColors = true;
+		}
+
+		if (bottomColor != bottomTargetColor)
+		{
+			bottomColor = Color.Lerp(bottomColor, bottomTargetColor, Time.deltaTime * stepSize);
+			bChangedColors = true;
+		}
+
+		if (bChangedColors)
+		{
+			Color[] colors = new Color[4] { topColor, topColor, bottomColor, bottomColor };
+			gradientMesh.colors = colors;
+		}
+	}
+	
+	void Update()
+	{
+		MaintainGradient();
+	}
+}