public void Execute()
{
var loadingOperation = (AsyncLoadSceneOperation)LoadingOperationHandle.Target;
LoadingOperationHandle.Free();
object[] objectReferences = null;
#if !UNITY_DOTSRUNTIME
objectReferences = (object[])ObjectReferencesHandle.Target;
ObjectReferencesHandle.Free();
#endif
try
{
using (var reader = new MemoryBinaryReader(FileContent))
{
k_ProfileDeserializeWorld.Begin();
SerializeUtility.DeserializeWorld(Transaction, reader, objectReferences);
k_ProfileDeserializeWorld.End();
}
}
catch (Exception exc)
{
loadingOperation._LoadingFailure = exc.Message;
loadingOperation._LoadingException = exc;
}
}
public BLP(byte[] bytes, int start, int length)
{
var reader = new MemoryBinaryReader(bytes, start, length);
Header = new BLPHeader(reader);
uint w = Header.Width;
uint h = Header.Height;
Data = new Rgba32[Header.MipCount][];
int mipLevel;
for (mipLevel = 0; mipLevel < Header.MipCount; ++mipLevel)
{
reader.Offset = (int)Header.GetMipOffset(mipLevel);
var mipReader = new LimitedReader(reader, (int)Header.GetMipSize(mipLevel));
if (Header.ColorEncoding == ColorEncoding.Palette)
{
uint len = w * h;
Data[mipLevel] = new Rgba32[w * h];
for (int j = 0; j < len; j++)
{
var b = mipReader.ReadByte();
var color = Header.PaletteBGRA ![b];
private static unsafe SuperBlock CreateSuperBlock(byte[] bytes)
{
fixed(byte *memory = bytes)
{
MemoryBinaryReader reader = new MemoryBinaryReader(memory, bytes.Length);
return(SuperBlock.Read(reader));
}
}
public void ReadCStringWide()
{
byte[] bytes = new byte[] { (byte)'T', 0, (byte)'e', 0, (byte)'s', 0, (byte)'t', 0, 0, 0 };
fixed(byte *memory = bytes)
{
MemoryBinaryReader reader = new MemoryBinaryReader(memory, bytes.Length);
Assert.Equal("Test", reader.ReadCStringWide().String);
Assert.Equal(0, reader.BytesRemaining);
}
}
public void ReadUint()
{
byte[] bytes = new byte[] { 127, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 1 };
fixed(byte *memory = bytes)
{
MemoryBinaryReader reader = new MemoryBinaryReader(memory, bytes.Length);
Assert.Equal(127U, reader.ReadUint());
Assert.Equal(uint.MaxValue, reader.ReadUint());
Assert.Equal(256 * 256 * 256U, reader.ReadUint());
Assert.Equal(0, reader.BytesRemaining);
}
}
public void ReadLong()
{
byte[] bytes = new byte[] { 127, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 1, 0, 0, 0, 0 };
fixed(byte *memory = bytes)
{
MemoryBinaryReader reader = new MemoryBinaryReader(memory, bytes.Length);
Assert.Equal(127, reader.ReadLong());
Assert.Equal(-1, reader.ReadLong());
Assert.Equal(256 * 256 * 256, reader.ReadLong());
Assert.Equal(0, reader.BytesRemaining);
}
}
public void ReadBytePinnerManaged()
{
byte[] bytes = new byte[] { 127, 128, 129, 200 };
MemoryBuffer buffer = new MemoryBuffer(bytes);
using var pinner = new MemoryBufferPinner(buffer);
var reader = new MemoryBinaryReader(pinner);
for (int i = 0; i < bytes.Length; i++)
{
Assert.Equal(bytes[i], reader.ReadByte());
}
Assert.Equal(0, reader.BytesRemaining);
}
public void ReadByte()
{
byte[] bytes = new byte[] { 127, 128, 129, 200 };
fixed(byte *memory = bytes)
{
MemoryBinaryReader reader = new MemoryBinaryReader(memory, bytes.Length);
for (int i = 0; i < bytes.Length; i++)
{
Assert.Equal(bytes[i], reader.ReadByte());
}
Assert.Equal(0, reader.BytesRemaining);
}
}
public unsafe void Move()
{
byte[] bytes = Guid.NewGuid().ToByteArray();
fixed(byte *memory = bytes)
{
MemoryBinaryReader reader = new MemoryBinaryReader(memory, bytes.Length);
Assert.Equal(bytes.Length, reader.Length);
reader.Move((uint)bytes.Length / 2);
Assert.Equal(bytes.Length / 2, reader.BytesRemaining);
reader.Position += bytes.Length / 2;
Assert.Equal(0, reader.BytesRemaining);
}
}
public static void DeserializeWorld(byte[] bytes, EntityManager em, object[] unityObjects = null)
{
em.PrepareForDeserialize();
unsafe
{
fixed(byte *dataPtr = bytes)
{
using (MemoryBinaryReader reader = new MemoryBinaryReader(dataPtr))
{
SerializeUtility.DeserializeWorld(em.BeginExclusiveEntityTransaction(), reader, unityObjects);
em.EndExclusiveEntityTransaction();
}
}
}
}
/// <summary>
/// Reads bytes from a buffer, validates the expected serialized version, and deserializes them into a new blob asset.
/// </summary>
/// <param name="data">A byte stream of the blob data to read.</param>
/// <param name="version">Expected version number of the blob data.</param>
/// <param name="result">The resulting BlobAssetReference if the data was read successful.</param>
/// <returns>A bool if the read was successful or not.</returns>
public static bool TryRead(byte *data, int version, out BlobAssetReference <T> result)
{
var binaryReader = new MemoryBinaryReader(data);
var storedVersion = binaryReader.ReadInt();
if (storedVersion != version)
{
result = default;
return(false);
}
result = binaryReader.Read <T>();
return(true);
}
public void ReadByteUnsafeAccessPointer()
{
byte[] bytes = new byte[] { 127, 128, 129, 200 };
fixed(byte *memory = bytes)
{
MemoryBuffer buffer = new MemoryBuffer(memory, bytes.Length);
using var access = new MemoryBufferUnsafeAccess(buffer);
var reader = new MemoryBinaryReader(access);
for (int i = 0; i < bytes.Length; i++)
{
Assert.Equal(bytes[i], reader.ReadByte());
}
Assert.Equal(0, reader.BytesRemaining);
}
}
public unsafe World Create()
{
World world;
fixed(byte *ptr = bytes)
{
var data = new MemoryBinaryReader(ptr);
var blob = data.Read <WorldDefinitionData>();
world = new World(blob.Value.name.ToString());
for (int i = 0; i < blob.Value.entries.Length; i++)
{
world.CreateSystem(Type.GetType(blob.Value.entries[i].assemblyQualifiedName.ToString()));
}
}
return(world);
}
/// <summary>
/// Create a clone of a BlobAssetReference
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static unsafe BlobAssetReference <T> Clone <T>(this BlobAssetReference <T> source) where T : struct
{
if (source == BlobAssetReference <T> .Null)
{
return(BlobAssetReference <T> .Null);
}
var writer = new MemoryBinaryWriter();
writer.Write(source);
var reader = new MemoryBinaryReader(writer.Data);
var clone = reader.Read <T>();
writer.Dispose();
reader.Dispose();
return(clone);
}
/// <summary>
/// Reads bytes from a buffer, validates the expected serialized version, and deserializes them into a new blob asset.
/// </summary>
/// <param name="buffer">Byte array of buffer</param>
/// <param name="version">Expected version number of the blob data.</param>
/// <param name="result">The resulting BlobAssetReference if the data was read successful.</param>
/// <returns>A bool if the read was successful or not.</returns>
public static bool TryRead(byte[] buffer, int version, out BlobAssetReference <T> result)
{
fixed(byte *fixedBuffer = buffer)
{
using (var binaryReader = new MemoryBinaryReader(fixedBuffer))
{
var storedVersion = binaryReader.ReadInt();
if (storedVersion != version)
{
result = default;
return(false);
}
result = binaryReader.Read <T>();
return(true);
}
}
}
public unsafe void ReadBytes()
{
byte[] bytes = Guid.NewGuid().ToByteArray();
fixed(byte *memory = bytes)
{
MemoryBinaryReader reader = new MemoryBinaryReader(memory, bytes.Length);
byte[] readBytes = new byte[reader.BytesRemaining];
fixed(byte *b = readBytes)
{
reader.ReadBytes(b, (uint)readBytes.Length);
}
Assert.Equal(bytes, readBytes);
Assert.Equal(0, reader.BytesRemaining);
}
}
public static unsafe BlobAssetReference <NodeBlob> ToBlob(this TextAsset file)
{
var dataPtr = UnsafeUtility.PinGCArrayAndGetDataAddress(file.bytes, out var gcHandle);
var reader = new MemoryBinaryReader((byte *)dataPtr);
try
{
var storedVersion = reader.ReadInt();
if (storedVersion != NodeBlob.VERSION)
{
throw new FormatException("Version is not match.");
}
return(reader.Read <NodeBlob>());
}
finally
{
reader.Dispose();
UnsafeUtility.ReleaseGCObject(gcHandle);
}
}
public unsafe void Duplicate()
{
byte[] bytes = Guid.NewGuid().ToByteArray();
fixed(byte *memory = bytes)
{
MemoryBinaryReader reader = new MemoryBinaryReader(memory, bytes.Length);
reader.Position = 5;
IBinaryReader reader2 = reader.Duplicate();
Assert.Equal(reader.Position, reader2.Position);
reader.Position++;
Assert.NotEqual(reader.Position, reader2.Position);
reader2.Position++;
Assert.Equal(reader.Position, reader2.Position);
reader2.Position++;
Assert.NotEqual(reader.Position, reader2.Position);
}
}
public void Execute()
{
var loadingOperation = (AsyncLoadSceneOperation)LoadingOperationHandle.Target;
LoadingOperationHandle.Free();
var objectReferences = (UnityEngine.Object[]) ObjectReferencesHandle.Target;
ObjectReferencesHandle.Free();
try
{
using (var reader = new MemoryBinaryReader(FileContent))
{
k_ProfileDeserializeWorld.Begin();
SerializeUtility.DeserializeWorld(Transaction, reader, objectReferences);
k_ProfileDeserializeWorld.End();
}
}
catch (Exception exc)
{
loadingOperation._LoadingFailure = exc.ToString();
}
}
public World DeserializeWorld(string base64)
{
var world = new World("Loaded world " + Time.time);
var manager = world.EntityManager;
var bytes = new NativeArray <byte>(Convert.FromBase64String(base64), Allocator.Temp);
var transaction = manager.BeginExclusiveEntityTransaction();
unsafe
{
var reader = new MemoryBinaryReader((byte *)bytes.GetUnsafePtr());
SerializeUtility.DeserializeWorld(transaction, reader);
}
manager.EndExclusiveEntityTransaction();
DestroyWorldTimeSingleton(world); // fix for ecs world time management
bytes.Dispose();
return(world);
}
public void Execute()
{
var loadingOperation = (AsyncLoadSceneOperation)LoadingOperationHandle.Target;
LoadingOperationHandle.Free();
try
{
using (var reader = new MemoryBinaryReader(FileContent))
{
k_ProfileDeserializeWorld.Begin();
SerializeUtility.DeserializeWorld(Transaction, reader, SharedComponentCount);
k_ProfileDeserializeWorld.End();
k_ProfileReleaseSharedComponents.Begin();
SerializeUtilityHybrid.ReleaseSharedComponents(Transaction, SharedComponentCount);
k_ProfileReleaseSharedComponents.End();
}
}
catch (Exception exc)
{
loadingOperation._LoadingFailure = exc.Message;
}
}
public AsyncLoadSceneOperation(AsyncLoadSceneData asyncLoadSceneData, bool usingLiveLink)
{
_Data = asyncLoadSceneData;
_LoadingStatus = LoadingStatus.NotStarted;
if (usingLiveLink && _ExpectedObjectReferenceCount != 0)
{
// Resolving must happen on the main thread
using (var data = new NativeArray <byte>(File.ReadAllBytes(_ResourcesPathObjRefs), Allocator.Temp))
using (var reader = new MemoryBinaryReader((byte *)data.GetUnsafePtr()))
{
var numObjRefGUIDs = reader.ReadInt();
NativeArray <RuntimeGlobalObjectId> objRefGUIDs = new NativeArray <RuntimeGlobalObjectId>(numObjRefGUIDs, Allocator.Temp);
reader.ReadArray(objRefGUIDs, numObjRefGUIDs);
var objs = new UnityEngine.Object[numObjRefGUIDs];
LiveLinkPlayerAssetRefreshSystem._GlobalAssetObjectResolver.ResolveObjects(objRefGUIDs, objs);
objRefGUIDs.Dispose();
_ResourceObjRefs = ScriptableObject.CreateInstance <ReferencedUnityObjects>();
_ResourceObjRefs.Array = objs;
}
}
}
protected override unsafe void OnUpdate()
{
var ecb = new EntityCommandBuffer(Allocator.TempJob);
Entities
.WithAll <SceneData, RequestSceneLoaded>()
.WithNone <SceneLoadRequest>()
.ForEach((Entity e) =>
{
var sceneData = EntityManager.GetComponentData <SceneData>(e);
var sceneGuid = sceneData.Scene.SceneGuid;
var path = DataRootPath + sceneGuid.Guid.ToString("N");
#if IO_ENABLE_TRACE
Debug.Log($"SceneStreamingSystem: starting load for {DebugSceneGuid(sceneData)} from {path}");
#endif
// Fire async reads for scene data
SceneLoadRequest request = new SceneLoadRequest();
request.SceneOpHandle = IOService.RequestAsyncRead(path);
ecb.AddComponent(e, request);
ecb.RemoveComponent <RequestSceneLoaded>(e);
sceneData.Status = SceneStatus.Loading;
ecb.SetComponent(e, sceneData);
});
ecb.Playback(EntityManager);
ecb.Dispose();
var pendingRequests = m_PendingRequestsQuery.ToEntityArray(Allocator.TempJob);
ecb = new EntityCommandBuffer(Allocator.TempJob);
foreach (var requestEntity in pendingRequests)
{
SceneData sceneData = EntityManager.GetComponentData <SceneData>(requestEntity);
SceneLoadRequest request = EntityManager.GetComponentData <SceneLoadRequest>(requestEntity);
var opStatus = request.SceneOpHandle.GetStatus();
if (opStatus <= Status.InProgress)
{
continue;
}
if (opStatus == Status.Failure)
{
request.SceneOpHandle.Dispose();
ecb.RemoveComponent <SceneLoadRequest>(requestEntity);
Debug.Log($"SceneStreamingSystem: Failed to load {DebugSceneGuid(sceneData)}");
sceneData.Status = SceneStatus.FailedToLoad;
ecb.SetComponent(requestEntity, sceneData);
continue;
}
Assert.IsTrue(opStatus == Status.Success);
request.SceneOpHandle.GetData(out var data, out var sceneDataSize);
SceneHeader header = *(SceneHeader *)data;
int headerSize = UnsafeUtility.SizeOf <SceneHeader>();
if (header.Version != SceneHeader.CurrentVersion)
{
throw new Exception($"Scene serialization version mismatch in {DebugSceneGuid(sceneData)}. Reading version '{header.Version}', expected '{SceneHeader.CurrentVersion}'");
}
byte *decompressedScene = data + headerSize;
if (header.Codec != Codec.Codec.None)
{
decompressedScene = (byte *)UnsafeUtility.Malloc(header.DecompressedSize, 16, Allocator.Temp);
if (!CodecService.Decompress(header.Codec, data + headerSize, sceneDataSize - headerSize, decompressedScene, header.DecompressedSize))
{
throw new Exception($"Failed to decompress compressed scene {DebugSceneGuid(sceneData)} using codec '{header.Codec}'");
}
}
using (var sceneReader = new MemoryBinaryReader(decompressedScene))
{
var loadingEM = m_LoadingWorld.EntityManager;
var transaction = loadingEM.BeginExclusiveEntityTransaction();
SerializeUtility.DeserializeWorld(transaction, sceneReader);
loadingEM.EndExclusiveEntityTransaction();
}
var scene = sceneData.Scene;
var activeEM = EntityManager;
activeEM.MoveEntitiesFrom(out var movedEntities, m_LoadingWorld.EntityManager);
foreach (var e in movedEntities)
{
ecb.AddSharedComponent(e, scene.SceneGuid);
ecb.AddSharedComponent(e, scene.SceneInstanceId);
}
// Fixup Entity references now that the entities have moved
EntityManager.World.GetExistingSystem <EntityReferenceRemapSystem>().Update();
EntityManager.World.GetExistingSystem <RemoveRemapInformationSystem>().Update();
if (header.Codec != Codec.Codec.None)
{
UnsafeUtility.Free(decompressedScene, Allocator.Temp);
}
#if IO_ENABLE_TRACE
Debug.Log($"SceneStreamingSystem: Loaded scene {DebugSceneGuid(sceneData)}");
#endif
sceneData.Status = SceneStatus.Loaded;
ecb.SetComponent(requestEntity, sceneData);
request.SceneOpHandle.Dispose();
ecb.RemoveComponent <SceneLoadRequest>(requestEntity);
m_LoadingWorld.EntityManager.PrepareForDeserialize();
movedEntities.Dispose();
}
ecb.Playback(EntityManager);
ecb.Dispose();
pendingRequests.Dispose();
}
protected override unsafe void OnUpdate()
{
{
var ecb = new EntityCommandBuffer(Allocator.Temp);
Entities
.WithAll <SceneData, RequestSceneLoaded>()
.WithNone <SceneLoadRequest>()
.ForEach((Entity e) =>
{
if (m_currentRequestTotal >= kMaxRequestsInFlight)
{
return;
}
var sceneData = EntityManager.GetComponentData <SceneData>(e);
var sceneGuid = sceneData.Scene.SceneGuid;
var path = "Data/" + sceneGuid.Guid.ToString("N");
// Fire async reads for scene data
SceneLoadRequest request = new SceneLoadRequest();
request.SceneOpHandle = IOService.RequestAsyncRead(path);
ecb.AddComponent(e, request);
ecb.RemoveComponent <RequestSceneLoaded>(e);
sceneData.Status = SceneStatus.Loading;
ecb.SetComponent(e, sceneData);
m_currentRequestTotal++;
});
ecb.Playback(EntityManager);
ecb.Dispose();
}
if (m_PendingRequestsQuery.CalculateLength() > 0)
{
var ecb = new EntityCommandBuffer(Allocator.Temp);
var pendingRequests = m_PendingRequestsQuery.ToEntityArray(Allocator.Temp);
Entity requestEntity = pendingRequests[0];
SceneData sceneData = EntityManager.GetComponentData <SceneData>(requestEntity);
SceneLoadRequest request = EntityManager.GetComponentData <SceneLoadRequest>(requestEntity);
var opStatus = request.SceneOpHandle.GetStatus();
if (opStatus <= Status.InProgress)
{
ecb.Playback(EntityManager);
ecb.Dispose();
return;
}
if (opStatus == Status.Failure)
{
request.SceneOpHandle.Dispose();
ecb.RemoveComponent <SceneLoadRequest>(requestEntity);
sceneData.Status = SceneStatus.FailedToLoad;
ecb.SetComponent(requestEntity, sceneData);
ecb.Playback(EntityManager);
ecb.Dispose();
m_currentRequestTotal--;
return;
}
Assert.IsTrue(opStatus == Status.Success);
request.SceneOpHandle.GetData(out var data, out var sceneDataSize);
SceneHeader header = *(SceneHeader *)data;
int headerSize = UnsafeUtility.SizeOf <SceneHeader>();
if (header.Version != SceneHeader.CurrentVersion)
{
throw new Exception($"Scene serialization version mismatch. Reading version '{header.Version}', expected '{SceneHeader.CurrentVersion}'");
}
byte *decompressedScene = data + headerSize;
if (header.Codec != Codec.Codec.None)
{
decompressedScene = (byte *)UnsafeUtility.Malloc(header.DecompressedSize, 16, Allocator.Temp);
if (!CodecService.Decompress(header.Codec, data + headerSize, sceneDataSize - headerSize, decompressedScene, header.DecompressedSize))
{
throw new Exception($"Failed to decompress compressed scene using codec '{header.Codec}'");
}
}
using (var sceneReader = new MemoryBinaryReader(decompressedScene))
{
var loadingEM = m_LoadingWorld.EntityManager;
var transaction = loadingEM.BeginExclusiveEntityTransaction();
if (header.SharedComponentCount > 0)
{
int numSharedComponentsLoaded = SerializeUtility.DeserializeSharedComponents(loadingEM, sceneReader);
// Chunks have now taken over ownership of the shared components (reference counts have been added)
// so remove the ref that was added on deserialization
for (int i = 0; i < numSharedComponentsLoaded; ++i)
{
transaction.ManagedComponentStore.RemoveReference(i + 1);
}
Assert.IsTrue(numSharedComponentsLoaded == header.SharedComponentCount,
$"Number of loaded SharedComponents for '{sceneData.Scene.SceneGuid.Guid}' loaded ({numSharedComponentsLoaded }) does not match what we expect ({header.SharedComponentCount})");
}
SerializeUtility.DeserializeWorld(transaction, sceneReader, header.SharedComponentCount);
loadingEM.EndExclusiveEntityTransaction();
}
var scene = sceneData.Scene;
World.Active.EntityManager.MoveEntitiesFrom(out var movedEntities, m_LoadingWorld.EntityManager);
foreach (var e in movedEntities)
{
World.Active.EntityManager.AddSharedComponentData(e, scene.SceneGuid);
World.Active.EntityManager.AddSharedComponentData(e, scene.SceneInstanceId);
}
// Fixup Entity references now that the entities have moved
EntityManager.World.GetOrCreateSystem <EntityReferenceRemapSystem>().Update();
EntityManager.World.GetOrCreateSystem <RemoveRemapInformationSystem>().Update();
if (header.Codec != Codec.Codec.None)
{
UnsafeUtility.Free(decompressedScene, Allocator.Temp);
}
sceneData.Status = SceneStatus.Loaded;
ecb.SetComponent(requestEntity, sceneData);
ecb.AddSharedComponent(requestEntity, scene.SceneGuid);
ecb.AddSharedComponent(requestEntity, scene.SceneInstanceId);
request.SceneOpHandle.Dispose();
ecb.RemoveComponent <SceneLoadRequest>(requestEntity);
ecb.Playback(EntityManager);
ecb.Dispose();
m_LoadingWorld.EntityManager.PrepareForDeserialize();
movedEntities.Dispose();
pendingRequests.Dispose();
m_currentRequestTotal--;
}
}
