Fixed the undo system

pzgulyas · pzgulyas · commit cd452ee58070 · 2023-11-30T21:26:07.000+01:00
diff --git a/Source/Contrib/TrackViewer/SceneViewer.cs b/Source/Contrib/TrackViewer/SceneViewer.cs
@@ -58,6 +58,7 @@ public class SceneViewer
         OrbitingCamera Camera;
         Stack<UndoDataSet> UndoStack = new Stack<UndoDataSet>();
         Stack<UndoDataSet> RedoStack = new Stack<UndoDataSet>();
+        EditorState EditorState;
 
         /// <summary>The command-line arguments</summary>
         private string[] CommandLineArgs;
@@ -126,19 +127,27 @@ public void Update(GameTime gameTime)
                 {
                     SelectedObject = selectedObject;
                     SelectedObjectChanged();
+                    EditorState = EditorState.ObjectSelected;
                 }
             }
             if (UserInput.IsPressed(UserCommand.EditorUnselectAll))
             {
-                SelectedObject = null;
-                SelectedObjectChanged();
+                if (EditorState == EditorState.ObjectSelected || EditorState == EditorState.Default)
+                {
+                    SetDefaultMode();
+                }
             }
             if (UserInput.IsPressed(UserCommand.EditorUndo))
             {
-                UndoCommand();
+                if (EditorState == EditorState.ObjectSelected || EditorState == EditorState.Default)
+                {
+                    SetDefaultMode();
+                    UndoCommand();
+                }
             }
             if (UserInput.IsPressed(UserCommand.EditorRedo))
             {
+                SetDefaultMode();
                 RedoCommand();
             }
 
@@ -198,12 +207,12 @@ public async Task SetCameraLocation()
             mouseLocation.Location.Y = elevatedLocation + 15;
             Camera.SetLocation(mouseLocation);
 
-            var lastView = UndoStack.Count > 0 ? UndoStack.Last(s => s.UndoEvent == UndoEvent.ViewChanged) :
+            var lastView = UndoStack.Count > 0 ? UndoStack.First(s => s.UndoEvent == UndoEvent.ViewChanged) :
                 new UndoDataSet()
                 {
-                    OldCameraLocation = Camera.CameraWorldLocation,
-                    OldCameraRotationXRadians = Camera.GetRotationX(),
-                    OldCameraRotationYRadians = Camera.GetRotationY(),
+                    NewCameraLocation = Camera.CameraWorldLocation,
+                    NewCameraRotationXRadians = Camera.GetRotationX(),
+                    NewCameraRotationYRadians = Camera.GetRotationY(),
                 };
 
             UndoStack.Push(new UndoDataSet()
@@ -222,12 +231,16 @@ void UpdateViewUndoState()
         {
             if (UndoStack.Count == 0)
                 return;
+            
+            var lastView = UndoStack.First(s => s.UndoEvent == UndoEvent.ViewChanged);
+
+            if (Camera.GetRotationX() == lastView.NewCameraRotationXRadians && Camera.GetRotationY() == lastView.NewCameraRotationYRadians && Camera.CameraWorldLocation == lastView.NewCameraLocation)
+                return;
 
-            var lastView = UndoStack.Last(s => s.UndoEvent == UndoEvent.ViewChanged);
-            if (lastView == UndoStack.Last())
+            if (UndoStack.First().UndoEvent == UndoEvent.ViewChanged) // then updatable
             {
-                if (lastView.NewCameraLocation == lastView.OldCameraLocation && (Camera.GetRotationX() != lastView.NewCameraRotationXRadians || Camera.GetRotationY() != lastView.NewCameraRotationYRadians)
-                    || lastView.NewCameraLocation != lastView.OldCameraLocation && Camera.CameraWorldLocation == lastView.NewCameraLocation)
+                if ((Camera.GetRotationX() == lastView.NewCameraRotationXRadians && Camera.GetRotationY() == lastView.NewCameraRotationYRadians) ^
+                    (lastView.NewCameraRotationXRadians != lastView.OldCameraRotationXRadians || lastView.NewCameraRotationYRadians != lastView.OldCameraRotationYRadians))
                 {
                     // Group rotations and pan-zooms by just updating the last action
                     lastView.NewCameraRotationXRadians = Camera.GetRotationX();
@@ -237,7 +250,7 @@ void UpdateViewUndoState()
                     return;
                 }
             }
-            if (Camera.GetRotationX() != lastView.NewCameraRotationXRadians || Camera.GetRotationY() != lastView.NewCameraRotationYRadians || Camera.CameraWorldLocation == lastView.NewCameraLocation)
+            if (Camera.GetRotationX() != lastView.NewCameraRotationXRadians || Camera.GetRotationY() != lastView.NewCameraRotationYRadians || Camera.CameraWorldLocation != lastView.NewCameraLocation)
             {
                 UndoStack.Push(new UndoDataSet()
                 {
@@ -253,19 +266,21 @@ void UpdateViewUndoState()
             }
         }
 
+        void SetDefaultMode()
+        {
+            SelectedObject = null;
+            SelectedObjectChanged();
+            EditorState = EditorState.Default;
+        }
+
         void UndoCommand()
         {
-            UndoDataSet undoDataSet;
             if (UndoStack.Count > 1)
             {
-                undoDataSet = UndoStack.Pop();
+                var undoDataSet = UndoStack.Pop();
                 RedoStack.Push(undoDataSet);
+                UndoRedo(undoDataSet, true);
             }
-            else
-            {
-                undoDataSet = UndoStack.Peek();
-            }
-            UndoRedo(undoDataSet, true);
         }
 
         void RedoCommand()
@@ -283,8 +298,9 @@ void UndoRedo(UndoDataSet undoDataSet, bool undo)
             if (undoDataSet.UndoEvent == UndoEvent.ViewChanged)
             {
                 Camera.SetLocation(undo ? undoDataSet.OldCameraLocation : undoDataSet.NewCameraLocation);
-                Camera.RotationXTargetRadians = undo ? undoDataSet.OldCameraRotationXRadians : undoDataSet.NewCameraRotationXRadians;
-                Camera.RotationYTargetRadians = undo ? undoDataSet.OldCameraRotationYRadians : undoDataSet.NewCameraRotationYRadians;
+                Camera.SetRotation(
+                    undo ? undoDataSet.OldCameraRotationXRadians : undoDataSet.NewCameraRotationXRadians,
+                    undo ? undoDataSet.OldCameraRotationYRadians : undoDataSet.NewCameraRotationYRadians);
             }
         }
 
@@ -370,6 +386,15 @@ public enum UndoEvent
         WorldObjectChanged,
     }
 
+    public enum EditorState
+    {
+        Default = 0,
+        ObjectSelected,
+        ObjectMovingX,
+        ObjectMovingY,
+        ObjectMovingZ,
+    }
+
     public class SceneViewerHwndHost : HwndHost
     {
         readonly IntPtr HwndChildHandle;
diff --git a/Source/RunActivity/Viewer3D/EditorPrimitives.cs b/Source/RunActivity/Viewer3D/EditorPrimitives.cs
@@ -22,8 +22,6 @@
 using ORTS.Common;
 using System;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Linq;
 
 namespace Orts.Viewer3D
@@ -50,10 +48,10 @@ public class EditorShapes : StaticShape, IDisposable
 
         public EditorShapes(Viewer viewer) : base(viewer, "", null, ShapeFlags.None, null, -1)
         {
-            MouseCrosshair = new MouseCrosshair(Viewer, Color.GreenYellow);
+            MouseCrosshair = new MouseCrosshair(Viewer, Color.GreenYellow, Color.Red, Color.Cyan);
             HandleX = new HandleX(Viewer, Color.Red);
             HandleY = new HandleY(Viewer, Color.Blue);
-            HandleZ = new HandleZ(Viewer, Color.Green);
+            HandleZ = new HandleZ(Viewer, Color.LightGreen);
         }
 
         public override void PrepareFrame(RenderFrame frame, ElapsedTime elapsedTime)
@@ -189,26 +187,54 @@ public override void Draw(GraphicsDevice graphicsDevice)
     }
 
     [CallOnThread("Loader")]
-    public class BoundingBoxPrimitive : EditorPrimitive
+    public class BoxPrimitive : EditorPrimitive
     {
-        static IndexBuffer BoundingBoxIndexBuffer;
-        public readonly Matrix ComplexTransform;
+        static IndexBuffer BoxIndexBuffer;
 
-        public BoundingBoxPrimitive(Viewer viewer, BoundingBox boundingBox, Color color)
+        public BoxPrimitive(Viewer viewer, float size, Color color)
+            : this(viewer, new Vector3(-size / 2), new Vector3(size / 2), color)
+        {
+            Material = viewer.MaterialManager.Load("EditorPrimitive");
+            if (BoxIndexBuffer == null)
+            {
+                var indexData = new short[] { 2, 3, 6, 7, 5, 3, 1, 2, 0, 6, 4, 5, 0, 1 };
+                BoxIndexBuffer = new IndexBuffer(viewer.GraphicsDevice, typeof(short), indexData.Length, BufferUsage.WriteOnly);
+                BoxIndexBuffer.SetData(indexData);
+            }
+            IndexBuffer = BoxIndexBuffer;
+            PrimitiveCount = IndexBuffer.IndexCount - 2;
+            PrimitiveType = PrimitiveType.TriangleStrip;
+        }
+
+        protected BoxPrimitive(Viewer viewer, Vector3 min, Vector3 max, Color color)
         {
             var vertexData = new VertexPositionColor[]
             {
-                new VertexPositionColor(boundingBox.Min, color),
-                new VertexPositionColor(new Vector3(boundingBox.Min.X, boundingBox.Min.Y, boundingBox.Max.Z), color),
-                new VertexPositionColor(new Vector3(boundingBox.Min.X, boundingBox.Max.Y, boundingBox.Min.Z), color),
-                new VertexPositionColor(new Vector3(boundingBox.Min.X, boundingBox.Max.Y, boundingBox.Max.Z), color),
-                new VertexPositionColor(new Vector3(boundingBox.Max.X, boundingBox.Min.Y, boundingBox.Min.Z), color),
-                new VertexPositionColor(new Vector3(boundingBox.Max.X, boundingBox.Min.Y, boundingBox.Max.Z), color),
-                new VertexPositionColor(new Vector3(boundingBox.Max.X, boundingBox.Max.Y, boundingBox.Min.Z), color),
-                new VertexPositionColor(boundingBox.Max, color)
+                new VertexPositionColor(min, color),
+                new VertexPositionColor(new Vector3(min.X, min.Y, max.Z), color),
+                new VertexPositionColor(new Vector3(min.X, max.Y, min.Z), color),
+                new VertexPositionColor(new Vector3(min.X, max.Y, max.Z), color),
+                new VertexPositionColor(new Vector3(max.X, min.Y, min.Z), color),
+                new VertexPositionColor(new Vector3(max.X, min.Y, max.Z), color),
+                new VertexPositionColor(new Vector3(max.X, max.Y, min.Z), color),
+                new VertexPositionColor(max, color)
             };
             VertexBuffer = new VertexBuffer(viewer.GraphicsDevice, typeof(VertexPositionColor), vertexData.Length, BufferUsage.WriteOnly);
             VertexBuffer.SetData(vertexData);
+        }
+    }
+
+    [CallOnThread("Loader")]
+    public class BoundingBoxPrimitive : BoxPrimitive
+    {
+        static IndexBuffer BoundingBoxIndexBuffer;
+        public readonly Matrix ComplexTransform;
+
+        public BoundingBoxPrimitive(Viewer viewer, BoundingBox boundingBox, Color color)
+            : base(viewer, boundingBox.Min, boundingBox.Max, color)
+        {
+            Material = viewer.MaterialManager.Load("EditorPrimitive");
+            ComplexTransform = boundingBox.ComplexTransform;
             if (BoundingBoxIndexBuffer == null)
             {
                 var indexData = new short[] { 0, 1, 0, 2, 0, 4, 1, 3, 1, 5, 2, 3, 2, 6, 3, 7, 4, 5, 4, 6, 5, 7, 6, 7 };
@@ -218,23 +244,21 @@ public BoundingBoxPrimitive(Viewer viewer, BoundingBox boundingBox, Color color)
             IndexBuffer = BoundingBoxIndexBuffer;
             PrimitiveCount = IndexBuffer.IndexCount / 2;
             PrimitiveType = PrimitiveType.LineList;
-            Material = viewer.MaterialManager.Load("EditorPrimitive");
-            ComplexTransform = boundingBox.ComplexTransform;
         }
     }
 
     [CallOnThread("Loader")]
     public class MouseCrosshair : EditorPrimitive
     {
-        public MouseCrosshair(Viewer viewer, Color color)
+        public MouseCrosshair(Viewer viewer, Color color, Color northColor, Color southColor)
         {
             var vertexData = new VertexPositionColor[]
             {
                 new VertexPositionColor(new Vector3(-5, 0, 0), color),
                 new VertexPositionColor(new Vector3(5, 0, 0), color),
-                new VertexPositionColor(new Vector3(0, 0, -5), Color.Red),
-                new VertexPositionColor(new Vector3(0, 0, 5), Color.Cyan),
-                new VertexPositionColor(new Vector3(0, 0, 0), color),
+                new VertexPositionColor(new Vector3(0, 0, -5), northColor),
+                new VertexPositionColor(new Vector3(0, 0, 5), southColor),
+                new VertexPositionColor(new Vector3(0, -5, 0), color),
                 new VertexPositionColor(new Vector3(0, 20, 0), color)
             };
             VertexBuffer = new VertexBuffer(viewer.GraphicsDevice, typeof(VertexPositionColor), vertexData.Length, BufferUsage.WriteOnly);
@@ -253,54 +277,40 @@ public HandleX(Viewer viewer, Color color)
             var vertexData = GetVertexData(color);
             VertexBuffer = new VertexBuffer(viewer.GraphicsDevice, typeof(VertexPositionColor), vertexData.Length, BufferUsage.WriteOnly);
             VertexBuffer.SetData(vertexData);
-            PrimitiveCount = VertexBuffer.VertexCount / 2;
-            PrimitiveType = PrimitiveType.TriangleList;
+            PrimitiveCount = VertexBuffer.VertexCount - 2;
+            PrimitiveType = PrimitiveType.TriangleStrip;
             Material = viewer.MaterialManager.Load("EditorPrimitive");
         }
 
         protected virtual VertexPositionColor[] GetVertexData(Color color) => GetVertexData(0, 1, 2, color);
         protected VertexPositionColor[] GetVertexData(int x, int y, int z, Color color)
         {
-            var l = 5f;
-            var d = 0.1f;
-            var a = l / 5;
-            var b = a / 4;
+            var l = 5f; // total length, meter
+            var d = 0.1f; // shaft half thickness
+            var a = l / 5; // arrow head length
+            var b = a / 4; // arrow head half thickness
             var c = l - a;
             var data = new float[][]
             {
-                new[] { 0, +d, 0 },
-                new[] { c, +d, 0 },
-                new[] { 0, -d, 0 },
+                // Arrow shaft
+                new[] { 0, d, 0 },
+                new[] { c, d, 0 },
+                new[] { 0, 0, d },
+                new[] { c, 0, d },
                 new[] { 0, -d, 0 },
-                new[] { c, +d, 0 },
                 new[] { c, -d, 0 },
-
-                new[] { 0, 0, +d },
-                new[] { c, 0, +d },
-                new[] { 0, 0, -d },
                 new[] { 0, 0, -d },
-                new[] { c, 0, +d },
                 new[] { c, 0, -d },
 
-                new[] { l,      0, 0 },
-                new[] { l - a, +b, +b },
-                new[] { l - a, -b, +b },
-                new[] { l,      0, 0 },
-                new[] { l - a, -b, +b },
-                new[] { l - a, -b, -b },
-                new[] { l,      0, 0 },
-                new[] { l - a, -b, -b },
-                new[] { l - a, +b, -b },
-                new[] { l,      0, 0 },
-                new[] { l - a, +b, -b },
-                new[] { l - a, +b, +b },
-
-                new[] { l - a, +b, +b },
-                new[] { l - a, +b, -b },
-                new[] { l - a, -b, -b },
-                new[] { l - a, -b, -b },
-                new[] { l - a, +b, -b },
-                new[] { l - a, -b, +b },
+                // Arrow head
+                new[] { l, 0, 0 },
+                new[] { c, +b, +b },
+                new[] { c, -b, +b },
+                new[] { c, -b, -b },
+                new[] { l, 0, 0 },
+                new[] { c, +b, -b },
+                new[] { c, +b, +b },
+                new[] { c, -b, -b },
             };
             var vertexData = new VertexPositionColor[data.Length];
             for (var i = 0; i < data.Length; i++)

Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,7 @@ public class SceneViewer`
`58`	`58`	`OrbitingCamera Camera;`
`59`	`59`	`Stack<UndoDataSet> UndoStack = new Stack<UndoDataSet>();`
`60`	`60`	`Stack<UndoDataSet> RedoStack = new Stack<UndoDataSet>();`
	`61`	`+ EditorState EditorState;`
`61`	`62`
`62`	`63`	`/// <summary>The command-line arguments</summary>`
`63`	`64`	`private string[] CommandLineArgs;`
`@@ -126,19 +127,27 @@ public void Update(GameTime gameTime)`
`126`	`127`	`{`
`127`	`128`	`SelectedObject = selectedObject;`
`128`	`129`	`SelectedObjectChanged();`
	`130`	`+ EditorState = EditorState.ObjectSelected;`
`129`	`131`	`}`
`130`	`132`	`}`
`131`	`133`	`if (UserInput.IsPressed(UserCommand.EditorUnselectAll))`
`132`	`134`	`{`
`133`		`- SelectedObject = null;`
`134`		`- SelectedObjectChanged();`
	`135`	`+ if (EditorState == EditorState.ObjectSelected \|\| EditorState == EditorState.Default)`
	`136`	`+ {`
	`137`	`+ SetDefaultMode();`
	`138`	`+ }`
`135`	`139`	`}`
`136`	`140`	`if (UserInput.IsPressed(UserCommand.EditorUndo))`
`137`	`141`	`{`
`138`		`- UndoCommand();`
	`142`	`+ if (EditorState == EditorState.ObjectSelected \|\| EditorState == EditorState.Default)`
	`143`	`+ {`
	`144`	`+ SetDefaultMode();`
	`145`	`+ UndoCommand();`
	`146`	`+ }`
`139`	`147`	`}`
`140`	`148`	`if (UserInput.IsPressed(UserCommand.EditorRedo))`
`141`	`149`	`{`
	`150`	`+ SetDefaultMode();`
`142`	`151`	`RedoCommand();`
`143`	`152`	`}`
`144`	`153`
`@@ -198,12 +207,12 @@ public async Task SetCameraLocation()`
`198`	`207`	`mouseLocation.Location.Y = elevatedLocation + 15;`
`199`	`208`	`Camera.SetLocation(mouseLocation);`
`200`	`209`
`201`		`- var lastView = UndoStack.Count > 0 ? UndoStack.Last(s => s.UndoEvent == UndoEvent.ViewChanged) :`
	`210`	`+ var lastView = UndoStack.Count > 0 ? UndoStack.First(s => s.UndoEvent == UndoEvent.ViewChanged) :`
`202`	`211`	`new UndoDataSet()`
`203`	`212`	`{`
`204`		`- OldCameraLocation = Camera.CameraWorldLocation,`
`205`		`- OldCameraRotationXRadians = Camera.GetRotationX(),`
`206`		`- OldCameraRotationYRadians = Camera.GetRotationY(),`
	`213`	`+ NewCameraLocation = Camera.CameraWorldLocation,`
	`214`	`+ NewCameraRotationXRadians = Camera.GetRotationX(),`
	`215`	`+ NewCameraRotationYRadians = Camera.GetRotationY(),`
`207`	`216`	`};`
`208`	`217`
`209`	`218`	`UndoStack.Push(new UndoDataSet()`
`@@ -222,12 +231,16 @@ void UpdateViewUndoState()`
`222`	`231`	`{`
`223`	`232`	`if (UndoStack.Count == 0)`
`224`	`233`	`return;`
	`234`	`+`
	`235`	`+ var lastView = UndoStack.First(s => s.UndoEvent == UndoEvent.ViewChanged);`
	`236`	`+`
	`237`	`+ if (Camera.GetRotationX() == lastView.NewCameraRotationXRadians && Camera.GetRotationY() == lastView.NewCameraRotationYRadians && Camera.CameraWorldLocation == lastView.NewCameraLocation)`
	`238`	`+ return;`
`225`	`239`
`226`		`- var lastView = UndoStack.Last(s => s.UndoEvent == UndoEvent.ViewChanged);`
`227`		`- if (lastView == UndoStack.Last())`
	`240`	`+ if (UndoStack.First().UndoEvent == UndoEvent.ViewChanged) // then updatable`
`228`	`241`	`{`
`229`		`- if (lastView.NewCameraLocation == lastView.OldCameraLocation && (Camera.GetRotationX() != lastView.NewCameraRotationXRadians \|\| Camera.GetRotationY() != lastView.NewCameraRotationYRadians)`
`230`		`- \|\| lastView.NewCameraLocation != lastView.OldCameraLocation && Camera.CameraWorldLocation == lastView.NewCameraLocation)`
	`242`	`+ if ((Camera.GetRotationX() == lastView.NewCameraRotationXRadians && Camera.GetRotationY() == lastView.NewCameraRotationYRadians) ^`
	`243`	`+ (lastView.NewCameraRotationXRadians != lastView.OldCameraRotationXRadians \|\| lastView.NewCameraRotationYRadians != lastView.OldCameraRotationYRadians))`
`231`	`244`	`{`
`232`	`245`	`// Group rotations and pan-zooms by just updating the last action`
`233`	`246`	`lastView.NewCameraRotationXRadians = Camera.GetRotationX();`
`@@ -237,7 +250,7 @@ void UpdateViewUndoState()`
`237`	`250`	`return;`
`238`	`251`	`}`
`239`	`252`	`}`
`240`		`- if (Camera.GetRotationX() != lastView.NewCameraRotationXRadians \|\| Camera.GetRotationY() != lastView.NewCameraRotationYRadians \|\| Camera.CameraWorldLocation == lastView.NewCameraLocation)`
	`253`	`+ if (Camera.GetRotationX() != lastView.NewCameraRotationXRadians \|\| Camera.GetRotationY() != lastView.NewCameraRotationYRadians \|\| Camera.CameraWorldLocation != lastView.NewCameraLocation)`
`241`	`254`	`{`
`242`	`255`	`UndoStack.Push(new UndoDataSet()`
`243`	`256`	`{`
`@@ -253,19 +266,21 @@ void UpdateViewUndoState()`
`253`	`266`	`}`
`254`	`267`	`}`
`255`	`268`
	`269`	`+ void SetDefaultMode()`
	`270`	`+ {`
	`271`	`+ SelectedObject = null;`
	`272`	`+ SelectedObjectChanged();`
	`273`	`+ EditorState = EditorState.Default;`
	`274`	`+ }`
	`275`	`+`
`256`	`276`	`void UndoCommand()`
`257`	`277`	`{`
`258`		`- UndoDataSet undoDataSet;`
`259`	`278`	`if (UndoStack.Count > 1)`
`260`	`279`	`{`
`261`		`- undoDataSet = UndoStack.Pop();`
	`280`	`+ var undoDataSet = UndoStack.Pop();`
`262`	`281`	`RedoStack.Push(undoDataSet);`
	`282`	`+ UndoRedo(undoDataSet, true);`
`263`	`283`	`}`
`264`		`- else`
`265`		`- {`
`266`		`- undoDataSet = UndoStack.Peek();`
`267`		`- }`
`268`		`- UndoRedo(undoDataSet, true);`
`269`	`284`	`}`
`270`	`285`
`271`	`286`	`void RedoCommand()`
`@@ -283,8 +298,9 @@ void UndoRedo(UndoDataSet undoDataSet, bool undo)`
`283`	`298`	`if (undoDataSet.UndoEvent == UndoEvent.ViewChanged)`
`284`	`299`	`{`
`285`	`300`	`Camera.SetLocation(undo ? undoDataSet.OldCameraLocation : undoDataSet.NewCameraLocation);`
`286`		`- Camera.RotationXTargetRadians = undo ? undoDataSet.OldCameraRotationXRadians : undoDataSet.NewCameraRotationXRadians;`
`287`		`- Camera.RotationYTargetRadians = undo ? undoDataSet.OldCameraRotationYRadians : undoDataSet.NewCameraRotationYRadians;`
	`301`	`+ Camera.SetRotation(`
	`302`	`+ undo ? undoDataSet.OldCameraRotationXRadians : undoDataSet.NewCameraRotationXRadians,`
	`303`	`+ undo ? undoDataSet.OldCameraRotationYRadians : undoDataSet.NewCameraRotationYRadians);`
`288`	`304`	`}`
`289`	`305`	`}`
`290`	`306`
`@@ -370,6 +386,15 @@ public enum UndoEvent`
`370`	`386`	`WorldObjectChanged,`
`371`	`387`	`}`
`372`	`388`
	`389`	`+ public enum EditorState`
	`390`	`+ {`
	`391`	`+ Default = 0,`
	`392`	`+ ObjectSelected,`
	`393`	`+ ObjectMovingX,`
	`394`	`+ ObjectMovingY,`
	`395`	`+ ObjectMovingZ,`
	`396`	`+ }`
	`397`	`+`
`373`	`398`	`public class SceneViewerHwndHost : HwndHost`
`374`	`399`	`{`
`375`	`400`	`readonly IntPtr HwndChildHandle;`