protected override void OnUpdate()
{
if (Input.GetKeyDown(KeyCode.H))
{
Debug.Log($"Saving world...");
using (var writer = new StreamBinaryWriter(FullPath))
{
EntityManager.CompleteAllJobs();
var q = EntityManager.CreateEntityQuery(typeof(Terminal));
EntityManager.DestroyEntity(q);
SerializeUtilityHybrid.Serialize(EntityManager, writer, out _refs);
int refCount = _refs == null ? 0 : _refs.Array.Length;
Debug.Log($"RefCount: {refCount}");
}
}
if (Input.GetKeyDown(KeyCode.L))
{
Debug.Log("Loading World...");
var loadWorld = new World("Loading World");
var em = loadWorld.EntityManager;
using (var reader = new StreamBinaryReader(FullPath))
{
SerializeUtilityHybrid.Deserialize(em, reader, _refs);
}
EntityManager.CompleteAllJobs();
EntityManager.DestroyEntity(EntityManager.UniversalQuery);
EntityManager.MoveEntitiesFrom(em);
loadWorld.Dispose();
}
}
public void HybridComponentSerialize()
{
var root = CreateGameObject();
var values = new[] { 123, 234, 345 };
foreach (var value in values)
{
var gameObject = CreateGameObject().ParentTo(root);
gameObject.AddComponent <EcsTestMonoBehaviourComponent>().SomeValue = value;
}
GameObjectConversionUtility.ConvertGameObjectHierarchy(root, MakeDefaultSettings().WithExtraSystem <ConversionHybridTests.MonoBehaviourComponentConversionSystem>());
ReferencedUnityObjects objRefs = null;
var writer = new TestBinaryWriter();
SerializeUtilityHybrid.Serialize(m_Manager, writer, out objRefs);
var world = new World("temp");
var reader = new TestBinaryReader(writer);
SerializeUtilityHybrid.Deserialize(world.EntityManager, reader, objRefs);
var query = world.EntityManager.CreateEntityQuery(typeof(EcsTestMonoBehaviourComponent));
var components = query.ToComponentArray <EcsTestMonoBehaviourComponent>();
CollectionAssert.AreEquivalent(components.Select(c => c.SomeValue), values);
query.Dispose();
world.Dispose();
reader.Dispose();
}
public void SerializingSharedComponent_WhenMoreThanOne_AndProxyHasDisallowMultiple_DoesNotCrash()
{
for (var i = 0; i < 20; ++i)
{
var entity = m_Manager.CreateEntity();
m_Manager.AddSharedComponentData(entity, new MockSharedDisallowMultiple {
Value = i
});
m_Manager.AddComponentData(entity, new EcsTestData(i));
}
var writer = new TestBinaryWriter();
GameObject sharedComponents = null;
try
{
Assert.That(
() => SerializeUtilityHybrid.Serialize(m_Manager, writer, out sharedComponents),
Throws.ArgumentException.With.Message.Matches(@"\bDisallowMultipleComponent\b")
);
}
finally
{
writer.Dispose();
if (sharedComponents != null)
{
GameObject.DestroyImmediate(sharedComponents);
}
}
}
static int WriteEntityScene(EntityManager scene, Hash128 sceneGUID, string subsection, GameObjectConversionSettings settings, out int objectReferenceCount, NativeArray <EntityRemapUtility.EntityRemapInfo> entityRemapInfos = default)
{
k_ProfileEntitiesSceneSave.Begin();
var ctx = settings.AssetImportContext;
var entitiesBinaryPath = GetSceneWritePath(sceneGUID, EntityScenesPaths.PathType.EntitiesBinary, subsection, ctx);
var objRefsPath = GetSceneWritePath(sceneGUID, EntityScenesPaths.PathType.EntitiesUnityObjectReferences, subsection, ctx);
ReferencedUnityObjects objRefs;
objectReferenceCount = 0;
EnsureFileIsWritableOrThrow(entitiesBinaryPath, ctx);
// Write binary entity file
int entitySceneFileSize = 0;
using (var writer = new StreamBinaryWriter(entitiesBinaryPath))
{
if (entityRemapInfos.IsCreated)
{
SerializeUtilityHybrid.Serialize(scene, writer, out objRefs, entityRemapInfos);
}
else
{
SerializeUtilityHybrid.Serialize(scene, writer, out objRefs);
}
entitySceneFileSize = (int)writer.Length;
// Write object references
k_ProfileEntitiesSceneWriteObjRefs.Begin();
if (objRefs != null)
{
var serializedObjectArray = new List <UnityObject>();
serializedObjectArray.Add(objRefs);
for (int i = 0; i != objRefs.Array.Length; i++)
{
var obj = objRefs.Array[i];
if (obj != null && !EditorUtility.IsPersistent(obj))
{
var saveInBuild = (obj.hideFlags & HideFlags.DontSaveInBuild) == 0;
if (saveInBuild)
{
serializedObjectArray.Add(obj);
}
else
{
objRefs.Array[i] = null;
}
}
}
UnityEditorInternal.InternalEditorUtility.SaveToSerializedFileAndForget(serializedObjectArray.ToArray(), objRefsPath, false);
objectReferenceCount = objRefs.Array.Length;
}
k_ProfileEntitiesSceneWriteObjRefs.End();
}
k_ProfileEntitiesSceneSave.End();
return(entitySceneFileSize);
}
static int WriteEntityScene(EntityManager scene, Entities.Hash128 sceneGUID, string subsection, NativeArray <EntityRemapUtility.EntityRemapInfo> entityRemapInfos = default(NativeArray <EntityRemapUtility.EntityRemapInfo>))
{
k_ProfileEntitiesSceneSave.Begin();
var entitiesBinaryPath = EntityScenesPaths.GetPathAndCreateDirectory(sceneGUID, EntityScenesPaths.PathType.EntitiesBinary, subsection);
var sharedDataPath = EntityScenesPaths.GetPathAndCreateDirectory(sceneGUID, EntityScenesPaths.PathType.EntitiesSharedComponents, subsection);
GameObject sharedComponents;
// We're going to do file writing manually, so make sure to do version control dance if needed
if (Provider.isActive && !AssetDatabase.IsOpenForEdit(entitiesBinaryPath, StatusQueryOptions.UseCachedIfPossible))
{
var task = Provider.Checkout(entitiesBinaryPath, CheckoutMode.Asset);
task.Wait();
if (!task.success)
{
throw new System.Exception($"Failed to checkout entity cache file {entitiesBinaryPath}");
}
}
// Write binary entity file
int entitySceneFileSize = 0;
using (var writer = new StreamBinaryWriter(entitiesBinaryPath))
{
if (entityRemapInfos.IsCreated)
{
SerializeUtilityHybrid.Serialize(scene, writer, out sharedComponents, entityRemapInfos);
}
else
{
SerializeUtilityHybrid.Serialize(scene, writer, out sharedComponents);
}
entitySceneFileSize = (int)writer.Length;
}
// Write shared component data prefab
k_ProfileEntitiesSceneCreatePrefab.Begin();
//var oldPrefab = AssetDatabase.LoadMainAssetAtPath(sharedDataPath);
//if (oldPrefab == null)
// PrefabUtility.CreatePrefab(sharedDataPath, sharedComponents, ReplacePrefabOptions.ReplaceNameBased);
if (sharedComponents != null)
{
PrefabUtility.SaveAsPrefabAsset(sharedComponents, sharedDataPath);
}
//else
// PrefabUtility.Save
//PrefabUtility.ReplacePrefab(sharedComponents, oldPrefab, ReplacePrefabOptions.ReplaceNameBased);
Object.DestroyImmediate(sharedComponents);
k_ProfileEntitiesSceneCreatePrefab.End();
k_ProfileEntitiesSceneSave.End();
return(entitySceneFileSize);
}
static void LoadHybrid(EntityManager entityManager, ReferencedUnityObjects objectTable)
{
string filePath = Application.persistentDataPath + "/testHyb.bin";
using (var binaryReader = new StreamBinaryReader(filePath))
{
//ExclusiveEntityTransaction transaction = entityManager.BeginExclusiveEntityTransaction();
SerializeUtilityHybrid.Deserialize(entityManager, binaryReader, objectTable);
//entityManager.EndExclusiveEntityTransaction();
}
}
static void SaveHybrid(EntityManager entityManager, out ReferencedUnityObjects objectTable)
{
string filePath = Application.persistentDataPath + "/testHyb.bin";
if (File.Exists(filePath))
{
File.Delete(filePath);
}
using (var binaryWriter = new StreamBinaryWriter(filePath))
{
SerializeUtilityHybrid.Serialize(entityManager, binaryWriter, out objectTable);
}
}
public void SharedComponentSerialize()
{
for (int i = 0; i != 20; i++)
{
var entity = m_Manager.CreateEntity();
m_Manager.AddSharedComponentData(entity, new MockSharedData {
Value = i
});
m_Manager.AddComponentData(entity, new EcsTestData(i));
}
var writer = new TestBinaryWriter();
GameObject sharedComponents;
SerializeUtilityHybrid.Serialize(m_Manager, writer, out sharedComponents);
var reader = new TestBinaryReader(writer);
var world = new World("temp");
SerializeUtilityHybrid.Deserialize(world.GetOrCreateManager <EntityManager>(), reader, sharedComponents);
var newWorldEntities = world.GetOrCreateManager <EntityManager>();
{
var entities = newWorldEntities.GetAllEntities();
Assert.AreEqual(20, entities.Length);
for (int i = 0; i != 20; i++)
{
Assert.AreEqual(i, newWorldEntities.GetComponentData <EcsTestData>(entities[i]).value);
Assert.AreEqual(i, newWorldEntities.GetSharedComponentData <MockSharedData>(entities[i]).Value);
}
for (int i = 0; i != 20; i++)
{
newWorldEntities.DestroyEntity(entities[i]);
}
entities.Dispose();
}
Assert.IsTrue(newWorldEntities.Debug.IsSharedComponentManagerEmpty());
world.Dispose();
reader.Dispose();
Object.DestroyImmediate(sharedComponents);
}
static int WriteEntityScene(EntityManager scene, Entities.Hash128 sceneGUID, string subsection, NativeArray <EntityRemapUtility.EntityRemapInfo> entityRemapInfos = default(NativeArray <EntityRemapUtility.EntityRemapInfo>))
{
k_ProfileEntitiesSceneSave.Begin();
var entitiesBinaryPath = EntityScenesPaths.GetPathAndCreateDirectory(sceneGUID, EntityScenesPaths.PathType.EntitiesBinary, subsection);
var sharedDataPath = EntityScenesPaths.GetPathAndCreateDirectory(sceneGUID, EntityScenesPaths.PathType.EntitiesSharedComponents, subsection);
GameObject sharedComponents;
// Write binary entity file
int entitySceneFileSize = 0;
using (var writer = new StreamBinaryWriter(entitiesBinaryPath))
{
if (entityRemapInfos.IsCreated)
{
SerializeUtilityHybrid.Serialize(scene, writer, out sharedComponents, entityRemapInfos);
}
else
{
SerializeUtilityHybrid.Serialize(scene, writer, out sharedComponents);
}
entitySceneFileSize = (int)writer.Length;
}
// Write shared component data prefab
k_ProfileEntitiesSceneCreatePrefab.Begin();
//var oldPrefab = AssetDatabase.LoadMainAssetAtPath(sharedDataPath);
//if (oldPrefab == null)
// PrefabUtility.CreatePrefab(sharedDataPath, sharedComponents, ReplacePrefabOptions.ReplaceNameBased);
if (sharedComponents != null)
{
PrefabUtility.SaveAsPrefabAsset(sharedComponents, sharedDataPath);
}
//else
// PrefabUtility.Save
//PrefabUtility.ReplacePrefab(sharedComponents, oldPrefab, ReplacePrefabOptions.ReplaceNameBased);
Object.DestroyImmediate(sharedComponents);
k_ProfileEntitiesSceneCreatePrefab.End();
k_ProfileEntitiesSceneSave.End();
return(entitySceneFileSize);
}
public static void Load()
{
if (World.All.Count < 1)
{
return;
}
// need an empty world to do this
var world = new World("LoadingWorld");
using (var reader = new StreamBinaryReader(WorldLocation)) //GetFullPathByName(fileName))
{
var objectRefAsset = AssetDatabase.LoadAssetAtPath <ReferencedUnityObjects>(WorldReferencesLocation);
// Load objects as binary file
SerializeUtilityHybrid.Deserialize(world.EntityManager, reader, objectRefAsset);
}
World.DefaultGameObjectInjectionWorld.EntityManager.DestroyEntity(World.DefaultGameObjectInjectionWorld.EntityManager.UniversalQuery);
World.DefaultGameObjectInjectionWorld.EntityManager.MoveEntitiesFrom(world.EntityManager);
Debug.Log("Loaded");
}
public void SerializingSharedComponent_WhenMoreThanOne_AndWrapperHasDisallowMultiple_DoesNotCrash()
{
for (var i = 0; i < 20; ++i)
{
var entity = m_Manager.CreateEntity();
m_Manager.AddSharedComponentData(entity, new MockSharedDisallowMultiple {
Value = i
});
m_Manager.AddComponentData(entity, new EcsTestData(i));
}
var writer = new TestBinaryWriter();
GameObject sharedComponents = null;
try
{
var ex = Assert.Throws <ArgumentException>(
() => SerializeUtilityHybrid.Serialize(m_Manager, writer, out sharedComponents)
);
Assert.That(
ex.Message,
Is.EqualTo(
string.Format(
"{0} is marked with {1}, but current implementation of {2} serializes all shared components on a single GameObject.",
typeof(MockSharedDisallowMultipleComponent),
typeof(DisallowMultipleComponent),
nameof(SerializeUtilityHybrid.SerializeSharedComponents)
)
)
);
}
finally
{
writer.Dispose();
if (sharedComponents != null)
{
GameObject.DestroyImmediate(sharedComponents);
}
}
}
// https://fogbugz.unity3d.com/f/cases/1204153/
public void SharedComponentUnityObjectSerialize_Case_1204153()
{
var go1 = new GameObject();
var go2 = new GameObject();
var shared = new SharedComponentWithUnityObject {
obj = go1
};
var entity = m_Manager.CreateEntity();
m_Manager.AddSharedComponentData(entity, shared);
var writer = new TestBinaryWriter();
ReferencedUnityObjects objRefs = null;
SerializeUtilityHybrid.Serialize(m_Manager, writer, out objRefs);
var reader = new TestBinaryReader(writer);
// Swap the obj ref to a different instance but same value. This can occur with any Unity.Object
// during subscene serialize/deserialize since the editor's Unity.Object.GetHashCode() returns
// an instance ID instead of a hash of the values in it. There is no reasonable expectation that
// the instance IDs would match between a serialize and deserialize.
objRefs.Array[0] = go2;
var world = new World("temp");
SerializeUtilityHybrid.Deserialize(world.EntityManager, reader, objRefs);
var newWorldEntities = world.EntityManager;
var uniqueShared = new List <SharedComponentWithUnityObject>();
var query = newWorldEntities.CreateEntityQuery(ComponentType.ReadWrite <SharedComponentWithUnityObject>());
newWorldEntities.GetAllUniqueSharedComponentData(uniqueShared);
Assert.AreEqual(2, uniqueShared.Count);
query.SetSharedComponentFilter(uniqueShared[1]);
Assert.AreEqual(1, query.CalculateEntityCount());
query.Dispose();
world.Dispose();
reader.Dispose();
}
private void SaveData()
{
if (!Directory.Exists("Saves"))
{
Directory.CreateDirectory("Saves");
}
var formatter = new BinaryFormatter();
var objects = new List <System.Object>();
var saveFile = File.Create("Saves/Save.bin");
// DOTS Save world
if (World.All.Count < 1)
{
return;
}
using (var writer = new StreamWriter(yamlpath))
{
// Path for saving world
var binaryWorldPath = _FileLocation + "\\" + "DefaultWorld.world"; // path backslash for system access
var binaryWriter = new StreamBinaryWriter(binaryWorldPath);
// Save whole world
// not hybrid SerializeUtility.SerializeWorld(em, binaryWriter, out var objectReferences);
var referencedObjectsPath = "Assets/ReferencedUnityWorldObjects.asset"; // path forward slash for asset access
SerializeUtilityHybrid.Serialize(em, binaryWriter, out ReferencedUnityObjects objectReferences);
binaryWriter.Dispose();
// For debugging: log all referenced objects which are saved QueryReferences.Query(objectReferences);
AssetDatabase.CreateAsset(objectReferences, referencedObjectsPath);
objects.Add(objectReferences);
/*var zx = GameObject.Find("test");
* var xm = zx.GetComponent<MeshFilter>();
* var m = xm.sharedMesh;
* var code = m.GetHashCode();*/
}
formatter.Serialize(saveFile, objects);
}
private void LoadData()
{
if (!File.Exists("Saves/Save.bin"))
{
return;
}
if (World.All.Count < 1)
{
return;
}
var formatter = new BinaryFormatter();
var saveFile = File.Open("Saves/Save.bin", FileMode.Open);
var deserializedObject = formatter.Deserialize(saveFile);
var objects = deserializedObject as List <Object>;
var refObjects = objects[0] as ReferencedUnityObjects;
// To generate the file we'll test against
var binaryPath = _FileLocation + "\\" + "DefaultWorld.world";
// need an empty world to do this
var loadingWorld = new World("SavingWorld");
var em = loadingWorld.EntityManager;
using (var reader = new StreamBinaryReader(binaryPath)) //GetFullPathByName(fileName))
{
var referencedObjectsPath = "Assets/ReferencedUnityWorldObjects.asset"; // path forward slash for asset access
var objectRefAsset = AssetDatabase.LoadAssetAtPath <ReferencedUnityObjects>(referencedObjectsPath);
// Load objects as binary file
SerializeUtilityHybrid.Deserialize(em, reader, refObjects);
}
World.DefaultGameObjectInjectionWorld.EntityManager.DestroyEntity(World.DefaultGameObjectInjectionWorld.EntityManager.UniversalQuery);
World.DefaultGameObjectInjectionWorld.EntityManager.MoveEntitiesFrom(em);
Debug.Log("Loaded");
}
/// <summary>
/// Default save method. Saves world as binary file.
/// </summary>
/// <param name="debug"></param>
public static void Save(bool debug = false)
{
if (World.All.Count < 1)
{
return;
}
var entityManager = World.DefaultGameObjectInjectionWorld.EntityManager;
// Path for saving world
var binaryWriter = new StreamBinaryWriter(WorldLocation);
// Save whole world
// pure version - SerializeUtility.SerializeWorld(em, binaryWriter, out var objectReferences);
SerializeUtilityHybrid.Serialize(entityManager, binaryWriter, out var objectReferences);
if (debug)
{
QueryReferences.Query(objectReferences);
}
AssetDatabase.CreateAsset(objectReferences, WorldReferencesLocation);
Debug.Log("Saved");
}
public void SharedComponentSerialize()
{
for (int i = 0; i != 20; i++)
{
var entity = m_Manager.CreateEntity();
m_Manager.AddSharedComponentData(entity, new MockSharedData {
Value = i
});
m_Manager.AddComponentData(entity, new EcsTestData(i));
var buffer = m_Manager.AddBuffer <EcsIntElement>(entity);
foreach (var val in Enumerable.Range(i, i + 5))
{
buffer.Add(new EcsIntElement {
Value = val
});
}
}
var writer = new TestBinaryWriter();
GameObject sharedComponents;
SerializeUtilityHybrid.Serialize(m_Manager, writer, out sharedComponents);
var reader = new TestBinaryReader(writer);
var world = new World("temp");
SerializeUtilityHybrid.Deserialize(world.EntityManager, reader, sharedComponents);
var newWorldEntities = world.EntityManager;
{
var entities = newWorldEntities.GetAllEntities();
Assert.AreEqual(20, entities.Length);
for (int i = 0; i != 20; i++)
{
Assert.AreEqual(i, newWorldEntities.GetComponentData <EcsTestData>(entities[i]).value);
Assert.AreEqual(i, newWorldEntities.GetSharedComponentData <MockSharedData>(entities[i]).Value);
var buffer = newWorldEntities.GetBuffer <EcsIntElement>(entities[i]);
Assert.That(
buffer.AsNativeArray().ToArray(),
Is.EqualTo(Enumerable.Range(i, i + 5).Select(x => new EcsIntElement {
Value = x
}))
);
}
for (int i = 0; i != 20; i++)
{
newWorldEntities.DestroyEntity(entities[i]);
}
entities.Dispose();
}
Assert.IsTrue(newWorldEntities.Debug.IsSharedComponentManagerEmpty());
world.Dispose();
reader.Dispose();
Object.DestroyImmediate(sharedComponents);
}
public void ManagedComponentWithObjectReferenceSerialize()
{
for (int i = 0; i != 20; i++)
{
var e1 = m_Manager.CreateEntity();
UnityEngine.Texture2D tex = new UnityEngine.Texture2D(i + 1, i + 1);
var expectedManagedComponent = new ManagedComponentWithObjectReference {
Texture = tex
};
m_Manager.AddComponentData(e1, expectedManagedComponent);
}
var writer = new TestBinaryWriter();
ReferencedUnityObjects objRefs = null;
SerializeUtilityHybrid.Serialize(m_Manager, writer, out objRefs);
var world = new World("temp");
var reader = new TestBinaryReader(writer);
SerializeUtilityHybrid.Deserialize(world.EntityManager, reader, objRefs);
var newWorldEntities = world.EntityManager;
{
var entities = newWorldEntities.GetAllEntities();
Assert.AreEqual(20, entities.Length);
var seenWidths = new NativeArray <bool>(entities.Length, Allocator.Temp);
var seenHeights = new NativeArray <bool>(entities.Length, Allocator.Temp);
for (int i = 0; i < entities.Length; ++i)
{
var e = entities[i];
var actualManagedComponent = newWorldEntities.GetComponentData <ManagedComponentWithObjectReference>(e);
Assert.NotNull(actualManagedComponent);
var tex = actualManagedComponent.Texture;
seenWidths[tex.width - 1] = true;
seenHeights[tex.height - 1] = true;
}
for (int i = 0; i < entities.Length; ++i)
{
Assert.IsTrue(seenWidths[i]);
Assert.IsTrue(seenHeights[i]);
}
seenWidths.Dispose();
seenHeights.Dispose();
for (int i = 0; i != 20; i++)
{
newWorldEntities.DestroyEntity(entities[i]);
}
entities.Dispose();
}
Assert.IsTrue(newWorldEntities.Debug.IsSharedComponentManagerEmpty());
world.Dispose();
reader.Dispose();
}
