protected virtual void OnDragEnter(PointerEventData pointerEventData)
{
if (m_prefabInstance != null)
{
return;
}
if (Editor.DragDrop.DragObjects[0] is AssetItem)
{
AssetItem assetItem = (AssetItem)Editor.DragDrop.DragObjects[0];
if (m_project.ToType(assetItem) == typeof(GameObject))
{
Editor.DragDrop.SetCursor(KnownCursor.DropAllowed);
Editor.IsBusy = true;
m_project.Load(new[] { assetItem }, (error, obj) =>
{
Editor.IsBusy = false;
OnAssetItemLoaded(error, obj);
});
m_dragItem = null;
}
else if (m_project.ToType(assetItem) == typeof(Material))
{
m_dragItem = assetItem;
}
}
}
private void OnProjectResourcesDoubleClick(object sender, ProjectTreeEventArgs e)
{
if (e.ProjectItem == null)
{
return;
}
if (e.ProjectItem.IsFolder)
{
m_projectTree.SelectedFolder = e.ProjectItem;
}
else
{
if (m_project.IsScene(e.ProjectItem))
{
Editor.IsPlaying = false;
Editor.IsBusy = true;
m_project.Load(new[] { (AssetItem)e.ProjectItem }, (error, obj) =>
{
Editor.IsBusy = false;
if (error.HasError)
{
m_windowManager.MessageBox("Unable to load scene " + e.ProjectItem.ToString(), error.ToString());
}
});
}
}
}
private void OnProjectFolderItemDoubleClick(object sender, ProjectTreeEventArgs e)
{
if (e.ProjectItem == null)
{
return;
}
if (e.ProjectItem.IsFolder)
{
m_projectTree.SelectedItem = e.ProjectItem;
}
else
{
if (m_project.IsScene(e.ProjectItem))
{
Editor.IsPlaying = false;
Editor.IsBusy = true;
m_project.Load(new[] { (AssetItem)e.ProjectItem }, (error, obj) =>
{
Editor.IsBusy = false;
if (error.HasError)
{
m_windowManager.MessageBox(m_localization.GetString("ID_RTEditor_ProjectView_UnableToLoadScene", "Unable to load scene") + " " + e.ProjectItem.ToString(), error.ToString());
}
});
}
}
}
private void HandleSelectionChanged(AssetItem assetItem)
{
if (assetItem != null && assetItem.TypeGuid == m_noneGuid)
{
IsNoneSelected = true;
SelectedObject = null;
}
else
{
IsNoneSelected = false;
if (assetItem != null)
{
if (m_sceneObjects.ContainsKey(assetItem.ItemID))
{
SelectedObject = m_sceneObjects[assetItem.ItemID];
}
else
{
SelectedObject = null;
m_project.Load(new[] { assetItem }, (error, obj) =>
{
SelectedObject = obj[0];
});
}
}
else
{
SelectedObject = null;
}
}
m_parentDialog.IsOkInteractable = m_treeView.SelectedItem != null;
}
private IEnumerator CoLoadScript(AssetItem assetItem, ProjectAsyncOperation <RuntimeTextAsset> ao)
{
ProjectAsyncOperation <UnityObject[]> loadAo = m_project.Load(new[] { assetItem });
yield return(loadAo);
ao.Error = loadAo.Error;
if (!ao.HasError)
{
ao.Result = (RuntimeTextAsset)loadAo.Result[0];
}
ao.IsCompleted = true;
}
public void Load(object dragObject, Type memberInfoType, Action <UnityObject> callback)
{
if (dragObject is AssetItem)
{
AssetItem assetItem = (AssetItem)dragObject;
IProject project = IOC.Resolve <IProject>();
project.Load(new[] { assetItem }, (error, loadedObjects) =>
{
if (error.HasError)
{
IWindowManager wnd = IOC.Resolve <IWindowManager>();
wnd.MessageBox("Unable to load object", error.ErrorText);
return;
}
callback(loadedObjects[0]);
});
}
else if (dragObject is GameObject)
{
UnityObject value = GetGameObjectOrComponent((GameObject)dragObject, memberInfoType);
callback(value);
}
else if (dragObject is ExposeToEditor)
{
UnityObject value = GetGameObjectOrComponent(((ExposeToEditor)dragObject).gameObject, memberInfoType);
callback(value);
}
}
IEnumerator LoadScene()
{
if (m_progressText != null)
{
m_progressText.text = "Loading ...";
}
yield return(FadeInProgress());
ProjectAsyncOperation ao = m_project.Load <Scene>(m_scenePath);
yield return(ao);
yield return(FadeOutProgress());
if (m_progress != null)
{
m_progress.gameObject.SetActive(false);
}
if (ao.Error.HasError)
{
Debug.LogError(ao.Error.ToString());
}
}
public override void Drop(object[] dragObjects, PointerEventData pointerEventData)
{
base.Drop(dragObjects, pointerEventData);
m_isSpawningPrefab = true;
if (CanDrop(dragObjects))
{
for (int i = 0; i < dragObjects.Length; ++i)
{
object dragObject = dragObjects[i];
AssetItem assetItem = dragObject as AssetItem;
if (assetItem != null)
{
m_project.Load(assetItem, (error, obj) =>
{
if (obj is GameObject)
{
GameObject prefab = (GameObject)obj;
bool wasPrefabEnabled = prefab.activeSelf;
prefab.SetActive(false);
GameObject prefabInstance = Instantiate(prefab, Vector3.zero, Quaternion.identity, ((GameObject)m_treeView.DropTarget).transform);
prefab.SetActive(wasPrefabEnabled);
ExposeToEditor exposeToEditor = prefabInstance.GetComponent <ExposeToEditor>();
if (exposeToEditor == null)
{
exposeToEditor = prefabInstance.AddComponent <ExposeToEditor>();
}
exposeToEditor.SetName(obj.name);
exposeToEditor.Parent = ((GameObject)m_treeView.DropTarget).GetComponent <ExposeToEditor>();
prefabInstance.SetActive(true);
RuntimeUndo.BeginRecord();
RuntimeUndo.RecordSelection();
RuntimeUndo.BeginRegisterCreateObject(prefabInstance);
RuntimeUndo.EndRecord();
bool isEnabled = RuntimeUndo.Enabled;
RuntimeUndo.Enabled = false;
RuntimeSelection.activeGameObject = prefabInstance;
RuntimeUndo.Enabled = isEnabled;
RuntimeUndo.BeginRecord();
RuntimeUndo.RegisterCreatedObject(prefabInstance);
RuntimeUndo.RecordSelection();
RuntimeUndo.EndRecord();
m_isSpawningPrefab = false;
}
});
}
}
m_treeView.ExternalItemDrop();
}
}
private void UpdateDependantAssetPreviews(AssetItem[] assetItems, Action callback)
{
IResourcePreviewUtility previewUtil = IOC.Resolve <IResourcePreviewUtility>();
AssetItem[] dependantItems = m_project.GetDependantAssetItems(assetItems).Where(item => !m_project.IsScene(item)).ToArray();
if (dependantItems.Length > 0)
{
m_project.Load(dependantItems, (loadError, loadedObjects) =>
{
if (loadError.HasError)
{
IsBusy = false;
m_wm.MessageBox("Unable to load assets", loadError.ErrorText);
return;
}
for (int i = 0; i < loadedObjects.Length; ++i)
{
UnityObject loadedObject = loadedObjects[i];
AssetItem dependantItem = dependantItems[i];
if (loadedObject != null)
{
byte[] previewData = previewUtil.CreatePreviewData(loadedObject);
dependantItem.Preview = new Preview {
ItemID = dependantItem.ItemID, PreviewData = previewData
};
}
else
{
dependantItem.Preview = new Preview {
ItemID = dependantItem.ItemID
};
}
}
m_project.SavePreview(dependantItems, (savePreviewError, savedAssetItems) =>
{
if (savePreviewError.HasError)
{
IsBusy = false;
m_wm.MessageBox("Unable to load assets", savePreviewError.ErrorText);
return;
}
callback();
});
});
}
else
{
callback();
}
}
public override void DragEnter(object[] dragObjects, PointerEventData eventData)
{
base.DragEnter(dragObjects, eventData);
if (Editor.DragDrop.DragObjects[0] is AssetItem)
{
AssetItem assetItem = (AssetItem)Editor.DragDrop.DragObjects[0];
if (m_project.ToType(assetItem) == typeof(GameObject))
{
Editor.DragDrop.SetCursor(KnownCursor.DropAllowed);
Editor.IsBusy = true;
m_project.Load(assetItem, (error, obj) =>
{
Editor.IsBusy = false;
if (IsPointerOver)
{
if (obj is GameObject)
{
IScenePivot scenePivot = IOCContainer.Resolve <IScenePivot>();
Vector3 up = Vector3.up;
if (Mathf.Abs(Vector3.Dot(Camera.transform.up, Vector3.up)) > Mathf.Cos(Mathf.Deg2Rad))
{
up = Vector3.Cross(Camera.transform.right, Vector3.up);
}
else
{
up = Vector3.up;
}
m_dragPlane = new Plane(up, scenePivot.SecondaryPivot.position);
GameObject prefab = (GameObject)obj;
bool wasPrefabEnabled = prefab.activeSelf;
prefab.SetActive(false);
m_prefabInstance = Instantiate(prefab, Vector3.zero, Quaternion.identity);
prefab.SetActive(wasPrefabEnabled);
ExposeToEditor exposeToEditor = m_prefabInstance.GetComponent <ExposeToEditor>();
if (exposeToEditor == null)
{
exposeToEditor = m_prefabInstance.AddComponent <ExposeToEditor>();
}
exposeToEditor.SetName(obj.name);
m_prefabInstance.SetActive(true);
}
}
});
}
}
}
public override void DragEnter(object[] dragObjects, PointerEventData eventData)
{
base.DragEnter(dragObjects, eventData);
if(Editor.DragDrop.DragObjects[0] is AssetItem)
{
AssetItem assetItem = (AssetItem)Editor.DragDrop.DragObjects[0];
if (m_project.ToType(assetItem) == typeof(GameObject))
{
Editor.DragDrop.SetCursor(KnownCursor.DropAllowed);
Editor.IsBusy = true;
m_project.Load(assetItem, (error, obj) =>
{
Editor.IsBusy = false;
if(IsPointerOver)
{
if (obj is GameObject)
{
GameObject prefab = (GameObject)obj;
bool wasPrefabEnabled = prefab.activeSelf;
prefab.SetActive(false);
m_prefabInstance = Instantiate(prefab, Vector3.zero, Quaternion.identity);
prefab.SetActive(wasPrefabEnabled);
ExposeToEditor exposeToEditor = m_prefabInstance.GetComponent<ExposeToEditor>();
if (exposeToEditor == null)
{
exposeToEditor = m_prefabInstance.AddComponent<ExposeToEditor>();
}
exposeToEditor.SetName(obj.name);
m_prefabInstance.SetActive(true);
if(m_dropExecuted)
{
RecordUndo();
m_prefabInstance = null;
m_dropExecuted = true;
}
}
}
});
}
}
}
protected virtual void OnDrop(PointerEventData pointerEventData)
{
if (!IsFilterEmpty)
{
return;
}
object[] dragObjects = Editor.DragDrop.DragObjects;
if (CanDrop(dragObjects))
{
ExposeToEditor dropTarget = (ExposeToEditor)m_treeView.DropTarget;
VirtualizingTreeViewItem treeViewItem = null;
if (dropTarget != null)
{
treeViewItem = m_treeView.GetTreeViewItem(m_treeView.DropTarget);
}
AssetItem[] loadAssetItems = dragObjects.Where(o => o is AssetItem && m_project.ToType((AssetItem)o) == typeof(GameObject)).Select(o => (AssetItem)o).ToArray();
if (loadAssetItems.Length > 0)
{
m_isSpawningPrefab = true;
Editor.IsBusy = true;
m_project.Load(loadAssetItems, (error, objects) =>
{
Editor.IsBusy = false;
if (error.HasError)
{
IWindowManager wm = IOC.Resolve <IWindowManager>();
wm.MessageBox(m_localization.GetString("ID_RTEditor_HierarchyView_UnableToLoadAssetItems", "Unable to load asset items"), error.ErrorText);
return;
}
OnAssetItemsLoaded(objects, dropTarget, treeViewItem);
});
}
else
{
m_treeView.ExternalItemDrop();
}
}
else
{
m_treeView.ExternalItemDrop();
}
}
public static ProjectAsyncOperation <UnityObject[]> Load <T>(this IProject project, string path)
{
if (!project.IsOpened)
{
throw new InvalidOperationException("OpenProject first");
}
path = string.Format("{0}/{1}", project.Root.Name, path);
AssetItem assetItem = project.Root.Get(path + project.GetExt(typeof(T))) as AssetItem;
if (assetItem == null)
{
throw new ArgumentException("not found", "path");
}
return(project.Load(new[] { assetItem }));
}
private static void GenerateProjCode(IProject proj)
{
proj.Load();
if (proj is BEProj)
{
BuildEntityProj bp = new Net.Code.Builder.Build.BEBuild.BuildEntityProj(proj as BEProj);
bp.BuildCode();
bp.BuildMSSQL();
bp.BuildMetaData();
}
else
{
BuildBPProj bp = new BuildBPProj(proj as BPProj);
bp.BuildCode();
bp.BuildMetaData();
}
// compilerCode(proj);
}
private static IEnumerator Load2(AssetItem assetItem, GameObject dummyGo, GameObject dummyChild, IProject project)
{
var loadResult = project.Load(assetItem);
yield return(loadResult);
Assert.IsFalse(loadResult.Error.HasError);
GameObject loadedGo = (GameObject)loadResult.Result;
Assert.AreEqual(dummyGo.name, loadedGo.name);
Assert.AreEqual(dummyGo.transform.position, loadedGo.transform.position);
Assert.AreEqual(1, loadedGo.transform.childCount);
foreach (Transform child in loadedGo.transform)
{
Assert.AreEqual(dummyChild.name, child.gameObject.name);
Assert.AreEqual(dummyChild.transform.position, child.transform.position);
}
}
public void OpenScene()
{
IsBusy = true;
AssetItem assetItem = m_project.Root.Get("Assets/TestScene" + m_project.GetExt(typeof(Scene))) as AssetItem;
if (assetItem != null)
{
m_project.Load(assetItem, (error, scene) =>
{
if (error.HasError)
{
Debug.LogError(error.ToString());
}
Debug.Log("Scene Opened");
IsBusy = false;
});
}
}
private void OnDrop(PointerEventData pointerEventData)
{
object dragObject = Editor.DragDrop.DragObjects[0];
if (dragObject is AssetItem)
{
AssetItem assetItem = (AssetItem)dragObject;
IProject project = IOC.Resolve <IProject>();
Editor.IsBusy = true;
project.Load(new[] { assetItem }, (error, loadedObjects) =>
{
Editor.IsBusy = false;
if (error.HasError)
{
IWindowManager wnd = IOC.Resolve <IWindowManager>();
wnd.MessageBox("Unable to load object", error.ErrorText);
return;
}
SetValue(loadedObjects[0]);
EndEdit();
SetInputField(loadedObjects[0]);
HideDragHighlight();
});
}
else if (dragObject is GameObject)
{
UnityObject value = GetGameObjectOrComponent((GameObject)dragObject);
SetValue(value);
EndEdit();
SetInputField(value);
HideDragHighlight();
}
else if (dragObject is ExposeToEditor)
{
UnityObject value = GetGameObjectOrComponent(((ExposeToEditor)dragObject).gameObject);
SetValue(value);
EndEdit();
SetInputField(value);
HideDragHighlight();
}
}
private static bool Load(AssetItem assetItem, GameObject dummyGo, GameObject dummyChild, IProject project, bool done)
{
project.Load(assetItem, (loadError, obj) =>
{
Assert.IsFalse(loadError.HasError);
GameObject loadedGo = (GameObject)obj;
Assert.AreEqual(dummyGo.name, loadedGo.name);
Assert.AreEqual(dummyGo.transform.position, loadedGo.transform.position);
Assert.AreEqual(1, loadedGo.transform.childCount);
foreach (Transform child in loadedGo.transform)
{
Assert.AreEqual(dummyChild.name, child.gameObject.name);
Assert.AreEqual(dummyChild.transform.position, child.transform.position);
}
done = true;
});
return(done);
}
private void SaveAssetToFolder(ProjectItem folder)
{
Editor.IsBusy = true;
IRuntimeEditor editor = IOC.Resolve <IRuntimeEditor>();
Asset.name = Input.text;
m_project.Save(new[] { folder }, new[] { new byte[0] }, new[] { Asset }, null, SelectSavedAssets, (saveError, saveResult) =>
{
if (saveError.HasError)
{
Editor.IsBusy = false;
m_windowManager.MessageBox(m_localization.GetString("ID_RTEditor_SaveAssetsDialog_UnableToSaveAsset", "Unable to save asset"), saveError.ToString());
RaseSaveCompleted(null);
}
else
{
Editor.IsBusy = true;
m_project.Load(saveResult, (loadError, UnityObject) =>
{
Editor.IsBusy = false;
if (loadError.HasError)
{
m_windowManager.MessageBox(m_localization.GetString("ID_RTEditor_SaveAssetsDialog_UnableToSaveAsset", "Unable to save asset"), loadError.ToString());
RaseSaveCompleted(null);
}
else
{
if (UnityObject.Length > 0)
{
Destroy(Asset);
Asset = UnityObject[0];
}
RaseSaveCompleted(Asset);
}
});
}
});
}
private IEnumerator CoLoad()
{
IProject project = IOC.Resolve <IProject>();
yield return(project.OpenProject("SurvivalGameProject"));
yield return(new WaitUntil(() => project.IsOpened));
IRuntimeScriptManager scriptManager = IOC.Resolve <IRuntimeScriptManager>();
yield return(new WaitUntil(() => scriptManager.IsLoaded));
IRTE editor = IOC.Resolve <IRTE>();
if (project.Exist <Scene>("Game"))
{
editor.IsBusy = true;
yield return(project.Load <Scene>("Game"));
editor.IsBusy = false;
}
}
public static void LoadScene()
{
string path = EditorUtility.OpenFilePanel("Open Scene", Application.persistentDataPath, "rtsc");
if (path.Length != 0)
{
IProject project = Dependencies.Project;
ISerializer serializer = Dependencies.Serializer;
project.Load(new[] { path }, loadDataCompleted =>
{
ProjectItem scene = loadDataCompleted.Data[0];
PersistentScene persistentScene = serializer.Deserialize <PersistentScene>(scene.Internal_Data.RawData);
PersistentScene.InstantiateGameObjects(persistentScene);
project.UnloadData(scene);
ExtraSceneData extraData = Object.FindObjectOfType <ExtraSceneData>();
Object.DestroyImmediate(extraData.gameObject);
});
}
}
private void btnBuild_Click(object sender, EventArgs e)
{
IProject cmd = (IProject)_projects.Where(t => t.CommandID == cboTemplateProjeto.SelectedItem.ToString()).Single();
cmd.Load(projectModel);
if (txtOutputPath.Text == "")
{
MessageBox.Show("Favor informar o path de saida");
txtOutputPath.Focus();
return;
}
try
{
cmd.Build(txtOutputPath.Text);
txtConsole.Text = FormatarConsole(cmd.Mensagens);
}
catch (Exception err)
{
txtConsole.Text = FormatarConsole(cmd.Mensagens);
txtConsole.Text += Environment.NewLine + string.Format("Erro no processamento!Msg: {0}", err.Message);
}
}
public override void Drop(object[] dragObjects, PointerEventData pointerEventData)
{
base.Drop(dragObjects, pointerEventData);
if (CanDrop(dragObjects))
{
ExposeToEditor dropTarget = (ExposeToEditor)m_treeView.DropTarget;
VirtualizingTreeViewItem treeViewItem = null;
if (dropTarget != null)
{
treeViewItem = m_treeView.GetTreeViewItem(m_treeView.DropTarget);
}
AssetItem[] loadAssetItems = dragObjects.Where(o => o is AssetItem && m_project.ToType((AssetItem)o) == typeof(GameObject)).Select(o => (AssetItem)o).ToArray();
if (loadAssetItems.Length > 0)
{
m_isSpawningPrefab = true;
Editor.IsBusy = true;
m_project.Load(loadAssetItems, (error, objects) =>
{
Editor.IsBusy = false;
if (error.HasError)
{
IWindowManager wm = IOC.Resolve <IWindowManager>();
wm.MessageBox("Unable to load asset items.", error.ErrorText);
return;
}
GameObject[] createdObjects = new GameObject[objects.Length];
for (int i = 0; i < objects.Length; ++i)
{
GameObject prefab = (GameObject)objects[i];
bool wasPrefabEnabled = prefab.activeSelf;
prefab.SetActive(false);
GameObject prefabInstance = Instantiate(prefab, Vector3.zero, Quaternion.identity);
prefab.SetActive(wasPrefabEnabled);
ExposeToEditor exposeToEditor = prefabInstance.GetComponent <ExposeToEditor>();
if (exposeToEditor == null)
{
exposeToEditor = prefabInstance.AddComponent <ExposeToEditor>();
}
exposeToEditor.SetName(prefab.name);
if (dropTarget == null)
{
exposeToEditor.transform.SetParent(null);
m_treeView.Add(exposeToEditor);
}
else
{
if (m_treeView.DropAction == ItemDropAction.SetLastChild)
{
exposeToEditor.transform.SetParent(dropTarget.transform);
m_treeView.AddChild(dropTarget, exposeToEditor);
treeViewItem.CanExpand = true;
treeViewItem.IsExpanded = true;
}
else if (m_treeView.DropAction != ItemDropAction.None)
{
int index;
int siblingIndex;
if (m_treeView.DropAction == ItemDropAction.SetNextSibling)
{
index = m_treeView.IndexOf(dropTarget) + 1;
siblingIndex = dropTarget.transform.GetSiblingIndex() + 1;
}
else
{
index = m_treeView.IndexOf(dropTarget);
siblingIndex = dropTarget.transform.GetSiblingIndex();
}
exposeToEditor.transform.SetParent(dropTarget.transform.parent != null ? dropTarget.transform.parent : null);
exposeToEditor.transform.SetSiblingIndex(siblingIndex);
TreeViewItemContainerData newTreeViewItemData = (TreeViewItemContainerData)m_treeView.Insert(index, exposeToEditor);
VirtualizingTreeViewItem newTreeViewItem = m_treeView.GetTreeViewItem(exposeToEditor);
if (newTreeViewItem != null)
{
newTreeViewItem.Parent = treeViewItem.Parent;
}
else
{
newTreeViewItemData.Parent = treeViewItem.Parent;
}
}
}
prefabInstance.SetActive(true);
createdObjects[i] = prefabInstance;
}
if (createdObjects.Length > 0)
{
IRuntimeEditor editor = IOC.Resolve <IRuntimeEditor>();
editor.RegisterCreatedObjects(createdObjects);
}
m_treeView.ExternalItemDrop();
m_isSpawningPrefab = false;
});
}
else
{
m_treeView.ExternalItemDrop();
}
}
else
{
m_treeView.ExternalItemDrop();
}
}
