private void MarkComponentInInspector(SEntityComponentId componentId, bool bMark) { bool bMarkEverything = componentId == SEntityComponentId.Invalid; void Mark(CInspectorSceneComponentViewModel sceneVm) { if (sceneVm.ComponentId == componentId || bMarkEverything) { sceneVm.SetViewModelMarked(bMark); } foreach (var child in sceneVm.Children) { Mark(child); } } if (SceneComponents.Count > 0) { Mark(SceneComponents[0]); } foreach (var entComp in EntityComponents) { if (entComp.ComponentId == componentId || bMarkEverything) { entComp.SetViewModelMarked(bMark); } } }
public static void DetachEntityFromAllParents(SEntityId entityId) { CEngine.Instance.Dispatch(EEngineUpdatePriority.BeginFrame, () => { CEntity target = entityId.GetEntity(); if (target == null || target.RootComponent == null || target.RootComponent.ParentComponent == null) { return; } SEntityComponentId oldRootParent = new SEntityComponentId(target.RootComponent.ParentComponent); void Do() { CWorld world = CEngine.Instance.CurrentWorld; CEntity entity = entityId.GetEntity(); if (entity != null) { entity.Detach(); } } void Undo() { CEngine.Instance.Dispatch(EEngineUpdatePriority.BeginFrame, () => { CWorld world = CEngine.Instance.CurrentWorld; CEntity entity = entityId.GetEntity(); CSceneComponent oldParent = oldRootParent.GetComponent <CSceneComponent>(); if (oldParent == null) { LogUtility.Log("[UndoRedo] The old parent is invalid! Undo stack has been corrupted and cleared."); UndoRedoUtility.Purge(null); return; } if (entity != null) { entity.AttachToComponent(oldParent); } }); } void Redo() { CEngine.Instance.Dispatch(EEngineUpdatePriority.BeginFrame, () => { Do(); }); } Do(); CRelayUndoItem item = new CRelayUndoItem(Undo, Redo); UndoRedoUtility.Record(item); }); }
public static void PickComponent(SEntityComponentId id) { CWorldOutlinerViewModel worldOutliner = CWorkspace.Instance.GetTool <CWorldOutlinerViewModel>(); if (worldOutliner != null) { CEngine.Instance.Dispatch(EEngineUpdatePriority.BeginFrame, () => { worldOutliner.PickingComponentId.GetComponent <CScenePickingComponent>()?.Pick(id.GetComponent <CSceneComponent>()); }); } }
public CInspectorEntityComponentViewModel(IInspectorViewModel viewModel, string name, SEntityComponentId componentId) : base(viewModel, name) { ComponentId = componentId; DeleteComponentCommand = new CRelayCommand(arg => { EditorEntityUtility.DestroyComponent(ComponentId); m_viewModel.QueueEntityInformationUpdate(ComponentId.EntityId, true); }); }
public void AttachComponent(SEntityComponentId child, SEntityComponentId parent) { CEngine.Instance.Dispatch(EEngineUpdatePriority.BeginFrame, () => { CSceneComponent parentObj = parent.GetComponent <CSceneComponent>(); CSceneComponent childObj = child.GetComponent <CSceneComponent>(); if (parentObj != null && childObj != null) { CSceneComponent oldParent = childObj.ParentComponent; SEntityComponentId oldParentid = new SEntityComponentId(oldParent); if (childObj.AttachToComponent(parentObj)) { UpdateEntityInformation_EngineThread(m_selectedObject.GetTargetEntityId(), true); void Undo() { CEngine.Instance.Dispatch(EEngineUpdatePriority.BeginFrame, () => { CSceneComponent oldParentInst = oldParentid.GetComponent <CSceneComponent>(); CSceneComponent childInst = child.GetComponent <CSceneComponent>(); if (oldParentInst != null && childInst != null) { childInst.AttachToComponent(oldParentInst); UpdateEntityInformation_EngineThread(child.EntityId, true); } }); } void Redo() { CEngine.Instance.Dispatch(EEngineUpdatePriority.BeginFrame, () => { CSceneComponent newParentInst = parent.GetComponent <CSceneComponent>(); CSceneComponent childInst = child.GetComponent <CSceneComponent>(); if (newParentInst != null && childInst != null) { childInst.AttachToComponent(newParentInst); UpdateEntityInformation_EngineThread(child.EntityId, true); } }); } CRelayUndoItem item = new CRelayUndoItem(Undo, Redo); UndoRedoUtility.Record(item); } } }); }
public CInspectorSceneComponentViewModel(IInspectorViewModel viewModel, string name, SEntityComponentId componentId, string dragIdentifier) : base(viewModel, name) { ComponentId = componentId; MakeRootCommand = new CRelayCommand(OnMakeRoot); DeleteComponentCommand = new CRelayCommand(OnDeleteComponent); DragEnterCommand = new CRelayCommand(OnDragEnter); DragOverCommand = new CRelayCommand(OnDragOver); DropCommand = new CRelayCommand(OnDrop); m_dragIdentifier = dragIdentifier; }
private void InspectComponent(SEntityComponentId componentId) { bool bUpdateInspectorObjectList = ShouldUpdateInspectorList(componentId); CEngine engine = CEngine.Instance; CWorldOutlinerViewModel worldOutliner = CWorkspace.Instance.GetTool <CWorldOutlinerViewModel>(); engine.Dispatch(EEngineUpdatePriority.BeginFrame, () => { CUpdateScheduler scheduler = engine.CurrentWorld.UpdateScheduler; if (m_updateScope != null && m_updateScope.IsConnected()) { scheduler.Disconnect(m_updateScope); } CEntityComponent component = componentId.GetComponent(); if (component != null) { m_selectedObject = new CEditableObject(componentId); m_updateScope = scheduler.Connect(UpdateCallback, EUpdatePriority.ResourceLoading); if (bUpdateInspectorObjectList) { UpdateEntityInformation_EngineThread(new SEntityId(component.Owner.Id)); } worldOutliner.PickingComponentId.GetComponent <CScenePickingComponent>().Pick(component as CSceneComponent); Application.Current.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal, (Action)(() => { m_desiredTarget = new CEditableObject(componentId); UnmarkEverything(); MarkComponentInInspector(componentId, true); })); } else { Application.Current.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal, (Action)(() => { m_desiredTarget = null; UnmarkEverything(); })); } }); }
public static void DestroyComponent(SEntityComponentId id) { if (id.OverrideComponent == null) { CEngine.Instance.Dispatch(EEngineUpdatePriority.BeginFrame, () => { CEntityComponent component = id.GetComponent <CEntityComponent>(); if (component != null) { component.Destroy(); } }); } else { CEntityComponent component = id.GetComponent <CEntityComponent>(); if (component != null) { component.Destroy(); } } UndoRedoUtility.Purge(null); }
private bool ShouldUpdateInspectorList(SEntityComponentId inspectedComponent) { if (m_desiredTarget == null) { return(true); } if (inspectedComponent == m_desiredTarget.ComponentId) { return(true); } if (m_desiredTarget.EntityId == inspectedComponent.EntityId) { return(false); } if (m_desiredTarget.ComponentId.EntityId == inspectedComponent.EntityId) { return(false); } return(true); }
public override void PostWorldLoad() { base.PostWorldLoad(); CEngine.Instance.Dispatch(EEngineUpdatePriority.BeginFrame, () => { Action <CEntity> callback = (entity) => { CHierarchyEntry root = EditorHelpers.FillLevelHierarchy(); Application.Current.Dispatcher.Invoke(() => { UpdateOutliner(root); }); }; Action <CAssetReference <CLevelAsset>, CLevel> levelChanged = (levelAsset, level) => { CHierarchyEntry root = EditorHelpers.FillLevelHierarchy(); SEntityComponentId newPickerId = SpawnScenePicker_EngineThread(CEngine.Instance.CurrentWorld); CWorkspace.Instance.PostLevelLoad(levelAsset); Application.Current.Dispatcher.Invoke(() => { PickingComponentId = newPickerId; UpdateOutliner(root); }); }; CWorld currentWorld = CEngine.Instance.CurrentWorld; currentWorld.OnEntitySpawned += callback; currentWorld.OnEntityDestroyed += callback; currentWorld.OnEntityRevived += callback; currentWorld.OnLevelChanged += levelChanged; currentWorld.OnHierarchyChanged += (child, oldParent, newParent) => { if (child == child.Owner?.RootComponent) { callback(null); } }; SEntityComponentId pickerId = SpawnScenePicker_EngineThread(currentWorld); Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (Action)(() => { PickingComponentId = pickerId; })); CScenePickingComponent.OnComponentPicked += (component) => { if (component == null) { Application.Current.Dispatcher.Invoke(() => { CWorkspace.Instance.SetSelectedObject(null); }); } else { CEntity entity = component.Owner; CEditableObject editObj = null; if (entity.RootComponent == null) { editObj = new CEditableObject(new SEntityId(entity.Id)); } else { editObj = new CEditableObject(new SEntityComponentId(entity.RootComponent)); } Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (Action)(() => { CWorkspace.Instance.SetSelectedObject(editObj); })); } }; callback(null); }); }
public static void MakeComponentRoot(SEntityComponentId id, bool bDispatch = true) { void Command() { CSceneComponent newRoot = id.GetComponent <CSceneComponent>(); if (newRoot == null) { return; } CSceneComponent oldRoot = newRoot.Owner.RootComponent; if (oldRoot == null) { return; } SEntityComponentId oldId = new SEntityComponentId(oldRoot); void Do() { CSceneComponent component = id.GetComponent <CSceneComponent>(); if (component != null) { CEntity owner = component.Owner; owner.SetRootComponent(component); } } void Redo() { CEngine.Instance.Dispatch(EEngineUpdatePriority.BeginFrame, () => { Do(); Application.Current.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal, (Action)(() => { CWorkspace space = CWorkspace.Instance; space.SetSelectedObject(space.SelectedEditableObject, true); })); }); } void Undo() { CEngine.Instance.Dispatch(EEngineUpdatePriority.BeginFrame, () => { CSceneComponent component = oldId.GetComponent <CSceneComponent>(); if (component != null) { CEntity owner = component.Owner; owner.SetRootComponent(component); Application.Current.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal, (Action)(() => { CWorkspace space = CWorkspace.Instance; space.SetSelectedObject(space.SelectedEditableObject, true); })); } }); } Do(); CUndoItem item = new CRelayUndoItem(Undo, Redo); UndoRedoUtility.Record(item); } if (bDispatch) { CEngine.Instance.Dispatch(EEngineUpdatePriority.BeginFrame, () => { Command(); }); } else { Command(); } }
public CEditableObject(SEntityComponentId componentId) { m_componentId = componentId; Type = EObjectType.Component; }
private void UpdateEntityInformation_EngineThread(SEntityId entityId, bool bReselectTarget = false) { void CreateViewModel(CSceneComponent component, CInspectorSceneComponentViewModel parent, CEntity owner) { if (component.Owner != owner || !component.ShowInInspector || component.MarkedForDestruction) { return; } SEntityComponentId id = new SEntityComponentId(component, false); CInspectorSceneComponentViewModel vm = new CInspectorSceneComponentViewModel(this, component.Name, id, "sceneComponent"); parent.Children.Add(vm); foreach (var child in component.Children) { CreateViewModel(child, vm, owner); } } CEntity entity = entityId.GetEntity(); if (entity != null) { CInspectorEntityViewModel entityInfo = null; CInspectorSceneComponentViewModel sceneComponentsInfo = null; List <CInspectorEntityComponentViewModel> entityComponentsInfo = null; sceneComponentsInfo = null; if (entity.RootComponent != null) { sceneComponentsInfo = new CInspectorSceneComponentViewModel(this, entity.RootComponent.Name, new SEntityComponentId(entity.RootComponent, false), "sceneComponent"); foreach (var child in entity.RootComponent.Children) { CreateViewModel(child, sceneComponentsInfo, entity); } } List <CEntityComponent> components = new List <CEntityComponent>(8); entityComponentsInfo = new List <CInspectorEntityComponentViewModel>(4); entity.GetComponents(components); for (int i = components.Count - 1; i >= 0; i--) { if (!(components[i] is CSceneComponent) && components[i].ShowInInspector && !components[i].MarkedForDestruction) { entityComponentsInfo.Add(new CInspectorEntityComponentViewModel(this, components[i].Name, new SEntityComponentId(components[i], false))); } } entityInfo = new CInspectorEntityViewModel(this, entity.Name, new SEntityId(entity.Id)); string entityName = entity.Name; Application.Current.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal, (Action)(() => { m_view?.LockInspector(false); UpdateEntityInformation_EditorThread(sceneComponentsInfo, entityComponentsInfo, entityInfo); m_entityName = entityName; RaisePropertyChanged(nameof(EntityName)); m_view.SetEntityName(entityName); if (bReselectTarget) { CWorkspace.Instance.SetSelectedObject(m_selectedObject, true); } })); } else { //Clear component list when selecting invalid entity Application.Current.Dispatcher.BeginInvoke((Action)(() => { UpdateEntityInformation_EditorThread(null, null, null); })); } }