/************************************************************************************
Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.

Licensed under the Oculus Utilities SDK License Version 1.31 (the "License"); you may not use
the Utilities SDK except in compliance with the License, which is provided at the time of installation
or download, or which otherwise accompanies this software in either electronic or hard copy form.

You may obtain a copy of the License at
https://developer.oculus.com/licenses/utilities-1.31

Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
ANY KIND, either express or implied. See the License for the specific language governing
permissions and limitations under the License.
************************************************************************************/

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering;

/// <summary>
/// A component to apply a Colored vignette effect to the camera
/// </summary>
[RequireComponent(typeof(Camera))]
[ExecuteInEditMode]
public class OVRVignette : MonoBehaviour {

	/// <summary>
	/// Controls the number of triangles in the vignette mesh.
	/// </summary>
	public enum MeshComplexityLevel
	{
		VerySimple,
		Simple,
		Normal,
		Detailed,
		VeryDetailed
	}

	/// <summary>
	/// Controls the falloff appearance.
	/// </summary>
	public enum FalloffType
	{
		Linear,
		Quadratic
	}

	private static readonly string QUADRATIC_FALLOFF = "QUADRATIC_FALLOFF";

	[SerializeField]
	[HideInInspector]
	private Shader VignetteShader;

	// These are only used at startup. 
	[SerializeField]
	[Tooltip("Controls the number of triangles used for the vignette mesh." +
		" Normal is best for most purposes.")]
	private MeshComplexityLevel MeshComplexity = MeshComplexityLevel.Normal;
	[SerializeField]
	[Tooltip("Controls how the falloff looks.")]
	private FalloffType Falloff = FalloffType.Linear;
	
	// These can be controlled dynamically at runtime
	[Tooltip("The Vertical FOV of the vignette")]
	public float VignetteFieldOfView = 60;
	[Tooltip("The Aspect ratio of the vignette controls the " +
		"Horizontal FOV. (Larger numbers are wider)")]
	public float VignetteAspectRatio = 1f;
	[Tooltip("The width of the falloff for the vignette in degrees")]
	public float VignetteFalloffDegrees = 10f;
	[ColorUsage(false)]
	[Tooltip("The color of the vignette. Alpha value is ignored")]
	public Color VignetteColor;

	private Camera _Camera;
	private MeshFilter _OpaqueMeshFilter;
	private MeshFilter _TransparentMeshFilter;
	private MeshRenderer _OpaqueMeshRenderer;
	private MeshRenderer _TransparentMeshRenderer;

	private Mesh _OpaqueMesh;
	private Mesh _TransparentMesh;
	private Material _OpaqueMaterial;
	private Material _TransparentMaterial;

	private int _ShaderScaleAndOffset0Property;
	private int _ShaderScaleAndOffset1Property;

	private Vector4[] _TransparentScaleAndOffset0 = new Vector4[2];
	private Vector4[] _TransparentScaleAndOffset1 = new Vector4[2];
	private Vector4[] _OpaqueScaleAndOffset0 = new Vector4[2];
	private Vector4[] _OpaqueScaleAndOffset1 = new Vector4[2];

	private bool _OpaqueVignetteVisible = false;
	private bool _TransparentVignetteVisible = false;

#if UNITY_EDITOR
	// in the editor, allow these to be changed at runtime
	private MeshComplexityLevel _InitialMeshComplexity;
	private FalloffType _InitialFalloff;
#endif

	private int GetTriangleCount()
	{
		switch(MeshComplexity)
		{
			case MeshComplexityLevel.VerySimple: return 32;
			case MeshComplexityLevel.Simple: return 64;
			case MeshComplexityLevel.Normal: return 128;
			case MeshComplexityLevel.Detailed: return 256;
			case MeshComplexityLevel.VeryDetailed: return 512;
			default: return 128;
		}
	}

	private void BuildMeshes()
	{
#if UNITY_EDITOR
		_InitialMeshComplexity = MeshComplexity;
#endif
		int triangleCount = GetTriangleCount();

		Vector3[] innerVerts = new Vector3[triangleCount];
		Vector2[] innerUVs = new Vector2[triangleCount];
		Vector3[] outerVerts = new Vector3[triangleCount];
		Vector2[] outerUVs = new Vector2[triangleCount];
		int[] tris = new int[triangleCount * 3];
		for (int i = 0; i < triangleCount; i += 2)
		{
			float angle = 2 * i * Mathf.PI / triangleCount;

			float x = Mathf.Cos(angle);
			float y = Mathf.Sin(angle);

			outerVerts[i] = new Vector3(x, y, 0);
			outerVerts[i + 1] = new Vector3(x, y, 0);
			outerUVs[i] = new Vector2(0, 1);
			outerUVs[i + 1] = new Vector2(1, 1);

			innerVerts[i] = new Vector3(x, y, 0);
			innerVerts[i + 1] = new Vector3(x, y, 0);
			innerUVs[i] = new Vector2(0, 1);
			innerUVs[i + 1] = new Vector2(1, 0);

			int ti = i * 3;
			tris[ti] = i;
			tris[ti + 1] = i + 1;
			tris[ti + 2] = (i + 2) % triangleCount;
			tris[ti + 3] = i + 1;
			tris[ti + 4] = (i + 3) % triangleCount;
			tris[ti + 5] = (i + 2) % triangleCount;
		}

		if (_OpaqueMesh != null)
		{
			DestroyImmediate(_OpaqueMesh);
		}

		if (_TransparentMesh != null)
		{
			DestroyImmediate(_TransparentMesh);
		}

		_OpaqueMesh = new Mesh()
		{
			name = "Opaque Vignette Mesh",
			hideFlags = HideFlags.HideAndDontSave
		};
		_TransparentMesh = new Mesh()
		{
			name = "Transparent Vignette Mesh",
			hideFlags = HideFlags.HideAndDontSave
		};

		_OpaqueMesh.vertices = outerVerts;
		_OpaqueMesh.uv = outerUVs;
		_OpaqueMesh.triangles = tris;
		_OpaqueMesh.UploadMeshData(true);
		_OpaqueMesh.bounds = new Bounds(Vector3.zero, Vector3.one * 10000);
		_OpaqueMeshFilter.sharedMesh = _OpaqueMesh;

		_TransparentMesh.vertices = innerVerts;
		_TransparentMesh.uv = innerUVs;
		_TransparentMesh.triangles = tris;
		_TransparentMesh.UploadMeshData(true);
		_TransparentMesh.bounds = new Bounds(Vector3.zero, Vector3.one * 10000);
		_TransparentMeshFilter.sharedMesh = _TransparentMesh;
	}

	private void BuildMaterials()
	{
#if UNITY_EDITOR
		_InitialFalloff = Falloff;
#endif
		if (VignetteShader == null)
		{
			VignetteShader = Shader.Find("Oculus/OVRVignette");
		}
		if (VignetteShader == null)
		{
			Debug.LogError("Could not find Vignette Shader! Vignette will not be drawn!");
			return;
		}

		if (_OpaqueMaterial == null)
		{
			_OpaqueMaterial = new Material(VignetteShader)
			{
				name = "Opaque Vignette Material",
				hideFlags = HideFlags.HideAndDontSave,
				renderQueue = (int)RenderQueue.Background
			};
			_OpaqueMaterial.SetFloat("_BlendSrc", (float)BlendMode.One);
			_OpaqueMaterial.SetFloat("_BlendDst", (float)BlendMode.Zero);
			_OpaqueMaterial.SetFloat("_ZWrite", 1);
		}
		_OpaqueMeshRenderer.sharedMaterial = _OpaqueMaterial;

		if (_TransparentMaterial == null)
		{
			_TransparentMaterial = new Material(VignetteShader)
			{
				name = "Transparent Vignette Material",
				hideFlags = HideFlags.HideAndDontSave,
				renderQueue = (int)RenderQueue.Overlay
			};

			_TransparentMaterial.SetFloat("_BlendSrc", (float)BlendMode.SrcAlpha);
			_TransparentMaterial.SetFloat("_BlendDst", (float)BlendMode.OneMinusSrcAlpha);
			_TransparentMaterial.SetFloat("_ZWrite", 0);
		}

		if (Falloff == FalloffType.Quadratic)
		{
			_TransparentMaterial.EnableKeyword(QUADRATIC_FALLOFF);
		}
		else
		{
			_TransparentMaterial.DisableKeyword(QUADRATIC_FALLOFF);
		}
		_TransparentMeshRenderer.sharedMaterial = _TransparentMaterial;
	}

	private void OnEnable()
	{
#if UNITY_2019_1_OR_NEWER
		RenderPipelineManager.beginCameraRendering += OnBeginCameraRendering;
#elif UNITY_2018_1_OR_NEWER
		UnityEngine.Experimental.Rendering.RenderPipeline.beginCameraRendering += OnBeginCameraRendering;
#endif
	}

	private void OnDisable()
	{
#if UNITY_2019_1_OR_NEWER
		RenderPipelineManager.beginCameraRendering -= OnBeginCameraRendering;
#elif UNITY_2018_1_OR_NEWER
		UnityEngine.Experimental.Rendering.RenderPipeline.beginCameraRendering -= OnBeginCameraRendering;
#endif
		DisableRenderers();
	}

	private void Awake()
	{
		_Camera = GetComponent<Camera>();
		_ShaderScaleAndOffset0Property = Shader.PropertyToID("_ScaleAndOffset0");
		_ShaderScaleAndOffset1Property = Shader.PropertyToID("_ScaleAndOffset1");

		GameObject opaqueObject = new GameObject("Opaque Vignette") { hideFlags = HideFlags.HideAndDontSave };
		opaqueObject.transform.SetParent(_Camera.transform, false);
		_OpaqueMeshFilter = opaqueObject.AddComponent<MeshFilter>();
		_OpaqueMeshRenderer = opaqueObject.AddComponent<MeshRenderer>();

		_OpaqueMeshRenderer.receiveShadows = false;
		_OpaqueMeshRenderer.shadowCastingMode = ShadowCastingMode.Off;
		_OpaqueMeshRenderer.lightProbeUsage = LightProbeUsage.Off;
		_OpaqueMeshRenderer.reflectionProbeUsage = ReflectionProbeUsage.Off;
		_OpaqueMeshRenderer.allowOcclusionWhenDynamic = false;
		_OpaqueMeshRenderer.enabled = false;

		GameObject transparentObject = new GameObject("Transparent Vignette") { hideFlags = HideFlags.HideAndDontSave };
		transparentObject.transform.SetParent(_Camera.transform, false);
		_TransparentMeshFilter = transparentObject.AddComponent<MeshFilter>();
		_TransparentMeshRenderer = transparentObject.AddComponent<MeshRenderer>();

		_TransparentMeshRenderer.receiveShadows = false;
		_TransparentMeshRenderer.shadowCastingMode = ShadowCastingMode.Off;
		_TransparentMeshRenderer.lightProbeUsage = LightProbeUsage.Off;
		_TransparentMeshRenderer.reflectionProbeUsage = ReflectionProbeUsage.Off;
		_TransparentMeshRenderer.allowOcclusionWhenDynamic = false;
		_TransparentMeshRenderer.enabled = false;

		BuildMeshes();
		BuildMaterials();
	}

	private void GetTanFovAndOffsetForStereoEye(Camera.StereoscopicEye eye, out float tanFovX, out float tanFovY, out float offsetX, out float offsetY)
	{
		var pt = _Camera.GetStereoProjectionMatrix(eye).transpose;

		var right = pt * new Vector4(-1, 0, 0, 1);
		var left = pt * new Vector4(1, 0, 0, 1);
		var up = pt * new Vector4(0, -1, 0, 1);
		var down = pt * new Vector4(0, 1, 0, 1);

		float rightTanFovX = right.z / right.x;
		float leftTanFovX = left.z / left.x;
		float upTanFovY = up.z / up.y;
		float downTanFovY = down.z / down.y;

		offsetX = -(rightTanFovX + leftTanFovX) / 2;
		offsetY = -(upTanFovY + downTanFovY) / 2;

		tanFovX = (rightTanFovX - leftTanFovX) / 2;
		tanFovY = (upTanFovY - downTanFovY) / 2;
	}

	private void GetTanFovAndOffsetForMonoEye(out float tanFovX, out float tanFovY, out float offsetX, out float offsetY)
	{
		// When calculating from Unity's camera fields, this is the calculation used.
		// We can't use this for stereo eyes because VR projection matrices are usually asymmetric.
		tanFovY = Mathf.Tan(Mathf.Deg2Rad * _Camera.fieldOfView * 0.5f);
		tanFovX = tanFovY * _Camera.aspect;
		offsetX = 0f;
		offsetY = 0f;
	}

	private bool VisibilityTest(float scaleX, float scaleY, float offsetX, float offsetY)
	{
		// because the corners of our viewport are the furthest from the center of our vignette,
		// we only need to test that the farthest corner is outside the vignette ring.
		return new Vector2((1 + Mathf.Abs(offsetX)) / scaleX, (1 + Mathf.Abs(offsetY)) / scaleY).sqrMagnitude > 1.0f;
	}

	private void Update()
	{
#if UNITY_EDITOR
		if (MeshComplexity != _InitialMeshComplexity)
		{
			// rebuild meshes
			BuildMeshes();
		}

		if(Falloff != _InitialFalloff)
		{
			// rebuild materials
			BuildMaterials();
		}
#endif

		// The opaque material could not be created, so just return
		if (_OpaqueMaterial == null)
		{
			return;
		}

		float tanInnerFovY = Mathf.Tan(VignetteFieldOfView * Mathf.Deg2Rad * 0.5f);
		float tanInnerFovX = tanInnerFovY * VignetteAspectRatio;
		float tanMiddleFovX = Mathf.Tan((VignetteFieldOfView + VignetteFalloffDegrees) * Mathf.Deg2Rad * 0.5f);
		float tanMiddleFovY = tanMiddleFovX * VignetteAspectRatio;

		_TransparentVignetteVisible = false;
		_OpaqueVignetteVisible = false;

		for (int i = 0; i < 2; i++)
		{
			float tanFovX, tanFovY, offsetX, offsetY;
			if (_Camera.stereoEnabled)
			{
				GetTanFovAndOffsetForStereoEye((Camera.StereoscopicEye)i, out tanFovX, out tanFovY, out offsetX, out offsetY);
			}
			else
			{
				GetTanFovAndOffsetForMonoEye(out tanFovX, out tanFovY, out offsetX, out offsetY);				
			}

			float borderScale = new Vector2((1 + Mathf.Abs(offsetX)) / VignetteAspectRatio, 1 + Mathf.Abs(offsetY)).magnitude * 1.01f;

			float innerScaleX = tanInnerFovX / tanFovX;
			float innerScaleY = tanInnerFovY / tanFovY;
			float middleScaleX = tanMiddleFovX / tanFovX;
			float middleScaleY = tanMiddleFovY / tanFovY;
			float outerScaleX = borderScale * VignetteAspectRatio;
			float outerScaleY = borderScale;

			// test for visibility.
			_TransparentVignetteVisible |= VisibilityTest(innerScaleX, innerScaleY, offsetX, offsetY);
			_OpaqueVignetteVisible |= VisibilityTest(middleScaleX, middleScaleY, offsetX, offsetY);

			_OpaqueScaleAndOffset0[i] = new Vector4(outerScaleX, outerScaleY, offsetX, offsetY);
			_OpaqueScaleAndOffset1[i] = new Vector4(middleScaleX, middleScaleY, offsetX, offsetY);
			_TransparentScaleAndOffset0[i] = new Vector4(middleScaleX, middleScaleY, offsetX, offsetY);
			_TransparentScaleAndOffset1[i] = new Vector4(innerScaleX, innerScaleY, offsetX, offsetY);
		}

		// if the vignette falloff is less than or equal to zero, we don't need to draw
		// the transparent mesh.
		_TransparentVignetteVisible &= VignetteFalloffDegrees > 0.0f;

		_OpaqueMaterial.SetVectorArray(_ShaderScaleAndOffset0Property, _OpaqueScaleAndOffset0);
		_OpaqueMaterial.SetVectorArray(_ShaderScaleAndOffset1Property, _OpaqueScaleAndOffset1);
		_OpaqueMaterial.color = VignetteColor;
		_TransparentMaterial.SetVectorArray(_ShaderScaleAndOffset0Property, _TransparentScaleAndOffset0);
		_TransparentMaterial.SetVectorArray(_ShaderScaleAndOffset1Property, _TransparentScaleAndOffset1);
		_TransparentMaterial.color = VignetteColor;
	}

	private void EnableRenderers()
	{
		_OpaqueMeshRenderer.enabled = _OpaqueVignetteVisible;
		_TransparentMeshRenderer.enabled = _TransparentVignetteVisible;
	}

	private void DisableRenderers()
	{
		_OpaqueMeshRenderer.enabled = false;
		_TransparentMeshRenderer.enabled = false;
	}

	// Objects are enabled on pre cull and disabled on post render so they only draw in this camera
	private void OnPreCull()
	{
		EnableRenderers();
	}

	private void OnPostRender()
	{
		DisableRenderers();
	}

#if UNITY_2019_1_OR_NEWER
	private void OnBeginCameraRendering(ScriptableRenderContext context, Camera camera)
#else
	private void OnBeginCameraRendering(Camera camera)
#endif
	{
		if (camera == _Camera)
		{
			EnableRenderers();
		}
		else
		{
			DisableRenderers();
		}
	}
}