private void ApplyTransform(AbstractTransformAction transformAction, ref TransformChangeInfos transformChangeInfos)
{
if (!Selected)
{
return;
}
Vector3 pp = Position, pr = Rotation, ps = Scale;
GlobalPosition = transformAction.NewPos(GlobalPosition, out bool posHasChanged);
Matrix3 rotMtx = GlobalRotation;
GlobalRotation = transformAction.NewRot(GlobalRotation, out bool rotHasChanged);
GlobalScale = transformAction.NewScale(GlobalScale, rotMtx, out bool scaleHasChanged);
Mesh.Transform.Position = GlobalPosition;
Mesh.Transform.Scale = GlobalScale;
Mesh.Transform.Rotation = GlobalRotation.ExtractRotation();
transformChangeInfos.Add(this, 0,
posHasChanged ? new Vector3?(pp) : new Vector3?(),
rotHasChanged ? new Vector3?(pr) : new Vector3?(),
scaleHasChanged ? new Vector3?(ps) : new Vector3?());
}
private void AddPointTransformsToUndo(EditorSceneBase scene, List <RenderablePathPoint> selected)
{
TransformChangeInfos transformChangeInfos = new TransformChangeInfos(new List <TransformChangeInfo>());
for (int i = 0; i < selected.Count; i++)
{
transformChangeInfos.Add(selected[i], i, selected[i].GlobalPosition, selected[i].Rotation, selected[i].GlobalScale);
}
scene.AddTransformToUndo(transformChangeInfos);
}
public RevertableScaleChange(TransformChangeInfos transformChangeInfos)
{
scaleInfos = new ScaleInfo[transformChangeInfos.changedPositions + transformChangeInfos.changedScales - transformChangeInfos.changedPosScales];
int i = 0;
foreach (TransformChangeInfo info in transformChangeInfos.infos)
{
if (info.position.HasValue || info.scale.HasValue)
{
scaleInfos[i++] = new ScaleInfo(info.obj, info.part, info.position, info.scale);
}
}
}
public RevertableRotChange(TransformChangeInfos transformChangeInfos)
{
rotInfos = new RotInfo[transformChangeInfos.changedPositions + transformChangeInfos.changedRotations - transformChangeInfos.changedPosRots];
int i = 0;
foreach (TransformChangeInfo info in transformChangeInfos.infos)
{
if (info.position.HasValue || info.rotation.HasValue)
{
rotInfos[i++] = new RotInfo(info.obj, info.part, info.position, info.rotation);
}
}
}
public RevertablePosChange(TransformChangeInfos transformChangeInfos)
{
posInfos = new PosInfo[transformChangeInfos.changedPositions];
int i = 0;
foreach (TransformChangeInfo info in transformChangeInfos.infos)
{
if (info.position.HasValue)
{
posInfos[i++] = new PosInfo(info.obj, info.part, info.position.Value);
}
}
}
public override uint MouseUp(MouseEventArgs e, GL_ControlBase control)
{
TransformChangeInfos transformChangeInfos = new TransformChangeInfos(new List <TransformChangeInfo>());
uint var = 0;
if (CurrentAction != NoAction && CurrentAction.IsApplyOnRelease())
{
foreach (IEditableObject obj in GetObjects())
{
obj.ApplyTransformActionToSelection(CurrentAction, ref transformChangeInfos);
}
var |= REDRAW_PICKING | FORCE_REENTER;
AddTransformToUndo(transformChangeInfos);
EndUndoCollection();
CurrentAction = NoAction;
}
if (ExclusiveAction != NoAction)
{
Hovered.ApplyTransformActionToPart(ExclusiveAction, HoveredPart, ref transformChangeInfos);
var |= REDRAW_PICKING;
AddTransformToUndo(transformChangeInfos);
EndUndoCollection();
ExclusiveAction = NoAction;
}
foreach (AbstractGlDrawable obj in StaticObjects)
{
var |= obj.MouseUp(e, control);
}
foreach (IEditableObject obj in GetObjects())
{
var |= obj.MouseUp(e, control);
}
return(var);
}
public void AddTransformToUndo(TransformChangeInfos transformChangeInfos)
{
if (transformChangeInfos.changedRotations > 0)
{
AddToUndo(new RevertableRotChange(transformChangeInfos));
}
else if (transformChangeInfos.changedScales > 0)
{
AddToUndo(new RevertableScaleChange(transformChangeInfos));
}
else if (transformChangeInfos.changedPositions > 0)
{
AddToUndo(new RevertablePosChange(transformChangeInfos));
}
if (transformChangeInfos.changedPositions + transformChangeInfos.changedRotations + transformChangeInfos.changedScales > 0)
{
ObjectsMoved?.Invoke(this, null);
}
}
public override void ApplyTransformActionToSelection(EditorSceneBase scene, AbstractTransformAction transformAction, ref TransformChangeInfos transformChangeInfos)
{
ApplyTransform(transformAction, ref transformChangeInfos);
}
public override void ApplyTransformActionToPart(EditorSceneBase scene, AbstractTransformAction transformAction, int _part, ref TransformChangeInfos transformChangeInfos)
{
if (PickingSelection == PickingMode.Mesh)
{
foreach (GenericPickableMesh mesh in PickableMeshes)
{
int span = mesh.GetPickableSpan();
if (_part >= 0 && _part < span)
{
mesh.ApplyTransformActionToPart(scene, transformAction, _part, ref transformChangeInfos);
return;
}
_part -= span;
}
}
}
public virtual void ApplyTransformActionToSelection(AbstractTransformAction transformAction, ref TransformChangeInfos transformChangeInfos)
{
}
public override void ApplyTransformActionToPart(EditorSceneBase scene, AbstractTransformAction transformAction, int _part, ref TransformChangeInfos transformChangeInfos)
{
foreach (RenderablePathPoint point in PathPoints)
{
int span = point.GetPickableSpan();
if (_part >= 0 && _part < span)
{
point.ApplyTransformActionToPart(scene, transformAction, _part, ref transformChangeInfos);
return;
}
_part -= span;
}
throw new Exception("Invalid partIndex");
}
public override void ApplyTransformActionToSelection(EditorSceneBase scene, AbstractTransformAction transformAction, ref TransformChangeInfos transformChangeInfos)
{
foreach (RenderablePathPoint point in GetSelectedPoints())
{
point.ApplyTransformActionToSelection(scene, transformAction, ref transformChangeInfos);
}
}
public override uint KeyDown(KeyEventArgs e, GL_ControlBase control, bool isRepeat)
{
TransformChangeInfos transformChangeInfos = new TransformChangeInfos(new List <TransformChangeInfo>());
uint var = 0;
bool selectionHasChanged = false;
if (!isRepeat)
{
if ((SelectionTransformAction != NoAction || CurrentAction != null))
{
SelectionTransformAction.KeyDown(e);
CurrentAction?.KeyDown(e);
var = NO_CAMERA_ACTION | REDRAW;
}
else
{
if (e.KeyData == KS_Focus)
{
BoundingBox box = BoundingBox.Default;
foreach (IEditableObject obj in GetObjects())
{
obj.GetSelectionBox(ref box);
}
if (box != BoundingBox.Default)
{
control.CameraTarget = box.GetCenter();
}
var = REDRAW_PICKING;
}
else if (e.KeyData == KS_Undo)
{
Undo();
var = REDRAW_PICKING;
}
else if (e.KeyData == KS_Redo)
{
Redo();
var = REDRAW_PICKING;
}
else if (e.KeyData == KS_Hide)
{
foreach (IEditableObject obj in GetObjects())
{
if (obj.IsSelected())
{
obj.Visible = false;
}
}
var = REDRAW_PICKING;
}
else if (e.KeyData == KS_UnHide)
{
foreach (IEditableObject obj in GetObjects())
{
if (obj.IsSelected())
{
obj.Visible = true;
}
}
var = REDRAW_PICKING;
}
else if (e.KeyData == KS_SnapSelected)
{
SnapAction action = new SnapAction();
foreach (IEditableObject obj in GetObjects())
{
obj.ApplyTransformActionToSelection(action, ref transformChangeInfos);
}
var = REDRAW_PICKING;
}
else if (e.KeyData == KS_ResetRotation)
{
ResetRot action = new ResetRot();
foreach (IEditableObject obj in GetObjects())
{
obj.ApplyTransformActionToSelection(action, ref transformChangeInfos);
}
var = REDRAW_PICKING;
}
else if (e.KeyData == KS_ResetScale)
{
ResetScale action = new ResetScale();
foreach (IEditableObject obj in GetObjects())
{
obj.ApplyTransformActionToSelection(action, ref transformChangeInfos);
}
var = REDRAW_PICKING;
}
else if (e.KeyData == KS_DeSelectAll)
{
foreach (IEditableObject obj in GetObjects())
{
obj.DeselectAll(control);
}
selectionHasChanged = true;
var = REDRAW;
}
else if (e.KeyData == KS_SelectAll)
{
if (multiSelect)
{
foreach (IEditableObject obj in GetObjects())
{
obj.SelectAll(control);
}
selectionHasChanged = true;
}
var = REDRAW;
}
}
}
foreach (IEditableObject obj in GetObjects())
{
var |= obj.KeyDown(e, control, isRepeat);
}
foreach (AbstractGlDrawable obj in StaticObjects)
{
var |= obj.KeyDown(e, control, isRepeat);
}
if (selectionHasChanged)
{
UpdateSelection(var);
}
AddTransformToUndo(transformChangeInfos);
return(var);
}
public override void ApplyTransformActionToSelection(AbstractTransformAction transformAction, ref TransformChangeInfos infos)
{
Vector3? prevPos;
Quaternion?prevRot;
Vector3? prevScale;
Position = transformAction.NewPos(Position, out prevPos);
rotation = transformAction.NewRot(rotation, out prevRot);
scale = transformAction.NewScale(scale, out prevScale);
infos.Add(this, 0, prevPos, prevRot, prevScale);
}
private void ApplyTransform(AbstractTransformAction transformAction, ref TransformChangeInfos transformChangeInfos)
{
if (Selected)
{
Vector3 pp = Position, pr = Rotation, ps = Scale;
Vector3 newPos = Vector3.Zero;
bool posHasChanged = false;
//Go through all points first to see if any point is over the applyed transform one
///This will move it to the original location and connect
foreach (var point in ParentPath.PathPoints)
{
if (point.IsPointOver)
{
posHasChanged = true;
newPos = point.GlobalPosition;
}
}
if (!posHasChanged)
{
newPos = OnPositionChanged(transformAction.NewPos(GlobalPosition, out posHasChanged));
Console.WriteLine($"newPos {newPos}");
}
if (posHasChanged)
{
List <RenderablePathPoint> pointsConnected = new List <RenderablePathPoint>();
foreach (var point in ParentPath.PathPoints)
{
if (point.IsPointOver)
{
Console.WriteLine($"pointsConnected {pointsConnected.Count}");
pointsConnected.Add(point);
}
}
foreach (var point in ParentPath.PathPoints)
{
point.IsPointOver = false;
}
foreach (var point in pointsConnected)
{
ConnectToPoint(point);
}
}
GlobalPosition = newPos;
Matrix3 rotMtx = GlobalRotation;
GlobalRotation = transformAction.NewRot(GlobalRotation, out bool rotHasChanged);
GlobalScale = transformAction.NewScale(GlobalScale, rotMtx, out bool scaleHasChanged);
transformChangeInfos.Add(this, 0,
posHasChanged ? new Vector3?(pp) : new Vector3?(),
rotHasChanged ? new Vector3?(pr) : new Vector3?(),
scaleHasChanged ? new Vector3?(ps) : new Vector3?());
}
}
public virtual void ApplyTransformActionToPart(AbstractTransformAction transformAction, int part, ref TransformChangeInfos transformChangeInfos)
{
}
public override void ApplyTransformActionToSelection(AbstractTransformAction transformAction, ref TransformChangeInfos infos)
{
if (!Selected)
{
return;
}
Vector3 pp = Position, pr = Rotation;
var newPos = transformAction.NewPos(GlobalPosition, out bool posHasChanged);
var newRot = transformAction.NewRot(Rotation, out bool rotHasChanged);
if (posHasChanged)
{
GlobalPosition = newPos;
}
if (rotHasChanged)
{
Rotation = newRot;
}
infos.Add(this, 0,
posHasChanged ? new Vector3?(pp) : null,
rotHasChanged ? new Vector3?(pr) : null,
null);
}
public override uint KeyDown(KeyEventArgs e, GL_ControlBase control)
{
TransformChangeInfos transformChangeInfos = new TransformChangeInfos(new List <TransformChangeInfo>());
uint var = 0;
bool selectionHasChanged = false;
if ((CurrentAction != NoAction || ExclusiveAction != NoAction) && e.KeyCode != Keys.V)
{
CurrentAction.KeyDown(e);
ExclusiveAction.KeyDown(e);
var = NO_CAMERA_ACTION | REDRAW;
}
else if (e.KeyCode == Keys.Z) //focus camera on the selection
{
if (e.Control)
{
Undo();
}
else
{
BoundingBox box = BoundingBox.Default;
foreach (IEditableObject obj in GetObjects())
{
obj.GetSelectionBox(ref box);
}
if (box != BoundingBox.Default)
{
control.CameraTarget = box.GetCenter();
}
}
var = REDRAW_PICKING;
}
else if (e.KeyCode == Keys.Y && e.Control)
{
Redo();
var = REDRAW_PICKING;
}
else if (e.KeyCode == Keys.H) //hide/show selected objects
{
foreach (IEditableObject obj in GetObjects())
{
if (obj.IsSelected())
{
obj.Visible = e.Shift;
}
}
var = REDRAW_PICKING;
}
else if (e.KeyCode == Keys.S && e.Shift) //auto snap selected objects
{
SnapAction action = new SnapAction();
foreach (IEditableObject obj in GetObjects())
{
obj.ApplyTransformActionToSelection(action, ref transformChangeInfos);
}
var = REDRAW_PICKING;
}
else if (e.KeyCode == Keys.R && e.Shift && e.Control) //reset scale for selected objects
{
ResetScale action = new ResetScale();
foreach (IEditableObject obj in GetObjects())
{
obj.ApplyTransformActionToSelection(action, ref transformChangeInfos);
}
var = REDRAW_PICKING;
}
else if (e.KeyCode == Keys.R && e.Shift) //reset rotation for selected objects
{
ResetRot action = new ResetRot();
foreach (IEditableObject obj in GetObjects())
{
obj.ApplyTransformActionToSelection(action, ref transformChangeInfos);
}
var = REDRAW_PICKING;
}
else if (e.Control && e.KeyCode == Keys.A) //select/deselect all objects
{
if (e.Shift)
{
foreach (IEditableObject obj in GetObjects())
{
obj.DeselectAll(control);
}
selectionHasChanged = true;
}
if (!e.Shift && multiSelect)
{
foreach (IEditableObject obj in GetObjects())
{
obj.SelectAll(control);
}
selectionHasChanged = true;
}
var = REDRAW;
}
foreach (IEditableObject obj in GetObjects())
{
var |= obj.KeyDown(e, control);
}
foreach (AbstractGlDrawable obj in StaticObjects)
{
var |= obj.KeyDown(e, control);
}
if (selectionHasChanged)
{
UpdateSelection(var);
}
AddTransformToUndo(transformChangeInfos);
return(var);
}
public override void ApplyTransformActionToSelection(EditorSceneBase scene, AbstractTransformAction transformAction, ref TransformChangeInfos infos)
{
if (!Selected)
{
return;
}
Vector3 pp = Position, pr = Rotation, ps = Scale;
GlobalPosition = OnPositionChanged(transformAction.NewPos(GlobalPosition, out bool posHasChanged));
Matrix3 rotMtx = GlobalRotation;
GlobalRotation = transformAction.NewRot(GlobalRotation, out bool rotHasChanged);
GlobalScale = transformAction.NewScale(GlobalScale, rotMtx, out bool scaleHasChanged);
infos.Add(this, 0,
posHasChanged ? new Vector3?(pp) : new Vector3?(),
rotHasChanged ? new Vector3?(pr) : new Vector3?(),
scaleHasChanged ? new Vector3?(ps) : new Vector3?());
}
public override void ApplyTransformActionToSelection(EditorSceneBase scene, AbstractTransformAction transformAction, ref TransformChangeInfos infos)
{
if (PickingSelection == PickingMode.Mesh)
{
foreach (GenericPickableMesh point in PickableMeshes)
{
point.ApplyTransformActionToSelection(scene, transformAction, ref infos);
}
}
else if (Selected)
{
Vector3 pp = Position, pr = Rotation, ps = Scale;
GlobalPosition = OnPositionChanged(transformAction.NewPos(GlobalPosition, out bool posHasChanged));
Matrix3 rotMtx = GlobalRotation;
GlobalRotation = transformAction.NewRot(GlobalRotation, out bool rotHasChanged);
GlobalScale = transformAction.NewScale(GlobalScale, rotMtx, out bool scaleHasChanged);
infos.Add(this, 0,
posHasChanged ? new Vector3?(pp) : new Vector3?(),
rotHasChanged ? new Vector3?(pr) : new Vector3?(),
scaleHasChanged ? new Vector3?(ps) : new Vector3?());
}
}
