SteamVR_SkyboxEditor.cs

//======= 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);
                }
            }
        }
    }
}