Beispiel #1
0
 public static void Save()
 {
     EditorPrefs.SetString("P3dWindow", EditorJsonUtility.ToJson(Instance));
 }
        static void SaveStateToSessionState()
        {
            var shareState = StoreFactory.get().state.shareState;

            SessionState.SetString(typeof(ConnectShareEditorWindow).Name, EditorJsonUtility.ToJson(shareState));
        }
Beispiel #3
0
        ////////////////////////////
        //! POSTPROCESSING COMPONENT GUI *** //

        void ISupportedPostComponent.LeftSideGUI(EditorWindow window, float width)
        {
            //profile = PostProcessingBehaviourOjbect.profile;
            profile = GetFieldValue("profile", PostProcessingBehaviourOjbect) as ScriptableObject;

            var changedProfile = EditorGUILayout.ObjectField(profile, Params.PostProcessingProfileType, false) as ScriptableObject;

            if (changedProfile != profile)
            {
                Undo.RecordObject(PostProcessingBehaviourOjbect, "Change PostProcessing Profile");
                profile = SetFieldValue("profile", PostProcessingBehaviourOjbect, changedProfile) as ScriptableObject;
                SetLast(changedProfile);
                EditorUtility.SetDirty(PostProcessingBehaviourOjbect);
                EditorUtility.SetDirty(Camera.main.gameObject);
            }

            GUILayout.BeginHorizontal(GUILayout.Width(width));
            for (int i = 0; i < LastList.Count; i++)
            {
                if (!LastList[i])
                {
                    continue;
                }
                var al = Params.Button.alignment;
                Params.Button.alignment = TextAnchor.MiddleLeft;
                var result = GUILayout.Button(Params.CONTENT(LastList[i].name, "Set " + LastList[i].name), Params.Button, GUILayout.Width(width / LastList.Count), GUILayout.Height(14));
                Params.Button.alignment = al;
                if (result)
                {
                    Undo.RecordObject(PostProcessingBehaviourOjbect, "Change PostProcessing Profile");
                    SetFieldValue("profile", PostProcessingBehaviourOjbect, LastList[i]);
                    EditorUtility.SetDirty(PostProcessingBehaviourOjbect);
                    EditorUtility.SetDirty(Camera.main.gameObject);
                }
                EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
            }
            GUILayout.EndHorizontal();

            //GUILayout.Space( 10 );
            GUILayout.BeginHorizontal(GUILayout.Width(width));
            if (GUILayout.Button(Params.CONTENT("Default Profile", "Set Default Profile")))
            {
                var defaultProfile = AssetDatabase.LoadAssetAtPath(Params.EditorResourcesPath + "/CameraProfile.asset", Params.PostProcessingProfileType) as ScriptableObject;
                if (!defaultProfile)
                {
                    defaultProfile = CreateProfile(Params.EditorResourcesPath + "/CameraProfile.asset");
                }
                Undo.RecordObject(PostProcessingBehaviourOjbect, "Change PostProcessing Profile");
                SetFieldValue("profile", PostProcessingBehaviourOjbect, defaultProfile);
                SetLast(defaultProfile);
                EditorUtility.SetDirty(PostProcessingBehaviourOjbect);
                EditorUtility.SetDirty(Camera.main.gameObject);
            }
            GUI.enabled = profile;
            if (GUILayout.Button(Params.CONTENT("New Copy", "Create and set a copy of current profile")))
            {
                var json       = EditorJsonUtility.ToJson(profile);
                var newProfile = CreateProfile(AssetDatabase.GenerateUniqueAssetPath("Assets/NewCameraProfile.asset"));
                EditorJsonUtility.FromJsonOverwrite(json, newProfile);
                EditorUtility.SetDirty(newProfile);
                Undo.RecordObject(PostProcessingBehaviourOjbect, "Change PostProcessing Profile");
                SetFieldValue("profile", PostProcessingBehaviourOjbect, newProfile);
                SetLast(newProfile);
                EditorUtility.SetDirty(PostProcessingBehaviourOjbect);
                EditorUtility.SetDirty(Camera.main.gameObject);
            }
            GUI.enabled = true;


            GUILayout.EndHorizontal();

            if (!profile)
            {
                return;
            }

            ModelType = GetField("fog", profile).FieldType.BaseType;

            if (!p_to_e.ContainsKey(profile))
            {
                p_to_e.Add(profile, Editor.CreateEditor(profile));
            }
            var e = p_to_e[profile];

            if (!e)
            {
                GUILayout.Label("Internal Plugin Error", Params.Label);
                return;
            }


            Params.AutoRefresh.Set(EditorGUILayout.ToggleLeft("Automatic refresh when changing", Params.AutoRefresh == 1) ? 1 : 0);


            GUILayout.Space(10);

            Params.scroll.x = Params.scrollX;
            Params.scroll.y = Params.scrollY;
            Params.scroll   = GUILayout.BeginScrollView(Params.scroll, alwaysShowVertical: true, alwaysShowHorizontal: false);
            Params.scrollX.Set(Params.scroll.x);
            Params.scrollY.Set(Params.scroll.y);
            e.OnInspectorGUI();
            GUILayout.EndScrollView();
        } //! POSTPROCESSING COMPONENT GUI
Beispiel #4
0
 string ISupportedPostComponent.GetHashString()
 {
     return(EditorJsonUtility.ToJson(((ISupportedPostComponent)this).MonoComponent));
 }
Beispiel #5
0
        internal static DriverResponse HandleDriverRequest(DriverRequest request)
        {
            var response = new DriverResponse {
                method = request.method
            };
            var session = GetSession();

            switch (request.method.ToLowerInvariant())
            {
            case "registereditor":
                if (string.IsNullOrEmpty(session))
                {
                    SaveSession(request.session);
                    response.session = request.session;
                }
                else
                {
                    response.session = session;
                }

                response.result = "unity";
                break;

            case "exist":
                response.result = ExecuteGameObjectEmulation(request.root, request.name, request.parent, request.upath,
                                                             gameObject => true.ToString(), false.ToString());
                break;

            case "active":
                response.result = ExecuteGameObjectEmulation(request.root, request.name, request.parent, request.upath,
                                                             gameObject => gameObject.activeInHierarchy.ToString(), false.ToString());
                break;

            case "onscreen":
                response.result = ExecuteGameObjectEmulation(request.root, request.name, request.parent, request.upath, go =>
                {
                    return(ScreenHelper.IsOnScreen(go).ToString());
                }, "False");
                break;

            case "clickable":
                response.result = ExecuteGameObjectEmulation(request.root, request.name, request.parent, request.upath, go =>
                {
                    return(ScreenHelper.IsGraphicClickable(go).ToString());
                }, "False");
                break;

            case "getcomponent":
                response.result = ExecuteGameObjectEmulation(request.root, request.name, request.parent, request.upath, gameObject =>
                {
                    var component = gameObject.GetComponent(request.value);
                    return(component != null ? EditorJsonUtility.ToJson(component) : "null");
                });
                break;

            case "click":
                response.result = ExecuteGameObjectEmulation(request.root, request.name, request.parent, request.upath, go =>
                {
                    var pointer = new PointerEventData(EventSystem.current);
                    ExecuteEvents.Execute(go, pointer, ExecuteEvents.pointerClickHandler);
                    return(SuccessResult);
                });
                break;

            case "isrendering":
                response.result = ExecuteGameObjectEmulation(request.root, request.name, request.parent, request.upath,
                                                             go =>
                {
                    var renderer = go.GetComponent <Renderer>();
                    if (renderer != null)
                    {
                        return(renderer.isVisible.ToString());
                    }

                    return(false.ToString());
                });
                break;

            case "count":
                response.result = ExecuteGameObjectsEmulation(request.root, request.name, request.parent, request.upath, goList => goList.Count.ToString());
                break;

            case "deletepref":
                response.result = InvokeOnMainThreadAndWait(() =>
                {
                    PlayerPrefs.DeleteKey(request.value);
                    PlayerPrefs.Save();
                });
                break;

            case "deleteallprefs":
                response.result = InvokeOnMainThreadAndWait(() =>
                {
                    PlayerPrefs.DeleteAll();
                    PlayerPrefs.Save();
                });
                break;

            case "swipe":
                var swipeDirection = Vector2.zero;
                switch (request.value)
                {
                case "up":
                    swipeDirection = Vector2.up;
                    break;

                case "down":
                    swipeDirection = Vector2.down;
                    break;

                case "left":
                    swipeDirection = Vector2.left;
                    break;

                case "right":
                    swipeDirection = Vector2.right;
                    break;
                }

                swipeDirection *= 100;

                response.result = ExecuteGameObjectEmulation(request.root, request.name, request.parent, request.upath, go =>
                {
                    var pointer = new PointerEventData(EventSystem.current);

                    var rt = (RectTransform)go.transform;

                    Vector3[] corners = new Vector3[4];
                    rt.GetWorldCorners(corners);
                    var bottomLeft  = Camera.main.WorldToScreenPoint(corners[0]);
                    var topLeft     = Camera.main.WorldToScreenPoint(corners[1]);
                    var topRight    = Camera.main.WorldToScreenPoint(corners[2]);
                    var bottomRight = Camera.main.WorldToScreenPoint(corners[3]);

                    var center = new Vector2(topLeft.x + (bottomRight.x - topLeft.x) / 2,
                                             bottomRight.y + (topLeft.y - bottomRight.y) / 2);

                    go.GetComponent <MonoBehaviour>()
                    .StartCoroutine(DragCoroutine(go, pointer, center, swipeDirection));

                    return(SuccessResult);
                });
                break;


            case "sendkeys":
                response.result = ExecuteGameObjectEmulation(request.root, request.name, request.parent, request.upath, go =>
                {
                    var input = go.GetComponent <InputField>();
                    if (input != null)
                    {
                        input.text = request.value;
                    }
                    else
                    {
                        return("input not found");
                    }

                    return(SuccessResult);
                });
                break;

            case "startplaymode":
                EditorApplication.update += StartPlayMode;
                response.result           = SuccessResult;
                break;

            case "stopplaymode":
                response.result = InvokeOnMainThreadAndWait(() =>
                {
                    EditorApplication.UnlockReloadAssemblies();
                    EditorApplication.isPlaying = false;
                });

                break;

            case "ping":
                response.result = "pong";
                break;

            case "takescreenshot":
                var path = request.value;
                MainThreadHelper.QueueOnMainThread(() => { TakeScreenshot(path); });
                response.result = SuccessResult;
                break;

            default:
                response.result = "Unknown method " + request.method + ".";
                break;
            }

            return(response);
        }
 void UpdateAbstractSubgraphOnDisk(string path)
 {
     File.WriteAllText(path, EditorJsonUtility.ToJson(graphObject.graph, true));
     AssetDatabase.ImportAsset(path);
 }
        // CALLBACK METHODS: ----------------------------------------------------------------------

        public static void OnRetrieveUpdate(bool isError, UpdateHttpRequest.OutputData data)
        {
            CHECKING_UPDATES = false;
            if (isError || data == null || data.error)
            {
                return;
            }

            EditorPrefs.SetString(KEY_UPDATE_CACHE, EditorJsonUtility.ToJson(data.data));
            if (GameCreatorUpdateWindow.WINDOW != null)
            {
                GameCreatorUpdateWindow.WINDOW.Refresh();
            }

            Version skipVersion = new Version(EditorPrefs.GetString(KEY_SKIP_PACKAGE_VERSION, "0.0.0"));

            if (data.data.version.Equals(skipVersion) && GameCreatorUpdateWindow.WINDOW == null)
            {
                return;
            }

            if (data.data.version.HigherThan(Config.GetCurrent().version))
            {
                string message = string.Empty;
                switch (data.data.type)
                {
                case "patch": message = PATCH; break;

                case "release": message = RELEASE; break;

                case "alpha": message = ALPHA; break;
                }

                int option = EditorUtility.DisplayDialogComplex(
                    "New Game Creator version available.",
                    message,
                    "Download " + data.data.version,
                    "Skip version",
                    "Remind me tomorrow"
                    );

                switch (option)
                {
                case 0: Application.OpenURL(URL_DOWNLOAD); break;

                case 1: SkipVersion(data.data.version);  break;

                case 2: SaveCheckTime(); break;
                }
            }
            else if (GameCreatorUpdateWindow.WINDOW != null)
            {
                EditorUtility.DisplayDialog(
                    "Game Creator is up to date.",
                    string.Format(
                        "You're currently using {0}, which is the latest version.",
                        Config.GetCurrent().version
                        ),
                    "Ok"
                    );
            }
        }
Beispiel #8
0
 //Comment
 public static void EditorCopy <T>(T value)
 {
     EditorGUIUtility.systemCopyBuffer = EditorJsonUtility.ToJson(value);
 }
Beispiel #9
0
 private void SaveSplitterState()
 {
     UserSettings.References.splitterState = EditorJsonUtility.ToJson(splitterState, false);
 }
Beispiel #10
0
 public void OnBeforeSerialize()
 {
     m_SerializedTexture = EditorJsonUtility.ToJson(new TextureHelper {
         textureArray = textureArray
     }, false);
 }
        void OnGUI()
        {
            EditorGUILayout.LabelField("ComponentBrowser", new GUIStyle()
            {
                fontStyle = FontStyle.Bold
            });

            var active = Selection.activeGameObject;

            UpdateSelectItemsIfNeeded(active);

            scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);

            EditorGUILayout.BeginHorizontal();
            inputAsText = EditorGUILayout.ToggleLeft("input Type as text:", inputAsText, GUILayout.ExpandWidth(false));
            GUI.enabled = inputAsText;
            var s = EditorGUILayout.TextField(inputTypeStr);

            EditorGUILayout.EndHorizontal();

            GUI.enabled   = !GUI.enabled;
            compSelection = GUILayout.SelectionGrid(compSelection, selectContents, 5, //
                                                    new GUIStyle(GUI.skin.button)
            {
                alignment = TextAnchor.MiddleLeft
            },                                                                                                        //
                                                    GUILayout.ExpandWidth(false));
            GUI.enabled = true;

            Type type = null;

            if (inputAsText)
            {
                if (s != inputTypeStr)
                {
                    inputTypeStr = s;
                    inputType    = TypeByName(s);
                }
                type = inputType;
            }
            else
            {
                if (compSelection < selectTypes.Length) // if activeGameObject == null then Length = 0, compSelection = 0
                {
                    type = selectTypes[compSelection];
                }
            }

            drawType(type);
            EditorGUILayout.EndScrollView();

            EditorGUILayout.BeginHorizontal();
            using (new EditorGUI.DisabledScope(!(compSelection < selectTypes.Length)))
            {
                if (GUILayout.Button("Copy as JSON", GUILayout.ExpandWidth(false)))
                {
                    GUIUtility.systemCopyBuffer = JsonUtility.ToJson(active.GetComponent(selectTypes[compSelection]), true);
                }
                if (GUILayout.Button("Copy with EditorJsonUtility", GUILayout.ExpandWidth(false)))
                {
                    GUIUtility.systemCopyBuffer = EditorJsonUtility.ToJson(active.GetComponent(selectTypes[compSelection]), true);
                }
            }
            EditorGUILayout.EndHorizontal();
        }
Beispiel #12
0
        private static void Send(EventName eventName, object eventData)
        {
            if (!RegisterEvents())
            {
                return;
            }

            var result = EditorAnalytics.SendEventWithLimit(eventName.ToString(), eventData);

            if (result == AnalyticsResult.Ok)
            {
                #if UNITY_TINY_INTERNAL
                Console.WriteLine($"Analytics: event='{eventName}', time='{DateTime.Now:HH:mm:ss}', payload={EditorJsonUtility.ToJson(eventData, true)}");
                #endif
            }
            else
            {
                TraceError($"failed to send event {eventName}. Result: {result}");
            }
        }
        private static void Send(EventName eventName, object eventData)
        {
#if SCENE_TEMPLATE_ANALYTICS_LOGGING
#else
            if (SceneTemplateUtils.IsDeveloperMode())
            {
                return;
            }
#endif

            if (!RegisterEvents())
            {
#if SCENE_TEMPLATE_ANALYTICS_LOGGING
                Console.WriteLine($"[ST] Analytics disabled: event='{eventName}', time='{DateTime.Now:HH:mm:ss}', payload={EditorJsonUtility.ToJson(eventData, true)}");
#endif
                return;
            }
            try
            {
                var result = EditorAnalytics.SendEventWithLimit(eventName.ToString(), eventData);
                if (result == AnalyticsResult.Ok)
                {
#if SCENE_TEMPLATE_ANALYTICS_LOGGING
                    Console.WriteLine($"[ST] Event='{eventName}', time='{DateTime.Now:HH:mm:ss}', payload={EditorJsonUtility.ToJson(eventData, true)}");
#endif
                }
                else
                {
                    Console.WriteLine($"[ST] Failed to send event {eventName}. Result: {result}");
                }
            }
            catch (Exception)
            {
                // ignored
            }
        }
        static public string ConvertToJson(baseAchievement toConvert)
        {
            string json = "\"" + toConvert.sName + "\":" + EditorJsonUtility.ToJson(toConvert);

            return(json);
        }
Beispiel #15
0
 public UdonGraphElementData GetData()
 {
     return(new UdonGraphElementData(UdonGraphElementType.UdonGroup, uid, EditorJsonUtility.ToJson(_customData)));
 }
Beispiel #16
0
 public string ExportAsJsonString()
 {
     return(EditorJsonUtility.ToJson(this));
 }
        public static void RefreshPackages()
        {
            if (_Packages == null)
            {
                // Load cache
                if (System.IO.File.Exists("EditorOutput/Runtime/packages.txt"))
                {
                    try
                    {
                        var json = System.IO.File.ReadAllText("EditorOutput/Runtime/packages.txt");
                        PackagesInfoList list = new PackagesInfoList();
                        EditorJsonUtility.FromJsonOverwrite(json, list);
                        List <UnityEditor.PackageManager.PackageInfo> packages = list.Packages;
                        if (packages.Count > 0)
                        {
                            var newinfos = new Dictionary <string, UnityEditor.PackageManager.PackageInfo>();
                            for (int i = 0; i < packages.Count; ++i)
                            {
                                var package = packages[i];
                                newinfos[package.name] = package;
                            }
                            _Packages = newinfos;
                            _OnPackagesChanged();
                        }
                    }
                    catch { }
                }
            }

            var req = UnityEditor.PackageManager.Client.List(true);

            EditorBridge.TerminableUpdate += () =>
            {
                if (req.IsCompleted)
                {
                    var newinfos = new Dictionary <string, UnityEditor.PackageManager.PackageInfo>();
                    foreach (var package in req.Result)
                    {
                        newinfos[package.name] = package;
                    }
                    if (_Packages == null || PackagesChanged(_Packages, newinfos))
                    {
                        // Save cache
                        try
                        {
                            System.IO.Directory.CreateDirectory("EditorOutput/Runtime/");
                            List <UnityEditor.PackageManager.PackageInfo> packages = new List <UnityEditor.PackageManager.PackageInfo>(newinfos.Values);
                            PackagesInfoList list = new PackagesInfoList();
                            list.Packages = packages;
                            var json = EditorJsonUtility.ToJson(list, true);
                            System.IO.File.WriteAllText("EditorOutput/Runtime/packages.txt", json);
                        }
                        catch { }
                        _Packages = newinfos;
                        _OnPackagesChanged();
                    }
                    //else
                    //{
                    //    _Packages = newinfos;
                    //}
                    return(true);
                }
                else
                {
                    return(false);
                }
            };
        }
Beispiel #18
0
        /// <summary>
        /// Copy components on the 'from' object which is the object being converted,
        /// over to the 'to' object which is the FBX.
        ///
        /// Copy over everything except meshes and materials, since these
        /// are already in the FBX.
        ///
        /// The 'from' hierarchy is not modified.
        ///
        /// Note: 'root' is the root object that is being converted
        /// </summary>
        internal static void CopyComponents(GameObject to, GameObject from, GameObject root, Dictionary <string, GameObject> nameMap)
        {
            // copy components on "from" to "to". Don't want to copy over meshes and materials that were exported
            var originalComponents    = new List <Component>(from.GetComponents <Component>());
            var destinationComponents = new List <Component>(to.GetComponents <Component>());

            foreach (var fromComponent in originalComponents)
            {
                // ignore missing components
                if (fromComponent == null)
                {
                    continue;
                }

                // ignore MeshFilter and Transform, but still ensure scene references are maintained.
                // Don't need to copy regular transform (except for the root object) as the values should already be correct in the FBX.
                // Furthermore, copying transform values may result in overrides in the prefab, which is undesired as if
                // the transform is updated in the FBX, it won't be in the prefab.
                if (fromComponent is MeshFilter || (fromComponent is Transform && from != root))
                {
                    FixSceneReferences(fromComponent, to.GetComponent(fromComponent.GetType()), root);
                    continue;
                }

                // ignore FbxPrefab (when converting LinkedPrefabs)
                // Also ignore RectTransform, since it is not currently possible to switch transforms
                // in a prefab.
                if (fromComponent is UnityEngine.Formats.Fbx.Exporter.FbxPrefab ||
                    fromComponent is RectTransform)
                {
                    continue;
                }

                var json = EditorJsonUtility.ToJson(fromComponent);
                if (string.IsNullOrEmpty(json))
                {
                    // this happens for missing scripts
                    continue;
                }

                System.Type expectedType = fromComponent.GetType();
                Component   toComponent  = null;

                // Find the component to copy to.
                for (int i = 0, n = destinationComponents.Count; i < n; i++)
                {
                    // ignore missing components
                    if (destinationComponents[i] == null)
                    {
                        continue;
                    }

                    if (destinationComponents[i].GetType() == expectedType)
                    {
                        // We have found the component we are looking for,
                        // remove it so we don't try to copy to it again
                        toComponent = destinationComponents[i];
                        destinationComponents.RemoveAt(i);
                        break;
                    }
                }

                // If it's a particle system renderer, then check to see if it hasn't already
                // been added when adding the particle system.
                // An object can have only one ParticleSystem so there shouldn't be an issue of the renderer
                // belonging to a different ParticleSystem.
                if (!toComponent && fromComponent is ParticleSystemRenderer)
                {
                    toComponent = to.GetComponent <ParticleSystemRenderer>();
                }

                if (!toComponent)
                {
                    toComponent = to.AddComponent(fromComponent.GetType());
                }

                if (!toComponent)
                {
                    // Failed to add component
                    Debug.LogWarningFormat("{0}: Failed to add component of type {1} to converted object", ModelExporter.PACKAGE_UI_NAME, fromComponent.GetType().Name);
                    continue;
                }

                FixSceneReferences(fromComponent, toComponent, root);

                // SkinnedMeshRenderer also stores the mesh.
                // Make sure this is not copied over when the SkinnedMeshRenderer is updated,
                // as we want to keep the mesh from the FBX not the scene.
                if (fromComponent is SkinnedMeshRenderer)
                {
                    var skinnedMesh = toComponent as SkinnedMeshRenderer;
                    var mesh        = skinnedMesh.sharedMesh;
                    EditorJsonUtility.FromJsonOverwrite(json, toComponent);
                    skinnedMesh.sharedMesh = mesh;
                }
                else
                {
                    EditorJsonUtility.FromJsonOverwrite(json, toComponent);
                }

                if (fromComponent is MeshCollider)
                {
                    // UNI-27534: This fixes the issue where the mesh collider would not update to point to the mesh in the fbx after export
                    // Point the mesh included in the mesh collider to the mesh in the FBX file, which is the same as the one in mesh filter
                    var fromMeshCollider = from.GetComponent <MeshCollider>();
                    var fromMeshFilter   = from.GetComponent <MeshFilter>();
                    // if the mesh collider isn't pointing to the same mesh as in the current mesh filter then don't
                    // do anything as it's probably pointing to a mesh in a different fbx
                    if (fromMeshCollider && fromMeshFilter && fromMeshCollider.sharedMesh == fromMeshFilter.sharedMesh)
                    {
                        var toFilter = to.GetComponent <MeshFilter>();
                        if (toFilter)
                        {
                            var toMeshCollider = toComponent as MeshCollider;
                            toMeshCollider.sharedMesh = toFilter.sharedMesh;
                        }
                    }
                }

                var serializedFromComponent = new SerializedObject(fromComponent);
                var serializedToComponent   = new SerializedObject(toComponent);
                var fromProperty            = serializedFromComponent.GetIterator();
                fromProperty.Next(true); // skip generic field
                // For SkinnedMeshRenderer, the bones array doesn't have visible children, but still needs to be copied over.
                // For everything else, filtering by visible children in the while loop and then copying properties that don't have visible children,
                // ensures that only the leaf properties are copied over. Copying other properties is not usually necessary and may break references that
                // were not meant to be copied.
                while (fromProperty.Next((fromComponent is SkinnedMeshRenderer)? fromProperty.hasChildren : fromProperty.hasVisibleChildren))
                {
                    if (!fromProperty.hasVisibleChildren)
                    {
                        // with Undo operations, copying m_Father reference causes issues. Also, it is not required as the reference is fixed when
                        // the transform is parented under the correct hierarchy (which happens before this).
                        if (fromProperty.propertyType == SerializedPropertyType.ObjectReference && fromProperty.propertyPath != "m_GameObject" &&
                            fromProperty.propertyPath != "m_Father" && fromProperty.objectReferenceValue &&
                            (fromProperty.objectReferenceValue is GameObject || fromProperty.objectReferenceValue is Component))
                        {
                            CopySerializedProperty(serializedToComponent, fromProperty, nameMap);
                        }
                    }
                }
            }
        }
 static void UpdateShaderGraphOnDisk(string path, GraphData graph)
 {
     File.WriteAllText(path, EditorJsonUtility.ToJson(graph, true));
     AssetDatabase.ImportAsset(path);
 }
        public void TestImportAsset(string unityLocalPath, string fullPath)
        {
            unityLocalPath = unityLocalPath.Replace("\\", "/");
            Debug.Log("Testing file: " + unityLocalPath);

            // invoke an import
            AssetDatabase.ImportAsset(unityLocalPath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate | ImportAssetOptions.DontDownloadFromCacheServer);

            // double check we can load it up and validate it
            string fileContents = File.ReadAllText(fullPath);

            Assert.Greater(fileContents.Length, 0);

            var       graphGuid      = AssetDatabase.AssetPathToGUID(unityLocalPath);
            var       messageManager = new MessageManager();
            GraphData graphData      = new GraphData()
            {
                assetGuid = graphGuid, messageManager = messageManager
            };

            MultiJson.Deserialize(graphData, fileContents);
            graphData.OnEnable();
            graphData.ValidateGraph();

            string fileExtension = Path.GetExtension(fullPath).ToLower();
            bool   isSubgraph    = (fileExtension.Contains("shadersubgraph"));

            if (isSubgraph)
            {
                // check that the SubGraphAsset is the same after versioning twice
                // this is important to ensure we're not importing subgraphs non-deterministically when they are out-of-date on disk
                AssetDatabase.ImportAsset(unityLocalPath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate | ImportAssetOptions.DontDownloadFromCacheServer);
                var subGraph   = AssetDatabase.LoadAssetAtPath <SubGraphAsset>(unityLocalPath);
                var serialized = EditorJsonUtility.ToJson(subGraph);

                AssetDatabase.ImportAsset(unityLocalPath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate | ImportAssetOptions.DontDownloadFromCacheServer);
                var subGraph2   = AssetDatabase.LoadAssetAtPath <SubGraphAsset>(unityLocalPath);
                var serialized2 = EditorJsonUtility.ToJson(subGraph2);

                Assert.AreEqual(serialized, serialized2, $"Importing the subgraph {unityLocalPath} twice resulted in different subgraph assets.");
            }
            else
            {
                // check that the generated shader is the same after versioning twice
                // this is important to ensure we're not importing shaders non-deterministically when they are out-of-date on disk
                string fileNameNoExtension = Path.GetFileNameWithoutExtension(fullPath);
                var    generator           = new Generator(graphData, graphData.outputNode, GenerationMode.ForReals, fileNameNoExtension, null);
                string shader = generator.generatedShader;

                // version again
                GraphData graphData2 = new GraphData()
                {
                    assetGuid = graphGuid, messageManager = messageManager
                };
                MultiJson.Deserialize(graphData2, fileContents);
                graphData2.OnEnable();
                graphData2.ValidateGraph();
                var    generator2 = new Generator(graphData2, graphData2.outputNode, GenerationMode.ForReals, fileNameNoExtension, null);
                string shader2    = generator2.generatedShader;

                Assert.AreEqual(shader, shader2, $"Importing the graph {unityLocalPath} twice resulted in different generated shaders.");

                // Texture test won't work on platforms that don't support more than 16 samplers

                bool isGL =
                    (SystemInfo.graphicsDeviceType == GraphicsDeviceType.OpenGLCore) ||
                    (SystemInfo.graphicsDeviceType == GraphicsDeviceType.OpenGLES2) ||
                    (SystemInfo.graphicsDeviceType == GraphicsDeviceType.OpenGLES3);

                bool isOSX =
                    (Application.platform == RuntimePlatform.OSXEditor) ||
                    (Application.platform == RuntimePlatform.OSXPlayer);

                bool samplersSupported = !(isOSX && isGL);
                if (!samplersSupported && fullPath.Contains("TextureTest"))
                {
                    // skip the compile test -- we know this shader won't compile on these platforms
                }
                else
                {
                    // now create a Unity Shader from the string
                    var compiledShader = ShaderUtil.CreateShaderAsset(shader, true);
                    compiledShader.hideFlags = HideFlags.HideAndDontSave;

                    Assert.NotNull(compiledShader);

                    // compile all the shader passes to see if there are any errors
                    var mat = new Material(compiledShader)
                    {
                        hideFlags = HideFlags.HideAndDontSave
                    };
                    for (int pass = 0; pass < mat.passCount; pass++)
                    {
                        ShaderUtil.CompilePass(mat, pass, true);
                    }
                    Object.DestroyImmediate(mat);
                }
            }
        }
        public void ToSubGraph()
        {
            var path = EditorUtility.SaveFilePanelInProject("Save subgraph", "New SubGraph", "ShaderSubGraph", "");

            path = path.Replace(Application.dataPath, "Assets");
            if (path.Length == 0)
            {
                return;
            }

            graphObject.RegisterCompleteObjectUndo("Convert To Subgraph");
            var graphView = graphEditorView.graphView;

            var nodes  = graphView.selection.OfType <MaterialNodeView>().Where(x => !(x.node is PropertyNode)).Select(x => x.node as INode).ToArray();
            var bounds = Rect.MinMaxRect(float.PositiveInfinity, float.PositiveInfinity, float.NegativeInfinity, float.NegativeInfinity);

            foreach (var node in nodes)
            {
                var center = node.drawState.position.center;
                bounds = Rect.MinMaxRect(
                    Mathf.Min(bounds.xMin, center.x),
                    Mathf.Min(bounds.yMin, center.y),
                    Mathf.Max(bounds.xMax, center.x),
                    Mathf.Max(bounds.yMax, center.y));
            }
            var middle = bounds.center;

            bounds.center = Vector2.zero;

            // Collect the property nodes and get the corresponding properties
            var propertyNodeGuids = graphView.selection.OfType <MaterialNodeView>().Where(x => (x.node is PropertyNode)).Select(x => ((PropertyNode)x.node).propertyGuid);
            var metaProperties    = graphView.graph.properties.Where(x => propertyNodeGuids.Contains(x.guid));

            var copyPasteGraph = new CopyPasteGraph(
                graphView.graph.guid,
                graphView.selection.OfType <MaterialNodeView>().Where(x => !(x.node is PropertyNode)).Select(x => x.node as INode),
                graphView.selection.OfType <Edge>().Select(x => x.userData as IEdge),
                graphView.selection.OfType <BlackboardField>().Select(x => x.userData as IShaderProperty),
                metaProperties);

            var deserialized = CopyPasteGraph.FromJson(JsonUtility.ToJson(copyPasteGraph, false));

            if (deserialized == null)
            {
                return;
            }

            var subGraph           = new SubGraph();
            var subGraphOutputNode = new SubGraphOutputNode();

            {
                var drawState = subGraphOutputNode.drawState;
                drawState.position           = new Rect(new Vector2(bounds.xMax + 200f, 0f), drawState.position.size);
                subGraphOutputNode.drawState = drawState;
            }
            subGraph.AddNode(subGraphOutputNode);

            var nodeGuidMap = new Dictionary <Guid, Guid>();

            foreach (var node in deserialized.GetNodes <INode>())
            {
                var oldGuid = node.guid;
                var newGuid = node.RewriteGuid();
                nodeGuidMap[oldGuid] = newGuid;
                var drawState = node.drawState;
                drawState.position = new Rect(drawState.position.position - middle, drawState.position.size);
                node.drawState     = drawState;
                subGraph.AddNode(node);
            }

            // figure out what needs remapping
            var externalOutputSlots = new List <IEdge>();
            var externalInputSlots  = new List <IEdge>();

            foreach (var edge in deserialized.edges)
            {
                var outputSlot = edge.outputSlot;
                var inputSlot  = edge.inputSlot;

                Guid remappedOutputNodeGuid;
                Guid remappedInputNodeGuid;
                var  outputSlotExistsInSubgraph = nodeGuidMap.TryGetValue(outputSlot.nodeGuid, out remappedOutputNodeGuid);
                var  inputSlotExistsInSubgraph  = nodeGuidMap.TryGetValue(inputSlot.nodeGuid, out remappedInputNodeGuid);

                // pasting nice internal links!
                if (outputSlotExistsInSubgraph && inputSlotExistsInSubgraph)
                {
                    var outputSlotRef = new SlotReference(remappedOutputNodeGuid, outputSlot.slotId);
                    var inputSlotRef  = new SlotReference(remappedInputNodeGuid, inputSlot.slotId);
                    subGraph.Connect(outputSlotRef, inputSlotRef);
                }
                // one edge needs to go to outside world
                else if (outputSlotExistsInSubgraph)
                {
                    externalInputSlots.Add(edge);
                }
                else if (inputSlotExistsInSubgraph)
                {
                    externalOutputSlots.Add(edge);
                }
            }

            // Find the unique edges coming INTO the graph
            var uniqueIncomingEdges = externalOutputSlots.GroupBy(
                edge => edge.outputSlot,
                edge => edge,
                (key, edges) => new { slotRef = key, edges = edges.ToList() });

            var externalInputNeedingConnection = new List <KeyValuePair <IEdge, IShaderProperty> >();

            foreach (var group in uniqueIncomingEdges)
            {
                var sr       = group.slotRef;
                var fromNode = graphObject.graph.GetNodeFromGuid(sr.nodeGuid);
                var fromSlot = fromNode.FindOutputSlot <MaterialSlot>(sr.slotId);

                IShaderProperty prop;
                switch (fromSlot.concreteValueType)
                {
                case ConcreteSlotValueType.Texture2D:
                    prop = new TextureShaderProperty();
                    break;

                case ConcreteSlotValueType.Texture2DArray:
                    prop = new Texture2DArrayShaderProperty();
                    break;

                case ConcreteSlotValueType.Texture3D:
                    prop = new Texture3DShaderProperty();
                    break;

                case ConcreteSlotValueType.Cubemap:
                    prop = new CubemapShaderProperty();
                    break;

                case ConcreteSlotValueType.Vector4:
                    prop = new Vector4ShaderProperty();
                    break;

                case ConcreteSlotValueType.Vector3:
                    prop = new Vector3ShaderProperty();
                    break;

                case ConcreteSlotValueType.Vector2:
                    prop = new Vector2ShaderProperty();
                    break;

                case ConcreteSlotValueType.Vector1:
                    prop = new Vector1ShaderProperty();
                    break;

                case ConcreteSlotValueType.Boolean:
                    prop = new BooleanShaderProperty();
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }

                if (prop != null)
                {
                    var materialGraph    = (AbstractMaterialGraph)graphObject.graph;
                    var fromPropertyNode = fromNode as PropertyNode;
                    var fromProperty     = fromPropertyNode != null?materialGraph.properties.FirstOrDefault(p => p.guid == fromPropertyNode.propertyGuid) : null;

                    prop.displayName = fromProperty != null ? fromProperty.displayName : fromNode.name;
                    subGraph.AddShaderProperty(prop);
                    var propNode = new PropertyNode();
                    {
                        var drawState = propNode.drawState;
                        drawState.position = new Rect(new Vector2(bounds.xMin - 300f, 0f), drawState.position.size);
                        propNode.drawState = drawState;
                    }
                    subGraph.AddNode(propNode);
                    propNode.propertyGuid = prop.guid;

                    foreach (var edge in group.edges)
                    {
                        subGraph.Connect(
                            new SlotReference(propNode.guid, PropertyNode.OutputSlotId),
                            new SlotReference(nodeGuidMap[edge.inputSlot.nodeGuid], edge.inputSlot.slotId));
                        externalInputNeedingConnection.Add(new KeyValuePair <IEdge, IShaderProperty>(edge, prop));
                    }
                }
            }

            var uniqueOutgoingEdges = externalInputSlots.GroupBy(
                edge => edge.inputSlot,
                edge => edge,
                (key, edges) => new { slot = key, edges = edges.ToList() });

            var externalOutputsNeedingConnection = new List <KeyValuePair <IEdge, IEdge> >();

            foreach (var group in uniqueOutgoingEdges)
            {
                var outputNode = subGraph.outputNode;
                var slotId     = outputNode.AddSlot();

                var inputSlotRef = new SlotReference(outputNode.guid, slotId);

                foreach (var edge in group.edges)
                {
                    var newEdge = subGraph.Connect(new SlotReference(nodeGuidMap[edge.outputSlot.nodeGuid], edge.outputSlot.slotId), inputSlotRef);
                    externalOutputsNeedingConnection.Add(new KeyValuePair <IEdge, IEdge>(edge, newEdge));
                }
            }

            File.WriteAllText(path, EditorJsonUtility.ToJson(subGraph));
            AssetDatabase.ImportAsset(path);

            var loadedSubGraph = AssetDatabase.LoadAssetAtPath(path, typeof(MaterialSubGraphAsset)) as MaterialSubGraphAsset;

            if (loadedSubGraph == null)
            {
                return;
            }

            var subGraphNode = new SubGraphNode();
            var ds           = subGraphNode.drawState;

            ds.position            = new Rect(middle - new Vector2(100f, 150f), Vector2.zero);
            subGraphNode.drawState = ds;
            graphObject.graph.AddNode(subGraphNode);
            subGraphNode.subGraphAsset = loadedSubGraph;

            foreach (var edgeMap in externalInputNeedingConnection)
            {
                graphObject.graph.Connect(edgeMap.Key.outputSlot, new SlotReference(subGraphNode.guid, edgeMap.Value.guid.GetHashCode()));
            }

            foreach (var edgeMap in externalOutputsNeedingConnection)
            {
                graphObject.graph.Connect(new SlotReference(subGraphNode.guid, edgeMap.Value.inputSlot.slotId), edgeMap.Key.inputSlot);
            }

            graphObject.graph.RemoveElements(
                graphView.selection.OfType <MaterialNodeView>().Select(x => x.node as INode),
                Enumerable.Empty <IEdge>());
            graphObject.graph.ValidateGraph();
        }
Beispiel #22
0
        public override void OnInspectorGUI()
        {
            base.OnInspectorGUI();


//			UIManager manager = target as UIManager;

            GUILayout.Space(20);
            GUILayout.Label("インスタンスキャッシュ", EditorStyles.boldLabel);
            using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
            {
                foreach (var ui in UIManager.pooledObjects)
                {
                    using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
                    {
//						using (new EditorGUILayout.HorizontalScope())
                        {
                            EditorGUILayout.ObjectField(ui, typeof(UIBase), true);
                            if (ui.isInitialized)
                            {
                                GUILayout.Label(EditorGUIUtility.FindTexture("d_preaudioloopon"), GUILayout.Width(20));
                            }
                            else
                            {
                                GUILayout.Label(EditorGUIUtility.FindTexture("d_preaudioloopoff"), GUILayout.Width(20));
                            }
                        }

//						if (GUILayout.Button(EditorGUIUtility.FindTexture("unityeditor.consolewindow"), EditorStyles.label))
//						{
//							Debug.Log(EditorJsonUtility.ToJson(ui.argument, false));
//						}

//						EditorGUILayout.Toggle("サスペンド?", ui.isResourceLoaded);
//						GUILayout.TextArea(EditorJsonUtility.ToJson(ui.argument, false));
                    }
                }
            }


            GUILayout.Space(20);
            GUILayout.Label("アクティブ", EditorStyles.boldLabel);

            if (UIManager.currentScreen)
            {
                using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
                {
                    foreach (var ui in UIManager.currentScreen.GetEnumrator())
                    {
                        using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
                        {
                            GUILayout.Label(ui.name, EditorStyles.boldLabel);

                            EditorGUILayout.ObjectField(ui, typeof(UIBase), true);
                            if (ui.isTransiting)
                            {
                                GUILayout.Label("遷移中", "sv_label_2");
                            }
                            else if (ui.isShow)
                            {
                                GUILayout.Label("表示済み", "sv_label_1");
                            }
                            //else if(ui.isResourceLoaded)
                            //GUILayout.Label("ロード済", "sv_label_5");
                            else if (ui.isInitialized)
                            {
                                GUILayout.Label("初期化済", "sv_label_6");
                            }
                            else
                            {
                                GUILayout.Label("-", "sv_label_0");
                            }


//							EditorGUILayout.Toggle("初期化済?", ui.isInitialized);
//							EditorGUILayout.Toggle("ロード済?", ui.isResourceLoaded);
//							EditorGUILayout.Toggle("表示済?", ui.isMovedIn);
                            GUILayout.TextArea(EditorJsonUtility.ToJson(ui.argument, false));
                        }
                    }
                }
            }


            GUILayout.Space(20);
            GUILayout.Label("スクリーン履歴", EditorStyles.boldLabel);

            using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
            {
                foreach (var arg in UIManager.screenHistory)
                {
                    using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
                    {
                        GUILayout.Label(arg.path, EditorStyles.boldLabel);

                        var ui = UIManager.pooledObjects.Find(x => x.argument == arg);
                        if (ui)
                        {
                            if (ui.isInitialized)
                            {
                                GUILayout.Label(EditorGUIUtility.FindTexture("d_preaudioloopon"), GUILayout.Width(20));
                            }
                            else
                            {
                                GUILayout.Label(EditorGUIUtility.FindTexture("d_preaudioloopoff"), GUILayout.Width(20));
                            }
                        }
                        GUILayout.TextArea(EditorJsonUtility.ToJson(arg, false));
                    }
                }
            }

            if (Application.isPlaying)
            {
                Repaint();
            }
        }
        public static string Save(object obj)
        {
            if (obj == null)
            {
                return(string.Empty);
            }

            if (obj.GetType().IsPrimitive)
            {
                return(string.Format(CultureInfo.InvariantCulture, "{0}", obj));
            }
            else if (obj is UnityEngine.Object) //type is a unity object
            {
                if ((obj as UnityEngine.Object) == null)
                {
                    return(string.Empty);
                }
                ObjectWrapper wrapper = new ObjectWrapper {
                    obj = obj as UnityEngine.Object
                };
                var json = EditorJsonUtility.ToJson(wrapper);
                return(json);
            }
            else if (obj is AnimationCurve)
            {
                AnimCurveWrapper sac   = new AnimCurveWrapper();
                AnimationCurve   curve = obj as AnimationCurve;


                sac.frames = new AnimCurveWrapper.Keyframe[curve.keys.Length];
                for (int i = 0; i < curve.keys.Length; ++i)
                {
                    sac.frames[i].time             = curve.keys[i].time;
                    sac.frames[i].value            = curve.keys[i].value;
                    sac.frames[i].inTangent        = curve.keys[i].inTangent;
                    sac.frames[i].outTangent       = curve.keys[i].outTangent;
                    sac.frames[i].tangentMode      = 0; // Not used
                    sac.frames[i].leftTangentMode  = AnimationUtility.GetKeyLeftTangentMode(curve, i);
                    sac.frames[i].rightTangentMode = AnimationUtility.GetKeyRightTangentMode(curve, i);
                    sac.frames[i].broken           = AnimationUtility.GetKeyBroken(curve, i);
                }
                sac.preWrapMode  = curve.preWrapMode;
                sac.postWrapMode = curve.postWrapMode;
                sac.version      = 1;

                return(JsonUtility.ToJson(sac));
            }
            else if (obj is Gradient)
            {
                GradientWrapper gw       = new GradientWrapper();
                Gradient        gradient = obj as Gradient;

                gw.gradientMode = gradient.mode;
                gw.colorKeys    = new GradientWrapper.ColorKey[gradient.colorKeys.Length];
                for (int i = 0; i < gradient.colorKeys.Length; ++i)
                {
                    gw.colorKeys[i].color = gradient.colorKeys[i].color;
                    gw.colorKeys[i].time  = gradient.colorKeys[i].time;
                }
                gw.alphaKeys = new GradientWrapper.AlphaKey[gradient.alphaKeys.Length];
                for (int i = 0; i < gradient.alphaKeys.Length; ++i)
                {
                    gw.alphaKeys[i].alpha = gradient.alphaKeys[i].alpha;
                    gw.alphaKeys[i].time  = gradient.alphaKeys[i].time;
                }
                return(JsonUtility.ToJson(gw));
            }
            else if (obj is string)
            {
                return("\"" + ((string)obj).Replace("\"", "\\\"") + "\"");
            }
            else if (obj is SerializableType)
            {
                return("\"" + ((SerializableType)obj).text + "\"");
            }
            else if (obj.GetType().IsArrayOrList())
            {
                IList list = (IList)obj;

                System.Text.StringBuilder sb = new System.Text.StringBuilder();
                sb.Append('[');
                for (int i = 0; i < list.Count; ++i)
                {
                    sb.Append(Save(list[i]));
                    sb.Append(',');
                }
                sb.Length = sb.Length - 1;
                sb.Append(']');

                return(sb.ToString());
            }
            else
            {
                return(EditorJsonUtility.ToJson(obj));
            }
        }
Beispiel #24
0
 void SaveState()
 {
     EditorPrefs.SetString(EditorPerfsKey, EditorJsonUtility.ToJson(this));
 }
 public void OnBeforeSerialize()
 {
     m_SerializedCubemap = EditorJsonUtility.ToJson(new CubemapHelper {
         cubemap = cubemap
     }, false);
 }
Beispiel #26
0
 public static void SaveUserPrefs()
 {
     EditorPrefs.SetString("TCP2_GlobalOptions", EditorJsonUtility.ToJson(data));
 }
Beispiel #27
0
 public string Export(bool format = true)
 {
     return(EditorJsonUtility.ToJson(this, format));
 }
Beispiel #28
0
 private static void Send(EventName eventName, object eventData)
 {
     if (!RegisterEvents())
     {
         #if QUICKSEARCH_ANALYTICS_LOGGING
         Console.WriteLine($"[QS] Analytics disabled: event='{eventName}', time='{DateTime.Now:HH:mm:ss}', payload={EditorJsonUtility.ToJson(eventData, true)}");
         #endif
         return;
     }
     try
     {
         var result = EditorAnalytics.SendEventWithLimit(eventName.ToString(), eventData);
         if (result == AnalyticsResult.Ok)
         {
             #if QUICKSEARCH_ANALYTICS_LOGGING
             Console.WriteLine($"[QS] Event='{eventName}', time='{DateTime.Now:HH:mm:ss}', payload={EditorJsonUtility.ToJson(eventData, true)}");
             #endif
         }
         else
         {
             Console.WriteLine($"[QS] Failed to send event {eventName}. Result: {result}");
         }
     }
     catch (Exception)
     {
         // ignored
     }
 }
Beispiel #29
0
 string ISupportedPostComponent.GetHashString()
 {
     return(EditorJsonUtility.ToJson(profile));
 }
Beispiel #30
0
        public void ShowGUI()
        {
            CustomGUILayout.MultiLineLabelGUI("Scene number:", sceneNumber.ToString());
            CustomGUILayout.MultiLineLabelGUI("Active NavMesh:", navMesh.ToString());
            CustomGUILayout.MultiLineLabelGUI("Default PlayerStart:", playerStart.ToString());
            CustomGUILayout.MultiLineLabelGUI("Default SortingMap:", sortingMap.ToString());
            CustomGUILayout.MultiLineLabelGUI("Default TintMap:", tintMap.ToString());
            CustomGUILayout.MultiLineLabelGUI("OnStart cutscene:", onStartCutscene.ToString());
            CustomGUILayout.MultiLineLabelGUI("OnLoadCutscene:", onLoadCutscene.ToString());

            EditorGUILayout.LabelField("Remember data:");
            if (allScriptData != null && allScriptData.Count > 0)
            {
                foreach (ScriptData scriptData in allScriptData)
                {
                    RememberData rememberData = SaveSystem.FileFormatHandler.DeserializeObject <RememberData> (scriptData.data);
                    if (rememberData != null)
                    {
                        CustomGUILayout.MultiLineLabelGUI("   " + rememberData.GetType().ToString() + ":", EditorJsonUtility.ToJson(rememberData, true));
                    }
                }
            }

            if (allTransformData != null && allTransformData.Count > 0)
            {
                foreach (TransformData transformData in allTransformData)
                {
                    CustomGUILayout.MultiLineLabelGUI("   " + transformData.GetType().ToString() + ":", EditorJsonUtility.ToJson(transformData, true));
                }
            }

            CustomGUILayout.MultiLineLabelGUI("Active ActionLists:", activeLists.ToString());
            CustomGUILayout.MultiLineLabelGUI("Local Variables:", localVariablesData);
        }