Merge branch 'FlaxEngine:master' into flax-msdf-font

Source/Editor/CustomEditors/Dedicated/NavMeshBoundsVolumeEditor.cs

@@ -0,0 +1,38 @@
+// Copyright (c) Wojciech Figat. All rights reserved.
+
+using FlaxEngine;
+
+namespace FlaxEditor.CustomEditors.Dedicated
+{
+    /// <summary>
+    /// Custom editor for <see cref="NavMeshBoundsVolume"/>.
+    /// </summary>
+    /// <seealso cref="ActorEditor" />
+    [CustomEditor(typeof(NavMeshBoundsVolume)), DefaultEditor]
+    internal class NavMeshBoundsVolumeEditor : ActorEditor
+    {
+        /// <inheritdoc />
+        public override void Initialize(LayoutElementsContainer layout)
+        {
+            base.Initialize(layout);
+
+            if (Values.HasDifferentTypes == false)
+            {
+                var button = layout.Button("Build");
+                button.Button.Clicked += OnBuildClicked;
+            }
+        }
+
+        private void OnBuildClicked()
+        {
+            foreach (var value in Values)
+            {
+                if (value is NavMeshBoundsVolume volume)
+                {
+                    Navigation.BuildNavMesh(volume.Box, volume.Scene);
+                    Editor.Instance.Scene.MarkSceneEdited(volume.Scene);
+                }
+            }
+        }
+    }
+}

Source/Editor/CustomEditors/Editors/CollectionEditor.cs

@@ -593,11 +593,12 @@ namespace FlaxEditor.CustomEditors.Editors
                 panel.Panel.Offsets = new Margin(7, 7, 0, 0);
                 panel.Panel.BackgroundColor = _background;
                 var elementType = ElementType;
+                var bindingAttr = System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public;
                 bool single = elementType.IsPrimitive ||
                               elementType.Equals(new ScriptType(typeof(string))) ||
                               elementType.IsEnum ||
-                              (elementType.GetFields().Length == 1 && elementType.GetProperties().Length == 0) ||
-                              (elementType.GetProperties().Length == 1 && elementType.GetFields().Length == 0) ||
+                              (elementType.GetFields(bindingAttr).Length == 1 && elementType.GetProperties(bindingAttr).Length == 0) ||
+                              (elementType.GetProperties(bindingAttr).Length == 1 && elementType.GetFields(bindingAttr).Length == 0) ||
                               elementType.Equals(new ScriptType(typeof(JsonAsset))) ||
                               elementType.Equals(new ScriptType(typeof(SettingsBase)));
                 if (_cachedDropPanels == null)

Source/Editor/Editor.cs

@@ -23,6 +23,7 @@ using FlaxEngine.Assertions;
 using FlaxEngine.GUI;
 using FlaxEngine.Interop;
 using FlaxEngine.Json;
+using FlaxEngine.Utilities;
 
 #pragma warning disable CS1591
 
@@ -1370,7 +1371,7 @@ namespace FlaxEditor
         public void BuildCSG()
         {
             var scenes = Level.Scenes;
-            scenes.ToList().ForEach(x => x.BuildCSG(0));
+            scenes.ForEach(x => x.BuildCSG(0));
             Scene.MarkSceneEdited(scenes);
         }
 
@@ -1380,7 +1381,7 @@ namespace FlaxEditor
         public void BuildNavMesh()
         {
             var scenes = Level.Scenes;
-            scenes.ToList().ForEach(x => Navigation.BuildNavMesh(x, 0));
+            Navigation.BuildNavMesh();
             Scene.MarkSceneEdited(scenes);
         }
 

Source/Editor/GUI/ContextMenu/ContextMenu.cs

@@ -502,6 +502,7 @@ namespace FlaxEditor.GUI.ContextMenu
             if (base.OnKeyDown(key))
                 return true;
 
+            // Keyboard navigation around the menu
             switch (key)
             {
             case KeyboardKeys.ArrowDown:
@@ -526,6 +527,20 @@ namespace FlaxEditor.GUI.ContextMenu
                     }
                 }
                 break;
+            case KeyboardKeys.ArrowRight:
+                for (int i = 0; i < _panel.Children.Count; i++)
+                {
+                    if (_panel.Children[i] is ContextMenuChildMenu item && item.Visible && item.IsFocused && !item.ContextMenu.IsOpened)
+                    {
+                        item.ShowChild(this);
+                        item.ContextMenu._panel.Children.FirstOrDefault(x => x is ContextMenuButton && x.Visible)?.Focus();
+                        break;
+                    }
+                }
+                break;
+            case KeyboardKeys.ArrowLeft:
+                ParentCM?.RootWindow.Focus();
+                break;
             }
 
             return false;

Source/Editor/GUI/ContextMenu/ContextMenuBase.cs

@@ -72,6 +72,11 @@ namespace FlaxEditor.GUI.ContextMenu
         /// </summary>
         public bool HasChildCMOpened => _childCM != null;
 
+        /// <summary>
+        /// Gets the parent context menu (if exists).
+        /// </summary>
+        public ContextMenuBase ParentCM => _parentCM;
+
         /// <summary>
         /// Gets the topmost context menu.
         /// </summary>
@@ -81,9 +86,7 @@ namespace FlaxEditor.GUI.ContextMenu
             {
                 var cm = this;
                 while (cm._parentCM != null && cm._isSubMenu)
-                {
                     cm = cm._parentCM;
-                }
                 return cm;
             }
         }
@@ -108,6 +111,11 @@ namespace FlaxEditor.GUI.ContextMenu
         /// </summary>
         public bool UseInput = true;
 
+        /// <summary>
+        /// Optional flag that can disable UI navigation (tab/enter).
+        /// </summary>
+        public bool UseNavigation = true;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="ContextMenuBase"/> class.
         /// </summary>
@@ -594,6 +602,21 @@ namespace FlaxEditor.GUI.ContextMenu
             case KeyboardKeys.Escape:
                 Hide();
                 return true;
+            case KeyboardKeys.Return:
+                if (UseNavigation && Root?.FocusedControl != null)
+                {
+                    Root.SubmitFocused();
+                    return true;
+                }
+                break;
+            case KeyboardKeys.Tab:
+                if (UseNavigation && Root != null)
+                {
+                    bool shiftDown = Root.GetKey(KeyboardKeys.Shift);
+                    Root.Navigate(shiftDown ? NavDirection.Previous : NavDirection.Next);
+                    return true;
+                }
+                break;
             }
             return false;
         }

Source/Editor/GUI/ContextMenu/ContextMenuChildMenu.cs

@@ -29,7 +29,7 @@ namespace FlaxEditor.GUI.ContextMenu
             CloseMenuOnClick = false;
         }
 
-        private void ShowChild(ContextMenu parentContextMenu)
+        internal void ShowChild(ContextMenu parentContextMenu)
         {
             // Hide parent CM popups and set itself as child
             var vAlign = parentContextMenu.ItemsAreaMargin.Top;

Source/Editor/GUI/CurveEditor.Contents.cs

@@ -522,6 +522,16 @@ namespace FlaxEditor.GUI
                             cm.AddButton("Show whole curve", _editor.ShowWholeCurve);
                             cm.AddButton("Reset view", _editor.ResetView);
                         }
+                        cm.AddSeparator();
+                        var presetCm = cm.AddChildMenu("Apply preset");
+                        foreach (var value in Enum.GetValues(typeof(CurvePreset)))
+                        {
+                            CurvePreset preset = (CurvePreset)value;
+                            string name = Utilities.Utils.GetPropertyNameUI(preset.ToString());
+                            var b = presetCm.ContextMenu.AddButton(name, () => _editor.ApplyPreset(preset));
+                            b.Enabled = !(_editor is LinearCurveEditor<T> && (preset != CurvePreset.Constant && preset != CurvePreset.Linear));
+                        }
+                        
                         _editor.OnShowContextMenu(cm, selectionCount);
                         cm.Show(this, location);
                     }
@@ -619,6 +629,33 @@ namespace FlaxEditor.GUI
             }
         }
 
+        /// <summary>
+        /// A list of avaliable curve presets for the <see cref="CurveEditor{T}"/>.
+        /// </summary>
+        public enum CurvePreset
+        {
+            /// <summary>
+            /// A curve where every point has the same value.
+            /// </summary>
+            Constant,
+            /// <summary>
+            /// A curve linear curve.
+            /// </summary>
+            Linear,
+            /// <summary>
+            /// A curve that starts a slowly and then accelerates until the end.
+            /// </summary>
+            EaseIn,
+            /// <summary>
+            /// A curve that starts a steep and then flattens until the end.
+            /// </summary>
+            EaseOut,
+            /// <summary>
+            /// A combination of the <see cref="CurvePreset.EaseIn"/> and <see cref="CurvePreset.EaseOut"/> preset.
+            /// </summary>
+            Smoothstep
+        }
+
         /// <inheritdoc />
         public override void OnKeyframesDeselect(IKeyframesEditor editor)
         {

Source/Editor/GUI/CurveEditor.cs

@@ -19,6 +19,48 @@ namespace FlaxEditor.GUI
     /// <seealso cref="CurveEditorBase" />
     public abstract partial class CurveEditor<T> : CurveEditorBase where T : new()
     {
+        /// <summary>
+        /// Represents a single point in a <see cref="CurveEditorPreset"/>.
+        /// </summary>
+        protected struct CurvePresetPoint
+        {
+            /// <summary>
+            /// The time.
+            /// </summary>
+            public float Time;
+
+            /// <summary>
+            /// The value.
+            /// </summary>
+            public float Value;
+
+            /// <summary>
+            /// The in tangent. Will be ignored in <see cref="LinearCurveEditor{T}"/>
+            /// </summary>
+            public float TangentIn;
+
+            /// <summary>
+            /// The out tangent. Will be ignored in <see cref="LinearCurveEditor{T}"/>
+            /// </summary>
+            public float TangentOut;
+        }
+
+        /// <summary>
+        /// A curve preset.
+        /// </summary>
+        protected struct CurveEditorPreset()
+        {
+            /// <summary>
+            /// If the tangents will be linear or smooth.
+            /// </summary>
+            public bool LinearTangents;
+
+            /// <summary>
+            /// The points of the preset.
+            /// </summary>
+            public List<CurvePresetPoint> Points;
+        }
+
         private class Popup : ContextMenuBase
         {
             private CustomEditorPresenter _presenter;
@@ -26,11 +68,12 @@ namespace FlaxEditor.GUI
             private List<int> _keyframeIndices;
             private bool _isDirty;
 
-            public Popup(CurveEditor<T> editor, object[] selection, List<int> keyframeIndices = null, float height = 140.0f)
-            : this(editor, height)
+            public Popup(CurveEditor<T> editor, object[] selection, List<int> keyframeIndices = null, float maxHeight = 140.0f)
+            : this(editor, maxHeight)
             {
                 _presenter.Select(selection);
                 _presenter.OpenAllGroups();
+                Size = new Float2(Size.X, Mathf.Min(_presenter.ContainerControl.Size.Y, maxHeight));
                 _keyframeIndices = keyframeIndices;
                 if (keyframeIndices != null && selection.Length != keyframeIndices.Count)
                     throw new Exception();
@@ -169,7 +212,7 @@ namespace FlaxEditor.GUI
                 if (IsSelected)
                     color = Editor.ContainsFocus ? style.SelectionBorder : Color.Lerp(style.ForegroundDisabled, style.SelectionBorder, 0.4f);
                 if (IsMouseOver)
-                    color *= 1.1f;
+                    color *= 1.5f;
                 Render2D.FillRectangle(rect, color);
             }
 
@@ -285,7 +328,7 @@ namespace FlaxEditor.GUI
         /// <summary>
         /// The keyframes size.
         /// </summary>
-        protected static readonly Float2 KeyframesSize = new Float2(7.0f);
+        protected static readonly Float2 KeyframesSize = new Float2(8.0f);
 
         /// <summary>
         /// The colors for the keyframe points.
@@ -326,6 +369,63 @@ namespace FlaxEditor.GUI
         private Color _labelsColor;
         private Font _labelsFont;
 
+        /// <summary>
+        /// Preset values for <see cref="CurvePreset"/> to be applied to a <see cref="CurveEditor{T}"/>.
+        /// </summary>
+        protected Dictionary<CurvePreset, CurveEditorPreset> Presets = new Dictionary<CurvePreset, CurveEditorPreset>
+        {
+            { CurvePreset.Constant, new CurveEditorPreset
+                {
+                    LinearTangents = true,
+                    Points = new List<CurvePresetPoint>
+                    {
+                        new CurvePresetPoint { Time = 0f, Value = 0.5f, TangentIn = 0f, TangentOut = 0f },
+                        new CurvePresetPoint { Time = 1f, Value = 0.5f, TangentIn = 0f, TangentOut = 0f },
+                    }
+                }
+            },
+            { CurvePreset.EaseIn, new CurveEditorPreset
+                {
+                    LinearTangents = false,
+                    Points = new List<CurvePresetPoint>
+                    {
+                        new CurvePresetPoint { Time = 0f, Value = 0f, TangentIn = 0f, TangentOut = 0f },
+                        new CurvePresetPoint { Time = 1f, Value = 1f, TangentIn = -1.4f, TangentOut = 0f },
+                    }
+                }
+            },
+            { CurvePreset.EaseOut, new CurveEditorPreset
+                {
+                    LinearTangents = false,
+                    Points = new List<CurvePresetPoint>
+                    {
+                        new CurvePresetPoint { Time = 1f, Value = 1f, TangentIn = 0f, TangentOut = 0f },
+                        new CurvePresetPoint { Time = 0f, Value = 0f, TangentIn = 0f, TangentOut = 1.4f },
+                    }
+                }
+            },
+            { CurvePreset.Linear, new CurveEditorPreset
+                {
+                    LinearTangents = true,
+                    Points = new List<CurvePresetPoint>
+                    {
+                        new CurvePresetPoint { Time = 0f, Value = 0f, TangentIn = 0f, TangentOut = 0f },
+                        new CurvePresetPoint { Time = 1f, Value = 1f, TangentIn = 0f, TangentOut = 0f },
+                    }
+                }
+            },
+            { CurvePreset.Smoothstep, new CurveEditorPreset
+                {
+                    LinearTangents = false,
+                    Points = new List<CurvePresetPoint>
+                    {
+                        new CurvePresetPoint { Time = 0f, Value = 0f, TangentIn = 0f, TangentOut = 0f },
+                        new CurvePresetPoint { Time = 1f, Value = 1f, TangentIn = 0f, TangentOut = 0f },
+                    }
+                }
+            },
+        };
+
         /// <summary>
         /// The keyframe UI points.
         /// </summary>
@@ -568,6 +668,28 @@ namespace FlaxEditor.GUI
         /// <param name="indicesToRemove">The list of indices of the keyframes to remove.</param>
         protected abstract void RemoveKeyframesInternal(HashSet<int> indicesToRemove);
 
+        /// <summary>
+        /// Tries to convert a float to the type of the type wildcard of the curve editor.
+        /// </summary>
+        /// <param name="value">The float.</param>
+        /// <returns>The converted value.</returns>
+        public static object ConvertCurvePresetValueToCurveEditorType(float value)
+        {
+            if (typeof(T) == typeof(Float2))
+                return new Float2(value);
+            if (typeof(T) == typeof(Float3))
+                return new Float3(value);
+            if (typeof(T) == typeof(Float4))
+                return new Float4(value);
+            if (typeof(T) == typeof(Vector2))
+                return new Vector2(value);
+            if (typeof(T) == typeof(Vector3))
+                return new Vector3(value);
+            if (typeof(T) == typeof(Vector4))
+                return new Vector4(value);
+            return value;
+        }
+
         /// <summary>
         /// Called when showing a context menu. Can be used to add custom buttons with actions.
         /// </summary>
@@ -752,6 +874,17 @@ namespace FlaxEditor.GUI
             ShowCurve(false);
         }
 
+        /// <summary>
+        /// Applies a <see cref="CurvePreset"/> to the curve editor.
+        /// </summary>
+        /// <param name="preset">The preset.</param>
+        public virtual void ApplyPreset(CurvePreset preset)
+        {
+            // Remove existing keyframes
+            SelectAll();
+            RemoveKeyframes();
+        }
+
         /// <inheritdoc />
         public override void Evaluate(out object result, float time, bool loop = false)
         {
@@ -1028,6 +1161,31 @@ namespace FlaxEditor.GUI
                 return true;
             }
 
+            bool left = key == KeyboardKeys.ArrowLeft;
+            bool right = key == KeyboardKeys.ArrowRight;
+            bool up = key == KeyboardKeys.ArrowUp;
+            bool down = key == KeyboardKeys.ArrowDown;
+
+            if (left || right || up || down)
+            {
+                bool shift = Root.GetKey(KeyboardKeys.Shift);
+                bool alt = Root.GetKey(KeyboardKeys.Alt);
+                float deltaValue = 10f;
+                if (shift || alt)
+                    deltaValue = shift ? 2.5f : 5f;
+
+                Float2 moveDelta = Float2.Zero;
+                if (left || right)
+                    moveDelta.X = left ? -deltaValue : deltaValue;
+                if (up || down)
+                    moveDelta.Y = up ? -deltaValue : deltaValue;
+
+                _contents.OnMoveStart(Float2.Zero);
+                _contents.OnMove(moveDelta);
+                _contents.OnMoveEnd(Float2.Zero);
+                return true;
+            }
+
             return false;
         }
 
@@ -1526,6 +1684,22 @@ namespace FlaxEditor.GUI
                 _tangents[i].Visible = false;
         }
 
+        /// <inheritdoc />
+        public override void ApplyPreset(CurvePreset preset)
+        {
+            base.ApplyPreset(preset);
+
+            CurveEditorPreset data = Presets[preset];
+            foreach (var point in data.Points)
+            {
+                float time = point.Time;
+                object value = ConvertCurvePresetValueToCurveEditorType((float)point.Value);
+                AddKeyframe(time, value);
+            }
+
+            ShowWholeCurve();
+        }
+
         /// <inheritdoc />
         protected override void DrawCurve(ref Rectangle viewRect)
         {
@@ -2312,6 +2486,30 @@ namespace FlaxEditor.GUI
             }
         }
 
+        /// <inheritdoc />
+        public override void ApplyPreset(CurvePreset preset)
+        {
+            base.ApplyPreset(preset);
+
+            CurveEditorPreset data = Presets[preset];
+
+            foreach (var point in data.Points)
+            {
+                float time = point.Time;
+                object value = ConvertCurvePresetValueToCurveEditorType((float)point.Value);
+                object tangentIn = ConvertCurvePresetValueToCurveEditorType((float)point.TangentIn);
+                object tangentOut = ConvertCurvePresetValueToCurveEditorType((float)point.TangentOut);
+
+                AddKeyframe(time, value, tangentIn, tangentOut);
+            }
+
+            SelectAll();
+            if (data.LinearTangents)
+                SetTangentsLinear();
+
+            ShowWholeCurve();
+        }
+
         /// <inheritdoc />
         protected override void SetScaleInternal(ref Float2 scale)
         {

Source/Editor/GUI/Docking/DockPanel.cs

@@ -469,7 +469,7 @@ namespace FlaxEditor.GUI.Docking
                     var childPanels = _childPanels.ToArray();
                     if (childPanels.Length != 0)
                     {
-                        // Move tabs from child panels into this one
+                        // Fallback: move tabs from child panels into this one.
                         DockWindow selectedTab = null;
                         foreach (var childPanel in childPanels)
                         {
@@ -490,7 +490,8 @@ namespace FlaxEditor.GUI.Docking
                     {
                         // Unlink splitter
                         var splitterParent = splitter.Parent;
-                        Assert.IsNotNull(splitterParent);
+                        if (splitterParent == null)
+                            return;
                         splitter.Parent = null;
 
                         // Move controls from second split panel to the split panel parent
@@ -507,17 +508,63 @@ namespace FlaxEditor.GUI.Docking
                         splitter.Dispose();
                     }
                 }
+                else if (IsMaster && _childPanels.Count != 0)
+                {
+                    if (TryCollapseSplitter(_tabsProxy?.Parent as Panel))
+                        return;
+                }
                 else if (!IsMaster)
                 {
                     throw new InvalidOperationException();
                 }
             }
+            else if (_childPanels.Count != 0)
+            {
+                if (TryCollapseSplitter(_tabsProxy?.Parent as Panel))
+                    return;
+            }
             else if (!IsMaster)
             {
                 throw new InvalidOperationException();
             }
         }
 
+        internal bool CollapseEmptyTabsProxy()
+        {
+            if (TabsCount == 0 && ChildPanelsCount > 0)
+            {
+                return TryCollapseSplitter(_tabsProxy?.Parent as Panel);
+            }
+            return false;
+        }
+
+        private bool TryCollapseSplitter(Panel removedPanelParent)
+        {
+            if (removedPanelParent == null)
+                return false;
+            if (!(removedPanelParent.Parent is SplitPanel tabsSplitter))
+                return false;
+
+            var splitterParent = tabsSplitter.Parent;
+            if (splitterParent == null)
+                return false;
+            tabsSplitter.Parent = null;
+
+            var scrPanel = removedPanelParent == tabsSplitter.Panel2 ? tabsSplitter.Panel1 : tabsSplitter.Panel2;
+            var srcPanelChildrenCount = scrPanel.ChildrenCount;
+            for (int i = srcPanelChildrenCount - 1; i >= 0 && scrPanel.ChildrenCount > 0; i--)
+            {
+                scrPanel.GetChild(i).Parent = splitterParent;
+            }
+            Assert.IsTrue(scrPanel.ChildrenCount == 0);
+            Assert.IsTrue(splitterParent.ChildrenCount == srcPanelChildrenCount);
+
+            tabsSplitter.Dispose();
+            if (_tabsProxy != null && _tabsProxy.Parent == removedPanelParent)
+                _tabsProxy = null;
+            return true;
+        }
+
         internal virtual void DockWindowInternal(DockState state, DockWindow window, bool autoSelect = true, float? splitterValue = null)
         {
             DockWindow(state, window, autoSelect, splitterValue);

Source/Editor/GUI/Tree/TreeNode.cs

@@ -1140,8 +1140,11 @@ namespace FlaxEditor.GUI.Tree
                         ParentTree.DraggedOverNode = this;
 
                     // Expand node if mouse goes over arrow
-                    if (ArrowRect.Contains(location) && HasAnyVisibleChild)
+                    if (ArrowRect.Contains(location) && HasAnyVisibleChild && IsCollapsed)
+                    {
                         Expand(true);
+                        ParentTree?.FlushPendingPerformLayout();
+                    }
 
                     result = OnDragEnterHeader(data);
                 }
@@ -1172,8 +1175,11 @@ namespace FlaxEditor.GUI.Tree
                         ParentTree.DraggedOverNode = this;
 
                     // Expand node if mouse goes over arrow
-                    if (ArrowRect.Contains(location) && HasAnyVisibleChild)
+                    if (ArrowRect.Contains(location) && HasAnyVisibleChild && IsCollapsed)
+                    {
                         Expand(true);
+                        ParentTree?.FlushPendingPerformLayout();
+                    }
 
                     if (!_isDragOverHeader)
                         result = OnDragEnterHeader(data);

Source/Editor/Gizmo/GizmoBase.cs

@@ -13,6 +13,7 @@ namespace FlaxEditor.Gizmo
     public abstract class GizmoBase
     {
         private IGizmoOwner _owner;
+        private bool _visible = true;
 
         /// <summary>
         /// Gets the gizmo owner.
@@ -34,6 +35,11 @@ namespace FlaxEditor.Gizmo
         /// </summary>
         public virtual BoundingSphere FocusBounds => BoundingSphere.Empty;
 
+        /// <summary>
+        /// Gets or sets a value indicating whether this gizmo is visible.
+        /// </summary>
+        public bool Visible { get { return _visible; } set { _visible = value; } }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="GizmoBase"/> class.
         /// </summary>

Source/Editor/Gizmo/ViewportRubberBandSelector.cs

@@ -36,11 +36,12 @@ public sealed class ViewportRubberBandSelector
     /// Triggers the start of a rubber band selection.
     /// </summary>
     /// <returns>True if selection started, otherwise false.</returns>
-    public bool TryStartingRubberBandSelection()
+    public bool TryStartingRubberBandSelection(Float2 mousePosition)
     {
         if (!_isRubberBandSpanning && _owner.Gizmos.Active != null && !_owner.Gizmos.Active.IsControllingMouse && !_owner.IsRightMouseButtonDown)
         {
             _tryStartRubberBand = true;
+            _cachedStartingMousePosition = mousePosition;
             return true;
         }
         return false;
@@ -82,12 +83,15 @@ public sealed class ViewportRubberBandSelector
             return;
         }
 
-        if (_tryStartRubberBand && (Mathf.Abs(_owner.MouseDelta.X) > 0.1f || Mathf.Abs(_owner.MouseDelta.Y) > 0.1f) && canStart)
+        if (_tryStartRubberBand && canStart)
         {
-            _isRubberBandSpanning = true;
-            _cachedStartingMousePosition = mousePosition;
-            _rubberBandRect = new Rectangle(_cachedStartingMousePosition, Float2.Zero);
-            _tryStartRubberBand = false;
+            var delta = mousePosition - _cachedStartingMousePosition;
+            if (Mathf.Abs(delta.X) > 0.1f || Mathf.Abs(delta.Y) > 0.1f)
+            {
+                _isRubberBandSpanning = true;
+                _rubberBandRect = new Rectangle(_cachedStartingMousePosition, Float2.Zero);
+                _tryStartRubberBand = false;
+            }
         }
         else if (_isRubberBandSpanning && _owner.Gizmos.Active != null && !_owner.Gizmos.Active.IsControllingMouse && !_owner.IsRightMouseButtonDown)
         {

Source/Editor/Modules/SceneEditingModule.cs

@@ -229,7 +229,7 @@ namespace FlaxEditor.Modules
             if (!isPlayMode && options.General.AutoRebuildNavMesh && actor.Scene && node.AffectsNavigationWithChildren)
             {
                 var bounds = actor.BoxWithChildren;
-                Navigation.BuildNavMesh(actor.Scene, bounds, options.General.AutoRebuildNavMeshTimeoutMs);
+                Navigation.BuildNavMesh(bounds, options.General.AutoRebuildNavMeshTimeoutMs);
             }
         }
 

Source/Editor/Modules/WindowsModule.cs

@@ -491,10 +491,15 @@ namespace FlaxEditor.Modules
                         Editor.LogWarning("Empty panel inside layout.");
                         p.RemoveIt();
                     }
+                    else
+                    {
+                        p.CollapseEmptyTabsProxy();
+                    }
                 }
             }
 
             panel.SelectTab(selectedTab);
+            panel.CollapseEmptyTabsProxy();
         }
 
         private static void SaveBounds(XmlWriter writer, Window win)

Source/Editor/Options/InputOptions.cs

@@ -387,6 +387,14 @@ namespace FlaxEditor.Options
         [EditorDisplay("Viewport"), EditorOrder(1760)]
         public InputBinding ToggleOrthographic = new InputBinding(KeyboardKeys.NumpadDecimal);
 
+        [DefaultValue(typeof(InputBinding), "G")]
+        [EditorDisplay("Viewport"), EditorOrder(1770)]
+        public InputBinding ToggleGameView = new InputBinding(KeyboardKeys.G);
+
+        [DefaultValue(typeof(InputBinding), "P")]
+        [EditorDisplay("Viewport"), EditorOrder(1770)]
+        public InputBinding ToggleNavMeshVisibility = new InputBinding(KeyboardKeys.P);
+
         #endregion
 
         #region Debug Views

Source/Editor/SceneGraph/Actors/SplineNode.cs

@@ -555,7 +555,7 @@ namespace FlaxEditor.SceneGraph.Actors
                 var options = Editor.Instance.Options.Options.General;
                 if (options.AutoRebuildNavMesh)
                 {
-                    Navigation.BuildNavMesh(collider.Scene, collider.Box, options.AutoRebuildNavMeshTimeoutMs);
+                    Navigation.BuildNavMesh(collider.Box, options.AutoRebuildNavMeshTimeoutMs);
                 }
             }
         }

Source/Editor/SceneGraph/Actors/StaticModelNode.cs

@@ -47,6 +47,11 @@ namespace FlaxEditor.SceneGraph.Actors
             }
         }
 
+        /// <summary>
+        /// Gets the model used by this actor.
+        /// </summary>
+        public Model Model => ((StaticModel)Actor).Model;
+
         /// <inheritdoc />
         public StaticModelNode(Actor actor)
         : base(actor)
@@ -120,12 +125,12 @@ namespace FlaxEditor.SceneGraph.Actors
         {
             base.OnContextMenu(contextMenu, window);
 
-            // Check if every selected node is a primitive
+            // Check if every selected node is a primitive or has collision asset
             var selection = GetSelection(window);
             bool autoOptionEnabled = true;
             foreach (var node in selection)
             {
-                if (node is StaticModelNode staticModelNode && !staticModelNode.IsPrimitive)
+                if (node is StaticModelNode staticModelNode && (!staticModelNode.IsPrimitive && GetCollisionData(staticModelNode.Model) == null))
                 {
                     autoOptionEnabled = false;
                     break;
@@ -201,6 +206,54 @@ namespace FlaxEditor.SceneGraph.Actors
             return Array.Empty<SceneGraphNode>();
         }
 
+        private static bool TryCollisionData(Model model, BinaryAssetItem assetItem, out CollisionData collisionData)
+        {
+            collisionData = FlaxEngine.Content.Load<CollisionData>(assetItem.ID);
+            if (collisionData)
+            {
+                var options = collisionData.Options;
+                if (options.Model == model.ID || options.Model == Guid.Empty)
+                    return true;
+            }
+            return false;
+        }
+
+        private CollisionData GetCollisionData(Model model)
+        {
+            if (model == null)
+                return null;
+
+            // Check if there already is collision data for that model to reuse
+            var modelItem = (AssetItem)Editor.Instance.ContentDatabase.Find(model.ID);
+            if (modelItem?.ParentFolder != null)
+            {
+                foreach (var child in modelItem.ParentFolder.Children)
+                {
+                    // Check if there is collision that was made with this model
+                    if (child is BinaryAssetItem b && b.IsOfType<CollisionData>())
+                    {
+                        if (TryCollisionData(model, b, out var collisionData))
+                            return collisionData;
+                    }
+
+                    // Check if there is an auto-imported collision
+                    if (child is ContentFolder childFolder && childFolder.ShortName == modelItem.ShortName)
+                    {
+                        foreach (var childFolderChild in childFolder.Children)
+                        {
+                            if (childFolderChild is BinaryAssetItem c && c.IsOfType<CollisionData>())
+                            {
+                                if (TryCollisionData(model, c, out var collisionData))
+                                    return collisionData;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return null;
+        }
+
         private void CreateAuto(StaticModel actor, Spawner spawner, bool singleNode)
         {
             // Special case for in-built Editor models that can use analytical collision
@@ -243,6 +296,15 @@ namespace FlaxEditor.SceneGraph.Actors
                 collider.LocalPosition = new Vector3(0, 50.0f, 0);
                 collider.LocalOrientation = Quaternion.Euler(0, 0, 90.0f);
             }
+            else
+            {
+                var collider = new MeshCollider
+                {
+                    Transform = actor.Transform,
+                    CollisionData = GetCollisionData(model),
+                };
+                spawner(collider);
+            }
         }
 
         private void CreateBox(StaticModel actor, Spawner spawner, bool singleNode)

Source/Editor/Surface/Archetypes/Material.cs

@@ -304,25 +304,14 @@ namespace FlaxEditor.Surface.Archetypes
             }
         }
 
-        internal sealed class CustomCodeNode : SurfaceNode
+        internal sealed class CustomCodeNode : ResizableSurfaceNode
         {
-            private Rectangle _resizeButtonRect;
-            private Float2 _startResizingSize;
-            private Float2 _startResizingCornerOffset;
-            private bool _isResizing;
             private CustomCodeTextBox _textBox;
 
-            private int SizeValueIndex => Archetype.TypeID == 8 ? 1 : 3; // Index of the Size stored in Values array
-
-            private Float2 SizeValue
-            {
-                get => (Float2)Values[SizeValueIndex];
-                set => SetValue(SizeValueIndex, value, false);
-            }
-
             public CustomCodeNode(uint id, VisjectSurfaceContext context, NodeArchetype nodeArch, GroupArchetype groupArch)
             : base(id, context, nodeArch, groupArch)
             {
+                _sizeValueIndex = Archetype.TypeID == 8 ? 1 : 3; // Index of the Size stored in Values array
                 Float2 pos = new Float2(FlaxEditor.Surface.Constants.NodeMarginX, FlaxEditor.Surface.Constants.NodeMarginY + FlaxEditor.Surface.Constants.NodeHeaderSize), size;
                 if (nodeArch.TypeID == 8)
                 {
@@ -345,126 +334,19 @@ namespace FlaxEditor.Surface.Archetypes
                 _textBox.EditEnd += () => SetValue(0, _textBox.Text);
             }
 
-            public override bool CanSelect(ref Float2 location)
-            {
-                return base.CanSelect(ref location) && !_resizeButtonRect.MakeOffsetted(Location).Contains(ref location);
-            }
-
             public override void OnSurfaceLoaded(SurfaceNodeActions action)
             {
                 base.OnSurfaceLoaded(action);
 
                 _textBox.Text = (string)Values[0];
-
-                var size = SizeValue;
-                if (Surface != null && Surface.GridSnappingEnabled)
-                    size = Surface.SnapToGrid(size, true);
-                Resize(size.X, size.Y);
             }
 
             public override void OnValuesChanged()
             {
                 base.OnValuesChanged();
 
-                var size = SizeValue;
-                Resize(size.X, size.Y);
                 _textBox.Text = (string)Values[0];
             }
-
-            protected override void UpdateRectangles()
-            {
-                base.UpdateRectangles();
-
-                const float buttonMargin = FlaxEditor.Surface.Constants.NodeCloseButtonMargin;
-                const float buttonSize = FlaxEditor.Surface.Constants.NodeCloseButtonSize;
-                _resizeButtonRect = new Rectangle(_closeButtonRect.Left, Height - buttonSize - buttonMargin - 4, buttonSize, buttonSize);
-            }
-
-            public override void Draw()
-            {
-                base.Draw();
-
-                var style = Style.Current;
-                if (_isResizing)
-                {
-                    Render2D.FillRectangle(_resizeButtonRect, style.Selection);
-                    Render2D.DrawRectangle(_resizeButtonRect, style.SelectionBorder);
-                }
-                Render2D.DrawSprite(style.Scale, _resizeButtonRect, _resizeButtonRect.Contains(_mousePosition) && Surface.CanEdit ? style.Foreground : style.ForegroundGrey);
-            }
-
-            public override void OnLostFocus()
-            {
-                if (_isResizing)
-                    EndResizing();
-
-                base.OnLostFocus();
-            }
-
-            public override void OnEndMouseCapture()
-            {
-                if (_isResizing)
-                    EndResizing();
-
-                base.OnEndMouseCapture();
-            }
-
-            public override bool OnMouseDown(Float2 location, MouseButton button)
-            {
-                if (base.OnMouseDown(location, button))
-                    return true;
-
-                if (button == MouseButton.Left && _resizeButtonRect.Contains(ref location) && Surface.CanEdit)
-                {
-                    // Start sliding
-                    _isResizing = true;
-                    _startResizingSize = Size;
-                    _startResizingCornerOffset = Size - location;
-                    StartMouseCapture();
-                    Cursor = CursorType.SizeNWSE;
-                    return true;
-                }
-
-                return false;
-            }
-
-            public override void OnMouseMove(Float2 location)
-            {
-                if (_isResizing)
-                {
-                    var emptySize = CalculateNodeSize(0, 0);
-                    var size = Float2.Max(location - emptySize + _startResizingCornerOffset, new Float2(240, 160));
-                    Resize(size.X, size.Y);
-                }
-                else
-                {
-                    base.OnMouseMove(location);
-                }
-            }
-
-            public override bool OnMouseUp(Float2 location, MouseButton button)
-            {
-                if (button == MouseButton.Left && _isResizing)
-                {
-                    EndResizing();
-                    return true;
-                }
-
-                return base.OnMouseUp(location, button);
-            }
-
-            private void EndResizing()
-            {
-                Cursor = CursorType.Default;
-                EndMouseCapture();
-                _isResizing = false;
-                if (_startResizingSize != Size)
-                {
-                    var emptySize = CalculateNodeSize(0, 0);
-                    SizeValue = Size - emptySize;
-                    Surface.MarkAsEdited(false);
-                }
-            }
         }
 
         internal enum MaterialTemplateInputsMapping

Source/Editor/Surface/Archetypes/Parameters.cs

@@ -1100,6 +1100,27 @@ namespace FlaxEditor.Surface.Archetypes
                     NodeElementArchetype.Factory.ComboBox(2 + 20, 0, 116)
                 }
             },
+            new NodeArchetype
+            {
+                TypeID = 5,
+                Create = (id, context, arch, groupArch) => new SurfaceNodeParamsSet(id, context, arch, groupArch),
+                Title = "Set Parameter",
+                Description = "Parameter value setter invoked when the animation pose is evaluated (output pose comes from input)",
+                Flags = NodeFlags.AnimGraph,
+                Size = new Float2(140, 40),
+                DefaultValues = new object[]
+                {
+                    Guid.Empty,
+                    null
+                },
+                Elements = new[]
+                {
+                    NodeElementArchetype.Factory.Output(0, string.Empty, typeof(void), 0),
+                    NodeElementArchetype.Factory.Input(0, string.Empty, true, typeof(void), 2),
+                    NodeElementArchetype.Factory.Input(1, string.Empty, true, ScriptType.Null, 1, 1),
+                    NodeElementArchetype.Factory.ComboBox(2 + 20, 0, 116)
+                }
+            },
         };
     }
 }

Source/Editor/Surface/Archetypes/Textures.cs

@@ -23,11 +23,14 @@ namespace FlaxEditor.Surface.Archetypes
             TextureGroup = 4,
         }
 
-        internal class SampleTextureNode : SurfaceNode
+        internal class TextureSamplerNode : SurfaceNode
         {
             private ComboBox _textureGroupPicker;
+            protected int _samplerTypeValueIndex = -1;
+            protected int _textureGroupValueIndex = -1;
+            protected int _level = 5;
 
-            public SampleTextureNode(uint id, VisjectSurfaceContext context, NodeArchetype nodeArch, GroupArchetype groupArch)
+            protected TextureSamplerNode(uint id, VisjectSurfaceContext context, NodeArchetype nodeArch, GroupArchetype groupArch)
             : base(id, context, nodeArch, groupArch)
             {
             }
@@ -48,13 +51,13 @@ namespace FlaxEditor.Surface.Archetypes
 
             private void UpdateUI()
             {
-                if ((int)Values[0] == (int)CommonSamplerType.TextureGroup)
+                if ((int)Values[_samplerTypeValueIndex] == (int)CommonSamplerType.TextureGroup)
                 {
                     if (_textureGroupPicker == null)
                     {
                         _textureGroupPicker = new ComboBox
                         {
-                            Location = new Float2(FlaxEditor.Surface.Constants.NodeMarginX + 50, FlaxEditor.Surface.Constants.NodeMarginY + FlaxEditor.Surface.Constants.NodeHeaderSize + FlaxEditor.Surface.Constants.LayoutOffsetY * 5),
+                            Location = new Float2(FlaxEditor.Surface.Constants.NodeMarginX + 50, FlaxEditor.Surface.Constants.NodeMarginY + FlaxEditor.Surface.Constants.NodeHeaderSize + FlaxEditor.Surface.Constants.LayoutOffsetY * _level),
                             Width = 100,
                             Parent = this,
                         };
@@ -71,7 +74,7 @@ namespace FlaxEditor.Surface.Archetypes
                         _textureGroupPicker.Visible = true;
                     }
                     _textureGroupPicker.SelectedIndexChanged -= OnSelectedTextureGroupChanged;
-                    _textureGroupPicker.SelectedIndex = (int)Values[2];
+                    _textureGroupPicker.SelectedIndex = (int)Values[_textureGroupValueIndex];
                     _textureGroupPicker.SelectedIndexChanged += OnSelectedTextureGroupChanged;
                 }
                 else if (_textureGroupPicker != null)
@@ -83,7 +86,39 @@ namespace FlaxEditor.Surface.Archetypes
 
             private void OnSelectedTextureGroupChanged(ComboBox comboBox)
             {
-                SetValue(2, _textureGroupPicker.SelectedIndex);
+                SetValue(_textureGroupValueIndex, _textureGroupPicker.SelectedIndex);
+            }
+        }
+
+        internal class SampleTextureNode : TextureSamplerNode
+        {
+            public SampleTextureNode(uint id, VisjectSurfaceContext context, NodeArchetype nodeArch, GroupArchetype groupArch)
+            : base(id, context, nodeArch, groupArch)
+            {
+                _samplerTypeValueIndex = 0;
+                _textureGroupValueIndex = 2;
+            }
+        }
+
+        internal class TriplanarSampleTextureNode : TextureSamplerNode
+        {
+            public TriplanarSampleTextureNode(uint id, VisjectSurfaceContext context, NodeArchetype nodeArch, GroupArchetype groupArch)
+            : base(id, context, nodeArch, groupArch)
+            {
+                _samplerTypeValueIndex = 3;
+                _textureGroupValueIndex = 5;
+                _level = 5;
+            }
+        }
+
+        internal class ProceduralSampleTextureNode : TextureSamplerNode
+        {
+            public ProceduralSampleTextureNode(uint id, VisjectSurfaceContext context, NodeArchetype nodeArch, GroupArchetype groupArch)
+            : base(id, context, nodeArch, groupArch)
+            {
+                _samplerTypeValueIndex = 0;
+                _textureGroupValueIndex = 2;
+                _level = 4;
             }
         }
 
@@ -280,9 +315,9 @@ namespace FlaxEditor.Surface.Archetypes
                 ConnectionsHints = ConnectionsHint.Vector,
                 DefaultValues = new object[]
                 {
-                    0,
-                    -1.0f,
-                    0,
+                    (int)CommonSamplerType.LinearClamp, // Sampler
+                    -1.0f, // Level
+                    0, // Texture Group
                 },
                 Elements = new[]
                 {
@@ -402,6 +437,7 @@ namespace FlaxEditor.Surface.Archetypes
             new NodeArchetype
             {
                 TypeID = 16,
+                Create = (id, context, arch, groupArch) => new TriplanarSampleTextureNode(id, context, arch, groupArch),
                 Title = "Triplanar Texture",
                 Description = "Projects a texture using world-space coordinates with triplanar mapping.",
                 Flags = NodeFlags.MaterialGraph,
@@ -411,8 +447,9 @@ namespace FlaxEditor.Surface.Archetypes
                     Float3.One, // Scale
                     1.0f, // Blend
                     Float2.Zero, // Offset
-                    2, // Sampler
+                    (int)CommonSamplerType.LinearWrap, // Sampler
                     false, // Local
+                    0, // Texture Group
                 },
                 Elements = new[]
                 {
@@ -430,17 +467,17 @@ namespace FlaxEditor.Surface.Archetypes
             new NodeArchetype
             {
                 TypeID = 17,
-                Create = (id, context, arch, groupArch) => new SampleTextureNode(id, context, arch, groupArch),
+                Create = (id, context, arch, groupArch) => new ProceduralSampleTextureNode(id, context, arch, groupArch),
                 Title = "Procedural Sample Texture",
                 Description = "Samples a texture to create a more natural look with less obvious tiling.",
                 Flags = NodeFlags.MaterialGraph,
-                Size = new Float2(240, 110),
+                Size = new Float2(240, 130),
                 ConnectionsHints = ConnectionsHint.Vector,
                 DefaultValues = new object[]
                 {
-                    2,
-                    -1.0f,
-                    0,
+                    (int)CommonSamplerType.LinearWrap, // Sampler
+                    -1.0f, // Level
+                    0, // Texture Group
                 },
                 Elements = new[]
                 {
@@ -448,8 +485,8 @@ namespace FlaxEditor.Surface.Archetypes
                     NodeElementArchetype.Factory.Input(1, "UVs", true, null, 1),
                     NodeElementArchetype.Factory.Input(2, "Offset", true, typeof(Float2), 3),
                     NodeElementArchetype.Factory.Output(0, "Color", typeof(Float4), 4),
-                    NodeElementArchetype.Factory.Text(0, Surface.Constants.LayoutOffsetY * 4, "Sampler"),
-                    NodeElementArchetype.Factory.ComboBox(50, Surface.Constants.LayoutOffsetY * 4, 100, 0, typeof(CommonSamplerType))
+                    NodeElementArchetype.Factory.Text(0, Surface.Constants.LayoutOffsetY * 3, "Sampler"),
+                    NodeElementArchetype.Factory.ComboBox(50, Surface.Constants.LayoutOffsetY * 3, 100, 0, typeof(CommonSamplerType))
                 }
             },
             new NodeArchetype
@@ -469,6 +506,7 @@ namespace FlaxEditor.Surface.Archetypes
             {
                 TypeID = 23,
                 Title = "Triplanar Normal Map",
+                Create = (id, context, arch, groupArch) => new TriplanarSampleTextureNode(id, context, arch, groupArch),
                 Description = "Projects a normal map texture using world-space coordinates with triplanar mapping.",
                 Flags = NodeFlags.MaterialGraph,
                 Size = new Float2(280, 100),
@@ -477,8 +515,9 @@ namespace FlaxEditor.Surface.Archetypes
                     Float3.One, // Scale
                     1.0f, // Blend
                     Float2.Zero, // Offset
-                    2, // Sampler
+                    (int)CommonSamplerType.LinearWrap, // Sampler
                     false, // Local
+                    0, // Texture Group
                 },
                 Elements = new[]
                 {

Source/Editor/Surface/Archetypes/Tools.cs

@@ -453,7 +453,7 @@ namespace FlaxEditor.Surface.Archetypes
             }
         }
 
-        private class CurveNode<T> : SurfaceNode where T : struct
+        private class CurveNode<T> : ResizableSurfaceNode where T : struct
         {
             private BezierCurveEditor<T> _curve;
             private bool _isSavingCurve;
@@ -467,7 +467,7 @@ namespace FlaxEditor.Surface.Archetypes
                     Create = (id, context, arch, groupArch) => new CurveNode<T>(id, context, arch, groupArch),
                     Description = "An animation spline represented by a set of keyframes, each representing an endpoint of a Bezier curve.",
                     Flags = NodeFlags.AllGraphs,
-                    Size = new Float2(400, 180.0f),
+                    Size = new Float2(400, 180),
                     DefaultValues = new object[]
                     {
                         // Keyframes count
@@ -491,6 +491,8 @@ namespace FlaxEditor.Surface.Archetypes
                         0.0f, zero, zero, zero,
                         0.0f, zero, zero, zero,
                         0.0f, zero, zero, zero,
+
+                        new Float2(400, 180),
                     },
                     Elements = new[]
                     {
@@ -504,30 +506,52 @@ namespace FlaxEditor.Surface.Archetypes
             public CurveNode(uint id, VisjectSurfaceContext context, NodeArchetype nodeArch, GroupArchetype groupArch)
             : base(id, context, nodeArch, groupArch)
             {
+                _sizeValueIndex = 29; // Index of the Size stored in Values array
             }
-
+                
             /// <inheritdoc />
             public override void OnLoaded(SurfaceNodeActions action)
             {
                 base.OnLoaded(action);
 
+                // Create curve editor
                 var upperLeft = GetBox(0).BottomLeft;
                 var upperRight = GetBox(1).BottomRight;
                 float curveMargin = 20.0f;
-
                 _curve = new BezierCurveEditor<T>
                 {
                     MaxKeyframes = 7,
                     Bounds = new Rectangle(upperLeft + new Float2(curveMargin, 10.0f), upperRight.X - upperLeft.X - curveMargin * 2.0f, 140.0f),
-                    Parent = this
+                    Parent = this,
+                    AnchorMax = Float2.One,
                 };
                 _curve.Edited += OnCurveEdited;
                 _curve.UnlockChildrenRecursive();
                 _curve.PerformLayout();
 
+                // Sync keyframes
                 UpdateCurveKeyframes();
             }
 
+            /// <inheritdoc />
+            public override void OnSurfaceLoaded(SurfaceNodeActions action)
+            {
+                base.OnSurfaceLoaded(action);
+
+                // Ensure the whole curve is shown
+                _curve.ShowWholeCurve();
+            }
+
+            public override void OnValuesChanged()
+            {
+                base.OnValuesChanged();
+
+                if (!_isSavingCurve)
+                {
+                    UpdateCurveKeyframes();
+                }
+            }
+
             private void OnCurveEdited()
             {
                 if (_isSavingCurve)
@@ -553,17 +577,6 @@ namespace FlaxEditor.Surface.Archetypes
                 _isSavingCurve = false;
             }
 
-            /// <inheritdoc />
-            public override void OnValuesChanged()
-            {
-                base.OnValuesChanged();
-
-                if (!_isSavingCurve)
-                {
-                    UpdateCurveKeyframes();
-                }
-            }
-
             private void UpdateCurveKeyframes()
             {
                 var count = (int)Values[0];
@@ -1575,7 +1588,7 @@ namespace FlaxEditor.Surface.Archetypes
                 DefaultValues = new object[]
                 {
                     Guid.Empty,
-                    string.Empty
+                    string.Empty,
                 },
                 Elements = new[]
                 {

Source/Editor/Surface/ResizableSurfaceNode.cs

@@ -0,0 +1,182 @@
+// Copyright (c) Wojciech Figat. All rights reserved.
+
+using FlaxEngine;
+using FlaxEngine.GUI;
+
+namespace FlaxEditor.Surface
+{
+    /// <summary>
+    /// Visject Surface node control that cna be resized.
+    /// </summary>
+    /// <seealso cref="SurfaceNode" />
+    [HideInEditor]
+    public class ResizableSurfaceNode : SurfaceNode
+    {
+        private Float2 _startResizingSize;
+        private Float2 _startResizingCornerOffset;
+
+        /// <summary>
+        /// Indicates whether the node is currently being resized.
+        /// </summary>
+        protected bool _isResizing;
+
+        /// <summary>
+        /// Index of the Float2 value in the node values list to store node size.
+        /// </summary>
+        protected int _sizeValueIndex = -1;
+
+        /// <summary>
+        /// Minimum node size.
+        /// </summary>
+        protected Float2 _sizeMin = new Float2(240, 160);
+
+        /// <summary>
+        /// Node resizing rectangle bounds.
+        /// </summary>
+        protected Rectangle _resizeButtonRect;
+
+        private Float2 SizeValue
+        {
+            get => (Float2)Values[_sizeValueIndex];
+            set => SetValue(_sizeValueIndex, value, false);
+        }
+
+        /// <inheritdoc />
+        public ResizableSurfaceNode(uint id, VisjectSurfaceContext context, NodeArchetype nodeArch, GroupArchetype groupArch)
+        : base(id, context, nodeArch, groupArch)
+        {
+        }
+
+        /// <inheritdoc />
+        public override bool CanSelect(ref Float2 location)
+        {
+            return base.CanSelect(ref location) && !_resizeButtonRect.MakeOffsetted(Location).Contains(ref location);
+        }
+
+        /// <inheritdoc />
+        public override void OnSurfaceLoaded(SurfaceNodeActions action)
+        {
+            // Reapply the curve node size
+            var size = SizeValue;
+            if (Surface != null && Surface.GridSnappingEnabled)
+                size = Surface.SnapToGrid(size, true);
+            Resize(size.X, size.Y);
+
+            base.OnSurfaceLoaded(action);
+        }
+
+        /// <inheritdoc />
+        public override void OnValuesChanged()
+        {
+            base.OnValuesChanged();
+
+            var size = SizeValue;
+            Resize(size.X, size.Y);
+        }
+
+        /// <inheritdoc />
+        public override void Draw()
+        {
+            base.Draw();
+
+            if (Surface.CanEdit)
+            {
+                var style = Style.Current;
+                if (_isResizing)
+                {
+                    Render2D.FillRectangle(_resizeButtonRect, style.Selection);
+                    Render2D.DrawRectangle(_resizeButtonRect, style.SelectionBorder);
+                }
+                Render2D.DrawSprite(style.Scale, _resizeButtonRect, _resizeButtonRect.Contains(_mousePosition) ? style.Foreground : style.ForegroundGrey);
+            }
+        }
+
+        /// <inheritdoc />
+        public override void OnLostFocus()
+        {
+            if (_isResizing)
+                EndResizing();
+
+            base.OnLostFocus();
+        }
+
+        /// <inheritdoc />
+        public override void OnEndMouseCapture()
+        {
+            if (_isResizing)
+                EndResizing();
+
+            base.OnEndMouseCapture();
+        }
+
+        /// <inheritdoc />
+        public override bool OnMouseDown(Float2 location, MouseButton button)
+        {
+            if (base.OnMouseDown(location, button))
+                return true;
+
+            if (button == MouseButton.Left && _resizeButtonRect.Contains(ref location) && Surface.CanEdit)
+            {
+                // Start resizing
+                _isResizing = true;
+                _startResizingSize = Size;
+                _startResizingCornerOffset = Size - location;
+                StartMouseCapture();
+                Cursor = CursorType.SizeNWSE;
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <inheritdoc />
+        public override void OnMouseMove(Float2 location)
+        {
+            if (_isResizing)
+            {
+                var emptySize = CalculateNodeSize(0, 0);
+                var size = Float2.Max(location - emptySize + _startResizingCornerOffset, _sizeMin);
+                Resize(size.X, size.Y);
+            }
+            else
+            {
+                base.OnMouseMove(location);
+            }
+        }
+
+        /// <inheritdoc />
+        public override bool OnMouseUp(Float2 location, MouseButton button)
+        {
+            if (button == MouseButton.Left && _isResizing)
+            {
+                EndResizing();
+                return true;
+            }
+
+            return base.OnMouseUp(location, button);
+        }
+
+        /// <inheritdoc />
+        protected override void UpdateRectangles()
+        {
+            base.UpdateRectangles();
+
+            const float buttonMargin = Constants.NodeCloseButtonMargin;
+            const float buttonSize = Constants.NodeCloseButtonSize;
+            _resizeButtonRect = new Rectangle(_closeButtonRect.Left, Height - buttonSize - buttonMargin - 4, buttonSize, buttonSize);
+        }
+
+        private void EndResizing()
+        {
+            Cursor = CursorType.Default;
+            EndMouseCapture();
+            _isResizing = false;
+            if (_startResizingSize != Size)
+            {
+                var emptySize = CalculateNodeSize(0, 0);
+                SizeValue = Size - emptySize;
+                Surface.MarkAsEdited(false);
+            }
+        }
+    }
+}

Source/Editor/Surface/SurfaceComment.cs

@@ -14,18 +14,11 @@ namespace FlaxEditor.Surface
     /// </summary>
     /// <seealso cref="SurfaceNode" />
     [HideInEditor]
-    public class SurfaceComment : SurfaceNode
+    public class SurfaceComment : ResizableSurfaceNode
     {
         private Rectangle _colorButtonRect;
-        private Rectangle _resizeButtonRect;
-        private Float2 _startResizingSize;
         private readonly TextBox _renameTextBox;
 
-        /// <summary>
-        /// True if sizing tool is in use.
-        /// </summary>
-        protected bool _isResizing;
-
         /// <summary>
         /// True if rename textbox is active in order to rename comment
         /// </summary>
@@ -52,12 +45,6 @@ namespace FlaxEditor.Surface
             set => SetValue(1, value, false);
         }
 
-        private Float2 SizeValue
-        {
-            get => (Float2)Values[2];
-            set => SetValue(2, value, false);
-        }
-
         private int OrderValue
         {
             get => (int)Values[3];
@@ -68,6 +55,8 @@ namespace FlaxEditor.Surface
         public SurfaceComment(uint id, VisjectSurfaceContext context, NodeArchetype nodeArch, GroupArchetype groupArch)
         : base(id, context, nodeArch, groupArch)
         {
+            _sizeValueIndex = 2; // Index of the Size stored in Values array
+            _sizeMin = new Float2(140.0f, Constants.NodeHeaderSize);
             _renameTextBox = new TextBox(false, 0, 0, Width)
             {
                 Height = Constants.NodeHeaderSize,
@@ -86,10 +75,6 @@ namespace FlaxEditor.Surface
             // Read node data
             Title = TitleValue;
             Color = ColorValue;
-            var size = SizeValue;
-            if (Surface != null && Surface.GridSnappingEnabled)
-                size = Surface.SnapToGrid(size, true);
-            Size = size;
 
             // Order
             // Backwards compatibility - When opening with an older version send the old comments to the back
@@ -126,27 +111,6 @@ namespace FlaxEditor.Surface
             // Read node data
             Title = TitleValue;
             Color = ColorValue;
-            Size = SizeValue;
-        }
-
-        private void EndResizing()
-        {
-            // Clear state
-            _isResizing = false;
-
-            if (_startResizingSize != Size)
-            {
-                SizeValue = Size;
-                Surface.MarkAsEdited(false);
-            }
-
-            EndMouseCapture();
-        }
-
-        /// <inheritdoc />
-        public override bool CanSelect(ref Float2 location)
-        {
-            return _headerRect.MakeOffsetted(Location).Contains(ref location) && !_resizeButtonRect.MakeOffsetted(Location).Contains(ref location);
         }
 
         /// <inheritdoc />
@@ -158,6 +122,8 @@ namespace FlaxEditor.Surface
         /// <inheritdoc />
         protected override void UpdateRectangles()
         {
+            base.UpdateRectangles();
+
             const float headerSize = Constants.NodeHeaderSize;
             const float buttonMargin = Constants.NodeCloseButtonMargin;
             const float buttonSize = Constants.NodeCloseButtonSize;
@@ -222,16 +188,13 @@ namespace FlaxEditor.Surface
                 // Color button
                 Render2D.DrawSprite(style.Settings, _colorButtonRect, _colorButtonRect.Contains(_mousePosition) && Surface.CanEdit ? style.Foreground : style.ForegroundGrey);
 
-                // Check if is resizing
+                // Resize button
                 if (_isResizing)
                 {
-                    // Draw overlay
                     Render2D.FillRectangle(_resizeButtonRect, style.Selection);
                     Render2D.DrawRectangle(_resizeButtonRect, style.SelectionBorder);
                 }
-
-                // Resize button
-                Render2D.DrawSprite(style.Scale, _resizeButtonRect, _resizeButtonRect.Contains(_mousePosition) && Surface.CanEdit ? style.Foreground : style.ForegroundGrey);
+                Render2D.DrawSprite(style.Scale, _resizeButtonRect, _resizeButtonRect.Contains(_mousePosition) ? style.Foreground : style.ForegroundGrey);
             }
 
             // Selection outline
@@ -247,88 +210,28 @@ namespace FlaxEditor.Surface
         /// <inheritdoc />
         protected override Float2 CalculateNodeSize(float width, float height)
         {
-            return Size;
+            // No margins or headers
+            return new Float2(width, height);
         }
 
         /// <inheritdoc />
         public override void OnLostFocus()
         {
-            // Check if was resizing
-            if (_isResizing)
-            {
-                EndResizing();
-            }
-
-            // Check if was renaming
             if (_isRenaming)
             {
                 Rename(_renameTextBox.Text);
                 StopRenaming();
             }
 
-            // Base
             base.OnLostFocus();
         }
 
-        /// <inheritdoc />
-        public override void OnEndMouseCapture()
-        {
-            // Check if was resizing
-            if (_isResizing)
-            {
-                EndResizing();
-            }
-            else
-            {
-                base.OnEndMouseCapture();
-            }
-        }
-
         /// <inheritdoc />
         public override bool ContainsPoint(ref Float2 location, bool precise)
         {
             return _headerRect.Contains(ref location) || _resizeButtonRect.Contains(ref location);
         }
 
-        /// <inheritdoc />
-        public override bool OnMouseDown(Float2 location, MouseButton button)
-        {
-            if (base.OnMouseDown(location, button))
-                return true;
-
-            // Check if can start resizing
-            if (button == MouseButton.Left && _resizeButtonRect.Contains(ref location) && Surface.CanEdit)
-            {
-                // Start sliding
-                _isResizing = true;
-                _startResizingSize = Size;
-                StartMouseCapture();
-
-                return true;
-            }
-
-            return false;
-        }
-
-        /// <inheritdoc />
-        public override void OnMouseMove(Float2 location)
-        {
-            // Check if is resizing
-            if (_isResizing)
-            {
-                // Update size
-                var size = Float2.Max(location, new Float2(140.0f, _headerRect.Bottom));
-                if (Surface.GridSnappingEnabled)
-                    size = Surface.SnapToGrid(size, true);
-                Size = size;
-            }
-            else
-            {
-                // Base
-                base.OnMouseMove(location);
-            }
-        }
-
         /// <inheritdoc />
         public override bool OnMouseDoubleClick(Float2 location, MouseButton button)
         {
@@ -394,12 +297,6 @@ namespace FlaxEditor.Surface
         /// <inheritdoc />
         public override bool OnMouseUp(Float2 location, MouseButton button)
         {
-            if (button == MouseButton.Left && _isResizing)
-            {
-                EndResizing();
-                return true;
-            }
-
             if (base.OnMouseUp(location, button))
                 return true;
 

Source/Editor/Surface/VisjectSurface.Input.cs

@@ -724,7 +724,12 @@ namespace FlaxEditor.Surface
 
             if (HasNodesSelection)
             {
-                var keyMoveRange = 50;
+                var keyMoveDelta = 50;
+                bool altDown = RootWindow.GetKey(KeyboardKeys.Alt);
+                bool shiftDown = RootWindow.GetKey(KeyboardKeys.Shift);
+                if (altDown || shiftDown)
+                    keyMoveDelta = shiftDown ? 10 : 25;
+
                 switch (key)
                 {
                 case KeyboardKeys.Backspace:
@@ -752,17 +757,18 @@ namespace FlaxEditor.Surface
                     Box selectedBox = GetSelectedBox(SelectedNodes);
                     if (selectedBox != null)
                     {
-                        Box toSelect = (key == KeyboardKeys.ArrowUp) ? selectedBox?.ParentNode.GetPreviousBox(selectedBox) : selectedBox?.ParentNode.GetNextBox(selectedBox);
-                        if (toSelect != null && toSelect.IsOutput == selectedBox.IsOutput)
-                        {
-                            Select(toSelect.ParentNode);
-                            toSelect.ParentNode.SelectBox(toSelect);
-                        }
+                        int delta = key == KeyboardKeys.ArrowDown ? 1 : -1;
+                        List<Box> boxes = selectedBox.ParentNode.GetBoxes().FindAll(b => b.IsOutput == selectedBox.IsOutput);
+                        int selectedIndex = boxes.IndexOf(selectedBox);
+                        Box toSelect = boxes[Mathf.Wrap(selectedIndex + delta, 0, boxes.Count - 1)];
+
+                        Select(toSelect.ParentNode);
+                        toSelect.ParentNode.SelectBox(toSelect);
                     }
                     else if (!IsMovingSelection && CanEdit)
                     {
                         // Move selected nodes
-                        var delta = new Float2(0, key == KeyboardKeys.ArrowUp ? -keyMoveRange : keyMoveRange);
+                        var delta = new Float2(0, key == KeyboardKeys.ArrowUp ? -keyMoveDelta : keyMoveDelta);
                         MoveSelectedNodes(delta);
                     }
                     return true;
@@ -775,12 +781,8 @@ namespace FlaxEditor.Surface
                     if (selectedBox != null)
                     {
                         Box toSelect = null;
-                        if ((key == KeyboardKeys.ArrowRight && selectedBox.IsOutput) || (key == KeyboardKeys.ArrowLeft && !selectedBox.IsOutput))
+                        if (((key == KeyboardKeys.ArrowRight && selectedBox.IsOutput) || (key == KeyboardKeys.ArrowLeft && !selectedBox.IsOutput)) && selectedBox.HasAnyConnection)
                         {
-                            if (_selectedConnectionIndex < 0 || _selectedConnectionIndex >= selectedBox.Connections.Count)
-                            {
-                                _selectedConnectionIndex = 0;
-                            }
                             toSelect = selectedBox.Connections[_selectedConnectionIndex];
                         }
                         else
@@ -808,7 +810,7 @@ namespace FlaxEditor.Surface
                     else if (!IsMovingSelection && CanEdit)
                     {
                         // Move selected nodes
-                        var delta = new Float2(key == KeyboardKeys.ArrowLeft ? -keyMoveRange : keyMoveRange, 0);
+                        var delta = new Float2(key == KeyboardKeys.ArrowLeft ? -keyMoveDelta : keyMoveDelta, 0);
                         MoveSelectedNodes(delta);
                     }
                     return true;
@@ -824,13 +826,9 @@ namespace FlaxEditor.Surface
                         return true;
 
                     if (Root.GetKey(KeyboardKeys.Shift))
-                    {
                         _selectedConnectionIndex = ((_selectedConnectionIndex - 1) % connectionCount + connectionCount) % connectionCount;
-                    }
                     else
-                    {
                         _selectedConnectionIndex = (_selectedConnectionIndex + 1) % connectionCount;
-                    }
                     return true;
                 }
                 }

Source/Editor/Tools/Terrain/EditTab.cs

@@ -192,7 +192,7 @@ namespace FlaxEditor.Tools.Terrain
                 {
                     if (terrain.Scene && terrain.HasStaticFlag(StaticFlags.Navigation))
                     {
-                        Navigation.BuildNavMesh(terrain.Scene, patchBounds, editorOptions.General.AutoRebuildNavMeshTimeoutMs);
+                        Navigation.BuildNavMesh(patchBounds, editorOptions.General.AutoRebuildNavMeshTimeoutMs);
                     }
                 }
             }

Source/Editor/Tools/Terrain/EditTerrainGizmo.cs

@@ -209,7 +209,7 @@ namespace FlaxEditor.Tools.Terrain
                 {
                     if (terrain.Scene && terrain.HasStaticFlag(StaticFlags.Navigation))
                     {
-                        Navigation.BuildNavMesh(terrain.Scene, patchBounds, editorOptions.General.AutoRebuildNavMeshTimeoutMs);
+                        Navigation.BuildNavMesh(patchBounds, editorOptions.General.AutoRebuildNavMeshTimeoutMs);
                     }
                 }
             }

Source/Editor/Tools/Terrain/Undo/EditTerrainMapAction.cs

@@ -172,7 +172,7 @@ namespace FlaxEditor.Tools.Terrain.Undo
             if (_navmeshBoundsModifications != null)
             {
                 foreach (var bounds in _navmeshBoundsModifications)
-                    Navigation.BuildNavMesh(scene, bounds, _dirtyNavMeshTimeoutMs);
+                    Navigation.BuildNavMesh(bounds, _dirtyNavMeshTimeoutMs);
             }
 
             Editor.Instance.Scene.MarkSceneEdited(scene);
@@ -217,11 +217,10 @@ namespace FlaxEditor.Tools.Terrain.Undo
             }
 
             // Update navmesh
-            var scene = Terrain.Scene;
             if (_navmeshBoundsModifications != null)
             {
                 foreach (var bounds in _navmeshBoundsModifications)
-                    Navigation.BuildNavMesh(scene, bounds, _dirtyNavMeshTimeoutMs);
+                    Navigation.BuildNavMesh(bounds, _dirtyNavMeshTimeoutMs);
             }
 
             Editor.Instance.Scene.MarkSceneEdited(Terrain.Scene);

Source/Editor/Undo/Actions/DeleteActorsAction.cs

@@ -303,7 +303,7 @@ namespace FlaxEditor.Actions
                     if (_nodeParents[i] is ActorNode node && node.Actor && node.Actor.Scene && node.AffectsNavigationWithChildren)
                     {
                         var bounds = node.Actor.BoxWithChildren;
-                        Navigation.BuildNavMesh(node.Actor.Scene, bounds, options.General.AutoRebuildNavMeshTimeoutMs);
+                        Navigation.BuildNavMesh(bounds, options.General.AutoRebuildNavMeshTimeoutMs);
                     }
                 }
             }

Source/Editor/Undo/Actions/ParentActorsAction.cs

@@ -134,7 +134,8 @@ namespace FlaxEditor.Actions
                 var obj = Object.Find<SceneObject>(ref item.ID);
                 if (obj != null)
                 {
-                    scenes.Add(obj.Parent.Scene);
+                    if (obj.Parent != null)
+                        scenes.Add(obj.Parent.Scene);
                     if (obj is Actor actor)
                         actor.SetParent(newParent, _worldPositionsStays, true);
                     else

Source/Editor/Undo/Actions/TransformObjectsAction.cs

@@ -121,12 +121,12 @@ namespace FlaxEditor
                 // Handle simple case where objects were moved just a little and use one navmesh build request to improve performance
                 if (data.BeforeBounds.Intersects(ref data.AfterBounds))
                 {
-                    Navigation.BuildNavMesh(data.Scene, BoundingBox.Merge(data.BeforeBounds, data.AfterBounds), options.General.AutoRebuildNavMeshTimeoutMs);
+                    Navigation.BuildNavMesh(BoundingBox.Merge(data.BeforeBounds, data.AfterBounds), options.General.AutoRebuildNavMeshTimeoutMs);
                 }
                 else
                 {
-                    Navigation.BuildNavMesh(data.Scene, data.BeforeBounds, options.General.AutoRebuildNavMeshTimeoutMs);
-                    Navigation.BuildNavMesh(data.Scene, data.AfterBounds, options.General.AutoRebuildNavMeshTimeoutMs);
+                    Navigation.BuildNavMesh(data.BeforeBounds, options.General.AutoRebuildNavMeshTimeoutMs);
+                    Navigation.BuildNavMesh(data.AfterBounds, options.General.AutoRebuildNavMeshTimeoutMs);
                 }
             }
         }

Source/Editor/Viewport/EditorViewport.cs

@@ -584,7 +584,7 @@ namespace FlaxEditor.Viewport
                 _cameraButton = new ViewportWidgetButton(string.Format(MovementSpeedTextFormat, _movementSpeed), _editor.Icons.Camera64, cameraCM, false, cameraSpeedTextWidth)
                 {
                     Tag = this,
-                    TooltipText = "Camera Settings",
+                    TooltipText = "Camera Settings.",
                     Parent = _cameraWidget
                 };
                 _cameraWidget.Parent = this;
@@ -593,7 +593,7 @@ namespace FlaxEditor.Viewport
                 _orthographicModeButton = new ViewportWidgetButton(string.Empty, _editor.Icons.CamSpeed32, null, true)
                 {
                     Checked = !_isOrtho,
-                    TooltipText = "Toggle Orthographic/Perspective Mode",
+                    TooltipText = "Toggle Orthographic/Perspective Mode.",
                     Parent = _cameraWidget
                 };
                 _orthographicModeButton.Toggled += OnOrthographicModeToggled;
@@ -832,7 +832,7 @@ namespace FlaxEditor.Viewport
                 ViewWidgetButtonMenu = new ContextMenu();
                 var viewModeButton = new ViewportWidgetButton("View", SpriteHandle.Invalid, ViewWidgetButtonMenu)
                 {
-                    TooltipText = "View properties",
+                    TooltipText = "View properties.",
                     Parent = viewMode
                 };
                 viewMode.Parent = this;
@@ -863,8 +863,10 @@ namespace FlaxEditor.Viewport
                         {
                         }
                     });
-                    viewLayers.AddButton("Reset layers", () => Task.ViewLayersMask = LayersMask.Default).Icon = _editor.Icons.Rotate32;
-                    viewLayers.AddButton("Disable layers", () => Task.ViewLayersMask = new LayersMask(0));
+                    viewLayers.AddButton("Reset layers", () => Task.ViewLayersMask = LayersMask.Default).Icon = Editor.Instance.Icons.Rotate32;
+                    viewLayers.AddSeparator();
+                    viewLayers.AddButton("Enable all", () => Task.ViewLayersMask = new LayersMask(-1)).Icon = Editor.Instance.Icons.CheckBoxTick12;
+                    viewLayers.AddButton("Disable all", () => Task.ViewLayersMask = new LayersMask(0)).Icon = Editor.Instance.Icons.Cross12;
                     viewLayers.AddSeparator();
                     var layers = LayersAndTagsSettings.GetCurrentLayers();
                     if (layers != null && layers.Length > 0)
@@ -904,8 +906,10 @@ namespace FlaxEditor.Viewport
                         {
                         }
                     });
-                    viewFlags.AddButton("Reset flags", () => Task.ViewFlags = ViewFlags.DefaultEditor).Icon = _editor.Icons.Rotate32;
-                    viewFlags.AddButton("Disable flags", () => Task.ViewFlags = ViewFlags.None);
+                    viewFlags.AddButton("Reset flags", () => Task.ViewFlags = ViewFlags.DefaultEditor).Icon = Editor.Instance.Icons.Rotate32;
+                    viewFlags.AddSeparator();
+                    viewFlags.AddButton("Enable all", () => Task.ViewFlags = ViewFlags.All).Icon = Editor.Instance.Icons.CheckBoxTick12;
+                    viewFlags.AddButton("Disable all", () => Task.ViewFlags = ViewFlags.None).Icon = Editor.Instance.Icons.Cross12;
                     viewFlags.AddSeparator();
                     for (int i = 0; i < ViewFlagsValues.Length; i++)
                     {

Source/Editor/Viewport/MainEditorGizmoViewport.cs

@@ -25,6 +25,7 @@ namespace FlaxEditor.Viewport
         private readonly Editor _editor;
         private readonly ContextMenuButton _showGridButton;
         private readonly ContextMenuButton _showNavigationButton;
+        private readonly ContextMenuButton _toggleGameViewButton;
         private SelectionOutline _customSelectionOutline;
 
         /// <summary>
@@ -108,6 +109,13 @@ namespace FlaxEditor.Viewport
         private EditorSpritesRenderer _editorSpritesRenderer;
         private ViewportRubberBandSelector _rubberBandSelector;
 
+        private bool _gameViewActive;
+        private ViewFlags _preGameViewFlags;
+        private ViewMode _preGameViewViewMode;
+        private bool _gameViewWasGridShown;
+        private bool _gameViewWasFpsCounterShown;
+        private bool _gameViewWasNagivationShown;
+
         /// <summary>
         /// Drag and drop handlers
         /// </summary>
@@ -185,6 +193,7 @@ namespace FlaxEditor.Viewport
         : base(Object.New<SceneRenderTask>(), editor.Undo, editor.Scene.Root)
         {
             _editor = editor;
+            var inputOptions = _editor.Options.Options.Input;
             DragHandlers = new ViewportDragHandlers(this, this, ValidateDragItem, ValidateDragActorType, ValidateDragScriptItem);
 
             // Prepare rendering task
@@ -232,9 +241,14 @@ namespace FlaxEditor.Viewport
             _showGridButton.CloseMenuOnClick = false;
 
             // Show navigation widget
-            _showNavigationButton = ViewWidgetShowMenu.AddButton("Navigation", () => ShowNavigation = !ShowNavigation);
+            _showNavigationButton = ViewWidgetShowMenu.AddButton("Navigation", inputOptions.ToggleNavMeshVisibility, () => ShowNavigation = !ShowNavigation);
             _showNavigationButton.CloseMenuOnClick = false;
 
+            // Game View
+            ViewWidgetButtonMenu.AddSeparator();
+            _toggleGameViewButton = ViewWidgetButtonMenu.AddButton("Game View", inputOptions.ToggleGameView, ToggleGameView);
+            _toggleGameViewButton.CloseMenuOnClick = false;
+
             // Create camera widget
             ViewWidgetButtonMenu.AddSeparator();
             ViewWidgetButtonMenu.AddButton("Create camera here", CreateCameraAtView);
@@ -259,6 +273,10 @@ namespace FlaxEditor.Viewport
             InputActions.Add(options => options.FocusSelection, FocusSelection);
             InputActions.Add(options => options.RotateSelection, RotateSelection);
             InputActions.Add(options => options.Delete, _editor.SceneEditing.Delete);
+            InputActions.Add(options => options.ToggleNavMeshVisibility, () => ShowNavigation = !ShowNavigation);
+
+            // Game View
+            InputActions.Add(options => options.ToggleGameView, ToggleGameView);
         }
 
         /// <inheritdoc />
@@ -373,9 +391,12 @@ namespace FlaxEditor.Viewport
         public void DrawEditorPrimitives(GPUContext context, ref RenderContext renderContext, GPUTexture target, GPUTexture targetDepth)
         {
             // Draw gizmos
-            for (int i = 0; i < Gizmos.Count; i++)
+            foreach (var gizmo in Gizmos)
             {
-                Gizmos[i].Draw(ref renderContext);
+                if (gizmo.Visible)
+                {
+                    gizmo.Draw(ref renderContext);
+                }
             }
 
             // Draw selected objects debug shapes and visuals
@@ -481,6 +502,36 @@ namespace FlaxEditor.Viewport
             TransformGizmo.EndTransforming();
         }
 
+        /// <summary>
+        /// Toggles game view view mode on or off.
+        /// </summary>
+        public void ToggleGameView()
+        {
+            if (!_gameViewActive)
+            {
+                // Cache flags & values
+                _preGameViewFlags = Task.ViewFlags;
+                _preGameViewViewMode = Task.ViewMode;
+                _gameViewWasGridShown = Grid.Enabled;
+                _gameViewWasFpsCounterShown = ShowFpsCounter;
+                _gameViewWasNagivationShown = ShowNavigation;
+            }
+
+            // Set flags & values
+            Task.ViewFlags = _gameViewActive ? _preGameViewFlags : ViewFlags.DefaultGame;
+            Task.ViewMode = _gameViewActive ? _preGameViewViewMode : ViewMode.Default;
+            ShowFpsCounter = _gameViewActive ? _gameViewWasFpsCounterShown : false;
+            ShowNavigation = _gameViewActive ? _gameViewWasNagivationShown : false;
+            Grid.Enabled = _gameViewActive ? _gameViewWasGridShown : false;
+
+            _gameViewActive = !_gameViewActive;
+
+            TransformGizmo.Visible = !_gameViewActive;
+            SelectionOutline.ShowSelectionOutline = !_gameViewActive;
+
+            _toggleGameViewButton.Icon = _gameViewActive ? Style.Current.CheckBoxTick : SpriteHandle.Invalid;
+        }
+
         /// <inheritdoc />
         public override void OnLostFocus()
         {
@@ -620,7 +671,7 @@ namespace FlaxEditor.Viewport
         {
             base.OnLeftMouseButtonDown();
 
-            _rubberBandSelector.TryStartingRubberBandSelection();
+            _rubberBandSelector.TryStartingRubberBandSelection(_viewMousePos);
         }
 
         /// <inheritdoc />

Source/Editor/Viewport/PrefabWindowViewport.cs

@@ -720,9 +720,12 @@ namespace FlaxEditor.Viewport
         public override void DrawEditorPrimitives(GPUContext context, ref RenderContext renderContext, GPUTexture target, GPUTexture targetDepth)
         {
             // Draw gizmos
-            for (int i = 0; i < Gizmos.Count; i++)
+            foreach (var gizmo in Gizmos)
             {
-                Gizmos[i].Draw(ref renderContext);
+                if (gizmo.Visible)
+                {
+                    gizmo.Draw(ref renderContext);
+                }
             }
 
             base.DrawEditorPrimitives(context, ref renderContext, target, targetDepth);

Source/Editor/Windows/Assets/AnimationGraphWindow.cs

@@ -99,7 +99,14 @@ namespace FlaxEditor.Windows.Assets
                 Window = window;
                 var surfaceParam = window.Surface.GetParameter(BaseModelId);
                 if (surfaceParam != null)
-                    BaseModel = FlaxEngine.Content.LoadAsync<SkinnedModel>((Guid)surfaceParam.Value);
+                {
+                    if (surfaceParam.Value is Guid asGuid)
+                        BaseModel = FlaxEngine.Content.LoadAsync<SkinnedModel>(asGuid);
+                    else if (surfaceParam.Value is SkinnedModel asModel)
+                        BaseModel = asModel;
+                    else
+                        BaseModel = null;
+                }
                 else
                     BaseModel = window.PreviewActor.GetParameterValue(BaseModelId) as SkinnedModel;
             }

Source/Editor/Windows/Assets/AnimationWindow.cs

@@ -2,7 +2,6 @@
 
 using System;
 using System.Globalization;
-using System.IO;
 using System.Reflection;
 using System.Xml;
 using FlaxEditor.Content;
@@ -25,7 +24,7 @@ namespace FlaxEditor.Windows.Assets
     /// </summary>
     /// <seealso cref="Animation" />
     /// <seealso cref="FlaxEditor.Windows.Assets.AssetEditorWindow" />
-    public sealed class AnimationWindow : AssetEditorWindowBase<Animation>
+    public sealed class AnimationWindow : ClonedAssetEditorWindowBase<Animation>
     {
         private sealed class Preview : AnimationPreview
         {
@@ -255,6 +254,7 @@ namespace FlaxEditor.Windows.Assets
         private bool _isWaitingForTimelineLoad;
         private SkinnedModel _initialPreviewModel, _initialBaseModel;
         private float _initialPanel2Splitter = 0.6f;
+        private bool _timelineIsDirty;
 
         /// <summary>
         /// Gets the animation timeline editor.
@@ -295,7 +295,7 @@ namespace FlaxEditor.Windows.Assets
                 Parent = _panel1.Panel1,
                 Enabled = false
             };
-            _timeline.Modified += MarkAsEdited;
+            _timeline.Modified += OnTimelineModified;
             _timeline.SetNoTracksText("Loading...");
 
             // Asset properties
@@ -321,11 +321,31 @@ namespace FlaxEditor.Windows.Assets
         {
             MarkAsEdited();
             UpdateToolstrip();
+            _propertiesPresenter.BuildLayout();
+        }
+
+        private void OnTimelineModified()
+        {
+            _timelineIsDirty = true;
+            MarkAsEdited();
+        }
+
+        private bool RefreshTempAsset()
+        {
+            if (_asset == null || _isWaitingForTimelineLoad)
+                return true;
+            if (_timeline.IsModified)
+            {
+                _timeline.Save(_asset);
+            }
+            _propertiesPresenter.BuildLayoutOnUpdate();
+
+            return false;
         }
 
         private string GetPreviewModelCacheName()
         {
-            return _asset.ID + ".PreviewModel";
+            return _item.ID + ".PreviewModel";
         }
 
         /// <inheritdoc />
@@ -361,7 +381,11 @@ namespace FlaxEditor.Windows.Assets
             if (!IsEdited)
                 return;
 
-            _timeline.Save(_asset);
+            if (RefreshTempAsset())
+                return;
+            if (SaveToOriginal())
+                return;
+
             ClearEditedFlag();
             _item.RefreshThumbnail();
         }
@@ -414,10 +438,18 @@ namespace FlaxEditor.Windows.Assets
         {
             base.Update(deltaTime);
 
+            // Check if temporary asset need to be updated
+            if (_timelineIsDirty)
+            {
+                _timelineIsDirty = false;
+                RefreshTempAsset();
+            }
+
+            // Check if need to load timeline
             if (_isWaitingForTimelineLoad && _asset.IsLoaded)
             {
                 _isWaitingForTimelineLoad = false;
-                _timeline._id = _asset.ID;
+                _timeline._id = _item.ID;
                 _timeline.Load(_asset);
                 _undo.Clear();
                 _timeline.Enabled = true;

Source/Editor/Windows/Assets/SkinnedModelWindow.cs

@@ -70,6 +70,13 @@ namespace FlaxEditor.Windows.Assets
                         return;
                     var nodes = proxy.Asset.Nodes;
                     var bones = proxy.Asset.Bones;
+                    var blendShapes = proxy.Asset.BlendShapes;
+
+                    // Info
+                    {
+                        var group = layout.Group("Info");
+                        group.Label($"Nodes: {nodes.Length}\nBones: {bones.Length}\nBlend Shapes: {blendShapes.Length}").AddCopyContextMenu().Label.Height *= 2.5f;
+                    }
 
                     // Skeleton Bones
                     {
@@ -109,7 +116,6 @@ namespace FlaxEditor.Windows.Assets
                     }
 
                     // Blend Shapes
-                    var blendShapes = proxy.Asset.BlendShapes;
                     if (blendShapes.Length != 0)
                     {
                         var group = layout.Group("Blend Shapes");

Source/Editor/Windows/EditGameWindow.cs

@@ -429,6 +429,7 @@ namespace FlaxEditor.Windows
             writer.WriteAttributeString("FarPlane", Viewport.FarPlane.ToString());
             writer.WriteAttributeString("FieldOfView", Viewport.FieldOfView.ToString());
             writer.WriteAttributeString("MovementSpeed", Viewport.MovementSpeed.ToString());
+            writer.WriteAttributeString("ViewportIconsScale", ViewportIconsRenderer.Scale.ToString());
             writer.WriteAttributeString("OrthographicScale", Viewport.OrthographicScale.ToString());
             writer.WriteAttributeString("UseOrthographicProjection", Viewport.UseOrthographicProjection.ToString());
             writer.WriteAttributeString("ViewFlags", ((ulong)Viewport.Task.View.Flags).ToString());
@@ -439,31 +440,24 @@ namespace FlaxEditor.Windows
         {
             if (bool.TryParse(node.GetAttribute("GridEnabled"), out bool value1))
                 Viewport.Grid.Enabled = value1;
-
             if (bool.TryParse(node.GetAttribute("ShowFpsCounter"), out value1))
                 Viewport.ShowFpsCounter = value1;
-
             if (bool.TryParse(node.GetAttribute("ShowNavigation"), out value1))
                 Viewport.ShowNavigation = value1;
-
             if (float.TryParse(node.GetAttribute("NearPlane"), out float value2))
                 Viewport.NearPlane = value2;
-
             if (float.TryParse(node.GetAttribute("FarPlane"), out value2))
                 Viewport.FarPlane = value2;
-
             if (float.TryParse(node.GetAttribute("FieldOfView"), out value2))
                 Viewport.FieldOfView = value2;
-
             if (float.TryParse(node.GetAttribute("MovementSpeed"), out value2))
                 Viewport.MovementSpeed = value2;
-
+            if (float.TryParse(node.GetAttribute("ViewportIconsScale"), out value2))
+                ViewportIconsRenderer.Scale = value2;
             if (float.TryParse(node.GetAttribute("OrthographicScale"), out value2))
                 Viewport.OrthographicScale = value2;
-
             if (bool.TryParse(node.GetAttribute("UseOrthographicProjection"), out value1))
                 Viewport.UseOrthographicProjection = value1;
-
             if (ulong.TryParse(node.GetAttribute("ViewFlags"), out ulong value3))
                 Viewport.Task.ViewFlags = (ViewFlags)value3;