/******************************************************************************
 * Spine Runtimes License Agreement
 * Last updated July 28, 2023. Replaces all prior versions.
 *
 * Copyright (c) 2013-2023, Esoteric Software LLC
 *
 * Integration of the Spine Runtimes into software or otherwise creating
 * derivative works of the Spine Runtimes is permitted under the terms and
 * conditions of Section 2 of the Spine Editor License Agreement:
 * http://esotericsoftware.com/spine-editor-license
 *
 * Otherwise, it is permitted to integrate the Spine Runtimes into software or
 * otherwise create derivative works of the Spine Runtimes (collectively,
 * "Products"), provided that each user of the Products must obtain their own
 * Spine Editor license and redistribution of the Products in any form must
 * include this license and copyright notice.
 *
 * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
 * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/

#if UNITY_2017_2_OR_NEWER
#define HAS_VECTOR2INT
#endif

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

namespace Spine.Unity.Examples {

	/// <summary>
	/// When enabled, this component renders a skeleton to a RenderTexture and
	/// then draws this RenderTexture at a UI SkeletonSubmeshGraphic quad of the same size.
	/// This allows changing transparency at a single quad, which produces a more
	/// natural fadeout effect.
	/// Note: It is recommended to keep this component disabled as much as possible
	/// because of the additional rendering overhead. Only enable it when alpha blending is required.
	/// </summary>
	[RequireComponent(typeof(SkeletonGraphic))]
	public class SkeletonGraphicRenderTexture : SkeletonRenderTextureBase {
#if HAS_VECTOR2INT
		[System.Serializable]
		public struct TextureMaterialPair {
			public Texture texture;
			public Material material;

			public TextureMaterialPair (Texture texture, Material material) {
				this.texture = texture;
				this.material = material;
			}
		}

		public RectTransform customRenderRect;
		protected SkeletonGraphic skeletonGraphic;
		public List<TextureMaterialPair> meshRendererMaterialForTexture = new List<TextureMaterialPair>();
		protected CanvasRenderer quadCanvasRenderer;
		protected SkeletonSubmeshGraphic quadMaskableGraphic;
		protected readonly Vector3[] worldCorners = new Vector3[4];

		public void ResetMeshRendererMaterials () {
			meshRendererMaterialForTexture.Clear();
			AtlasAssetBase[] atlasAssets = skeletonGraphic.SkeletonDataAsset.atlasAssets;
			for (int i = 0; i < atlasAssets.Length; ++i) {
				foreach (Material material in atlasAssets[i].Materials) {
					if (material.mainTexture != null) {
						meshRendererMaterialForTexture.Add(
							new TextureMaterialPair(material.mainTexture, material));
					}
				}
			}
		}

		protected override void Awake () {
			base.Awake();
			skeletonGraphic = this.GetComponent<SkeletonGraphic>();
			if (targetCamera == null) {
				targetCamera = skeletonGraphic.canvas.worldCamera;
				if (targetCamera == null)
					targetCamera = Camera.main;
			}
			CreateQuadChild();
		}

		void CreateQuadChild () {
			quad = new GameObject(this.name + " RenderTexture", typeof(CanvasRenderer), typeof(SkeletonSubmeshGraphic));
			quad.transform.SetParent(this.transform.parent, false);
			quadCanvasRenderer = quad.GetComponent<CanvasRenderer>();
			quadMaskableGraphic = quad.GetComponent<SkeletonSubmeshGraphic>();

			quadMesh = new Mesh();
			quadMesh.MarkDynamic();
			quadMesh.name = "RenderTexture Quad";
			quadMesh.hideFlags = HideFlags.DontSaveInBuild | HideFlags.DontSaveInEditor;

			if (quadMaterial == null) {
				quadMaterial = new Material(Shader.Find("Spine/SkeletonGraphic"));
				quadMaterial.EnableKeyword("_CANVAS_GROUP_COMPATIBLE");
			}
		}

		void Reset () {
			skeletonGraphic = this.GetComponent<SkeletonGraphic>();
			ResetMeshRendererMaterials();
#if UNITY_EDITOR
			string[] assets = UnityEditor.AssetDatabase.FindAssets("t:material RenderQuadGraphicMaterial");
			if (assets.Length > 0) {
				string materialPath = UnityEditor.AssetDatabase.GUIDToAssetPath(assets[0]);
				quadMaterial = UnityEditor.AssetDatabase.LoadAssetAtPath<Material>(materialPath);
			}
#endif
		}

		void OnEnable () {
			skeletonGraphic.OnInstructionsPrepared += PrepareQuad;
			skeletonGraphic.AssignMeshOverrideSingleRenderer += RenderSingleMeshToRenderTexture;
			skeletonGraphic.AssignMeshOverrideMultipleRenderers += RenderMultipleMeshesToRenderTexture;
			skeletonGraphic.disableMeshAssignmentOnOverride = true;
			skeletonGraphic.OnMeshAndMaterialsUpdated += RenderOntoQuad;
			skeletonGraphic.OnAnimationRebuild += OnRebuild;
			List<CanvasRenderer> canvasRenderers = skeletonGraphic.canvasRenderers;
			for (int i = 0; i < canvasRenderers.Count; ++i)
				canvasRenderers[i].cull = true;

			if (quadCanvasRenderer)
				quadCanvasRenderer.gameObject.SetActive(true);
		}

		void OnDisable () {
			skeletonGraphic.OnInstructionsPrepared -= PrepareQuad;
			skeletonGraphic.AssignMeshOverrideSingleRenderer -= RenderSingleMeshToRenderTexture;
			skeletonGraphic.AssignMeshOverrideMultipleRenderers -= RenderMultipleMeshesToRenderTexture;
			skeletonGraphic.disableMeshAssignmentOnOverride = false;
			skeletonGraphic.OnMeshAndMaterialsUpdated -= RenderOntoQuad;
			skeletonGraphic.OnAnimationRebuild -= OnRebuild;
			List<CanvasRenderer> canvasRenderers = skeletonGraphic.canvasRenderers;
			for (int i = 0; i < canvasRenderers.Count; ++i)
				canvasRenderers[i].cull = false;

			if (quadCanvasRenderer)
				quadCanvasRenderer.gameObject.SetActive(false);
			if (renderTexture)
				RenderTexture.ReleaseTemporary(renderTexture);
			allocatedRenderTextureSize = Vector2Int.zero;
		}

		void PrepareQuad (SkeletonRendererInstruction instruction) {
			PrepareForMesh();
			SetupQuad();
		}

		void RenderOntoQuad (SkeletonGraphic skeletonRenderer) {
			AssignAtQuad();
		}

		void OnRebuild (ISkeletonAnimation skeletonGraphic) {
			ResetMeshRendererMaterials();
		}

		protected void PrepareForMesh () {
			// We need to get the min/max of all four corners, rotation of the skeleton
			// in combination with perspective projection otherwise might lead to incorrect
			// screen space min/max.
			RectTransform rectTransform = customRenderRect ? customRenderRect : skeletonGraphic.rectTransform;
			rectTransform.GetWorldCorners(worldCorners);

			RenderMode canvasRenderMode = skeletonGraphic.canvas.renderMode;
			Vector3 screenCorner0, screenCorner1, screenCorner2, screenCorner3;
			// note: world corners are ordered bottom left, top left, top right, bottom right.
			// This corresponds to 0, 3, 1, 2 in our desired order.
			if (canvasRenderMode == RenderMode.ScreenSpaceOverlay) {
				screenCorner0 = worldCorners[0];
				screenCorner1 = worldCorners[3];
				screenCorner2 = worldCorners[1];
				screenCorner3 = worldCorners[2];
			} else {
				screenCorner0 = targetCamera.WorldToScreenPoint(worldCorners[0]);
				screenCorner1 = targetCamera.WorldToScreenPoint(worldCorners[3]);
				screenCorner2 = targetCamera.WorldToScreenPoint(worldCorners[1]);
				screenCorner3 = targetCamera.WorldToScreenPoint(worldCorners[2]);
			}

			// To avoid perspective distortion when rotated, we project all vertices
			// onto a plane parallel to the view frustum near plane.
			// Avoids the requirement of 'noperspective' vertex attribute interpolation modifier in shaders.
			float averageScreenDepth = (screenCorner0.z + screenCorner1.z + screenCorner2.z + screenCorner3.z) / 4.0f;
			screenCorner0.z = screenCorner1.z = screenCorner2.z = screenCorner3.z = averageScreenDepth;

			if (canvasRenderMode == RenderMode.ScreenSpaceOverlay) {
				worldCornerNoDistortion0 = screenCorner0;
				worldCornerNoDistortion1 = screenCorner1;
				worldCornerNoDistortion2 = screenCorner2;
				worldCornerNoDistortion3 = screenCorner3;
			} else {
				worldCornerNoDistortion0 = targetCamera.ScreenToWorldPoint(screenCorner0);
				worldCornerNoDistortion1 = targetCamera.ScreenToWorldPoint(screenCorner1);
				worldCornerNoDistortion2 = targetCamera.ScreenToWorldPoint(screenCorner2);
				worldCornerNoDistortion3 = targetCamera.ScreenToWorldPoint(screenCorner3);
			}
			Vector3 screenSpaceMin, screenSpaceMax;
			PrepareTextureMapping(out screenSpaceMin, out screenSpaceMax,
				screenCorner0, screenCorner1, screenCorner2, screenCorner3);
			PrepareCommandBuffer(targetCamera, screenSpaceMin, screenSpaceMax);
		}

		protected Material MeshRendererMaterialForTexture (Texture texture) {
			return meshRendererMaterialForTexture.Find(x => x.texture == texture).material;
		}

		protected void RenderSingleMeshToRenderTexture (Mesh mesh, Material graphicMaterial, Texture texture) {
			if (mesh.subMeshCount == 0) return;
			Material meshRendererMaterial = MeshRendererMaterialForTexture(texture);
			foreach (int shaderPass in shaderPasses)
				commandBuffer.DrawMesh(mesh, transform.localToWorldMatrix, meshRendererMaterial, 0, shaderPass);
			Graphics.ExecuteCommandBuffer(commandBuffer);
		}

		protected void RenderMultipleMeshesToRenderTexture (int meshCount,
			Mesh[] meshes, Material[] graphicMaterials, Texture[] textures) {

			for (int i = 0; i < meshCount; ++i) {
				Mesh mesh = meshes[i];
				if (mesh.subMeshCount == 0) continue;

				Material meshRendererMaterial = MeshRendererMaterialForTexture(textures[i]);
				foreach (int shaderPass in shaderPasses)
					commandBuffer.DrawMesh(mesh, transform.localToWorldMatrix, meshRendererMaterial, 0, shaderPass);
			}
			Graphics.ExecuteCommandBuffer(commandBuffer);
		}

		protected void SetupQuad () {
			quadCanvasRenderer.SetMaterial(quadMaterial, this.renderTexture);
			quadMaskableGraphic.color = color;
			quadCanvasRenderer.SetColor(color);

			RectTransform srcRectTransform = skeletonGraphic.rectTransform;
			RectTransform dstRectTransform = quadMaskableGraphic.rectTransform;

			dstRectTransform.anchorMin = srcRectTransform.anchorMin;
			dstRectTransform.anchorMax = srcRectTransform.anchorMax;
			dstRectTransform.anchoredPosition = srcRectTransform.anchoredPosition;
			dstRectTransform.pivot = srcRectTransform.pivot;
			dstRectTransform.localScale = srcRectTransform.localScale;
			dstRectTransform.sizeDelta = srcRectTransform.sizeDelta;
			dstRectTransform.rotation = srcRectTransform.rotation;
		}

		protected void PrepareCommandBuffer (Camera targetCamera, Vector3 screenSpaceMin, Vector3 screenSpaceMax) {
			commandBuffer.Clear();
			commandBuffer.SetRenderTarget(renderTexture);
			commandBuffer.ClearRenderTarget(true, true, Color.clear);

			Vector2 targetViewportSize = new Vector2(
				screenSpaceMax.x - screenSpaceMin.x,
				screenSpaceMax.y - screenSpaceMin.y);

			RenderMode canvasRenderMode = skeletonGraphic.canvas.renderMode;
			if (canvasRenderMode == RenderMode.ScreenSpaceOverlay) {
				Rect canvasRect = skeletonGraphic.canvas.pixelRect;
				canvasRect.x += screenSpaceMin.x;
				canvasRect.y += screenSpaceMin.y;
				canvasRect.width = targetViewportSize.x;
				canvasRect.height = targetViewportSize.y;
				Matrix4x4 projectionMatrix = Matrix4x4.Ortho(
					canvasRect.x, canvasRect.x + canvasRect.width,
					canvasRect.y, canvasRect.y + canvasRect.height,
					float.MinValue, float.MaxValue);
				commandBuffer.SetViewMatrix(Matrix4x4.identity);
				commandBuffer.SetProjectionMatrix(projectionMatrix);
			} else {
				commandBuffer.SetViewMatrix(targetCamera.worldToCameraMatrix);
				Matrix4x4 projectionMatrix = CalculateProjectionMatrix(targetCamera,
					screenSpaceMin, screenSpaceMax, skeletonGraphic.canvas.pixelRect.size);
				commandBuffer.SetProjectionMatrix(projectionMatrix);
			}
			Rect viewportRect = new Rect(Vector2.zero, targetViewportSize * downScaleFactor);
			commandBuffer.SetViewport(viewportRect);
		}

		protected override void AssignMeshAtRenderer () {
			quadCanvasRenderer.SetMesh(quadMesh);
		}
#endif // HAS_VECTOR2INT
	}
}