public void SyncDiff() { using (var diff = WorldDiffer.UpdateDiff(m_After, m_Shadow, Allocator.TempJob)) { WorldDiffer.ApplyDiff(m_DstWorld, diff); } }
public void StressTestRecreation() { // Add shared component to scramble src shared indices var ent = m_Manager.CreateEntity(); m_Manager.AddSharedComponentData(ent, new EcsTestSharedComp(3)); int end = 100; CreateStressData(0, end, false, true, true); SyncDiff(); for (int i = 0; i < 10; i++) { m_Manager.DestroyEntity(m_Manager.GetAllEntities()); CreateStressData(0, end, false, true, true); using (var diff = WorldDiffer.UpdateDiff(m_After, m_Shadow, Allocator.TempJob)) { Assert.IsFalse(diff.HasChanges); WorldDiffer.ApplyDiff(m_DstWorld, diff); } TestStressData(0, end, false, true, true); } Assert.AreEqual(end, m_DstManager.GetAllEntities().Length); }
public void Apply(World world) { foreach (var diff in m_WorldDiffs) { WorldDiffer.ApplyDiff(world, diff); } }
public void WorldChangeTracker_DestroyEntityAndRestore() { var entity = m_EntityManager.CreateEntity(typeof(EntityGuid)); UpdateWithoutChanges(); m_EntityManager.DestroyEntity(entity); Assert.IsTrue(m_ChangeTracker.TryGetChanges(out var changes)); try { Assert.IsTrue(changes.EntitiesWereDeleted); Assert.AreEqual(1, changes.WorldDiff.DeletedEntityCount); Assert.AreEqual(1, changes.InverseDiff.NewEntityCount); WorldDiffer.ApplyDiff(m_World, changes.InverseDiff); using (var entities = m_EntityManager.GetAllEntities(Allocator.Temp)) { Assert.AreEqual(1, entities.Length); } } finally { changes.Dispose(); } }
public static void ConvertSceneAndApplyDiff(Scene scene, World previousStateShadowWorld, World dstEntityWorld) { using (var cleanConvertedEntityWorld = new World("Clean Entity Conversion World")) { ConvertScene(scene, default(Unity.Entities.Hash128), cleanConvertedEntityWorld, ConversionFlags.AddEntityGUID); WorldDiffer.DiffAndApply(cleanConvertedEntityWorld, previousStateShadowWorld, dstEntityWorld); } }
public static void ConvertSceneAndApplyDiff(Scene scene, World previousStateShadowWorld, World dstEntityWorld) { using (var cleanConvertedEntityWorld = new World("Clean Entity Conversion World")) { GameObjectConversionUtility.ConvertScene(scene, cleanConvertedEntityWorld, true); WorldDiffer.DiffAndApply(cleanConvertedEntityWorld, previousStateShadowWorld, dstEntityWorld); } }
public static void ConvertSceneAndApplyDiff(Scene scene, World previousStateShadowWorld, World dstEntityWorld) { using (var cleanConvertedEntityWorld = new World("Clean Entity Conversion World")) { ConvertInternal(scene, cleanConvertedEntityWorld, true); using (var diff = WorldDiffer.UpdateDiff(cleanConvertedEntityWorld, previousStateShadowWorld, Allocator.TempJob)) { WorldDiffer.ApplyDiff(dstEntityWorld, diff); } } }
public void ComputeDiffOnly() { EntityGuid[] guids = new EntityGuid[4]; Entity[] ents = new Entity[4]; // create 4 entities for (int i = 0; i < 4; ++i) { guids[i] = GenerateEntityGuid(i + 1); ents[i] = m_Manager.CreateEntity(typeof(EntityGuid), typeof(EcsTestData)); m_Manager.SetComponentData(ents[i], guids[i]); m_Manager.SetComponentData(ents[i], new EcsTestData { value = i }); } WorldDiff diff = default; // Calculate initial diff diff = WorldDiffer.CreateDiff(m_After, m_Shadow, Allocator.TempJob); Assert.AreEqual(diff.NewEntityCount, 4); diff.Dispose(); // These shouldn't exist in the shadow world foreach (var guid in guids) { Assert.AreEqual(Entity.Null, GetEntityByGuid(m_Shadow.EntityManager, guid)); } // Calculate same diff again; results should be the same as above diff = WorldDiffer.CreateDiff(m_After, m_Shadow, Allocator.TempJob); Assert.AreEqual(diff.NewEntityCount, 4); // These still shouldn't exist in the shadow world foreach (var guid in guids) { Assert.AreEqual(Entity.Null, GetEntityByGuid(m_Shadow.EntityManager, guid)); } // Now apply the diff to the dst world WorldDiffer.ApplyDiff(m_DstWorld, diff); diff.Dispose(); // and now they should exist in the dst world for (int i = 0; i < 4; ++i) { Assert.AreEqual(ents[i], GetEntityByGuid(m_DstManager, guids[i])); } }
public void DiffOnly() { using (var diff = WorldDiffer.UpdateDiff(m_After, m_Shadow, Allocator.TempJob)) { Assert.IsFalse(diff.HasChanges); } var guid = GenerateEntityGuid(0); var e = m_Manager.CreateEntity(typeof(EntityGuid), typeof(EcsTestData)); m_Manager.SetComponentData(e, guid); m_Manager.SetComponentData(e, new EcsTestData { value = 9 }); using (var diff = WorldDiffer.UpdateDiff(m_After, m_Shadow, Allocator.TempJob)) { Assert.AreEqual(0, diff.DeletedEntityCount); Assert.AreEqual(1, diff.NewEntityCount); Assert.AreEqual(2, diff.AddComponents.Length); Assert.AreEqual(2, diff.SetCommands.Length); } m_Manager.SetComponentData(e, guid); m_Manager.SetComponentData(e, new EcsTestData { value = 10 }); using (var diff = WorldDiffer.UpdateDiff(m_After, m_Shadow, Allocator.TempJob)) { Assert.AreEqual(0, diff.DeletedEntityCount); Assert.AreEqual(0, diff.NewEntityCount); Assert.AreEqual(1, diff.SetCommands.Length); Assert.AreEqual(0, diff.AddComponents.Length); } m_Manager.DestroyEntity(e); using (var diff = WorldDiffer.UpdateDiff(m_After, m_Shadow, Allocator.TempJob)) { Assert.AreEqual(1, diff.DeletedEntityCount); Assert.AreEqual(0, diff.NewEntityCount); Assert.AreEqual(0, diff.SetCommands.Length); Assert.AreEqual(0, diff.RemoveComponents.Length); } }
public void SharedComponentDiff() { var e = m_Manager.CreateEntity(); var guid = GenerateEntityGuid(0); m_Manager.AddComponentData(e, guid); m_Manager.AddSharedComponentData(e, new EcsTestSharedComp { value = 2 }); using (var diff = WorldDiffer.UpdateDiff(m_After, m_Shadow, Allocator.TempJob)) { Assert.AreEqual(1, diff.NewEntityCount); Assert.AreEqual(2, diff.AddComponents.Length); Assert.AreEqual(1, diff.SetCommands.Length); Assert.AreEqual(1, diff.SharedSetCommands.Length); } }
public void EntityPatchWithAmbiguousTargetDoesNotThrow() { var guid = GenerateEntityGuid(0); var srcWorldEntity0 = m_Manager.CreateEntity(); m_Manager.AddComponentData(srcWorldEntity0, guid); var dstWorldEntity0 = m_DstManager.CreateEntity(); m_DstManager.AddComponentData(dstWorldEntity0, guid); Assert.DoesNotThrow(() => { var diff = WorldDiffer.UpdateDiff(m_After, m_Shadow, Allocator.TempJob); Append(ref diff.EntityPatches, new DiffEntityPatch { Guid = guid }); using (diff) WorldDiffer.ApplyDiff(m_DstWorld, diff); }); }
public void WorldDiffsShowNoChangesWithPatchedReferences() { EntityGuid[] guids = new EntityGuid[2]; Entity[] ents = new Entity[2]; for (int i = 0; i < 2; ++i) { guids[i] = GenerateEntityGuid(i + 1); ents[i] = m_Manager.CreateEntity(typeof(EntityGuid), typeof(EcsTestDataEntity)); } for (int i = 0; i < 2; ++i) { m_Manager.SetComponentData(ents[i], guids[i]); m_Manager.SetComponentData(ents[i], new EcsTestDataEntity { value0 = i, value1 = ents[i] }); } // create and destroy a dummy entity in dst world, bumping up the version number var e = m_DstWorld.EntityManager.CreateEntity(typeof(EcsTestData)); m_DstWorld.EntityManager.DestroyEntity(e); // create and apply a diff of two entities being created with inner references var diff = WorldDiffer.CreateDiff(m_After, m_Shadow, Allocator.TempJob); using (diff) { WorldDiffer.ApplyDiff(m_DstWorld, diff); } // The diff between m_DstWorld and m_After should be empty, even though internally // they refer to different Entity index/version values (but the guids are the same). diff = WorldDiffer.CreateDiff(m_DstWorld, m_After, Allocator.TempJob); using (diff) { Assert.IsFalse(diff.HasChanges); } }
void ApplyLiveLink(SubScene scene) { //Debug.Log("ApplyLiveLink: " + scene.SceneName); var streamingSystem = World.GetExistingManager <SubSceneStreamingSystem>(); var isFirstTime = scene.LiveLinkShadowWorld == null; if (scene.LiveLinkShadowWorld == null) { scene.LiveLinkShadowWorld = new World("LiveLink"); } using (var cleanConvertedEntityWorld = new World("Clean Entity Conversion World")) { // Unload scene //@TODO: We optimally shouldn't be unloading the scene here. We should simply prime the shadow world with the scene that we originally loaded into the player (Including Entity GUIDs) // This way we can continue the live link, compared to exactly what we loaded into the player. if (isFirstTime) { foreach (var s in scene._SceneEntities) { streamingSystem.UnloadSceneImmediate(s); EntityManager.DestroyEntity(s); } var sceneEntity = EntityManager.CreateEntity(); EntityManager.SetName(sceneEntity, "Scene (LiveLink): " + scene.SceneName); EntityManager.AddComponentObject(sceneEntity, scene); EntityManager.AddComponentData(sceneEntity, new SubSceneStreamingSystem.StreamingState { Status = SubSceneStreamingSystem.StreamingStatus.Loaded }); EntityManager.AddComponentData(sceneEntity, new SubSceneStreamingSystem.IgnoreTag( )); scene._SceneEntities = new List <Entity>(); scene._SceneEntities.Add(sceneEntity); } // Convert scene GameObjectConversionUtility.ConvertScene(scene.LoadedScene, scene.SceneGUID, cleanConvertedEntityWorld, GameObjectConversionUtility.ConversionFlags.AddEntityGUID | GameObjectConversionUtility.ConversionFlags.AssignName); var convertedEntityManager = cleanConvertedEntityWorld.GetOrCreateManager <EntityManager>(); var liveLinkSceneEntity = scene._SceneEntities[0]; /// We want to let the live linked scene be able to reference the already existing Scene Entity (Specifically SceneTag should point to the scene Entity after live link completes) // Add Scene tag to all entities using the convertedSceneEntity that will map to the already existing scene entity. convertedEntityManager.AddSharedComponentData(convertedEntityManager.UniversalGroup, new SceneTag { SceneEntity = liveLinkSceneEntity }); WorldDiffer.DiffAndApply(cleanConvertedEntityWorld, scene.LiveLinkShadowWorld, World); convertedEntityManager.Debug.CheckInternalConsistency(); scene.LiveLinkShadowWorld.GetOrCreateManager <EntityManager>().Debug.CheckInternalConsistency(); var group = EntityManager.CreateComponentGroup(typeof(SceneTag), ComponentType.Exclude <EditorRenderData>()); group.SetFilter(new SceneTag { SceneEntity = liveLinkSceneEntity }); EntityManager.AddSharedComponentData(group, new EditorRenderData() { SceneCullingMask = m_LiveLinkEditGameViewMask, PickableObject = scene.gameObject }); group.Dispose(); scene.LiveLinkDirtyID = GetSceneDirtyID(scene.LoadedScene); EditorUpdateUtility.EditModeQueuePlayerLoopUpdate(); } }