//======= Copyright (c) Valve Corporation, All rights reserved. ===============
//
// Purpose: Custom inspector display for SteamVR_Skybox
//
//=============================================================================

using UnityEngine;
using UnityEditor;
using System.Text;
using System.Collections.Generic;
using Valve.VR;
using System.IO;

[CustomEditor(typeof(SteamVR_Skybox)), CanEditMultipleObjects]
public class SteamVR_SkyboxEditor : Editor
{
	private const string nameFormat = "{0}/{1}-{2}.png";
	private const string helpText = "Take snapshot will use the current " +
		"position and rotation to capture six directional screenshots to use as this " +
		"skybox's textures.  Note: This skybox is only used to override what shows up " +
		"in the compositor (e.g. when loading levels).  Add a Camera component to this " +
		"object to override default settings like which layers to render.  Additionally, " +
		"by specifying your own targetTexture, you can control the size of the textures " +
		"and other properties like antialiasing.  Don't forget to disable the camera.\n\n" +
		"For stereo screenshots, a panorama is render for each eye using the specified " +
		"ipd (in millimeters) broken up into segments cellSize pixels square to optimize " +
		"generation.\n(32x32 takes about 10 seconds depending on scene complexity, 16x16 " +
		"takes around a minute, while will 8x8 take several minutes.)\n\nTo test, hit " +
		"play then pause - this will activate the skybox settings, and then drop you to " +
		"the compositor where the skybox is rendered.";

	public override void OnInspectorGUI()
	{
		DrawDefaultInspector();

		EditorGUILayout.HelpBox(helpText, MessageType.Info);

		if (GUILayout.Button("Take snapshot"))
		{
			var directions = new Quaternion[] {
				Quaternion.LookRotation(Vector3.forward),
				Quaternion.LookRotation(Vector3.back),
				Quaternion.LookRotation(Vector3.left),
				Quaternion.LookRotation(Vector3.right),
				Quaternion.LookRotation(Vector3.up, Vector3.back),
				Quaternion.LookRotation(Vector3.down, Vector3.forward)
			};

			Camera tempCamera = null;
			foreach (SteamVR_Skybox target in targets)
			{
				var targetScene = target.gameObject.scene;
                var sceneName = Path.GetFileNameWithoutExtension(targetScene.path);
				var scenePath = Path.GetDirectoryName(targetScene.path);
				var assetPath = scenePath + "/" + sceneName;
				if (!AssetDatabase.IsValidFolder(assetPath))
				{
					var guid = AssetDatabase.CreateFolder(scenePath, sceneName);
					assetPath = AssetDatabase.GUIDToAssetPath(guid);
				}

				var camera = target.GetComponent<Camera>();
				if (camera == null)
				{
					if (tempCamera == null)
						tempCamera = new GameObject().AddComponent<Camera>();
					camera = tempCamera;
				}

				var targetTexture = camera.targetTexture;
				if (camera.targetTexture == null)
				{
					targetTexture = new RenderTexture(1024, 1024, 24);
					targetTexture.antiAliasing = 8;
					camera.targetTexture = targetTexture;
				}

				var oldPosition = target.transform.localPosition;
				var oldRotation = target.transform.localRotation;
				var baseRotation = target.transform.rotation;

				var t = camera.transform;
				t.position = target.transform.position;
				camera.orthographic = false;
				camera.fieldOfView = 90;

				for (int i = 0; i < directions.Length; i++)
				{
					t.rotation = baseRotation * directions[i];
					camera.Render();

					// Copy to texture and save to disk.
					RenderTexture.active = targetTexture;
					var texture = new Texture2D(targetTexture.width, targetTexture.height, TextureFormat.ARGB32, false);
					texture.ReadPixels(new Rect(0, 0, texture.width, texture.height), 0, 0);
					texture.Apply();
					RenderTexture.active = null;

					var assetName = string.Format(nameFormat, assetPath, target.name, i);
					System.IO.File.WriteAllBytes(assetName, texture.EncodeToPNG());
				}
	
				if (camera != tempCamera)
				{
					target.transform.localPosition = oldPosition;
					target.transform.localRotation = oldRotation;
				}
			}

			if (tempCamera != null)
			{
				Object.DestroyImmediate(tempCamera.gameObject);
			}

			// Now that everything has be written out, reload the associated assets and assign them.
			AssetDatabase.Refresh();
			foreach (SteamVR_Skybox target in targets)
			{
				var targetScene = target.gameObject.scene;
				var sceneName = Path.GetFileNameWithoutExtension(targetScene.path);
				var scenePath = Path.GetDirectoryName(targetScene.path);
				var assetPath = scenePath + "/" + sceneName;

				for (int i = 0; i < directions.Length; i++)
				{
					var assetName = string.Format(nameFormat, assetPath, target.name, i);
					var importer = AssetImporter.GetAtPath(assetName) as TextureImporter;
#if (UNITY_5_4 || UNITY_5_3 || UNITY_5_2 || UNITY_5_1 || UNITY_5_0)
					importer.textureFormat = TextureImporterFormat.RGB24;
#else
					importer.textureCompression = TextureImporterCompression.Uncompressed;
#endif
					importer.wrapMode = TextureWrapMode.Clamp;
					importer.mipmapEnabled = false;
					importer.SaveAndReimport();

					var texture = AssetDatabase.LoadAssetAtPath<Texture>(assetName);
					target.SetTextureByIndex(i, texture);
				}
			}
		}
		else if (GUILayout.Button("Take stereo snapshot"))
		{
			const int width = 4096;
			const int height = width / 2;
			const int halfHeight = height / 2;

			var textures = new Texture2D[] {
				new Texture2D(width, height, TextureFormat.ARGB32, false),
				new Texture2D(width, height, TextureFormat.ARGB32, false) };

			var timer = new System.Diagnostics.Stopwatch();

			Camera tempCamera = null;
			foreach (SteamVR_Skybox target in targets)
			{
				timer.Start();

				var targetScene = target.gameObject.scene;
				var sceneName = Path.GetFileNameWithoutExtension(targetScene.path);
				var scenePath = Path.GetDirectoryName(targetScene.path);
				var assetPath = scenePath + "/" + sceneName;
				if (!AssetDatabase.IsValidFolder(assetPath))
				{
					var guid = AssetDatabase.CreateFolder(scenePath, sceneName);
					assetPath = AssetDatabase.GUIDToAssetPath(guid);
				}

				var camera = target.GetComponent<Camera>();
				if (camera == null)
				{
					if (tempCamera == null)
						tempCamera = new GameObject().AddComponent<Camera>();
					camera = tempCamera;
				}

				var fx = camera.gameObject.AddComponent<SteamVR_SphericalProjection>();

				var oldTargetTexture = camera.targetTexture;
				var oldOrthographic = camera.orthographic;
				var oldFieldOfView = camera.fieldOfView;
				var oldAspect = camera.aspect;

				var oldPosition = target.transform.localPosition;
				var oldRotation = target.transform.localRotation;
				var basePosition = target.transform.position;
				var baseRotation = target.transform.rotation;

				var transform = camera.transform;

				int cellSize = int.Parse(target.StereoCellSize.ToString().Substring(1));
	            float ipd = target.StereoIpdMm / 1000.0f;
				int vTotal = halfHeight / cellSize;
				float dv = 90.0f / vTotal; // vertical degrees per segment
				float dvHalf = dv / 2.0f;

				var targetTexture = new RenderTexture(cellSize, cellSize, 24);
				targetTexture.wrapMode = TextureWrapMode.Clamp;
				targetTexture.antiAliasing = 8;

				camera.fieldOfView = dv;
				camera.orthographic = false;
				camera.targetTexture = targetTexture;

				// Render sections of a sphere using a rectilinear projection
				// and resample using a sphereical projection into a single panorama
				// texture per eye.  We break into sections in order to keep the eye
				// separation similar around the sphere.  Rendering alternates between
				// top and bottom sections, sweeping horizontally around the sphere,
				// alternating left and right eyes.
				for (int v = 0; v < vTotal; v++)
				{
					var pitch = 90.0f - (v * dv) - dvHalf;
					var uTotal = width / targetTexture.width;
                    var du = 360.0f / uTotal; // horizontal degrees per segment
					var duHalf = du / 2.0f;

					var vTarget = v * halfHeight / vTotal;

					for (int i = 0; i < 2; i++) // top, bottom
					{
						if (i == 1)
						{
							pitch = -pitch;
							vTarget = height - vTarget - cellSize;
                        }

						for (int u = 0; u < uTotal; u++)
						{
							var yaw = -180.0f + (u * du) + duHalf;

							var uTarget = u * width / uTotal;

							var xOffset = -ipd / 2 * Mathf.Cos(pitch * Mathf.Deg2Rad);

							for (int j = 0; j < 2; j++) // left, right
							{
								var texture = textures[j];

								if (j == 1)
								{
									xOffset = -xOffset;
								}

								var offset = baseRotation * Quaternion.Euler(0, yaw, 0) * new Vector3(xOffset, 0, 0);
								transform.position = basePosition + offset;

								var direction = Quaternion.Euler(pitch, yaw, 0.0f);
								transform.rotation = baseRotation * direction;

								// vector pointing to center of this section
								var N = direction * Vector3.forward;

								// horizontal span of this section in degrees
								var phi0 = yaw - (du / 2);
								var phi1 = phi0 + du;

								// vertical span of this section in degrees
								var theta0 = pitch + (dv / 2);
								var theta1 = theta0 - dv;

								var midPhi = (phi0 + phi1) / 2;
								var baseTheta = Mathf.Abs(theta0) < Mathf.Abs(theta1) ? theta0 : theta1;

								// vectors pointing to corners of image closes to the equator
								var V00 = Quaternion.Euler(baseTheta, phi0, 0.0f) * Vector3.forward;
								var V01 = Quaternion.Euler(baseTheta, phi1, 0.0f) * Vector3.forward;

								// vectors pointing to top and bottom midsection of image
								var V0M = Quaternion.Euler(theta0, midPhi, 0.0f) * Vector3.forward;
								var V1M = Quaternion.Euler(theta1, midPhi, 0.0f) * Vector3.forward;

								// intersection points for each of the above
								var P00 = V00 / Vector3.Dot(V00, N);
								var P01 = V01 / Vector3.Dot(V01, N);
								var P0M = V0M / Vector3.Dot(V0M, N);
								var P1M = V1M / Vector3.Dot(V1M, N);

								// calculate basis vectors for plane
								var P00_P01 = P01 - P00;
								var P0M_P1M = P1M - P0M;

								var uMag = P00_P01.magnitude;
								var vMag = P0M_P1M.magnitude;

								var uScale = 1.0f / uMag;
								var vScale = 1.0f / vMag;

								var uAxis = P00_P01 * uScale;
								var vAxis = P0M_P1M * vScale;

								// update material constant buffer
								fx.Set(N, phi0, phi1, theta0, theta1,
									uAxis, P00, uScale,
									vAxis, P0M, vScale);

								camera.aspect = uMag / vMag;
								camera.Render();

								RenderTexture.active = targetTexture;
								texture.ReadPixels(new Rect(0, 0, targetTexture.width, targetTexture.height), uTarget, vTarget);
								RenderTexture.active = null;
							}
						}
					}
                }

				// Save textures to disk.
				for (int i = 0; i < 2; i++)
				{
					var texture = textures[i];

					texture.Apply();
					var assetName = string.Format(nameFormat, assetPath, target.name, i);
					File.WriteAllBytes(assetName, texture.EncodeToPNG());
				}

				// Cleanup.
				if (camera != tempCamera)
				{
					camera.targetTexture = oldTargetTexture;
					camera.orthographic = oldOrthographic;
					camera.fieldOfView = oldFieldOfView;
					camera.aspect = oldAspect;

					target.transform.localPosition = oldPosition;
					target.transform.localRotation = oldRotation;
                }
				else
				{
					tempCamera.targetTexture = null;
				}

				DestroyImmediate(targetTexture);
				DestroyImmediate(fx);

				timer.Stop();
				Debug.Log(string.Format("Screenshot took {0} seconds.", timer.Elapsed));
			}

			if (tempCamera != null)
			{
				DestroyImmediate(tempCamera.gameObject);
			}

			DestroyImmediate(textures[0]);
			DestroyImmediate(textures[1]);

			// Now that everything has be written out, reload the associated assets and assign them.
			AssetDatabase.Refresh();
			foreach (SteamVR_Skybox target in targets)
			{
				var targetScene = target.gameObject.scene;
				var sceneName = Path.GetFileNameWithoutExtension(targetScene.path);
				var scenePath = Path.GetDirectoryName(targetScene.path);
				var assetPath = scenePath + "/" + sceneName;

				for (int i = 0; i < 2; i++)
				{
					var assetName = string.Format(nameFormat, assetPath, target.name, i);
					var importer = AssetImporter.GetAtPath(assetName) as TextureImporter;
					importer.mipmapEnabled = false;
					importer.wrapMode = TextureWrapMode.Repeat;
#if (UNITY_5_4 || UNITY_5_3 || UNITY_5_2 || UNITY_5_1 || UNITY_5_0)
					importer.SetPlatformTextureSettings("Standalone", width, TextureImporterFormat.RGB24);
#else
					var settings = importer.GetPlatformTextureSettings("Standalone");
					settings.textureCompression = TextureImporterCompression.Uncompressed;
					settings.maxTextureSize = width;
					importer.SetPlatformTextureSettings(settings);
#endif
					importer.SaveAndReimport();

					var texture = AssetDatabase.LoadAssetAtPath<Texture2D>(assetName);
					target.SetTextureByIndex(i, texture);
				}
			}
		}
	}
}