Icosa integration

Assets/Editor/DummyCommandRefs.cs

@@ -179,15 +179,15 @@ public static void Prefabs_Panels_MemoryWarningPanel()
         public static void Prefabs_Panels_PolyPanel()
         {
             Use(GlobalCommands.LoginToGenericCloud);
-            Use(GlobalCommands.ViewPolyGallery);
-            Use(GlobalCommands.ViewPolyPage);
+            Use(GlobalCommands.ViewBlocksGallery);
+            Use(GlobalCommands.ViewIcosaHomePage);
         }
 
         public static void Prefabs_Panels_PolyPanel_Mobile()
         {
             Use(GlobalCommands.LoginToGenericCloud);
-            Use(GlobalCommands.ViewPolyGallery);
-            Use(GlobalCommands.ViewPolyPage);
+            Use(GlobalCommands.ViewBlocksGallery);
+            Use(GlobalCommands.ViewIcosaHomePage);
         }
 
         public static void Prefabs_Panels_ReferencePanel_ReferencePanel_Mobile()

Assets/Editor/GlTF_EditorExporter.cs

@@ -20,8 +20,13 @@
 using System.Text;
 using JetBrains.Annotations;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using SimpleJSON;
 using UnityEditor;
+using UnityEditor.ShaderGraph.Serialization;
 using UnityEngine;
+using UnityGLTF;
+using UnityGLTF.Extensions;
 using UObject = UnityEngine.Object;
 
 namespace TiltBrush
@@ -95,7 +100,7 @@ private static void ExportBrushStrokes_gltf1()
         {
             new ExportGlTF().ExportBrushStrokes(
                 GetExportBaseName() + ".gltf",
-                AxisConvention.kGltfAccordingToPoly,
+                AxisConvention.kGltfAccordingToIcosa,
                 binary: false,
                 doExtras: true,
                 gltfVersion: 1,
@@ -128,75 +133,135 @@ private static bool ExportBrushStrokes_Enabled()
         [MenuItem("Open Brush/glTF/Export Environments to glTF", false, 4)]
         private static void ExportEnvironments()
         {
-#if !GAMEOBJ_EXPORT_TO_GLTF
-            Debug.LogError("Enable the define and fix up the code");
-#else
-    // Save the original RenderSettings
-    Environment.RenderSettingsLite originalRenderSettings = Environment.GetRenderSettings();
-
-    // Clear out the existing environments directory to do a clean export
-    string projectPath = Path.GetDirectoryName(Application.dataPath);
-    string environmentExportPath = Path.Combine(projectPath,
-                                                ExportUtils.kProjectRelativeEnvironmentExportRoot);
-    try {
-      Directory.Delete(environmentExportPath, recursive: true);
-    } catch (DirectoryNotFoundException) {
-      // It's okay if this directory doesn't exist yet as it will be created later.
-    }
+            // Save the original RenderSettings
+            Environment.RenderSettingsLite originalRenderSettings = Environment.GetRenderSettings();
 
-    // Clear out the existing textures directory to do a clean export
-    string textureExportPath = Path.Combine(projectPath,
-                                            ExportUtils.kProjectRelativeTextureExportRoot);
-    try {
-      Directory.Delete(textureExportPath, recursive: true);
-    } catch (DirectoryNotFoundException) {
-      // It's okay if this directory doesn't exist yet as it will be created later.
-    }
-    if (!FileUtils.InitializeDirectoryWithUserError(
-        textureExportPath, "Failed to export, can't create texture export directory")) {
-      return;
-    }
+            // Clear out the existing environments directory to do a clean export
+            string projectPath = Path.GetDirectoryName(Application.dataPath);
+            string environmentExportPath = Path.Combine(projectPath,
+                                                        ExportUtils.kProjectRelativeEnvironmentExportRoot);
+            try
+            {
+                Directory.Delete(environmentExportPath, recursive: true);
+            }
+            catch (DirectoryNotFoundException)
+            {
+                // It's okay if this directory doesn't exist yet as it will be created later.
+            }
 
-    // Get the environment
-    TiltBrushManifest manifest = AssetDatabase.LoadAssetAtPath<TiltBrushManifest>("Assets/Manifest.asset");
-    foreach (Environment env in manifest.Environments) {
-      // Copy over the RenderSettings
-      Environment.SetRenderSettings(env.m_RenderSettings);
-
-      // Set up the environment
-      string envGuid = env.m_Guid.ToString("D");
-      Debug.LogFormat("Exporting environment: {0}", env.m_RenderSettings.m_EnvironmentPrefab);
-      GameObject envPrefab = Resources.Load<GameObject>(env.m_RenderSettings.m_EnvironmentPrefab);
-      GameObject envGameObject = UObject.Instantiate(envPrefab);
-      envGameObject.name = envGuid;
-
-      // Hide game objects that don't get exported to Poly.
-      foreach (Transform child in envGameObject.transform) {
-        if (SceneSettings.ExcludeFromPolyExport(child)) {
-          child.gameObject.SetActive(false);
-        }
-      }
+            // Clear out the existing textures directory to do a clean export
+            string textureExportPath = Path.Combine(projectPath,
+                                                    ExportUtils.kProjectRelativeTextureExportRoot);
+            try
+            {
+                Directory.Delete(textureExportPath, recursive: true);
+            }
+            catch (DirectoryNotFoundException)
+            {
+                // It's okay if this directory doesn't exist yet as it will be created later.
+            }
+            if (!FileUtils.InitializeDirectoryWithUserError(
+                textureExportPath, "Failed to export, can't create texture export directory"))
+            {
+                return;
+            }
 
-      // Set up the environment export directory
-      string directoryName = Path.Combine(environmentExportPath, envGuid);
-      if (!FileUtils.InitializeDirectoryWithUserError(
-          directoryName, "Failed to export, can't create environment export directory")) {
-        return;
-      }
+            // Get the environment
+            TiltBrushManifest manifest = AssetDatabase.LoadAssetAtPath<TiltBrushManifest>("Assets/Manifest.asset");
+            JToken colorToJArray(Color c) => JToken.FromObject(new { c.r, c.g, c.b, c.a });
+            JToken vector3ToJArray(Vector3 c) => JToken.FromObject(new { c.x, c.y, c.z });
+            var envJson = new JObject();
+            foreach (Environment env in manifest.Environments)
+            {
+                // Copy over the RenderSettings
+                Environment.SetRenderSettings(env.m_RenderSettings);
+
+                // Set up the environment
+                string envGuid = env.m_Guid.ToString("D");
+                var envJsonItem = new JObject();
+                envJsonItem["name"] = env.name;
+                envJsonItem["guid"] = envGuid;
+                var envRenderSettingsJson = new JObject();
+                envRenderSettingsJson["fogEnabled"] = env.m_RenderSettings.m_FogEnabled;
+                envRenderSettingsJson["fogColor"] = colorToJArray(env.m_RenderSettings.m_FogColor);
+                envRenderSettingsJson["fogDensity"] = env.m_RenderSettings.m_FogDensity;
+                envRenderSettingsJson["fogStartDistance"] = env.m_RenderSettings.m_FogStartDistance;
+                envRenderSettingsJson["fogEndDistance"] = env.m_RenderSettings.m_FogEndDistance;
+                envRenderSettingsJson["clearColor"] = colorToJArray(env.m_RenderSettings.m_ClearColor);
+                envRenderSettingsJson["ambientColor"] = colorToJArray(env.m_RenderSettings.m_AmbientColor);
+                envRenderSettingsJson["skyboxExposure"] = env.m_RenderSettings.m_SkyboxExposure;
+                envRenderSettingsJson["skyboxTint"] = colorToJArray(env.m_RenderSettings.m_SkyboxTint);
+                envRenderSettingsJson["environmentPrefab"] = env.m_RenderSettings.m_EnvironmentPrefab;
+                envRenderSettingsJson["environmentReverbZone"] = env.m_RenderSettings.m_EnvironmentReverbZonePrefab;
+                envRenderSettingsJson["skyboxCubemap"] = env.m_RenderSettings.m_SkyboxCubemap != null ?
+                    env.m_RenderSettings.m_SkyboxCubemap.name : "";
+                envRenderSettingsJson["reflectionCubemap"] = env.m_RenderSettings.m_ReflectionCubemap != null ?
+                    env.m_RenderSettings.m_ReflectionCubemap.name : "";
+                envRenderSettingsJson["reflectionIntensity"] = env.m_RenderSettings.m_ReflectionIntensity;
+                envJsonItem["renderSettings"] = envRenderSettingsJson;
+                var envLights = new JArray();
+                foreach (var light in env.m_Lights)
+                {
+                    var envLight = new JObject();
+                    envLight["color"] = colorToJArray(light.Color);
+                    envLight["position"] = vector3ToJArray(light.m_Position);
+                    envLight["rotation"] = vector3ToJArray(light.m_Rotation.eulerAngles);
+                    envLight["type"] = light.m_Type.ToString();
+                    envLight["range"] = light.m_Range;
+                    envLight["spotAngle"] = light.m_SpotAngle;
+                    envLight["shadowsEnabled"] = light.m_ShadowsEnabled;
+                    envLights.Add(envLight);
 
-      string basename = FileUtils.SanitizeFilename(envGameObject.name);
-      string gltfName = Path.Combine(directoryName, basename + ".gltf");
+                }
+                envJsonItem["lights"] = envLights;
+                envJsonItem["teleportBoundsHalfWidth"] = env.m_TeleportBoundsHalfWidth;
+                envJsonItem["controllerXRayHeight"] = env.m_ControllerXRayHeight;
+                envJsonItem["widgetHome"] = vector3ToJArray(env.m_WidgetHome);
+                envJsonItem["skyboxColorA"] = colorToJArray(env.m_SkyboxColorA);
+                envJsonItem["skyboxColorB"] = colorToJArray(env.m_SkyboxColorB);
+                envJson[envGuid] = envJsonItem;
+
+                Debug.LogFormat("Exporting environment: {0}", env.m_RenderSettings.m_EnvironmentPrefab);
+                GameObject envPrefab = Resources.Load<GameObject>(env.m_RenderSettings.m_EnvironmentPrefab);
+                GameObject envGameObject = UObject.Instantiate(envPrefab);
+                envGameObject.name = envGuid;
+
+                // Hide game objects that don't get exported to Poly.
+                foreach (Transform child in envGameObject.transform)
+                {
+                    if (SceneSettings.ExcludeFromPolyExport(child))
+                    {
+                        child.gameObject.SetActive(false);
+                    }
+                }
 
-      var exporter = new ExportGlTF();
-      exporter.ExportGameObject(envGameObject, gltfName, env);
+                // Set up the environment export directory
+                string directoryName = Path.Combine(environmentExportPath, envGuid);
+                if (!FileUtils.InitializeDirectoryWithUserError(
+                    directoryName, "Failed to export, can't create environment export directory"))
+                {
+                    return;
+                }
 
-      // DestroyImmediate is required because editor mode never runs object garbage collection.
-      UObject.DestroyImmediate(envGameObject);
-    }
+                string basename = FileUtils.SanitizeFilename(envGameObject.name);
+
+                var settings = GLTFSettings.GetOrCreateSettings();
+                settings.UseMainCameraVisibility = false;
+                var context = new ExportContext();
+                var unityGltfexporter = new GLTFSceneExporter(envGameObject.transform, context);
+                unityGltfexporter.SaveGLB(directoryName, basename + ".glb");
+
+                // DestroyImmediate is required because editor mode never runs object garbage collection.
+                UObject.DestroyImmediate(envGameObject);
+            }
+
+            string jsonString = envJson.ToString();
+            string path = Path.Combine(environmentExportPath, "environments.json");
+            File.WriteAllText(path, jsonString);
+
+            // Restore the original RenderSettings
+            Environment.SetRenderSettings(originalRenderSettings);
 
-    // Restore the original RenderSettings
-    Environment.SetRenderSettings(originalRenderSettings);
-#endif
         }
 
         private static Dictionary<Guid, BrushDescriptor> GetBrushes()

Assets/Editor/RenderCubeMap.cs

@@ -0,0 +1,69 @@
+using UnityEngine;
+using UnityEditor;
+using System.IO;
+
+public class RenderCubeMap : EditorWindow
+{
+    [SerializeField]
+    static int faceSize = 1024;
+
+    [MenuItem("Open Brush/RenderCubeMap", false, 11)]
+    static void Init()
+    {
+        var cam = Camera.main;
+        var camPos = cam.transform.position;
+        var camRot = cam.transform.rotation;
+
+        // cam.fieldOfView = 45;
+        // cam.farClipPlane = 4000;
+        // cam.allowMSAA = false;
+
+        cam.transform.position = new Vector3(0, 10, 0);
+        cam.transform.rotation = Quaternion.identity;
+
+        RenderToCubeMap(Camera.main);
+
+        cam.transform.position = camPos;
+        cam.transform.rotation = camRot;
+    }
+
+    static void RenderToCubeMap(Camera Cam)
+    {
+        Cubemap cubemap = new Cubemap(faceSize, TextureFormat.ARGB32, false);
+
+        var cubeSavePath = Application.dataPath + "/cube" + ".png";
+
+        Cam.RenderToCubemap(cubemap, 63);
+        Texture2D flattenedTexture = new Texture2D(faceSize * 4, faceSize * 3, TextureFormat.ARGB32, false);
+        for (int i = 0; i < 6; i++)
+        {
+            int x = 0, y = 0;
+            switch (i)
+            {
+                case 0: x = faceSize; y = faceSize * 2; break; // Top
+                case 1: x = faceSize; y = 0; break;            // Bottom
+                case 2: x = faceSize * 3; y = faceSize; break; // Right
+                case 3: x = 0; y = faceSize; break;            // Left
+                case 4: x = faceSize; y = faceSize; break;     // Front
+                case 5: x = faceSize * 2; y = faceSize; break; // Back
+            }
+            Graphics.CopyTexture(cubemap, i, 0, 0, 0, faceSize, faceSize, flattenedTexture, 0, 0, x, y);
+        }
+
+        byte[] bytes = flattenedTexture.EncodeToPNG();
+        DestroyImmediate(flattenedTexture, true);
+        File.WriteAllBytes(cubeSavePath, bytes);
+
+        // var tex2DSavePath = Application.dataPath + "/360tex" +  ".jpg";
+        // renderTexCube.ConvertToEquirect(renderTex2D);
+        DestroyImmediate(cubemap, true);
+        // Texture2D tex2d = new Texture2D(faceSize, 2048, TextureFormat.RGB24,false);
+        // RenderTexture.active = renderTex2D;
+        // tex2d.ReadPixels(new Rect(0,0,renderTex2D.width, renderTex2D.height),0,0);
+        // DestroyImmediate(renderTex2D, true);
+        // tex2d.Apply();
+        // bytes = tex2d.EncodeToJPG();
+        // DestroyImmediate(tex2d, true);
+        // File.WriteAllBytes(tex2DSavePath, bytes);
+    }
+}

Assets/Editor/SetIcosaToken.cs

@@ -0,0 +1,58 @@
+// Copyright 2021 The Tilt Brush Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// 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.
+
+namespace TiltBrush
+{
+
+    using UnityEngine;
+    using UnityEditor;
+
+    public class SetIcosaToken : EditorWindow
+    {
+        private static string key = "IcosaToken";
+        private static string value = "";
+
+        [MenuItem("Open Brush/Icosa/Set Login Token")]
+        public static void ShowWindow()
+        {
+            value = PlayerPrefs.GetString(key);
+            GetWindow<SetIcosaToken>("Set Icosa Login Token");
+        }
+
+        void OnGUI()
+        {
+            GUILayout.Label("Enter Token", EditorStyles.boldLabel);
+            value = EditorGUILayout.TextField("Value", value);
+
+            if (GUILayout.Button("Save"))
+            {
+                PlayerPrefs.SetString(key, value);
+                PlayerPrefs.Save();
+                Debug.Log($"Saved: {key} = {value}");
+            }
+
+            if (GUILayout.Button("Load"))
+            {
+                value = PlayerPrefs.GetString(key, "");
+                Debug.Log($"Loaded: {key} = {value}");
+            }
+
+            if (GUILayout.Button("Delete"))
+            {
+                PlayerPrefs.DeleteKey(key);
+                Debug.Log($"Deleted: {key}");
+            }
+        }
+    }
+}