Beispiel #1
0
        public static PrefabInstance CreateVirtualInstance(VirtualSerializedFile virtualFile, GameObject root)
        {
            PrefabInstance instance = virtualFile.CreateAsset((assetInfo) => new PrefabInstance(assetInfo));

            instance.ObjectHideFlags = HideFlags.HideInHierarchy;
            instance.Objects         = Array.Empty <PPtr <EditorExtension> >();
            instance.Modification    = new PrefabModification(virtualFile.Layout);
            instance.RootGameObject  = root.File.CreatePPtr(root);
            instance.IsPrefabAsset   = true;
            instance.Name            = root.Name;
            return(instance);
        }
Beispiel #2
0
        public override IEnumerable <Object> FetchDependencies(ISerializedFile file, bool isLog = false)
        {
            foreach (Object asset in base.FetchDependencies(file, isLog))
            {
                yield return(asset);
            }

#if UNIVERSAL
            yield return(CorrespondingSourceObject.FetchDependency(file));

            yield return(PrefabInstance.FetchDependency(file));

            yield return(PrefabAsset.FetchDependency(file));
#endif
        }
Beispiel #3
0
        public override void Write(AssetWriter writer)
        {
            base.Write(writer);

#if UNIVERSAL
            if (HasCorrespondingSourceObject(writer.Flags))
            {
                CorrespondingSourceObject.Write(writer);
                PrefabInstance.Write(writer);
            }
            if (HasPrefabAsset(writer.Version, writer.Flags))
            {
                PrefabAsset.Write(writer);
            }
#endif
        }
Beispiel #4
0
        public override void Read(AssetReader reader)
        {
            base.Read(reader);

#if UNIVERSAL
            if (HasCorrespondingSourceObject(reader.Flags))
            {
                CorrespondingSourceObject.Read(reader);
                PrefabInstance.Read(reader);
            }
            if (HasPrefabAsset(reader.Version, reader.Flags))
            {
                PrefabAsset.Read(reader);
            }
#endif
        }
        public override void Write(AssetWriter writer)
        {
            base.Write(writer);

#if UNIVERSAL
            EditorExtensionLayout layout = writer.Layout.EditorExtension;
            if (layout.HasExtensionPtr)
            {
                ExtensionPtr.Write(writer);
            }
            if (layout.HasCorrespondingSourceObject)
            {
                CorrespondingSourceObject.Write(writer);
                PrefabInstance.Write(writer);
            }
            if (layout.HasPrefabAsset)
            {
                PrefabAsset.Write(writer);
            }
#endif
        }
        public override void Read(AssetReader reader)
        {
            base.Read(reader);

#if UNIVERSAL
            EditorExtensionLayout layout = reader.Layout.EditorExtension;
            if (layout.HasExtensionPtr)
            {
                ExtensionPtr = reader.ReadAsset <PPtr <Object> >();
            }
            if (layout.HasCorrespondingSourceObject)
            {
                CorrespondingSourceObject.Read(reader);
                PrefabInstance.Read(reader);
            }
            if (layout.HasPrefabAsset)
            {
                PrefabAsset.Read(reader);
            }
#endif
        }
        public override void Read(AssetReader reader)
        {
            base.Read(reader);

#if UNIVERSAL
            if (HasEditorPtrs(reader.Flags))
            {
                if (HasCorrespondingSourceObject(reader.Version, reader.Flags))
                {
                    CorrespondingSourceObject.Read(reader);
                    PrefabInstance.Read(reader);
                }
                else
                {
                    ExtensionPtr = reader.ReadAsset <PPtr <Object> >();
                }
                if (HasPrefabAsset(reader.Version, reader.Flags))
                {
                    PrefabAsset.Read(reader);
                }
            }
#endif
        }