Ejemplo n.º 1
0
        public void Convert(Scene scene, Hash128 sceneHash, GameObjectConversionUtility.ConversionFlags flags)
        {
            using (m_Convert.Auto())
            {
                // Try incremental conversion
                if (!_RequestCleanConversion)
                {
                    // Debug.Log("Incremental convert");
                    try
                    {
                        GameObjectConversionUtility.ConvertIncremental(GameObjectWorld, _ChangedGameObjects, flags);
                        _ChangedGameObjects.Clear();
                    }
                    catch (Exception e)
                    {
                        _RequestCleanConversion = true;
                        Debug.LogWarning("Incremental conversion failed. Performing full conversion instead\n" + e.ToString());
                    }
                }

                // If anything failed, fall back to clean conversion
                if (_RequestCleanConversion)
                {
                    // Debug.Log("Clean convert");
                    ConvertedWorld.EntityManager.DestroyEntity(ConvertedWorld.EntityManager.UniversalQuery);
                    GameObjectWorld = GameObjectConversionUtility.ConvertIncrementalInitialize(scene, new GameObjectConversionSettings(ConvertedWorld, sceneHash, flags));
                }

                _ChangedGameObjects.Clear();
                _RequestCleanConversion = false;
            }
        }
Ejemplo n.º 2
0
        void Convert(Scene scene, Hash128 sceneGUID, GameObjectConversionUtility.ConversionFlags flags, BuildConfiguration config)
        {
            using (m_ConvertMarker.Auto())
            {
                // Try incremental conversion
                if (!_RequestCleanConversion)
                {
                    // Debug.Log("Incremental convert");
                    try
                    {
                        GameObjectConversionUtility.ConvertIncremental(_GameObjectWorld, _ChangedGameObjects, flags);
                        _ChangedGameObjects.Clear();
                    }
                    #pragma warning disable 168
                    catch (Exception e)
                    {
                        _RequestCleanConversion = true;

                        // Debug.Log("Incremental conversion failed. Performing full conversion instead\n" + e.ToString());
                    }
                    #pragma warning restore 168
                }

                // If anything failed, fall back to clean conversion
                if (_RequestCleanConversion)
                {
                    // Debug.Log("Clean convert");
                    _ConvertedWorld.EntityManager.DestroyEntity(_ConvertedWorld.EntityManager.UniversalQuery);
                    var conversionSettings = new GameObjectConversionSettings(_ConvertedWorld, flags);
                    conversionSettings.BuildConfiguration  = config;
                    conversionSettings.SceneGUID           = sceneGUID;
                    conversionSettings.DebugConversionName = _SceneName;
                    conversionSettings.BlobAssetStore      = m_BlobAssetStore;
                    conversionSettings.FilterFlags         = WorldSystemFilterFlags.HybridGameObjectConversion;

                    if (_GameObjectWorld != null && _GameObjectWorld.IsCreated)
                    {
                        _GameObjectWorld.Dispose();
                        _GameObjectWorld = null;
                    }
                    _GameObjectWorld = GameObjectConversionUtility.ConvertIncrementalInitialize(scene, conversionSettings);
                    m_AssetDependencies.Clear();
                    AddAssetDependencies(_GameObjectWorld.GetExistingSystem <GameObjectConversionMappingSystem>().Dependencies, ref m_AssetDependencies);
                }

                _ChangedGameObjects.Clear();
                _RequestCleanConversion = false;
            }
        }
        GameObjectConversionSettings PrepareConversion(World dstWorld, GameObjectConversionUtility.ConversionFlags flags, GUID buildConfigurationGUID, BuildConfiguration buildConfig)
        {
            dstWorld.EntityManager.DestroyEntity(dstWorld.EntityManager.UniversalQuery);
            var conversionSettings = new GameObjectConversionSettings(dstWorld, flags)
            {
                BuildConfigurationGUID = buildConfigurationGUID,
                BuildConfiguration     = buildConfig,
                SceneGUID           = _SceneGUID,
                DebugConversionName = _Scene.name,
                BlobAssetStore      = _BlobAssetStore
            };

            if (LiveConversionSettings.AdditionalConversionSystems.Count != 0)
            {
                conversionSettings.ExtraSystems = LiveConversionSettings.AdditionalConversionSystems.ToArray();
            }
            return(conversionSettings);
        }
        public void Convert(Scene scene, Hash128 sceneGUID, GameObjectConversionUtility.ConversionFlags flags, BuildSettings buildSettings)
        {
            using (m_ConvertMarker.Auto())
            {
                // Try incremental conversion
                if (!_RequestCleanConversion)
                {
                    // Debug.Log("Incremental convert");
                    try
                    {
                        GameObjectConversionUtility.ConvertIncremental(_GameObjectWorld, _ChangedGameObjects, flags);
                        _ChangedGameObjects.Clear();
                    }
                    catch (Exception e)
                    {
                        _RequestCleanConversion = true;
                        Debug.LogWarning("Incremental conversion failed. Performing full conversion instead\n" + e.ToString());
                    }
                }

                // If anything failed, fall back to clean conversion
                if (_RequestCleanConversion)
                {
                    // Debug.Log("Clean convert");
                    _ConvertedWorld.EntityManager.DestroyEntity(_ConvertedWorld.EntityManager.UniversalQuery);
                    var conversionSettings = new GameObjectConversionSettings(_ConvertedWorld, flags);
                    conversionSettings.BuildSettings       = buildSettings;
                    conversionSettings.SceneGUID           = sceneGUID;
                    conversionSettings.DebugConversionName = _SceneName;
                    conversionSettings.blobAssetStore      = m_BlobAssetStore;

                    if (_GameObjectWorld != null && _GameObjectWorld.IsCreated)
                    {
                        _GameObjectWorld.Dispose();
                        _GameObjectWorld = null;
                    }
                    _GameObjectWorld = GameObjectConversionUtility.ConvertIncrementalInitialize(scene, conversionSettings);
                }

                _ChangedGameObjects.Clear();
                _RequestCleanConversion = false;
            }
        }
        void Convert(GameObjectConversionUtility.ConversionFlags flags)
        {
            using (LiveLinkConvertMarker.Auto())
            {
                var mode = LiveConversionSettings.Mode;
#if UNITY_2020_2_OR_NEWER
                if (mode == LiveConversionSettings.ConversionMode.AlwaysCleanConvert)
                {
                    _RequestCleanConversion = true;
                }
                _IncrementalConversionDebug.LastConversionFlags = flags;
#endif

                // Try incremental conversion
                if (!_RequestCleanConversion)
                {
                    try
                    {
                        using (IncrementalConversionMarker.Auto())
                        {
#if UNITY_2020_2_OR_NEWER
                            _IncrementalConversionDebug.NeedsUpdate = true;
                            var batch = new IncrementalConversionBatch();
                            _IncrementalConversionChangeTracker.FillBatch(ref batch);
                            GameObjectConversionUtility.ConvertIncremental(_GameObjectWorld, flags, ref batch);
#else
                            GameObjectConversionUtility.ConvertIncremental(_GameObjectWorld, m_ChangedGameObjects, _IncrementalConversionChangeTracker.ChangedAssets, flags);
#endif
                            AddMissingData(_ConvertedWorld, _MissingSceneQuery, _MissingRenderDataQuery);
                        }
                    }
#if UNITY_2020_2_OR_NEWER
                    catch (Exception e)
                    {
                        _RequestCleanConversion = true;
                        if (LiveConversionSettings.TreatIncrementalConversionFailureAsError)
                        {
                            throw;
                        }
                        if (mode != LiveConversionSettings.ConversionMode.AlwaysCleanConvert)
                        {
                            Debug.Log("Incremental conversion failed. Performing full conversion instead\n" + e);
                        }
                    }
#else
                    catch (Exception)

                    {
                        _RequestCleanConversion = true;
                    }
#endif
                }

                // If anything failed, fall back to clean conversion
                if (_RequestCleanConversion)
                {
#if UNITY_2020_2_OR_NEWER
                    _IncrementalConversionDebug.NeedsUpdate = false;
#endif
                    using (CleanConversionMarker.Auto())
                    {
                        if (_GameObjectWorld != null && _GameObjectWorld.IsCreated)
                        {
                            _GameObjectWorld.Dispose();
                            _GameObjectWorld = null;
                        }

                        var settings = PrepareConversion(_ConvertedWorld, flags, _buildConfigurationGUID, _buildConfiguration);
                        _GameObjectWorld = GameObjectConversionUtility.InitializeIncrementalConversion(_Scene, settings);
                        _MappingSystem   = _GameObjectWorld.GetExistingSystem <GameObjectConversionMappingSystem>();
                        AddMissingData(_ConvertedWorld, _MissingSceneQuery, _MissingRenderDataQuery);
                    }
                }

                _IncrementalConversionChangeTracker.Clear();
                _RequestCleanConversion = false;
            }
        }