public void Load(string projectPath, string[] assetPaths, Type[] types, StorageEventHandler <PersistentObject[]> callback)
{
PersistentObject[] result = new PersistentObject[assetPaths.Length];
for (int i = 0; i < assetPaths.Length; ++i)
{
string assetPath = assetPaths[i];
assetPath = FullPath(projectPath) + assetPath;
ISerializer serializer = IOC.Resolve <ISerializer>();
try
{
if (File.Exists(assetPath))
{
using (FileStream fs = File.OpenRead(assetPath))
{
result[i] = (PersistentObject)serializer.Deserialize(fs, types[i]);
}
}
else
{
callback(new Error(Error.E_NotFound), new PersistentObject[0]);
return;
}
}
catch (Exception e)
{
Debug.LogErrorFormat("Unable to load asset: {0} -> got exception: {1} ", assetPath, e.ToString());
callback(new Error(Error.E_Exception)
{
ErrorText = e.ToString()
}, new PersistentObject[0]);
return;
}
}
callback(new Error(Error.OK), result);
}
protected void RestoreDataAndResolveDependencies()
{
List <GameObject> goList = new List <GameObject>();
List <bool> goActivationList = new List <bool>();
for (int i = 0; i < Data.Length; ++i)
{
PersistentObject data = Data[i];
long id = Identifiers[i];
UnityObject obj = FromID <UnityObject>(id);
if (obj == null)
{
Debug.LogWarningFormat("objects does not have object with instance id {0} however PersistentData of type {1} is present", id, data.GetType());
continue;
}
data.WriteTo(obj);
if (obj is GameObject)
{
goList.Add((GameObject)obj);
PersistentGameObject goData = (PersistentGameObject)data;
goActivationList.Add(goData.ActiveSelf);
}
}
for (int i = 0; i < goList.Count; ++i)
{
bool activeSelf = goActivationList[i];
GameObject go = goList[i];
if (go != null)
{
go.SetActive(activeSelf);
}
}
}
protected override object WriteToImpl(object obj)
{
if (Descriptors == null && Data == null)
{
return(obj);
}
if (Descriptors == null && Data != null || Data != null && Descriptors == null)
{
throw new ArgumentException("data is corrupted", "scene");
}
if (Descriptors.Length == 0)
{
return(obj);
}
if (Identifiers == null || Identifiers.Length != Data.Length)
{
throw new ArgumentException("data is corrupted", "scene");
}
Scene scene = (Scene)obj;
GameObject[] rootGameObjects = scene.GetRootGameObjects();
for (int i = 0; i < rootGameObjects.Length; ++i)
{
GameObject rootGO = rootGameObjects[i];
if (rootGO.GetComponent <RTSLIgnore>())
{
continue;
}
UnityObject.DestroyImmediate(rootGO);
}
Dictionary <int, UnityObject> idToUnityObj = new Dictionary <int, UnityObject>();
for (int i = 0; i < Descriptors.Length; ++i)
{
PersistentDescriptor descriptor = Descriptors[i];
if (descriptor != null)
{
CreateGameObjectWithComponents(m_typeMap, descriptor, idToUnityObj, null);
}
}
UnityObject[] assetInstances = null;
if (AssetIdentifiers != null)
{
IUnityObjectFactory factory = IOC.Resolve <IUnityObjectFactory>();
assetInstances = new UnityObject[AssetIdentifiers.Length];
for (int i = 0; i < AssetIdentifiers.Length; ++i)
{
PersistentObject asset = Assets[i];
Type uoType = m_typeMap.ToUnityType(asset.GetType());
if (uoType != null)
{
if (factory.CanCreateInstance(uoType, asset))
{
UnityObject assetInstance = factory.CreateInstance(uoType, asset);
if (assetInstance != null)
{
assetInstances[i] = assetInstance;
idToUnityObj.Add(AssetIdentifiers[i], assetInstance);
}
}
else
{
Debug.LogWarning("Unable to create object of type " + uoType.ToString());
}
}
else
{
Debug.LogWarning("Unable to resolve unity type for " + asset.GetType().FullName);
}
}
}
m_assetDB.RegisterSceneObjects(idToUnityObj);
if (assetInstances != null)
{
for (int i = 0; i < AssetIdentifiers.Length; ++i)
{
UnityObject assetInstance = assetInstances[i];
if (assetInstance != null)
{
PersistentObject asset = Assets[i];
asset.WriteTo(assetInstance);
}
}
}
RestoreDataAndResolveDependencies();
m_assetDB.UnregisterSceneObjects();
return(scene);
}
protected override void ReadFromImpl(object obj)
{
Scene scene = (Scene)obj;
GameObject[] rootGameObjects = scene.GetRootGameObjects();
List <PersistentObject> data = new List <PersistentObject>();
List <long> identifiers = new List <long>();
List <PersistentDescriptor> descriptors = new List <PersistentDescriptor>(rootGameObjects.Length);
GetDepsFromContext getSceneDepsCtx = new GetDepsFromContext();
for (int i = 0; i < rootGameObjects.Length; ++i)
{
GameObject rootGO = rootGameObjects[i];
PersistentDescriptor descriptor = CreateDescriptorAndData(rootGO, data, identifiers, getSceneDepsCtx);
if (descriptor != null)
{
descriptors.Add(descriptor);
}
}
HashSet <object> allDeps = getSceneDepsCtx.Dependencies;
List <UnityObject> externalDeps = new List <UnityObject>(allDeps.OfType <UnityObject>());
Queue <UnityObject> depsQueue = new Queue <UnityObject>(allDeps.OfType <UnityObject>());
List <PersistentObject> assets = new List <PersistentObject>();
List <int> assetIdentifiers = new List <int>();
GetDepsFromContext getDepsCtx = new GetDepsFromContext();
while (depsQueue.Count > 0)
{
UnityObject uo = depsQueue.Dequeue();
if (!uo)
{
continue;
}
if (!m_assetDB.IsMapped(uo))
{
if (!(uo is GameObject) && !(uo is Component))
{
Type persistentType = m_typeMap.ToPersistentType(uo.GetType());
if (persistentType != null)
{
getDepsCtx.Clear();
PersistentObject persistentObject = (PersistentObject)Activator.CreateInstance(persistentType);
persistentObject.ReadFrom(uo);
persistentObject.GetDepsFrom(uo, getDepsCtx);
assets.Add(persistentObject);
assetIdentifiers.Add(uo.GetInstanceID());
foreach (UnityObject dep in getDepsCtx.Dependencies)
{
if (!allDeps.Contains(dep))
{
allDeps.Add(dep);
depsQueue.Enqueue(dep);
}
}
}
}
externalDeps.Remove(uo);
}
}
Descriptors = descriptors.ToArray();
Identifiers = identifiers.ToArray();
Data = data.ToArray();
Dependencies = externalDeps.Select(uo => m_assetDB.ToID(uo)).ToArray();
Assets = assets.ToArray();
AssetIdentifiers = assetIdentifiers.ToArray();
}
public void Save(string projectPath, string[] folderPaths, AssetItem[] assetItems, PersistentObject[] persistentObjects, ProjectInfo projectInfo, bool previewOnly, StorageEventHandler callback)
{
QueueUserWorkItem(() =>
{
if (!previewOnly)
{
if (assetItems.Length != persistentObjects.Length)
{
throw new ArgumentException("assetItems");
}
}
if (assetItems.Length > folderPaths.Length)
{
int l = folderPaths.Length;
Array.Resize(ref folderPaths, assetItems.Length);
for (int i = l; i < folderPaths.Length; ++i)
{
folderPaths[i] = folderPaths[l - 1];
}
}
projectPath = FullPath(projectPath);
if (!Directory.Exists(projectPath))
{
Directory.CreateDirectory(projectPath);
}
string projectInfoPath = projectPath + "/Project.rtmeta";
ISerializer serializer = IOC.Resolve <ISerializer>();
Error error = new Error(Error.OK);
for (int i = 0; i < assetItems.Length; ++i)
{
string folderPath = folderPaths[i];
AssetItem assetItem = assetItems[i];
try
{
string path = projectPath + folderPath;
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
string previewPath = path + "/" + assetItem.NameExt + PreviewExt;
if (assetItem.Preview == null)
{
File.Delete(previewPath);
}
else
{
File.Delete(previewPath);
using (FileStream fs = File.Create(previewPath))
{
serializer.Serialize(assetItem.Preview, fs);
}
}
if (!previewOnly)
{
PersistentObject persistentObject = persistentObjects[i];
File.Delete(path + "/" + assetItem.NameExt + MetaExt);
using (FileStream fs = File.Create(path + "/" + assetItem.NameExt + MetaExt))
{
serializer.Serialize(assetItem, fs);
}
File.Delete(path + "/" + assetItem.NameExt);
if (persistentObject is PersistentRuntimeTextAsset)
{
PersistentRuntimeTextAsset textAsset = (PersistentRuntimeTextAsset)persistentObject;
File.WriteAllText(path + "/" + assetItem.NameExt, textAsset.Text);
}
else if (persistentObject is PersistentRuntimeBinaryAsset)
{
PersistentRuntimeBinaryAsset binAsset = (PersistentRuntimeBinaryAsset)persistentObject;
File.WriteAllBytes(path + "/" + assetItem.NameExt, binAsset.Data);
}
else
{
using (FileStream fs = File.Create(path + "/" + assetItem.NameExt))
{
serializer.Serialize(persistentObject, fs);
}
}
}
}
catch (Exception e)
{
Debug.LogErrorFormat("Unable to create asset: {0} -> got exception: {1} ", assetItem.NameExt, e.ToString());
error.ErrorCode = Error.E_Exception;
error.ErrorText = e.ToString();
break;
}
}
File.Delete(projectInfoPath);
using (FileStream fs = File.Create(projectInfoPath))
{
serializer.Serialize(projectInfo, fs);
}
Callback(() => callback(error));
});
}
public void Load(string projectPath, AssetItem[] assetItems, Type[] types, StorageEventHandler <PersistentObject <TID>[]> callback)
{
string[] assetPaths = assetItems.Select(item => item.ToString()).ToArray();
long[] customDataOffsets = assetItems.Select(item => item.CustomDataOffset).ToArray();
QueueUserWorkItem(() =>
{
PersistentObject <TID>[] result = new PersistentObject <TID> [assetPaths.Length];
for (int i = 0; i < assetPaths.Length; ++i)
{
string assetPath = assetPaths[i];
assetPath = FullPath(projectPath) + assetPath;
ISerializer serializer = IOC.Resolve <ISerializer>();
try
{
if (File.Exists(assetPath))
{
if (types[i] == typeof(PersistentRuntimeTextAsset <TID>))
{
PersistentRuntimeTextAsset <TID> textAsset = new PersistentRuntimeTextAsset <TID>();
textAsset.name = Path.GetFileName(assetPath);
textAsset.Text = File.ReadAllText(assetPath);
textAsset.Ext = Path.GetExtension(assetPath);
result[i] = textAsset;
}
else if (types[i] == typeof(PersistentRuntimeBinaryAsset <TID>))
{
PersistentRuntimeBinaryAsset <TID> binAsset = new PersistentRuntimeBinaryAsset <TID>();
binAsset.name = Path.GetFileName(assetPath);
binAsset.Data = File.ReadAllBytes(assetPath);
binAsset.Ext = Path.GetExtension(assetPath);
result[i] = binAsset;
}
else
{
using (FileStream fs = File.OpenRead(assetPath))
{
long customDataOffset = customDataOffsets[i];
if (customDataOffset == -1)
{
result[i] = (PersistentObject <TID>)serializer.Deserialize(fs, types[i]);
}
else
{
if (customDataOffset > 0)
{
result[i] = (PersistentObject <TID>)serializer.Deserialize(fs, types[i], customDataOffset);
}
else
{
result[i] = (PersistentObject <TID>)Activator.CreateInstance(types[i]);
}
if (fs.Position < fs.Length)
{
using (BinaryReader reader = new BinaryReader(fs))
{
CustomSerializationHeader header = reader.ReadHeader();
if (header.IsValid)
{
ICustomSerialization customSerialization = (ICustomSerialization)result[i];
customSerialization.Deserialize(fs, reader);
}
}
}
}
}
}
}
else
{
Callback(() => callback(new Error(Error.E_NotFound), new PersistentObject <TID> [0]));
return;
}
}
catch (Exception e)
{
Debug.LogErrorFormat("Unable to load asset: {0} -> got exception: {1} ", assetPath, e.ToString());
Callback(() => callback(new Error(Error.E_Exception)
{
ErrorText = e.ToString()
}, new PersistentObject <TID> [0]));
return;
}
}
Callback(() => callback(new Error(Error.OK), result));
});
}
protected PersistentDescriptor CreateDescriptorAndData(GameObject go, List <PersistentObject> persistentData, List <long> persistentIdentifiers, /*HashSet<int> usings,*/ GetDepsFromContext getDepsFromCtx, PersistentDescriptor parentDescriptor = null)
{
if (go.GetComponent <RTSLIgnore>())
{
//Do not save persistent ignore objects
return(null);
}
Type persistentType = m_typeMap.ToPersistentType(go.GetType());
if (persistentType == null)
{
return(null);
}
long persistentID = ToID(go);
//if(m_assetDB.IsResourceID(persistentID))
//{
// int ordinal = m_assetDB.ToOrdinal(persistentID);
// usings.Add(ordinal);
//}
PersistentDescriptor descriptor = new PersistentDescriptor(m_typeMap.ToGuid(persistentType), persistentID, go.name);
descriptor.Parent = parentDescriptor;
PersistentObject goData = (PersistentObject)Activator.CreateInstance(persistentType);
goData.ReadFrom(go);
goData.GetDepsFrom(go, getDepsFromCtx);
persistentData.Add(goData);
persistentIdentifiers.Add(persistentID);
Component[] components = go.GetComponents <Component>().Where(c => c != null).ToArray();
if (components.Length > 0)
{
List <PersistentDescriptor> componentDescriptors = new List <PersistentDescriptor>();
for (int i = 0; i < components.Length; ++i)
{
Component component = components[i];
Type persistentComponentType = m_typeMap.ToPersistentType(component.GetType());
if (persistentComponentType == null)
{
continue;
}
long componentID = ToID(component);
//if (m_assetDB.IsResourceID(componentID))
//{
// int ordinal = m_assetDB.ToOrdinal(componentID);
// usings.Add(ordinal);
//}
PersistentDescriptor componentDescriptor = new PersistentDescriptor(m_typeMap.ToGuid(persistentComponentType), componentID, component.name);
componentDescriptor.Parent = descriptor;
componentDescriptors.Add(componentDescriptor);
PersistentObject componentData = (PersistentObject)Activator.CreateInstance(persistentComponentType);
componentData.ReadFrom(component);
componentData.GetDepsFrom(component, getDepsFromCtx);
persistentData.Add(componentData);
persistentIdentifiers.Add(componentID);
}
if (componentDescriptors.Count > 0)
{
descriptor.Components = componentDescriptors.ToArray();
}
}
Transform transform = go.transform;
if (transform.childCount > 0)
{
List <PersistentDescriptor> children = new List <PersistentDescriptor>();
foreach (Transform child in transform)
{
PersistentDescriptor childDescriptor = CreateDescriptorAndData(child.gameObject, persistentData, persistentIdentifiers, /*usings,*/ getDepsFromCtx, descriptor);
if (childDescriptor != null)
{
children.Add(childDescriptor);
}
}
descriptor.Children = children.ToArray();
}
return(descriptor);
}
