private static IEnumerator CoLoadLayer(Action <LayersInfo> callback)
{
IProject project = IOC.Resolve <IProject>();
if (m_loadedLayers == null || project.ProjectInfo.Name != m_currentProject)
{
m_currentProject = project.ProjectInfo.Name;
ProjectAsyncOperation <RuntimeTextAsset> getLayersInfoAo = project.GetValue <RuntimeTextAsset>("Battlehub.RTEditor.LayersInfo");
yield return(getLayersInfoAo);
if (getLayersInfoAo.HasError)
{
if (getLayersInfoAo.Error.ErrorCode != Error.E_NotFound)
{
Debug.LogErrorFormat("Unable to load LayersInfo {0}", getLayersInfoAo.Error);
yield break;
}
m_loadedLayers = ScriptableObject.CreateInstance <LayersInfo>();
m_loadedLayers.Layers = new List <LayersInfo.Layer>
{
new LayersInfo.Layer("Default", 0),
new LayersInfo.Layer("Transparent FX", 1),
new LayersInfo.Layer("Ignore Raycast", 2),
new LayersInfo.Layer("Water", 4),
new LayersInfo.Layer("UI", 5)
};
for (int i = 10; i <= 15; ++i)
{
m_loadedLayers.Layers.Add(new LayersInfo.Layer(LayerMask.LayerToName(i), i));
}
for (int i = 25; i <= 30; ++i)
{
m_loadedLayers.Layers.Add(new LayersInfo.Layer(LayerMask.LayerToName(i), i));
}
RuntimeTextAsset layersTextAsset = ScriptableObject.CreateInstance <RuntimeTextAsset>();
layersTextAsset.Text = JsonUtility.ToJson(m_loadedLayers);
ProjectAsyncOperation setLayersInfoAo = project.SetValue("Battlehub.RTEditor.LayersInfo", layersTextAsset);
yield return(setLayersInfoAo);
if (setLayersInfoAo.HasError)
{
Debug.LogErrorFormat("Unable to set LayersInfo {0}", setLayersInfoAo.Error);
yield break;
}
}
else
{
m_loadedLayers = ScriptableObject.CreateInstance <LayersInfo>();
JsonUtility.FromJsonOverwrite(getLayersInfoAo.Result.Text, m_loadedLayers);
foreach (LayersInfo.Layer layer in m_loadedLayers.Layers)
{
if (string.IsNullOrEmpty(layer.Name))
{
layer.Name = LayerMask.LayerToName(layer.Index);
}
}
}
}
callback(m_loadedLayers);
}
public ProjectAsyncOperation <ProjectItem[]> DeleteAssets(ProjectItem[] projectItems, Action <ProjectItem[]> done)
{
ProjectAsyncOperation <ProjectItem[]> ao = new ProjectAsyncOperation <ProjectItem[]> ();
IProject project = IOC.Resolve <IProject>();
AssetItem[] assetItems = projectItems.OfType <AssetItem>().ToArray();
for (int i = 0; i < assetItems.Length; ++i)
{
AssetItem assetItem = assetItems[i];
UnityObject obj = m_project.FromID <UnityObject>(assetItem.ItemID);
if (obj != null)
{
if (obj is GameObject)
{
GameObject go = (GameObject)obj;
Component[] components = go.GetComponentsInChildren <Component>(true);
for (int j = 0; j < components.Length; ++j)
{
Component component = components[j];
Undo.Erase(component, null);
if (component is Transform)
{
Undo.Erase(component.gameObject, null);
}
}
}
else
{
Undo.Erase(obj, null);
}
}
}
ProjectItem[] folders = projectItems.Where(pi => pi.IsFolder).ToArray();
m_project.Delete(assetItems.Union(folders).ToArray(), (deleteError, deletedItems) =>
{
IsBusy = false;
if (deleteError.HasError)
{
m_wm.MessageBox("Unable to delete folders", deleteError.ErrorText);
if (done != null)
{
done(null);
}
ao.Error = deleteError;
ao.IsCompleted = true;
return;
}
StartCoroutine(CoUpdateDependantAssetPreview(assetItems, () =>
{
if (done != null)
{
done(projectItems);
}
ao.Error = new Error();
ao.Result = projectItems;
ao.IsCompleted = true;
}));
});
return(ao);
}
private IEnumerator Start()
{
yield return(new WaitUntil(() => m_project.IsOpened));
yield return(new WaitWhile(() => m_editor.IsBusy));
if (Loading != null)
{
Loading();
}
ProjectAsyncOperation <RuntimeBinaryAsset> getAssemblyAo = m_project.GetValue <RuntimeBinaryAsset>(RuntimeAssemblyKey);
yield return(getAssemblyAo);
if (getAssemblyAo.HasError)
{
if (getAssemblyAo.Error.ErrorCode != Error.E_NotFound)
{
Debug.LogError(getAssemblyAo.Error);
}
else
{
m_typeNameToGuid = new Dictionary <string, Guid>();
m_runtimeTypeGuidsAsset = ScriptableObject.CreateInstance <RuntimeTextAsset>();
}
}
else
{
ProjectAsyncOperation <RuntimeTextAsset> getGuidsAo = m_project.GetValue <RuntimeTextAsset>(RuntimeTypeGuids);
yield return(getGuidsAo);
if (getGuidsAo.HasError)
{
Debug.LogError(getGuidsAo.Error);
}
else
{
m_typeNameToGuid = new Dictionary <string, Guid>();
m_runtimeTypeGuidsAsset = getGuidsAo.Result;
string xml = m_runtimeTypeGuidsAsset.Text;
if (!string.IsNullOrEmpty(xml))
{
RuntimeTypeGuids typeGuids = XmlUtility.FromXml <RuntimeTypeGuids>(xml);
foreach (RuntimeTypeGuid typeGuid in typeGuids.Guids)
{
Guid guid;
if (!m_typeNameToGuid.ContainsKey(typeGuid.FullName) && Guid.TryParse(typeGuid.Guid, out guid))
{
m_typeNameToGuid.Add(typeGuid.FullName, guid);
}
}
}
LoadAssembly(getAssemblyAo.Result.Data);
}
}
if (Loaded != null)
{
Loaded();
}
}
private IEnumerator CoCreatePrefab(ProjectItem dropTarget, byte[][] previewData, object[] objects, Action <AssetItem[]> done)
{
if (objects.Any(o => !(o is GameObject)))
{
IsBusy = true;
if (dropTarget.Children == null || dropTarget.Get("DropTarget/Data") == null)
{
ProjectAsyncOperation createFoldersAo = m_project.CreateFolder(dropTarget.Get("DropTarget/Data", true));
yield return(createFoldersAo);
if (createFoldersAo.HasError)
{
m_wm.MessageBox("Unable to create data folder", createFoldersAo.Error.ToString());
IsBusy = false;
if (done != null)
{
done(null);
}
yield break;
}
}
IProjectTree projectTree = IOC.Resolve <IProjectTree>();
if (projectTree != null)
{
projectTree.SelectedItem = dropTarget;
}
}
IsBusy = true;
ProjectItem dataFolder = dropTarget.Get("DropTarget/Data");
List <ProjectItem> parents = new List <ProjectItem>();
for (int i = 0; i < objects.Length; ++i)
{
object obj = objects[i];
if (obj is GameObject)
{
parents.Add(dropTarget);
}
else
{
parents.Add(dataFolder);
}
}
ProjectAsyncOperation <AssetItem[]> saveAo = m_project.Save(parents.ToArray(), previewData, objects, null);
yield return(saveAo);
if (saveAo.HasError)
{
m_wm.MessageBox(m_localization.GetString("ID_RTEditor_UnableToCreatePrefab", "Unable to create prefab"), saveAo.Error.ErrorText);
IsBusy = false;
if (done != null)
{
done(null);
}
yield break;
}
IsBusy = false;
if (done != null)
{
done(saveAo.Result.ToArray());
}
}
public ProjectAsyncOperation <AssetItem[]> SaveAssets(UnityObject[] assets, Action <AssetItem[]> done)
{
ProjectAsyncOperation <AssetItem[]> ao = new ProjectAsyncOperation <AssetItem[]>();
IProject project = IOC.Resolve <IProject>();
List <UnityObject> assetsToSave = new List <UnityObject>();
List <AssetItem> assetItems = new List <AssetItem>();
for (int i = 0; i < assets.Length; ++i)
{
UnityObject asset = assets[i];
AssetItem assetItem = project.ToAssetItem(asset);
if (assetItem == null)
{
continue;
}
assetsToSave.Add(asset);
assetItems.Add(assetItem);
}
if (assetsToSave.Count == 0)
{
if (done != null)
{
done(assetItems.ToArray());
}
ao.Error = Error.NoError;
ao.IsCompleted = true;
return(ao);
}
IsBusy = true;
m_project.Save(assetItems.ToArray(), assets.ToArray(), (saveError, saveResult) =>
{
if (saveError.HasError)
{
IsBusy = false;
m_wm.MessageBox(m_localization.GetString("ID_RTEditor_UnableToSaveAsset", "Unable to save asset"), saveError.ErrorText);
if (done != null)
{
done(null);
}
ao.Error = saveError;
ao.IsCompleted = true;
return;
}
UpdateDependentAssetPreviews(saveResult, () =>
{
IsBusy = false;
if (done != null)
{
done(saveResult);
}
ao.Error = Error.NoError;
ao.Result = saveResult;
ao.IsCompleted = true;
});
});
return(ao);
}
