private static bool DestroyGameObjects(Transform t, bool forceDestroy)
        {
            //We going to destroy all gameObjects except PersistentIgnore
            bool destroy = true; //destroy by default

            if (!forceDestroy)   //if not forced to destroy
            {
                PersistentIgnore ignore = t.GetComponent <PersistentIgnore>();
                if (ignore) //check if this is PersistentIgnore
                {
                    if (ignore.IsRuntime)
                    {
                        //if PersistentIgnore created in runtime (not in UnityEditor) then destroy it
                        return(true);
                    }

                    return(false);

                    /*
                     * if (ignore.ReplacementPrefab == null)
                     * {
                     *  //if there is no replacement prefab leave gameobject subtree as is and do not destroy nothing
                     *  return false;
                     * }
                     *
                     * //if ReplacementPrefab field set do not destroy GameObject
                     * destroy = false;
                     * //but force destory all it's children
                     * forceDestroy = true;
                     */
                }
            }

            List <Transform> children = new List <Transform>();

            foreach (Transform child in t)
            {
                children.Add(child);
            }

            for (int i = 0; i < children.Count; ++i)
            {
                Transform child = children[i];
                if (DestroyGameObjects(child, forceDestroy))
                {
                    UnityObject.DestroyImmediate(child.gameObject);
                }
                else
                {
                    //PersistentIgnore objects became roots to prevent destruction
                    child.SetParent(null, true);
                }
            }

            return(destroy);
        }
Exemple #2
0
        /// <summary>
        /// Create Persistent Data for all GameObjects and Components, write it to PersistentData list
        /// </summary>
        /// <param name="go">gameObject (initially root)</param>
        /// <param name="data">list which will be populated with PersistentData objects</param>
        private static void CreatePersistentData(GameObject go, List <PersistentData> data)
        {
            PersistentIgnore persistentIgnore = go.GetComponent <PersistentIgnore>();

            if (persistentIgnore != null /* && persistentIgnore.ReplacementPrefab == null*/)
            {
                //Do not save persistent ignore objects without replacement prefab
                return;
            }
            PersistentData goData = Create(go);

            if (goData != null)
            {
                goData.ActiveSelf = go.activeSelf;
                goData.ReadFrom(go);
                data.Add(goData);
            }

            Component[] components;
            if (persistentIgnore == null)
            {
                components = go.GetComponents <Component>().Where(c => c != null && !PersistentDescriptor.IgnoreTypes.Contains(c.GetType())).ToArray();
            }
            else
            {
                //if PersistentIgnore component exists save only Transform and PersistentIgnore components
                components = go.GetComponents <Transform>();
                Array.Resize(ref components, components.Length + 1);
                components[components.Length - 1] = persistentIgnore;
            }

            for (int i = 0; i < components.Length; ++i)
            {
                Component      component     = components[i];
                PersistentData componentData = PersistentData.Create(component);
                if (componentData != null)
                {
                    componentData.ReadFrom(component);
                    data.Add(componentData);
                }
            }

            Transform transform = go.transform;

            foreach (Transform childTransform in transform)
            {
                //Do not create childDescriptor for replacementPrefab child & for persistentIgnore without ReplacementPrefab
                if (persistentIgnore == null /* || persistentIgnore.ReplacementPrefab != null && !persistentIgnore.IsChildOfReplacementPrefab(childTransform)*/)
                {
                    //only for independent child
                    CreatePersistentData(childTransform.gameObject, data);
                }
            }
        }
Exemple #3
0
        private static void FindPersistentIgnoreObjects(Transform t, List <UnityObject> pIgnoreObjects)
        {
            PersistentIgnore pIgnore = t.GetComponent <PersistentIgnore>();

            if (pIgnore != null)
            {
                pIgnoreObjects.Add(pIgnore);
            }

            foreach (Transform c in t)
            {
                FindPersistentIgnoreObjects(c, pIgnoreObjects);
            }
        }
Exemple #4
0
        private static void CreatePersistentIngoreResourceGroups(ResourceMap map, List <UnityObject> ignoreObjects, Dictionary <UnityObject, int> dict)
        {
            for (int i = 0; i < ignoreObjects.Count; ++i)
            {
                PersistentIgnore io = (PersistentIgnore)ignoreObjects[i];
                if (!io)
                {
                    continue;
                }
                GameObject go = io.gameObject;
                Transform  tr = io.transform;

                ResourceGroup[] resourceGroups = go.GetComponents <ResourceGroup>();
                foreach (ResourceGroup rg in resourceGroups)
                {
                    UnityObject.DestroyImmediate(rg);
                }

                List <ObjectToID> mappingsInGroup = new List <ObjectToID>();
                ResourceGroup     resourceGroup   = go.AddComponent <ResourceGroup>();
                resourceGroup.Guid = map.Guid;
                int id;
                if (!dict.TryGetValue(io, out id))
                {
                    id = map.IncCounter();
                    dict.Add(io, id);
                }

                mappingsInGroup.Add(new ObjectToID(io, id));

                if (!dict.TryGetValue(go, out id))
                {
                    id = map.IncCounter();
                    dict.Add(go, id);
                }

                mappingsInGroup.Add(new ObjectToID(go, id));

                if (!dict.TryGetValue(tr, out id))
                {
                    id = map.IncCounter();
                    dict.Add(tr, id);
                }

                mappingsInGroup.Add(new ObjectToID(tr, id));

                resourceGroup.Mapping = mappingsInGroup.OrderBy(m => m.Name).ToArray();
            }
        }
        public static GameObject InstantiatePrefab(this GameObject prefab, Vector3 position, Quaternion rotation)
        {
            if (prefab == null)
            {
                return(null);
            }

            PersistentIgnore persistentIgnore = prefab.GetComponent <PersistentIgnore>();

            if (persistentIgnore != null)
            {
                return(persistentIgnore.InstantiatePrefab(prefab, position, rotation));
            }
            return(UnityObject.Instantiate(prefab, position, rotation));
        }
        private void LoadMappings(ResourceGroup group, bool ignoreConflicts = false, List <int> ids = null)
        {
            if (!group.gameObject.IsPrefab())
            {
                PersistentIgnore ignore = group.GetComponent <PersistentIgnore>();
                if (ignore == null || ignore.IsRuntime)
                {
                    return;
                }
            }

            ObjectToID[] mappings = group.Mapping;
            for (int j = 0; j < mappings.Length; ++j)
            {
                ObjectToID mapping = mappings[j];
                if (mapping.Object == null)
                {
                    continue;
                }

                int realId = mapping.Object.GetInstanceID();
                if (m_idToId.ContainsKey(realId))
                {
                    if (ignoreConflicts)
                    {
                        continue;
                    }
                    Debug.LogError("key " + realId + "already added. Group " + group.name + " guid " + group.Guid + " mapping " + j + " mapped object " + mapping.Object);
                }
                m_idToId.Add(realId, mapping.Id);
                if (ids != null)
                {
                    //ss
                    ids.Add(realId);
                }
            }
        }
Exemple #7
0
        public static void RestoreDataAndResolveDependencies(PersistentData[] dataObjects, Dictionary <long, UnityObject> objects)
        {
            //3. Create persistent data dictionary (new object id -> Persistent Data)
            Dictionary <UnityObject, PersistentData> persistentData = new Dictionary <UnityObject, PersistentData>();

            for (int i = 0; i < dataObjects.Length; ++i)
            {
                PersistentData data = dataObjects[i];

                UnityObject obj;
                if (objects.TryGetValue(data.InstanceId, out obj))
                {
                    persistentData.Add(obj, data);
                }
            }

            //4. Create replacement prefabs and replace PersistentIgnoreObjects
            foreach (KeyValuePair <UnityObject, PersistentData> kvp in persistentData)
            {
                PersistentIgnore persistentIgnore = kvp.Key as PersistentIgnore;
                if (persistentIgnore == null)
                {
                    continue;
                }

                GameObject go = persistentIgnore.gameObject;

                PersistentData goData        = persistentData[go];
                PersistentData scriptData    = kvp.Value;
                PersistentData transformData = persistentData[go.transform];

                //Recover go data
                goData.WriteTo(go, objects);

                //Recover script data
                scriptData.WriteTo(persistentIgnore, objects);

                //Recover transform data
                transformData.WriteTo(go.transform, objects);

                /*
                 * if (persistentIgnore.ReplacementPrefab != null)
                 * {
                 *  //make sure that Replacement prefab is not active,
                 *  //this will prevent Awake and other methods from running too early
                 *  persistentIgnore.ReplacementPrefab.gameObject.SetActive(false);
                 *
                 *  PersistentIgnore replacementScript = UnityObject.Instantiate(persistentIgnore.ReplacementPrefab);
                 *  List<GameObject> destroy = new List<GameObject>();
                 *  //Destroy prefab children according to PersistentIgnore component settings
                 *  foreach (Transform childTransform in replacementScript.transform)
                 *  {
                 *      if (!replacementScript.IsChildOfReplacementPrefab(childTransform))
                 *      {
                 *          destroy.Add(childTransform.gameObject);
                 *      }
                 *  }
                 *  for (int i = 0; i < destroy.Count; ++i)
                 *  {
                 *      UnityObject.DestroyImmediate(destroy[i]);
                 *  }
                 *
                 *  //replace gameObject with repacementPrefab in objects dictionary
                 *  //Thereby all other objects will reference replacementPrefab instad of gameObject
                 *  objects[goData.InstanceId] = replacementScript.gameObject;
                 *  objects[scriptData.InstanceId] = replacementScript;
                 *  objects[transformData.InstanceId] = replacementScript.transform;
                 *
                 *  //insert replacementPrefab to hierarchy
                 *  replacementScript.transform.SetParent(go.transform.parent);
                 *  foreach (Transform childTransform in go.transform)
                 *  {
                 *      childTransform.SetParent(replacementScript.transform);
                 *  }
                 *
                 *  UnityObject.Destroy(go); //Destroy gameObject which was replaced by replacement Prefab
                 * }
                 */
            }

            List <GameObject> goList           = new List <GameObject>();
            List <bool>       goActivationList = new List <bool>();

            //5. Recover data using scene.Data
            for (int i = 0; i < dataObjects.Length; ++i)
            {
                PersistentData data = dataObjects[i];
                if (!objects.ContainsKey(data.InstanceId))
                {
                    Debug.LogWarningFormat("objects does not have object with instance id {0} however PersistentData of type {1} is present", data.InstanceId, data.GetType());
                    continue;
                }

                UnityObject obj = objects[data.InstanceId];
                data.WriteTo(obj, objects);

                if (obj is GameObject)
                {
                    goList.Add((GameObject)obj);
                    goActivationList.Add(data.ActiveSelf);
                }
            }

            for (int i = 0; i < goList.Count; ++i)
            {
                bool       activeSelf = goActivationList[i];
                GameObject go         = goList[i];
                go.SetActive(activeSelf);
            }
        }
Exemple #8
0
        /// <summary>
        /// Create PersistentDescriptor for gameObject recursive. Set PersistentDescriptor.Parent.
        /// Used is process of creation of PersistentScene object for current scene
        /// </summary>
        /// <param name="go">gameObject (initally root gameObject)</param>
        /// <param name="parentDescriptor">parent descriptor (initially null)</param>
        /// <returns></returns>
        public static PersistentDescriptor CreateDescriptor(GameObject go, PersistentDescriptor parentDescriptor = null)
        {
            PersistentIgnore persistentIgnore = go.GetComponent <PersistentIgnore>();

            if (persistentIgnore != null /*&& persistentIgnore.ReplacementPrefab == null*/)
            {
                //Do not save persistent ignore objects without replacement prefab
                return(null);
            }
            PersistentDescriptor descriptor = new PersistentDescriptor(go);

            descriptor.Parent = parentDescriptor;

            Component[] components;
            if (persistentIgnore == null)
            {
                components = go.GetComponents <Component>().Where(c => c != null && !IgnoreTypes.Contains(c.GetType())).ToArray();
            }
            else
            {
                //if PersistentIgnore component exists then save only Transform and PersistentIgnore components
                components = go.GetComponents <Transform>();
                Array.Resize(ref components, components.Length + 1);
                components[components.Length - 1] = persistentIgnore;
            }

            if (components.Length > 0)
            {
                descriptor.Components = new PersistentDescriptor[components.Length];
                for (int i = 0; i < components.Length; ++i)
                {
                    Component component = components[i];

                    PersistentDescriptor componentDescriptor = new PersistentDescriptor(component);
                    componentDescriptor.Parent = descriptor;

                    descriptor.Components[i] = componentDescriptor;
                }
            }


            Transform transform = go.transform;

            if (transform.childCount > 0)
            {
                List <PersistentDescriptor> children = new List <PersistentDescriptor>();

                foreach (Transform child in transform)
                {
                    //Do not create childDescriptor for replacementPrefab child & for persistentIgnore without ReplacementPrefab
                    if (persistentIgnore == null /* || persistentIgnore.ReplacementPrefab != null && !persistentIgnore.IsChildOfReplacementPrefab(child)*/)
                    {
                        //only for independent child
                        PersistentDescriptor childDescriptor = CreateDescriptor(child.gameObject, descriptor);
                        if (childDescriptor != null)
                        {
                            children.Add(childDescriptor);
                        }
                    }
                }

                descriptor.Children = children.ToArray();
            }

            return(descriptor);
        }