Exemplo n.º 1
0
        void CreateSceneDataCommand(string internalName, GUID asset)
        {
            var sdOp = new SceneDataWriteOperation();

            var fileObjects = m_WriteData.FileToObjects[internalName];

#if !UNITY_2019_1_OR_NEWER
            // ContentBuildInterface.PrepareScene was not returning stable sorted references, causing a indeterminism and loading errors in some cases
            // Add correct sorting here until patch lands to fix the API.
            fileObjects = GetSortedSceneObjectIdentifiers(fileObjects);
#endif
            sdOp.Command = CreateWriteCommand(internalName, fileObjects, new LinearPackedIdentifiers(2)); // Start at 2: PreloadData = 1

            sdOp.UsageSet = new BuildUsageTagSet();
            m_WriteData.FileToUsageSet.Add(internalName, sdOp.UsageSet);

            sdOp.ReferenceMap = new BuildReferenceMap();
            m_WriteData.FileToReferenceMap.Add(internalName, sdOp.ReferenceMap);

            var sceneInfo = m_DependencyData.SceneInfo[asset];
            sdOp.Scene = sceneInfo.scene;
#if !UNITY_2019_3_OR_NEWER
            sdOp.ProcessedScene = sceneInfo.processedScene;
#endif

            {
                var objectSet = new HashSet <ObjectIdentifier>(m_WriteData.FileToObjects[internalName]);
                sdOp.PreloadInfo = new PreloadInfo {
                    preloadObjects = sceneInfo.referencedObjects.Where(x => !objectSet.Contains(x)).ToList()
                };
            }

            m_WriteData.WriteOperations.Add(sdOp);
        }
Exemplo n.º 2
0
        public IEnumerator SceneDataWriteOperation_HashChanges_WhenPrefabDepenencyChanges()
        {
            Scene s = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);

            yield return(null);

            var prefab = AssetDatabase.LoadAssetAtPath <GameObject>(k_CubePath);

            prefab.transform.position = new Vector3(0, 0, 0);
            EditorUtility.SetDirty(prefab);
            AssetDatabase.SaveAssets();
            PrefabUtility.InstantiatePrefab(prefab);

            EditorSceneManager.SaveScene(s, k_ScenePath);

            var op = new SceneDataWriteOperation
            {
                Command     = new WriteCommand(),
                PreloadInfo = new PreloadInfo(),
#if !UNITY_2019_3_OR_NEWER
                ProcessedScene = k_ScenePath,
#endif
                ReferenceMap = new BuildReferenceMap(),
                UsageSet     = new BuildUsageTagSet(),
                Scene        = k_ScenePath
            };
            var cacheVersion1 = op.GetHash128();

            prefab.transform.position = new Vector3(1, 1, 1);
            EditorUtility.SetDirty(prefab);
            AssetDatabase.SaveAssets();
            var cacheVersion2 = op.GetHash128();

            Assert.AreNotEqual(cacheVersion1, cacheVersion2);
        }
        public void OneTimeSetUp()
        {
            WriteOperations    = new IWriteOperation[5];
            WriteOperations[0] = new AssetBundleWriteOperation();
#pragma warning disable CS0618 // Type or member is obsolete
            WriteOperations[1] = new RawWriteOperation();
#pragma warning restore CS0618 // Type or member is obsolete
            WriteOperations[2] = new SceneBundleWriteOperation();
            WriteOperations[3] = new SceneDataWriteOperation();
#pragma warning disable CS0618 // Type or member is obsolete
            WriteOperations[4] = new SceneRawWriteOperation();
#pragma warning restore CS0618 // Type or member is obsolete

            var command = new WriteCommand
            {
                fileName     = GUID.Generate().ToString(),
                internalName = GUID.Generate().ToString()
            };
            var usageSet     = new BuildUsageTagSet();
            var referenceMap = new BuildReferenceMap();

            for (int i = 0; i < WriteOperations.Length; i++)
            {
                WriteOperations[i].Command      = command;
                WriteOperations[i].UsageSet     = usageSet;
                WriteOperations[i].ReferenceMap = referenceMap;
            }
        }
        void CreateSceneDataCommand(string internalName, GUID scene)
        {
            var fileObjects = m_WriteData.FileToObjects[internalName];

#if !UNITY_2019_1_OR_NEWER
            // ContentBuildInterface.PrepareScene was not returning stable sorted references, causing a indeterminism and loading errors in some cases
            // Add correct sorting here until patch lands to fix the API.
            fileObjects = GetSortedSceneObjectIdentifiers(fileObjects);
#endif


            var command        = CreateWriteCommand(internalName, fileObjects, new LinearPackedIdentifiers(2)); // Start at 3: PreloadData = 1
            var usageSet       = new BuildUsageTagSet();
            var referenceMap   = new BuildReferenceMap();
            var preloadObjects = new List <ObjectIdentifier>();
            var dependencyInfo = m_DependencyData.SceneInfo[scene];
            var fileObjectSet  = new HashSet <ObjectIdentifier>(fileObjects);


            usageSet.UnionWith(m_DependencyData.SceneUsage[scene]);
            referenceMap.AddMappings(command.internalName, command.serializeObjects.ToArray());
            foreach (var referencedObject in dependencyInfo.referencedObjects)
            {
                if (fileObjectSet.Contains(referencedObject))
                {
                    continue;
                }
                preloadObjects.Add(referencedObject);
            }


            var operation = new SceneDataWriteOperation();
            operation.Command        = command;
            operation.UsageSet       = usageSet;
            operation.ReferenceMap   = referenceMap;
            operation.DependencyHash = m_DependencyData.DependencyHash.TryGetValue(scene, out var hash) ? hash : new Hash128();
            operation.Scene          = dependencyInfo.scene;
#if !UNITY_2019_3_OR_NEWER
            operation.ProcessedScene = dependencyInfo.processedScene;
#endif
            operation.PreloadInfo = new PreloadInfo();
            operation.PreloadInfo.preloadObjects = preloadObjects;


            m_WriteData.FileToReferenceMap.Add(command.internalName, referenceMap);
            m_WriteData.FileToUsageSet.Add(command.internalName, usageSet);
            m_WriteData.WriteOperations.Add(operation);
        }
Exemplo n.º 5
0
        private IWriteOperation CreateSceneDataWriteOperation(string bundleName, string bundleFileName, GUID scene, BuildDependencyInfo buildInfo)
        {
            var sceneInfo = buildInfo.sceneInfo[scene];

            var op = new SceneDataWriteOperation();

            op.scene            = sceneInfo.scene;
            op.processedScene   = sceneInfo.processedScene;
            op.command.fileName = GenerateInternalFileName(sceneInfo.scene) + ".sharedAssets";
            // TODO: This is bundle formatted internal name, we need to rethink this for PlayerData
            op.command.internalName = string.Format("archive:/{0}/{1}", bundleFileName, op.command.fileName);
            // TODO: Rethink the way we do dependencies here, assetToBundles is for bundles only, won't work for PlayerData or Raw Data.
            op.command.dependencies = buildInfo.assetToBundles[scene].OrderBy(x => x).Where(x => x != bundleName).Select(x => string.Format("archive:/{0}/{0}", GenerateInternalFileName(x))).ToList();
            buildInfo.sceneUsageTags.TryGetValue(scene, out op.usageTags);
            op.command.serializeObjects   = new List <SerializationInfo>();
            op.preloadInfo.preloadObjects = new List <ObjectIdentifier>();
            long identifier = 2; // Scenes use linear id assignment

            foreach (var reference in sceneInfo.referencedObjects)
            {
                if (!buildInfo.assetInfo.ContainsKey(reference.guid) && reference.filePath != kUnityDefaultResourcePath)
                {
                    op.command.serializeObjects.Add(new SerializationInfo
                    {
                        serializationObject = reference,
                        serializationIndex  = identifier++
                    });
                }
                else
                {
                    op.preloadInfo.preloadObjects.Add(reference);
                }
            }

            // TODO: Add this functionality:
            // Unique to scenes, we point at sharedAssets of a previously built scene in this set as a dependency to reduce object duplication.

            return(op);
        }