private void ChangeProperty(object prop, Entity selection, object obj, object newval,
ref bool committed, bool shouldUpdateVisual, bool destroyRenderModel, int arrayindex = -1)
{
if (prop == _changingPropery && _lastUncommittedAction != null && ContextActionManager.PeekUndoAction() == _lastUncommittedAction)
{
ContextActionManager.UndoAction();
}
else
{
_lastUncommittedAction = null;
}
if (_changingObject != null && selection != null && selection.WrappedObject != _changingObject)
{
committed = true;
}
else
{
PropertiesChangedAction action;
if (arrayindex != -1)
{
action = new PropertiesChangedAction((PropertyInfo)prop, arrayindex, obj, newval);
}
else
{
action = new PropertiesChangedAction((PropertyInfo)prop, obj, newval);
}
if (shouldUpdateVisual && selection != null)
{
action.SetPostExecutionAction((undo) =>
{
if (destroyRenderModel)
{
if (selection.RenderSceneMesh != null)
{
selection.RenderSceneMesh.Dispose();
selection.RenderSceneMesh = null;
}
}
selection.UpdateRenderModel();
});
}
ContextActionManager.ExecuteAction(action);
_lastUncommittedAction = action;
_changingPropery = prop;
// ChangingObject = selection.MsbObject;
_changingObject = selection != null ? selection.WrappedObject : obj;
}
}
public override void DrawEditorMenu()
{
if (ImGui.BeginMenu("Edit"))
{
if (ImGui.MenuItem("Undo", "CTRL+Z", false, EditorActionManager.CanUndo()))
{
EditorActionManager.UndoAction();
}
if (ImGui.MenuItem("Redo", "Ctrl+Y", false, EditorActionManager.CanRedo()))
{
EditorActionManager.RedoAction();
}
if (ImGui.MenuItem("Delete", "Delete", false, true))
{
}
if (ImGui.MenuItem("Duplicate", "Ctrl+D", false, true))
{
}
ImGui.EndMenu();
}
}
public void OnGUI()
{
// Docking setup
//var vp = ImGui.GetMainViewport();
var wins = ImGui.GetWindowSize();
var winp = ImGui.GetWindowPos();
winp.Y += 20.0f;
wins.Y -= 20.0f;
ImGui.SetNextWindowPos(winp);
ImGui.SetNextWindowSize(wins);
var dsid = ImGui.GetID("DockSpace_ModelEdit");
ImGui.DockSpace(dsid, new Vector2(0, 0));
// Keyboard shortcuts
if (EditorActionManager.CanUndo() && InputTracker.GetControlShortcut(Key.Z))
{
EditorActionManager.UndoAction();
}
if (EditorActionManager.CanRedo() && InputTracker.GetControlShortcut(Key.Y))
{
EditorActionManager.RedoAction();
}
if (!ViewportUsingKeyboard && !ImGui.GetIO().WantCaptureKeyboard)
{
if (InputTracker.GetKeyDown(Key.W))
{
Gizmos.Mode = Gizmos.GizmosMode.Translate;
}
if (InputTracker.GetKeyDown(Key.E))
{
Gizmos.Mode = Gizmos.GizmosMode.Rotate;
}
// Use home key to cycle between gizmos origin modes
if (InputTracker.GetKeyDown(Key.Home))
{
if (Gizmos.Origin == Gizmos.GizmosOrigin.World)
{
Gizmos.Origin = Gizmos.GizmosOrigin.BoundingBox;
}
else if (Gizmos.Origin == Gizmos.GizmosOrigin.BoundingBox)
{
Gizmos.Origin = Gizmos.GizmosOrigin.World;
}
}
// F key frames the selection
if (InputTracker.GetKeyDown(Key.F))
{
var selected = _selection.GetFilteredSelection <Entity>();
bool first = false;
BoundingBox box = new BoundingBox();
foreach (var s in selected)
{
if (s.RenderSceneMesh != null)
{
if (!first)
{
box = s.RenderSceneMesh.GetBounds();
first = true;
}
else
{
box = BoundingBox.Combine(box, s.RenderSceneMesh.GetBounds());
}
}
}
if (first)
{
Viewport.FrameBox(box);
}
}
// Render settings
if (InputTracker.GetControlShortcut(Key.Number1))
{
RenderScene.DrawFilter = Scene.RenderFilter.MapPiece | Scene.RenderFilter.Object | Scene.RenderFilter.Character | Scene.RenderFilter.Region;
}
else if (InputTracker.GetControlShortcut(Key.Number2))
{
RenderScene.DrawFilter = Scene.RenderFilter.Collision | Scene.RenderFilter.Object | Scene.RenderFilter.Character | Scene.RenderFilter.Region;
}
else if (InputTracker.GetControlShortcut(Key.Number3))
{
RenderScene.DrawFilter = Scene.RenderFilter.Collision | Scene.RenderFilter.Navmesh | Scene.RenderFilter.Object | Scene.RenderFilter.Character | Scene.RenderFilter.Region;
}
}
ImGui.SetNextWindowSize(new Vector2(300, 500), ImGuiCond.FirstUseEver);
ImGui.SetNextWindowPos(new Vector2(20, 20), ImGuiCond.FirstUseEver);
System.Numerics.Vector3 clear_color = new System.Numerics.Vector3(114f / 255f, 144f / 255f, 154f / 255f);
//ImGui.Text($@"Viewport size: {Viewport.Width}x{Viewport.Height}");
//ImGui.Text(string.Format("Application average {0:F3} ms/frame ({1:F1} FPS)", 1000f / ImGui.GetIO().Framerate, ImGui.GetIO().Framerate));
Viewport.OnGui();
_assetBrowser.OnGui();
_sceneTree.OnGui();
_propEditor.OnGui(_selection.GetSingleFilteredSelection <Entity>(), "modeleditprop", Viewport.Width, Viewport.Height);
ResourceManager.OnGuiDrawTasks(Viewport.Width, Viewport.Height);
}
public override void DrawEditorMenu()
{
if (ImGui.BeginMenu("Edit"))
{
if (ImGui.MenuItem("Undo", "CTRL+Z", false, EditorActionManager.CanUndo()))
{
EditorActionManager.UndoAction();
}
if (ImGui.MenuItem("Redo", "Ctrl+Y", false, EditorActionManager.CanRedo()))
{
EditorActionManager.RedoAction();
}
if (ImGui.MenuItem("Delete", "Delete", false, _selection.IsSelection()))
{
var action = new DeleteMapObjectsAction(Universe, RenderScene, _selection.GetFilteredSelection <MapEntity>().ToList(), true);
EditorActionManager.ExecuteAction(action);
}
if (ImGui.MenuItem("Duplicate", "Ctrl+D", false, _selection.IsSelection()))
{
var action = new CloneMapObjectsAction(Universe, RenderScene, _selection.GetFilteredSelection <MapEntity>().ToList(), true);
EditorActionManager.ExecuteAction(action);
}
ImGui.EndMenu();
}
if (ImGui.BeginMenu("Display"))
{
if (ImGui.MenuItem("Grid", "", Viewport.DrawGrid))
{
Viewport.DrawGrid = !Viewport.DrawGrid;
}
if (ImGui.BeginMenu("Object Types"))
{
if (ImGui.MenuItem("Debug", "", RenderScene.DrawFilter.HasFlag(Scene.RenderFilter.Debug)))
{
RenderScene.ToggleDrawFilter(Scene.RenderFilter.Debug);
}
if (ImGui.MenuItem("Map Piece", "", RenderScene.DrawFilter.HasFlag(Scene.RenderFilter.MapPiece)))
{
RenderScene.ToggleDrawFilter(Scene.RenderFilter.MapPiece);
}
if (ImGui.MenuItem("Collision", "", RenderScene.DrawFilter.HasFlag(Scene.RenderFilter.Collision)))
{
RenderScene.ToggleDrawFilter(Scene.RenderFilter.Collision);
}
if (ImGui.MenuItem("Object", "", RenderScene.DrawFilter.HasFlag(Scene.RenderFilter.Object)))
{
RenderScene.ToggleDrawFilter(Scene.RenderFilter.Object);
}
if (ImGui.MenuItem("Character", "", RenderScene.DrawFilter.HasFlag(Scene.RenderFilter.Character)))
{
RenderScene.ToggleDrawFilter(Scene.RenderFilter.Character);
}
if (ImGui.MenuItem("Navmesh", "", RenderScene.DrawFilter.HasFlag(Scene.RenderFilter.Navmesh)))
{
RenderScene.ToggleDrawFilter(Scene.RenderFilter.Navmesh);
}
if (ImGui.MenuItem("Region", "", RenderScene.DrawFilter.HasFlag(Scene.RenderFilter.Region)))
{
RenderScene.ToggleDrawFilter(Scene.RenderFilter.Region);
}
ImGui.EndMenu();
}
if (ImGui.BeginMenu("Display Presets"))
{
if (ImGui.MenuItem("Map Piece/Character/Objects", "Ctrl-1"))
{
RenderScene.DrawFilter = Scene.RenderFilter.MapPiece | Scene.RenderFilter.Object | Scene.RenderFilter.Character | Scene.RenderFilter.Region;
}
if (ImGui.MenuItem("Collision/Character/Objects", "Ctrl-2"))
{
RenderScene.DrawFilter = Scene.RenderFilter.Collision | Scene.RenderFilter.Object | Scene.RenderFilter.Character | Scene.RenderFilter.Region;
}
if (ImGui.MenuItem("Collision/Navmesh/Character/Objects", "Ctrl-3"))
{
RenderScene.DrawFilter = Scene.RenderFilter.Collision | Scene.RenderFilter.Navmesh | Scene.RenderFilter.Object | Scene.RenderFilter.Character | Scene.RenderFilter.Region;
}
ImGui.EndMenu();
}
if (ImGui.BeginMenu("Environment Map"))
{
if (ImGui.MenuItem("Default"))
{
Viewport.SetEnvMap(0);
}
foreach (var map in Universe.EnvMapTextures)
{
if (ImGui.MenuItem(map))
{
var tex = ResourceManager.GetTextureResource($@"tex/{map}".ToLower());
if (tex.IsLoaded && tex.Get() != null && tex.TryLock())
{
if (tex.Get().GPUTexture.Resident)
{
Viewport.SetEnvMap(tex.Get().GPUTexture.TexHandle);
}
tex.Unlock();
}
}
}
ImGui.EndMenu();
}
if (ImGui.BeginMenu("Scene Lighting"))
{
Viewport.SceneParamsGui();
ImGui.EndMenu();
}
CFG.Current.LastSceneFilter = RenderScene.DrawFilter;
ImGui.EndMenu();
}
if (ImGui.BeginMenu("Gizmos"))
{
if (ImGui.BeginMenu("Mode"))
{
if (ImGui.MenuItem("Translate", "W", Gizmos.Mode == Gizmos.GizmosMode.Translate))
{
Gizmos.Mode = Gizmos.GizmosMode.Translate;
}
if (ImGui.MenuItem("Rotate", "E", Gizmos.Mode == Gizmos.GizmosMode.Rotate))
{
Gizmos.Mode = Gizmos.GizmosMode.Rotate;
}
ImGui.EndMenu();
}
if (ImGui.BeginMenu("Space"))
{
if (ImGui.MenuItem("Local", "", Gizmos.Space == Gizmos.GizmosSpace.Local))
{
Gizmos.Space = Gizmos.GizmosSpace.Local;
}
if (ImGui.MenuItem("World", "", Gizmos.Space == Gizmos.GizmosSpace.World))
{
Gizmos.Space = Gizmos.GizmosSpace.World;
}
ImGui.EndMenu();
}
if (ImGui.BeginMenu("Origin"))
{
if (ImGui.MenuItem("World", "", Gizmos.Origin == Gizmos.GizmosOrigin.World))
{
Gizmos.Origin = Gizmos.GizmosOrigin.World;
}
if (ImGui.MenuItem("Bounding Box", "", Gizmos.Origin == Gizmos.GizmosOrigin.BoundingBox))
{
Gizmos.Origin = Gizmos.GizmosOrigin.BoundingBox;
}
ImGui.EndMenu();
}
ImGui.EndMenu();
}
}
private void ChangeProperty(object prop, Entity selection, object obj, object newval,
bool changed, bool committed, bool shouldUpdateVisual, int arrayindex = -1)
{
if (changed)
{
if (prop == ChangingPropery && LastUncommittedAction != null)
{
if (ContextActionManager.PeekUndoAction() == LastUncommittedAction)
{
ContextActionManager.UndoAction();
}
else
{
LastUncommittedAction = null;
}
}
else
{
LastUncommittedAction = null;
}
if (ChangingObject != null && selection != null && selection.WrappedObject != ChangingObject)
{
committed = true;
}
else
{
PropertiesChangedAction action;
if (arrayindex != -1)
{
action = new PropertiesChangedAction((PropertyInfo)prop, arrayindex, obj, newval);
}
else
{
action = new PropertiesChangedAction((PropertyInfo)prop, obj, newval);
}
if (shouldUpdateVisual && selection != null)
{
action.SetPostExecutionAction((undo) =>
{
selection.UpdateRenderModel();
});
}
ContextActionManager.ExecuteAction(action);
LastUncommittedAction = action;
ChangingPropery = prop;
//ChangingObject = selection.MsbObject;
ChangingObject = selection != null ? selection.WrappedObject : obj;
}
}
if (committed)
{
// Invalidate name cache
if (selection != null)
{
selection.Name = null;
}
// Undo and redo the last action with a rendering update
if (LastUncommittedAction != null && ContextActionManager.PeekUndoAction() == LastUncommittedAction)
{
if (LastUncommittedAction is PropertiesChangedAction a)
{
// Kinda a hack to prevent a jumping glitch
a.SetPostExecutionAction(null);
ContextActionManager.UndoAction();
if (selection != null)
{
a.SetPostExecutionAction((undo) =>
{
selection.UpdateRenderModel();
});
}
ContextActionManager.ExecuteAction(a);
}
}
LastUncommittedAction = null;
ChangingPropery = null;
ChangingObject = null;
}
}