private static void SaveComponent(Component component)
                {
                    int identifier = GetLocalIdentifier(component);

                    if (identifier != -1)
                    {
                        string scenePath = component.gameObject.scene.path;

                        int saveObjIndex = GetSavedObjectIndex(identifier, scenePath);

                        //If the component isn't already in saved object list add it
                        if (saveObjIndex == -1)
                        {
                            int objectCount = EditorPrefs.GetInt(kEditorPrefsObjectCountKey);
                            saveObjIndex = objectCount;
                            objectCount++;
                            EditorPrefs.SetInt(kEditorPrefsObjectCountKey, objectCount);
                        }

                        RestoredObjectData data          = GetObjectData(component);
                        string             editorPrefKey = kEditorPrefsKey + System.Convert.ToString(saveObjIndex);

                        EditorPrefs.SetString(editorPrefKey + kEditorPrefsObjectScene, scenePath);
                        EditorPrefs.SetString(editorPrefKey + kEditorPrefsObjectId, System.Convert.ToString(identifier));
                        EditorPrefs.SetString(editorPrefKey + kEditorPrefsObjectJson, data._json);
                        EditorPrefs.SetString(editorPrefKey + kEditorPrefsObjectRefs, data._missingObjectRefs);
                        EditorPrefs.SetString(editorPrefKey + kEditorPrefsObjectMaterialRefs, data._missingMaterials);
                    }
                }
Exemplo n.º 2
0
                private static void RestoreSavedObjects()
                {
                    int numSavedObjects = EditorPrefs.GetInt(kEditorPrefsObjectCountKey, 0);

                    List <Object>             restoredObjects     = new List <Object>();
                    List <RestoredObjectData> restoredObjectsData = new List <RestoredObjectData>();

                    for (int i = 0; i < numSavedObjects; i++)
                    {
                        string editorPrefKey = kEditorPrefsKey + System.Convert.ToString(i);

                        if (EditorPrefs.HasKey(editorPrefKey + kEditorPrefsObjectScene))
                        {
                            string sceneStr      = EditorPrefs.GetString(editorPrefKey + kEditorPrefsObjectScene);
                            string identifierStr = EditorPrefs.GetString(editorPrefKey + kEditorPrefsObjectId);

                            Object obj = FindObject(sceneStr, SafeConvertToInt(identifierStr));

                            if (obj != null)
                            {
                                string jsonStr      = EditorPrefs.GetString(editorPrefKey + kEditorPrefsObjectJson);
                                string objectRefStr = EditorPrefs.GetString(editorPrefKey + kEditorPrefsObjectRefs);
                                string materialStr  = EditorPrefs.GetString(editorPrefKey + kEditorPrefsObjectMaterialRefs);

                                restoredObjects.Add(obj);

                                RestoredObjectData data = new RestoredObjectData
                                {
                                    _json              = jsonStr,
                                    _scenePath         = sceneStr,
                                    _missingObjectRefs = objectRefStr,
                                    _missingMaterials  = materialStr
                                };

                                restoredObjectsData.Add(data);
                            }
                        }

                        SafeDeleteEditorPref(editorPrefKey + kEditorPrefsObjectScene);
                        SafeDeleteEditorPref(editorPrefKey + kEditorPrefsObjectId);
                        SafeDeleteEditorPref(editorPrefKey + kEditorPrefsObjectJson);
                        SafeDeleteEditorPref(editorPrefKey + kEditorPrefsObjectRefs);
                        SafeDeleteEditorPref(editorPrefKey + kEditorPrefsObjectMaterialRefs);
                    }

                    if (restoredObjects.Count > 0)
                    {
                        Undo.RecordObjects(restoredObjects.ToArray(), kUndoText);

                        for (int i = 0; i < restoredObjects.Count; i++)
                        {
                            RestoreObjectFromData(restoredObjects[i], restoredObjectsData[i]);
                        }
                    }

                    EditorPrefs.DeleteKey(kEditorPrefsObjectCountKey);
                }
Exemplo n.º 3
0
                private static RestoredObjectData GetObjectData(Object obj)
                {
                    RestoredObjectData data = new RestoredObjectData();

                    bool unityType = ShouldUseEditorSerialiser(obj);

                    List <string>            materials        = new List <string>();
                    List <ObjectRefProperty> objectProperties = unityType ? new List <ObjectRefProperty>() : null;

                    GetSpecialCaseProperties(obj, materials, objectProperties);

                    //If Component is a Unity in built type we have to restore any scene links as they won't be serialized by EditorJsonUtility
                    if (unityType)
                    {
                        data._json = EditorJsonUtility.ToJson(obj);

                        //Build missing object refs string
                        data._missingObjectRefs = "";

                        foreach (ObjectRefProperty prop in objectProperties)
                        {
                            if (!string.IsNullOrEmpty(data._missingObjectRefs))
                            {
                                data._missingObjectRefs += kItemSplitChar;
                            }

                            data._missingObjectRefs += System.Convert.ToString(prop._objectId) + kObjectPathSplitChar + prop._propertyPath;
                        }
                    }
                    else
                    {
                        data._json = JsonUtility.ToJson(obj);
                        data._missingObjectRefs = "";
                    }

                    //Build missing materials string
                    data._missingMaterials = "";

                    foreach (string material in materials)
                    {
                        if (!string.IsNullOrEmpty(data._missingMaterials))
                        {
                            data._missingMaterials += kItemSplitChar;
                        }

                        data._missingMaterials += material;
                    }

                    return(data);
                }
Exemplo n.º 4
0
                private static void SaveObjectValues(Object obj, int saveObjIndex)
                {
                    RestoredObjectData data = GetObjectData(obj);

                    string editorPrefKey = kEditorPrefsKey + System.Convert.ToString(saveObjIndex);

                    EditorPrefs.SetString(editorPrefKey + kEditorPrefsObjectJson, data._json);
                    EditorPrefs.SetString(editorPrefKey + kEditorPrefsObjectRefs, data._missingObjectRefs);
                    EditorPrefs.SetString(editorPrefKey + kEditorPrefsObjectMaterialRefs, data._missingMaterials);

                    if (obj is GameObject)
                    {
                        AddGameObjectChildObjectValues((GameObject)obj);
                    }
                }
Exemplo n.º 5
0
                private static void RestoreObjectFromData(Object obj, RestoredObjectData data)
                {
                    bool unityType = ShouldUseEditorSerialiser(obj);

                    //Find any lost material refs
                    List <MaterialRef> materialRefs = FindOriginalMaterials(obj, data._missingMaterials);

                    if (unityType)
                    {
                        EditorJsonUtility.FromJsonOverwrite(data._json, obj);
                        ApplyObjectRefs(obj, data._scenePath, data._missingObjectRefs);
                    }
                    else
                    {
                        JsonUtility.FromJsonOverwrite(data._json, obj);
                    }

                    //Revert any lost material refs
                    ApplyMaterialsRefs(obj, materialRefs);
                }