private CurrentTool MovePrevious(CurrentTool currentTool)
{
return(currentTool == CurrentTool.Resize ? CurrentTool.Color :
Enum.GetValues(typeof(CurrentTool)).Cast <CurrentTool>()
.OrderByDescending(t => t)
.FirstOrDefault(t => (int)t < (int)currentTool));
}
private void panelWorkflow_MouseMove(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
CurrentTool.OnMouseMove(e.X, e.Y);
}
}
private void form_MouseWheel(object sender, MouseEventArgs e)
{
if (Control.ModifierKeys.HasFlag(Keys.Control) && Form.Mode == RegionCaptureMode.Annotation)
{
if (e.Delta > 0)
{
CurrentTool = CurrentTool.Previous <ShapeType>();
}
else if (e.Delta < 0)
{
CurrentTool = CurrentTool.Next <ShapeType>();
}
}
else
{
if (e.Delta > 0)
{
Options.MagnifierPixelCount = Math.Min(Options.MagnifierPixelCount + 2, RegionCaptureOptions.MagnifierPixelCountMaximum);
}
else if (e.Delta < 0)
{
Options.MagnifierPixelCount = Math.Max(Options.MagnifierPixelCount - 2, RegionCaptureOptions.MagnifierPixelCountMinimum);
}
}
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
Graphics g = e.Graphics;
//Enable anti-aliasing for prettier vertices!
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
g.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality;
g.FillRectangle(gb, new Rectangle(0, 0, this.Width, this.Height));
foreach (GUIVertex gv in verts)
{
gv.Draw(g);
}
foreach (GUIEdge edge in edges)
{
edge.Draw(g);
}
if (CurrentTool != null)
{
CurrentTool.Draw(g);
}
}
//--------------------------------------------------------------------------------------------------
public void MouseDown(ViewportController viewportController)
{
if (_LastDetectedInteractive is AIS_ViewCube viewCube &&
_LastDetectedOwner is AIS_ViewCubeOwner viewCubeOwner)
{
if (!viewportController.LockedToPlane)
{
viewCube.HandleClick(viewCubeOwner);
}
return;
}
if (CurrentTool != null)
{
if (CurrentTool.OnMouseDown(_MouseEventData))
{
// Handled by tool
return;
}
}
if (_ToolActions.Any())
{
foreach (var toolAction in _ToolActions)
{
if (toolAction.OnMouseDown(_MouseEventData))
{
// Handled by tool action
return;
}
}
}
IsSelecting = true;
}
private void panelForm_MouseUp(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
CurrentTool.OnMouseUp(e.X, e.Y);
}
}
void mPanel_MouseDown(object sender, MouseEventArgs e)
{
if (CurrentTool != null)
{
CurrentTool.OnMouseDown(e.X, e.Y, e);
}
}
/// <summary>
/// Called when the PlayState is entered from the state manager.
/// </summary>
public override void OnEnter()
{
// Just toss out any pending input.
DwarfGame.GumInputMapper.GetInputQueue();
if (!IsInitialized)
{
EnterTime = DateTime.Now;
DiscoverPlayerTools();
VoxSelector.Selected += (voxels, button) => CurrentTool.OnVoxelsSelected(voxels, button);
VoxSelector.Dragged += (voxels, button) => CurrentTool.OnVoxelsDragged(voxels, button);
BodySelector.Selected += (bodies, button) =>
{
CurrentTool.OnBodiesSelected(bodies, button);
if (CurrentToolMode == "SelectUnits")
{
SelectedObjects = bodies;
}
};
BodySelector.MouseOver += (bodies) => CurrentTool.OnMouseOver(bodies);
// Ensure game is not paused.
World.Paused = false;
DwarfTime.LastTime.Speed = 1.0f;
// Setup new gui. Double rendering the mouse?
Gui = new Gui.Root(DwarfGame.GuiSkin);
Gui.MousePointer = new Gui.MousePointer("mouse", 4, 0);
World.UserInterface = this;
CreateGUIComponents();
IsInitialized = true;
SoundManager.PlayMusic("main_theme_day");
World.Time.Dawn += time =>
{
SoundManager.PlaySound(ContentPaths.Audio.Oscar.sfx_gui_daytime, 0.15f);
SoundManager.PlayMusic("main_theme_day");
};
World.Time.NewNight += time =>
{
SoundManager.PlaySound(ContentPaths.Audio.Oscar.sfx_gui_nighttime, 0.15f);
SoundManager.PlayMusic("main_theme_night");
};
World.UnpauseThreads();
AutoSaveTimer = new Timer(GameSettings.Current.AutoSaveTimeMinutes * 60.0f, false, Timer.TimerMode.Real);
foreach (var contextCommandFactory in AssetManager.EnumerateModHooks(typeof(ContextCommandAttribute), typeof(ContextCommands.ContextCommand), new Type[] { }))
{
ContextCommands.Add(contextCommandFactory.Invoke(null, new Object[] { }) as ContextCommands.ContextCommand);
}
World.LogEvent(String.Format("We have arrived at {0}", World.Overworld.Name));
}
base.OnEnter();
}
private void createPlacement()
{
if (currentPlacement != null)
{
return;
}
var blueprint = CurrentTool?.CreatePlacementBlueprint();
if (blueprint != null)
{
// doing this post-creations as adding the default hit sample should be the case regardless of the ruleset.
blueprint.HitObject.Samples.Add(new HitSampleInfo {
Name = HitSampleInfo.HIT_NORMAL
});
placementBlueprintContainer.Child = currentPlacement = blueprint;
// Fixes a 1-frame position discrepancy due to the first mouse move event happening in the next frame
updatePlacementPosition();
updatePlacementSamples();
updatePlacementNewCombo();
}
}
/// <summary>
/// set the new solid manipulation mode
/// </summary>
/// <param name="mode"></param>
private void SetSolidManipulationMode(string mode)
{
CurrentTool?.Deinitialize();
switch (mode)
{
case "brush":
CurrentTool = new SolidManipulationTool();
textureProperties.Enabled = true;
break;
case "face":
CurrentTool = new SolidFaceTool();
textureProperties.Enabled = true;
break;
case "vertex":
CurrentTool = new SolidVertexTool();
textureProperties.Enabled = false;
break;
}
CurrentTool?.Initialize(this);
UpdateSolidManipulationToolbar();
UpdateSolidPropertiesControl();
UpdateCutCopyPasteToolbar();
UpdateGroupToolbar();
RenderViewports();
}
protected override void OnKeyUp(KeyEventArgs e)
{
if (CurrentTool != null)
{
CurrentTool.OnKeyUp(e);
}
}
private void InitializeDial()
{
radialController = RadialController.CreateForCurrentView();
// Set rotation resolution to 1 degree of sensitivity.
radialController.RotationResolutionInDegrees = 36;
// create new dial menu item
//ToggleMenuItem =
// RadialControllerMenuItem.CreateFromFontGlyph("Toggle Light", "\xE793", "Segoe MDL2 Assets");
//radialController.Menu.Items.Add(ToggleMenuItem);
BrightnessMenuItem =
RadialControllerMenuItem.CreateFromFontGlyph("Brightness", "\xE706", "Segoe MDL2 Assets");
radialController.Menu.Items.Add(BrightnessMenuItem);
ColorMenuItem =
RadialControllerMenuItem.CreateFromFontGlyph("Color", "\xE790", "Segoe MDL2 Assets");
radialController.Menu.Items.Add(ColorMenuItem);
// clear all default item
RadialControllerConfiguration config = RadialControllerConfiguration.GetForCurrentView();
config.SetDefaultMenuItems(new RadialControllerSystemMenuItemKind[] { });
// bind dial menu item to CurrentTool Enum
//ToggleMenuItem.Invoked += (sender, args) => thisTool = CurrentTool.ToggleItem;
BrightnessMenuItem.Invoked += (sender, args) => thisTool = CurrentTool.BrightnessItem;
ColorMenuItem.Invoked += (sender, args) => thisTool = CurrentTool.ColorItem;
// subscribe click and rotation of the dial
radialController.ButtonClicked += (sender, args) => { RadialController_ButtonClicked(sender, args); };
radialController.RotationChanged += (sender, args) => { RadialController_RotationChanged(sender, args); };
}
public void Commit()
{
if (CurrentTool != null)
{
CurrentTool.DoCommit();
}
}
//--------------------------------------------------------------------------------------------------
public bool KeyPressed(Key key)
{
if (CurrentTool != null)
{
if (CurrentTool.OnKeyPressed(key))
{
return(true);
}
}
if (_ToolActions.Any())
{
foreach (var toolAction in _ToolActions)
{
if (toolAction.OnKeyPressed(key))
{
// Handled by tool action
//Workspace.V3dViewer.Redraw();
return(true);
}
}
}
return(false);
}
public void Render(DwarfGame game, DwarfTime time, GraphicsDevice g)
{
CurrentTool.Render(game, g, time);
VoxSelector.Render();
foreach (CreatureAI creature in Faction.SelectedMinions)
{
//Drawer2D.DrawZAlignedRect(creature.Position + Vector3.Down * 0.5f, 0.25f, 0.25f, 2, new Color(255, 255, 255, 50));
creature.Creature.SelectionCircle.IsVisible = true;
foreach (Task task in creature.Tasks)
{
task.Render(time);
}
if (creature.CurrentTask != null)
{
creature.CurrentTask.Render(time);
}
}
DwarfGame.SpriteBatch.Begin();
BodySelector.Render(DwarfGame.SpriteBatch);
DwarfGame.SpriteBatch.End();
}
public void OnBodiesSelected(List <Body> bodies, InputManager.MouseButton button)
{
CurrentTool.OnBodiesSelected(bodies, button);
if (CurrentToolMode == ToolMode.SelectUnits)
{
SelectedObjects = bodies;
}
}
//--------------------------------------------------------------------------------------------------
public bool PrepareUndo()
{
if (CurrentTool != null)
{
return(CurrentTool.PrepareUndo());
}
return(true);
}
public void StartTool(Tool tool)
{
CurrentTool = tool ?? throw new ArgumentNullException(nameof(tool));
CurrentTool.Manager = this;
CurrentTool.Start();
}
//protected override void OnResize(EventArgs e)
//{
// base.OnResize(e);
//}
void mPanel_MouseUp(object sender, MouseEventArgs e)
{
// base.OnMouseUp(e);
if (CurrentTool != null)
{
CurrentTool.OnMouseUp(e.X, e.Y);
}
}
public void ChangeTool(ToolMode NewTool)
{
Tools[NewTool].OnBegin();
if (CurrentToolMode != NewTool)
{
CurrentTool.OnEnd();
}
CurrentToolMode = NewTool;
}
public void NextStep()
{
if (CurrentTool is null)
{
return;
}
CurrentTool.NextStep();
}
public void PreviousStep()
{
if (CurrentTool is null)
{
return;
}
CurrentTool.PreviousStep();
}
void mPanel_MouseMove(object sender, MouseEventArgs e)
{
if (CurrentTool != null)
{
CurrentTool.OnMouseMove(e.X, e.Y);
}
RgPoint pt = mScreenDisplay.DisplayTransformation.ToUnit(new PointF(e.X, e.Y));
Debug.Write(string.Format("X:{0}mm Y:{1}mm", pt.X * 25.4, pt.Y * 25.4));
}
private void panelWorkflow_MouseDown(object sender, MouseEventArgs e)
{
Focus();
if (e.Button == MouseButtons.Left)
{
CurrentTool.OnMouseDown(e.X, e.Y);
CurrentTool.AfterActivityCreate();
}
}
private void panelForm_MouseDown(object sender, MouseEventArgs e)
{
Focus();
if (e.Button == MouseButtons.Left)
{
CurrentTool.OnMouseDown(e.X, e.Y);
CurrentTool.AfterControlCreate();
}
}
//--------------------------------------------------------------------------------------------------
public bool CanPasteFromClipboard()
{
if (CurrentTool != null)
{
return(CurrentTool.CanPasteFromClipboard());
}
else
{
return(InteractiveContext.Current.DocumentController.CanPasteFromClipboard());
}
}
//--------------------------------------------------------------------------------------------------
public IEnumerable <InteractiveEntity> PasteFromClipboard()
{
if (CurrentTool != null)
{
return(CurrentTool.PasteFromClipboard());
}
else
{
return(InteractiveContext.Current.DocumentController.PasteFromClipboard());
}
}
//--------------------------------------------------------------------------------------------------
public void Delete()
{
if (CurrentTool != null)
{
CurrentTool.Delete();
}
else
{
InteractiveContext.Current.DocumentController.Delete(Selection.SelectedEntities);
}
}
//--------------------------------------------------------------------------------------------------
public bool CanDuplicate()
{
if (CurrentTool != null)
{
return(CurrentTool.CanDuplicate());
}
else
{
return(InteractiveContext.Current.DocumentController.CanDuplicate(Selection.SelectedEntities));
}
}
public void setCurrentTool(CurrentTool tool)
{
this.currentToolEnum = tool;
if (this.currentTool != null)
{
this.currentTool.toolChangeOut();
}
this.currentTool = toolsCollection[tool];
this.currentTool.toolChangeIn();
//Console.WriteLine(this.currentTool.ToString());
}
public void sceneEditor()
{
Undo.RecordObjects(new Object[] { spriteDeformer }, "Move deformer");
HandleUtility.AddDefaultControl(GUIUtility.GetControlID(GetHashCode(), FocusType.Passive));
if (Tools.current != Tool.View)
Tools.current = Tool.None;
if (Event.current.keyCode == KeyCode.Delete)
{
spriteDeformer.RemovePoints(selectedPoints.ToArray());
selectedPoints.Clear();
upDateMeshDate(true);
Event.current.Use();
}
foreach (SpritePoint p in spriteDeformer.points)
{
Handles.color = colorSets[ColorSet.POINT].standart;
Vector3 pos = spriteDeformer.SpritePositionToGlobal(p.spritePosition + p.offset2d);
Handles.SphereCap(0, pos, Quaternion.identity, 0.1f * HandleUtility.GetHandleSize(pos));
}
foreach (Edge e in spriteDeformer.edges)
{
Handles.color = colorSets[ColorSet.EDGE].standart;
Handles.DrawLine(spriteDeformer.SpritePositionToGlobal(e.point1.spritePosition + e.point1.offset2d), spriteDeformer.SpritePositionToGlobal(e.point2.spritePosition + e.point2.offset2d));
}
foreach (SpritePoint p in selectedPoints)
{
Vector3 pos = spriteDeformer.SpritePositionToGlobal(p.spritePosition + p.offset2d);
Handles.color = colorSets[ColorSet.POINT].selected;
Handles.SphereCap(0, pos, Quaternion.identity, 0.14f * HandleUtility.GetHandleSize(pos));
}
if (deformerTool == null) deformerTool = new DeformerTool(this);
deformerTool.OnSceneGUI();
if (Event.current.type == EventType.mouseDown && currentTool == CurrentTool.NONE && Tools.current != Tool.View && Event.current.button == 0)
{
if (GUIUtility.hotControl == 0 && !Event.current.alt)
{
startSelectedRect = Event.current.mousePosition;
currentTool = CurrentTool.SELECT_RECT;
}
}
if (currentTool == CurrentTool.SELECT_RECT)
{
Vector2 currentPos = Event.current.mousePosition;
Handles.BeginGUI();
Vector3 upLeft = (startSelectedRect);
Vector3 downRight = (currentPos);
Vector3 upRight = (new Vector2(currentPos.x, startSelectedRect.y));
Vector3 downLeft = (new Vector2(startSelectedRect.x, currentPos.y));
Vector3[] rectVerts = { upLeft, upRight, downRight, downLeft };
Handles.color = colorSets[ColorSet.SELECTED_RECTANGLE].standart;
Handles.DrawSolidRectangleWithOutline(rectVerts, colorSets[ColorSet.SELECTED_RECTANGLE].standart, colorSets[ColorSet.SELECTED_RECTANGLE].over);
Handles.EndGUI();
List<SpritePoint> inRecPoints = new List<SpritePoint>();
foreach (SpritePoint p in spriteDeformer.points)
{
Vector2 pScreenPos = HandleUtility.WorldToGUIPoint(spriteDeformer.SpritePositionToGlobal(p.spritePosition + p.offset2d));
Rect r = new Rect(startSelectedRect.x, startSelectedRect.y, currentPos.x - startSelectedRect.x, currentPos.y - startSelectedRect.y);
if (r.Contains(pScreenPos, true))
{
Vector3 pos = spriteDeformer.SpritePositionToGlobal(p.spritePosition + p.offset2d);
Handles.color = colorSets[ColorSet.POINT].over;
Handles.SphereCap(0, pos, Quaternion.identity, 0.15f * HandleUtility.GetHandleSize(pos));
inRecPoints.Add(p);
}
}
if (Event.current.rawType == EventType.MouseUp)
{
if (!(Event.current.shift || Event.current.control))
if(!(startSelectedRect == Event.current.mousePosition))
selectedPoints.Clear();
if (startSelectedRect == Event.current.mousePosition)
{
SpritePoint clossestP = null;
float minD = float.MaxValue;
foreach (var item in spriteDeformer.points)
{
float d = Vector2.Distance(Event.current.mousePosition,
HandleUtility.WorldToGUIPoint(
spriteDeformer.SpritePositionToGlobal(item.spritePosition + item.offset2d)));
if (d < minD)
{
minD = d;
clossestP = item;
}
}
if (minD < 6f)
{
if (!(Event.current.shift || Event.current.control))
{
selectedPoints.Clear();
}
inRecPoints.Add(clossestP);
}
}
foreach (SpritePoint p in inRecPoints)
{
if (Event.current.shift && Event.current.control)
{
if (!selectedPoints.Contains(p))
selectedPoints.Add(p);
}
else
if (Event.current.shift)
{
if (selectedPoints.Contains(p))
selectedPoints.Remove(p);
else
selectedPoints.Add(p);
}
else
if (Event.current.control)
{
if (selectedPoints.Contains(p))
selectedPoints.Remove(p);
}
else
{
selectedPoints.Add(p);
}
}
if(!spriteDeformer.editorProps.savePivot)deformerTool.recalCulatePivot();
currentTool = CurrentTool.NONE;
}
}
if (Event.current.rawType == EventType.MouseUp)
{
currentTool = CurrentTool.NONE;
}
}
