Fix managed wrapper function parameter handling for BytesContainer

#3823

.github/workflows/build_linux.yml

@@ -16,7 +16,7 @@ jobs:
       uses: actions/checkout@v3
     - name: Install dependencies
       run: |
-        sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev build-essential gettext libtool libtool-bin libpulse-dev libasound2-dev libjack-dev portaudio19-dev libwayland-dev
+        sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev build-essential gettext libtool libtool-bin libpulse-dev libasound2-dev libjack-dev portaudio19-dev
     - name: Setup Vulkan
       uses: ./.github/actions/vulkan
     - name: Setup .NET
@@ -44,7 +44,7 @@ jobs:
       uses: actions/checkout@v3
     - name: Install dependencies
       run: |
-        sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev libwayland-dev
+        sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev
     - name: Setup Vulkan
       uses: ./.github/actions/vulkan
     - name: Setup .NET

.github/workflows/tests.yml

@@ -28,7 +28,7 @@ jobs:
         git lfs pull
     - name: Install dependencies
       run: |
-        sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev build-essential gettext libtool libtool-bin libpulse-dev libasound2-dev libjack-dev portaudio19-dev libwayland-dev
+        sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev build-essential gettext libtool libtool-bin libpulse-dev libasound2-dev libjack-dev portaudio19-dev
     - name: Build
       run: |
         ./GenerateProjectFiles.sh -vs2022 -log -verbose -printSDKs -dotnet=8

Content/Shaders/SDF.flax

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d2b1dc1523cb2140db7ce5fed6e97b09d7fcebbe6cc19fca7708b5b882267040
-size 4175
+oid sha256:d3922811f0eb56cbb515c93cd53d80316740ea78219aa81118d2c9dee4a9d230
+size 4142

Flax.flaxproj

@@ -4,7 +4,7 @@
     "Major": 1,
     "Minor": 11,
     "Revision": 0,
-    "Build": 6804
+    "Build": 6805
   },
   "Company": "Flax",
   "Copyright": "Copyright (c) 2012-2025 Wojciech Figat. All rights reserved.",
@@ -13,7 +13,6 @@
   "Configuration": {
     "UseCSharp": true,
     "UseLargeWorlds": false,
-    "UseDotNet": true,
-    "UseSDL": true
+    "UseDotNet": true
   }
 }

Source/Editor/Content/Items/ContentFolder.cs

@@ -282,7 +282,7 @@ namespace FlaxEditor.Content
 
             if (data is DragDataFiles)
                 return DragDropEffect.Copy;
-            return _dragOverItems?.Effect ?? DragDropEffect.None;
+            return _dragOverItems.Effect;
         }
 
         /// <inheritdoc />

Source/Editor/Content/Items/CppScriptItem.cs

@@ -20,7 +20,7 @@ namespace FlaxEditor.Content
         }
 
         /// <inheritdoc />
-        public override string TypeDescription => Path.EndsWith(".h") || Path.EndsWith(".hpp") ? "C++ Header File" : "C++ Source Code";
+        public override string TypeDescription => Path.EndsWith(".h") ? "C++ Header File" : "C++ Source Code";
 
         /// <inheritdoc />
         public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.CPPScript128;

Source/Editor/Content/Items/VisualScriptItem.cs

@@ -281,6 +281,13 @@ namespace FlaxEditor.Content
 
         private void CacheData()
         {
+            if (!_asset)
+            {
+                _parameters = Utils.GetEmptyArray<ScriptMemberInfo>();
+                _methods = Utils.GetEmptyArray<ScriptMemberInfo>();
+                _attributes = Utils.GetEmptyArray<Attribute>();
+                return;
+            }
             if (_parameters != null)
                 return;
             if (_asset.WaitForLoaded())
@@ -344,13 +351,13 @@ namespace FlaxEditor.Content
         }
 
         /// <inheritdoc />
-        public string Name => Path.GetFileNameWithoutExtension(_asset.Path);
+        public string Name => _asset ? Path.GetFileNameWithoutExtension(_asset.Path) : null;
 
         /// <inheritdoc />
         public string Namespace => string.Empty;
 
         /// <inheritdoc />
-        public string TypeName => JsonSerializer.GetStringID(_asset.ID);
+        public string TypeName => _asset ? JsonSerializer.GetStringID(_asset.ID) : null;
 
         /// <inheritdoc />
         public bool IsPublic => true;

Source/Editor/Cooker/Steps/CompileScriptsStep.cpp

@@ -10,9 +10,10 @@
 #include "Engine/Serialization/JsonTools.h"
 #include "Engine/Serialization/JsonWriters.h"
 #include "Editor/Cooker/PlatformTools.h"
+#include "Engine/Engine/Globals.h"
 #include "Editor/Editor.h"
 #include "Editor/ProjectInfo.h"
-#include "Engine/Engine/Globals.h"
+#include "Editor/Utilities/EditorUtilities.h"
 #if PLATFORM_MAC
 #include <sys/stat.h>
 #endif
@@ -127,7 +128,7 @@ bool CompileScriptsStep::DeployBinaries(CookingData& data, const String& path, c
         const String dst = dstPath / StringUtils::GetFileName(file);
         if (dst == file)
             continue;
-        if (FileSystem::CopyFile(dst, file))
+        if (EditorUtilities::CopyFileIfNewer(dst, file))
         {
             data.Error(String::Format(TEXT("Failed to copy file from {0} to {1}."), file, dst));
             return true;

Source/Editor/Cooker/Steps/CookAssetsStep.cpp

@@ -1368,7 +1368,10 @@ bool CookAssetsStep::Perform(CookingData& data)
             {
                 typeName = e.TypeName;
             }
-            LOG(Info, "{0}: {1:>4} assets of total size {2}", typeName, e.Count, Utilities::BytesToText(e.ContentSize));
+            if (e.Count == 1)
+                LOG(Info, "{0}:    1 asset  of total size {1}", typeName, Utilities::BytesToText(e.ContentSize));
+            else
+                LOG(Info, "{0}: {1:>4} assets of total size {2}", typeName, e.Count, Utilities::BytesToText(e.ContentSize));
         }
         LOG(Info, "");
     }

Source/Editor/Cooker/Steps/PrecompileAssembliesStep.cpp

@@ -59,6 +59,7 @@ bool PrecompileAssembliesStep::Perform(CookingData& data)
     data.StepProgress(infoMsg, 0);
 
     // Override Newtonsoft.Json with AOT-version (one that doesn't use System.Reflection.Emit)
+    // TODO: remove it since EngineModule does properly reference AOT lib now
     EditorUtilities::CopyFileIfNewer(data.ManagedCodeOutputPath / TEXT("Newtonsoft.Json.dll"), Globals::StartupFolder / TEXT("Source/Platforms/DotNet/AOT/Newtonsoft.Json.dll"));
     FileSystem::DeleteFile(data.ManagedCodeOutputPath / TEXT("Newtonsoft.Json.xml"));
     FileSystem::DeleteFile(data.ManagedCodeOutputPath / TEXT("Newtonsoft.Json.pdb"));

Source/Editor/CustomEditors/Dedicated/LocalizationSettingsEditor.cs

@@ -190,12 +190,12 @@ namespace FlaxEditor.CustomEditors.Dedicated
                     foreach (var file in files)
                         FindNewKeysCSharp(file, newKeys, allKeys);
 
-                    // C/C++
-                    files = Directory.GetFiles(Globals.ProjectSourceFolder, "*.cpp", SearchOption.AllDirectories).Concat(Directory.GetFiles(Globals.ProjectSourceFolder, "*.c", SearchOption.AllDirectories)).ToArray();
+                    // C++
+                    files = Directory.GetFiles(Globals.ProjectSourceFolder, "*.cpp", SearchOption.AllDirectories);
                     filesCount += files.Length;
                     foreach (var file in files)
                         FindNewKeysCpp(file, newKeys, allKeys);
-                    files = Directory.GetFiles(Globals.ProjectSourceFolder, "*.h", SearchOption.AllDirectories).Concat(Directory.GetFiles(Globals.ProjectSourceFolder, "*.hpp", SearchOption.AllDirectories)).ToArray();;
+                    files = Directory.GetFiles(Globals.ProjectSourceFolder, "*.h", SearchOption.AllDirectories);
                     filesCount += files.Length;
                     foreach (var file in files)
                         FindNewKeysCpp(file, newKeys, allKeys);

Source/Editor/GUI/ContextMenu/ContextMenuBase.cs

@@ -1,10 +1,7 @@
-#if PLATFORM_WINDOWS || PLATFORM_SDL
+#if PLATFORM_WINDOWS
 #define USE_IS_FOREGROUND
 #else
 #endif
-#if PLATFORM_SDL
-#define USE_SDL_WORKAROUNDS
-#endif
 // Copyright (c) Wojciech Figat. All rights reserved.
 
 using System.Collections.Generic;
@@ -125,7 +122,7 @@ namespace FlaxEditor.GUI.ContextMenu
         }
 
         /// <summary>
-        /// Shows the empty menu popup on a screen.
+        /// Shows the empty menu popup o na screen.
         /// </summary>
         /// <param name="control">The target control.</param>
         /// <param name="area">The target control area to cover.</param>
@@ -260,9 +257,7 @@ namespace FlaxEditor.GUI.ContextMenu
                 desc.AllowMaximize = false;
                 desc.AllowDragAndDrop = false;
                 desc.IsTopmost = true;
-                desc.Type = WindowType.Popup;
-                desc.Parent = parentWin.Window;
-                desc.Title = "ContextMenu";
+                desc.IsRegularWindow = false;
                 desc.HasSizingFrame = false;
                 OnWindowCreating(ref desc);
                 _window = Platform.CreateWindow(ref desc);
@@ -271,12 +266,6 @@ namespace FlaxEditor.GUI.ContextMenu
                     _window.GotFocus += OnWindowGotFocus;
                     _window.LostFocus += OnWindowLostFocus;
                 }
-                
-#if USE_IS_FOREGROUND && USE_SDL_WORKAROUNDS
-                // The focus between popup and parent windows doesn't change, force hide the popup when clicked on parent
-                parentWin.Window.MouseDown += OnWindowMouseDown;
-                _window.Closed += () => parentWin.Window.MouseDown -= OnWindowMouseDown;
-#endif
 
                 // Attach to the window
                 _parentCM = parent as ContextMenuBase;
@@ -452,17 +441,6 @@ namespace FlaxEditor.GUI.ContextMenu
             }
         }
 
-#if USE_SDL_WORKAROUNDS
-        private void OnWindowGotFocus()
-        {
-        }
-        
-        private void OnWindowMouseDown(ref Float2 mousePosition, MouseButton button, ref bool handled)
-        {
-            // The user clicked outside the popup window
-            Hide();
-        }
-#else
         private void OnWindowGotFocus()
         {
             var child = _childCM;
@@ -476,7 +454,6 @@ namespace FlaxEditor.GUI.ContextMenu
                 });
             }
         }
-#endif
 
         private void OnWindowLostFocus()
         {
@@ -575,12 +552,7 @@ namespace FlaxEditor.GUI.ContextMenu
             // Let root context menu to check if none of the popup windows
             if (_parentCM == null && UseVisibilityControl && !IsForeground)
             {
-#if USE_SDL_WORKAROUNDS
-                if (!IsMouseOver)
-                    Hide();
-#else
                 Hide();
-#endif
             }
         }
 #endif

Source/Editor/GUI/Dialogs/ColorPickerDialog.cs

@@ -326,11 +326,8 @@ namespace FlaxEditor.GUI.Dialogs
             // Update eye dropper tool
             if (_activeEyedropper)
             {
-                // Try reading the color under the cursor in realtime if supported by the platform
                 Float2 mousePosition = Platform.MousePosition;
-                Color color = ScreenUtilities.GetColorAt(mousePosition);
-                if (color != Color.Transparent)
-                    SelectedColor = color;
+                SelectedColor = ScreenUtilities.GetColorAt(mousePosition);
             }
         }
 

Source/Editor/GUI/Docking/DockHintWindow.cs

@@ -0,0 +1,545 @@
+// Copyright (c) Wojciech Figat. All rights reserved.
+
+using System;
+using FlaxEngine;
+using FlaxEngine.GUI;
+
+namespace FlaxEditor.GUI.Docking
+{
+    /// <summary>
+    /// Helper class used to handle docking windows dragging and docking.
+    /// </summary>
+    public class DockHintWindow
+    {
+        private FloatWindowDockPanel _toMove;
+
+        private Float2 _dragOffset;
+        private Float2 _defaultWindowSize;
+        private Rectangle _rectDock;
+        private Rectangle _rectWindow;
+        private Float2 _mouse;
+        private DockState _toSet;
+        private DockPanel _toDock;
+        private bool _lateDragOffsetUpdate;
+
+        private Rectangle _rLeft, _rRight, _rBottom, _rUpper, _rCenter;
+
+        private DockHintWindow(FloatWindowDockPanel toMove)
+        {
+            _toMove = toMove;
+            _toSet = DockState.Float;
+            var window = toMove.Window.Window;
+
+            // Remove focus from drag target
+            _toMove.Focus();
+            _toMove.Defocus();
+
+            // Focus window
+            window.Focus();
+
+            // Check if window is maximized and restore window.
+            if (window.IsMaximized)
+            {
+                // Restore window and set position to mouse.
+                var mousePos = window.MousePosition;
+                var previousSize = window.Size;
+                window.Restore();
+                window.Position = Platform.MousePosition - mousePos * window.Size / previousSize;
+            }
+
+            // Calculate dragging offset and move window to the destination position
+            var mouseScreenPosition = Platform.MousePosition;
+
+            // If the _toMove window was not focused when initializing this window, the result vector only contains zeros
+            // and to prevent a failure, we need to perform an update for the drag offset at later time which will be done in the OnMouseMove event handler.
+            if (mouseScreenPosition != Float2.Zero)
+                CalculateDragOffset(mouseScreenPosition);
+            else
+                _lateDragOffsetUpdate = true;
+
+            // Get initial size
+            _defaultWindowSize = window.Size;
+
+            // Init proxy window
+            Proxy.Init(ref _defaultWindowSize);
+
+            // Bind events
+            Proxy.Window.MouseUp += OnMouseUp;
+            Proxy.Window.MouseMove += OnMouseMove;
+            Proxy.Window.LostFocus += OnLostFocus;
+
+            // Start tracking mouse
+            Proxy.Window.StartTrackingMouse(false);
+
+            // Update window GUI
+            Proxy.Window.GUI.PerformLayout();
+
+            // Update rectangles
+            UpdateRects();
+
+            // Hide base window
+            window.Hide();
+
+            // Enable hit window presentation
+            Proxy.Window.RenderingEnabled = true;
+            Proxy.Window.Show();
+            Proxy.Window.Focus();
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        public void Dispose()
+        {
+            // End tracking mouse
+            Proxy.Window.EndTrackingMouse();
+
+            // Disable rendering
+            Proxy.Window.RenderingEnabled = false;
+
+            // Unbind events
+            Proxy.Window.MouseUp -= OnMouseUp;
+            Proxy.Window.MouseMove -= OnMouseMove;
+            Proxy.Window.LostFocus -= OnLostFocus;
+
+            // Hide the proxy
+            Proxy.Hide();
+
+            if (_toMove == null)
+                return;
+
+            // Check if window won't be docked
+            if (_toSet == DockState.Float)
+            {
+                var window = _toMove.Window?.Window;
+                if (window == null)
+                    return;
+                var mouse = Platform.MousePosition;
+
+                // Move base window
+                window.Position = mouse - _dragOffset;
+
+                // Show base window
+                window.Show();
+            }
+            else
+            {
+                bool hasNoChildPanels = _toMove.ChildPanelsCount == 0;
+
+                // Check if window has only single tab
+                if (hasNoChildPanels && _toMove.TabsCount == 1)
+                {
+                    // Dock window
+                    _toMove.GetTab(0).Show(_toSet, _toDock);
+                }
+                // Check if dock as tab and has no child panels
+                else if (hasNoChildPanels && _toSet == DockState.DockFill)
+                {
+                    // Dock all tabs
+                    while (_toMove.TabsCount > 0)
+                    {
+                        _toMove.GetTab(0).Show(DockState.DockFill, _toDock);
+                    }
+                }
+                else
+                {
+                    var selectedTab = _toMove.SelectedTab;
+
+                    // Dock the first tab into the target location
+                    var firstTab = _toMove.GetTab(0);
+                    firstTab.Show(_toSet, _toDock);
+
+                    // Dock rest of the tabs
+                    while (_toMove.TabsCount > 0)
+                    {
+                        _toMove.GetTab(0).Show(DockState.DockFill, firstTab);
+                    }
+
+                    // Keep selected tab being selected
+                    selectedTab?.SelectTab();
+                }
+
+                // Focus target window
+                _toDock.Root.Focus();
+            }
+
+            _toMove = null;
+        }
+
+        /// <summary>
+        /// Creates the new dragging hit window.
+        /// </summary>
+        /// <param name="toMove">Floating dock panel to move.</param>
+        /// <returns>The dock hint window object.</returns>
+        public static DockHintWindow Create(FloatWindowDockPanel toMove)
+        {
+            if (toMove == null)
+                throw new ArgumentNullException();
+
+            return new DockHintWindow(toMove);
+        }
+
+        /// <summary>
+        /// Creates the new dragging hit window.
+        /// </summary>
+        /// <param name="toMove">Dock window to move.</param>
+        /// <returns>The dock hint window object.</returns>
+        public static DockHintWindow Create(DockWindow toMove)
+        {
+            if (toMove == null)
+                throw new ArgumentNullException();
+
+            // Show floating
+            toMove.ShowFloating();
+
+            // Move window to the mouse position (with some offset for caption bar)
+            var window = (WindowRootControl)toMove.Root;
+            var mouse = Platform.MousePosition;
+            window.Window.Position = mouse - new Float2(8, 8);
+
+            // Get floating panel
+            var floatingPanelToMove = window.GetChild(0) as FloatWindowDockPanel;
+
+            return new DockHintWindow(floatingPanelToMove);
+        }
+
+        /// <summary>
+        /// Calculates window rectangle in the dock window.
+        /// </summary>
+        /// <param name="state">Window dock state.</param>
+        /// <param name="rect">Dock panel rectangle.</param>
+        /// <returns>Calculated window rectangle.</returns>
+        public static Rectangle CalculateDockRect(DockState state, ref Rectangle rect)
+        {
+            Rectangle result = rect;
+            switch (state)
+            {
+            case DockState.DockFill:
+                result.Location.Y += Editor.Instance.Options.Options.Interface.TabHeight;
+                result.Size.Y -= Editor.Instance.Options.Options.Interface.TabHeight;
+                break;
+            case DockState.DockTop:
+                result.Size.Y *= DockPanel.DefaultSplitterValue;
+                break;
+            case DockState.DockLeft:
+                result.Size.X *= DockPanel.DefaultSplitterValue;
+                break;
+            case DockState.DockBottom:
+                result.Location.Y += result.Size.Y * (1 - DockPanel.DefaultSplitterValue);
+                result.Size.Y *= DockPanel.DefaultSplitterValue;
+                break;
+            case DockState.DockRight:
+                result.Location.X += result.Size.X * (1 - DockPanel.DefaultSplitterValue);
+                result.Size.X *= DockPanel.DefaultSplitterValue;
+                break;
+            }
+            return result;
+        }
+
+        private void CalculateDragOffset(Float2 mouseScreenPosition)
+        {
+            var baseWinPos = _toMove.Window.Window.Position;
+            _dragOffset = mouseScreenPosition - baseWinPos;
+        }
+
+        private void UpdateRects()
+        {
+            // Cache mouse position
+            _mouse = Platform.MousePosition;
+
+            // Check intersection with any dock panel
+            var uiMouse = _mouse;
+            _toDock = _toMove.MasterPanel.HitTest(ref uiMouse, _toMove);
+
+            // Check dock state to use
+            bool showProxyHints = _toDock != null;
+            bool showBorderHints = showProxyHints;
+            bool showCenterHint = showProxyHints;
+            if (showProxyHints)
+            {
+                // If moved window has not only tabs but also child panels disable docking as tab
+                if (_toMove.ChildPanelsCount > 0)
+                    showCenterHint = false;
+
+                // Disable docking windows with one or more dock panels inside
+                if (_toMove.ChildPanelsCount > 0)
+                    showBorderHints = false;
+
+                // Get dock area
+                _rectDock = _toDock.DockAreaBounds;
+
+                // Cache dock rectangles
+                var size = _rectDock.Size;
+                var offset = _rectDock.Location;
+                var borderMargin = 4.0f;
+                var hintWindowsSize = Proxy.HintWindowsSize * Platform.DpiScale;
+                var hintWindowsSize2 = hintWindowsSize * 0.5f;
+                var centerX = size.X * 0.5f;
+                var centerY = size.Y * 0.5f;
+                _rUpper = new Rectangle(centerX - hintWindowsSize2, borderMargin, hintWindowsSize, hintWindowsSize) + offset;
+                _rBottom = new Rectangle(centerX - hintWindowsSize2, size.Y - hintWindowsSize - borderMargin, hintWindowsSize, hintWindowsSize) + offset;
+                _rLeft = new Rectangle(borderMargin, centerY - hintWindowsSize2, hintWindowsSize, hintWindowsSize) + offset;
+                _rRight = new Rectangle(size.X - hintWindowsSize - borderMargin, centerY - hintWindowsSize2, hintWindowsSize, hintWindowsSize) + offset;
+                _rCenter = new Rectangle(centerX - hintWindowsSize2, centerY - hintWindowsSize2, hintWindowsSize, hintWindowsSize) + offset;
+
+                // Hit test
+                DockState toSet = DockState.Float;
+                if (showBorderHints)
+                {
+                    if (_rUpper.Contains(_mouse))
+                        toSet = DockState.DockTop;
+                    else if (_rBottom.Contains(_mouse))
+                        toSet = DockState.DockBottom;
+                    else if (_rLeft.Contains(_mouse))
+                        toSet = DockState.DockLeft;
+                    else if (_rRight.Contains(_mouse))
+                        toSet = DockState.DockRight;
+                }
+                if (showCenterHint && _rCenter.Contains(_mouse))
+                    toSet = DockState.DockFill;
+                _toSet = toSet;
+
+                // Show proxy hint windows
+                Proxy.Down.Position = _rBottom.Location;
+                Proxy.Left.Position = _rLeft.Location;
+                Proxy.Right.Position = _rRight.Location;
+                Proxy.Up.Position = _rUpper.Location;
+                Proxy.Center.Position = _rCenter.Location;
+            }
+            else
+            {
+                _toSet = DockState.Float;
+            }
+
+            // Update proxy hint windows visibility
+            Proxy.Down.IsVisible = showProxyHints & showBorderHints;
+            Proxy.Left.IsVisible = showProxyHints & showBorderHints;
+            Proxy.Right.IsVisible = showProxyHints & showBorderHints;
+            Proxy.Up.IsVisible = showProxyHints & showBorderHints;
+            Proxy.Center.IsVisible = showProxyHints & showCenterHint;
+
+            // Calculate proxy/dock/window rectangles
+            if (_toDock == null)
+            {
+                // Floating window over nothing
+                _rectWindow = new Rectangle(_mouse - _dragOffset, _defaultWindowSize);
+            }
+            else
+            {
+                if (_toSet == DockState.Float)
+                {
+                    // Floating window over dock panel
+                    _rectWindow = new Rectangle(_mouse - _dragOffset, _defaultWindowSize);
+                }
+                else
+                {
+                    // Use only part of the dock panel to show hint
+                    _rectWindow = CalculateDockRect(_toSet, ref _rectDock);
+                }
+            }
+
+            // Update proxy window
+            Proxy.Window.ClientBounds = _rectWindow;
+        }
+
+        private void OnMouseUp(ref Float2 location, MouseButton button, ref bool handled)
+        {
+            if (button == MouseButton.Left)
+            {
+                Dispose();
+            }
+        }
+
+        private void OnMouseMove(ref Float2 mousePos)
+        {
+            // Recalculate the drag offset because the current mouse screen position was invalid when we initialized the window
+            if (_lateDragOffsetUpdate)
+            {
+                // Calculate dragging offset and move window to the destination position
+                CalculateDragOffset(mousePos);
+
+                // Reset state
+                _lateDragOffsetUpdate = false;
+            }
+
+            UpdateRects();
+        }
+
+        private void OnLostFocus()
+        {
+            Dispose();
+        }
+
+        /// <summary>
+        /// Contains helper proxy windows shared across docking panels. They are used to visualize docking window locations.
+        /// </summary>
+        public static class Proxy
+        {
+            /// <summary>
+            /// The drag proxy window.
+            /// </summary>
+            public static Window Window;
+
+            /// <summary>
+            /// The left hint proxy window.
+            /// </summary>
+            public static Window Left;
+
+            /// <summary>
+            /// The right hint proxy window.
+            /// </summary>
+            public static Window Right;
+
+            /// <summary>
+            /// The up hint proxy window.
+            /// </summary>
+            public static Window Up;
+
+            /// <summary>
+            /// The down hint proxy window.
+            /// </summary>
+            public static Window Down;
+
+            /// <summary>
+            /// The center hint proxy window.
+            /// </summary>
+            public static Window Center;
+
+            /// <summary>
+            /// The hint windows size.
+            /// </summary>
+            public const float HintWindowsSize = 32.0f;
+
+            /// <summary>
+            /// Initializes the hit proxy windows. Those windows are used to indicate drag target areas (left, right, top, bottom, etc.).
+            /// </summary>
+            public static void InitHitProxy()
+            {
+                CreateProxy(ref Left, "DockHint.Left");
+                CreateProxy(ref Right, "DockHint.Right");
+                CreateProxy(ref Up, "DockHint.Up");
+                CreateProxy(ref Down, "DockHint.Down");
+                CreateProxy(ref Center, "DockHint.Center");
+            }
+
+            /// <summary>
+            /// Initializes the hint window.
+            /// </summary>
+            /// <param name="initSize">Initial size of the proxy window.</param>
+            public static void Init(ref Float2 initSize)
+            {
+                if (Window == null)
+                {
+                    var settings = CreateWindowSettings.Default;
+                    settings.Title = "DockHint.Window";
+                    settings.Size = initSize;
+                    settings.AllowInput = true;
+                    settings.AllowMaximize = false;
+                    settings.AllowMinimize = false;
+                    settings.HasBorder = false;
+                    settings.HasSizingFrame = false;
+                    settings.IsRegularWindow = false;
+                    settings.SupportsTransparency = true;
+                    settings.ShowInTaskbar = false;
+                    settings.ShowAfterFirstPaint = false;
+                    settings.IsTopmost = true;
+
+                    Window = Platform.CreateWindow(ref settings);
+                    Window.Opacity = 0.6f;
+                    Window.GUI.BackgroundColor = Style.Current.Selection;
+                    Window.GUI.AddChild<DragVisuals>();
+                }
+                else
+                {
+                    // Resize proxy
+                    Window.ClientSize = initSize;
+                }
+
+                InitHitProxy();
+            }
+
+            private sealed class DragVisuals : Control
+            {
+                public DragVisuals()
+                {
+                    AnchorPreset = AnchorPresets.StretchAll;
+                    Offsets = Margin.Zero;
+                }
+
+                public override void Draw()
+                {
+                    Render2D.DrawRectangle(new Rectangle(Float2.Zero, Size), Style.Current.SelectionBorder);
+                }
+            }
+
+            private static void CreateProxy(ref Window win, string name)
+            {
+                if (win != null)
+                    return;
+
+                var settings = CreateWindowSettings.Default;
+                settings.Title = name;
+                settings.Size = new Float2(HintWindowsSize * Platform.DpiScale);
+                settings.AllowInput = false;
+                settings.AllowMaximize = false;
+                settings.AllowMinimize = false;
+                settings.HasBorder = false;
+                settings.HasSizingFrame = false;
+                settings.IsRegularWindow = false;
+                settings.SupportsTransparency = true;
+                settings.ShowInTaskbar = false;
+                settings.ActivateWhenFirstShown = false;
+                settings.IsTopmost = true;
+                settings.ShowAfterFirstPaint = false;
+
+                win = Platform.CreateWindow(ref settings);
+                win.Opacity = 0.6f;
+                win.GUI.BackgroundColor = Style.Current.Selection;
+                win.GUI.AddChild<DragVisuals>();
+            }
+
+            /// <summary>
+            /// Hides proxy windows.
+            /// </summary>
+            public static void Hide()
+            {
+                HideProxy(ref Window);
+                HideProxy(ref Left);
+                HideProxy(ref Right);
+                HideProxy(ref Up);
+                HideProxy(ref Down);
+                HideProxy(ref Center);
+            }
+
+            private static void HideProxy(ref Window win)
+            {
+                if (win)
+                {
+                    win.Hide();
+                }
+            }
+
+            /// <summary>
+            /// Releases proxy data and windows.
+            /// </summary>
+            public static void Dispose()
+            {
+                DisposeProxy(ref Window);
+                DisposeProxy(ref Left);
+                DisposeProxy(ref Right);
+                DisposeProxy(ref Up);
+                DisposeProxy(ref Down);
+                DisposeProxy(ref Center);
+            }
+
+            private static void DisposeProxy(ref Window win)
+            {
+                if (win)
+                {
+                    win.Close(ClosingReason.User);
+                    win = null;
+                }
+            }
+        }
+    }
+}

Source/Editor/GUI/Docking/DockPanelProxy.cs

@@ -19,7 +19,11 @@ namespace FlaxEditor.GUI.Docking
         private float _tabHeight = Editor.Instance.Options.Options.Interface.TabHeight;
         private bool _useMinimumTabWidth = Editor.Instance.Options.Options.Interface.UseMinimumTabWidth;
         private float _minimumTabWidth = Editor.Instance.Options.Options.Interface.MinimumTabWidth;
-        private readonly bool _hideTabForSingleTab = Utilities.Utils.HideSingleTabWindowTabBars();
+#if PLATFORM_WINDOWS
+        private readonly bool _hideTabForSingleTab = Editor.Instance.Options.Options.Interface.HideSingleTabWindowTabBars;
+#else
+        private readonly bool _hideTabForSingleTab = false;
+#endif
 
         /// <summary>
         /// The is mouse down flag (left button).
@@ -50,11 +54,6 @@ namespace FlaxEditor.GUI.Docking
         /// The mouse position.
         /// </summary>
         public Float2 MousePosition = Float2.Minimum;
-        
-        /// <summary>
-        /// The mouse position.
-        /// </summary>
-        public Float2 MouseStartPosition = Float2.Minimum;
 
         /// <summary>
         /// The start drag asynchronous window.
@@ -197,7 +196,7 @@ namespace FlaxEditor.GUI.Docking
                 if (_panel.ChildPanelsCount == 0 && _panel.TabsCount == 1 && _panel.IsFloating)
                 {
                     // Create docking hint window but in an async manner
-                    WindowDragHelper.StartDragging(_panel as FloatWindowDockPanel);
+                    DockHintWindow.Create(_panel as FloatWindowDockPanel);
                 }
                 else
                 {
@@ -208,7 +207,7 @@ namespace FlaxEditor.GUI.Docking
                     _panel.SelectTab(index - 1);
 
                     // Create docking hint window
-                    WindowDragHelper.StartDragging(win, _panel.RootWindow.Window);
+                    DockHintWindow.Create(win);
                 }
             }
         }
@@ -394,7 +393,6 @@ namespace FlaxEditor.GUI.Docking
             if (IsSingleFloatingWindow)
                 return base.OnMouseDown(location, button);
             MouseDownWindow = GetTabAtPos(location, out IsMouseDownOverCross);
-            MouseStartPosition = location;
 
             // Check buttons
             if (button == MouseButton.Left)
@@ -481,20 +479,6 @@ namespace FlaxEditor.GUI.Docking
                         StartDrag(MouseDownWindow);
                     MouseDownWindow = null;
                 }
-                // Check if single tab is tried to be moved
-                else if (MouseDownWindow != null && _panel.TabsCount <= 1)
-                {
-                    if ((MousePosition - MouseStartPosition).Length > 3)
-                    {
-                        // Clear flag
-                        IsMouseLeftButtonDown = false;
-
-                        // Check tab under the mouse
-                        if (!IsMouseDownOverCross && MouseDownWindow != null)
-                            StartDrag(MouseDownWindow);
-                        MouseDownWindow = null;
-                    }
-                }
                 // Check if has more than one tab to change order
                 else if (MouseDownWindow != null && _panel.TabsCount > 1)
                 {

Source/Editor/GUI/Docking/DockWindow.cs

@@ -182,25 +182,6 @@ namespace FlaxEditor.GUI.Docking
         /// <param name="size">Window size, set <see cref="Float2.Zero"/> to use default.</param>
         /// <param name="position">Window location.</param>
         public void ShowFloating(Float2 location, Float2 size, WindowStartPosition position = WindowStartPosition.CenterParent)
-        {
-            CreateFloating(location, size, position, true);
-        }
-
-        /// <summary>
-        /// Creates the window in a floating state.
-        /// </summary>
-        public void CreateFloating()
-        {
-            CreateFloating(Float2.Zero, Float2.Zero);
-        }
-        /// <summary>
-        /// Creates the window in a floating state.
-        /// </summary>
-        /// <param name="location">Window location.</param>
-        /// <param name="size">Window size, set <see cref="Float2.Zero"/> to use default.</param>
-        /// <param name="position">Window location.</param>
-        /// <param name="showWindow">Window visibility.</param>
-        public void CreateFloating(Float2 location, Float2 size, WindowStartPosition position = WindowStartPosition.CenterParent, bool showWindow = false)
         {
             Undock();
 
@@ -218,17 +199,14 @@ namespace FlaxEditor.GUI.Docking
             windowGUI.UnlockChildrenRecursive();
             windowGUI.PerformLayout();
 
-            if (showWindow)
-            {
-                // Show
-                window.Show();
-                window.BringToFront();
-                window.Focus();
-                OnShow();
+            // Show
+            window.Show();
+            window.BringToFront();
+            window.Focus();
+            OnShow();
 
-                // Perform layout again
-                windowGUI.PerformLayout();
-            }
+            // Perform layout again
+            windowGUI.PerformLayout();
         }
 
         /// <summary>

Source/Editor/GUI/Docking/FloatWindowDockPanel.cs

@@ -11,42 +11,6 @@ namespace FlaxEditor.GUI.Docking
     /// <seealso cref="DockPanel" />
     public class FloatWindowDockPanel : DockPanel
     {
-        private class FloatWindowDecorations : WindowDecorations
-        {
-            private FloatWindowDockPanel _panel;
-            
-            public FloatWindowDecorations(FloatWindowDockPanel panel)
-            : base(panel.RootWindow)
-            {
-                _panel = panel;
-            }
-            
-            /// <inheritdoc />
-            public override bool OnMouseDown(Float2 location, MouseButton button)
-            {
-                if (Title.Bounds.Contains(location) && button == MouseButton.Left)
-                {
-                    _panel.BeginDrag();
-                    return true;
-                }
-                return base.OnMouseDown(location, button);
-            }
-
-#if !PLATFORM_WINDOWS
-            /// <inheritdoc />
-            protected override WindowHitCodes OnHitTest(ref Float2 mouse)
-            {
-                var hit = base.OnHitTest(ref mouse);
-                if (hit == WindowHitCodes.Caption)
-                {
-                    // Override the system behaviour when interacting with the caption area
-                    hit = WindowHitCodes.Client;
-                }
-                return hit;
-            }
-#endif
-        }
-
         private MasterDockPanel _masterPanel;
         private WindowRootControl _window;
 
@@ -76,26 +40,6 @@ namespace FlaxEditor.GUI.Docking
             Parent = window;
             _window.Window.Closing += OnClosing;
             _window.Window.LeftButtonHit += OnLeftButtonHit;
-            
-            if (Utilities.Utils.UseCustomWindowDecorations())
-            {
-                var decorations = Parent.AddChild(new FloatWindowDecorations(this));
-                decorations.SetAnchorPreset(AnchorPresets.HorizontalStretchTop, false);
-            }
-        }
-        
-        /// <inheritdoc />
-        protected override void PerformLayoutBeforeChildren()
-        {
-            base.PerformLayoutBeforeChildren();
-            
-            var decorations = Parent.GetChild<FloatWindowDecorations>();
-            if (decorations != null)
-            {
-                // Apply offset for the title bar
-                foreach (var child in Children)
-                    child.Bounds = child.Bounds with { Y = decorations.Height, Height = Parent.Height - decorations.Height };
-            }
         }
 
         /// <summary>
@@ -108,7 +52,7 @@ namespace FlaxEditor.GUI.Docking
                 return;
 
             // Create docking hint window
-            WindowDragHelper.StartDragging(this);
+            DockHintWindow.Create(this);
         }
 
         /// <summary>
@@ -127,28 +71,22 @@ namespace FlaxEditor.GUI.Docking
             settings.Title = title;
             settings.Size = size;
             settings.Position = location;
-            settings.MinimumSize = new Float2(200, 150);
+            settings.MinimumSize = new Float2(1);
             settings.MaximumSize = Float2.Zero; // Unlimited size
             settings.Fullscreen = false;
             settings.HasBorder = true;
-            settings.SupportsTransparency = true;
+            settings.SupportsTransparency = false;
             settings.ActivateWhenFirstShown = true;
             settings.AllowInput = true;
             settings.AllowMinimize = true;
             settings.AllowMaximize = true;
             settings.AllowDragAndDrop = true;
             settings.IsTopmost = false;
-            settings.Type = WindowType.Regular;
+            settings.IsRegularWindow = true;
             settings.HasSizingFrame = true;
             settings.ShowAfterFirstPaint = false;
             settings.ShowInTaskbar = true;
             settings.StartPosition = startPosition;
-            
-            if (Utilities.Utils.UseCustomWindowDecorations())
-            {
-                settings.HasBorder = false;
-                //settings.HasSizingFrame = false;
-            }
 
             // Create window
             return Platform.CreateWindow(ref settings);

Source/Editor/GUI/Docking/MasterDockPanel.cs

@@ -81,6 +81,7 @@ namespace FlaxEditor.GUI.Docking
         public DockPanel HitTest(ref Float2 position, FloatWindowDockPanel excluded)
         {
             // Check all floating windows
+            // TODO: gather windows order and take it into account when performing test
             for (int i = 0; i < FloatingPanels.Count; i++)
             {
                 var win = FloatingPanels[i];
@@ -93,44 +94,9 @@ namespace FlaxEditor.GUI.Docking
             }
 
             // Base
-            //if (!Root?.RootWindow.Window.IsFocused ?? false)
-            //    return null;
             return base.HitTest(ref position);
         }
 
-        /// <summary>
-        /// Performs hit test over dock panel.
-        /// </summary>
-        /// <param name="position">Window space position to test.</param>
-        /// <param name="excluded">Floating window to omit during searching (and all docked to that one).</param>
-        /// <param name="hitResults">Results of the hit test</param>
-        /// <returns>True if any dock panels were hit, otherwise false.</returns>
-        public bool HitTest(ref Float2 position, FloatWindowDockPanel excluded, out DockPanel[] hitResults)
-        {
-            // Check all floating windows
-            List<DockPanel> results = new(FloatingPanels.Count);
-            for (int i = 0; i < FloatingPanels.Count; i++)
-            {
-                var win = FloatingPanels[i];
-                if (win.Visible && win != excluded)
-                {
-                    var result = win.HitTest(ref position);
-                    if (result != null)
-                        results.Add(result);
-                }
-            }
-
-            // Base
-            //if (!Root?.RootWindow.Window.IsFocused ?? false)
-            //    return null;
-            var baseResult = base.HitTest(ref position);
-            if (baseResult != null)
-                results.Add(baseResult);
-
-            hitResults = results.ToArray();
-            return hitResults.Length > 0;
-        }
-
         internal void LinkWindow(DockWindow window)
         {
             // Add to the windows list

Source/Editor/GUI/Docking/WindowDragHelper.cs

@@ -1,458 +0,0 @@
-// Copyright (c) Wojciech Figat. All rights reserved.
-
-using System;
-using FlaxEngine;
-using FlaxEngine.GUI;
-
-namespace FlaxEditor.GUI.Docking
-{
-    /// <summary>
-    /// Helper class used to handle docking windows dragging and docking.
-    /// </summary>
-    public class WindowDragHelper
-    {
-        private FloatWindowDockPanel _toMove;
-
-        private Float2 _dragOffset;
-        private Rectangle _rectDock;
-        private Float2 _mouse;
-        private DockState _toSet;
-        private DockPanel _toDock;
-        private Window _dragSourceWindow;
-
-        private Rectangle _rLeft, _rRight, _rBottom, _rUpper, _rCenter;
-        private Control _dockHintDown, _dockHintUp, _dockHintLeft, _dockHintRight, _dockHintCenter;
-
-        /// <summary>
-        /// The hint control size.
-        /// </summary>
-        public const float HintControlSize = 32.0f;
-
-        /// <summary>
-        /// The opacity of the dragged window when hint controls are shown.
-        /// </summary>
-        public const float DragWindowOpacity = 0.4f;
-        
-        /// <summary>
-        /// Returns true if any windows are being dragged.
-        /// </summary>
-        public static bool IsDragActive { get; private set; }
-
-        private WindowDragHelper(FloatWindowDockPanel toMove, Window dragSourceWindow)
-        {
-            IsDragActive = true;
-            _toMove = toMove;
-            _toSet = DockState.Float;
-            var window = toMove.Window.Window;
-
-            // Bind events
-            FlaxEngine.Scripting.Update += OnUpdate;
-            window.MouseUp += OnMouseUp;
-            
-            // Update rectangles
-            UpdateRects(Platform.MousePosition);
-            
-            // Ensure the dragged window stays on top of every other window
-            window.IsAlwaysOnTop = true;
-
-            _dragSourceWindow = dragSourceWindow;
-            if (_dragSourceWindow != null) // Detaching a tab from existing window
-            {
-                _dragOffset = new Float2(window.Size.X / 2, 10.0f);
-                
-                _dragSourceWindow.MouseUp += OnMouseUp; // The mouse up event is sent to the source window on Windows
-
-                // TODO: when detaching tab in floating window (not main window), the drag source window is still main window?
-                var dragSourceWindowWayland = toMove.MasterPanel?.RootWindow.Window ?? Editor.Instance.Windows.MainWindow;
-                window.DoDragDrop(window.Title, _dragOffset, dragSourceWindowWayland);
-            }
-            else
-            {
-                _dragOffset = window.MousePosition;
-                window.DoDragDrop(window.Title, _dragOffset, window);
-            }
-        }
-
-        /// <summary>
-        /// Releases unmanaged and - optionally - managed resources.
-        /// </summary>
-        public void Dispose()
-        {
-            IsDragActive = false;
-            var window = _toMove?.Window?.Window;
-
-            // Unbind events
-            FlaxEngine.Scripting.Update -= OnUpdate;
-            if (window != null)
-                window.MouseUp -= OnMouseUp;
-            if (_dragSourceWindow != null)
-                _dragSourceWindow.MouseUp -= OnMouseUp;
-
-            RemoveDockHints();
-
-            if (_toMove == null)
-                return;
-
-            if (window != null)
-            {
-                window.Opacity = 1.0f;
-                window.IsAlwaysOnTop = false;
-                window.BringToFront();
-            }
-
-            // Check if window won't be docked
-            if (_toSet == DockState.Float)
-            {
-                if (window == null)
-                    return;
-
-                // Show base window
-                window.Show();
-            }
-            else
-            {
-                bool hasNoChildPanels = _toMove.ChildPanelsCount == 0;
-
-                // Check if window has only single tab
-                if (hasNoChildPanels && _toMove.TabsCount == 1)
-                {
-                    // Dock window
-                    _toMove.GetTab(0).Show(_toSet, _toDock);
-                }
-                // Check if dock as tab and has no child panels
-                else if (hasNoChildPanels && _toSet == DockState.DockFill)
-                {
-                    // Dock all tabs
-                    while (_toMove.TabsCount > 0)
-                    {
-                        _toMove.GetTab(0).Show(DockState.DockFill, _toDock);
-                    }
-                }
-                else
-                {
-                    var selectedTab = _toMove.SelectedTab;
-
-                    // Dock the first tab into the target location
-                    if (_toMove.TabsCount > 0)
-                    {
-                        var firstTab = _toMove.GetTab(0);
-                        firstTab.Show(_toSet, _toDock);
-
-                        // Dock rest of the tabs
-                        while (_toMove.TabsCount > 0)
-                        {
-                            _toMove.GetTab(0).Show(DockState.DockFill, firstTab);
-                        }
-                    }
-
-                    // Keep selected tab being selected
-                    selectedTab?.SelectTab();
-                }
-
-                // Focus target window
-                _toDock.Root.Focus();
-            }
-
-            _toMove = null;
-        }
-
-        /// <summary>
-        /// Start dragging a floating dock panel.
-        /// </summary>
-        /// <param name="toMove">Floating dock panel to move.</param>
-        /// <returns>The window drag helper object.</returns>
-        public static WindowDragHelper StartDragging(FloatWindowDockPanel toMove)
-        {
-            if (toMove == null)
-                throw new ArgumentNullException();
-
-            return new WindowDragHelper(toMove, null);
-        }
-
-        /// <summary>
-        /// Start dragging a docked panel into a floating window.
-        /// </summary>
-        /// <param name="toMove">Dock window to move.</param>
-        /// <param name="dragSourceWindow">The window where dragging started from.</param>
-        /// <returns>The window drag helper object.</returns>
-        public static WindowDragHelper StartDragging(DockWindow toMove, Window dragSourceWindow)
-        {
-            if (toMove == null)
-                throw new ArgumentNullException();
-
-            // Create floating window
-            toMove.CreateFloating();
-
-            // Get floating panel
-            var window = (WindowRootControl)toMove.Root;
-            var floatingPanelToMove = window.GetChild(0) as FloatWindowDockPanel;
-
-            return new WindowDragHelper(floatingPanelToMove, dragSourceWindow);
-        }
-
-        private sealed class DragVisuals : Control
-        {
-            public DragVisuals()
-            {
-                AnchorPreset = AnchorPresets.StretchAll;
-                Offsets = Margin.Zero;
-            }
-
-            public override void Draw()
-            {
-                base.Draw();
-                Render2D.DrawRectangle(new Rectangle(Float2.Zero, Size), Style.Current.SelectionBorder);
-            }
-        }
-
-        private void AddDockHints()
-        {
-            if (_toDock == null)
-                return;
-
-            if (_toDock.RootWindow.Window != _dragSourceWindow)
-                _toDock.RootWindow.Window.MouseUp += OnMouseUp;
-
-            _dockHintDown = AddHintControl(new Float2(0.5f, 1));
-            _dockHintUp = AddHintControl(new Float2(0.5f, 0));
-            _dockHintLeft = AddHintControl(new Float2(0, 0.5f));
-            _dockHintRight = AddHintControl(new Float2(1, 0.5f));
-            _dockHintCenter = AddHintControl(new Float2(0.5f, 0.5f));
-
-            Control AddHintControl(Float2 pivot)
-            {
-                DragVisuals hintControl = _toDock.AddChild<DragVisuals>();
-                hintControl.Size = new Float2(HintControlSize);
-                hintControl.BackgroundColor = Style.Current.Selection.AlphaMultiplied(0.6f);
-                hintControl.Pivot = pivot;
-                hintControl.PivotRelative = true;
-                return hintControl;
-            }
-        }
-        
-        private void RemoveDockHints()
-        {
-            if (_toDock == null)
-                return;
-
-            if (_toDock.RootWindow.Window != _dragSourceWindow)
-                _toDock.RootWindow.Window.MouseUp -= OnMouseUp;
-
-            _dockHintDown?.Parent.RemoveChild(_dockHintDown);
-            _dockHintUp?.Parent.RemoveChild(_dockHintUp);
-            _dockHintLeft?.Parent.RemoveChild(_dockHintLeft);
-            _dockHintRight?.Parent.RemoveChild(_dockHintRight);
-            _dockHintCenter?.Parent.RemoveChild(_dockHintCenter);
-            _dockHintDown = _dockHintUp = _dockHintLeft = _dockHintRight = _dockHintCenter = null;
-        }
-
-        private void UpdateRects(Float2 mousePos)
-        {
-            // Cache mouse position
-            _mouse = mousePos;
-
-            // Check intersection with any dock panel
-            DockPanel dockPanel = null;
-            if (_toMove.MasterPanel.HitTest(ref _mouse, _toMove, out var hitResults))
-            {
-                dockPanel = hitResults[0];
-
-                // Prefer panel which currently has focus
-                foreach (var hit in hitResults)
-                {
-                    if (hit.RootWindow.Window.IsFocused)
-                    {
-                        dockPanel = hit;
-                        break;
-                    }
-                }
-
-                // Prefer panel in the same window we hit earlier
-                if (dockPanel?.RootWindow != _toDock?.RootWindow)
-                {
-                    foreach (var hit in hitResults)
-                    {
-                        if (hit.RootWindow == _toDock?.RootWindow)
-                        {
-                            dockPanel = _toDock;
-                            break;
-                        }
-                    }
-                }
-            }
-            
-            if (dockPanel != _toDock)
-            {
-                RemoveDockHints();
-                _toDock = dockPanel;
-                AddDockHints();
-
-                // Make sure the all the dock hint areas are not under other windows
-                _toDock?.RootWindow.Window.BringToFront();
-                //_toDock?.RootWindow.Window.Focus();
-
-                // Make the dragged window transparent when dock hints are visible
-                _toMove.Window.Window.Opacity = _toDock == null ? 1.0f : DragWindowOpacity;
-            }
-            
-            // Check dock state to use
-            bool showProxyHints = _toDock != null;
-            bool showBorderHints = showProxyHints;
-            bool showCenterHint = showProxyHints;
-            Control hoveredHintControl = null;
-            Float2 hoveredSizeOverride = Float2.Zero;
-            if (showProxyHints)
-            {
-                // If moved window has not only tabs but also child panels disable docking as tab
-                if (_toMove.ChildPanelsCount > 0)
-                    showCenterHint = false;
-
-                // Disable docking windows with one or more dock panels inside
-                if (_toMove.ChildPanelsCount > 0)
-                    showBorderHints = false;
-
-                // Get dock area
-                _rectDock = _toDock.DockAreaBounds;
-
-                // Cache dock rectangles
-                var size = _rectDock.Size / Platform.DpiScale;
-                var offset = _toDock.PointFromScreen(_rectDock.Location);
-                var borderMargin = 4.0f;
-                var hintWindowsSize = HintControlSize;
-                var hintWindowsSize2 = hintWindowsSize * 0.5f;
-                var hintPreviewSize = new Float2(Math.Max(HintControlSize * 2, size.X * 0.5f), Math.Max(HintControlSize * 2, size.Y * 0.5f));
-                var centerX = size.X * 0.5f;
-                var centerY = size.Y * 0.5f;
-                _rUpper = new Rectangle(centerX - hintWindowsSize2, borderMargin, hintWindowsSize, hintWindowsSize) + offset;
-                _rBottom = new Rectangle(centerX - hintWindowsSize2, size.Y - hintWindowsSize - borderMargin, hintWindowsSize, hintWindowsSize) + offset;
-                _rLeft = new Rectangle(borderMargin, centerY - hintWindowsSize2, hintWindowsSize, hintWindowsSize) + offset;
-                _rRight = new Rectangle(size.X - hintWindowsSize - borderMargin, centerY - hintWindowsSize2, hintWindowsSize, hintWindowsSize) + offset;
-                _rCenter = new Rectangle(centerX - hintWindowsSize2, centerY - hintWindowsSize2, hintWindowsSize, hintWindowsSize) + offset;
-
-                // Hit test, and calculate the approximation for filled area when hovered over the hint
-                DockState toSet = DockState.Float;
-                if (showBorderHints)
-                {
-                    if (_rUpper.Contains(_toDock.PointFromScreen(_mouse)))
-                    {
-                        toSet = DockState.DockTop;
-                        hoveredHintControl = _dockHintUp;
-                        hoveredSizeOverride = new Float2(size.X, hintPreviewSize.Y);
-                    }
-                    else if (_rBottom.Contains(_toDock.PointFromScreen(_mouse)))
-                    {
-                        toSet = DockState.DockBottom;
-                        hoveredHintControl = _dockHintDown;
-                        hoveredSizeOverride = new Float2(size.X, hintPreviewSize.Y);
-                    }
-                    else if (_rLeft.Contains(_toDock.PointFromScreen(_mouse)))
-                    {
-                        toSet = DockState.DockLeft;
-                        hoveredHintControl = _dockHintLeft;
-                        hoveredSizeOverride = new Float2(hintPreviewSize.X, size.Y);
-                    }
-                    else if (_rRight.Contains(_toDock.PointFromScreen(_mouse)))
-                    {
-                        toSet = DockState.DockRight;
-                        hoveredHintControl = _dockHintRight;
-                        hoveredSizeOverride = new Float2(hintPreviewSize.X, size.Y);
-                    }
-                }
-                if (showCenterHint && _rCenter.Contains(_toDock.PointFromScreen(_mouse)))
-                {
-                    toSet = DockState.DockFill;
-                    hoveredHintControl = _dockHintCenter;
-                    hoveredSizeOverride = new Float2(size.X, size.Y);
-                }
-
-                _toSet = toSet;
-            }
-            else
-            {
-                _toSet = DockState.Float;
-            }
-            
-            // Update sizes and opacity of hint controls
-            if (_toDock != null)
-            {
-                if (hoveredHintControl != _dockHintDown)
-                {
-                    _dockHintDown.Size = new Float2(HintControlSize);
-                    _dockHintDown.BackgroundColor = Style.Current.Selection.AlphaMultiplied(0.6f);
-                }
-                if (hoveredHintControl != _dockHintLeft)
-                {
-                    _dockHintLeft.Size = new Float2(HintControlSize);
-                    _dockHintLeft.BackgroundColor = Style.Current.Selection.AlphaMultiplied(0.6f);
-                }
-                if (hoveredHintControl != _dockHintRight)
-                {
-                    _dockHintRight.Size = new Float2(HintControlSize);
-                    _dockHintRight.BackgroundColor = Style.Current.Selection.AlphaMultiplied(0.6f);
-                }
-                if (hoveredHintControl != _dockHintUp)
-                {
-                    _dockHintUp.Size = new Float2(HintControlSize);
-                    _dockHintUp.BackgroundColor = Style.Current.Selection.AlphaMultiplied(0.6f);
-                }
-                if (hoveredHintControl != _dockHintCenter)
-                {
-                    _dockHintCenter.Size = new Float2(HintControlSize);
-                    _dockHintCenter.BackgroundColor = Style.Current.Selection.AlphaMultiplied(0.6f);
-                }
-
-                if (_toSet != DockState.Float)
-                {
-                    if (hoveredHintControl != null)
-                    {
-                        hoveredHintControl.BackgroundColor = Style.Current.Selection.AlphaMultiplied(1.0f);
-                        hoveredHintControl.Size = hoveredSizeOverride;
-                    }
-                }
-            }
-
-            // Update hint controls visibility and location
-            if (showProxyHints)
-            {
-                if (hoveredHintControl != _dockHintDown)
-                    _dockHintDown.Location = _rBottom.Location;
-                if (hoveredHintControl != _dockHintLeft)
-                    _dockHintLeft.Location = _rLeft.Location;
-                if (hoveredHintControl != _dockHintRight)
-                    _dockHintRight.Location = _rRight.Location;
-                if (hoveredHintControl != _dockHintUp)
-                    _dockHintUp.Location = _rUpper.Location;
-                if (hoveredHintControl != _dockHintCenter)
-                    _dockHintCenter.Location = _rCenter.Location;
-                
-                _dockHintDown.Visible = showProxyHints & showBorderHints;
-                _dockHintLeft.Visible = showProxyHints & showBorderHints;
-                _dockHintRight.Visible = showProxyHints & showBorderHints;
-                _dockHintUp.Visible = showProxyHints & showBorderHints;
-                _dockHintCenter.Visible = showProxyHints & showCenterHint;
-            }
-        }
-
-        private void OnMouseUp(ref Float2 location, MouseButton button, ref bool handled)
-        {
-            if (button == MouseButton.Left)
-                Dispose();
-        }
-
-        private void OnUpdate()
-        {
-            var mousePos = Platform.MousePosition;
-
-            if (_mouse != mousePos)
-                OnMouseMove(mousePos);
-        }
-        
-        private void OnMouseMove(Float2 mousePos)
-        {
-            if (_dragSourceWindow != null)
-                _toMove.Window.Window.Position = mousePos - _dragOffset;
-
-            UpdateRects(mousePos);
-        }
-    }
-}

Source/Editor/GUI/Input/ValueBox.cs

@@ -266,7 +266,6 @@ namespace FlaxEditor.GUI.Input
             return base.OnMouseDown(location, button);
         }
 
-#if !PLATFORM_SDL
         /// <inheritdoc />
         public override void OnMouseMove(Float2 location)
         {
@@ -293,45 +292,13 @@ namespace FlaxEditor.GUI.Input
             base.OnMouseMove(location);
         }
 
-#else
-
-        /// <inheritdoc />
-        public override void OnMouseMoveRelative(Float2 mouseMotion)
-        {
-            var location = Root.TrackingMouseOffset;
-            if (_isSliding)
-            {
-                // Update sliding
-                ApplySliding(Root.TrackingMouseOffset.X * _slideSpeed);
-                return;
-            }
-
-            // Update cursor type so user knows they can slide value
-            if (CanUseSliding && SlideRect.Contains(location) && !_isSliding)
-            {
-                Cursor = CursorType.SizeWE;
-                _cursorChanged = true;
-            }
-            else if (_cursorChanged && !_isSliding)
-            {
-                Cursor = CursorType.Default;
-                _cursorChanged = false;
-            }
-
-            base.OnMouseMoveRelative(mouseMotion);
-        }
-
-#endif
-
         /// <inheritdoc />
         public override bool OnMouseUp(Float2 location, MouseButton button)
         {
             if (button == MouseButton.Left && _isSliding)
             {
-#if !PLATFORM_SDL
                 // End sliding and return mouse to original location
                 RootWindow.MousePosition = _mouseClickedPosition;
-#endif
                 EndSliding();
                 return true;
             }

Source/Editor/GUI/MainMenu.cs

@@ -12,6 +12,16 @@ namespace FlaxEditor.GUI
     /// <seealso cref="FlaxEngine.GUI.ContainerControl" />
     public sealed class MainMenu : ContainerControl
     {
+#if PLATFORM_WINDOWS
+        private bool _useCustomWindowSystem;
+        private Image _icon;
+        private Label _title;
+        private Button _closeButton;
+        private Button _minimizeButton;
+        private Button _maximizeButton;
+        private LocalizedString _charChromeRestore, _charChromeMaximize;
+        private Window _window;
+#endif
         private MainMenuButton _selected;
 
         /// <summary>
@@ -50,12 +60,200 @@ namespace FlaxEditor.GUI
         /// <summary>
         /// Initializes a new instance of the <see cref="MainMenu"/> class.
         /// </summary>
-        public MainMenu()
+        /// <param name="mainWindow">The main window.</param>
+        public MainMenu(RootControl mainWindow)
         : base(0, 0, 0, 20)
         {
             AutoFocus = false;
             AnchorPreset = AnchorPresets.HorizontalStretchTop;
-            BackgroundColor = Style.Current.LightBackground;
+
+#if PLATFORM_WINDOWS
+            _useCustomWindowSystem = !Editor.Instance.Options.Options.Interface.UseNativeWindowSystem;
+            if (_useCustomWindowSystem)
+            {
+                BackgroundColor = Style.Current.LightBackground;
+                Height = 28;
+
+                var windowIcon = FlaxEngine.Content.LoadAsyncInternal<Texture>(EditorAssets.WindowIcon);
+                FontAsset windowIconsFont = FlaxEngine.Content.LoadAsyncInternal<FontAsset>(EditorAssets.WindowIconsFont);
+                Font iconFont = windowIconsFont?.CreateFont(9);
+
+                _window = mainWindow.RootWindow.Window;
+                _window.HitTest += OnHitTest;
+                _window.Closed += OnWindowClosed;
+
+                ScriptsBuilder.GetBinariesConfiguration(out _, out _, out _, out var configuration);
+
+                _icon = new Image
+                {
+                    Margin = new Margin(6, 6, 6, 6),
+                    Brush = new TextureBrush(windowIcon),
+                    Color = Style.Current.Foreground,
+                    KeepAspectRatio = false,
+                    TooltipText = string.Format("{0}\nVersion {1}\nConfiguration {3}\nGraphics {2}", _window.Title, Globals.EngineVersion, GPUDevice.Instance.RendererType, configuration),
+                    Parent = this,
+                };
+
+                _title = new Label(0, 0, Width, Height)
+                {
+                    Text = _window.Title,
+                    HorizontalAlignment = TextAlignment.Center,
+                    VerticalAlignment = TextAlignment.Center,
+                    ClipText = true,
+                    TextColor = Style.Current.ForegroundGrey,
+                    TextColorHighlighted = Style.Current.ForegroundGrey,
+                    Parent = this,
+                };
+
+                _closeButton = new Button
+                {
+                    Text = ((char)EditorAssets.SegMDL2Icons.ChromeClose).ToString(),
+                    Font = new FontReference(iconFont),
+                    BackgroundColor = Color.Transparent,
+                    BorderColor = Color.Transparent,
+                    BorderColorHighlighted = Color.Transparent,
+                    BorderColorSelected = Color.Transparent,
+                    TextColor = Style.Current.Foreground,
+                    Width = 46,
+                    BackgroundColorHighlighted = Color.Red,
+                    BackgroundColorSelected = Color.Red.RGBMultiplied(1.3f),
+                    Parent = this,
+                };
+                _closeButton.Clicked += () => _window.Close(ClosingReason.User);
+
+                _minimizeButton = new Button
+                {
+                    Text = ((char)EditorAssets.SegMDL2Icons.ChromeMinimize).ToString(),
+                    Font = new FontReference(iconFont),
+                    BackgroundColor = Color.Transparent,
+                    BorderColor = Color.Transparent,
+                    BorderColorHighlighted = Color.Transparent,
+                    BorderColorSelected = Color.Transparent,
+                    TextColor = Style.Current.Foreground,
+                    Width = 46,
+                    BackgroundColorHighlighted = Style.Current.LightBackground.RGBMultiplied(1.3f),
+                    Parent = this,
+                };
+                _minimizeButton.Clicked += () => _window.Minimize();
+
+                _maximizeButton = new Button
+                {
+                    Text = ((char)(_window.IsMaximized ? EditorAssets.SegMDL2Icons.ChromeRestore : EditorAssets.SegMDL2Icons.ChromeMaximize)).ToString(),
+                    Font = new FontReference(iconFont),
+                    BackgroundColor = Color.Transparent,
+                    BorderColor = Color.Transparent,
+                    BorderColorHighlighted = Color.Transparent,
+                    BorderColorSelected = Color.Transparent,
+                    TextColor = Style.Current.Foreground,
+                    Width = 46,
+                    BackgroundColorHighlighted = Style.Current.LightBackground.RGBMultiplied(1.3f),
+                    Parent = this,
+                };
+                _maximizeButton.Clicked += () =>
+                {
+                    if (_window.IsMaximized)
+                        _window.Restore();
+                    else
+                        _window.Maximize();
+                };
+                _charChromeRestore = ((char)EditorAssets.SegMDL2Icons.ChromeRestore).ToString();
+                _charChromeMaximize = ((char)EditorAssets.SegMDL2Icons.ChromeMaximize).ToString();
+            }
+            else
+#endif
+            {
+                BackgroundColor = Style.Current.LightBackground;
+            }
+        }
+
+#if PLATFORM_WINDOWS
+        /// <inheritdoc />
+        public override void Update(float deltaTime)
+        {
+            base.Update(deltaTime);
+
+            if (_maximizeButton != null)
+            {
+                _maximizeButton.Text = _window.IsMaximized ? _charChromeRestore : _charChromeMaximize;
+            }
+        }
+
+        private void OnWindowClosed()
+        {
+            if (_window != null)
+            {
+                _window.HitTest = null;
+                _window = null;
+            }
+        }
+
+        private WindowHitCodes OnHitTest(ref Float2 mouse)
+        {
+            var dpiScale = _window.DpiScale;
+
+            if (_window.IsMinimized)
+                return WindowHitCodes.NoWhere;
+
+            if (!_window.IsMaximized)
+            {
+                var pos = _window.ScreenToClient(mouse * dpiScale); // pos is not DPI adjusted
+                var winSize = _window.Size;
+
+                // Distance from which the mouse is considered to be on the border/corner
+                float distance = 5.0f * dpiScale;
+
+                if (pos.Y > winSize.Y - distance && pos.X < distance)
+                    return WindowHitCodes.BottomLeft;
+
+                if (pos.X > winSize.X - distance && pos.Y > winSize.Y - distance)
+                    return WindowHitCodes.BottomRight;
+
+                if (pos.Y < distance && pos.X < distance)
+                    return WindowHitCodes.TopLeft;
+
+                if (pos.Y < distance && pos.X > winSize.X - distance)
+                    return WindowHitCodes.TopRight;
+
+                if (pos.X > winSize.X - distance)
+                    return WindowHitCodes.Right;
+
+                if (pos.X < distance)
+                    return WindowHitCodes.Left;
+
+                if (pos.Y < distance)
+                    return WindowHitCodes.Top;
+
+                if (pos.Y > winSize.Y - distance)
+                    return WindowHitCodes.Bottom;
+            }
+
+            var mousePos = PointFromScreen(mouse * dpiScale);
+            var controlUnderMouse = GetChildAt(mousePos);
+            var isMouseOverSth = controlUnderMouse != null && controlUnderMouse != _title;
+            var rb = GetRightButton();
+            if (rb != null && _minimizeButton != null && new Rectangle(rb.UpperRight, _minimizeButton.BottomLeft - rb.UpperRight).Contains(ref mousePos) && !isMouseOverSth)
+                return WindowHitCodes.Caption;
+
+            return WindowHitCodes.Client;
+        }
+#endif
+
+        /// <summary>
+        /// Return the rightmost button.
+        /// </summary>
+        /// <returns>Rightmost button, null if there is no <see cref="MainMenuButton"/></returns>
+        private MainMenuButton GetRightButton()
+        {
+            MainMenuButton b = null;
+            foreach (var control in Children)
+            {
+                if (b == null && control is MainMenuButton)
+                    b = (MainMenuButton)control;
+
+                if (control is MainMenuButton && control.Right > b.Right)
+                    b = (MainMenuButton)control;
+            }
+            return b;
         }
 
         /// <summary>
@@ -100,6 +298,26 @@ namespace FlaxEditor.GUI
             return result;
         }
 
+        /// <inheritdoc />
+        public override bool OnMouseDoubleClick(Float2 location, MouseButton button)
+        {
+            if (base.OnMouseDoubleClick(location, button))
+                return true;
+
+#if PLATFORM_WINDOWS
+            var child = GetChildAtRecursive(location);
+            if (_useCustomWindowSystem && child is not Button && child is not MainMenuButton)
+            {
+                if (_window.IsMaximized)
+                    _window.Restore();
+                else
+                    _window.Maximize();
+            }
+#endif
+
+            return true;
+        }
+
         /// <inheritdoc />
         public override bool OnKeyDown(KeyboardKeys key)
         {
@@ -115,8 +333,16 @@ namespace FlaxEditor.GUI
         protected override void PerformLayoutAfterChildren()
         {
             float x = 0;
-            WindowDecorations decorations = Parent.GetChild<WindowDecorations>();
-            x += decorations?.Icon?.Width ?? 0;
+
+#if PLATFORM_WINDOWS
+            if (_useCustomWindowSystem)
+            {
+                // Icon
+                _icon.X = x;
+                _icon.Size = new Float2(Height);
+                x += _icon.Width;
+            }
+#endif
 
             // Arrange controls
             MainMenuButton rightMostButton = null;
@@ -135,21 +361,37 @@ namespace FlaxEditor.GUI
                     x += b.Width;
                 }
             }
-            
-            // Fill the right side if title and buttons are not present
-            if (decorations?.Title == null)
-                Width = Parent.Width;
-            else
-                Width = x;
+
+#if PLATFORM_WINDOWS
+            if (_useCustomWindowSystem)
+            {
+                // Buttons
+                _closeButton.Height = Height;
+                _closeButton.X = Width - _closeButton.Width;
+                _maximizeButton.Height = Height;
+                _maximizeButton.X = _closeButton.X - _maximizeButton.Width;
+                _minimizeButton.Height = Height;
+                _minimizeButton.X = _maximizeButton.X - _minimizeButton.Width;
+
+                // Title
+                _title.Bounds = new Rectangle(x + 2, 0, _minimizeButton.Left - x - 4, Height);
+                //_title.Text = _title.Width < 300.0f ? Editor.Instance.ProjectInfo.Name : _window.Title;
+            }
+#endif
         }
 
+#if PLATFORM_WINDOWS
         /// <inheritdoc />
         public override void OnDestroy()
         {
             base.OnDestroy();
-            
-            if (_selected != null)
-                Selected = null;
+
+            if (_window != null)
+            {
+                _window.Closed -= OnWindowClosed;
+                OnWindowClosed();
+            }
         }
+#endif
     }
 }

Source/Editor/GUI/MainMenuButton.cs

@@ -42,12 +42,14 @@ namespace FlaxEditor.GUI
             Text = text;
 
             var style = Style.Current;
-            if (!Utilities.Utils.UseCustomWindowDecorations())
+#if PLATFORM_WINDOWS
+            if (Editor.Instance.Options.Options.Interface.UseNativeWindowSystem)
             {
                 BackgroundColorMouseOver = style.BackgroundHighlighted;
                 BackgroundColorMouseOverOpened = style.Background;
             }
             else
+#endif
             {
                 BackgroundColorMouseOver = BackgroundColorMouseOverOpened = style.LightBackground * 1.3f;
             }

Source/Editor/GUI/WindowDecorations.cs

@@ -1,342 +0,0 @@
-// Copyright (c) Wojciech Figat. All rights reserved.
-
-using System;
-using FlaxEditor.GUI.Docking;
-using FlaxEditor.Options;
-using FlaxEngine;
-using FlaxEngine.GUI;
-
-namespace FlaxEditor.GUI;
-
-/// <summary>
-/// Represents the title bar of the window with buttons.
-/// </summary>
-/// <seealso cref="FlaxEngine.GUI.ContainerControl" />
-public class WindowDecorations : ContainerControl
-{
-    private Image _icon;
-    private Label _title;
-    private Button _closeButton;
-    private Button _minimizeButton;
-    private Button _maximizeButton;
-    private LocalizedString _charChromeRestore, _charChromeMaximize;
-    private Window _window;
-
-    /// <summary>
-    /// The title label in the title bar.
-    /// </summary>
-    public Label Title => _title;
-    
-    /// <summary>
-    /// The icon used in the title bar.
-    /// </summary>
-    public Image Icon => _icon;
-    
-    /// <summary>
-    /// The tooltip shown when hovering over the icon.
-    /// </summary>
-    public string IconTooltipText
-    {
-        get => _icon?.TooltipText ?? null;
-        set
-        {
-            if (_icon != null)
-                _icon.TooltipText = value;
-        }
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="WindowDecorations"/> class.
-    /// </summary>
-    /// <param name="window">The window.</param>
-    /// <param name="iconOnly">When set, omit drawing title and buttons.</param>
-    public WindowDecorations(RootControl window, bool iconOnly = false)
-    : base(0, 0, 0, 20)
-    {
-        _window = window.RootWindow.Window;
-        
-        AutoFocus = false;
-        AnchorPreset = AnchorPresets.HorizontalStretchTop;
-        BackgroundColor = Color.Transparent;
-
-        var windowIcon = FlaxEngine.Content.LoadAsyncInternal<Texture>(EditorAssets.WindowIcon);
-
-        _icon = new Image
-        {
-            Margin = new Margin(4, 4, 4, 4),
-            Brush = new TextureBrush(windowIcon),
-            Color = Style.Current.Foreground,
-            BackgroundColor = Style.Current.LightBackground,
-            KeepAspectRatio = false,
-            Parent = this,
-        };
-
-        if (!iconOnly)
-        {
-            _icon.Margin = new Margin(6, 6, 6, 6);
-            Height = 28;
-            
-            _window.HitTest += OnHitTest;
-            _window.Closed += OnWindowClosed;
-            
-            FontAsset windowIconsFont = FlaxEngine.Content.LoadAsyncInternal<FontAsset>(EditorAssets.WindowIconsFont);
-            Font iconFont = windowIconsFont?.CreateFont(9);
-            
-            _title = new Label(0, 0, Width, Height)
-            {
-                Text = _window.Title,
-                HorizontalAlignment = TextAlignment.Center,
-                VerticalAlignment = TextAlignment.Center,
-                ClipText = true,
-                TextColor = Style.Current.ForegroundGrey,
-                TextColorHighlighted = Style.Current.ForegroundGrey,
-                BackgroundColor = Style.Current.LightBackground,
-                Parent = this,
-            };
-
-            _closeButton = new Button
-            {
-                Text = ((char)EditorAssets.SegMDL2Icons.ChromeClose).ToString(),
-                Font = new FontReference(iconFont),
-                BackgroundColor = Style.Current.LightBackground,
-                BorderColor = Color.Transparent,
-                BorderColorHighlighted = Color.Transparent,
-                BorderColorSelected = Color.Transparent,
-                TextColor = Style.Current.Foreground,
-                Width = 46,
-                BackgroundColorHighlighted = Color.Red,
-                BackgroundColorSelected = Color.Red.RGBMultiplied(1.3f),
-                Parent = this,
-            };
-            _closeButton.Clicked += () => _window.Close(ClosingReason.User);
-
-            _minimizeButton = new Button
-            {
-                Text = ((char)EditorAssets.SegMDL2Icons.ChromeMinimize).ToString(),
-                Font = new FontReference(iconFont),
-                BackgroundColor = Style.Current.LightBackground,
-                BorderColor = Color.Transparent,
-                BorderColorHighlighted = Color.Transparent,
-                BorderColorSelected = Color.Transparent,
-                TextColor = Style.Current.Foreground,
-                Width = 46,
-                BackgroundColorHighlighted = Style.Current.LightBackground.RGBMultiplied(1.3f),
-                Parent = this,
-            };
-            _minimizeButton.Clicked += () => _window.Minimize();
-
-            _maximizeButton = new Button
-            {
-                Text = ((char)(_window.IsMaximized ? EditorAssets.SegMDL2Icons.ChromeRestore : EditorAssets.SegMDL2Icons.ChromeMaximize)).ToString(),
-                Font = new FontReference(iconFont),
-                BackgroundColor = Style.Current.LightBackground,
-                BorderColor = Color.Transparent,
-                BorderColorHighlighted = Color.Transparent,
-                BorderColorSelected = Color.Transparent,
-                TextColor = Style.Current.Foreground,
-                Width = 46,
-                BackgroundColorHighlighted = Style.Current.LightBackground.RGBMultiplied(1.3f),
-                Parent = this,
-            };
-            _maximizeButton.Clicked += () =>
-            {
-                if (_window.IsMaximized)
-                    _window.Restore();
-                else
-                    _window.Maximize();
-            };
-
-            _charChromeRestore = ((char)EditorAssets.SegMDL2Icons.ChromeRestore).ToString();
-            _charChromeMaximize = ((char)EditorAssets.SegMDL2Icons.ChromeMaximize).ToString();
-        }
-    }
-    
-    /// <inheritdoc />
-    public override void Update(float deltaTime)
-    {
-        base.Update(deltaTime);
-
-        if (_maximizeButton != null)
-        {
-            var maximizeText = _window.IsMaximized ? _charChromeRestore : _charChromeMaximize;
-            if (_maximizeButton.Text != maximizeText)
-                _maximizeButton.Text = maximizeText;
-        }
-    }
-
-    private void OnWindowClosed()
-    {
-        if (_window != null)
-        {
-            _window.HitTest -= OnHitTest;
-            _window = null;
-        }
-    }
-
-    /// <summary>
-    /// Perform hit test on the window.
-    /// </summary>
-    /// <param name="mouse">The mouse position</param>
-    /// <returns>The hit code for given position.</returns>
-    protected virtual WindowHitCodes OnHitTest(ref Float2 mouse)
-    {
-        if (_window.IsMinimized)
-            return WindowHitCodes.NoWhere;
-
-        var dpiScale = _window.DpiScale;
-        var pos = _window.ScreenToClient(mouse * dpiScale); // pos is not DPI adjusted
-        if (!_window.IsMaximized)
-        {
-            var winSize = _window.Size;
-
-            // Distance from which the mouse is considered to be on the border/corner
-            float distance = 5.0f * dpiScale;
-
-            if (pos.Y > winSize.Y - distance && pos.X < distance)
-                return WindowHitCodes.BottomLeft;
-
-            if (pos.X > winSize.X - distance && pos.Y > winSize.Y - distance)
-                return WindowHitCodes.BottomRight;
-
-            if (pos.Y < distance && pos.X < distance)
-                return WindowHitCodes.TopLeft;
-
-            if (pos.Y < distance && pos.X > winSize.X - distance)
-                return WindowHitCodes.TopRight;
-
-            if (pos.X > winSize.X - distance)
-                return WindowHitCodes.Right;
-
-            if (pos.X < distance)
-                return WindowHitCodes.Left;
-
-            if (pos.Y < distance)
-                return WindowHitCodes.Top;
-
-            if (pos.Y > winSize.Y - distance)
-                return WindowHitCodes.Bottom;
-        }
-        
-        var controlUnderMouse = GetChildAt(pos, control => control != _title);
-        if (_title.Bounds.Contains(pos) && controlUnderMouse == null)
-            return WindowHitCodes.Caption;
-
-        return WindowHitCodes.Client;
-    }
-    
-    /// <inheritdoc />
-    public override bool OnMouseDoubleClick(Float2 location, MouseButton button)
-    {
-        // These may not work with main window due to SDL not passing mouse events
-        // when interacting with hit tests on caption area...
-        
-        if (Title.Bounds.Contains(location) && button == MouseButton.Left)
-        {
-            if (_window.IsMaximized)
-                _window.Restore();
-            else
-                _window.Maximize();
-            return true;
-        }
-        else if (Icon.Bounds.Contains(location) && button == MouseButton.Left)
-        {
-            _window.Close(ClosingReason.User);
-            return true;
-        }
-        return base.OnMouseDoubleClick(location, button);
-    }
-
-    /// <inheritdoc />
-    protected override void PerformLayoutAfterChildren()
-    {
-        // Calculate extents for title bounds area excluding the icon and main menu area
-        float x = 0;
-        
-        // Icon
-        if (_icon != null)
-        {
-            _icon.X = x;
-            _icon.Size = new Float2(Height);
-            x += _icon.Width;
-        }
-
-        // Main menu if present
-        if (Parent.GetChild<MainMenu>() is MainMenu mainMenu)
-        {
-            for (int i = 0; i < mainMenu.Children.Count; i++)
-            {
-                var c = mainMenu.Children[i];
-                if (c is MainMenuButton b && c.Visible)
-                {
-                    b.Bounds = new Rectangle(x, 0, b.Width, Height);
-                    x += b.Width;
-                }
-            }
-        }
-     
-        // Buttons
-        float rightMostButtonX = Width;
-        if (_closeButton != null)
-        {
-            _closeButton.Height = Height;
-            _closeButton.X = rightMostButtonX - _closeButton.Width;
-            rightMostButtonX = _closeButton.X;
-        }
-        if (_maximizeButton != null)
-        {
-            _maximizeButton.Height = Height;
-            _maximizeButton.X = rightMostButtonX - _maximizeButton.Width;
-            rightMostButtonX = _maximizeButton.X;
-        }
-        if (_minimizeButton != null)
-        {
-            _minimizeButton.Height = Height;
-            _minimizeButton.X = rightMostButtonX - _minimizeButton.Width;
-            rightMostButtonX = _minimizeButton.X;
-        }
-
-        // Title
-        if (_title != null)
-        {
-            _title.Text = _window.Title;
-            _title.Bounds = new Rectangle(x, 0, rightMostButtonX - x, Height);
-        }
-    }
-    
-    /// <inheritdoc />
-    public override void Draw()
-    {
-        base.Draw();
-        DrawBorders();
-    }
-
-    /// <summary>
-    /// Draw borders around the window.
-    /// </summary>
-    public virtual void DrawBorders()
-    {
-        var win = RootWindow.Window;
-        if (win.IsMaximized)
-            return;
-
-        if (Editor.Instance.UI.StatusBar == null)
-            return;
-        
-        const float thickness = 1.0f;
-        Color color = Editor.Instance.UI.StatusBar.StatusColor;
-        Rectangle rect = new Rectangle(thickness * 0.5f, thickness * 0.5f, Parent.Width - thickness, Parent.Height - thickness);
-        Render2D.DrawRectangle(rect, color);
-    }
-
-    /// <inheritdoc />
-    public override void OnDestroy()
-    {
-        base.OnDestroy();
-
-        if (_window != null)
-        {
-            _window.Closed -= OnWindowClosed;
-            OnWindowClosed();
-        }
-    }
-}

Source/Editor/Managed/ManagedEditor.Internal.cpp

@@ -402,11 +402,10 @@ DEFINE_INTERNAL_CALL(void) EditorInternal_RunVisualScriptBreakpointLoopTick(floa
                 break;
             }
         }
-        WindowsManager::WindowsLocker.Unlock();
         for (const auto& e : inputEvents)
         {
             auto window = e.Target ? e.Target : defaultWindow;
-            if (!window || window->IsClosed())
+            if (!window)
                 continue;
             switch (e.Type)
             {
@@ -436,14 +435,12 @@ DEFINE_INTERNAL_CALL(void) EditorInternal_RunVisualScriptBreakpointLoopTick(floa
             case InputDevice::EventType::MouseMove:
                 window->OnMouseMove(window->ScreenToClient(e.MouseData.Position));
                 break;
-            case InputDevice::EventType::MouseMoveRelative:
-                window->OnMouseMoveRelative(e.MouseMovementData.PositionRelative);
-                break;
             case InputDevice::EventType::MouseLeave:
                 window->OnMouseLeave();
                 break;
             }
         }
+        WindowsManager::WindowsLocker.Unlock();
     }
     WindowsManager::WindowsLocker.Lock();
     Array<Window*, InlinedAllocation<32>> windows;

Source/Editor/Modules/ContentDatabaseModule.cs

@@ -1013,7 +1013,7 @@ namespace FlaxEditor.Modules
                     ContentItem item;
                     if (path.EndsWith(".cs"))
                         item = new CSharpScriptItem(path);
-                    else if (path.EndsWith(".cpp") || path.EndsWith(".h") || path.EndsWith(".c") || path.EndsWith(".hpp"))
+                    else if (path.EndsWith(".cpp") || path.EndsWith(".h"))
                         item = new CppScriptItem(path);
                     else if (path.EndsWith(".shader") || path.EndsWith(".hlsl"))
                         item = new ShaderSourceItem(path);

Source/Editor/Modules/ContentImportingModule.cs

@@ -222,7 +222,7 @@ namespace FlaxEditor.Modules
                 outputExtension = extension;
 
                 // Check if can place source files here
-                if (!targetLocation.CanHaveScripts && (extension == ".cs" || extension == ".cpp" || extension == ".h" || extension == ".c" || extension == ".hpp"))
+                if (!targetLocation.CanHaveScripts && (extension == ".cs" || extension == ".cpp" || extension == ".h"))
                 {
                     // Error
                     Editor.LogWarning(string.Format("Cannot import \'{0}\' to \'{1}\'. The target directory cannot have scripts.", inputPath, targetLocation.Node.Path));

Source/Editor/Modules/SimulationModule.cs

@@ -267,7 +267,7 @@ namespace FlaxEditor.Modules
         }
 
         /// <inheritdoc />
-        public override void OnPlayBeginning()
+        public override void OnPlayBegin()
         {
             Editor.Windows.FlashMainWindow();
 

Source/Editor/Modules/UIModule.cs

@@ -16,6 +16,7 @@ using FlaxEditor.Windows;
 using FlaxEngine;
 using FlaxEngine.GUI;
 using FlaxEngine.Json;
+using DockHintWindow = FlaxEditor.GUI.Docking.DockHintWindow;
 using MasterDockPanel = FlaxEditor.GUI.Docking.MasterDockPanel;
 using FlaxEditor.Content.Settings;
 using FlaxEditor.Options;
@@ -28,40 +29,6 @@ namespace FlaxEditor.Modules
     /// <seealso cref="FlaxEditor.Modules.EditorModule" />
     public sealed class UIModule : EditorModule
     {
-        private class MainWindowDecorations : WindowDecorations
-        {
-            public MainWindowDecorations(RootControl window, bool iconOnly) 
-            : base(window, iconOnly)
-            {
-            }
-
-            /// <inheritdoc />
-            public override bool OnKeyDown(KeyboardKeys key)
-            {
-                if (base.OnKeyDown(key))
-                    return true;
-
-                // Fallback to the edit window for shortcuts
-                var editor = Editor.Instance;
-                return editor.Windows.EditWin.InputActions.Process(editor, this, key);
-            }
-            
-            /// <inheritdoc />
-            public override void DrawBorders()
-            {
-                // Draw main window borders if using a custom style
-                var win = RootWindow.Window;
-                if (win.IsMaximized)
-                    return;
-
-                var color = Editor.Instance.UI.StatusBar.StatusColor;
-                var rect = new Rectangle(0.5f, 0.5f, Parent.Width - 1.0f, Parent.Height - 1.0f - StatusBar.DefaultHeight);
-                Render2D.DrawLine(rect.UpperLeft, rect.UpperRight, color);
-                Render2D.DrawLine(rect.UpperLeft, rect.BottomLeft, color);
-                Render2D.DrawLine(rect.UpperRight, rect.BottomRight, color);
-            }
-        }
-        
         private Label _progressLabel;
         private ProgressBar _progressBar;
         private Button _outputLogButton;
@@ -177,11 +144,6 @@ namespace FlaxEditor.Modules
         /// </summary>
         public MainMenu MainMenu;
 
-        /// <summary>
-        /// The window decorations (title bar with buttons)
-        /// </summary>
-        public WindowDecorations WindowDecorations;
-
         /// <summary>
         /// The tool strip control.
         /// </summary>
@@ -464,11 +426,19 @@ namespace FlaxEditor.Modules
             InitToolstrip(mainWindow);
             InitStatusBar(mainWindow);
             InitDockPanel(mainWindow);
-            InitWindowDecorations(mainWindow);
 
             Editor.Options.OptionsChanged += OnOptionsChanged;
-            
-            mainWindow.PerformLayout(true);
+
+            // Add dummy control for drawing the main window borders if using a custom style
+#if PLATFORM_WINDOWS
+            if (!Editor.Options.Options.Interface.UseNativeWindowSystem)
+#endif
+            {
+                mainWindow.AddChild(new CustomWindowBorderControl
+                {
+                    Size = Float2.Zero,
+                });
+            }
         }
 
         private void InitViewportScaleOptions()
@@ -540,6 +510,23 @@ namespace FlaxEditor.Modules
             }
         }
 
+        private class CustomWindowBorderControl : Control
+        {
+            /// <inheritdoc />
+            public override void Draw()
+            {
+                var win = RootWindow.Window;
+                if (win.IsMaximized)
+                    return;
+
+                var color = Editor.Instance.UI.StatusBar.StatusColor;
+                var rect = new Rectangle(0.5f, 0.5f, Parent.Width - 1.0f, Parent.Height - 1.0f - StatusBar.DefaultHeight);
+                Render2D.DrawLine(rect.UpperLeft, rect.UpperRight, color);
+                Render2D.DrawLine(rect.UpperLeft, rect.BottomLeft, color);
+                Render2D.DrawLine(rect.UpperRight, rect.BottomRight, color);
+            }
+        }
+
         /// <inheritdoc />
         public override void OnEndInit()
         {
@@ -571,6 +558,13 @@ namespace FlaxEditor.Modules
             UpdateToolstrip();
         }
 
+        /// <inheritdoc />
+        public override void OnExit()
+        {
+            // Cleanup dock panel hint proxy windows (Flax will destroy them by var but it's better to clear them earlier)
+            DockHintWindow.Proxy.Dispose();
+        }
+
         private IColorPickerDialog ShowPickColorDialog(Control targetControl, Color initialValue, ColorValueBox.ColorPickerEvent colorChanged, ColorValueBox.ColorPickerClosedEvent pickerClosed, bool useDynamicEditing)
         {
             var dialog = new ColorPickerDialog(initialValue, colorChanged, pickerClosed, useDynamicEditing);
@@ -624,12 +618,10 @@ namespace FlaxEditor.Modules
 
         private void InitMainMenu(RootControl mainWindow)
         {
-            MainMenu = new MainMenu()
+            MainMenu = new MainMenu(mainWindow)
             {
                 Parent = mainWindow
             };
-            if (Utilities.Utils.UseCustomWindowDecorations(isMainWindow: true))
-                MainMenu.Height = 28;
 
             var inputOptions = Editor.Options.Options.Input;
 
@@ -771,20 +763,6 @@ namespace FlaxEditor.Modules
             cm.AddButton("Information about Flax", () => new AboutDialog().Show());
         }
 
-        private void InitWindowDecorations(RootControl mainWindow)
-        {
-            ScriptsBuilder.GetBinariesConfiguration(out _, out _, out _, out var configuration);
-            var driver = Platform.DisplayServer;
-            if (!string.IsNullOrEmpty(driver))
-                driver = $" ({driver})";
-            
-            WindowDecorations = new MainWindowDecorations(mainWindow, !Utilities.Utils.UseCustomWindowDecorations(isMainWindow: true))
-            {
-                Parent = mainWindow,
-                IconTooltipText = $"{mainWindow.RootWindow.Title}\nVersion {Globals.EngineVersion}\nConfiguration {configuration}\nGraphics {GPUDevice.Instance.RendererType}{driver}",
-            };
-        }
-        
         private void OnOptionsChanged(EditorOptions options)
         {
             var inputOptions = options.Input;
@@ -1205,7 +1183,6 @@ namespace FlaxEditor.Modules
         {
             // Clear UI references (GUI cannot be used after window closing)
             MainMenu = null;
-            WindowDecorations = null;
             ToolStrip = null;
             MasterPanel = null;
             StatusBar = null;

Source/Editor/Modules/WindowsModule.cs

@@ -10,6 +10,7 @@ using System.Text;
 using System.Xml;
 using FlaxEditor.Content;
 using FlaxEditor.GUI.Dialogs;
+using FlaxEditor.GUI.Docking;
 using FlaxEditor.Windows;
 using FlaxEditor.Windows.Assets;
 using FlaxEditor.Windows.Profiler;
@@ -757,19 +758,17 @@ namespace FlaxEditor.Modules
             var settings = CreateWindowSettings.Default;
             settings.Title = "Flax Editor";
             settings.Size = Platform.DesktopSize * 0.75f;
-            settings.MinimumSize = new Float2(200, 150);
             settings.StartPosition = WindowStartPosition.CenterScreen;
             settings.ShowAfterFirstPaint = true;
-            
-            if (Utilities.Utils.UseCustomWindowDecorations(isMainWindow: true))
+#if PLATFORM_WINDOWS
+            if (!Editor.Instance.Options.Options.Interface.UseNativeWindowSystem)
             {
                 settings.HasBorder = false;
-#if PLATFORM_WINDOWS && !PLATFORM_SDL
+
                 // Skip OS sizing frame and implement it using LeftButtonHit
                 settings.HasSizingFrame = false;
-#endif
             }
-#if PLATFORM_LINUX && !PLATFORM_SDL
+#elif PLATFORM_LINUX
             settings.HasBorder = false;
 #endif
             MainWindow = Platform.CreateWindow(ref settings);
@@ -897,9 +896,11 @@ namespace FlaxEditor.Modules
 
                     if (type.IsAssignableTo(typeof(AssetEditorWindow)))
                     {
-                        var ctor = type.GetConstructor(new Type[] { typeof(Editor), typeof(AssetItem) });
                         var assetItem = Editor.ContentDatabase.FindAsset(winData.AssetItemID);
+                        var assetType = assetItem.GetType();
+                        var ctor = type.GetConstructor(new Type[] { typeof(Editor), assetType });
                         var win = (AssetEditorWindow)ctor.Invoke(new object[] { Editor.Instance, assetItem });
+
                         win.Show(winData.DockState, winData.DockState != DockState.Float ? winData.DockedTo : null, winData.SelectOnShow, winData.SplitterValue);
                         if (winData.DockState == DockState.Float)
                         {

Source/Editor/Options/InterfaceOptions.cs

@@ -179,34 +179,6 @@ namespace FlaxEditor.Options
             GameWindowThenRestore,
         }
 
-        /// <summary>
-        /// Options for type of window decorations to use.
-        /// </summary>
-        public enum WindowDecorationsType
-        {
-            /// <summary>
-            /// Determined automatically based on the system and any known compatibility issues with native decorations.
-            /// </summary>
-            Auto,
-            
-            /// <summary>
-            /// Automatically choose most compatible window decorations for child windows, prefer custom decorations on main window.
-            /// </summary>
-            [EditorDisplay(Name = "Auto (Child Only)")]
-            AutoChildOnly,
-            
-            /// <summary>
-            /// Use native system window decorations on all windows.
-            /// </summary>
-            Native,
-            
-            /// <summary>
-            /// Use custom client-side window decorations on all windows.
-            /// </summary>
-            [EditorDisplay(Name = "Client-side")]
-            ClientSide,
-        }
-
         /// <summary>
         /// Gets or sets the Editor User Interface scale. Applied to all UI elements, windows and text. Can be used to scale the interface up on a bigger display. Editor restart required.
         /// </summary>
@@ -296,14 +268,7 @@ namespace FlaxEditor.Options
         [EditorDisplay("Interface"), EditorOrder(322)]
         public bool ScrollToScriptOnAdd { get; set; } = true;
 
-#if PLATFORM_SDL
-        /// <summary>
-        /// Gets or sets a value indicating whether use native window title bar decorations in child windows. Editor restart required.
-        /// </summary>
-        [DefaultValue(WindowDecorationsType.AutoChildOnly)]
-        [EditorDisplay("Interface"), EditorOrder(70), Tooltip("Determines whether use native window title bar decorations. Editor restart required.")]
-        public WindowDecorationsType WindowDecorations { get; set; } = WindowDecorationsType.AutoChildOnly;
-#elif PLATFORM_WINDOWS
+#if PLATFORM_WINDOWS
         /// <summary>
         /// Gets or sets a value indicating whether use native window title bar. Editor restart required.
         /// </summary>
@@ -312,7 +277,7 @@ namespace FlaxEditor.Options
         public bool UseNativeWindowSystem { get; set; } = false;
 #endif
 
-#if PLATFORM_SDL || PLATFORM_WINDOWS
+#if PLATFORM_WINDOWS
         /// <summary>
         /// Gets or sets a value indicating whether a window containing a single tabs hides the tab bar. Editor restart recommended.
         /// </summary>

Source/Editor/Scripting/ScriptsBuilder.cpp

@@ -121,13 +121,9 @@ void ScriptsBuilderImpl::sourceDirEvent(const String& path, FileSystemAction act
     // Discard non-source files or generated files
     if ((!path.EndsWith(TEXT(".cs")) &&
         !path.EndsWith(TEXT(".cpp")) &&
-        !path.EndsWith(TEXT(".c")) &&
-        !path.EndsWith(TEXT(".hpp")) &&
         !path.EndsWith(TEXT(".h"))) ||
         path.EndsWith(TEXT(".Gen.cs")))
-    {
         return;
-    }
 
     ScopeLock scopeLock(_locker);
     _lastSourceCodeEdited = DateTime::Now();

Source/Editor/Scripting/TypeUtils.cs

@@ -406,6 +406,8 @@ namespace FlaxEngine.Utilities
         {
             if (type == ScriptType.Null)
                 return null;
+            if (type.BaseType == null)
+                return type.Type;
             while (type.Type == null)
                 type = type.BaseType;
             return type.Type;

Source/Editor/Surface/SurfaceUtils.cs

@@ -400,7 +400,7 @@ namespace FlaxEditor.Surface
                 return scriptType.GetGenericTypeDefinition() == typeof(Dictionary<,>);
             }
             var managedType = TypeUtils.GetType(scriptType);
-            return !TypeUtils.IsDelegate(managedType);
+            return managedType != null && !TypeUtils.IsDelegate(managedType);
         }
 
         internal static bool IsValidVisualScriptFunctionType(ScriptType scriptType)
@@ -408,7 +408,7 @@ namespace FlaxEditor.Surface
             if (scriptType.IsGenericType || scriptType.IsStatic || !scriptType.IsPublic || scriptType.HasAttribute(typeof(HideInEditorAttribute), true))
                 return false;
             var managedType = TypeUtils.GetType(scriptType);
-            return !TypeUtils.IsDelegate(managedType);
+            return managedType != null && !TypeUtils.IsDelegate(managedType);
         }
 
         internal static string GetVisualScriptTypeDescription(ScriptType type)

Source/Editor/Utilities/ScreenUtilities.cpp

@@ -0,0 +1,131 @@
+// Copyright (c) Wojciech Figat. All rights reserved.
+
+#include "ScreenUtilities.h"
+#include "Engine/Core/Math/Vector2.h"
+#include "Engine/Core/Delegate.h"
+#include "Engine/Core/Log.h"
+#include "Engine/Profiler/ProfilerCPU.h"
+
+Delegate<Color32> ScreenUtilities::PickColorDone;
+
+#if PLATFORM_WINDOWS
+
+#include <Windows.h>
+
+#pragma comment(lib, "Gdi32.lib")
+
+static HHOOK MouseCallbackHook;
+
+LRESULT CALLBACK OnScreenUtilsMouseCallback(_In_ int nCode, _In_ WPARAM wParam, _In_ LPARAM lParam)
+{
+    if (nCode >= 0 && wParam == WM_LBUTTONDOWN)
+    {
+        UnhookWindowsHookEx(MouseCallbackHook);
+
+        // Push event with the picked color
+        const Float2 cursorPos = Platform::GetMousePosition();
+        const Color32 colorPicked = ScreenUtilities::GetColorAt(cursorPos);
+        ScreenUtilities::PickColorDone(colorPicked);
+        return 1;
+    }
+    return CallNextHookEx(NULL, nCode, wParam, lParam);
+}
+
+Color32 ScreenUtilities::GetColorAt(const Float2& pos)
+{
+    PROFILE_CPU();
+    HDC deviceContext = GetDC(NULL);
+    COLORREF color = GetPixel(deviceContext, (int)pos.X, (int)pos.Y);
+    ReleaseDC(NULL, deviceContext);
+    return Color32(GetRValue(color), GetGValue(color), GetBValue(color), 255);
+}
+
+void ScreenUtilities::PickColor()
+{
+    MouseCallbackHook = SetWindowsHookEx(WH_MOUSE_LL, OnScreenUtilsMouseCallback, NULL, NULL);
+    if (MouseCallbackHook == NULL)
+    {
+        LOG(Warning, "Failed to set mouse hook.");
+        LOG(Warning, "Error: {0}", GetLastError());
+    }
+}
+
+#elif PLATFORM_LINUX
+
+#include "Engine/Platform/Linux/LinuxPlatform.h"
+#include "Engine/Platform/Linux/IncludeX11.h"
+
+Color32 ScreenUtilities::GetColorAt(const Float2& pos)
+{
+    X11::XColor color;
+    
+    X11::Display* display = (X11::Display*) LinuxPlatform::GetXDisplay();
+    int defaultScreen = X11::XDefaultScreen(display);
+
+    X11::XImage* image;
+    image = X11::XGetImage(display, X11::XRootWindow(display, defaultScreen), (int)pos.X, (int)pos.Y, 1, 1, AllPlanes, XYPixmap);
+    color.pixel = XGetPixel(image, 0, 0);
+    X11::XFree(image);
+
+    X11::XQueryColor(display, X11::XDefaultColormap(display, defaultScreen), &color);
+
+    Color32 outputColor;
+    outputColor.R = color.red / 256;
+    outputColor.G = color.green / 256;
+    outputColor.B = color.blue / 256;
+    outputColor.A = 255;
+    return outputColor;
+}
+
+void OnScreenUtilsXEventCallback(void* eventPtr)
+{
+    X11::XEvent* event = (X11::XEvent*) eventPtr;
+    X11::Display* display = (X11::Display*)LinuxPlatform::GetXDisplay();
+    if (event->type == ButtonPress)
+    {
+        const Float2 cursorPos = Platform::GetMousePosition();
+        const Color32 colorPicked = ScreenUtilities::GetColorAt(cursorPos);
+        X11::XUngrabPointer(display, CurrentTime);
+        ScreenUtilities::PickColorDone(colorPicked);
+        LinuxPlatform::xEventRecieved.Unbind(OnScreenUtilsXEventCallback);
+    }
+}
+
+void ScreenUtilities::PickColor()
+{
+    PROFILE_CPU();
+    X11::Display* display = (X11::Display*) LinuxPlatform::GetXDisplay();
+    X11::Window rootWindow = X11::XRootWindow(display, X11::XDefaultScreen(display));
+
+    X11::Cursor cursor = XCreateFontCursor(display, 130);
+    int grabbedPointer = X11::XGrabPointer(display, rootWindow, 0,  ButtonPressMask, GrabModeAsync, GrabModeAsync, rootWindow, cursor, CurrentTime);
+    if (grabbedPointer != GrabSuccess)
+    {
+        LOG(Error, "Failed to grab cursor for events.");
+        X11::XFreeCursor(display, cursor);
+        return;
+    }
+
+    X11::XFreeCursor(display, cursor);
+    LinuxPlatform::xEventRecieved.Bind(OnScreenUtilsXEventCallback);
+}
+
+#elif PLATFORM_MAC
+
+#include <Cocoa/Cocoa.h>
+#include <AppKit/AppKit.h>
+
+Color32 ScreenUtilities::GetColorAt(const Float2& pos)
+{
+    // TODO: implement ScreenUtilities for macOS
+    return { 0, 0, 0, 255 };
+}
+
+void ScreenUtilities::PickColor()
+{
+    // This is what C# calls to start the color picking sequence
+    // This should stop mouse clicks from working for one click, and that click is on the selected color
+    // There is a class called NSColorSample that might implement that for you, but maybe not.
+}
+
+#endif

Source/Editor/Utilities/ScreenUtilities.h

@@ -2,4 +2,32 @@
 
 #pragma once
 
-#include "Engine/Platform/ScreenUtilities.h"
+#include "Engine/Core/Types/BaseTypes.h"
+#include "Engine/Core/Math/Color32.h"
+#include "Engine/Core/Math/Vector2.h"
+#include "Engine/Core/Delegate.h"
+
+/// <summary>
+/// Platform-dependent screen utilities.
+/// </summary>
+API_CLASS(Static) class FLAXENGINE_API ScreenUtilities
+{
+    DECLARE_SCRIPTING_TYPE_MINIMAL(ScreenUtilities);
+
+    /// <summary>
+    /// Gets the pixel color at the specified coordinates.
+    /// </summary>
+    /// <param name="pos">Screen-space coordinate to read.</param>
+    /// <returns>Pixel color at the specified coordinates.</returns>
+    API_FUNCTION() static Color32 GetColorAt(const Float2& pos);
+
+    /// <summary>
+    /// Starts async color picking. Color will be returned through PickColorDone event when the actions ends (user selected the final color with a mouse). When action is active, GetColorAt can be used to read the current value.
+    /// </summary>
+    API_FUNCTION() static void PickColor();
+
+    /// <summary>
+    /// Called when PickColor action is finished.
+    /// </summary>
+    API_EVENT() static Delegate<Color32> PickColorDone;
+};

Source/Editor/Utilities/Utils.cs

@@ -1583,31 +1583,5 @@ namespace FlaxEditor.Utilities
                 c = c.Parent;
             return c as ISceneEditingContext;
         }
-
-        internal static bool UseCustomWindowDecorations(bool isMainWindow = false)
-        {
-            return Editor.Instance.Options.Options.Interface.WindowDecorations switch
-            {
-                Options.InterfaceOptions.WindowDecorationsType.Auto => !Platform.SupportsNativeDecorations,
-                Options.InterfaceOptions.WindowDecorationsType.AutoChildOnly => !isMainWindow ? !Platform.SupportsNativeDecorations : true,
-                Options.InterfaceOptions.WindowDecorationsType.Native => false,
-                Options.InterfaceOptions.WindowDecorationsType.ClientSide => true,
-                _ => throw new ArgumentOutOfRangeException()
-            };
-        }
-
-        internal static bool HideSingleTabWindowTabBars()
-        {
-#if PLATFORM_SDL
-            // We should not hide the tab bars if tab handle is the only way to dock the window
-            bool clientSideDecorations = UseCustomWindowDecorations(false);
-            bool draggableDecorations = clientSideDecorations || Platform.SupportsNativeDecorationDragging;
-            return draggableDecorations && Editor.Instance.Options.Options.Interface.HideSingleTabWindowTabBars;
-#elif PLATFORM_WINDOWS
-            return Editor.Instance.Options.Options.Interface.HideSingleTabWindowTabBars;
-#else
-            return false;
-#endif
-        }
     }
 }

Source/Editor/Viewport/EditorGizmoViewport.cs

@@ -77,7 +77,7 @@ namespace FlaxEditor.Viewport
         public bool SnapToVertex => ContainsFocus && Editor.Instance.Options.Options.Input.SnapToVertex.Process(Root);
 
         /// <inheritdoc />
-        public Float2 MouseDelta => FlaxEngine.Input.MousePositionDelta;
+        public Float2 MouseDelta => _mouseDelta;
 
         /// <inheritdoc />
         public bool UseSnapping => Root?.GetKey(KeyboardKeys.Control) ?? false;

Source/Editor/Viewport/EditorViewport.cs

@@ -4,7 +4,6 @@ using System;
 using System.Linq;
 using FlaxEditor.Content.Settings;
 using FlaxEditor.GUI.ContextMenu;
-using FlaxEditor.GUI.Docking;
 using FlaxEditor.GUI.Input;
 using FlaxEditor.Options;
 using FlaxEditor.Viewport.Cameras;
@@ -159,22 +158,18 @@ namespace FlaxEditor.Viewport
         private float _movementSpeed;
         private float _minMovementSpeed;
         private float _maxMovementSpeed;
-#if !PLATFORM_SDL
         private float _mouseAccelerationScale;
         private bool _useMouseFiltering;
         private bool _useMouseAcceleration;
-#endif
 
         // Input
 
         internal bool _disableInputUpdate;
         private bool _isControllingMouse, _isViewportControllingMouse, _wasVirtualMouseRightDown, _isVirtualMouseRightDown;
-        private Float2 _startPos;
-#if !PLATFORM_SDL
-        private Float2 _mouseDeltaLast;
         private int _deltaFilteringStep;
+        private Float2 _startPos;
+        private Float2 _mouseDeltaLast;
         private Float2[] _deltaFilteringBuffer = new Float2[FpsCameraFilteringFrames];
-#endif
 
         /// <summary>
         /// The previous input (from the previous update).
@@ -527,11 +522,10 @@ namespace FlaxEditor.Viewport
         : base(task)
         {
             _editor = Editor.Instance;
-#if !PLATFORM_SDL
+
             _mouseAccelerationScale = 0.1f;
             _useMouseFiltering = false;
             _useMouseAcceleration = false;
-#endif
             _camera = camera;
             if (_camera != null)
                 _camera.Viewport = this;
@@ -1531,9 +1525,7 @@ namespace FlaxEditor.Viewport
             // Hide cursor and start tracking mouse movement
             win.StartTrackingMouse(false);
             win.Cursor = CursorType.Hidden;
-            win.MouseMoveRelative += OnMouseMoveRelative;
 
-#if !PLATFORM_SDL
             // Center mouse position if it's too close to the edge
             var size = Size;
             var center = Float2.Round(size * 0.5f);
@@ -1542,7 +1534,6 @@ namespace FlaxEditor.Viewport
                 _viewMousePos = center;
                 win.MousePosition = PointToWindow(_viewMousePos);
             }
-#endif
         }
 
         /// <summary>
@@ -1554,7 +1545,6 @@ namespace FlaxEditor.Viewport
             // Restore cursor and stop tracking mouse movement
             win.Cursor = CursorType.Default;
             win.EndTrackingMouse();
-            win.MouseMoveRelative -= OnMouseMoveRelative;
         }
 
         /// <summary>
@@ -1636,15 +1626,18 @@ namespace FlaxEditor.Viewport
 
             // Get parent window
             var win = (WindowRootControl)Root;
-            if (win.IsFocused)
+
+            // Get current mouse position in the view
             {
-                // Get current mouse position in the view
-                _viewMousePos = PointFromWindow(win.MousePosition);
+                // When the window is not focused, the position in window does not return sane values
+                Float2 pos = PointFromWindow(win.MousePosition);
+                if (!float.IsInfinity(pos.LengthSquared))
+                    _viewMousePos = pos;
             }
 
             // Update input
             var window = win.Window;
-            var canUseInput = window != null && window.IsFocused && window.IsForegroundWindow && !WindowDragHelper.IsDragActive;
+            var canUseInput = window != null && window.IsFocused && window.IsForegroundWindow;
             {
                 // Get input buttons and keys (skip if viewport has no focus or mouse is over a child control)
                 var isViewportControllingMouse = canUseInput && IsControllingMouse;
@@ -1656,17 +1649,9 @@ namespace FlaxEditor.Viewport
                     else
                         EndMouseCapture();
                 }
-                
+                bool useMouse = IsControllingMouse || (Mathf.IsInRange(_viewMousePos.X, 0, Width) && Mathf.IsInRange(_viewMousePos.Y, 0, Height));
                 _prevInput = _input;
-#if PLATFORM_SDL
-                bool useMouse = IsControllingMouse || ContainsPoint(ref _viewMousePos) || _prevInput.IsControllingMouse;
                 var hit = GetChildAt(_viewMousePos, c => c.Visible && !(c is CanvasRootControl) && !(c is UIEditorRoot));
-                if (_prevInput.IsControllingMouse)
-                    hit = null;
-#else
-                bool useMouse = IsControllingMouse || ContainsPoint(ref _viewMousePos);
-                var hit = GetChildAt(_viewMousePos, c => c.Visible && !(c is CanvasRootControl) && !(c is UIEditorRoot));
-#endif
                 if (canUseInput && ContainsFocus && hit == null)
                     _input.Gather(win.Window, useMouse, ref _prevInput);
                 else
@@ -1779,10 +1764,6 @@ namespace FlaxEditor.Viewport
                 if (_input.IsControlDown)
                     moveDelta *= 0.3f;
 
-#if PLATFORM_SDL
-                var mouseDelta = _mouseDelta;
-                _mouseDelta = Float2.Zero;
-#else
                 // Calculate smooth mouse delta not dependant on viewport size
                 var offset = _viewMousePos - _startPos;
                 if (_input.IsZooming && !_input.IsMouseRightDown && !_input.IsMouseLeftDown && !_input.IsMouseMiddleDown && !_isOrtho && !rmbWheel && !_isVirtualMouseRightDown)
@@ -1824,7 +1805,6 @@ namespace FlaxEditor.Viewport
                     mouseDelta += _mouseDeltaLast * _mouseAccelerationScale;
                     _mouseDeltaLast = currentDelta;
                 }
-#endif
 
                 // Update
                 moveDelta *= dt * (60.0f * 4.0f);
@@ -1833,14 +1813,12 @@ namespace FlaxEditor.Viewport
                     mouseDelta *= new Float2(1, -1);
                 UpdateView(dt, ref moveDelta, ref mouseDelta, out var centerMouse);
 
-#if !PLATFORM_SDL
                 // Move mouse back to the root position
                 if (centerMouse && (_input.IsMouseRightDown || _input.IsMouseLeftDown || _input.IsMouseMiddleDown || _isVirtualMouseRightDown))
                 {
                     var center = PointToWindow(_startPos);
                     win.MousePosition = center;
                 }
-#endif
 
                 // Change Ortho size on mouse scroll
                 if (_isOrtho && !rmbWheel)
@@ -1852,8 +1830,6 @@ namespace FlaxEditor.Viewport
             }
             else
             {
-#if PLATFORM_SDL
-#else
                 if (_input.IsMouseLeftDown || _input.IsMouseRightDown || _isVirtualMouseRightDown)
                 {
                     // Calculate smooth mouse delta not dependant on viewport size
@@ -1868,7 +1844,6 @@ namespace FlaxEditor.Viewport
                     _mouseDelta = Float2.Zero;
                 }
                 _mouseDeltaLast = Float2.Zero;
-#endif
 
                 if (ContainsFocus)
                 {
@@ -1918,12 +1893,6 @@ namespace FlaxEditor.Viewport
             _input.MouseWheelDelta = 0;
         }
 
-        /// <inheritdoc />
-        public void OnMouseMoveRelative(ref Float2 mouseMotion)
-        {
-            _mouseDelta += mouseMotion;
-        }
-
         /// <inheritdoc />
         public override bool OnMouseDown(Float2 location, MouseButton button)
         {
@@ -1989,8 +1958,7 @@ namespace FlaxEditor.Viewport
 
             if (_isControllingMouse)
             {
-                if (RootWindow?.Window != null)
-                    OnControlMouseEnd(RootWindow.Window);
+                OnControlMouseEnd(RootWindow.Window);
                 _isControllingMouse = false;
                 _isVirtualMouseRightDown = false;
             }

Source/Editor/Viewport/MainEditorGizmoViewport.cs

@@ -611,25 +611,16 @@ namespace FlaxEditor.Viewport
 
             // Don't allow rubber band selection when gizmo is controlling mouse, vertex painting mode, or cloth painting is enabled
             bool canStart = !(IsControllingMouse || IsRightMouseButtonDown || IsAltKeyDown) &&
-                            Gizmos?.Active is TransformGizmo;
+                            Gizmos?.Active is TransformGizmo && !Gizmos.Active.IsControllingMouse;
             _rubberBandSelector.TryCreateRubberBand(canStart, _viewMousePos);
         }
 
-        /// <inheritdoc />
-        protected override void OnControlMouseBegin(Window win)
-        {
-            _rubberBandSelector.ReleaseRubberBandSelection();
-
-            base.OnControlMouseBegin(win);
-        }
-
         /// <inheritdoc />
         protected override void OnLeftMouseButtonDown()
         {
             base.OnLeftMouseButtonDown();
 
-            if (!IsAltKeyDown)
-                _rubberBandSelector.TryStartingRubberBandSelection();
+            _rubberBandSelector.TryStartingRubberBandSelection();
         }
 
         /// <inheritdoc />

Source/Editor/Windows/AboutDialog.cs

@@ -130,9 +130,6 @@ namespace FlaxEditor.Windows
                 "Mono Project - www.mono-project.com",
 #if USE_NETCORE
                 ".NET - www.dotnet.microsoft.com",
-#endif
-#if PLATFORM_SDL
-                "Simple DirectMedia Layer - www.libsdl.org",
 #endif
                 "FreeType Project - www.freetype.org",
                 "Assimp - www.assimp.sourceforge.net",

Source/Editor/Windows/GameWindow.cs

@@ -874,7 +874,7 @@ namespace FlaxEditor.Windows
                 _cursorVisible = Screen.CursorVisible;
                 _cursorLockMode = Screen.CursorLock;
                 Screen.CursorVisible = true;
-                if (Screen.CursorLock == CursorLockMode.Clipped || Screen.CursorLock == CursorLockMode.Locked)
+                if (Screen.CursorLock == CursorLockMode.Clipped)
                     Screen.CursorLock = CursorLockMode.None;
 
                 // Defocus
@@ -963,11 +963,8 @@ namespace FlaxEditor.Windows
 
             if (Editor.StateMachine.IsPlayMode && !Editor.StateMachine.PlayingState.IsPaused)
             {
-                // Make sure the cursor is always in the viewport when cursor is locked
-                bool forceCenter = _cursorLockMode != CursorLockMode.None && !IsMouseOver;
-
                 // Center mouse in play mode
-                if (CenterMouseOnFocus || forceCenter)
+                if (CenterMouseOnFocus)
                 {
                     var center = PointToWindow(Size * 0.5f);
                     Root.MousePosition = center;
@@ -992,10 +989,9 @@ namespace FlaxEditor.Windows
                 _cursorVisible = Screen.CursorVisible;
                 _cursorLockMode = Screen.CursorLock;
 
-                // Restore cursor state, could be hidden or locked by the game
+                // Restore cursor visibility (could be hidden by the game)
                 if (!_cursorVisible)
                     Screen.CursorVisible = true;
-                Screen.CursorLock = CursorLockMode.None;
 
                 if (Editor.IsPlayMode && IsDocked && IsSelected && RootWindow.FocusedControl == null)
                 {

Source/Editor/Windows/SceneTreeWindow.cs

@@ -26,6 +26,7 @@ namespace FlaxEditor.Windows
         private Tree _tree;
         private Panel _sceneTreePanel;
         private bool _isUpdatingSelection;
+        private bool _isMouseDown;
         private bool _blockSceneTreeScroll = false;
 
         private DragAssets _dragAssets;
@@ -373,7 +374,10 @@ namespace FlaxEditor.Windows
                 return true;
 
             if (buttons == MouseButton.Right)
+            {
+                _isMouseDown = true;
                 return true;
+            }
 
             return false;
         }
@@ -384,8 +388,10 @@ namespace FlaxEditor.Windows
             if (base.OnMouseUp(location, buttons))
                 return true;
 
-            if (buttons == MouseButton.Right)
+            if (_isMouseDown && buttons == MouseButton.Right)
             {
+                _isMouseDown = false;
+
                 if (Editor.StateMachine.CurrentState.CanEditScene)
                 {
                     // Show context menu
@@ -410,6 +416,14 @@ namespace FlaxEditor.Windows
             return false;
         }
 
+        /// <inheritdoc />
+        public override void OnLostFocus()
+        {
+            _isMouseDown = false;
+
+            base.OnLostFocus();
+        }
+
         /// <inheritdoc />
         public override DragDropEffect OnDragEnter(ref Float2 location, DragData data)
         {

Source/Editor/Windows/SplashScreen.cpp

@@ -29,7 +29,7 @@ const Char* SplashScreenQuotes[] =
 #elif PLATFORM_LINUX
     TEXT("Try it on a Raspberry"),
     TEXT("Trying to exit vim"),
-    TEXT("sudo flax --project HelloWorld.flaxproj"),
+    TEXT("Sudo flax --loadproject"),
 #elif PLATFORM_MAC
     TEXT("don't compare Macbooks to oranges."),
     TEXT("Why does macbook heat up?\nBecause it doesn't have windows"),
@@ -105,7 +105,6 @@ const Char* SplashScreenQuotes[] =
     TEXT("You have my bow.\nAnd my axe!"),
     TEXT("To the bridge of Khazad-dum."),
     TEXT("One ring to rule them all.\nOne ring to find them."),
-    TEXT("Where there's a whip, there's a way."),
     TEXT("That's what she said"),
     TEXT("We could be compiling shaders here"),
     TEXT("Hello There"),
@@ -167,7 +166,7 @@ void SplashScreen::Show()
     settings.AllowMaximize = false;
     settings.AllowDragAndDrop = false;
     settings.IsTopmost = false;
-    settings.Type = WindowType::Utility;
+    settings.IsRegularWindow = false;
     settings.HasSizingFrame = false;
     settings.ShowAfterFirstPaint = true;
     settings.StartPosition = WindowStartPosition::CenterScreen;

Source/Engine/Animations/Graph/AnimGroup.Animation.cpp

@@ -2441,10 +2441,14 @@ void AnimGraphExecutor::ProcessGroupAnimation(Box* boxBase, Node* nodeBase, Valu
         {
             if (bucket.LoopsLeft == 0)
             {
-                // End playing animation
+                // End playing animation and reset bucket params
                 value = tryGetValue(node->GetBox(1), Value::Null);
                 bucket.Index = -1;
                 slot.Animation = nullptr;
+                bucket.TimePosition = 0.0f;
+                bucket.BlendInPosition = 0.0f;
+                bucket.BlendOutPosition = 0.0f;
+                bucket.LoopsDone = 0;
                 return;
             }
 
@@ -2553,9 +2557,15 @@ void AnimGraphExecutor::ProcessGroupFunction(Box* boxBase, Node* node, Value& va
     // Function Input
     case 1:
     {
+        // Skip when graph is too small (eg. preview) and fallback with default value from the function graph
+        if (context.GraphStack.Count() < 2)
+        {
+            value = tryGetValue(node->TryGetBox(1), Value::Zero);
+            break;
+        }
+
         // Find the function call
         AnimGraphNode* functionCallNode = nullptr;
-        ASSERT(context.GraphStack.Count() >= 2);
         Graph* graph;
         for (int32 i = context.CallStack.Count() - 1; i >= 0; i--)
         {

Source/Engine/Content/Content.cpp

@@ -30,6 +30,7 @@
 #include "Engine/Profiler/ProfilerCPU.h"
 #include "Engine/Profiler/ProfilerMemory.h"
 #include "Engine/Scripting/ManagedCLR/MClass.h"
+#include "Engine/Scripting/Internal/InternalCalls.h"
 #include "Engine/Scripting/Scripting.h"
 #if USE_EDITOR
 #include "Editor/Editor.h"
@@ -346,17 +347,21 @@ int32 LoadingThread::Run()
     ContentLoadTask* task;
     ThisLoadThread = this;
 
+    MONO_THREAD_INFO_TYPE* monoThreadInfo = nullptr;
     while (Platform::AtomicRead(&_exitFlag) == 0)
     {
         if (LoadTasks.try_dequeue(task))
         {
             Run(task);
+            MONO_THREAD_INFO_GET(monoThreadInfo);
         }
         else
         {
+            MONO_ENTER_GC_SAFE_WITH_INFO(monoThreadInfo);
             LoadTasksMutex.Lock();
             LoadTasksSignal.Wait(LoadTasksMutex);
             LoadTasksMutex.Unlock();
+            MONO_EXIT_GC_SAFE_WITH_INFO;
         }
     }
 

Source/Engine/Core/Collections/Array.h

@@ -658,7 +658,10 @@ public:
         --_count;
         T* data = _allocation.Get();
         if (index < _count)
-            Memory::MoveAssignItems(data + index, data + (index + 1), _count - index);
+        {
+            for (int32 i = index; i < _count; i++)
+                data[i] = MoveTemp(data[i + 1]);
+        }
         Memory::DestructItems(data + _count, 1);
     }
 

Source/Engine/Core/Collections/HashSetBase.h

@@ -409,27 +409,36 @@ protected:
         else
         {
             // Rebuild entire table completely
+            const int32 elementsCount = _elementsCount;
+            const int32 oldSize = _size;
             AllocationData oldAllocation;
-            AllocationUtils::MoveToEmpty<BucketType, AllocationType>(oldAllocation, _allocation, _size, _size);
+            AllocationUtils::MoveToEmpty<BucketType, AllocationType>(oldAllocation, _allocation, oldSize, oldSize);
             _allocation.Allocate(_size);
             BucketType* data = _allocation.Get();
-            for (int32 i = 0; i < _size; ++i)
+            for (int32 i = 0; i < oldSize; ++i)
                 data[i]._state = HashSetBucketState::Empty;
             BucketType* oldData = oldAllocation.Get();
             FindPositionResult pos;
-            for (int32 i = 0; i < _size; ++i)
+            for (int32 i = 0; i < oldSize; ++i)
             {
                 BucketType& oldBucket = oldData[i];
                 if (oldBucket.IsOccupied())
                 {
                     FindPosition(oldBucket.GetKey(), pos);
-                    ASSERT(pos.FreeSlotIndex != -1);
+                    if (pos.FreeSlotIndex == -1)
+                    {
+                        // Grow and retry to handle pathological cases (eg. heavy collisions)
+                        EnsureCapacity(_size + 1, true);
+                        FindPosition(oldBucket.GetKey(), pos);
+                        ASSERT(pos.FreeSlotIndex != -1);
+                    }
                     BucketType& bucket = _allocation.Get()[pos.FreeSlotIndex];
                     bucket = MoveTemp(oldBucket);
                 }
             }
-            for (int32 i = 0; i < _size; ++i)
+            for (int32 i = 0; i < oldSize; ++i)
                 oldData[i].Free();
+            _elementsCount = elementsCount;
         }
         _deletedCount = 0;
     }

Source/Engine/Core/Compiler.h

@@ -4,8 +4,9 @@
 
 #if defined(__clang__)
 
-#define DLLEXPORT __attribute__ ((__visibility__ ("default")))
+#define DLLEXPORT __attribute__((__visibility__("default")))
 #define DLLIMPORT
+#define USED __attribute__((used))
 #define THREADLOCAL __thread
 #define STDCALL __attribute__((stdcall))
 #define CDECL __attribute__((cdecl))
@@ -19,7 +20,7 @@
 #define PACK_BEGIN()
 #define PACK_END() __attribute__((__packed__))
 #define ALIGN_BEGIN(_align)
-#define ALIGN_END(_align) __attribute__( (aligned(_align) ) )
+#define ALIGN_END(_align) __attribute__((aligned(_align)))
 #define OFFSET_OF(X, Y) __builtin_offsetof(X, Y)
 #define PRAGMA_DISABLE_DEPRECATION_WARNINGS \
     _Pragma("clang diagnostic push") \
@@ -37,8 +38,9 @@
 
 #elif defined(__GNUC__)
 
-#define DLLEXPORT __attribute__ ((__visibility__ ("default")))
+#define DLLEXPORT __attribute__((__visibility__("default")))
 #define DLLIMPORT
+#define USED __attribute__((used))
 #define THREADLOCAL __thread
 #define STDCALL __attribute__((stdcall))
 #define CDECL __attribute__((cdecl))
@@ -52,7 +54,7 @@
 #define PACK_BEGIN()
 #define PACK_END() __attribute__((__packed__))
 #define ALIGN_BEGIN(_align)
-#define ALIGN_END(_align) __attribute__( (aligned(_align) ) )
+#define ALIGN_END(_align) __attribute__((aligned(_align)))
 #define OFFSET_OF(X, Y) __builtin_offsetof(X, Y)
 #define PRAGMA_DISABLE_DEPRECATION_WARNINGS
 #define PRAGMA_ENABLE_DEPRECATION_WARNINGS
@@ -67,6 +69,7 @@
 
 #define DLLEXPORT __declspec(dllexport)
 #define DLLIMPORT __declspec(dllimport)
+#define USED
 #define THREADLOCAL __declspec(thread)
 #define STDCALL __stdcall
 #define CDECL __cdecl

Source/Engine/Core/Memory/Allocation.h

@@ -18,9 +18,7 @@ namespace AllocationUtils
         capacity |= capacity >> 8;
         capacity |= capacity >> 16;
         uint64 capacity64 = (uint64)(capacity + 1) * 2;
-        if (capacity64 > MAX_int32)
-            capacity64 = MAX_int32;
-        return (int32)capacity64;
+        return capacity64 >= MAX_int32 ? MAX_int32 : (int32)capacity64 / 2;
     }
 
     // Aligns the input value to the next power of 2 to be used as bigger memory allocation block.

Source/Engine/Engine/CommandLine.cpp

@@ -145,12 +145,6 @@ bool CommandLine::Parse(const Char* cmdLine)
     PARSE_BOOL_SWITCH("-monolog ", MonoLog);
     PARSE_BOOL_SWITCH("-mute ", Mute);
     PARSE_BOOL_SWITCH("-lowdpi ", LowDPI);
-
-#if PLATFORM_LINUX && PLATFORM_SDL
-    PARSE_BOOL_SWITCH("-wayland ", Wayland);
-    PARSE_BOOL_SWITCH("-x11 ", X11);
-#endif
-
 #if USE_EDITOR
     PARSE_BOOL_SWITCH("-clearcache ", ClearCache);
     PARSE_BOOL_SWITCH("-clearcooker ", ClearCookerCache);

Source/Engine/Engine/CommandLine.h

@@ -127,20 +127,6 @@ public:
         /// </summary>
         Nullable<bool> LowDPI;
 
-#if PLATFORM_LINUX && PLATFORM_SDL
-
-        /// <summary>
-        /// -wayland (prefer Wayland over X11 as display server)
-        /// </summary>
-        Nullable<bool> Wayland;
-
-        /// <summary>
-        /// -x11 (prefer X11 over Wayland as display server)
-        /// </summary>
-        Nullable<bool> X11;
-
-#endif
-
 #if USE_EDITOR
         /// <summary>
         /// -project !path! (Startup project path)

Source/Engine/Engine/Engine.cpp

@@ -105,8 +105,6 @@ int32 Engine::Main(const Char* cmdLine)
     CommandLine::Options.Std = true;
 #endif
 
-    Platform::SetHighDpiAwarenessEnabled(!CommandLine::Options.LowDPI.IsTrue());
-
     if (Platform::Init())
     {
         Platform::Fatal(TEXT("Cannot init platform."));
@@ -116,6 +114,7 @@ int32 Engine::Main(const Char* cmdLine)
     InitProfilerMemory(cmdLine, 1);
 #endif
 
+    Platform::SetHighDpiAwarenessEnabled(!CommandLine::Options.LowDPI.IsTrue());
     Time::StartupTime = DateTime::Now();
     Globals::StartupFolder = Globals::BinariesFolder = Platform::GetMainDirectory();
 #if USE_EDITOR

Source/Engine/Engine/NativeInterop.cs

@@ -79,10 +79,11 @@ namespace FlaxEngine.Interop
             NativeLibrary.SetDllImportResolver(Assembly.GetExecutingAssembly(), NativeLibraryImportResolver);
 
             // Change default culture to match with Mono runtime default culture
-            CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
-            CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
-            System.Threading.Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
-            System.Threading.Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
+            var culture = CultureInfo.InvariantCulture;
+            CultureInfo.DefaultThreadCurrentCulture = culture;
+            CultureInfo.DefaultThreadCurrentUICulture = culture;
+            System.Threading.Thread.CurrentThread.CurrentCulture = culture;
+            System.Threading.Thread.CurrentThread.CurrentUICulture = culture;
 
         }
 

Source/Engine/Engine/Screen.cpp

@@ -6,8 +6,6 @@
 #include "Engine/Core/Types/Nullable.h"
 #include "Engine/Platform/Window.h"
 #include "Engine/Engine/EngineService.h"
-#include "Engine/Input/Input.h"
-#include "Engine/Input/Mouse.h"
 #if USE_EDITOR
 #include "Editor/Editor.h"
 #include "Editor/Managed/ManagedEditor.h"
@@ -15,14 +13,10 @@
 #include "Engine/Engine/Engine.h"
 #endif
 
-namespace
-{
-    Nullable<bool> Fullscreen;
-    Nullable<Float2> Size;
-    bool CursorVisible = true;
-    CursorLockMode CursorLock = CursorLockMode::None;
-    bool LastGameViewportFocus = false;
-}
+Nullable<bool> Fullscreen;
+Nullable<Float2> Size;
+bool CursorVisible = true;
+CursorLockMode CursorLock = CursorLockMode::None;
 
 class ScreenService : public EngineService
 {
@@ -107,9 +101,9 @@ void Screen::SetCursorVisible(const bool value)
 	const auto win = Engine::MainWindow;
 #endif
     if (win && Engine::HasGameViewportFocus())
+    {
         win->SetCursor(value ? CursorType::Default : CursorType::Hidden);
-    else if (win)
-        win->SetCursor(CursorType::Default);
+    }
     CursorVisible = value;
 }
 
@@ -122,31 +116,21 @@ void Screen::SetCursorLock(CursorLockMode mode)
 {
 #if USE_EDITOR
     const auto win = Editor::Managed->GetGameWindow(true);
-    Rectangle bounds(Editor::Managed->GameViewportToScreen(Float2::Zero), Editor::Managed->GetGameWindowSize());
-    if (win)
-        bounds = Rectangle(win->ScreenToClient(bounds.GetTopLeft()), bounds.Size);
 #else
     const auto win = Engine::MainWindow;
-    Rectangle bounds = win != nullptr ? win->GetClientBounds() : Rectangle();
 #endif
-    if (win)
+    if (win && mode == CursorLockMode::Clipped)
     {
-        bool inRelativeMode = Input::Mouse->IsRelative();
-        if (mode == CursorLockMode::Clipped)
-            win->StartClippingCursor(bounds);
-        else if (mode == CursorLockMode::Locked)
-        {
-            // Use mouse clip region to restrict the cursor in one spot
-            win->StartClippingCursor(Rectangle(bounds.GetCenter(), Float2(1, 1)));
-        }
-        else if (CursorLock == CursorLockMode::Locked || CursorLock == CursorLockMode::Clipped)
-            win->EndClippingCursor();
-
-        // Enable relative mode when cursor is restricted
-        if (mode != CursorLockMode::None)
-            Input::Mouse->SetRelativeMode(true, win);
-        else if (mode == CursorLockMode::None && inRelativeMode)
-            Input::Mouse->SetRelativeMode(false, win);
+#if USE_EDITOR
+        Rectangle bounds(Editor::Managed->GameViewportToScreen(Float2::Zero), Editor::Managed->GetGameWindowSize());
+#else
+        Rectangle bounds = win->GetClientBounds();
+#endif
+        win->StartClippingCursor(bounds);
+    }
+    else if (win && CursorLock == CursorLockMode::Clipped)
+    {
+        win->EndClippingCursor();
     }
     CursorLock = mode;
 }
@@ -206,11 +190,7 @@ void ScreenService::Update()
 {
 #if USE_EDITOR
     // Sync current cursor state in Editor (eg. when viewport focus can change)
-    const auto win = Editor::Managed->GetGameWindow(true);
-    bool gameViewportFocus = win && Engine::HasGameViewportFocus();
-    if (gameViewportFocus != LastGameViewportFocus)
-        Screen::SetCursorVisible(CursorVisible);
-    LastGameViewportFocus = gameViewportFocus;
+    Screen::SetCursorVisible(CursorVisible);
 #endif
 }
 

Source/Engine/Engine/Time.h

@@ -16,7 +16,6 @@ API_CLASS(Static, Attributes="DebugCommand") class FLAXENGINE_API Time
     friend class Engine;
     friend class TimeService;
     friend class PhysicsSettings;
-    friend Window;
 
 public:
     /// <summary>

Source/Engine/Graphics/GPUContext.cpp

@@ -67,7 +67,7 @@ void GPUContext::FrameBegin()
 
 void GPUContext::FrameEnd()
 {
-    ClearState();
+    ResetState();
     FlushState();
 }
 

Source/Engine/Graphics/GPUContext.h

@@ -189,7 +189,7 @@ public:
     /// [Deprecated in v1.10]
     /// </summary>
     /// <returns><c>true</c> if  depth buffer is binded; otherwise, <c>false</c>.</returns>
-    DEPRECATED("IsDepthBufferBinded has been deprecated and will be removed in ")
+    DEPRECATED("IsDepthBufferBinded has been deprecated and will be removed in future")
     virtual bool IsDepthBufferBinded() = 0;
 
 public:
@@ -617,8 +617,17 @@ public:
 
     /// <summary>
     /// Clears the context state.
+    /// [Deprecated in v1.12]
     /// </summary>
-    API_FUNCTION() virtual void ClearState() = 0;
+    API_FUNCTION() DEPRECATED("Use ResetState instead") void ClearState()
+    {
+        ResetState();
+    }
+
+    /// <summary>
+    /// Resets the context state.
+    /// </summary>
+    API_FUNCTION() virtual void ResetState() = 0;
 
     /// <summary>
     /// Flushes the internal cached context state with a command buffer.

Source/Engine/Graphics/Materials/DeferredMaterialShader.cpp

@@ -201,6 +201,7 @@ bool DeferredMaterialShader::Load()
     psDesc.DepthWriteEnable = true;
     psDesc.DepthEnable = true;
     psDesc.DepthFunc = ComparisonFunc::Less;
+    psDesc.BlendMode.RenderTargetWriteMask = BlendingMode::ColorWrite::None;
     psDesc.HS = nullptr;
     psDesc.DS = nullptr;
     GPUShaderProgramVS* instancedDepthPassVS;

Source/Engine/Graphics/Materials/ForwardMaterialShader.cpp

@@ -195,5 +195,10 @@ bool ForwardMaterialShader::Load()
     psDesc.VS = _shader->GetVS("VS_Skinned");
     _cache.DepthSkinned.Init(psDesc);
 
+#if PLATFORM_PS5
+    // Fix shader binding issues on forward shading materials on PS5
+    _drawModes = DrawPass::None;
+#endif
+
     return false;
 }

Source/Engine/Graphics/Materials/ParticleMaterialShader.cpp

@@ -264,5 +264,10 @@ bool ParticleMaterialShader::Load()
     // Lazy initialization
     _cacheVolumetricFog.Desc.PS = nullptr;
 
+#if PLATFORM_PS5
+    // Fix shader binding issues on forward shading materials on PS5
+    _drawModes = DrawPass::None;
+#endif
+
     return false;
 }

Source/Engine/Graphics/RenderBuffers.cpp

@@ -113,7 +113,8 @@ GPUTexture* RenderBuffers::RequestHalfResDepth(GPUContext* context)
 
 PixelFormat RenderBuffers::GetOutputFormat() const
 {
-    return _useAlpha ? PixelFormat::R16G16B16A16_Float : PixelFormat::R11G11B10_Float;
+    // TODO: fix incorrect alpha leaking into reflections on PS5 with R11G11B10_Float
+    return _useAlpha || PLATFORM_PS5 ? PixelFormat::R16G16B16A16_Float : PixelFormat::R11G11B10_Float;
 }
 
 bool RenderBuffers::GetUseAlpha() const

Source/Engine/Graphics/RenderTask.h

@@ -450,7 +450,7 @@ public:
 /// <summary>
 /// The high-level renderer context. Used to collect the draw calls for the scene rendering. Can be used to perform a custom rendering.
 /// </summary>
-API_STRUCT(NoDefault) struct RenderContext
+API_STRUCT(NoDefault) struct FLAXENGINE_API RenderContext
 {
     DECLARE_SCRIPTING_TYPE_MINIMAL(RenderContext);
 
@@ -491,7 +491,7 @@ API_STRUCT(NoDefault) struct RenderContext
 /// <summary>
 /// The high-level renderer context batch that encapsulates multiple rendering requests within a single task (eg. optimize main view scene rendering and shadow projections at once).
 /// </summary>
-API_STRUCT(NoDefault) struct RenderContextBatch
+API_STRUCT(NoDefault) struct FLAXENGINE_API RenderContextBatch
 {
     DECLARE_SCRIPTING_TYPE_MINIMAL(RenderContextBatch);
 

Source/Engine/Graphics/Shaders/GPUVertexLayout.cpp

@@ -216,20 +216,21 @@ GPUVertexLayout* GPUVertexLayout::Get(const Span<GPUVertexLayout*>& layouts)
     return result;
 }
 
-GPUVertexLayout* GPUVertexLayout::Merge(GPUVertexLayout* base, GPUVertexLayout* reference, bool removeUnused, bool addMissing, int32 missingSlotOverride)
+GPUVertexLayout* GPUVertexLayout::Merge(GPUVertexLayout* base, GPUVertexLayout* reference, bool removeUnused, bool addMissing, int32 missingSlotOverride, bool referenceOrder)
 {
     GPUVertexLayout* result = base ? base : reference;
     if (base && reference && base != reference)
     {
         bool elementsModified = false;
         Elements newElements = base->GetElements();
+        const Elements& refElements = reference->GetElements();
         if (removeUnused)
         {
             for (int32 i = newElements.Count() - 1; i >= 0; i--)
             {
                 bool missing = true;
                 const VertexElement& e = newElements.Get()[i];
-                for (const VertexElement& ee : reference->GetElements())
+                for (const VertexElement& ee : refElements)
                 {
                     if (ee.Type == e.Type)
                     {
@@ -247,7 +248,7 @@ GPUVertexLayout* GPUVertexLayout::Merge(GPUVertexLayout* base, GPUVertexLayout*
         }
         if (addMissing)
         {
-            for (const VertexElement& e : reference->GetElements())
+            for (const VertexElement& e : refElements)
             {
                 bool missing = true;
                 for (const VertexElement& ee : base->GetElements())
@@ -282,6 +283,32 @@ GPUVertexLayout* GPUVertexLayout::Merge(GPUVertexLayout* base, GPUVertexLayout*
                 }
             }
         }
+        if (referenceOrder)
+        {
+            for (int32 i = 0, j = 0; i < newElements.Count() && j < refElements.Count(); j++)
+            {
+                if (newElements[i].Type == refElements[j].Type)
+                {
+                    // Elements match so move forward
+                    i++;
+                    continue;
+                }
+
+                // Find reference element in a new list
+                for (int32 k = i + 1; k < newElements.Count(); k++)
+                {
+                    if (newElements[k].Type == refElements[j].Type)
+                    {
+                        // Move matching element to the reference position
+                        VertexElement e = newElements[k];
+                        newElements.RemoveAt(k);
+                        newElements.Insert(i, e);
+                        i++;
+                        break;
+                    }
+                }
+            }
+        }
         if (elementsModified)
             result = Get(newElements, true);
     }

Source/Engine/Graphics/Shaders/GPUVertexLayout.h

@@ -84,8 +84,9 @@ public:
     /// <param name="removeUnused">True to remove elements from base layout that don't exist in a reference layout.</param>
     /// <param name="addMissing">True to add missing elements to base layout that exist in a reference layout.</param>
     /// <param name="missingSlotOverride">Allows to override the input slot for missing elements. Use value -1 to inherit slot from the reference layout.</param>
+    /// <param name="referenceOrder">True to reorder result elements to match the reference layout. For example, if input vertex buffer layout is different than vertex shader then it can match those.</param>
     /// <returns>Vertex layout object. Doesn't need to be cleared as it's cached for an application lifetime.</returns>
-    static GPUVertexLayout* Merge(GPUVertexLayout* base, GPUVertexLayout* reference, bool removeUnused = false, bool addMissing = true, int32 missingSlotOverride = -1);
+    static GPUVertexLayout* Merge(GPUVertexLayout* base, GPUVertexLayout* reference, bool removeUnused = false, bool addMissing = true, int32 missingSlotOverride = -1, bool referenceOrder = false);
 
 public:
     // [GPUResource]

Source/Engine/GraphicsDevice/DirectX/DX11/GPUContextDX11.cpp

@@ -724,7 +724,7 @@ void GPUContextDX11::SetState(GPUPipelineState* state)
     }
 }
 
-void GPUContextDX11::ClearState()
+void GPUContextDX11::ResetState()
 {
     if (!_context)
         return;

Source/Engine/GraphicsDevice/DirectX/DX11/GPUContextDX11.h

@@ -158,7 +158,7 @@ public:
     void SetScissor(const Rectangle& scissorRect) override;
     GPUPipelineState* GetState() const override;
     void SetState(GPUPipelineState* state) override;
-    void ClearState() override;
+    void ResetState() override;
     void FlushState() override;
     void Flush() override;
     void UpdateBuffer(GPUBuffer* buffer, const void* data, uint32 size, uint32 offset) override;

Source/Engine/GraphicsDevice/DirectX/DX12/CommandQueueDX12.cpp

@@ -143,6 +143,8 @@ void CommandQueueDX12::WaitForFence(uint64 fenceValue)
 
 void CommandQueueDX12::WaitForGPU()
 {
+    PROFILE_CPU();
+    ZoneColor(TracyWaitZoneColor);
     const uint64 value = _fence.Signal(this);
     _fence.WaitCPU(value);
 }

Source/Engine/GraphicsDevice/DirectX/DX12/GPUBufferDX12.cpp

@@ -137,7 +137,7 @@ bool GPUBufferDX12::OnInit()
     // Create resource
     ID3D12Resource* resource;
 #if PLATFORM_WINDOWS
-    D3D12_HEAP_FLAGS heapFlags = D3D12_HEAP_FLAG_CREATE_NOT_ZEROED;
+    D3D12_HEAP_FLAGS heapFlags = EnumHasAnyFlags(_desc.Flags, GPUBufferFlags::VertexBuffer | GPUBufferFlags::IndexBuffer) || _desc.InitData ? D3D12_HEAP_FLAG_CREATE_NOT_ZEROED : D3D12_HEAP_FLAG_NONE;
 #else
     D3D12_HEAP_FLAGS heapFlags = D3D12_HEAP_FLAG_NONE;
 #endif

Source/Engine/GraphicsDevice/DirectX/DX12/GPUContextDX12.cpp

@@ -1304,7 +1304,7 @@ void GPUContextDX12::SetState(GPUPipelineState* state)
     }
 }
 
-void GPUContextDX12::ClearState()
+void GPUContextDX12::ResetState()
 {
     if (!_commandList)
         return;

Source/Engine/GraphicsDevice/DirectX/DX12/GPUContextDX12.h

@@ -201,7 +201,7 @@ public:
     void SetScissor(const Rectangle& scissorRect) override;
     GPUPipelineState* GetState() const override;
     void SetState(GPUPipelineState* state) override;
-    void ClearState() override;
+    void ResetState() override;
     void FlushState() override;
     void Flush() override;
     void UpdateBuffer(GPUBuffer* buffer, const void* data, uint32 size, uint32 offset) override;

Source/Engine/GraphicsDevice/DirectX/DX12/GPUDeviceDX12.cpp

@@ -628,6 +628,7 @@ bool GPUDeviceDX12::Init()
     VALIDATE_DIRECTX_CALL(dxgiAdapter->EnumOutputs(0, dxgiOutput.GetAddressOf()));
     DXGI_FORMAT backbufferFormat = RenderToolsDX::ToDxgiFormat(GPU_BACK_BUFFER_PIXEL_FORMAT);
     UINT modesCount = 0;
+#ifdef _GAMING_XBOX_SCARLETT
     VALIDATE_DIRECTX_CALL(dxgiOutput->GetDisplayModeList(backbufferFormat, 0, &modesCount, NULL));
     Array<DXGIXBOX_MODE_DESC> modes;
     modes.Resize((int32)modesCount);
@@ -642,6 +643,11 @@ bool GPUDeviceDX12::Init()
         videoOutput.RefreshRate = Math::Max(videoOutput.RefreshRate, mode.RefreshRate.Numerator / (float)mode.RefreshRate.Denominator);
     }
     modes.Resize(0);
+#else
+    videoOutput.Width = 1920;
+    videoOutput.Height = 1080;
+    videoOutput.RefreshRate = 60;
+#endif
 
 #if PLATFORM_GDK
     GDKPlatform::Suspended.Bind<GPUDeviceDX12, &GPUDeviceDX12::OnSuspended>(this);

Source/Engine/GraphicsDevice/DirectX/DX12/GPUTextureDX12.cpp

@@ -159,7 +159,7 @@ bool GPUTextureDX12::OnInit()
         initialState = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE | D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
 
     // Create texture
-#if PLATFORM_WINDOWS
+#if PLATFORM_WINDOWS && 0
     D3D12_HEAP_FLAGS heapFlags = useRTV || useDSV ? D3D12_HEAP_FLAG_CREATE_NOT_ZEROED : D3D12_HEAP_FLAG_NONE;
 #else
     D3D12_HEAP_FLAGS heapFlags = D3D12_HEAP_FLAG_NONE;

Source/Engine/GraphicsDevice/Null/GPUContextNull.h

@@ -177,7 +177,7 @@ public:
     {
     }
 
-    void ClearState() override
+    void ResetState() override
     {
     }
 

Source/Engine/GraphicsDevice/Vulkan/Android/AndroidVulkanPlatform.cpp

@@ -4,7 +4,6 @@
 
 #include "AndroidVulkanPlatform.h"
 #include "../RenderToolsVulkan.h"
-#include "Engine/Platform/Window.h"
 
 void AndroidVulkanPlatform::GetInstanceExtensions(Array<const char*>& extensions, Array<const char*>& layers)
 {
@@ -18,10 +17,8 @@ void AndroidVulkanPlatform::GetDeviceExtensions(Array<const char*>& extensions,
 	extensions.Add(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME);
 }
 
-void AndroidVulkanPlatform::CreateSurface(Window* window, GPUDeviceVulkan* device, VkInstance instance, VkSurfaceKHR* surface)
+void AndroidVulkanPlatform::CreateSurface(void* windowHandle, VkInstance instance, VkSurfaceKHR* surface)
 {
-    ASSERT(window);
-    void* windowHandle = window->GetNativePtr();
     ASSERT(windowHandle);
     VkAndroidSurfaceCreateInfoKHR surfaceCreateInfo;
     RenderToolsVulkan::ZeroStruct(surfaceCreateInfo, VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR);

Source/Engine/GraphicsDevice/Vulkan/Android/AndroidVulkanPlatform.h

@@ -9,8 +9,6 @@
 // Support more backbuffers in case driver decides to use more
 #define VULKAN_BACK_BUFFERS_COUNT_MAX 8
 
-class GPUDeviceVulkan;
-
 /// <summary>
 /// The implementation for the Vulkan API support for Android platform.
 /// </summary>
@@ -19,7 +17,7 @@ class AndroidVulkanPlatform : public VulkanPlatformBase
 public:
 	static void GetInstanceExtensions(Array<const char*>& extensions, Array<const char*>& layers);
 	static void GetDeviceExtensions(Array<const char*>& extensions, Array<const char*>& layers);
-	static void CreateSurface(Window* window, GPUDeviceVulkan* device, VkInstance instance, VkSurfaceKHR* surface);
+	static void CreateSurface(void* windowHandle, VkInstance instance, VkSurfaceKHR* surface);
 };
 
 typedef AndroidVulkanPlatform VulkanPlatform;

Source/Engine/GraphicsDevice/Vulkan/GPUContextVulkan.cpp

@@ -1329,7 +1329,7 @@ void GPUContextVulkan::SetState(GPUPipelineState* state)
     }
 }
 
-void GPUContextVulkan::ClearState()
+void GPUContextVulkan::ResetState()
 {
     ResetRenderTarget();
     ResetSR();

Source/Engine/GraphicsDevice/Vulkan/GPUContextVulkan.h

@@ -193,7 +193,7 @@ public:
     void SetScissor(const Rectangle& scissorRect) override;
     GPUPipelineState* GetState() const override;
     void SetState(GPUPipelineState* state) override;
-    void ClearState() override;
+    void ResetState() override;
     void FlushState() override;
     void Flush() override;
     void UpdateBuffer(GPUBuffer* buffer, const void* data, uint32 size, uint32 offset) override;

Source/Engine/GraphicsDevice/Vulkan/GPUSwapChainVulkan.cpp

@@ -195,7 +195,7 @@ bool GPUSwapChainVulkan::CreateSwapChain(int32 width, int32 height)
     ASSERT_LOW_LAYER(_backBuffers.Count() == 0);
 
     // Create platform-dependent surface
-    VulkanPlatform::CreateSurface(_window, _device, GPUDeviceVulkan::Instance, &_surface);
+    VulkanPlatform::CreateSurface(windowHandle, GPUDeviceVulkan::Instance, &_surface);
     if (_surface == VK_NULL_HANDLE)
     {
         LOG(Warning, "Failed to create Vulkan surface.");
@@ -352,22 +352,13 @@ bool GPUSwapChainVulkan::CreateSwapChain(int32 width, int32 height)
         LOG(Error, "Vulkan swapchain dimensions are invalid {}x{} (minImageExtent={}x{}, maxImageExtent={}x{})", width, height, surfProperties.minImageExtent.width, surfProperties.minImageExtent.height, surfProperties.maxImageExtent.width, surfProperties.maxImageExtent.height);
         return true;
     }
-
-    uint32_t backbuffersCount = VULKAN_BACK_BUFFERS_COUNT;
-#if PLATFORM_SDL && PLATFORM_LINUX && USE_EDITOR
-    // Wayland compositor might block one of the backbuffers while the window is minimized or fully occluded,
-    // make sure we have at least 3 backbuffers available so double-buffering can be used while we are blocked.
-    if (Platform::UsesWayland())
-        backbuffersCount = Math::Max<uint32_t>(backbuffersCount, 3);
-#endif
-    
     ASSERT(surfProperties.minImageCount <= VULKAN_BACK_BUFFERS_COUNT_MAX);
     VkSwapchainCreateInfoKHR swapChainInfo;
     RenderToolsVulkan::ZeroStruct(swapChainInfo, VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR);
     swapChainInfo.surface = _surface;
     swapChainInfo.minImageCount = surfProperties.maxImageCount > 0 // A value of 0 means that there is no limit on the number of image
-                                      ? Math::Min<uint32_t>(backbuffersCount, surfProperties.maxImageCount)
-                                      : backbuffersCount;
+                                      ? Math::Min<uint32_t>(VULKAN_BACK_BUFFERS_COUNT, surfProperties.maxImageCount)
+                                      : VULKAN_BACK_BUFFERS_COUNT;
     swapChainInfo.minImageCount = Math::Max<uint32_t>(swapChainInfo.minImageCount, surfProperties.minImageCount);
     swapChainInfo.minImageCount = Math::Min<uint32_t>(swapChainInfo.minImageCount, VULKAN_BACK_BUFFERS_COUNT_MAX);
     swapChainInfo.imageFormat = result.format;
@@ -386,9 +377,7 @@ bool GPUSwapChainVulkan::CreateSwapChain(int32 width, int32 height)
     swapChainInfo.presentMode = presentMode;
     swapChainInfo.clipped = VK_TRUE;
     swapChainInfo.compositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
-    if (_window->GetSettings().SupportsTransparency && surfProperties.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR)
-        swapChainInfo.compositeAlpha = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR;
-    else if (surfProperties.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR)
+    if (surfProperties.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR)
         swapChainInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
 
     // Create swap chain

Source/Engine/GraphicsDevice/Vulkan/Linux/LinuxVulkanPlatform.cpp

@@ -4,61 +4,62 @@
 
 #include "LinuxVulkanPlatform.h"
 #include "../RenderToolsVulkan.h"
-#include "Engine/Platform/Window.h"
 
+// Contents of vulkan\vulkan_xlib.h inlined here to prevent typename collisions with engine types due to X11 types
 #include "Engine/Platform/Linux/IncludeX11.h"
-#define Display X11::Display
-#define Window X11::Window
-#define VisualID X11::VisualID
-#include "vulkan/vulkan_xlib.h"
-#undef Display
-#undef Window
-#undef VisualID
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define VK_KHR_xlib_surface 1
+#define VK_KHR_XLIB_SURFACE_SPEC_VERSION  6
+#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
+typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
 
-#include "vulkan/vulkan_wayland.h"
+typedef struct VkXlibSurfaceCreateInfoKHR
+{
+	VkStructureType sType;
+	const void* pNext;
+	VkXlibSurfaceCreateFlagsKHR flags;
+	X11::Display* dpy;
+	X11::Window window;
+} VkXlibSurfaceCreateInfoKHR;
 
-// Export extension from volk
+typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, X11::Display* dpy, X11::VisualID visualID);
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
+    VkInstance                                  instance,
+    const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    Display*                                    dpy,
+    VisualID                                    visualID);
+#endif
+#ifdef __cplusplus
+}
+#endif
+//
+
+// Export X11 surface extension from volk
 extern PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR;
 extern PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR;
-extern PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR;
-extern PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR;
 
 void LinuxVulkanPlatform::GetInstanceExtensions(Array<const char*>& extensions, Array<const char*>& layers)
 {
 	extensions.Add(VK_KHR_SURFACE_EXTENSION_NAME);
 	extensions.Add(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
-    extensions.Add(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
 }
 
-void LinuxVulkanPlatform::CreateSurface(Window* window, GPUDeviceVulkan* device, VkInstance instance, VkSurfaceKHR* surface)
+void LinuxVulkanPlatform::CreateSurface(void* windowHandle, VkInstance instance, VkSurfaceKHR* surface)
 {
-#if !PLATFORM_SDL
-    void* windowHandle = window->GetNativePtr();
 	VkXlibSurfaceCreateInfoKHR surfaceCreateInfo;
 	RenderToolsVulkan::ZeroStruct(surfaceCreateInfo, VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR);
-	surfaceCreateInfo.dpy = (X11::Display*)Platform::GetXDisplay();
+	surfaceCreateInfo.dpy = (X11::Display*)LinuxPlatform::GetXDisplay();
 	surfaceCreateInfo.window = (X11::Window)windowHandle;
 	VALIDATE_VULKAN_RESULT(vkCreateXlibSurfaceKHR(instance, &surfaceCreateInfo, nullptr, surface));
-#else
-    SDLWindow* sdlWindow = static_cast<Window*>(window);
-    void* windowHandle = window->GetNativePtr();
-    if (SDLPlatform::UsesWayland())
-    {
-        VkWaylandSurfaceCreateInfoKHR surfaceCreateInfo;
-        RenderToolsVulkan::ZeroStruct(surfaceCreateInfo, VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR);
-        surfaceCreateInfo.display = (wl_display*)sdlWindow->GetWaylandDisplay();
-        surfaceCreateInfo.surface = (wl_surface*)windowHandle;
-        VALIDATE_VULKAN_RESULT(vkCreateWaylandSurfaceKHR(instance, &surfaceCreateInfo, nullptr, surface));
-    }
-    else if (SDLPlatform::UsesX11())
-    {
-        VkXlibSurfaceCreateInfoKHR surfaceCreateInfo;
-        RenderToolsVulkan::ZeroStruct(surfaceCreateInfo, VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR);
-        surfaceCreateInfo.dpy = (X11::Display*)sdlWindow->GetX11Display();
-        surfaceCreateInfo.window = (X11::Window)windowHandle;
-        VALIDATE_VULKAN_RESULT(vkCreateXlibSurfaceKHR(instance, &surfaceCreateInfo, nullptr, surface));
-    }
-#endif
 }
 
 #endif

Source/Engine/GraphicsDevice/Vulkan/Linux/LinuxVulkanPlatform.h

@@ -12,8 +12,6 @@
 // Prevent wierd error 'Invalid VkValidationCacheEXT Object'
 #define VULKAN_USE_VALIDATION_CACHE 0
 
-class GPUDeviceVulkan;
-
 /// <summary>
 /// The implementation for the Vulkan API support for Linux platform.
 /// </summary>
@@ -21,7 +19,7 @@ class LinuxVulkanPlatform : public VulkanPlatformBase
 {
 public:
 	static void GetInstanceExtensions(Array<const char*>& extensions, Array<const char*>& layers);
-	static void CreateSurface(Window* window, GPUDeviceVulkan* device, VkInstance instance, VkSurfaceKHR* outSurface);
+	static void CreateSurface(void* windowHandle, VkInstance instance, VkSurfaceKHR* outSurface);
 };
 
 typedef LinuxVulkanPlatform VulkanPlatform;

Source/Engine/GraphicsDevice/Vulkan/Mac/MacVulkanPlatform.cpp

@@ -4,40 +4,21 @@
 
 #include "MacVulkanPlatform.h"
 #include "../RenderToolsVulkan.h"
-#include "Engine/Platform/Window.h"
-#include "Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.h"
 #include <Cocoa/Cocoa.h>
-#include <QuartzCore/CAMetalLayer.h>
 
 void MacVulkanPlatform::GetInstanceExtensions(Array<const char*>& extensions, Array<const char*>& layers)
 {
     extensions.Add(VK_KHR_SURFACE_EXTENSION_NAME);
-    extensions.Add(VK_MVK_MACOS_SURFACE_EXTENSION_NAME);
-    extensions.Add(VK_EXT_METAL_SURFACE_EXTENSION_NAME);
+	extensions.Add(VK_MVK_MACOS_SURFACE_EXTENSION_NAME);
 }
 
-void MacVulkanPlatform::CreateSurface(Window* window, GPUDeviceVulkan* device, VkInstance instance, VkSurfaceKHR* surface)
+void MacVulkanPlatform::CreateSurface(void* windowHandle, VkInstance instance, VkSurfaceKHR* surface)
 {
-    void* windowHandle = window->GetNativePtr();
-    NSWindow* nswindow = (NSWindow*)windowHandle;
-#if PLATFORM_SDL
-    nswindow.contentView.wantsLayer = YES;
-    nswindow.contentView.layer = [CAMetalLayer layer];
-#endif
-    if (device->InstanceExtensions.Contains(VK_EXT_METAL_SURFACE_EXTENSION_NAME))
-    {
-        VkMetalSurfaceCreateInfoEXT surfaceCreateInfo;
-        RenderToolsVulkan::ZeroStruct(surfaceCreateInfo, VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT);
-        surfaceCreateInfo.pLayer = (CAMetalLayer*)nswindow.contentView.layer;
-        VALIDATE_VULKAN_RESULT(vkCreateMetalSurfaceEXT(instance, &surfaceCreateInfo, nullptr, surface));
-    }
-    else
-    {
-        VkMacOSSurfaceCreateInfoMVK surfaceCreateInfo;
-        RenderToolsVulkan::ZeroStruct(surfaceCreateInfo, VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK);
-        surfaceCreateInfo.pView = (void*)nswindow.contentView;
-        VALIDATE_VULKAN_RESULT(vkCreateMacOSSurfaceMVK(instance, &surfaceCreateInfo, nullptr, surface));
-    }
+    NSWindow* window = (NSWindow*)windowHandle;
+	VkMacOSSurfaceCreateInfoMVK surfaceCreateInfo;
+	RenderToolsVulkan::ZeroStruct(surfaceCreateInfo, VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK);
+	surfaceCreateInfo.pView = (void*)window.contentView;
+	VALIDATE_VULKAN_RESULT(vkCreateMacOSSurfaceMVK(instance, &surfaceCreateInfo, nullptr, surface));
 }
 
 #endif

Source/Engine/GraphicsDevice/Vulkan/Mac/MacVulkanPlatform.h

@@ -11,8 +11,6 @@
 // General/Validation Error:0 VK_ERROR_INITIALIZATION_FAILED: Could not create MTLCounterSampleBuffer for query pool of type VK_QUERY_TYPE_TIMESTAMP. Reverting to emulated behavior. (Error code 0): Cannot allocate sample buffer
 #define VULKAN_USE_QUERIES 0
 
-class GPUDeviceVulkan;
-
 /// <summary>
 /// The implementation for the Vulkan API support for Mac platform.
 /// </summary>
@@ -20,7 +18,7 @@ class MacVulkanPlatform : public VulkanPlatformBase
 {
 public:
 	static void GetInstanceExtensions(Array<const char*>& extensions, Array<const char*>& layers);
-	static void CreateSurface(Window* window, GPUDeviceVulkan* device, VkInstance instance, VkSurfaceKHR* outSurface);
+	static void CreateSurface(void* windowHandle, VkInstance instance, VkSurfaceKHR* outSurface);
 };
 
 typedef MacVulkanPlatform VulkanPlatform;

Source/Engine/GraphicsDevice/Vulkan/Win32/Win32VulkanPlatform.cpp

@@ -6,7 +6,6 @@
 
 #include "../RenderToolsVulkan.h"
 #include "Engine/Graphics/GPUDevice.h"
-#include "Engine/Platform/Window.h"
 
 void Win32VulkanPlatform::GetInstanceExtensions(Array<const char*>& extensions, Array<const char*>& layers)
 {
@@ -14,9 +13,8 @@ void Win32VulkanPlatform::GetInstanceExtensions(Array<const char*>& extensions,
     extensions.Add(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
 }
 
-void Win32VulkanPlatform::CreateSurface(Window* window, GPUDeviceVulkan* device, VkInstance instance, VkSurfaceKHR* surface)
+void Win32VulkanPlatform::CreateSurface(void* windowHandle, VkInstance instance, VkSurfaceKHR* surface)
 {
-    void* windowHandle = window->GetNativePtr();
     VkWin32SurfaceCreateInfoKHR surfaceCreateInfo;
     RenderToolsVulkan::ZeroStruct(surfaceCreateInfo, VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR);
     surfaceCreateInfo.hinstance = GetModuleHandle(nullptr);

Source/Engine/GraphicsDevice/Vulkan/Win32/Win32VulkanPlatform.h

@@ -10,8 +10,6 @@
 #define VULKAN_USE_PLATFORM_WIN32_KHX 1
 #define VULKAN_USE_CREATE_WIN32_SURFACE 1
 
-class GPUDeviceVulkan;
-
 /// <summary>
 /// The implementation for the Vulkan API support for Win32 platform.
 /// </summary>
@@ -19,7 +17,7 @@ class Win32VulkanPlatform : public VulkanPlatformBase
 {
 public:
     static void GetInstanceExtensions(Array<const char*>& extensions, Array<const char*>& layers);
-    static void CreateSurface(Window* window, GPUDeviceVulkan* device, VkInstance instance, VkSurfaceKHR* surface);
+    static void CreateSurface(void* windowHandle, VkInstance instance, VkSurfaceKHR* surface);
 };
 
 typedef Win32VulkanPlatform VulkanPlatform;

Source/Engine/GraphicsDevice/Vulkan/iOS/iOSVulkanPlatform.cpp

@@ -5,7 +5,6 @@
 #include "iOSVulkanPlatform.h"
 #include "../RenderToolsVulkan.h"
 #include "Engine/Core/Delegate.h"
-#include "Engine/Platform/Window.h"
 #include <UIKit/UIKit.h>
 
 void iOSVulkanPlatform::GetInstanceExtensions(Array<const char*>& extensions, Array<const char*>& layers)
@@ -14,9 +13,8 @@ void iOSVulkanPlatform::GetInstanceExtensions(Array<const char*>& extensions, Ar
 	extensions.Add(VK_MVK_IOS_SURFACE_EXTENSION_NAME);
 }
 
-void iOSVulkanPlatform::CreateSurface(Window* window, GPUDeviceVulkan* device, VkInstance instance, VkSurfaceKHR* surface)
+void iOSVulkanPlatform::CreateSurface(void* windowHandle, VkInstance instance, VkSurfaceKHR* surface)
 {
-    void* windowHandle = window->GetNativePtr();
 	// Create surface on a main UI Thread
 	Function<void()> func = [&windowHandle, &instance, &surface]()
 	{

Source/Engine/GraphicsDevice/Vulkan/iOS/iOSVulkanPlatform.h

@@ -11,8 +11,6 @@
 // General/Validation Error:0 VK_ERROR_INITIALIZATION_FAILED: Could not create MTLCounterSampleBuffer for query pool of type VK_QUERY_TYPE_TIMESTAMP. Reverting to emulated behavior. (Error code 0): Cannot allocate sample buffer
 #define VULKAN_USE_QUERIES 0
 
-class GPUDeviceVulkan;
-
 /// <summary>
 /// The implementation for the Vulkan API support for iOS platform.
 /// </summary>
@@ -20,7 +18,7 @@ class iOSVulkanPlatform : public VulkanPlatformBase
 {
 public:
 	static void GetInstanceExtensions(Array<const char*>& extensions, Array<const char*>& layers);
-	static void CreateSurface(Window* window, GPUDeviceVulkan* device, VkInstance instance, VkSurfaceKHR* outSurface);
+	static void CreateSurface(void* windowHandle, VkInstance instance, VkSurfaceKHR* outSurface);
 };
 
 typedef iOSVulkanPlatform VulkanPlatform;

Source/Engine/Input/Input.cpp

@@ -79,7 +79,6 @@ Delegate<const Float2&, MouseButton> Input::MouseUp;
 Delegate<const Float2&, MouseButton> Input::MouseDoubleClick;
 Delegate<const Float2&, float> Input::MouseWheel;
 Delegate<const Float2&> Input::MouseMove;
-Delegate<const Float2&> Input::MouseMoveRelative;
 Action Input::MouseLeave;
 Delegate<const Float2&, int32> Input::TouchDown;
 Delegate<const Float2&, int32> Input::TouchMove;
@@ -216,14 +215,6 @@ void Mouse::OnMouseMove(const Float2& position, Window* target)
     e.MouseData.Position = position;
 }
 
-void Mouse::OnMouseMoveRelative(const Float2& positionRelative, Window* target)
-{
-    Event& e = _queue.AddOne();
-    e.Type = EventType::MouseMoveRelative;
-    e.Target = target;
-    e.MouseMovementData.PositionRelative = positionRelative;
-}
-
 void Mouse::OnMouseLeave(Window* target)
 {
     PROFILE_MEM(Input);
@@ -291,11 +282,6 @@ bool Mouse::Update(EventQueue& queue)
             _state.MousePosition = e.MouseData.Position;
             break;
         }
-        case EventType::MouseMoveRelative:
-        {
-            _state.MousePosition += e.MouseMovementData.PositionRelative;
-            break;
-        }
         case EventType::MouseLeave:
         {
             break;
@@ -936,10 +922,11 @@ void InputService::Update()
     WindowsManager::WindowsLocker.Unlock();
 
     // Send input events for the focused window
+    WindowsManager::WindowsLocker.Lock();
     for (const auto& e : InputEvents)
     {
         auto window = e.Target ? e.Target : defaultWindow;
-        if (!window || window->IsClosed())
+        if (!window || !WindowsManager::Windows.Contains(window))
             continue;
         switch (e.Type)
         {
@@ -969,9 +956,6 @@ void InputService::Update()
         case InputDevice::EventType::MouseMove:
             window->OnMouseMove(window->ScreenToClient(e.MouseData.Position));
             break;
-        case InputDevice::EventType::MouseMoveRelative:
-            window->OnMouseMoveRelative(e.MouseMovementData.PositionRelative);
-            break;
         case InputDevice::EventType::MouseLeave:
             window->OnMouseLeave();
             break;
@@ -987,6 +971,7 @@ void InputService::Update()
             break;
         }
     }
+    WindowsManager::WindowsLocker.Unlock();
 
     // Skip if game has no focus to handle the input
     if (!Engine::HasGameViewportFocus())
@@ -1027,9 +1012,6 @@ void InputService::Update()
         case InputDevice::EventType::MouseMove:
             Input::MouseMove(e.MouseData.Position);
             break;
-        case InputDevice::EventType::MouseMoveRelative:
-            Input::MouseMoveRelative(e.MouseMovementData.PositionRelative);
-            break;
         case InputDevice::EventType::MouseLeave:
             Input::MouseLeave();
             break;
@@ -1243,7 +1225,6 @@ void InputService::Update()
         }
     }
 
-#if !PLATFORM_SDL
     // Lock mouse if need to
     const auto lockMode = Screen::GetCursorLock();
     if (lockMode == CursorLockMode::Locked)
@@ -1252,7 +1233,6 @@ void InputService::Update()
                            Screen::ScreenToGameViewport(Float2::Zero);
         Input::SetMousePosition(pos);
     }
-#endif
 
     // Send events for the active actions and axes (send events only in play mode)
     if (!Time::GetGamePaused())

Source/Engine/Input/Input.h

@@ -108,11 +108,6 @@ public:
     /// </summary>
     API_EVENT() static Delegate<const Float2&> MouseMove;
 
-    /// <summary>
-    /// Event fired when mouse moves while in relative mode.
-    /// </summary>
-    API_EVENT() static Delegate<const Float2&> MouseMoveRelative;
-
     /// <summary>
     /// Event fired when mouse leaves window.
     /// </summary>

Source/Engine/Input/InputDevice.h

@@ -25,7 +25,6 @@ public:
         MouseDoubleClick,
         MouseWheel,
         MouseMove,
-        MouseMoveRelative,
         MouseLeave,
         TouchDown,
         TouchMove,
@@ -55,11 +54,6 @@ public:
                 Float2 Position;
             } MouseData;
 
-            struct
-            {
-                Float2 PositionRelative;
-            } MouseMovementData;
-
             struct
             {
                 float WheelDelta;

Source/Engine/Input/Mouse.h

@@ -46,14 +46,12 @@ public:
 protected:
     State _state;
     State _prevState;
-    bool _relativeMode;
 
     explicit Mouse()
         : InputDevice(SpawnParams(Guid::New(), TypeInitializer), TEXT("Mouse"))
     {
         _state.Clear();
         _prevState.Clear();
-        _relativeMode = false;
     }
 
 public:
@@ -116,16 +114,6 @@ public:
         return !_state.MouseButtons[static_cast<int32>(button)] && _prevState.MouseButtons[static_cast<int32>(button)];
     }
 
-    /// <summary>
-    /// Gets the current state of mouse relative mode. 
-    /// </summary>
-    /// <param name="window">The window to check against, or null to check for any window.</param>
-    /// <returns>True if mouse is in relative mode, otherwise false.</returns>
-    API_FUNCTION() virtual bool IsRelative(Window* window = nullptr) const
-    {
-        return _relativeMode;
-    }
-
 public:
     /// <summary>
     /// Sets the mouse position.
@@ -133,17 +121,6 @@ public:
     /// <param name="newPosition">The new position.</param>
     virtual void SetMousePosition(const Float2& newPosition) = 0;
 
-    /// <summary>
-    /// Sets the mouse relative mode state. While enabled, the mouse movement tracking becomes more accurate.
-    /// The cursor will be hidden while in relative mode.
-    /// </summary>
-    /// <param name="relativeMode">The new relative mode state.</param>
-    /// <param name="window">The window.</param>
-    virtual void SetRelativeMode(bool relativeMode, Window* window)
-    {
-        _relativeMode = relativeMode;
-    }
-
     /// <summary>
     /// Called when mouse cursor gets moved by the application. Invalidates the previous cached mouse position to prevent mouse jitter when locking the cursor programmatically.
     /// </summary>
@@ -181,13 +158,6 @@ public:
     /// <param name="target">The target window to receive this event, otherwise input system will pick the window automatically.</param>
     void OnMouseMove(const Float2& position, Window* target = nullptr);
 
-    /// <summary>
-    /// Called when mouse moves in relative mode.
-    /// </summary>
-    /// <param name="positionRelative">The mouse position change.</param>
-    /// <param name="target">The target window to receive this event, otherwise input system will pick the window automatically.</param>
-    void OnMouseMoveRelative(const Float2& positionRelative, Window* target = nullptr);
-
     /// <summary>
     /// Called when mouse leaves the input source area.
     /// </summary>

Source/Engine/Level/Actors/AnimatedModel.cpp

@@ -554,10 +554,11 @@ void AnimatedModel::StopSlotAnimation(const StringView& slotName, Animation* ani
 {
     for (auto& slot : GraphInstance.Slots)
     {
-        if (slot.Animation == anim && slot.Name == slotName)
+        if ((slot.Animation == anim || anim == nullptr) && slot.Name == slotName)
         {
             //slot.Animation = nullptr; // TODO: make an immediate version of this method and set the animation to nullptr.
-            slot.Reset = true;
+            if (slot.Animation != nullptr)
+                slot.Reset = true;
             break;
         }
     }
@@ -573,7 +574,7 @@ void AnimatedModel::PauseSlotAnimation(const StringView& slotName, Animation* an
 {
     for (auto& slot : GraphInstance.Slots)
     {
-        if (slot.Animation == anim && slot.Name == slotName)
+        if ((slot.Animation == anim || anim == nullptr) && slot.Name == slotName)
         {
             slot.Pause = true;
             break;
@@ -595,7 +596,7 @@ bool AnimatedModel::IsPlayingSlotAnimation(const StringView& slotName, Animation
 {
     for (auto& slot : GraphInstance.Slots)
     {
-        if (slot.Animation == anim && slot.Name == slotName && !slot.Pause)
+        if ((slot.Animation == anim || anim == nullptr) && slot.Name == slotName && !slot.Pause)
             return true;
     }
     return false;

Source/Engine/Level/Actors/AnimatedModel.h

@@ -412,8 +412,8 @@ public:
     /// Stops the animation playback on the slot in Anim Graph.
     /// </summary>
     /// <param name="slotName">The name of the slot.</param>
-    /// <param name="anim">The animation to stop.</param>
-    API_FUNCTION() void StopSlotAnimation(const StringView& slotName, Animation* anim);
+    /// <param name="anim">The animation to check. Null to use slot name only.</param>
+    API_FUNCTION() void StopSlotAnimation(const StringView& slotName, Animation* anim = nullptr);
 
     /// <summary>
     /// Pauses all the animations playback on the all slots in Anim Graph.
@@ -424,8 +424,8 @@ public:
     /// Pauses the animation playback on the slot in Anim Graph.
     /// </summary>
     /// <param name="slotName">The name of the slot.</param>
-    /// <param name="anim">The animation to pause.</param>
-    API_FUNCTION() void PauseSlotAnimation(const StringView& slotName, Animation* anim);
+    /// <param name="anim">The animation to check. Null to use slot name only.</param>
+    API_FUNCTION() void PauseSlotAnimation(const StringView& slotName, Animation* anim = nullptr);
 
     /// <summary>
     /// Checks if any  animation playback is active on any  slot in Anim Graph (not paused).
@@ -436,8 +436,8 @@ public:
     /// Checks if the animation playback is active on the slot in Anim Graph (not paused).
     /// </summary>
     /// <param name="slotName">The name of the slot.</param>
-    /// <param name="anim">The animation to check.</param>
-    API_FUNCTION() bool IsPlayingSlotAnimation(const StringView& slotName, Animation* anim);
+    /// <param name="anim">The animation to check. Null to use slot name only.</param>
+    API_FUNCTION() bool IsPlayingSlotAnimation(const StringView& slotName, Animation* anim = nullptr);
 
 private:
     void ApplyRootMotion(const Transform& rootMotionDelta);

Source/Engine/Main/MainUtil.h

@@ -16,7 +16,7 @@ const Char* GetCommandLine(int argc, char* argv[])
     const Char* cmdLine;
     if (length != 0)
     {
-        Char* str = (Char*)malloc(length * sizeof(Char));
+        Char* str = (Char*)malloc((length + 1) * sizeof(Char));
         cmdLine = str;
         for (int i = 1; i < argc; i++)
         {

Source/Engine/Networking/NetworkReplicationHierarchy.h

@@ -100,6 +100,35 @@ API_STRUCT(NoDefault, Namespace="FlaxEngine.Networking") struct FLAXENGINE_API N
         return Word0 + Word1 != 0;
     }
 
+    NetworkClientsMask operator&(const NetworkClientsMask& other) const
+    {
+        return { Word0 & other.Word0, Word1 & other.Word1 };
+    }
+
+    NetworkClientsMask operator|(const NetworkClientsMask& other) const
+    {
+        return { Word0 | other.Word0, Word1 | other.Word1 };
+    }
+
+    NetworkClientsMask operator~() const
+    {
+        return { ~Word0, ~Word1 };
+    }
+
+    NetworkClientsMask& operator|=(const NetworkClientsMask& other)
+    {
+        Word0 |= other.Word0;
+        Word1 |= other.Word1;
+        return *this;
+    }
+
+    NetworkClientsMask& operator&=(const NetworkClientsMask& other)
+    {
+        Word0 &= other.Word0;
+        Word1 &= other.Word1;
+        return *this;
+    }
+
     bool operator==(const NetworkClientsMask& other) const
     {
         return Word0 == other.Word0 && Word1 == other.Word1;

Source/Engine/Networking/NetworkReplicator.cpp

@@ -116,17 +116,6 @@ PACK_STRUCT(struct NetworkMessageObjectRpc
 
 struct NetworkReplicatedObject
 {
-    ScriptingObjectReference<ScriptingObject> Object;
-    Guid ObjectId;
-    Guid ParentId;
-    uint32 OwnerClientId;
-    uint32 LastOwnerFrame = 0;
-    NetworkObjectRole Role;
-    uint8 Spawned : 1;
-    uint8 Synced : 1;
-    DataContainer<uint32> TargetClientIds;
-    INetworkObject* AsNetworkObject;
-
     struct
     {
         NetworkClientsMask Mask;
@@ -139,6 +128,17 @@ struct NetworkReplicatedObject
         }
     } RepCache;
 
+    ScriptingObjectReference<ScriptingObject> Object;
+    Guid ObjectId;
+    Guid ParentId;
+    DataContainer<uint32> TargetClientIds;
+    INetworkObject* AsNetworkObject;
+    uint32 OwnerClientId;
+    uint32 LastOwnerFrame = 0;
+    NetworkObjectRole Role;
+    uint8 Spawned : 1;
+    uint8 Synced : 1;
+
     NetworkReplicatedObject()
     {
         Spawned = 0;
@@ -152,12 +152,12 @@ struct NetworkReplicatedObject
 
     bool operator==(const NetworkReplicatedObject& other) const
     {
-        return Object == other.Object;
+        return ObjectId == other.ObjectId;
     }
 
     bool operator==(const ScriptingObject* other) const
     {
-        return Object == other;
+        return other && ObjectId == other->GetID();
     }
 
     bool operator==(const Guid& other) const
@@ -176,6 +176,11 @@ inline uint32 GetHash(const NetworkReplicatedObject& key)
     return GetHash(key.ObjectId);
 }
 
+inline uint32 GetHash(const ScriptingObject* key)
+{
+    return key ? GetHash(key->GetID()) : 0;
+}
+
 struct Serializer
 {
     NetworkReplicator::SerializeFunc Methods[2];
@@ -698,14 +703,11 @@ void SendReplication(ScriptingObject* obj, NetworkClientsMask targetClients)
         return;
     auto& item = it->Item;
     const bool isClient = NetworkManager::IsClient();
+    const NetworkClientsMask fullTargetClients = targetClients;
 
-    // Skip serialization of objects that none will receive
-    if (!isClient)
-    {
-        BuildCachedTargets(item, targetClients);
-        if (CachedTargets.Count() == 0)
-            return;
-    }
+    // If server has no recipients, skip early.
+    if (!isClient && !targetClients)
+        return;
 
     if (item.AsNetworkObject)
         item.AsNetworkObject->OnNetworkSerialize();
@@ -728,18 +730,30 @@ void SendReplication(ScriptingObject* obj, NetworkClientsMask targetClients)
 
 #if USE_NETWORK_REPLICATOR_CACHE
     // Process replication cache to skip sending object data if it didn't change
-    if (item.RepCache.Data.Length() == size &&
-        item.RepCache.Mask == targetClients &&
-        Platform::MemoryCompare(item.RepCache.Data.Get(), stream->GetBuffer(), size) == 0)
+    if (item.RepCache.Data.Length() == size && Platform::MemoryCompare(item.RepCache.Data.Get(), stream->GetBuffer(), size) == 0)
     {
-        return;
+        // Check if only newly joined clients are missing this data to avoid resending it to everyone
+        NetworkClientsMask missingClients = targetClients & ~item.RepCache.Mask;
+
+        // If data is the same and only the client set changed, replicate to missing clients only
+        if (!missingClients)
+            return;
+        targetClients = missingClients;
     }
-    item.RepCache.Mask = targetClients;
+    item.RepCache.Mask = fullTargetClients;
     item.RepCache.Data.Copy(stream->GetBuffer(), size);
 #endif
     // TODO: use Unreliable for dynamic objects that are replicated every frame? (eg. player state)
     constexpr NetworkChannelType repChannel = NetworkChannelType::Reliable;
 
+    // Skip serialization of objects that none will receive
+    if (!isClient)
+    {
+        BuildCachedTargets(item, targetClients);
+        if (CachedTargets.Count() == 0)
+            return;
+    }
+
     // Send object to clients
     NetworkMessageObjectReplicate msgData;
     msgData.OwnerFrame = NetworkManager::Frame;
@@ -1530,7 +1544,21 @@ void NetworkReplicator::DespawnObject(ScriptingObject* obj)
     // Register for despawning (batched during update)
     auto& despawn = DespawnQueue.AddOne();
     despawn.Id = obj->GetID();
-    despawn.Targets = item.TargetClientIds;
+    if (item.TargetClientIds.IsValid())
+    {
+        despawn.Targets = item.TargetClientIds;
+    }
+    else
+    {
+        // Snapshot current recipients to avoid sending despawn to clients that connect later (and never got the spawn)
+        Array<uint32, InlinedAllocation<8>> clientIds;
+        for (const NetworkClient* client : NetworkManager::Clients)
+        {
+            if (client->State == NetworkConnectionState::Connected && client->ClientId != item.OwnerClientId)
+                clientIds.Add(client->ClientId);
+        }
+        despawn.Targets.Copy(clientIds);
+    }
 
     // Prevent spawning
     for (int32 i = 0; i < SpawnQueue.Count(); i++)
@@ -1823,6 +1851,31 @@ void NetworkInternal::NetworkReplicatorClientConnected(NetworkClient* client)
 {
     ScopeLock lock(ObjectsLock);
     NewClients.Add(client);
+
+    // Ensure cached replication acknowledges the new client without resending to others.
+    // Clear the new client's bit in RepCache and schedule a near-term replication.
+    const int32 clientIndex = NetworkManager::Clients.Find(client);
+    if (clientIndex != -1)
+    {
+        const uint64 bitMask = 1ull << (uint64)(clientIndex % 64);
+        const int32 wordIndex = clientIndex / 64;
+        for (auto it = Objects.Begin(); it.IsNotEnd(); ++it)
+        {
+            auto& item = it->Item;
+            ScriptingObject* obj = item.Object.Get();
+            if (!obj || !item.Spawned || item.Role != NetworkObjectRole::OwnedAuthoritative)
+                continue;
+
+            // Mark this client as missing cached data
+            uint64* word = wordIndex == 0 ? &item.RepCache.Mask.Word0 : &item.RepCache.Mask.Word1;
+            *word &= ~bitMask;
+
+            // Force next replication tick for this object so the new client gets data promptly
+            if (Hierarchy)
+                Hierarchy->DirtyObject(obj);
+        }
+    }
+
     ASSERT(sizeof(NetworkClientsMask) * 8 >= (uint32)NetworkManager::Clients.Count()); // Ensure that clients mask can hold all of clients
 }
 
@@ -2275,7 +2328,9 @@ void NetworkInternal::OnNetworkMessageObjectDespawn(NetworkEvent& event, Network
     }
     else
     {
-        NETWORK_REPLICATOR_LOG(Error, "[NetworkReplicator] Failed to despawn object {}", objectId);
+        // If this client never had the object (eg. it was targeted to other clients only), drop the message quietly
+        DespawnedObjects.Add(objectId);
+        NETWORK_REPLICATOR_LOG(Warning, "[NetworkReplicator] Failed to despawn object {}", objectId);
     }
 }
 

Source/Engine/Particles/Graph/CPU/ParticleEmitterGraph.CPU.Particles.cpp

@@ -482,9 +482,15 @@ void ParticleEmitterGraphCPUExecutor::ProcessGroupFunction(Box* box, Node* node,
     // Function Input
     case 1:
     {
+        // Skip when graph is too small (eg. preview) and fallback with default value from the function graph
+        if (context.GraphStack.Count() < 2)
+        {
+            value = tryGetValue(node->TryGetBox(1), Value::Zero);
+            break;
+        }
+
         // Find the function call
         Node* functionCallNode = nullptr;
-        ASSERT(context.GraphStack.Count() >= 2);
         ParticleEmitterGraphCPU* graph;
         for (int32 i = context.CallStackSize - 1; i >= 0; i--)
         {

Source/Engine/Platform/Android/AndroidFileSystem.cpp

@@ -422,24 +422,8 @@ bool AndroidFileSystem::getFilesFromDirectoryTop(Array<String>& results, const c
         if (S_ISREG(statEntry.st_mode) != 0)
         {
             // Validate with filter
-            const int32 fullPathLength = StringUtils::Length(fullPath);
-            const int32 searchPatternLength = StringUtils::Length(searchPattern);
-            if (searchPatternLength == 0 || StringUtils::Compare(searchPattern, "*") == 0)
-            {
-                // All files
-            }
-            else if (searchPattern[0] == '*' && searchPatternLength < fullPathLength && StringUtils::Compare(fullPath + fullPathLength - searchPatternLength + 1, searchPattern + 1) == 0)
-            {
-                // Path ending
-            }
-            else
-            {
-                // TODO: implement all cases in a generic way
-                continue;
-            }
-
-            // Add file
-            results.Add(String(fullPath));
+            if (FileSystem::PathFilterHelper(fullPath, searchPattern))
+                results.Add(String(fullPath));
         }
     }
 

Source/Engine/Platform/Base/Enums.h

@@ -1,251 +0,0 @@
-// Copyright (c) Wojciech Figat. All rights reserved.
-
-#pragma once
-
-#include "Engine/Core/Config.h"
-
-/// <summary>
-/// Window closing reasons.
-/// </summary>
-API_ENUM() enum class ClosingReason
-{
-    /// <summary>
-    /// The unknown.
-    /// </summary>
-    Unknown = 0,
-
-    /// <summary>
-    /// The user.
-    /// </summary>
-    User,
-
-    /// <summary>
-    /// The engine exit.
-    /// </summary>
-    EngineExit,
-
-    /// <summary>
-    /// The close event.
-    /// </summary>
-    CloseEvent,
-};
-
-/// <summary>
-/// Types of default cursors.
-/// </summary>
-API_ENUM() enum class CursorType
-{
-    /// <summary>
-    /// The default.
-    /// </summary>
-    Default = 0,
-
-    /// <summary>
-    /// The cross.
-    /// </summary>
-    Cross,
-
-    /// <summary>
-    /// The hand.
-    /// </summary>
-    Hand,
-
-    /// <summary>
-    /// The help icon
-    /// </summary>
-    Help,
-
-    /// <summary>
-    /// The I beam.
-    /// </summary>
-    IBeam,
-
-    /// <summary>
-    /// The blocking image.
-    /// </summary>
-    No,
-
-    /// <summary>
-    /// The wait.
-    /// </summary>
-    Wait,
-
-    /// <summary>
-    /// The size all sides.
-    /// </summary>
-    SizeAll,
-
-    /// <summary>
-    /// The size NE-SW.
-    /// </summary>
-    SizeNESW,
-
-    /// <summary>
-    /// The size NS.
-    /// </summary>
-    SizeNS,
-
-    /// <summary>
-    /// The size NW-SE.
-    /// </summary>
-    SizeNWSE,
-
-    /// <summary>
-    /// The size WE.
-    /// </summary>
-    SizeWE,
-
-    /// <summary>
-    /// The cursor is hidden.
-    /// </summary>
-    Hidden,
-
-    MAX
-};
-
-/// <summary>
-/// Data drag and drop effects.
-/// </summary>
-API_ENUM() enum class DragDropEffect
-{
-    /// <summary>
-    /// The none.
-    /// </summary>
-    None = 0,
-
-    /// <summary>
-    /// The copy.
-    /// </summary>
-    Copy,
-
-    /// <summary>
-    /// The move.
-    /// </summary>
-    Move,
-
-    /// <summary>
-    /// The link.
-    /// </summary>
-    Link,
-};
-
-/// <summary>
-/// Window hit test codes. Note: they are 1:1 mapping for Win32 values.
-/// </summary>
-API_ENUM() enum class WindowHitCodes
-{
-    /// <summary>
-    /// The transparent area.
-    /// </summary>
-    Transparent = -1,
-
-    /// <summary>
-    /// The no hit.
-    /// </summary>
-    NoWhere = 0,
-
-    /// <summary>
-    /// The client area.
-    /// </summary>
-    Client = 1,
-
-    /// <summary>
-    /// The caption area.
-    /// </summary>
-    Caption = 2,
-
-    /// <summary>
-    /// The system menu.
-    /// </summary>
-    SystemMenu = 3,
-
-    /// <summary>
-    /// The grow box
-    /// </summary>
-    GrowBox = 4,
-
-    /// <summary>
-    /// The menu.
-    /// </summary>
-    Menu = 5,
-
-    /// <summary>
-    /// The horizontal scroll.
-    /// </summary>
-    HScroll = 6,
-
-    /// <summary>
-    /// The vertical scroll.
-    /// </summary>
-    VScroll = 7,
-
-    /// <summary>
-    /// The minimize button.
-    /// </summary>
-    MinButton = 8,
-
-    /// <summary>
-    /// The maximize button.
-    /// </summary>
-    MaxButton = 9,
-
-    /// <summary>
-    /// The left side;
-    /// </summary>
-    Left = 10,
-
-    /// <summary>
-    /// The right side.
-    /// </summary>
-    Right = 11,
-
-    /// <summary>
-    /// The top side.
-    /// </summary>
-    Top = 12,
-
-    /// <summary>
-    /// The top left corner.
-    /// </summary>
-    TopLeft = 13,
-
-    /// <summary>
-    /// The top right corner.
-    /// </summary>
-    TopRight = 14,
-
-    /// <summary>
-    /// The bottom side.
-    /// </summary>
-    Bottom = 15,
-
-    /// <summary>
-    /// The bottom left corner.
-    /// </summary>
-    BottomLeft = 16,
-
-    /// <summary>
-    /// The bottom right corner.
-    /// </summary>
-    BottomRight = 17,
-
-    /// <summary>
-    /// The border.
-    /// </summary>
-    Border = 18,
-
-    /// <summary>
-    /// The object.
-    /// </summary>
-    Object = 19,
-
-    /// <summary>
-    /// The close button.
-    /// </summary>
-    Close = 20,
-
-    /// <summary>
-    /// The help button.
-    /// </summary>
-    Help = 21,
-};

Source/Engine/Platform/Base/FileSystemBase.cpp

@@ -7,6 +7,7 @@
 #include "Engine/Core/Types/StringView.h"
 #include "Engine/Core/Collections/Array.h"
 #include "Engine/Core/Math/Math.h"
+#include "Engine/Core/Log.h"
 #include "Engine/Engine/Globals.h"
 
 bool FileSystemBase::ShowOpenFileDialog(Window* parentWindow, const StringView& initialDirectory, const StringView& filter, bool multiSelect, const StringView& title, Array<String, HeapAllocation>& filenames)
@@ -313,3 +314,39 @@ bool FileSystemBase::DirectoryCopyHelper(const String& dst, const String& src, b
 
     return false;
 }
+
+bool FileSystemBase::PathFilterHelper(const char* path, const char* searchPattern)
+{
+    // Validate with filter
+    const int32 pathLength = StringUtils::Length(path);
+    const int32 searchPatternLength = StringUtils::Length(searchPattern);
+    if (searchPatternLength == 0 ||
+        StringUtils::Compare(searchPattern, "*") == 0 ||
+        StringUtils::Compare(searchPattern, "*.*") == 0)
+    {
+        // All files
+        return true;
+    }
+    else if (searchPattern[0] == '*' && StringUtils::Find(searchPattern + 1, "*") == nullptr)
+    {
+        // Path ending
+        return searchPatternLength < pathLength && StringUtils::Compare(path + pathLength - searchPatternLength + 1, searchPattern + 1, searchPatternLength - 1) == 0;
+    }
+    else if (searchPattern[0] == '*' && searchPatternLength > 2 && searchPattern[searchPatternLength - 1] == '*')
+    {
+        // Contains pattern
+        bool match = false;
+        for (int32 i = 0; i < pathLength - searchPatternLength - 1; i++)
+        {
+            int32 len = Math::Min(searchPatternLength - 2, pathLength - i);
+            if (StringUtils::Compare(&path[i], &searchPattern[1], len) == 0)
+                return true;
+        }
+    }
+    else
+    {
+        // TODO: implement all cases in a generic way
+        LOG(Warning, "DirectoryGetFiles: Wildcard filter is not implemented ({})", String(searchPattern));
+    }
+    return false;
+}

Source/Engine/Platform/Base/FileSystemBase.h

@@ -284,6 +284,6 @@ public:
     /// <returns>Relative path</returns>
     static String ConvertAbsolutePathToRelative(const String& basePath, const String& path);
 
-private:
     static bool DirectoryCopyHelper(const String& dst, const String& src, bool withSubDirectories);
+    static bool PathFilterHelper(const char* path, const char* searchPattern);
 };