diff --git a/Content/Shaders/SSR.flax b/Content/Shaders/SSR.flax
index a422ce5c0..d7cfdca1a 100644
--- a/Content/Shaders/SSR.flax
+++ b/Content/Shaders/SSR.flax
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0317fb2ca888fee6d32c7754d6f83e2f1e58924725a8221c5131e974501168ac
-size 10912
+oid sha256:d3c3ceba0aa0b79f5619147a0ec8ac30d87c142322bd256dc235b7b4f890fc94
+size 11142
diff --git a/Source/Editor/Content/Import/ModelImportEntry.cs b/Source/Editor/Content/Import/ModelImportEntry.cs
index bbb384562..484efb1d9 100644
--- a/Source/Editor/Content/Import/ModelImportEntry.cs
+++ b/Source/Editor/Content/Import/ModelImportEntry.cs
@@ -12,13 +12,14 @@ namespace FlaxEngine.Tools
     {
         partial struct Options
         {
-            private bool ShowGeometry => Type == ModelTool.ModelType.Model || Type == ModelTool.ModelType.SkinnedModel;
-            private bool ShowModel => Type == ModelTool.ModelType.Model;
-            private bool ShowSkinnedModel => Type == ModelTool.ModelType.SkinnedModel;
-            private bool ShowAnimation => Type == ModelTool.ModelType.Animation;
+            private bool ShowGeometry => Type == ModelType.Model || Type == ModelType.SkinnedModel || Type == ModelType.Prefab;
+            private bool ShowModel => Type == ModelType.Model || Type == ModelType.Prefab;
+            private bool ShowSkinnedModel => Type == ModelType.SkinnedModel || Type == ModelType.Prefab;
+            private bool ShowAnimation => Type == ModelType.Animation || Type == ModelType.Prefab;
             private bool ShowSmoothingNormalsAngle => ShowGeometry && CalculateNormals;
             private bool ShowSmoothingTangentsAngle => ShowGeometry && CalculateTangents;
-            private bool ShowFramesRange => ShowAnimation && Duration == ModelTool.AnimationDuration.Custom;
+            private bool ShowFramesRange => ShowAnimation && Duration == AnimationDuration.Custom;
+            private bool ShowSplitting => Type != ModelType.Prefab;
         }
     }
 }
diff --git a/Source/Editor/Content/PreviewsCache.cpp b/Source/Editor/Content/PreviewsCache.cpp
index 2d62e8170..b0f3619a5 100644
--- a/Source/Editor/Content/PreviewsCache.cpp
+++ b/Source/Editor/Content/PreviewsCache.cpp
@@ -5,6 +5,7 @@
 #include "Engine/Graphics/GPUContext.h"
 #include "Engine/Threading/Threading.h"
 #include "Engine/Graphics/RenderTools.h"
+#include "Engine/Content/Content.h"
 #include "Engine/Content/Factories/BinaryAssetFactory.h"
 #include "Engine/ContentImporters/AssetsImportingManager.h"
 #include "Engine/Content/Upgraders/TextureAssetUpgrader.h"
@@ -92,15 +93,12 @@ SpriteHandle PreviewsCache::FindSlot(const Guid& id)
 {
     if (WaitForLoaded())
         return SpriteHandle::Invalid;
-
-    // Find entry
     int32 index;
     if (_assets.Find(id, index))
     {
         const String spriteName = StringUtils::ToString(index);
         return FindSprite(spriteName);
     }
-
     return SpriteHandle::Invalid;
 }
 
@@ -114,6 +112,17 @@ Asset::LoadResult PreviewsCache::load()
         return LoadResult::Failed;
     _assets.Set(previewsMetaChunk->Get<Guid>(), ASSETS_ICONS_PER_ATLAS);
 
+    // Verify if cached assets still exist (don't store thumbnails for removed files)
+    AssetInfo assetInfo;
+    for (Guid& id : _assets)
+    {
+        if (id.IsValid() && Content::GetAsset(id) == nullptr && !Content::GetAssetInfo(id, assetInfo))
+        {
+            // Free slot (no matter the texture contents)
+            id = Guid::Empty;
+        }
+    }
+
     // Setup atlas sprites array
     Sprite sprite;
     sprite.Area.Size = static_cast<float>(ASSET_ICON_SIZE) / ASSETS_ICONS_ATLAS_SIZE;
@@ -162,7 +171,7 @@ SpriteHandle PreviewsCache::OccupySlot(GPUTexture* source, const Guid& id)
     if (WaitForLoaded())
         return SpriteHandle::Invalid;
 
-    // Find free slot and for that asset
+    // Find this asset slot or use the first empty
     int32 index = _assets.Find(id);
     if (index == INVALID_INDEX)
         index = _assets.Find(Guid::Empty);
@@ -201,14 +210,12 @@ bool PreviewsCache::ReleaseSlot(const Guid& id)
 {
     bool result = false;
     ScopeLock lock(Locker);
-
     int32 index = _assets.Find(id);
     if (index != INVALID_INDEX)
     {
         _assets[index] = Guid::Empty;
         result = true;
     }
-
     return result;
 }
 
diff --git a/Source/Editor/Content/Proxy/ModelProxy.cs b/Source/Editor/Content/Proxy/ModelProxy.cs
index 0cf16850d..c3ac3b247 100644
--- a/Source/Editor/Content/Proxy/ModelProxy.cs
+++ b/Source/Editor/Content/Proxy/ModelProxy.cs
@@ -72,7 +72,10 @@ namespace FlaxEditor.Content
         {
             if (_preview == null)
             {
-                _preview = new ModelPreview(false);
+                _preview = new ModelPreview(false)
+                {
+                    ScaleToFit = false,
+                };
                 InitAssetPreview(_preview);
             }
 
@@ -91,6 +94,7 @@ namespace FlaxEditor.Content
             _preview.Model = (Model)request.Asset;
             _preview.Parent = guiRoot;
             _preview.SyncBackbufferSize();
+            _preview.ViewportCamera.SetArcBallView(_preview.Model.GetBox());
 
             _preview.Task.OnDraw();
         }
diff --git a/Source/Editor/Content/Proxy/SceneProxy.cs b/Source/Editor/Content/Proxy/SceneProxy.cs
index 004c2aed7..d959b524a 100644
--- a/Source/Editor/Content/Proxy/SceneProxy.cs
+++ b/Source/Editor/Content/Proxy/SceneProxy.cs
@@ -1,6 +1,7 @@
 // Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
 
 using System;
+using FlaxEditor.GUI.ContextMenu;
 using FlaxEditor.Windows;
 using FlaxEngine;
 
@@ -68,5 +69,15 @@ namespace FlaxEditor.Content
         {
             return new SceneItem(path, id);
         }
+
+        /// <inheritdoc />
+        public override void OnContentWindowContextMenu(ContextMenu menu, ContentItem item)
+        {
+            var id = ((SceneItem)item).ID;
+            if (Level.FindScene(id) == null)
+            {
+                menu.AddButton("Open (additive)", () => { Editor.Instance.Scene.OpenScene(id, true); });
+            }
+        }
     }
 }
diff --git a/Source/Editor/Content/Thumbnails/ThumbnailRequest.cs b/Source/Editor/Content/Thumbnails/ThumbnailRequest.cs
index 6e60602ff..40ad17720 100644
--- a/Source/Editor/Content/Thumbnails/ThumbnailRequest.cs
+++ b/Source/Editor/Content/Thumbnails/ThumbnailRequest.cs
@@ -35,6 +35,11 @@ namespace FlaxEditor.Content.Thumbnails
             /// The finalized state.
             /// </summary>
             Disposed,
+
+            /// <summary>
+            /// The request has failed (eg. asset cannot be loaded).
+            /// </summary>
+            Failed,
         };
 
         /// <summary>
@@ -78,6 +83,14 @@ namespace FlaxEditor.Content.Thumbnails
             Proxy = proxy;
         }
 
+        internal void Update()
+        {
+            if (State == States.Prepared && (!Asset || Asset.LastLoadFailed))
+            {
+                State = States.Failed;
+            }
+        }
+
         /// <summary>
         /// Prepares this request.
         /// </summary>
@@ -85,11 +98,8 @@ namespace FlaxEditor.Content.Thumbnails
         {
             if (State != States.Created)
                 throw new InvalidOperationException();
-
-            // Prepare
             Asset = FlaxEngine.Content.LoadAsync(Item.Path);
             Proxy.OnThumbnailDrawPrepare(this);
-
             State = States.Prepared;
         }
 
@@ -101,9 +111,7 @@ namespace FlaxEditor.Content.Thumbnails
         {
             if (State != States.Prepared)
                 throw new InvalidOperationException();
-
             Item.Thumbnail = icon;
-
             State = States.Rendered;
         }
 
diff --git a/Source/Editor/Content/Thumbnails/ThumbnailsModule.cs b/Source/Editor/Content/Thumbnails/ThumbnailsModule.cs
index 1282e4daa..b213cb798 100644
--- a/Source/Editor/Content/Thumbnails/ThumbnailsModule.cs
+++ b/Source/Editor/Content/Thumbnails/ThumbnailsModule.cs
@@ -21,15 +21,11 @@ namespace FlaxEditor.Content.Thumbnails
         /// </summary>
         public const float MinimumRequiredResourcesQuality = 0.8f;
 
-        // TODO: free atlas slots for deleted assets
-
         private readonly List<PreviewsCache> _cache = new List<PreviewsCache>(4);
         private readonly string _cacheFolder;
-
-        private DateTime _lastFlushTime;
-
         private readonly List<ThumbnailRequest> _requests = new List<ThumbnailRequest>(128);
         private readonly PreviewRoot _guiRoot = new PreviewRoot();
+        private DateTime _lastFlushTime;
         private RenderTask _task;
         private GPUTexture _output;
 
@@ -88,7 +84,6 @@ namespace FlaxEditor.Content.Thumbnails
                         }
                     }
 
-                    // Add request
                     AddRequest(assetItem, proxy);
                 }
             }
@@ -118,15 +113,15 @@ namespace FlaxEditor.Content.Thumbnails
                 for (int i = 0; i < _cache.Count; i++)
                 {
                     if (_cache[i].ReleaseSlot(assetItem.ID))
-                    {
                         break;
-                    }
                 }
             }
         }
 
         internal static bool HasMinimumQuality(TextureBase asset)
         {
+            if (asset.HasStreamingError)
+                return true; // Don't block thumbnails queue when texture fails to stream in (eg. unsupported format)
             var mipLevels = asset.MipLevels;
             var minMipLevels = Mathf.Min(mipLevels, 7);
             return asset.IsLoaded && asset.ResidentMipLevels >= Mathf.Max(minMipLevels, (int)(mipLevels * MinimumRequiredResourcesQuality));
@@ -198,13 +193,7 @@ namespace FlaxEditor.Content.Thumbnails
         /// <inheritdoc />
         void IContentItemOwner.OnItemDeleted(ContentItem item)
         {
-            if (item is AssetItem assetItem)
-            {
-                lock (_requests)
-                {
-                    RemoveRequest(assetItem);
-                }
-            }
+            DeletePreview(item);
         }
 
         /// <inheritdoc />
@@ -494,10 +483,7 @@ namespace FlaxEditor.Content.Thumbnails
         {
             // Wait some frames before start generating previews (late init feature)
             if (Time.TimeSinceStartup < 1.0f || HasAllAtlasesLoaded() == false)
-            {
-                // Back
                 return;
-            }
 
             lock (_requests)
             {
@@ -515,6 +501,7 @@ namespace FlaxEditor.Content.Thumbnails
                         var request = _requests[i];
                         try
                         {
+                            request.Update();
                             if (request.IsReady)
                             {
                                 isAnyReady = true;
@@ -523,6 +510,10 @@ namespace FlaxEditor.Content.Thumbnails
                             {
                                 request.Prepare();
                             }
+                            else if (request.State == ThumbnailRequest.States.Failed)
+                            {
+                                _requests.RemoveAt(i--);
+                            }
                         }
                         catch (Exception ex)
                         {
diff --git a/Source/Editor/Cooker/Platform/Android/AndroidPlatformTools.cpp b/Source/Editor/Cooker/Platform/Android/AndroidPlatformTools.cpp
index 995f19fce..88f993f20 100644
--- a/Source/Editor/Cooker/Platform/Android/AndroidPlatformTools.cpp
+++ b/Source/Editor/Cooker/Platform/Android/AndroidPlatformTools.cpp
@@ -169,6 +169,30 @@ bool AndroidPlatformTools::OnPostProcess(CookingData& data)
         permissions += String::Format(TEXT("\n    <uses-permission android:name=\"{0}\" />"), e.Item);
     }
 
+    // Setup default Android screen orientation
+    auto defaultOrienation = platformSettings->DefaultOrientation;
+    String orientation = String("fullSensor");
+    switch (defaultOrienation)
+    {
+    case AndroidPlatformSettings::ScreenOrientation::Portrait:
+        orientation = String("portrait");
+        break;
+    case AndroidPlatformSettings::ScreenOrientation::PortraitReverse:
+        orientation = String("reversePortrait");
+        break;
+    case AndroidPlatformSettings::ScreenOrientation::LandscapeRight:
+        orientation = String("landscape");
+        break;
+    case AndroidPlatformSettings::ScreenOrientation::LandscapeLeft:
+        orientation = String("reverseLandscape");
+        break;
+    case AndroidPlatformSettings::ScreenOrientation::AutoRotation:
+        orientation = String("fullSensor");
+        break;
+    default:
+        break;
+    }
+
     // Setup Android application attributes
     String attributes;
     if (data.Configuration != BuildConfiguration::Release)
@@ -223,6 +247,7 @@ bool AndroidPlatformTools::OnPostProcess(CookingData& data)
     EditorUtilities::ReplaceInFile(manifestPath, TEXT("${PackageName}"), packageName);
     EditorUtilities::ReplaceInFile(manifestPath, TEXT("${ProjectVersion}"), projectVersion);
     EditorUtilities::ReplaceInFile(manifestPath, TEXT("${AndroidPermissions}"), permissions);
+    EditorUtilities::ReplaceInFile(manifestPath, TEXT("${DefaultOrientation}"), orientation);
     EditorUtilities::ReplaceInFile(manifestPath, TEXT("${AndroidAttributes}"), attributes);
     const String stringsPath = data.OriginalOutputPath / TEXT("app/src/main/res/values/strings.xml");
     EditorUtilities::ReplaceInFile(stringsPath, TEXT("${ProjectName}"), gameSettings->ProductName);
diff --git a/Source/Editor/Cooker/Steps/CookAssetsStep.cpp b/Source/Editor/Cooker/Steps/CookAssetsStep.cpp
index 4d4ea5e07..8fd87bcfd 100644
--- a/Source/Editor/Cooker/Steps/CookAssetsStep.cpp
+++ b/Source/Editor/Cooker/Steps/CookAssetsStep.cpp
@@ -1270,7 +1270,7 @@ bool CookAssetsStep::Perform(CookingData& data)
     {
         Array<CookingData::AssetTypeStatistics> assetTypes;
         data.Stats.AssetStats.GetValues(assetTypes);
-        Sorting::QuickSort(assetTypes.Get(), assetTypes.Count());
+        Sorting::QuickSort(assetTypes);
 
         LOG(Info, "");
         LOG(Info, "Top assets types stats:");
diff --git a/Source/Editor/Cooker/Steps/DeployDataStep.cpp b/Source/Editor/Cooker/Steps/DeployDataStep.cpp
index c1179c77a..59ff0d744 100644
--- a/Source/Editor/Cooker/Steps/DeployDataStep.cpp
+++ b/Source/Editor/Cooker/Steps/DeployDataStep.cpp
@@ -48,21 +48,21 @@ bool DeployDataStep::Perform(CookingData& data)
     }
     if (buildSettings.SkipDotnetPackaging && data.Tools->UseSystemDotnet())
     {
-        // Use system-installed .Net Runtime
+        // Use system-installed .NET Runtime
         FileSystem::DeleteDirectory(dstDotnet);
     }
     else
     {
-        // Deploy .Net Runtime files
+        // Deploy .NET Runtime files
         FileSystem::CreateDirectory(dstDotnet);
         String srcDotnet = depsRoot / TEXT("Dotnet");
         if (FileSystem::DirectoryExists(srcDotnet))
         {
-            // Use prebuilt .Net installation for that platform
-            LOG(Info, "Using .Net Runtime {} at {}", data.Tools->GetName(), srcDotnet);
+            // Use prebuilt .NET installation for that platform
+            LOG(Info, "Using .NET Runtime {} at {}", data.Tools->GetName(), srcDotnet);
             if (EditorUtilities::CopyDirectoryIfNewer(dstDotnet, srcDotnet, true))
             {
-                data.Error(TEXT("Failed to copy .Net runtime data files."));
+                data.Error(TEXT("Failed to copy .NET runtime data files."));
                 return true;
             }
         }
@@ -85,7 +85,7 @@ bool DeployDataStep::Perform(CookingData& data)
             }
             if (canUseSystemDotnet && (aotMode == DotNetAOTModes::None || aotMode == DotNetAOTModes::ILC))
             {
-                // Ask Flax.Build to provide .Net SDK location for the current platform
+                // Ask Flax.Build to provide .NET SDK location for the current platform
                 String sdks;
                 bool failed = ScriptsBuilder::RunBuildTool(String::Format(TEXT("-log -logMessagesOnly -logFileWithConsole -logfile=SDKs.txt -printSDKs {}"), GAME_BUILD_DOTNET_VER), data.CacheDirectory);
                 failed |= File::ReadAllText(data.CacheDirectory / TEXT("SDKs.txt"), sdks);
@@ -101,7 +101,7 @@ bool DeployDataStep::Perform(CookingData& data)
                 }
                 if (failed || !FileSystem::DirectoryExists(srcDotnet))
                 {
-                    data.Error(TEXT("Failed to get .Net SDK location for a current platform."));
+                    data.Error(TEXT("Failed to get .NET SDK location for the current host platform."));
                     return true;
                 }
 
@@ -110,19 +110,25 @@ bool DeployDataStep::Perform(CookingData& data)
                 FileSystem::GetChildDirectories(versions, srcDotnet / TEXT("host/fxr"));
                 if (versions.Count() == 0)
                 {
-                    data.Error(TEXT("Failed to get .Net SDK location for a current platform."));
+                    data.Error(TEXT("Failed to find any .NET hostfxr versions for the current host platform."));
                     return true;
                 }
                 for (String& version : versions)
                 {
                     version = String(StringUtils::GetFileName(version));
-                    if (!version.StartsWith(TEXT("7.")))
+                    if (!version.StartsWith(TEXT("7.")) && !version.StartsWith(TEXT("8."))) // .NET 7 or .NET 8
                         version.Clear();
                 }
-                Sorting::QuickSort(versions.Get(), versions.Count());
+                Sorting::QuickSort(versions);
                 const String version = versions.Last();
+                if (version.IsEmpty())
+                {
+                    data.Error(TEXT("Failed to find supported .NET hostfxr version for the current host platform."));
+                    return true;
+                }
+
                 FileSystem::NormalizePath(srcDotnet);
-                LOG(Info, "Using .Net Runtime {} at {}", version, srcDotnet);
+                LOG(Info, "Using .NET Runtime {} at {}", version, srcDotnet);
 
                 // Check if previously deployed files are valid (eg. system-installed .NET was updated from version 7.0.3 to 7.0.5)
                 {
@@ -158,13 +164,13 @@ bool DeployDataStep::Perform(CookingData& data)
                 }
                 if (failed)
                 {
-                    data.Error(TEXT("Failed to copy .Net runtime data files."));
+                    data.Error(TEXT("Failed to copy .NET runtime data files."));
                     return true;
                 }
             }
             else
             {
-                // Ask Flax.Build to provide .Net Host Runtime location for the target platform
+                // Ask Flax.Build to provide .NET Host Runtime location for the target platform
                 String sdks;
                 const Char *platformName, *archName;
                 data.GetBuildPlatformName(platformName, archName);
@@ -180,11 +186,11 @@ bool DeployDataStep::Perform(CookingData& data)
                 }
                 if (failed || !FileSystem::DirectoryExists(srcDotnet))
                 {
-                    data.Error(TEXT("Failed to get .Net SDK location for a current platform."));
+                    data.Error(TEXT("Failed to get .NET SDK location for the current host platform."));
                     return true;
                 }
                 FileSystem::NormalizePath(srcDotnet);
-                LOG(Info, "Using .Net Runtime {} at {}", TEXT("Host"), srcDotnet);
+                LOG(Info, "Using .NET Runtime {} at {}", TEXT("Host"), srcDotnet);
 
                 // Deploy runtime files
                 const Char* corlibPrivateName = TEXT("System.Private.CoreLib.dll");
@@ -249,7 +255,7 @@ bool DeployDataStep::Perform(CookingData& data)
                     DEPLOY_NATIVE_FILE("libmonosgen-2.0.dylib");
                     DEPLOY_NATIVE_FILE("libSystem.IO.Compression.Native.dylib");
                     DEPLOY_NATIVE_FILE("libSystem.Native.dylib");
-                    DEPLOY_NATIVE_FILE("libSystem.Net.Security.Native.dylib");
+                    DEPLOY_NATIVE_FILE("libSystem.NET.Security.Native.dylib");
                     DEPLOY_NATIVE_FILE("libSystem.Security.Cryptography.Native.Apple.dylib");
                     break;
 #undef DEPLOY_NATIVE_FILE
@@ -257,7 +263,7 @@ bool DeployDataStep::Perform(CookingData& data)
                 }
                 if (failed)
                 {
-                    data.Error(TEXT("Failed to copy .Net runtime data files."));
+                    data.Error(TEXT("Failed to copy .NET runtime data files."));
                     return true;
                 }
             }
@@ -278,7 +284,7 @@ bool DeployDataStep::Perform(CookingData& data)
             }
             if (ScriptsBuilder::RunBuildTool(args))
             {
-                data.Error(TEXT("Failed to optimize .Net class library."));
+                data.Error(TEXT("Failed to optimize .NET class library."));
                 return true;
             }
         }
diff --git a/Source/Editor/CustomEditors/CustomEditor.cs b/Source/Editor/CustomEditors/CustomEditor.cs
index 9de330213..a519b1da1 100644
--- a/Source/Editor/CustomEditors/CustomEditor.cs
+++ b/Source/Editor/CustomEditors/CustomEditor.cs
@@ -7,9 +7,8 @@ using FlaxEditor.CustomEditors.GUI;
 using FlaxEditor.Scripting;
 using FlaxEngine;
 using FlaxEngine.GUI;
+using FlaxEngine.Json;
 using FlaxEngine.Utilities;
-using Newtonsoft.Json;
-using JsonSerializer = FlaxEngine.Json.JsonSerializer;
 
 namespace FlaxEditor.CustomEditors
 {
@@ -386,22 +385,22 @@ namespace FlaxEditor.CustomEditors
             LinkedLabel = label;
         }
 
-        private void RevertDiffToDefault(CustomEditor editor)
-        {
-            if (editor.ChildrenEditors.Count == 0)
-            {
-                // Skip if no change detected
-                if (!editor.Values.IsDefaultValueModified)
-                    return;
+        /// <summary>
+        /// If true, the value reverting to default/reference will be handled via iteration over children editors, instead of for a whole object at once.
+        /// </summary>
+        public virtual bool RevertValueWithChildren => ChildrenEditors.Count != 0;
 
-                editor.SetValueToDefault();
+        private void RevertDiffToDefault()
+        {
+            if (RevertValueWithChildren)
+            {
+                foreach (var child in ChildrenEditors)
+                    child.RevertDiffToDefault();
             }
             else
             {
-                for (int i = 0; i < editor.ChildrenEditors.Count; i++)
-                {
-                    RevertDiffToDefault(editor.ChildrenEditors[i]);
-                }
+                if (Values.IsDefaultValueModified)
+                    SetValueToDefault();
             }
         }
 
@@ -414,11 +413,6 @@ namespace FlaxEditor.CustomEditors
             {
                 if (!Values.IsDefaultValueModified)
                     return false;
-
-                // Skip array items (show diff only on a bottom level properties and fields)
-                if (ParentEditor is Editors.ArrayEditor)
-                    return false;
-
                 return true;
             }
         }
@@ -430,7 +424,7 @@ namespace FlaxEditor.CustomEditors
         {
             if (!Values.HasDefaultValue)
                 return;
-            RevertDiffToDefault(this);
+            RevertDiffToDefault();
         }
 
         /// <summary>
@@ -468,22 +462,17 @@ namespace FlaxEditor.CustomEditors
             }
         }
 
-        private void RevertDiffToReference(CustomEditor editor)
+        private void RevertDiffToReference()
         {
-            if (editor.ChildrenEditors.Count == 0)
+            if (RevertValueWithChildren)
             {
-                // Skip if no change detected
-                if (!editor.Values.IsReferenceValueModified)
-                    return;
-
-                editor.SetValueToReference();
+                foreach (var child in ChildrenEditors)
+                    child.RevertDiffToReference();
             }
             else
             {
-                for (int i = 0; i < editor.ChildrenEditors.Count; i++)
-                {
-                    RevertDiffToReference(editor.ChildrenEditors[i]);
-                }
+                if (Values.IsReferenceValueModified)
+                    SetValueToReference();
             }
         }
 
@@ -496,11 +485,6 @@ namespace FlaxEditor.CustomEditors
             {
                 if (!Values.IsReferenceValueModified)
                     return false;
-
-                // Skip array items (show diff only on a bottom level properties and fields)
-                if (ParentEditor is Editors.ArrayEditor)
-                    return false;
-
                 return true;
             }
         }
@@ -512,7 +496,7 @@ namespace FlaxEditor.CustomEditors
         {
             if (!Values.HasReferenceValue)
                 return;
-            RevertDiffToReference(this);
+            RevertDiffToReference();
         }
 
         /// <summary>
@@ -657,7 +641,7 @@ namespace FlaxEditor.CustomEditors
                 // Default
                 try
                 {
-                    obj = JsonConvert.DeserializeObject(text, TypeUtils.GetType(Values.Type), JsonSerializer.Settings);
+                    obj = Newtonsoft.Json.JsonConvert.DeserializeObject(text, TypeUtils.GetType(Values.Type), JsonSerializer.Settings);
                 }
                 catch
                 {
@@ -762,7 +746,7 @@ namespace FlaxEditor.CustomEditors
         /// </summary>
         public void SetValueToDefault()
         {
-            SetValue(Values.DefaultValue);
+            SetValueCloned(Values.DefaultValue);
         }
 
         /// <summary>
@@ -799,7 +783,19 @@ namespace FlaxEditor.CustomEditors
                 return;
             }
 
-            SetValue(Values.ReferenceValue);
+            SetValueCloned(Values.ReferenceValue);
+        }
+
+        private void SetValueCloned(object value)
+        {
+            // For objects (eg. arrays) we need to clone them to prevent editing default/reference value within editor
+            if (value != null && !value.GetType().IsValueType)
+            {
+                var json = JsonSerializer.Serialize(value);
+                value = JsonSerializer.Deserialize(json, value.GetType());
+            }
+
+            SetValue(value);
         }
 
         /// <summary>
@@ -811,7 +807,6 @@ namespace FlaxEditor.CustomEditors
         {
             if (_isSetBlocked)
                 return;
-
             if (OnDirty(this, value, token))
             {
                 _hasValueDirty = true;
diff --git a/Source/Editor/CustomEditors/Dedicated/ModelPrefabEditor.cs b/Source/Editor/CustomEditors/Dedicated/ModelPrefabEditor.cs
new file mode 100644
index 000000000..1e41fcc32
--- /dev/null
+++ b/Source/Editor/CustomEditors/Dedicated/ModelPrefabEditor.cs
@@ -0,0 +1,84 @@
+// Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
+
+using System;
+using System.IO;
+using FlaxEditor.Content;
+using FlaxEditor.CustomEditors.Editors;
+using FlaxEngine;
+using FlaxEngine.GUI;
+using FlaxEngine.Tools;
+
+namespace FlaxEditor.CustomEditors.Dedicated;
+
+/// <summary>
+/// The missing script editor.
+/// </summary>
+[CustomEditor(typeof(ModelPrefab)), DefaultEditor]
+public class ModelPrefabEditor : GenericEditor
+{
+    private Guid _prefabId;
+    private Button _reimportButton;
+    private string _importPath;
+
+    /// <inheritdoc />
+    public override void Initialize(LayoutElementsContainer layout)
+    {
+        base.Initialize(layout);
+
+        var modelPrefab = Values[0] as ModelPrefab;
+        if (modelPrefab == null)
+            return;
+        _prefabId = modelPrefab.PrefabID;
+        while (true)
+        {
+            if (_prefabId == Guid.Empty)
+            {
+                break;
+            }
+
+            var prefab = FlaxEngine.Content.Load<Prefab>(_prefabId);
+            if (prefab)
+            {
+                var prefabObjectId = modelPrefab.PrefabObjectID;
+                var prefabObject = prefab.GetDefaultInstance(ref prefabObjectId);
+                if (prefabObject.PrefabID == _prefabId)
+                    break;
+                _prefabId = prefabObject.PrefabID;
+            }
+        }
+
+        var button = layout.Button("Reimport", "Reimports the source asset as prefab.");
+        _reimportButton = button.Button;
+        _reimportButton.Clicked += OnReimport;
+    }
+
+    private void OnReimport()
+    {
+        var prefab = FlaxEngine.Content.Load<Prefab>(_prefabId);
+        var modelPrefab = (ModelPrefab)Values[0];
+        var importPath = modelPrefab.ImportPath;
+        var editor = Editor.Instance;
+        if (editor.ContentImporting.GetReimportPath("Model Prefab", ref importPath))
+            return;
+        var folder = editor.ContentDatabase.Find(Path.GetDirectoryName(prefab.Path)) as ContentFolder;
+        if (folder == null)
+            return;
+        var importOptions = modelPrefab.ImportOptions;
+        importOptions.Type = ModelTool.ModelType.Prefab;
+        _importPath = importPath;
+        _reimportButton.Enabled = false;
+        editor.ContentImporting.ImportFileEnd += OnImportFileEnd;
+        editor.ContentImporting.Import(importPath, folder, true, importOptions);
+    }
+
+    private void OnImportFileEnd(IFileEntryAction entry, bool failed)
+    {
+        if (entry.SourceUrl == _importPath)
+        {
+            // Restore button
+            _importPath = null;
+            _reimportButton.Enabled = true;
+            Editor.Instance.ContentImporting.ImportFileEnd -= OnImportFileEnd;
+        }
+    }
+}
diff --git a/Source/Editor/CustomEditors/Dedicated/ScriptsEditor.cs b/Source/Editor/CustomEditors/Dedicated/ScriptsEditor.cs
index d7bfbbad7..f783822a5 100644
--- a/Source/Editor/CustomEditors/Dedicated/ScriptsEditor.cs
+++ b/Source/Editor/CustomEditors/Dedicated/ScriptsEditor.cs
@@ -246,6 +246,7 @@ namespace FlaxEditor.CustomEditors.Dedicated
             var multiAction = new MultiUndoAction(actions);
             multiAction.Do();
             var presenter = ScriptsEditor.Presenter;
+            ScriptsEditor.ParentEditor?.RebuildLayout();
             if (presenter != null)
             {
                 presenter.Undo.AddAction(multiAction);
diff --git a/Source/Editor/CustomEditors/Editors/CollectionEditor.cs b/Source/Editor/CustomEditors/Editors/CollectionEditor.cs
index 6f623fb23..919da4301 100644
--- a/Source/Editor/CustomEditors/Editors/CollectionEditor.cs
+++ b/Source/Editor/CustomEditors/Editors/CollectionEditor.cs
@@ -87,6 +87,7 @@ namespace FlaxEditor.CustomEditors.Editors
         protected bool NotNullItems;
 
         private IntegerValueElement _size;
+        private PropertyNameLabel _sizeLabel;
         private Color _background;
         private int _elementsCount;
         private bool _readOnly;
@@ -109,6 +110,9 @@ namespace FlaxEditor.CustomEditors.Editors
             }
         }
 
+        /// <inheritdoc />
+        public override bool RevertValueWithChildren => false; // Always revert value for a whole collection
+
         /// <inheritdoc />
         public override void Initialize(LayoutElementsContainer layout)
         {
@@ -174,7 +178,9 @@ namespace FlaxEditor.CustomEditors.Editors
             }
             else
             {
-                _size = dragArea.IntegerValue("Size");
+                var sizeProperty = dragArea.AddPropertyItem("Size");
+                _sizeLabel = sizeProperty.Labels.Last();
+                _size = sizeProperty.IntegerValue();
                 _size.IntValue.MinValue = 0;
                 _size.IntValue.MaxValue = ushort.MaxValue;
                 _size.IntValue.Value = size;
@@ -274,6 +280,15 @@ namespace FlaxEditor.CustomEditors.Editors
             }
         }
 
+        /// <inheritdoc />
+        protected override void Deinitialize()
+        {
+            _size = null;
+            _sizeLabel = null;
+
+            base.Deinitialize();
+        }
+
         /// <summary>
         /// Rebuilds the parent layout if its collection.
         /// </summary>
@@ -296,7 +311,6 @@ namespace FlaxEditor.CustomEditors.Editors
         {
             if (IsSetBlocked)
                 return;
-
             Resize(_size.IntValue.Value);
         }
 
@@ -311,11 +325,9 @@ namespace FlaxEditor.CustomEditors.Editors
                 return;
 
             var cloned = CloneValues();
-
             var tmp = cloned[dstIndex];
             cloned[dstIndex] = cloned[srcIndex];
             cloned[srcIndex] = tmp;
-
             SetValue(cloned);
         }
 
@@ -371,6 +383,17 @@ namespace FlaxEditor.CustomEditors.Editors
             if (HasDifferentValues || HasDifferentTypes)
                 return;
 
+            // Update reference/default value indicator
+            if (_sizeLabel != null)
+            {
+                var color = Color.Transparent;
+                if (Values.HasReferenceValue && Values.ReferenceValue is IList referenceValue && referenceValue.Count != Count)
+                    color = FlaxEngine.GUI.Style.Current.BackgroundSelected;
+                else if (Values.HasDefaultValue && Values.DefaultValue is IList defaultValue && defaultValue.Count != Count)
+                    color = Color.Yellow * 0.8f;
+                _sizeLabel.HighlightStripColor = color;
+            }
+
             // Check if collection has been resized (by UI or from external source)
             if (Count != _elementsCount)
             {
diff --git a/Source/Editor/CustomEditors/Values/CustomValueContainer.cs b/Source/Editor/CustomEditors/Values/CustomValueContainer.cs
index 9a09c4cc2..23b5832e5 100644
--- a/Source/Editor/CustomEditors/Values/CustomValueContainer.cs
+++ b/Source/Editor/CustomEditors/Values/CustomValueContainer.cs
@@ -73,7 +73,6 @@ namespace FlaxEditor.CustomEditors
         {
             if (instanceValues == null || instanceValues.Count != Count)
                 throw new ArgumentException();
-
             for (int i = 0; i < Count; i++)
             {
                 var v = instanceValues[i];
diff --git a/Source/Editor/Editor.cpp b/Source/Editor/Editor.cpp
index 527bfeb6d..2cf9b9b8f 100644
--- a/Source/Editor/Editor.cpp
+++ b/Source/Editor/Editor.cpp
@@ -404,13 +404,23 @@ int32 Editor::LoadProduct()
 
     // Create new project option
     if (CommandLine::Options.NewProject)
+    {
+        Array<String> projectFiles;
+        FileSystem::DirectoryGetFiles(projectFiles, projectPath, TEXT("*.flaxproj"), DirectorySearchOption::TopDirectoryOnly);
+        if (projectFiles.Count() == 1)
+        {
+            // Skip creating new project if it already exists
+            LOG(Info, "Skip creatinng new project because it already exists");
+            CommandLine::Options.NewProject.Reset();
+        }
+    }
+    if (CommandLine::Options.NewProject)
     {
         if (projectPath.IsEmpty())
             projectPath = Platform::GetWorkingDirectory();
         else if (!FileSystem::DirectoryExists(projectPath))
             FileSystem::CreateDirectory(projectPath);
         FileSystem::NormalizePath(projectPath);
-
         String folderName = StringUtils::GetFileName(projectPath);
         String tmpName;
         for (int32 i = 0; i < folderName.Length(); i++)
diff --git a/Source/Editor/Editor.cs b/Source/Editor/Editor.cs
index b384b6515..393bf564e 100644
--- a/Source/Editor/Editor.cs
+++ b/Source/Editor/Editor.cs
@@ -1343,108 +1343,6 @@ namespace FlaxEditor
             public float AutoRebuildNavMeshTimeoutMs;
         }
 
-        [StructLayout(LayoutKind.Sequential)]
-        [NativeMarshalling(typeof(VisualScriptLocalMarshaller))]
-        internal struct VisualScriptLocal
-        {
-            public string Value;
-            public string ValueTypeName;
-            public uint NodeId;
-            public int BoxId;
-        }
-
-        [CustomMarshaller(typeof(VisualScriptLocal), MarshalMode.Default, typeof(VisualScriptLocalMarshaller))]
-        internal static class VisualScriptLocalMarshaller
-        {
-            [StructLayout(LayoutKind.Sequential)]
-            internal struct VisualScriptLocalNative
-            {
-                public IntPtr Value;
-                public IntPtr ValueTypeName;
-                public uint NodeId;
-                public int BoxId;
-            }
-
-            internal static VisualScriptLocal ConvertToManaged(VisualScriptLocalNative unmanaged) => ToManaged(unmanaged);
-            internal static VisualScriptLocalNative ConvertToUnmanaged(VisualScriptLocal managed) => ToNative(managed);
-
-            internal static VisualScriptLocal ToManaged(VisualScriptLocalNative managed)
-            {
-                return new VisualScriptLocal()
-                {
-                    Value = ManagedString.ToManaged(managed.Value),
-                    ValueTypeName = ManagedString.ToManaged(managed.ValueTypeName),
-                    NodeId = managed.NodeId,
-                    BoxId = managed.BoxId,
-                };
-            }
-
-            internal static VisualScriptLocalNative ToNative(VisualScriptLocal managed)
-            {
-                return new VisualScriptLocalNative()
-                {
-                    Value = ManagedString.ToNative(managed.Value),
-                    ValueTypeName = ManagedString.ToNative(managed.ValueTypeName),
-                    NodeId = managed.NodeId,
-                    BoxId = managed.BoxId,
-                };
-            }
-
-            internal static void Free(VisualScriptLocalNative unmanaged)
-            {
-                ManagedString.Free(unmanaged.Value);
-                ManagedString.Free(unmanaged.ValueTypeName);
-            }
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        [NativeMarshalling(typeof(VisualScriptStackFrameMarshaller))]
-        internal struct VisualScriptStackFrame
-        {
-            public VisualScript Script;
-            public uint NodeId;
-            public int BoxId;
-        }
-
-        [CustomMarshaller(typeof(VisualScriptStackFrame), MarshalMode.Default, typeof(VisualScriptStackFrameMarshaller))]
-        internal static class VisualScriptStackFrameMarshaller
-        {
-            [StructLayout(LayoutKind.Sequential)]
-            internal struct VisualScriptStackFrameNative
-            {
-                public IntPtr Script;
-                public uint NodeId;
-                public int BoxId;
-            }
-
-            internal static VisualScriptStackFrame ConvertToManaged(VisualScriptStackFrameNative unmanaged) => ToManaged(unmanaged);
-            internal static VisualScriptStackFrameNative ConvertToUnmanaged(VisualScriptStackFrame managed) => ToNative(managed);
-
-            internal static VisualScriptStackFrame ToManaged(VisualScriptStackFrameNative managed)
-            {
-                return new VisualScriptStackFrame()
-                {
-                    Script = VisualScriptMarshaller.ConvertToManaged(managed.Script),
-                    NodeId = managed.NodeId,
-                    BoxId = managed.BoxId,
-                };
-            }
-
-            internal static VisualScriptStackFrameNative ToNative(VisualScriptStackFrame managed)
-            {
-                return new VisualScriptStackFrameNative()
-                {
-                    Script = VisualScriptMarshaller.ConvertToUnmanaged(managed.Script),
-                    NodeId = managed.NodeId,
-                    BoxId = managed.BoxId,
-                };
-            }
-
-            internal static void Free(VisualScriptStackFrameNative unmanaged)
-            {
-            }
-        }
-
         internal void BuildCommand(string arg)
         {
             if (TryBuildCommand(arg))
@@ -1723,21 +1621,6 @@ namespace FlaxEditor
         [LibraryImport("FlaxEngine", EntryPoint = "EditorInternal_RunVisualScriptBreakpointLoopTick", StringMarshalling = StringMarshalling.Custom, StringMarshallingCustomType = typeof(StringMarshaller))]
         internal static partial void Internal_RunVisualScriptBreakpointLoopTick(float deltaTime);
 
-        [LibraryImport("FlaxEngine", EntryPoint = "EditorInternal_GetVisualScriptLocals", StringMarshalling = StringMarshalling.Custom, StringMarshallingCustomType = typeof(StringMarshaller))]
-        [return: MarshalUsing(typeof(FlaxEngine.Interop.ArrayMarshaller<,>), CountElementName = "localsCount")]
-        internal static partial VisualScriptLocal[] Internal_GetVisualScriptLocals(out int localsCount);
-
-        [LibraryImport("FlaxEngine", EntryPoint = "EditorInternal_GetVisualScriptStackFrames", StringMarshalling = StringMarshalling.Custom, StringMarshallingCustomType = typeof(StringMarshaller))]
-        [return: MarshalUsing(typeof(FlaxEngine.Interop.ArrayMarshaller<,>), CountElementName = "stackFrameCount")]
-        internal static partial VisualScriptStackFrame[] Internal_GetVisualScriptStackFrames(out int stackFrameCount);
-
-        [LibraryImport("FlaxEngine", EntryPoint = "EditorInternal_GetVisualScriptPreviousScopeFrame", StringMarshalling = StringMarshalling.Custom, StringMarshallingCustomType = typeof(StringMarshaller))]
-        internal static partial VisualScriptStackFrame Internal_GetVisualScriptPreviousScopeFrame();
-
-        [LibraryImport("FlaxEngine", EntryPoint = "EditorInternal_EvaluateVisualScriptLocal", StringMarshalling = StringMarshalling.Custom, StringMarshallingCustomType = typeof(StringMarshaller))]
-        [return: MarshalAs(UnmanagedType.U1)]
-        internal static partial bool Internal_EvaluateVisualScriptLocal(IntPtr script, ref VisualScriptLocal local);
-
         [LibraryImport("FlaxEngine", EntryPoint = "EditorInternal_DeserializeSceneObject", StringMarshalling = StringMarshalling.Custom, StringMarshallingCustomType = typeof(StringMarshaller))]
         internal static partial void Internal_DeserializeSceneObject(IntPtr sceneObject, string json);
 
diff --git a/Source/Editor/GUI/Dialogs/ColorPickerDialog.cs b/Source/Editor/GUI/Dialogs/ColorPickerDialog.cs
index 27878a763..66512236c 100644
--- a/Source/Editor/GUI/Dialogs/ColorPickerDialog.cs
+++ b/Source/Editor/GUI/Dialogs/ColorPickerDialog.cs
@@ -3,6 +3,8 @@
 using FlaxEditor.GUI.Input;
 using FlaxEngine;
 using FlaxEngine.GUI;
+using FlaxEngine.Json;
+using System.Collections.Generic;
 
 namespace FlaxEditor.GUI.Dialogs
 {
@@ -30,6 +32,8 @@ namespace FlaxEditor.GUI.Dialogs
         private const float HSVMargin = 0.0f;
         private const float ChannelsMargin = 4.0f;
         private const float ChannelTextWidth = 12.0f;
+        private const float SavedColorButtonWidth = 20.0f;
+        private const float SavedColorButtonHeight = 20.0f;
 
         private Color _initialValue;
         private Color _value;
@@ -52,6 +56,9 @@ namespace FlaxEditor.GUI.Dialogs
         private Button _cOK;
         private Button _cEyedropper;
 
+        private List<Color> _savedColors = new List<Color>();
+        private List<Button> _savedColorButtons = new List<Button>();
+
         /// <summary>
         /// Gets the selected color.
         /// </summary>
@@ -111,6 +118,12 @@ namespace FlaxEditor.GUI.Dialogs
             _onChanged = colorChanged;
             _onClosed = pickerClosed;
 
+            // Get saved colors if they exist
+            if (Editor.Instance.ProjectCache.TryGetCustomData("ColorPickerSavedColors", out var savedColors))
+            {
+                _savedColors = JsonSerializer.Deserialize<List<Color>>(savedColors);
+            }
+
             // Selector
             _cSelector = new ColorSelectorWithSliders(180, 18)
             {
@@ -195,6 +208,9 @@ namespace FlaxEditor.GUI.Dialogs
             };
             _cOK.Clicked += OnSubmit;
 
+            // Create saved color buttons
+            CreateAllSaveButtons();
+
             // Eyedropper button
             var style = Style.Current;
             _cEyedropper = new Button(_cOK.X - EyedropperMargin, _cHex.Bottom + PickerMargin)
@@ -216,6 +232,50 @@ namespace FlaxEditor.GUI.Dialogs
             SelectedColor = initialValue;
         }
 
+        private void OnSavedColorButtonClicked(Button button)
+        {
+            if (button.Tag == null)
+            {
+                // Prevent setting same color 2 times... because why...
+                foreach (var color in _savedColors)
+                {
+                    if (color == _value)
+                    {
+                        return;
+                    }
+                }
+
+                // Set color of button to current value;
+                button.BackgroundColor = _value;
+                button.BackgroundColorHighlighted = _value;
+                button.BackgroundColorSelected = _value.RGBMultiplied(0.8f);
+                button.Text = "";
+                button.Tag = _value;
+
+                // Save new colors
+                _savedColors.Add(_value);
+                var savedColors = JsonSerializer.Serialize(_savedColors, typeof(List<Color>));
+                Editor.Instance.ProjectCache.SetCustomData("ColorPickerSavedColors", savedColors);
+
+                // create new + button
+                if (_savedColorButtons.Count < 8)
+                {
+                    var savedColorButton = new Button(PickerMargin * (_savedColorButtons.Count + 1) + SavedColorButtonWidth * _savedColorButtons.Count, Height - SavedColorButtonHeight - PickerMargin, SavedColorButtonWidth, SavedColorButtonHeight)
+                    {
+                        Text = "+",
+                        Parent = this,
+                        Tag = null,
+                    };
+                    savedColorButton.ButtonClicked += (b) => OnSavedColorButtonClicked(b);
+                    _savedColorButtons.Add(savedColorButton);
+                }
+            }
+            else
+            {
+                SelectedColor = (Color)button.Tag;
+            }
+        }
+
         private void OnColorPicked(Color32 colorPicked)
         {
             if (_activeEyedropper)
@@ -340,6 +400,111 @@ namespace FlaxEditor.GUI.Dialogs
             return base.OnKeyDown(key);
         }
 
+        /// <inheritdoc />
+        public override bool OnMouseUp(Float2 location, MouseButton button)
+        {
+            if (base.OnMouseUp(location, button))
+            {
+                return true;
+            }
+
+            var child = GetChildAtRecursive(location);
+            if (button == MouseButton.Right && child is Button b && b.Tag is Color c)
+            {
+                // Show menu
+                var menu = new ContextMenu.ContextMenu();
+                var replaceButton = menu.AddButton("Replace");
+                replaceButton.Clicked += () => OnSavedColorReplace(b);
+                var deleteButton = menu.AddButton("Delete");
+                deleteButton.Clicked += () => OnSavedColorDelete(b);
+                _disableEvents = true;
+                menu.Show(this, location);
+                menu.VisibleChanged += (c) => _disableEvents = false;
+                return true;
+            }
+
+            return false;
+        }
+
+        private void OnSavedColorReplace(Button button)
+        {
+            // Prevent setting same color 2 times... because why...
+            foreach (var color in _savedColors)
+            {
+                if (color == _value)
+                {
+                    return;
+                }
+            }
+
+            // Set new Color in spot
+            for (int i = 0; i < _savedColors.Count; i++)
+            {
+                var color = _savedColors[i];
+                if (color == (Color)button.Tag)
+                {
+                    color = _value;
+                }
+            }
+
+            // Set color of button to current value;
+            button.BackgroundColor = _value;
+            button.BackgroundColorHighlighted = _value;
+            button.Text = "";
+            button.Tag = _value;
+
+            // Save new colors
+            var savedColors = JsonSerializer.Serialize(_savedColors, typeof(List<Color>));
+            Editor.Instance.ProjectCache.SetCustomData("ColorPickerSavedColors", savedColors);
+        }
+
+        private void OnSavedColorDelete(Button button)
+        {
+            _savedColors.Remove((Color)button.Tag);
+
+            foreach (var b in _savedColorButtons)
+            {
+                Children.Remove(b);
+            }
+            _savedColorButtons.Clear();
+
+            CreateAllSaveButtons();
+
+            // Save new colors
+            var savedColors = JsonSerializer.Serialize(_savedColors, typeof(List<Color>));
+            Editor.Instance.ProjectCache.SetCustomData("ColorPickerSavedColors", savedColors);
+        }
+
+        private void CreateAllSaveButtons()
+        {
+            // Create saved color buttons
+            for (int i = 0; i < _savedColors.Count; i++)
+            {
+                var savedColor = _savedColors[i];
+                var savedColorButton = new Button(PickerMargin * (i + 1) + SavedColorButtonWidth * i, Height - SavedColorButtonHeight - PickerMargin, SavedColorButtonWidth, SavedColorButtonHeight)
+                {
+                    Parent = this,
+                    Tag = savedColor,
+                    BackgroundColor = savedColor,
+                    BackgroundColorHighlighted = savedColor,
+                    BackgroundColorSelected = savedColor.RGBMultiplied(0.8f),
+                };
+                savedColorButton.ButtonClicked += (b) => OnSavedColorButtonClicked(b);
+                _savedColorButtons.Add(savedColorButton);
+            }
+            if (_savedColors.Count < 8)
+            {
+                var savedColorButton = new Button(PickerMargin * (_savedColors.Count + 1) + SavedColorButtonWidth * _savedColors.Count, Height - SavedColorButtonHeight - PickerMargin, SavedColorButtonWidth, SavedColorButtonHeight)
+                {
+                    Text = "+",
+                    Parent = this,
+                    Tag = null,
+                };
+                savedColorButton.ButtonClicked += (b) => OnSavedColorButtonClicked(b);
+                _savedColorButtons.Add(savedColorButton);
+            }
+        }
+
         /// <inheritdoc />
         public override void OnSubmit()
         {
diff --git a/Source/Editor/Gizmo/TransformGizmo.cs b/Source/Editor/Gizmo/TransformGizmo.cs
index 4a3fa39ba..741b89d2d 100644
--- a/Source/Editor/Gizmo/TransformGizmo.cs
+++ b/Source/Editor/Gizmo/TransformGizmo.cs
@@ -201,7 +201,21 @@ namespace FlaxEditor.Gizmo
                     ActorNode prefabRoot = GetPrefabRootInParent(actorNode);
                     if (prefabRoot != null && actorNode != prefabRoot)
                     {
-                        hit = WalkUpAndFindActorNodeBeforeSelection(actorNode, prefabRoot);
+                        bool isPrefabInSelection = false;
+                        foreach (var e in sceneEditing.Selection)
+                        {
+                            if (e is ActorNode ae && GetPrefabRootInParent(ae) == prefabRoot)
+                            {
+                                isPrefabInSelection = true;
+                                break;
+                            }
+                        }
+
+                        // Skip selecting prefab root if we already had object from that prefab selected
+                        if (!isPrefabInSelection)
+                        {
+                            hit = WalkUpAndFindActorNodeBeforeSelection(actorNode, prefabRoot);
+                        }
                     }
                 }
 
diff --git a/Source/Editor/Managed/ManagedEditor.Internal.cpp b/Source/Editor/Managed/ManagedEditor.Internal.cpp
index 969608676..ae8b71ee2 100644
--- a/Source/Editor/Managed/ManagedEditor.Internal.cpp
+++ b/Source/Editor/Managed/ManagedEditor.Internal.cpp
@@ -526,133 +526,6 @@ DEFINE_INTERNAL_CALL(void) EditorInternal_RunVisualScriptBreakpointLoopTick(floa
     Engine::OnDraw();
 }
 
-struct VisualScriptLocalManaged
-{
-    MString* Value;
-    MString* ValueTypeName;
-    uint32 NodeId;
-    int32 BoxId;
-};
-
-DEFINE_INTERNAL_CALL(MArray*) EditorInternal_GetVisualScriptLocals(int* localsCount)
-{
-    MArray* result = nullptr;
-    *localsCount = 0;
-    const auto stack = VisualScripting::GetThreadStackTop();
-    if (stack && stack->Scope)
-    {
-        const int32 count = stack->Scope->Parameters.Length() + stack->Scope->ReturnedValues.Count();
-        const MClass* mclass = ((NativeBinaryModule*)GetBinaryModuleFlaxEngine())->Assembly->GetClass("FlaxEditor.Editor+VisualScriptLocal");
-        ASSERT(mclass);
-        result = MCore::Array::New(mclass, count);
-        VisualScriptLocalManaged local;
-        local.NodeId = MAX_uint32;
-        if (stack->Scope->Parameters.Length() != 0)
-        {
-            auto s = stack;
-            while (s->PreviousFrame && s->PreviousFrame->Scope == stack->Scope)
-                s = s->PreviousFrame;
-            if (s)
-                local.NodeId = s->Node->ID;
-        }
-        VisualScriptLocalManaged* resultPtr = MCore::Array::GetAddress<VisualScriptLocalManaged>(result);
-        for (int32 i = 0; i < stack->Scope->Parameters.Length(); i++)
-        {
-            auto& v = stack->Scope->Parameters[i];
-            local.BoxId = i + 1;
-            local.Value = MUtils::ToString(v.ToString());
-            local.ValueTypeName = MUtils::ToString(v.Type.GetTypeName());
-            resultPtr[i] = local;
-        }
-        for (int32 i = 0; i < stack->Scope->ReturnedValues.Count(); i++)
-        {
-            auto& v = stack->Scope->ReturnedValues[i];
-            local.NodeId = v.NodeId;
-            local.BoxId = v.BoxId;
-            local.Value = MUtils::ToString(v.Value.ToString());
-            local.ValueTypeName = MUtils::ToString(v.Value.Type.GetTypeName());
-            resultPtr[stack->Scope->Parameters.Length() + i] = local;
-        }
-        *localsCount = count;
-    }
-    return result;
-}
-
-struct VisualScriptStackFrameManaged
-{
-    MObject* Script;
-    uint32 NodeId;
-    int32 BoxId;
-};
-
-DEFINE_INTERNAL_CALL(MArray*) EditorInternal_GetVisualScriptStackFrames(int* stackFramesCount)
-{
-    MArray* result = nullptr;
-    *stackFramesCount = 0;
-    const auto stack = VisualScripting::GetThreadStackTop();
-    if (stack)
-    {
-        int32 count = 0;
-        auto s = stack;
-        while (s)
-        {
-            s = s->PreviousFrame;
-            count++;
-        }
-        const MClass* mclass = ((NativeBinaryModule*)GetBinaryModuleFlaxEngine())->Assembly->GetClass("FlaxEditor.Editor+VisualScriptStackFrame");
-        ASSERT(mclass);
-        result = MCore::Array::New(mclass, count);
-        VisualScriptStackFrameManaged* resultPtr = MCore::Array::GetAddress<VisualScriptStackFrameManaged>(result);
-        s = stack;
-        count = 0;
-        while (s)
-        {
-            VisualScriptStackFrameManaged frame;
-            frame.Script = s->Script->GetOrCreateManagedInstance();
-            frame.NodeId = s->Node->ID;
-            frame.BoxId = s->Box ? s->Box->ID : MAX_uint32;
-            resultPtr[count] = frame;
-            s = s->PreviousFrame;
-            count++;
-        }
-        *stackFramesCount = count;
-    }
-    return result;
-}
-
-DEFINE_INTERNAL_CALL(VisualScriptStackFrameManaged) EditorInternal_GetVisualScriptPreviousScopeFrame()
-{
-    VisualScriptStackFrameManaged frame;
-    Platform::MemoryClear(&frame, sizeof(frame));
-    const auto stack = VisualScripting::GetThreadStackTop();
-    if (stack)
-    {
-        auto s = stack;
-        while (s->PreviousFrame && s->PreviousFrame->Scope == stack->Scope)
-            s = s->PreviousFrame;
-        if (s && s->PreviousFrame)
-        {
-            s = s->PreviousFrame;
-            frame.Script = s->Script->GetOrCreateManagedInstance();
-            frame.NodeId = s->Node->ID;
-            frame.BoxId = s->Box ? s->Box->ID : MAX_uint32;
-        }
-    }
-    return frame;
-}
-
-DEFINE_INTERNAL_CALL(bool) EditorInternal_EvaluateVisualScriptLocal(VisualScript* script, VisualScriptLocalManaged* local)
-{
-    Variant v;
-    if (VisualScripting::Evaluate(script, VisualScripting::GetThreadStackTop()->Instance, local->NodeId, local->BoxId, v))
-    {
-        local->Value = MUtils::ToString(v.ToString());
-        local->ValueTypeName = MUtils::ToString(v.Type.GetTypeName());
-        return true;
-    }
-    return false;
-}
-
 DEFINE_INTERNAL_CALL(void) EditorInternal_DeserializeSceneObject(SceneObject* sceneObject, MString* jsonObj)
 {
     PROFILE_CPU_NAMED("DeserializeSceneObject");
@@ -769,7 +642,7 @@ bool ManagedEditor::TryRestoreImportOptions(ModelTool::Options& options, String
 
     // Get options from model
     FileSystem::NormalizePath(assetPath);
-    return ImportModelFile::TryGetImportOptions(assetPath, options);
+    return ImportModel::TryGetImportOptions(assetPath, options);
 }
 
 bool ManagedEditor::Import(const String& inputPath, const String& outputPath, const AudioTool::Options& options)
diff --git a/Source/Editor/Managed/ManagedEditor.cpp b/Source/Editor/Managed/ManagedEditor.cpp
index bed742885..f7e0c1498 100644
--- a/Source/Editor/Managed/ManagedEditor.cpp
+++ b/Source/Editor/Managed/ManagedEditor.cpp
@@ -489,6 +489,95 @@ void ManagedEditor::RequestStartPlayOnEditMode()
     Internal_RequestStartPlayOnEditMode->Invoke(GetManagedInstance(), nullptr, nullptr);
 }
 
+Array<ManagedEditor::VisualScriptStackFrame> ManagedEditor::GetVisualScriptStackFrames()
+{
+    Array<VisualScriptStackFrame> result;
+    const auto stack = VisualScripting::GetThreadStackTop();
+    auto s = stack;
+    while (s)
+    {
+        VisualScriptStackFrame& frame = result.AddOne();
+        frame.Script = s->Script;
+        frame.NodeId = s->Node->ID;
+        frame.BoxId = s->Box ? s->Box->ID : MAX_uint32;
+        s = s->PreviousFrame;
+    }
+    return result;
+}
+
+ManagedEditor::VisualScriptStackFrame ManagedEditor::GetVisualScriptPreviousScopeFrame()
+{
+    VisualScriptStackFrame frame;
+    Platform::MemoryClear(&frame, sizeof(frame));
+    const auto stack = VisualScripting::GetThreadStackTop();
+    if (stack)
+    {
+        auto s = stack;
+        while (s->PreviousFrame && s->PreviousFrame->Scope == stack->Scope)
+            s = s->PreviousFrame;
+        if (s && s->PreviousFrame)
+        {
+            s = s->PreviousFrame;
+            frame.Script = s->Script;
+            frame.NodeId = s->Node->ID;
+            frame.BoxId = s->Box ? s->Box->ID : MAX_uint32;
+        }
+    }
+    return frame;
+}
+
+Array<ManagedEditor::VisualScriptLocal> ManagedEditor::GetVisualScriptLocals()
+{
+    Array<VisualScriptLocal> result;
+    const auto stack = VisualScripting::GetThreadStackTop();
+    if (stack && stack->Scope)
+    {
+        const int32 count = stack->Scope->Parameters.Length() + stack->Scope->ReturnedValues.Count();
+        result.Resize(count);
+        VisualScriptLocal local;
+        local.NodeId = MAX_uint32;
+        if (stack->Scope->Parameters.Length() != 0)
+        {
+            auto s = stack;
+            while (s->PreviousFrame && s->PreviousFrame->Scope == stack->Scope)
+                s = s->PreviousFrame;
+            if (s)
+                local.NodeId = s->Node->ID;
+        }
+        for (int32 i = 0; i < stack->Scope->Parameters.Length(); i++)
+        {
+            auto& v = stack->Scope->Parameters[i];
+            local.BoxId = i + 1;
+            local.Value = v.ToString();
+            local.ValueTypeName = v.Type.GetTypeName();
+            result[i] = local;
+        }
+        for (int32 i = 0; i < stack->Scope->ReturnedValues.Count(); i++)
+        {
+            auto& v = stack->Scope->ReturnedValues[i];
+            local.NodeId = v.NodeId;
+            local.BoxId = v.BoxId;
+            local.Value = v.Value.ToString();
+            local.ValueTypeName = v.Value.Type.GetTypeName();
+            result[stack->Scope->Parameters.Length() + i] = local;
+        }
+    }
+    return result;
+}
+
+bool ManagedEditor::EvaluateVisualScriptLocal(VisualScript* script, VisualScriptLocal& local)
+{
+    Variant v;
+    const auto stack = VisualScripting::GetThreadStackTop();
+    if (stack && VisualScripting::Evaluate(script, stack->Instance, local.NodeId, local.BoxId, v))
+    {
+        local.Value = v.ToString();
+        local.ValueTypeName = v.Type.GetTypeName();
+        return true;
+    }
+    return false;
+}
+
 void ManagedEditor::OnEditorAssemblyLoaded(MAssembly* assembly)
 {
     ASSERT(!HasManagedInstance());
diff --git a/Source/Editor/Managed/ManagedEditor.h b/Source/Editor/Managed/ManagedEditor.h
index 93d1723a3..8c9571cfd 100644
--- a/Source/Editor/Managed/ManagedEditor.h
+++ b/Source/Editor/Managed/ManagedEditor.h
@@ -210,6 +210,31 @@ public:
     API_FUNCTION() static bool TryRestoreImportOptions(API_PARAM(Ref) AudioTool::Options& options, String assetPath);
 #endif
 
+public:
+    API_STRUCT(Internal, NoDefault) struct VisualScriptStackFrame
+    {
+        DECLARE_SCRIPTING_TYPE_MINIMAL(VisualScriptStackFrame);
+
+        API_FIELD() class VisualScript* Script;
+        API_FIELD() uint32 NodeId;
+        API_FIELD() int32 BoxId;
+    };
+
+    API_STRUCT(Internal, NoDefault) struct VisualScriptLocal
+    {
+        DECLARE_SCRIPTING_TYPE_MINIMAL(VisualScriptLocal);
+
+        API_FIELD() String Value;
+        API_FIELD() String ValueTypeName;
+        API_FIELD() uint32 NodeId;
+        API_FIELD() int32 BoxId;
+    };
+
+    API_FUNCTION(Internal) static Array<VisualScriptStackFrame> GetVisualScriptStackFrames();
+    API_FUNCTION(Internal) static VisualScriptStackFrame GetVisualScriptPreviousScopeFrame();
+    API_FUNCTION(Internal) static Array<VisualScriptLocal> GetVisualScriptLocals();
+    API_FUNCTION(Internal) static bool EvaluateVisualScriptLocal(VisualScript* script, API_PARAM(Ref) VisualScriptLocal& local);
+
 private:
     void OnEditorAssemblyLoaded(MAssembly* assembly);
 
diff --git a/Source/Editor/Modules/ContentImportingModule.cs b/Source/Editor/Modules/ContentImportingModule.cs
index 85dd50d35..587d3a6c6 100644
--- a/Source/Editor/Modules/ContentImportingModule.cs
+++ b/Source/Editor/Modules/ContentImportingModule.cs
@@ -126,29 +126,35 @@ namespace FlaxEditor.Modules
         {
             if (item != null && !item.GetImportPath(out string importPath))
             {
-                // Check if input file is missing
-                if (!System.IO.File.Exists(importPath))
-                {
-                    Editor.LogWarning(string.Format("Cannot reimport asset \'{0}\'. File \'{1}\' does not exist.", item.Path, importPath));
-                    if (skipSettingsDialog)
-                        return;
-
-                    // Ask user to select new file location
-                    var title = string.Format("Please find missing \'{0}\' file for asset \'{1}\'", importPath, item.ShortName);
-                    if (FileSystem.ShowOpenFileDialog(Editor.Windows.MainWindow, null, "All files (*.*)\0*.*\0", false, title, out var files))
-                        return;
-                    if (files != null && files.Length > 0)
-                        importPath = files[0];
-
-                    // Validate file path again
-                    if (!System.IO.File.Exists(importPath))
-                        return;
-                }
-
+                if (GetReimportPath(item.ShortName, ref importPath, skipSettingsDialog))
+                    return;
                 Import(importPath, item.Path, true, skipSettingsDialog, settings);
             }
         }
 
+        internal bool GetReimportPath(string contextName, ref string importPath, bool skipSettingsDialog = false)
+        {
+            // Check if input file is missing
+            if (!System.IO.File.Exists(importPath))
+            {
+                Editor.LogWarning(string.Format("Cannot reimport asset \'{0}\'. File \'{1}\' does not exist.", contextName, importPath));
+                if (skipSettingsDialog)
+                    return true;
+
+                // Ask user to select new file location
+                var title = string.Format("Please find missing \'{0}\' file for asset \'{1}\'", importPath, contextName);
+                if (FileSystem.ShowOpenFileDialog(Editor.Windows.MainWindow, null, "All files (*.*)\0*.*\0", false, title, out var files))
+                    return true;
+                if (files != null && files.Length > 0)
+                    importPath = files[0];
+
+                // Validate file path again
+                if (!System.IO.File.Exists(importPath))
+                    return true;
+            }
+            return false;
+        }
+
         /// <summary>
         /// Imports the specified files.
         /// </summary>
diff --git a/Source/Editor/SceneGraph/Actors/BoxColliderNode.cs b/Source/Editor/SceneGraph/Actors/BoxColliderNode.cs
index 1f92eceea..0f6670feb 100644
--- a/Source/Editor/SceneGraph/Actors/BoxColliderNode.cs
+++ b/Source/Editor/SceneGraph/Actors/BoxColliderNode.cs
@@ -7,9 +7,37 @@ using Real = System.Single;
 #endif
 
 using FlaxEngine;
+using FlaxEditor.CustomEditors.Dedicated;
+using FlaxEditor.CustomEditors;
+using FlaxEditor.Scripting;
 
 namespace FlaxEditor.SceneGraph.Actors
 {
+    /// <summary>
+    /// Dedicated custom editor for BoxCollider objects.
+    /// </summary>
+    [CustomEditor(typeof(BoxCollider)), DefaultEditor]
+    public class BoxColliderEditor : ActorEditor
+    {
+        /// <inheritdoc />
+        public override void Initialize(LayoutElementsContainer layout)
+        {
+            base.Initialize(layout);
+
+            layout.Space(20f);
+            layout.Button("Resize to Fit", Editor.Instance.CodeDocs.GetTooltip(new ScriptMemberInfo(typeof(BoxCollider).GetMethod("AutoResize")))).Button.Clicked += OnResizeClicked;
+        }
+
+        private void OnResizeClicked()
+        {
+            foreach (var value in Values)
+            {
+                if (value is BoxCollider collider)
+                    collider.AutoResize();
+            }
+        }
+    }
+
     /// <summary>
     /// Scene tree node for <see cref="BoxCollider"/> actor type.
     /// </summary>
@@ -37,5 +65,18 @@ namespace FlaxEditor.SceneGraph.Actors
 
             return base.RayCastSelf(ref ray, out distance, out normal);
         }
+
+        /// <inheritdoc />
+        public override void PostSpawn()
+        {
+            base.PostSpawn();
+
+            if (Actor.HasPrefabLink)
+            {
+                return;
+            }
+
+            ((BoxCollider)Actor).AutoResize();
+        }
     }
 }
diff --git a/Source/Editor/SceneGraph/Actors/SplineNode.cs b/Source/Editor/SceneGraph/Actors/SplineNode.cs
index 3b9e8651d..acd23130d 100644
--- a/Source/Editor/SceneGraph/Actors/SplineNode.cs
+++ b/Source/Editor/SceneGraph/Actors/SplineNode.cs
@@ -334,6 +334,11 @@ namespace FlaxEditor.SceneGraph.Actors
         {
             base.PostSpawn();
 
+            if (Actor.HasPrefabLink)
+            {
+                return;
+            }
+
             // Setup for an initial spline
             var spline = (Spline)Actor;
             spline.AddSplineLocalPoint(Vector3.Zero, false);
diff --git a/Source/Editor/SceneGraph/Actors/SpriteRenderNode.cs b/Source/Editor/SceneGraph/Actors/SpriteRenderNode.cs
index 8b5b498e1..65e1a1f0b 100644
--- a/Source/Editor/SceneGraph/Actors/SpriteRenderNode.cs
+++ b/Source/Editor/SceneGraph/Actors/SpriteRenderNode.cs
@@ -61,10 +61,15 @@ namespace FlaxEditor.SceneGraph.Actors
         {
             base.PostSpawn();
 
+            if (Actor.HasPrefabLink)
+            {
+                return;
+            }
+
             // Setup for default values
-            var text = (SpriteRender)Actor;
-            text.Material = FlaxEngine.Content.LoadAsyncInternal<MaterialBase>(EditorAssets.DefaultSpriteMaterial);
-            text.Image = FlaxEngine.Content.LoadAsyncInternal<Texture>(EditorAssets.FlaxIconTexture);
+            var sprite = (SpriteRender)Actor;
+            sprite.Material = FlaxEngine.Content.LoadAsyncInternal<MaterialBase>(EditorAssets.DefaultSpriteMaterial);
+            sprite.Image = FlaxEngine.Content.LoadAsyncInternal<Texture>(EditorAssets.FlaxIconTexture);
         }
     }
 }
diff --git a/Source/Editor/SceneGraph/Actors/TextRenderNode.cs b/Source/Editor/SceneGraph/Actors/TextRenderNode.cs
index a79708fe8..4c0208c84 100644
--- a/Source/Editor/SceneGraph/Actors/TextRenderNode.cs
+++ b/Source/Editor/SceneGraph/Actors/TextRenderNode.cs
@@ -22,6 +22,11 @@ namespace FlaxEditor.SceneGraph.Actors
         {
             base.PostSpawn();
 
+            if (Actor.HasPrefabLink)
+            {
+                return;
+            }
+
             // Setup for default values
             var text = (TextRender)Actor;
             text.Text = "My Text";
diff --git a/Source/Editor/SceneGraph/Actors/UICanvasNode.cs b/Source/Editor/SceneGraph/Actors/UICanvasNode.cs
index ed6fc08d6..7890e64c1 100644
--- a/Source/Editor/SceneGraph/Actors/UICanvasNode.cs
+++ b/Source/Editor/SceneGraph/Actors/UICanvasNode.cs
@@ -29,15 +29,33 @@ namespace FlaxEditor.SceneGraph.Actors
         {
             base.PostSpawn();
 
+            if (Actor.HasPrefabLink)
+            {
+                return;
+            }
+
             // Rotate to match the space (GUI uses upper left corner as a root)
             Actor.LocalOrientation = Quaternion.Euler(0, -180, -180);
-            var uiControl = new UIControl
+            bool canSpawn = true;
+            foreach (var uiControl in Actor.GetChildren<UIControl>())
             {
-                Name = "Canvas Scalar",
-                Transform = Actor.Transform,
-                Control = new CanvasScaler()
-            };
-            Root.Spawn(uiControl, Actor);
+                if (uiControl.Get<CanvasScaler>() == null)
+                    continue;
+                canSpawn = false;
+                break;
+            }
+
+            if (canSpawn)
+            {
+                var uiControl = new UIControl
+                {
+                    Name = "Canvas Scalar",
+                    Transform = Actor.Transform,
+                    Control = new CanvasScaler()
+                };
+                Root.Spawn(uiControl, Actor);
+            }
+            _treeNode.Expand();
         }
 
         /// <inheritdoc />
diff --git a/Source/Editor/SceneGraph/GUI/ActorTreeNode.cs b/Source/Editor/SceneGraph/GUI/ActorTreeNode.cs
index f64e46385..9cfe5b7bd 100644
--- a/Source/Editor/SceneGraph/GUI/ActorTreeNode.cs
+++ b/Source/Editor/SceneGraph/GUI/ActorTreeNode.cs
@@ -85,12 +85,20 @@ namespace FlaxEditor.SceneGraph.GUI
         {
             if (Parent is ActorTreeNode parent)
             {
-                for (int i = 0; i < parent.ChildrenCount; i++)
+                var anyChanged = false;
+                var children = parent.Children;
+                for (int i = 0; i < children.Count; i++)
                 {
-                    if (parent.Children[i] is ActorTreeNode child && child.Actor)
-                        child._orderInParent = child.Actor.OrderInParent;
+                    if (children[i] is ActorTreeNode child && child.Actor)
+                    {
+                        var orderInParent = child.Actor.OrderInParent;
+                        anyChanged |= child._orderInParent != orderInParent;
+                        if (anyChanged)
+                            child._orderInParent = orderInParent;
+                    }
                 }
-                parent.SortChildren();
+                if (anyChanged)
+                    parent.SortChildren();
             }
             else if (Actor)
             {
@@ -690,6 +698,10 @@ namespace FlaxEditor.SceneGraph.GUI
             if (thisHasScene != otherHasScene)
                 return false;
 
+            // Reject dragging actors between prefab windows (different roots)
+            if (!thisHasScene && ActorNode.Root != actorNode.Root)
+                return false;
+
             // Reject dragging parents and itself
             return actorNode.Actor != null && actorNode != ActorNode && actorNode.Find(Actor) == null;
         }
diff --git a/Source/Editor/Surface/Archetypes/Animation.StateMachine.cs b/Source/Editor/Surface/Archetypes/Animation.StateMachine.cs
index 621c7c25e..9d4367303 100644
--- a/Source/Editor/Surface/Archetypes/Animation.StateMachine.cs
+++ b/Source/Editor/Surface/Archetypes/Animation.StateMachine.cs
@@ -1335,6 +1335,7 @@ namespace FlaxEditor.Surface.Archetypes
                 Surface?.AddBatchedUndoAction(action);
                 action.Do();
                 Surface?.OnNodesConnected(this, other);
+                Surface?.MarkAsEdited();
             }
         }
 
@@ -1911,6 +1912,7 @@ namespace FlaxEditor.Surface.Archetypes
             {
                 var action = new StateMachineStateBase.AddRemoveTransitionAction(this);
                 SourceState.Surface?.AddBatchedUndoAction(action);
+                SourceState.Surface?.MarkAsEdited();
                 action.Do();
             }
 
diff --git a/Source/Editor/Surface/Archetypes/Animation.cs b/Source/Editor/Surface/Archetypes/Animation.cs
index 40a3d2a63..446883406 100644
--- a/Source/Editor/Surface/Archetypes/Animation.cs
+++ b/Source/Editor/Surface/Archetypes/Animation.cs
@@ -493,7 +493,15 @@ namespace FlaxEditor.Surface.Archetypes
             {
                 TypeID = 10,
                 Title = "Blend Additive",
-                Description = "Blend animation poses (with additive mode)",
+                Description = 
+                "Blend animation poses (with additive mode)" +
+                "\n" +
+                "\nNote: " +
+                "\nOrder of nodes matters, because Additive animation is appplayed on top of curent frame." +
+                "\n" +
+                "\nTip for blender users:" +
+                "\nInside NLA the the order is bottom (first node in flax) to the top (last node in flax)" +
+                "\n​u need to place it in this order to get correct resoults",
                 Flags = NodeFlags.AnimGraph,
                 Size = new Float2(170, 80),
                 DefaultValues = new object[]
diff --git a/Source/Editor/Surface/Archetypes/BehaviorTree.cs b/Source/Editor/Surface/Archetypes/BehaviorTree.cs
index f8cd7bb5a..07005df28 100644
--- a/Source/Editor/Surface/Archetypes/BehaviorTree.cs
+++ b/Source/Editor/Surface/Archetypes/BehaviorTree.cs
@@ -755,6 +755,29 @@ namespace FlaxEditor.Surface.Archetypes
                 }
             }
 
+            /// <inheritdoc />
+            public override void OnDeleted(SurfaceNodeActions action)
+            {
+                // Unlink from the current parent (when deleted by user)
+                var node = Node;
+                if (node != null)
+                {
+                    if (action == SurfaceNodeActions.User)
+                    {
+                        var decorators = node.DecoratorIds;
+                        decorators.Remove(ID);
+                        node.DecoratorIds = decorators;
+                    }
+                    else
+                    {
+                        node._decorators = null;
+                        node.ResizeAuto();
+                    }
+                }
+
+                base.OnDeleted(action);
+            }
+
             public override void OnSurfaceCanEditChanged(bool canEdit)
             {
                 base.OnSurfaceCanEditChanged(canEdit);
diff --git a/Source/Editor/Surface/Undo/AddRemoveNodeAction.cs b/Source/Editor/Surface/Undo/AddRemoveNodeAction.cs
index ba6770287..0deb66fbe 100644
--- a/Source/Editor/Surface/Undo/AddRemoveNodeAction.cs
+++ b/Source/Editor/Surface/Undo/AddRemoveNodeAction.cs
@@ -19,6 +19,7 @@ namespace FlaxEditor.Surface.Undo
         private ushort _typeId;
         private Float2 _nodeLocation;
         private object[] _nodeValues;
+        private SurfaceNodeActions _actionType = SurfaceNodeActions.User; // Action usage flow is first to apply user effect such as removing/adding node, then we use Undo type so node can react to this
 
         public AddRemoveNodeAction(SurfaceNode node, bool isAdd)
         {
@@ -38,6 +39,7 @@ namespace FlaxEditor.Surface.Undo
                 Add();
             else
                 Remove();
+            _actionType = SurfaceNodeActions.Undo;
         }
 
         /// <inheritdoc />
@@ -67,8 +69,8 @@ namespace FlaxEditor.Surface.Undo
             else if (_nodeValues != null && _nodeValues.Length != 0)
                 throw new InvalidOperationException("Invalid node values.");
             node.Location = _nodeLocation;
-            context.OnControlLoaded(node, SurfaceNodeActions.Undo);
-            node.OnSurfaceLoaded(SurfaceNodeActions.Undo);
+            context.OnControlLoaded(node, _actionType);
+            node.OnSurfaceLoaded(_actionType);
 
             context.MarkAsModified();
         }
@@ -89,7 +91,7 @@ namespace FlaxEditor.Surface.Undo
 
             // Remove node
             context.Nodes.Remove(node);
-            context.OnControlDeleted(node, SurfaceNodeActions.Undo);
+            context.OnControlDeleted(node, _actionType);
 
             context.MarkAsModified();
         }
diff --git a/Source/Editor/Surface/VisjectSurface.Input.cs b/Source/Editor/Surface/VisjectSurface.Input.cs
index ec878a407..419c2d468 100644
--- a/Source/Editor/Surface/VisjectSurface.Input.cs
+++ b/Source/Editor/Surface/VisjectSurface.Input.cs
@@ -533,6 +533,7 @@ namespace FlaxEditor.Surface
                     UpdateSelectionRectangle();
                 }
             }
+            bool showPrimaryMenu = false;
             if (_rightMouseDown && button == MouseButton.Right)
             {
                 _rightMouseDown = false;
@@ -546,8 +547,7 @@ namespace FlaxEditor.Surface
                     _cmStartPos = location;
                     if (controlUnderMouse == null)
                     {
-                        // Show primary context menu
-                        ShowPrimaryMenu(_cmStartPos);
+                        showPrimaryMenu = true;
                     }
                 }
                 _mouseMoveAmount = 0;
@@ -573,8 +573,13 @@ namespace FlaxEditor.Surface
                 return true;
             }
 
+            // If none of the child controls handled this show the primary context menu
+            if (showPrimaryMenu)
+            {
+                ShowPrimaryMenu(_cmStartPos);
+            }
             // Letting go of a connection or right clicking while creating a connection
-            if (!_isMovingSelection && _connectionInstigator != null && !IsPrimaryMenuOpened)
+            else if (!_isMovingSelection && _connectionInstigator != null && !IsPrimaryMenuOpened)
             {
                 _cmStartPos = location;
                 Cursor = CursorType.Default;
diff --git a/Source/Editor/Surface/VisjectSurface.cs b/Source/Editor/Surface/VisjectSurface.cs
index 3ac702549..530f3265f 100644
--- a/Source/Editor/Surface/VisjectSurface.cs
+++ b/Source/Editor/Surface/VisjectSurface.cs
@@ -837,7 +837,7 @@ namespace FlaxEditor.Surface
                         actions.Add(action);
                     }
 
-                    Undo.AddAction(new MultiUndoAction(actions, nodes.Count == 1 ? "Remove node" : "Remove nodes"));
+                    AddBatchedUndoAction(new MultiUndoAction(actions, nodes.Count == 1 ? "Remove node" : "Remove nodes"));
                 }
             }
 
diff --git a/Source/Editor/Surface/VisualScriptSurface.cs b/Source/Editor/Surface/VisualScriptSurface.cs
index 2f8d4cda8..4635e09d7 100644
--- a/Source/Editor/Surface/VisualScriptSurface.cs
+++ b/Source/Editor/Surface/VisualScriptSurface.cs
@@ -62,6 +62,19 @@ namespace FlaxEditor.Surface
             return true;
         }
 
+        private string GetBoxDebuggerTooltip(ref Editor.VisualScriptLocal local)
+        {
+            if (string.IsNullOrEmpty(local.ValueTypeName))
+            {
+                if (string.IsNullOrEmpty(local.Value))
+                    return string.Empty;
+                return local.Value;
+            }
+            if (string.IsNullOrEmpty(local.Value))
+                return $"({local.ValueTypeName})";
+            return $"{local.Value}\n({local.ValueTypeName})";
+        }
+
         /// <inheritdoc />
         public override void OnNodeBreakpointEdited(SurfaceNode node)
         {
@@ -95,7 +108,7 @@ namespace FlaxEditor.Surface
                         ref var local = ref state.Locals[i];
                         if (local.BoxId == box.ID && local.NodeId == box.ParentNode.ID)
                         {
-                            text = $"{local.Value ?? string.Empty} ({local.ValueTypeName})";
+                            text = GetBoxDebuggerTooltip(ref local);
                             return true;
                         }
                     }
@@ -107,7 +120,7 @@ namespace FlaxEditor.Surface
                             ref var local = ref state.Locals[i];
                             if (local.BoxId == connectedBox.ID && local.NodeId == connectedBox.ParentNode.ID)
                             {
-                                text = $"{local.Value ?? string.Empty} ({local.ValueTypeName})";
+                                text = GetBoxDebuggerTooltip(ref local);
                                 return true;
                             }
                         }
@@ -123,9 +136,33 @@ namespace FlaxEditor.Surface
                         BoxId = box.ID,
                     };
                     var script = ((Windows.Assets.VisualScriptWindow)box.Surface.Owner).Asset;
-                    if (Editor.Internal_EvaluateVisualScriptLocal(Object.GetUnmanagedPtr(script), ref local))
+                    if (Editor.EvaluateVisualScriptLocal(script, ref local))
                     {
-                        text = $"{local.Value ?? string.Empty} ({local.ValueTypeName})";
+                        // Check if got no value (null)
+                        if (string.IsNullOrEmpty(local.ValueTypeName) && string.Equals(local.Value, "null", StringComparison.Ordinal))
+                        {
+                            var connections = box.Connections;
+                            if (connections.Count == 0 && box.Archetype.ValueIndex >= 0 && box.ParentNode.Values != null && box.Archetype.ValueIndex < box.ParentNode.Values.Length)
+                            {
+                                // Special case when there is no value but the box has no connection and uses default value
+                                var defaultValue = box.ParentNode.Values[box.Archetype.ValueIndex];
+                                if (defaultValue != null)
+                                {
+                                    local.Value = defaultValue.ToString();
+                                    local.ValueTypeName = defaultValue.GetType().FullName;
+                                }
+                            }
+                            else if (connections.Count == 1)
+                            {
+                                // Special case when there is no value but the box has a connection with valid value to try to use it instead
+                                box = connections[0];
+                                local.NodeId = box.ParentNode.ID;
+                                local.BoxId = box.ID;
+                                Editor.EvaluateVisualScriptLocal(script, ref local);
+                            }
+                        }
+
+                        text = GetBoxDebuggerTooltip(ref local);
                         return true;
                     }
                 }
diff --git a/Source/Editor/Viewport/EditorViewport.cs b/Source/Editor/Viewport/EditorViewport.cs
index c49392d01..9ac9b5571 100644
--- a/Source/Editor/Viewport/EditorViewport.cs
+++ b/Source/Editor/Viewport/EditorViewport.cs
@@ -1374,8 +1374,8 @@ namespace FlaxEditor.Viewport
             ivp.Invert();
 
             // Create near and far points
-            var nearPoint = new Vector3(mousePosition, 0.0f);
-            var farPoint = new Vector3(mousePosition, 1.0f);
+            var nearPoint = new Vector3(mousePosition, _nearPlane);
+            var farPoint = new Vector3(mousePosition, _farPlane);
             viewport.Unproject(ref nearPoint, ref ivp, out nearPoint);
             viewport.Unproject(ref farPoint, ref ivp, out farPoint);
 
diff --git a/Source/Editor/Windows/Assets/PrefabWindow.Hierarchy.cs b/Source/Editor/Windows/Assets/PrefabWindow.Hierarchy.cs
index a8d9ae1be..478439e0e 100644
--- a/Source/Editor/Windows/Assets/PrefabWindow.Hierarchy.cs
+++ b/Source/Editor/Windows/Assets/PrefabWindow.Hierarchy.cs
@@ -368,7 +368,7 @@ namespace FlaxEditor.Windows.Assets
                 actor.Layer = parentActor.Layer;
 
                 // Rename actor to identify it easily
-                actor.Name = Utilities.Utils.IncrementNameNumber(actor.GetType().Name, x => parentActor.GetChild(x) == null);
+                actor.Name = Utilities.Utils.IncrementNameNumber(actor.Name, x => parentActor.GetChild(x) == null);
             }
 
             // Spawn it
@@ -428,11 +428,9 @@ namespace FlaxEditor.Windows.Assets
 
         private void Update(ActorNode actorNode)
         {
-            if (actorNode.Actor)
-            {
-                actorNode.TreeNode.UpdateText();
-                actorNode.TreeNode.OnOrderInParentChanged();
-            }
+            actorNode.TreeNode.UpdateText();
+            if (actorNode.TreeNode.IsCollapsed)
+                return;
 
             for (int i = 0; i < actorNode.ChildNodes.Count; i++)
             {
diff --git a/Source/Editor/Windows/Assets/PrefabWindow.cs b/Source/Editor/Windows/Assets/PrefabWindow.cs
index f50a832a1..025760b1e 100644
--- a/Source/Editor/Windows/Assets/PrefabWindow.cs
+++ b/Source/Editor/Windows/Assets/PrefabWindow.cs
@@ -440,6 +440,7 @@ namespace FlaxEditor.Windows.Assets
         {
             try
             {
+                FlaxEngine.Profiler.BeginEvent("PrefabWindow.Update");
                 if (Graph.Main != null)
                 {
                     // Due to fact that actors in prefab editor are only created but not added to gameplay 
@@ -468,6 +469,10 @@ namespace FlaxEditor.Windows.Assets
                     Graph.Root.TreeNode.ExpandAll(true);
                 }
             }
+            finally
+            {
+                FlaxEngine.Profiler.EndEvent();
+            }
 
             // Auto fit
             if (_focusCamera && _viewport.Task.FrameCount > 1)
diff --git a/Source/Editor/Windows/Assets/VisualScriptWindow.cs b/Source/Editor/Windows/Assets/VisualScriptWindow.cs
index 79157f850..802269677 100644
--- a/Source/Editor/Windows/Assets/VisualScriptWindow.cs
+++ b/Source/Editor/Windows/Assets/VisualScriptWindow.cs
@@ -797,11 +797,12 @@ namespace FlaxEditor.Windows.Assets
             }
 
             // Check if any breakpoint was hit
-            for (int i = 0; i < Surface.Breakpoints.Count; i++)
+            var breakpoints = Surface.Breakpoints;
+            for (int i = 0; i < breakpoints.Count; i++)
             {
-                if (Surface.Breakpoints[i].ID == flowInfo.NodeId)
+                if (breakpoints[i].ID == flowInfo.NodeId)
                 {
-                    OnDebugBreakpointHit(ref flowInfo, Surface.Breakpoints[i]);
+                    OnDebugBreakpointHit(ref flowInfo, breakpoints[i]);
                     break;
                 }
             }
@@ -820,7 +821,7 @@ namespace FlaxEditor.Windows.Assets
             var state = (BreakpointHangState)Editor.Instance.Simulation.BreakpointHangTag;
             if (state.Locals == null)
             {
-                state.Locals = Editor.Internal_GetVisualScriptLocals(out var _);
+                state.Locals = Editor.GetVisualScriptLocals();
                 Editor.Instance.Simulation.BreakpointHangTag = state;
             }
             return state;
@@ -831,7 +832,7 @@ namespace FlaxEditor.Windows.Assets
             var state = (BreakpointHangState)Editor.Instance.Simulation.BreakpointHangTag;
             if (state.StackFrames == null)
             {
-                state.StackFrames = Editor.Internal_GetVisualScriptStackFrames(out var _);
+                state.StackFrames = Editor.GetVisualScriptStackFrames();
                 Editor.Instance.Simulation.BreakpointHangTag = state;
             }
             return state;
@@ -976,7 +977,7 @@ namespace FlaxEditor.Windows.Assets
                 return;
 
             // Break on any of the output connects from the previous scope node
-            var frame = Editor.Internal_GetVisualScriptPreviousScopeFrame();
+            var frame = Editor.GetVisualScriptPreviousScopeFrame();
             if (frame.Script != null)
             {
                 if (_debugStepOutNodesIds == null)
diff --git a/Source/Editor/Windows/PluginsWindow.cs b/Source/Editor/Windows/PluginsWindow.cs
index f43fb0342..eb04f07b8 100644
--- a/Source/Editor/Windows/PluginsWindow.cs
+++ b/Source/Editor/Windows/PluginsWindow.cs
@@ -381,6 +381,7 @@ namespace FlaxEditor.Windows
                     Arguments = $"clone {gitPath} \"{clonePath}\"",
                     ShellExecute = false,
                     LogOutput = true,
+                    WaitForEnd = true
                 };
                 Platform.CreateProcess(ref settings);
             }
@@ -402,6 +403,7 @@ namespace FlaxEditor.Windows
                     Arguments = "submodule update --init",
                     ShellExecute = false,
                     LogOutput = true,
+                    WaitForEnd = true
                 };
                 Platform.CreateProcess(ref settings);
             }
diff --git a/Source/Editor/Windows/SceneTreeWindow.ContextMenu.cs b/Source/Editor/Windows/SceneTreeWindow.ContextMenu.cs
index a99c3ac7d..0c8e0f283 100644
--- a/Source/Editor/Windows/SceneTreeWindow.ContextMenu.cs
+++ b/Source/Editor/Windows/SceneTreeWindow.ContextMenu.cs
@@ -1,6 +1,8 @@
 // Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using FlaxEditor.GUI.ContextMenu;
 using FlaxEditor.SceneGraph;
 using FlaxEngine;
@@ -146,6 +148,31 @@ namespace FlaxEditor.Windows
                 contextMenu.AddButton("Break Prefab Link", Editor.Prefabs.BreakLinks);
             }
 
+            // Load additional scenes option
+
+            if (!hasSthSelected)
+            {
+                var allScenes = FlaxEngine.Content.GetAllAssetsByType(typeof(SceneAsset));
+                var loadedSceneIds = Editor.Instance.Scene.Root.ChildNodes.Select(node => node.ID).ToList();
+                var unloadedScenes = allScenes.Where(sceneId => !loadedSceneIds.Contains(sceneId)).ToList();
+                if (unloadedScenes.Count > 0)
+                {
+                    contextMenu.AddSeparator();
+                    var childCM = contextMenu.GetOrAddChildMenu("Open Scene");
+                    foreach (var sceneGuid in unloadedScenes)
+                    {
+                        if (FlaxEngine.Content.GetAssetInfo(sceneGuid, out var unloadedScene))
+                        {
+                            var splitPath = unloadedScene.Path.Split('/');
+                            var sceneName = splitPath[^1];
+                            if (splitPath[^1].EndsWith(".scene"))
+                                sceneName = sceneName[..^6];
+                            childCM.ContextMenu.AddButton(sceneName, () => { Editor.Instance.Scene.OpenScene(sceneGuid, true); });
+                        }
+                    }
+                }
+            }
+
             // Spawning actors options
 
             contextMenu.AddSeparator();
diff --git a/Source/Engine/AI/BehaviorKnowledge.cpp b/Source/Engine/AI/BehaviorKnowledge.cpp
index a73a1cfd4..fce460636 100644
--- a/Source/Engine/AI/BehaviorKnowledge.cpp
+++ b/Source/Engine/AI/BehaviorKnowledge.cpp
@@ -144,7 +144,10 @@ BehaviorKnowledge::~BehaviorKnowledge()
 
 void BehaviorKnowledge::InitMemory(BehaviorTree* tree)
 {
-    ASSERT_LOW_LAYER(!Tree && tree);
+    if (Tree)
+        FreeMemory();
+    if (!tree)
+        return;
     Tree = tree;
     Blackboard = Variant::NewValue(tree->Graph.Root->BlackboardType);
     RelevantNodes.Resize(tree->Graph.NodesCount, false);
diff --git a/Source/Engine/AI/BehaviorTreeNodes.cpp b/Source/Engine/AI/BehaviorTreeNodes.cpp
index fb49a007e..42b12d911 100644
--- a/Source/Engine/AI/BehaviorTreeNodes.cpp
+++ b/Source/Engine/AI/BehaviorTreeNodes.cpp
@@ -624,8 +624,10 @@ void BehaviorTreeLoopDecorator::PostUpdate(const BehaviorUpdateContext& context,
     if (result == BehaviorUpdateResult::Success)
     {
         auto state = GetState<State>(context.Memory);
-        state->Loops--;
-        if (state->Loops > 0)
+        if (!InfiniteLoop)
+            state->Loops--;
+
+        if (state->Loops > 0 || InfiniteLoop)
         {
             // Keep running in a loop but reset node's state (preserve self state)
             result = BehaviorUpdateResult::Running;
diff --git a/Source/Engine/AI/BehaviorTreeNodes.h b/Source/Engine/AI/BehaviorTreeNodes.h
index d72bdee04..b92f0f0d9 100644
--- a/Source/Engine/AI/BehaviorTreeNodes.h
+++ b/Source/Engine/AI/BehaviorTreeNodes.h
@@ -305,12 +305,16 @@ API_CLASS(Sealed) class FLAXENGINE_API BehaviorTreeLoopDecorator : public Behavi
     DECLARE_SCRIPTING_TYPE_WITH_CONSTRUCTOR_IMPL(BehaviorTreeLoopDecorator, BehaviorTreeDecorator);
     API_AUTO_SERIALIZATION();
 
-    // Amount of times to execute the node. Unused if LoopCountSelector is used.
-    API_FIELD(Attributes="EditorOrder(10), Limit(0)")
+    // Is the loop infinite (until failed)?
+    API_FIELD(Attributes = "EditorOrder(10)")
+    bool InfiniteLoop = false;
+
+    // Amount of times to execute the node. Unused if LoopCountSelector is used or if InfiniteLoop is used.
+    API_FIELD(Attributes="EditorOrder(20), Limit(0), VisibleIf(nameof(InfiniteLoop), true)")
     int32 LoopCount = 3;
 
-    // Amount of times to execute the node from behavior's knowledge (blackboard, goal or sensor). If set, overrides LoopCount.
-    API_FIELD(Attributes="EditorOrder(20)")
+    // Amount of times to execute the node from behavior's knowledge (blackboard, goal or sensor). If set, overrides LoopCount. Unused if InfiniteLoop is used.
+    API_FIELD(Attributes="EditorOrder(30), VisibleIf(nameof(InfiniteLoop), true)")
     BehaviorKnowledgeSelector<int32> LoopCountSelector;
 
 public:
diff --git a/Source/Engine/Animations/AnimEvent.h b/Source/Engine/Animations/AnimEvent.h
index 4ed7eab48..6cf54459f 100644
--- a/Source/Engine/Animations/AnimEvent.h
+++ b/Source/Engine/Animations/AnimEvent.h
@@ -17,6 +17,11 @@ API_CLASS(Abstract) class FLAXENGINE_API AnimEvent : public SerializableScriptin
 {
     DECLARE_SCRIPTING_TYPE(AnimEvent);
 
+    /// <summary>
+    /// Indicates whether the event can be executed in async from a thread that updates the animated model. Otherwise, event execution will be delayed until the sync point of the animated model and called from the main thread. Async events need to precisely handle data access, especially when it comes to editing scene objects with multi-threading.
+    /// </summary>
+    API_FIELD(Attributes="HideInEditor, NoSerialize") bool Async = false;
+
 #if USE_EDITOR
     /// <summary>
     /// Event display color in the Editor.
diff --git a/Source/Engine/Animations/AnimationData.h b/Source/Engine/Animations/AnimationData.h
index e382ef6e3..c69de8afa 100644
--- a/Source/Engine/Animations/AnimationData.h
+++ b/Source/Engine/Animations/AnimationData.h
@@ -98,7 +98,6 @@ public:
 /// </summary>
 struct AnimationData
 {
-public:
     /// <summary>
     /// The duration of the animation (in frames).
     /// </summary>
@@ -114,6 +113,11 @@ public:
     /// </summary>
     bool EnableRootMotion = false;
 
+    /// <summary>
+    /// The animation name.
+    /// </summary>
+    String Name;
+
     /// <summary>
     /// The custom node name to be used as a root motion source. If not specified the actual root node will be used.
     /// </summary>
@@ -131,14 +135,14 @@ public:
     FORCE_INLINE float GetLength() const
     {
 #if BUILD_DEBUG
-        ASSERT(FramesPerSecond != 0);
+        ASSERT(FramesPerSecond > ZeroTolerance);
 #endif
         return static_cast<float>(Duration / FramesPerSecond);
     }
 
     uint64 GetMemoryUsage() const
     {
-        uint64 result = RootNodeName.Length() * sizeof(Char) + Channels.Capacity() * sizeof(NodeAnimationData);
+        uint64 result = (Name.Length() + RootNodeName.Length()) * sizeof(Char) + Channels.Capacity() * sizeof(NodeAnimationData);
         for (const auto& e : Channels)
             result += e.GetMemoryUsage();
         return result;
@@ -151,9 +155,7 @@ public:
     {
         int32 result = 0;
         for (int32 i = 0; i < Channels.Count(); i++)
-        {
             result += Channels[i].GetKeyframesCount();
-        }
         return result;
     }
 
@@ -166,6 +168,7 @@ public:
         ::Swap(Duration, other.Duration);
         ::Swap(FramesPerSecond, other.FramesPerSecond);
         ::Swap(EnableRootMotion, other.EnableRootMotion);
+        ::Swap(Name, other.Name);
         ::Swap(RootNodeName, other.RootNodeName);
         Channels.Swap(other.Channels);
     }
@@ -175,6 +178,7 @@ public:
     /// </summary>
     void Dispose()
     {
+        Name.Clear();
         Duration = 0.0;
         FramesPerSecond = 0.0;
         RootNodeName.Clear();
diff --git a/Source/Engine/Animations/Animations.cpp b/Source/Engine/Animations/Animations.cpp
index 6599bebac..e571af162 100644
--- a/Source/Engine/Animations/Animations.cpp
+++ b/Source/Engine/Animations/Animations.cpp
@@ -146,6 +146,7 @@ void AnimationsSystem::PostExecute(TaskGraph* graph)
         auto animatedModel = AnimationManagerInstance.UpdateList[index];
         if (CanUpdateModel(animatedModel))
         {
+            animatedModel->GraphInstance.InvokeAnimEvents();
             animatedModel->OnAnimationUpdated_Sync();
         }
     }
diff --git a/Source/Engine/Animations/Graph/AnimGraph.cpp b/Source/Engine/Animations/Graph/AnimGraph.cpp
index 71c9534e0..5aa720d31 100644
--- a/Source/Engine/Animations/Graph/AnimGraph.cpp
+++ b/Source/Engine/Animations/Graph/AnimGraph.cpp
@@ -38,22 +38,16 @@ void AnimGraphImpulse::SetNodeModelTransformation(SkeletonData& skeleton, int32
 
 void AnimGraphInstanceData::Clear()
 {
-    Version = 0;
-    LastUpdateTime = -1;
-    CurrentFrame = 0;
-    RootTransform = Transform::Identity;
-    RootMotion = Transform::Identity;
+    ClearState();
     Parameters.Resize(0);
-    State.Resize(0);
-    NodesPose.Resize(0);
-    Slots.Resize(0);
-    for (const auto& e : Events)
-        ((AnimContinuousEvent*)e.Instance)->OnEnd((AnimatedModel*)Object, e.Anim, 0.0f, 0.0f);
-    Events.Resize(0);
 }
 
 void AnimGraphInstanceData::ClearState()
 {
+    for (const auto& e : ActiveEvents)
+        OutgoingEvents.Add(e.End((AnimatedModel*)Object));
+    ActiveEvents.Clear();
+    InvokeAnimEvents();
     Version = 0;
     LastUpdateTime = -1;
     CurrentFrame = 0;
@@ -62,9 +56,6 @@ void AnimGraphInstanceData::ClearState()
     State.Resize(0);
     NodesPose.Resize(0);
     Slots.Clear();
-    for (const auto& e : Events)
-        ((AnimContinuousEvent*)e.Instance)->OnEnd((AnimatedModel*)Object, e.Anim, 0.0f, 0.0f);
-    Events.Clear();
 }
 
 void AnimGraphInstanceData::Invalidate()
@@ -73,6 +64,43 @@ void AnimGraphInstanceData::Invalidate()
     CurrentFrame = 0;
 }
 
+void AnimGraphInstanceData::InvokeAnimEvents()
+{
+    const bool all = IsInMainThread();
+    for (int32 i = 0; i < OutgoingEvents.Count(); i++)
+    {
+        const OutgoingEvent e = OutgoingEvents[i];
+        if (all || e.Instance->Async)
+        {
+            OutgoingEvents.RemoveAtKeepOrder(i);
+            switch (e.Type)
+            {
+            case OutgoingEvent::OnEvent:
+                e.Instance->OnEvent(e.Actor, e.Anim, e.Time, e.DeltaTime);
+                break;
+            case OutgoingEvent::OnBegin:
+                ((AnimContinuousEvent*)e.Instance)->OnBegin(e.Actor, e.Anim, e.Time, e.DeltaTime);
+                break;
+            case OutgoingEvent::OnEnd:
+                ((AnimContinuousEvent*)e.Instance)->OnEnd(e.Actor, e.Anim, e.Time, e.DeltaTime);
+                break;
+            }
+        }
+    }
+}
+
+AnimGraphInstanceData::OutgoingEvent AnimGraphInstanceData::ActiveEvent::End(AnimatedModel* actor) const
+{
+    OutgoingEvent out;
+    out.Instance = Instance;
+    out.Actor = actor;
+    out.Anim = Anim;
+    out.Time = 0.0f;
+    out.DeltaTime = 0.0f;
+    out.Type = OutgoingEvent::OnEnd;
+    return out;
+}
+
 AnimGraphImpulse* AnimGraphNode::GetNodes(AnimGraphExecutor* executor)
 {
     auto& context = AnimGraphExecutor::Context.Get();
@@ -208,7 +236,7 @@ void AnimGraphExecutor::Update(AnimGraphInstanceData& data, float dt)
             // Initialize buckets
             ResetBuckets(context, &_graph);
         }
-        for (auto& e : data.Events)
+        for (auto& e : data.ActiveEvents)
             e.Hit = false;
 
         // Init empty nodes data
@@ -240,16 +268,17 @@ void AnimGraphExecutor::Update(AnimGraphInstanceData& data, float dt)
         if (animResult == nullptr)
             animResult = GetEmptyNodes();
     }
-    if (data.Events.Count() != 0)
+    if (data.ActiveEvents.Count() != 0)
     {
         ANIM_GRAPH_PROFILE_EVENT("Events");
-        for (int32 i = data.Events.Count() - 1; i >= 0; i--)
+        for (int32 i = data.ActiveEvents.Count() - 1; i >= 0; i--)
         {
-            const auto& e = data.Events[i];
+            const auto& e = data.ActiveEvents[i];
             if (!e.Hit)
             {
-                ((AnimContinuousEvent*)e.Instance)->OnEnd((AnimatedModel*)context.Data->Object, e.Anim, 0.0f, 0.0f);
-                data.Events.RemoveAt(i);
+                // Remove active event that was not hit during this frame (eg. animation using it was not used in blending)
+                data.OutgoingEvents.Add(e.End((AnimatedModel*)context.Data->Object));
+                data.ActiveEvents.RemoveAt(i);
             }
         }
     }
@@ -284,7 +313,6 @@ void AnimGraphExecutor::Update(AnimGraphInstanceData& data, float dt)
                     RetargetSkeletonNode(sourceSkeleton, targetSkeleton, mapping, node, i);
                     targetNodes[i] = node;
                 }
-
             }
         }
 
@@ -319,6 +347,9 @@ void AnimGraphExecutor::Update(AnimGraphInstanceData& data, float dt)
         data.RootMotion = animResult->RootMotion;
     }
 
+    // Invoke any async anim events
+    context.Data->InvokeAnimEvents();
+
     // Cleanup
     context.Data = nullptr;
 }
diff --git a/Source/Engine/Animations/Graph/AnimGraph.h b/Source/Engine/Animations/Graph/AnimGraph.h
index 41edb72f3..afaa4441b 100644
--- a/Source/Engine/Animations/Graph/AnimGraph.h
+++ b/Source/Engine/Animations/Graph/AnimGraph.h
@@ -23,6 +23,9 @@ class AnimSubGraph;
 class AnimGraphBase;
 class AnimGraphNode;
 class AnimGraphExecutor;
+class AnimatedModel;
+class AnimEvent;
+class AnimContinuousEvent;
 class SkinnedModel;
 class SkeletonData;
 
@@ -349,16 +352,40 @@ public:
     /// </summary>
     void Invalidate();
 
+    /// <summary>
+    /// Invokes any outgoing AnimEvent and AnimContinuousEvent collected during the last animation update. When called from non-main thread only Async events will be invoked.
+    /// </summary>
+    void InvokeAnimEvents();
+
 private:
-    struct Event
+    struct OutgoingEvent
     {
+        enum Types
+        {
+            OnEvent,
+            OnBegin,
+            OnEnd,
+        };
+
         AnimEvent* Instance;
+        AnimatedModel* Actor;
+        Animation* Anim;
+        float Time, DeltaTime;
+        Types Type;
+    };
+
+    struct ActiveEvent
+    {
+        AnimContinuousEvent* Instance;
         Animation* Anim;
         AnimGraphNode* Node;
         bool Hit;
+
+        OutgoingEvent End(AnimatedModel* actor) const;
     };
 
-    Array<Event, InlinedAllocation<8>> Events;
+    Array<ActiveEvent, InlinedAllocation<8>> ActiveEvents;
+    Array<OutgoingEvent, InlinedAllocation<8>> OutgoingEvents;
 };
 
 /// <summary>
@@ -441,7 +468,7 @@ public:
         /// The invalid transition valid used in Transitions to indicate invalid transition linkage.
         /// </summary>
         const static uint16 InvalidTransitionIndex = MAX_uint16;
-        
+
         /// <summary>
         /// The outgoing transitions from this state to the other states. Each array item contains index of the transition data from the state node graph transitions cache. Value InvalidTransitionIndex is used for last transition to indicate the transitions amount.
         /// </summary>
diff --git a/Source/Engine/Animations/Graph/AnimGroup.Animation.cpp b/Source/Engine/Animations/Graph/AnimGroup.Animation.cpp
index 6f0d7661b..8a7751ecb 100644
--- a/Source/Engine/Animations/Graph/AnimGroup.Animation.cpp
+++ b/Source/Engine/Animations/Graph/AnimGroup.Animation.cpp
@@ -100,48 +100,50 @@ void AnimGraphExecutor::ProcessAnimEvents(AnimGraphNode* node, bool loop, float
             if (!k.Value.Instance)
                 continue;
             const float duration = k.Value.Duration > 1 ? k.Value.Duration : 0.0f;
+#define ADD_OUTGOING_EVENT(type) context.Data->OutgoingEvents.Add({ k.Value.Instance, (AnimatedModel*)context.Data->Object, anim, eventTime, eventDeltaTime, AnimGraphInstanceData::OutgoingEvent::type })
             if (k.Time <= eventTimeMax && eventTimeMin <= k.Time + duration)
             {
                 int32 stateIndex = -1;
                 if (duration > 1)
                 {
                     // Begin for continuous event
-                    for (stateIndex = 0; stateIndex < context.Data->Events.Count(); stateIndex++)
+                    for (stateIndex = 0; stateIndex < context.Data->ActiveEvents.Count(); stateIndex++)
                     {
-                        const auto& e = context.Data->Events[stateIndex];
+                        const auto& e = context.Data->ActiveEvents[stateIndex];
                         if (e.Instance == k.Value.Instance && e.Node == node)
                             break;
                     }
-                    if (stateIndex == context.Data->Events.Count())
+                    if (stateIndex == context.Data->ActiveEvents.Count())
                     {
-                        auto& e = context.Data->Events.AddOne();
-                        e.Instance = k.Value.Instance;
+                        ASSERT(k.Value.Instance->Is<AnimContinuousEvent>());
+                        auto& e = context.Data->ActiveEvents.AddOne();
+                        e.Instance = (AnimContinuousEvent*)k.Value.Instance;
                         e.Anim = anim;
                         e.Node = node;
-                        ASSERT(k.Value.Instance->Is<AnimContinuousEvent>());
-                        ((AnimContinuousEvent*)k.Value.Instance)->OnBegin((AnimatedModel*)context.Data->Object, anim, eventTime, eventDeltaTime);
+                        ADD_OUTGOING_EVENT(OnBegin);
                     }
                 }
 
                 // Event
-                k.Value.Instance->OnEvent((AnimatedModel*)context.Data->Object, anim, eventTime, eventDeltaTime);
+                ADD_OUTGOING_EVENT(OnEvent);
                 if (stateIndex != -1)
-                    context.Data->Events[stateIndex].Hit = true;
+                    context.Data->ActiveEvents[stateIndex].Hit = true;
             }
             else if (duration > 1)
             {
                 // End for continuous event
-                for (int32 i = 0; i < context.Data->Events.Count(); i++)
+                for (int32 i = 0; i < context.Data->ActiveEvents.Count(); i++)
                 {
-                    const auto& e = context.Data->Events[i];
+                    const auto& e = context.Data->ActiveEvents[i];
                     if (e.Instance == k.Value.Instance && e.Node == node)
                     {
-                        ((AnimContinuousEvent*)k.Value.Instance)->OnEnd((AnimatedModel*)context.Data->Object, anim, eventTime, eventDeltaTime);
-                        context.Data->Events.RemoveAt(i);
+                        ADD_OUTGOING_EVENT(OnEnd);
+                        context.Data->ActiveEvents.RemoveAt(i);
                         break;
                     }
                 }
             }
+#undef ADD_OUTGOING_EVENT
         }
     }
 }
@@ -1068,20 +1070,26 @@ void AnimGraphExecutor::ProcessGroupAnimation(Box* boxBase, Node* nodeBase, Valu
             else
             {
                 const auto nodes = node->GetNodes(this);
-                const auto nodesA = static_cast<AnimGraphImpulse*>(valueA.AsPointer);
-                const auto nodesB = static_cast<AnimGraphImpulse*>(valueB.AsPointer);
-                Transform t, tA, tB;
+                const auto basePoseNodes = static_cast<AnimGraphImpulse*>(valueA.AsPointer);
+                const auto blendPoseNodes = static_cast<AnimGraphImpulse*>(valueB.AsPointer);
+                const auto& refrenceNodes = _graph.BaseModel.Get()->GetNodes();
+                Transform t, basePoseTransform, blendPoseTransform, refrenceTransform;
                 for (int32 i = 0; i < nodes->Nodes.Count(); i++)
                 {
-                    tA = nodesA->Nodes[i];
-                    tB = nodesB->Nodes[i];
-                    t.Translation = tA.Translation + tB.Translation;
-                    t.Orientation = tA.Orientation * tB.Orientation;
-                    t.Scale = tA.Scale * tB.Scale;
-                    t.Orientation.Normalize();
-                    Transform::Lerp(tA, t, alpha, nodes->Nodes[i]);
+                    basePoseTransform = basePoseNodes->Nodes[i];
+                    blendPoseTransform = blendPoseNodes->Nodes[i];
+                    refrenceTransform = refrenceNodes[i].LocalTransform;
+
+                    // base + (blend - refrence) = transform
+                    t.Translation = basePoseTransform.Translation + (blendPoseTransform.Translation - refrenceTransform.Translation);
+                    auto diff = Quaternion::Invert(refrenceTransform.Orientation) * blendPoseTransform.Orientation;
+                    t.Orientation = basePoseTransform.Orientation * diff;
+                    t.Scale = basePoseTransform.Scale + (blendPoseTransform.Scale - refrenceTransform.Scale);
+
+                    //lerp base and transform
+                    Transform::Lerp(basePoseTransform, t, alpha, nodes->Nodes[i]);
                 }
-                Transform::Lerp(nodesA->RootMotion, nodesA->RootMotion + nodesB->RootMotion, alpha, nodes->RootMotion);
+                Transform::Lerp(basePoseNodes->RootMotion, basePoseNodes->RootMotion + blendPoseNodes->RootMotion, alpha, nodes->RootMotion);
                 value = nodes;
             }
         }
diff --git a/Source/Engine/Content/Asset.cpp b/Source/Engine/Content/Asset.cpp
index 93d904d5e..de710cb7d 100644
--- a/Source/Engine/Content/Asset.cpp
+++ b/Source/Engine/Content/Asset.cpp
@@ -310,6 +310,10 @@ void Asset::ChangeID(const Guid& newId)
     if (!IsVirtual())
         CRASH;
 
+    // ID has to be unique
+    if (Content::GetAsset(newId) != nullptr)
+        CRASH;
+
     const Guid oldId = _id;
     ManagedScriptingObject::ChangeID(newId);
     Content::onAssetChangeId(this, oldId, newId);
@@ -438,12 +442,15 @@ bool Asset::WaitForLoaded(double timeoutInMilliseconds) const
         // Note: to reproduce this case just include material into material (use layering).
         // So during loading first material it will wait for child materials loaded calling this function
 
+        const double timeoutInSeconds = timeoutInMilliseconds * 0.001;
+        const double startTime = Platform::GetTimeSeconds();
         Task* task = loadingTask;
         Array<ContentLoadTask*, InlinedAllocation<64>> localQueue;
-        while (!Engine::ShouldExit())
+#define CHECK_CONDITIONS() (!Engine::ShouldExit() && (timeoutInSeconds <= 0.0 || Platform::GetTimeSeconds() - startTime < timeoutInSeconds))
+        do
         {
             // Try to execute content tasks
-            while (task->IsQueued() && !Engine::ShouldExit())
+            while (task->IsQueued() && CHECK_CONDITIONS())
             {
                 // Dequeue task from the loading queue
                 ContentLoadTask* tmp;
@@ -494,7 +501,8 @@ bool Asset::WaitForLoaded(double timeoutInMilliseconds) const
                     break;
                 }
             }
-        }
+        } while (CHECK_CONDITIONS());
+#undef CHECK_CONDITIONS
     }
     else
     {
diff --git a/Source/Engine/Content/Assets/Model.cpp b/Source/Engine/Content/Assets/Model.cpp
index 691b00a50..4eee62126 100644
--- a/Source/Engine/Content/Assets/Model.cpp
+++ b/Source/Engine/Content/Assets/Model.cpp
@@ -34,7 +34,6 @@
 #define CHECK_INVALID_BUFFER(model, buffer) \
     if (buffer->IsValidFor(model) == false) \
 	{ \
-		LOG(Warning, "Invalid Model Instance Buffer size {0} for Model {1}. It should be {2}. Manual update to proper size.", buffer->Count(), model->ToString(), model->MaterialSlots.Count()); \
 		buffer->Setup(model); \
 	}
 
diff --git a/Source/Engine/Content/Assets/SkinnedModel.cpp b/Source/Engine/Content/Assets/SkinnedModel.cpp
index b823db5a3..5e94eac49 100644
--- a/Source/Engine/Content/Assets/SkinnedModel.cpp
+++ b/Source/Engine/Content/Assets/SkinnedModel.cpp
@@ -23,7 +23,6 @@
 #define CHECK_INVALID_BUFFER(model, buffer) \
     if (buffer->IsValidFor(model) == false) \
 	{ \
-		LOG(Warning, "Invalid Skinned Model Instance Buffer size {0} for Skinned Model {1}. It should be {2}. Manual update to proper size.", buffer->Count(), model->ToString(), model->MaterialSlots.Count()); \
 		buffer->Setup(model); \
 	}
 
diff --git a/Source/Engine/Content/Assets/VisualScript.cpp b/Source/Engine/Content/Assets/VisualScript.cpp
index 9748ba60c..320116d60 100644
--- a/Source/Engine/Content/Assets/VisualScript.cpp
+++ b/Source/Engine/Content/Assets/VisualScript.cpp
@@ -892,6 +892,11 @@ void VisualScriptExecutor::ProcessGroupFunction(Box* boxBase, Node* node, Value&
             PrintStack(LogType::Error);
             break;
         }
+        if (boxBase->ID == 1)
+        {
+            value = instance;
+            break;
+        }
         // TODO: check if instance is of event type (including inheritance)
 
         // Add Visual Script method to the event bindings table
diff --git a/Source/Engine/Content/Content.cpp b/Source/Engine/Content/Content.cpp
index 982ae599f..897817850 100644
--- a/Source/Engine/Content/Content.cpp
+++ b/Source/Engine/Content/Content.cpp
@@ -230,6 +230,7 @@ bool Content::GetAssetInfo(const Guid& id, AssetInfo& info)
     // Find asset in registry
     if (Cache.FindAsset(id, info))
         return true;
+    PROFILE_CPU();
 
     // Locking injects some stalls but we need to make it safe (only one thread can pass though it at once)
     ScopeLock lock(WorkspaceDiscoveryLocker);
@@ -276,6 +277,7 @@ bool Content::GetAssetInfo(const StringView& path, AssetInfo& info)
     // Find asset in registry
     if (Cache.FindAsset(path, info))
         return true;
+    PROFILE_CPU();
 
     const auto extension = FileSystem::GetExtension(path).ToLower();
 
@@ -538,6 +540,8 @@ void Content::DeleteAsset(Asset* asset)
 
 void Content::DeleteAsset(const StringView& path)
 {
+    PROFILE_CPU();
+
     // Try to delete already loaded asset
     Asset* asset = GetAsset(path);
     if (asset != nullptr)
@@ -566,12 +570,12 @@ void Content::DeleteAsset(const StringView& path)
 
 void Content::deleteFileSafety(const StringView& path, const Guid& id)
 {
-    // Check if given id is invalid
     if (!id.IsValid())
     {
         LOG(Warning, "Cannot remove file \'{0}\'. Given ID is invalid.", path);
         return;
     }
+    PROFILE_CPU();
 
     // Ensure that file has the same ID (prevent from deleting different assets)
     auto storage = ContentStorageManager::TryGetStorage(path);
@@ -678,6 +682,7 @@ bool Content::FastTmpAssetClone(const StringView& path, String& resultPath)
 
 bool Content::CloneAssetFile(const StringView& dstPath, const StringView& srcPath, const Guid& dstId)
 {
+    PROFILE_CPU();
     ASSERT(FileSystem::AreFilePathsEqual(srcPath, dstPath) == false && dstId.IsValid());
 
     LOG(Info, "Cloning asset \'{0}\' to \'{1}\'({2}).", srcPath, dstPath, dstId);
@@ -796,6 +801,7 @@ Asset* Content::CreateVirtualAsset(MClass* type)
 
 Asset* Content::CreateVirtualAsset(const ScriptingTypeHandle& type)
 {
+    PROFILE_CPU();
     auto& assetType = type.GetType();
 
     // Init mock asset info
diff --git a/Source/Engine/Content/Storage/FlaxStorage.cpp b/Source/Engine/Content/Storage/FlaxStorage.cpp
index a47e0bd0e..9d4691be1 100644
--- a/Source/Engine/Content/Storage/FlaxStorage.cpp
+++ b/Source/Engine/Content/Storage/FlaxStorage.cpp
@@ -562,6 +562,7 @@ bool FlaxStorage::Reload()
 {
     if (!IsLoaded())
         return false;
+    PROFILE_CPU();
 
     OnReloading(this);
 
@@ -728,7 +729,11 @@ bool FlaxStorage::ChangeAssetID(Entry& e, const Guid& newId)
     }
 
     // Close file
-    CloseFileHandles();
+    if (CloseFileHandles())
+    {
+        LOG(Error, "Cannot close file access for '{}'", _path);
+        return true;
+    }
 
     // Change ID
     // TODO: here we could extend it and load assets from the storage and call asset ID change event to change references
@@ -776,6 +781,8 @@ FlaxChunk* FlaxStorage::AllocateChunk()
 
 bool FlaxStorage::Create(const StringView& path, const AssetInitData* data, int32 dataCount, bool silentMode, const CustomData* customData)
 {
+    PROFILE_CPU();
+    ZoneText(*path, path.Length());
     LOG(Info, "Creating package at \'{0}\'. Silent Mode: {1}", path, silentMode);
 
     // Prepare to have access to the file
@@ -1296,8 +1303,10 @@ FileReadStream* FlaxStorage::OpenFile()
     return stream;
 }
 
-void FlaxStorage::CloseFileHandles()
+bool FlaxStorage::CloseFileHandles()
 {
+    PROFILE_CPU();
+
     // Note: this is usually called by the content manager when this file is not used or on exit
     // In those situations all the async tasks using this storage should be cancelled externally
 
@@ -1323,10 +1332,12 @@ void FlaxStorage::CloseFileHandles()
     waitTime = 100;
     while (Platform::AtomicRead(&_chunksLock) != 0 && waitTime-- > 0)
         Platform::Sleep(1);
-    ASSERT(_chunksLock == 0);
+    if (Platform::AtomicRead(&_chunksLock) != 0)
+        return true; // Failed, someone is still accessing the file
 
     // Close file handles (from all threads)
     _file.DeleteAll();
+    return false;
 }
 
 void FlaxStorage::Dispose()
@@ -1335,7 +1346,10 @@ void FlaxStorage::Dispose()
         return;
 
     // Close file
-    CloseFileHandles();
+    if (CloseFileHandles())
+    {
+        LOG(Error, "Cannot close file access for '{}'", _path);
+    }
 
     // Release data
     _chunks.ClearDelete();
diff --git a/Source/Engine/Content/Storage/FlaxStorage.h b/Source/Engine/Content/Storage/FlaxStorage.h
index 85c9db072..77c912c5a 100644
--- a/Source/Engine/Content/Storage/FlaxStorage.h
+++ b/Source/Engine/Content/Storage/FlaxStorage.h
@@ -405,7 +405,7 @@ public:
     /// <summary>
     /// Closes the file handles (it can be modified from the outside).
     /// </summary>
-    void CloseFileHandles();
+    bool CloseFileHandles();
 
     /// <summary>
 	/// Releases storage resources and closes handle to the file.
diff --git a/Source/Engine/ContentImporters/AssetsImportingManager.cpp b/Source/Engine/ContentImporters/AssetsImportingManager.cpp
index cb366ffb3..a0b28f4f8 100644
--- a/Source/Engine/ContentImporters/AssetsImportingManager.cpp
+++ b/Source/Engine/ContentImporters/AssetsImportingManager.cpp
@@ -15,7 +15,7 @@
 #include "Engine/Platform/Platform.h"
 #include "Engine/Engine/Globals.h"
 #include "ImportTexture.h"
-#include "ImportModelFile.h"
+#include "ImportModel.h"
 #include "ImportAudio.h"
 #include "ImportShader.h"
 #include "ImportFont.h"
@@ -165,20 +165,7 @@ bool CreateAssetContext::AllocateChunk(int32 index)
 void CreateAssetContext::AddMeta(JsonWriter& writer) const
 {
     writer.JKEY("ImportPath");
-    if (AssetsImportingManager::UseImportPathRelative && !FileSystem::IsRelative(InputPath)
-#if PLATFORM_WINDOWS
-        // Import path from other drive should be stored as absolute on Windows to prevent issues
-        && InputPath.Length() > 2 && Globals::ProjectFolder.Length() > 2 && InputPath[0] == Globals::ProjectFolder[0]
-#endif
-    )
-    {
-        const String relativePath = FileSystem::ConvertAbsolutePathToRelative(Globals::ProjectFolder, InputPath);
-        writer.String(relativePath);
-    }
-    else
-    {
-        writer.String(InputPath);
-    }
+    writer.String(AssetsImportingManager::GetImportPath(InputPath));
     writer.JKEY("ImportUsername");
     writer.String(Platform::GetUserName());
 }
@@ -189,7 +176,12 @@ void CreateAssetContext::ApplyChanges()
     auto storage = ContentStorageManager::TryGetStorage(TargetAssetPath);
     if (storage && storage->IsLoaded())
     {
-        storage->CloseFileHandles();
+        if (storage->CloseFileHandles())
+        {
+            LOG(Error, "Cannot close file access for '{}'", TargetAssetPath);
+            _applyChangesResult = CreateAssetResult::CannotSaveFile;
+            return;
+        }
     }
 
     // Move file
@@ -304,8 +296,24 @@ bool AssetsImportingManager::ImportIfEdited(const StringView& inputPath, const S
     return false;
 }
 
+String AssetsImportingManager::GetImportPath(const String& path)
+{
+    if (UseImportPathRelative && !FileSystem::IsRelative(path)
+#if PLATFORM_WINDOWS
+        // Import path from other drive should be stored as absolute on Windows to prevent issues
+        && path.Length() > 2 && Globals::ProjectFolder.Length() > 2 && path[0] == Globals::ProjectFolder[0]
+#endif
+    )
+    {
+        return FileSystem::ConvertAbsolutePathToRelative(Globals::ProjectFolder, path);
+    }
+    return path;
+}
+
 bool AssetsImportingManager::Create(const Function<CreateAssetResult(CreateAssetContext&)>& callback, const StringView& inputPath, const StringView& outputPath, Guid& assetId, void* arg)
 {
+    PROFILE_CPU();
+    ZoneText(*outputPath, outputPath.Length());
     const auto startTime = Platform::GetTimeSeconds();
 
     // Pick ID if not specified
@@ -369,7 +377,7 @@ bool AssetsImportingManager::Create(const Function<CreateAssetResult(CreateAsset
     if (result == CreateAssetResult::Ok)
     {
         // Register asset
-        Content::GetRegistry()->RegisterAsset(context.Data.Header, outputPath);
+        Content::GetRegistry()->RegisterAsset(context.Data.Header, context.TargetAssetPath);
 
         // Done
         const auto endTime = Platform::GetTimeSeconds();
@@ -380,7 +388,7 @@ bool AssetsImportingManager::Create(const Function<CreateAssetResult(CreateAsset
         // Do nothing
         return true;
     }
-    else
+    else if (result != CreateAssetResult::Skip)
     {
         LOG(Error, "Cannot import file '{0}'! Result: {1}", inputPath, ::ToString(result));
         return true;
@@ -425,37 +433,37 @@ bool AssetsImportingManagerService::Init()
         { TEXT("otf"), ASSET_FILES_EXTENSION, ImportFont::Import },
 
         // Models
-        { TEXT("obj"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("fbx"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("x"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("dae"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("gltf"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("glb"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
+        { TEXT("obj"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("fbx"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("x"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("dae"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("gltf"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("glb"), ASSET_FILES_EXTENSION, ImportModel::Import },
 
         // gettext PO files
         { TEXT("po"), TEXT("json"), CreateJson::ImportPo },
 
         // Models (untested formats - may fail :/)
-        { TEXT("blend"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("bvh"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("ase"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("ply"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("dxf"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("ifc"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("nff"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("smd"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("vta"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("mdl"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("md2"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("md3"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("md5mesh"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("q3o"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("q3s"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("ac"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("stl"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("lwo"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("lws"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
-        { TEXT("lxo"), ASSET_FILES_EXTENSION, ImportModelFile::Import },
+        { TEXT("blend"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("bvh"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("ase"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("ply"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("dxf"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("ifc"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("nff"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("smd"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("vta"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("mdl"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("md2"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("md3"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("md5mesh"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("q3o"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("q3s"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("ac"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("stl"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("lwo"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("lws"), ASSET_FILES_EXTENSION, ImportModel::Import },
+        { TEXT("lxo"), ASSET_FILES_EXTENSION, ImportModel::Import },
     };
     AssetsImportingManager::Importers.Add(InBuildImporters, ARRAY_COUNT(InBuildImporters));
 
@@ -473,7 +481,7 @@ bool AssetsImportingManagerService::Init()
         { AssetsImportingManager::CreateMaterialInstanceTag, CreateMaterialInstance::Create },
 
         // Models
-        { AssetsImportingManager::CreateModelTag, ImportModelFile::Create },
+        { AssetsImportingManager::CreateModelTag, ImportModel::Create },
 
         // Other
         { AssetsImportingManager::CreateRawDataTag, CreateRawData::Create },
diff --git a/Source/Engine/ContentImporters/AssetsImportingManager.h b/Source/Engine/ContentImporters/AssetsImportingManager.h
index eb5058650..2b76298a6 100644
--- a/Source/Engine/ContentImporters/AssetsImportingManager.h
+++ b/Source/Engine/ContentImporters/AssetsImportingManager.h
@@ -236,6 +236,9 @@ public:
         return ImportIfEdited(inputPath, outputPath, id, arg);
     }
 
+    // Converts source files path into the relative format if enabled by the project settings. Result path can be stored in asset for reimports.
+    static String GetImportPath(const String& path);
+
 private:
     static bool Create(const CreateAssetFunction& callback, const StringView& inputPath, const StringView& outputPath, Guid& assetId, void* arg);
 };
diff --git a/Source/Engine/ContentImporters/CreateJson.cpp b/Source/Engine/ContentImporters/CreateJson.cpp
index 3ca21601c..96a10ab27 100644
--- a/Source/Engine/ContentImporters/CreateJson.cpp
+++ b/Source/Engine/ContentImporters/CreateJson.cpp
@@ -53,7 +53,7 @@ bool CreateJson::Create(const StringView& path, const StringAnsiView& data, cons
         {
             if (FileSystem::CreateDirectory(directory))
             {
-                LOG(Warning, "Failed to create directory");
+                LOG(Warning, "Failed to create directory '{}'", directory);
                 return true;
             }
         }
diff --git a/Source/Engine/ContentImporters/ImportModel.cpp b/Source/Engine/ContentImporters/ImportModel.cpp
new file mode 100644
index 000000000..baac1defb
--- /dev/null
+++ b/Source/Engine/ContentImporters/ImportModel.cpp
@@ -0,0 +1,743 @@
+// Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
+
+#include "ImportModel.h"
+
+#if COMPILE_WITH_ASSETS_IMPORTER
+
+#include "Engine/Core/Log.h"
+#include "Engine/Core/Collections/Sorting.h"
+#include "Engine/Core/Collections/ArrayExtensions.h"
+#include "Engine/Serialization/MemoryWriteStream.h"
+#include "Engine/Serialization/JsonWriters.h"
+#include "Engine/Graphics/Models/ModelData.h"
+#include "Engine/Content/Assets/Model.h"
+#include "Engine/Content/Assets/SkinnedModel.h"
+#include "Engine/Content/Storage/ContentStorageManager.h"
+#include "Engine/Content/Assets/Animation.h"
+#include "Engine/Content/Content.h"
+#include "Engine/Level/Actors/EmptyActor.h"
+#include "Engine/Level/Actors/StaticModel.h"
+#include "Engine/Level/Prefabs/Prefab.h"
+#include "Engine/Level/Prefabs/PrefabManager.h"
+#include "Engine/Level/Scripts/ModelPrefab.h"
+#include "Engine/Platform/FileSystem.h"
+#include "Engine/Utilities/RectPack.h"
+#include "Engine/Profiler/ProfilerCPU.h"
+#include "AssetsImportingManager.h"
+
+bool ImportModel::TryGetImportOptions(const StringView& path, Options& options)
+{
+    if (FileSystem::FileExists(path))
+    {
+        // Try to load asset file and asset info
+        auto tmpFile = ContentStorageManager::GetStorage(path);
+        AssetInitData data;
+        if (tmpFile
+            && tmpFile->GetEntriesCount() == 1
+            && (
+                (tmpFile->GetEntry(0).TypeName == Model::TypeName && !tmpFile->LoadAssetHeader(0, data) && data.SerializedVersion >= 4)
+                ||
+                (tmpFile->GetEntry(0).TypeName == SkinnedModel::TypeName && !tmpFile->LoadAssetHeader(0, data) && data.SerializedVersion >= 1)
+                ||
+                (tmpFile->GetEntry(0).TypeName == Animation::TypeName && !tmpFile->LoadAssetHeader(0, data) && data.SerializedVersion >= 1)
+            ))
+        {
+            // Check import meta
+            rapidjson_flax::Document metadata;
+            metadata.Parse((const char*)data.Metadata.Get(), data.Metadata.Length());
+            if (metadata.HasParseError() == false)
+            {
+                options.Deserialize(metadata, nullptr);
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+struct PrefabObject
+{
+    int32 NodeIndex;
+    String Name;
+    String AssetPath;
+};
+
+void RepackMeshLightmapUVs(ModelData& data)
+{
+    // Use weight-based coordinates space placement and rect-pack to allocate more space for bigger meshes in the model lightmap chart
+    int32 lodIndex = 0;
+    auto& lod = data.LODs[lodIndex];
+
+    // Build list of meshes with their area
+    struct LightmapUVsPack : RectPack<LightmapUVsPack, float>
+    {
+        LightmapUVsPack(float x, float y, float width, float height)
+            : RectPack<LightmapUVsPack, float>(x, y, width, height)
+        {
+        }
+
+        void OnInsert()
+        {
+        }
+    };
+    struct MeshEntry
+    {
+        MeshData* Mesh;
+        float Area;
+        float Size;
+        LightmapUVsPack* Slot;
+    };
+    Array<MeshEntry> entries;
+    entries.Resize(lod.Meshes.Count());
+    float areaSum = 0;
+    for (int32 meshIndex = 0; meshIndex < lod.Meshes.Count(); meshIndex++)
+    {
+        auto& entry = entries[meshIndex];
+        entry.Mesh = lod.Meshes[meshIndex];
+        entry.Area = entry.Mesh->CalculateTrianglesArea();
+        entry.Size = Math::Sqrt(entry.Area);
+        areaSum += entry.Area;
+    }
+
+    if (areaSum > ZeroTolerance)
+    {
+        // Pack all surfaces into atlas
+        float atlasSize = Math::Sqrt(areaSum) * 1.02f;
+        int32 triesLeft = 10;
+        while (triesLeft--)
+        {
+            bool failed = false;
+            const float chartsPadding = (4.0f / 256.0f) * atlasSize;
+            LightmapUVsPack root(chartsPadding, chartsPadding, atlasSize - chartsPadding, atlasSize - chartsPadding);
+            for (auto& entry : entries)
+            {
+                entry.Slot = root.Insert(entry.Size, entry.Size, chartsPadding);
+                if (entry.Slot == nullptr)
+                {
+                    // Failed to insert surface, increase atlas size and try again
+                    atlasSize *= 1.5f;
+                    failed = true;
+                    break;
+                }
+            }
+
+            if (!failed)
+            {
+                // Transform meshes lightmap UVs into the slots in the whole atlas
+                const float atlasSizeInv = 1.0f / atlasSize;
+                for (const auto& entry : entries)
+                {
+                    Float2 uvOffset(entry.Slot->X * atlasSizeInv, entry.Slot->Y * atlasSizeInv);
+                    Float2 uvScale((entry.Slot->Width - chartsPadding) * atlasSizeInv, (entry.Slot->Height - chartsPadding) * atlasSizeInv);
+                    // TODO: SIMD
+                    for (auto& uv : entry.Mesh->LightmapUVs)
+                    {
+                        uv = uv * uvScale + uvOffset;
+                    }
+                }
+                break;
+            }
+        }
+    }
+}
+
+void TryRestoreMaterials(CreateAssetContext& context, ModelData& modelData)
+{
+    // Skip if file is missing
+    if (!FileSystem::FileExists(context.TargetAssetPath))
+        return;
+
+    // Try to load asset that gets reimported
+    AssetReference<Asset> asset = Content::LoadAsync<Asset>(context.TargetAssetPath);
+    if (asset == nullptr)
+        return;
+    if (asset->WaitForLoaded())
+        return;
+
+    // Get model object
+    ModelBase* model = nullptr;
+    if (asset.Get()->GetTypeName() == Model::TypeName)
+    {
+        model = ((Model*)asset.Get());
+    }
+    else if (asset.Get()->GetTypeName() == SkinnedModel::TypeName)
+    {
+        model = ((SkinnedModel*)asset.Get());
+    }
+    if (!model)
+        return;
+
+    // Peek materials
+    for (int32 i = 0; i < modelData.Materials.Count(); i++)
+    {
+        auto& dstSlot = modelData.Materials[i];
+
+        if (model->MaterialSlots.Count() > i)
+        {
+            auto& srcSlot = model->MaterialSlots[i];
+
+            dstSlot.Name = srcSlot.Name;
+            dstSlot.ShadowsMode = srcSlot.ShadowsMode;
+            dstSlot.AssetID = srcSlot.Material.GetID();
+        }
+    }
+}
+
+void SetupMaterialSlots(ModelData& data, const Array<MaterialSlotEntry>& materials)
+{
+    Array<int32> materialSlotsTable;
+    materialSlotsTable.Resize(materials.Count());
+    materialSlotsTable.SetAll(-1);
+    for (auto& lod : data.LODs)
+    {
+        for (MeshData* mesh : lod.Meshes)
+        {
+            int32 newSlotIndex = materialSlotsTable[mesh->MaterialSlotIndex];
+            if (newSlotIndex == -1)
+            {
+                newSlotIndex = data.Materials.Count();
+                data.Materials.AddOne() = materials[mesh->MaterialSlotIndex];
+            }
+            mesh->MaterialSlotIndex = newSlotIndex;
+        }
+    }
+}
+
+bool SortMeshGroups(IGrouping<StringView, MeshData*> const& i1, IGrouping<StringView, MeshData*> const& i2)
+{
+    return i1.GetKey().Compare(i2.GetKey()) < 0;
+}
+
+CreateAssetResult ImportModel::Import(CreateAssetContext& context)
+{
+    // Get import options
+    Options options;
+    if (context.CustomArg != nullptr)
+    {
+        // Copy import options from argument
+        options = *static_cast<Options*>(context.CustomArg);
+    }
+    else
+    {
+        // Restore the previous settings or use default ones
+        if (!TryGetImportOptions(context.TargetAssetPath, options))
+        {
+            LOG(Warning, "Missing model import options. Using default values.");
+        }
+    }
+
+    // Import model file
+    ModelData* data = options.Cached ? options.Cached->Data : nullptr;
+    ModelData dataThis;
+    Array<IGrouping<StringView, MeshData*>>* meshesByNamePtr = options.Cached ? (Array<IGrouping<StringView, MeshData*>>*)options.Cached->MeshesByName : nullptr;
+    Array<IGrouping<StringView, MeshData*>> meshesByNameThis;
+    String autoImportOutput;
+    if (!data)
+    {
+        String errorMsg;
+        autoImportOutput = StringUtils::GetDirectoryName(context.TargetAssetPath);
+        autoImportOutput /= options.SubAssetFolder.HasChars() ? options.SubAssetFolder.TrimTrailing() : String(StringUtils::GetFileNameWithoutExtension(context.InputPath));
+        if (ModelTool::ImportModel(context.InputPath, dataThis, options, errorMsg, autoImportOutput))
+        {
+            LOG(Error, "Cannot import model file. {0}", errorMsg);
+            return CreateAssetResult::Error;
+        }
+        data = &dataThis;
+
+        // Group meshes by the name (the same mesh name can be used by multiple meshes that use different materials)
+        if (data->LODs.Count() != 0)
+        {
+            const Function<StringView(MeshData* const&)> f = [](MeshData* const& x) -> StringView
+            {
+                return x->Name;
+            };
+            ArrayExtensions::GroupBy(data->LODs[0].Meshes, f, meshesByNameThis);
+            Sorting::QuickSort(meshesByNameThis.Get(), meshesByNameThis.Count(), &SortMeshGroups);
+        }
+        meshesByNamePtr = &meshesByNameThis;
+    }
+    Array<IGrouping<StringView, MeshData*>>& meshesByName = *meshesByNamePtr;
+
+    // Import objects from file separately
+    ModelTool::Options::CachedData cached = { data, (void*)meshesByNamePtr };
+    Array<PrefabObject> prefabObjects;
+    if (options.Type == ModelTool::ModelType::Prefab)
+    {
+        // Normalize options
+        options.SplitObjects = false;
+        options.ObjectIndex = -1;
+
+        // Import all of the objects recursive but use current model data to skip loading file again
+        options.Cached = &cached;
+        Function<bool(Options& splitOptions, const StringView& objectName, String& outputPath)> splitImport = [&context, &autoImportOutput](Options& splitOptions, const StringView& objectName, String& outputPath)
+        {
+            // Recursive importing of the split object
+            String postFix = objectName;
+            const int32 splitPos = postFix.FindLast(TEXT('|'));
+            if (splitPos != -1)
+                postFix = postFix.Substring(splitPos + 1);
+            // TODO: check for name collisions with material/texture assets
+            outputPath = autoImportOutput / String(StringUtils::GetFileNameWithoutExtension(context.TargetAssetPath)) + TEXT(" ") + postFix + TEXT(".flax");
+            splitOptions.SubAssetFolder = TEXT(" "); // Use the same folder as asset as they all are imported to the subdir for the prefab (see SubAssetFolder usage above)
+            return AssetsImportingManager::Import(context.InputPath, outputPath, &splitOptions);
+        };
+        auto splitOptions = options;
+        LOG(Info, "Splitting imported {0} meshes", meshesByName.Count());
+        PrefabObject prefabObject;
+        for (int32 groupIndex = 0; groupIndex < meshesByName.Count(); groupIndex++)
+        {
+            auto& group = meshesByName[groupIndex];
+
+            // Cache object options (nested sub-object import removes the meshes)
+            prefabObject.NodeIndex = group.First()->NodeIndex;
+            prefabObject.Name = group.First()->Name;
+
+            splitOptions.Type = ModelTool::ModelType::Model;
+            splitOptions.ObjectIndex = groupIndex;
+            if (!splitImport(splitOptions, group.GetKey(), prefabObject.AssetPath))
+            {
+                prefabObjects.Add(prefabObject);
+            }
+        }
+        LOG(Info, "Splitting imported {0} animations", data->Animations.Count());
+        for (int32 i = 0; i < data->Animations.Count(); i++)
+        {
+            auto& animation = data->Animations[i];
+            splitOptions.Type = ModelTool::ModelType::Animation;
+            splitOptions.ObjectIndex = i;
+            splitImport(splitOptions, animation.Name, prefabObject.AssetPath);
+        }
+    }
+    else if (options.SplitObjects)
+    {
+        // Import the first object within this call
+        options.SplitObjects = false;
+        options.ObjectIndex = 0;
+
+        // Import rest of the objects recursive but use current model data to skip loading file again
+        options.Cached = &cached;
+        Function<bool(Options& splitOptions, const StringView& objectName)> splitImport;
+        splitImport.Bind([&context](Options& splitOptions, const StringView& objectName)
+        {
+            // Recursive importing of the split object
+            String postFix = objectName;
+            const int32 splitPos = postFix.FindLast(TEXT('|'));
+            if (splitPos != -1)
+                postFix = postFix.Substring(splitPos + 1);
+            const String outputPath = String(StringUtils::GetPathWithoutExtension(context.TargetAssetPath)) + TEXT(" ") + postFix + TEXT(".flax");
+            return AssetsImportingManager::Import(context.InputPath, outputPath, &splitOptions);
+        });
+        auto splitOptions = options;
+        switch (options.Type)
+        {
+        case ModelTool::ModelType::Model:
+        case ModelTool::ModelType::SkinnedModel:
+            LOG(Info, "Splitting imported {0} meshes", meshesByName.Count());
+            for (int32 groupIndex = 1; groupIndex < meshesByName.Count(); groupIndex++)
+            {
+                auto& group = meshesByName[groupIndex];
+                splitOptions.ObjectIndex = groupIndex;
+                splitImport(splitOptions, group.GetKey());
+            }
+            break;
+        case ModelTool::ModelType::Animation:
+            LOG(Info, "Splitting imported {0} animations", data->Animations.Count());
+            for (int32 i = 1; i < data->Animations.Count(); i++)
+            {
+                auto& animation = data->Animations[i];
+                splitOptions.ObjectIndex = i;
+                splitImport(splitOptions, animation.Name);
+            }
+            break;
+        }
+    }
+
+    // When importing a single object as model asset then select a specific mesh group
+    Array<MeshData*> meshesToDelete;
+    if (options.ObjectIndex >= 0 &&
+        options.ObjectIndex < meshesByName.Count() &&
+        (options.Type == ModelTool::ModelType::Model || options.Type == ModelTool::ModelType::SkinnedModel))
+    {
+        auto& group = meshesByName[options.ObjectIndex];
+        if (&dataThis == data)
+        {
+            // Use meshes only from the the grouping (others will be removed manually)
+            {
+                auto& lod = dataThis.LODs[0];
+                meshesToDelete.Add(lod.Meshes);
+                lod.Meshes.Clear();
+                for (MeshData* mesh : group)
+                {
+                    lod.Meshes.Add(mesh);
+                    meshesToDelete.Remove(mesh);
+                }
+            }
+            for (int32 lodIndex = 1; lodIndex < dataThis.LODs.Count(); lodIndex++)
+            {
+                auto& lod = dataThis.LODs[lodIndex];
+                Array<MeshData*> lodMeshes = lod.Meshes;
+                lod.Meshes.Clear();
+                for (MeshData* lodMesh : lodMeshes)
+                {
+                    if (lodMesh->Name == group.GetKey())
+                        lod.Meshes.Add(lodMesh);
+                    else
+                        meshesToDelete.Add(lodMesh);
+                }
+            }
+
+            // Use only materials references by meshes from the first grouping
+            {
+                auto materials = dataThis.Materials;
+                dataThis.Materials.Clear();
+                SetupMaterialSlots(dataThis, materials);
+            }
+        }
+        else
+        {
+            // Copy data from others data
+            dataThis.Skeleton = data->Skeleton;
+            dataThis.Nodes = data->Nodes;
+
+            // Move meshes from this group (including any LODs of them)
+            {
+                auto& lod = dataThis.LODs.AddOne();
+                lod.ScreenSize = data->LODs[0].ScreenSize;
+                lod.Meshes.Add(group);
+                for (MeshData* mesh : group)
+                    data->LODs[0].Meshes.Remove(mesh);
+            }
+            for (int32 lodIndex = 1; lodIndex < data->LODs.Count(); lodIndex++)
+            {
+                Array<MeshData*> lodMeshes = data->LODs[lodIndex].Meshes;
+                for (int32 i = lodMeshes.Count() - 1; i >= 0; i--)
+                {
+                    MeshData* lodMesh = lodMeshes[i];
+                    if (lodMesh->Name == group.GetKey())
+                        data->LODs[lodIndex].Meshes.Remove(lodMesh);
+                    else
+                        lodMeshes.RemoveAtKeepOrder(i);
+                }
+                if (lodMeshes.Count() == 0)
+                    break; // No meshes of that name in this LOD so skip further ones
+                auto& lod = dataThis.LODs.AddOne();
+                lod.ScreenSize = data->LODs[lodIndex].ScreenSize;
+                lod.Meshes.Add(lodMeshes);
+            }
+
+            // Copy materials used by the meshes
+            SetupMaterialSlots(dataThis, data->Materials);
+        }
+        data = &dataThis;
+    }
+
+    // Check if restore materials on model reimport
+    if (options.RestoreMaterialsOnReimport && data->Materials.HasItems())
+    {
+        TryRestoreMaterials(context, *data);
+    }
+
+    // When using generated lightmap UVs those coordinates needs to be moved so all meshes are in unique locations in [0-1]x[0-1] coordinates space
+    // Model importer generates UVs in [0-1] space for each mesh so now we need to pack them inside the whole model (only when using multiple meshes)
+    if (options.Type == ModelTool::ModelType::Model && options.LightmapUVsSource == ModelLightmapUVsSource::Generate && data->LODs.HasItems() && data->LODs[0].Meshes.Count() > 1)
+    {
+        RepackMeshLightmapUVs(*data);
+    }
+
+    // Create destination asset type
+    CreateAssetResult result = CreateAssetResult::InvalidTypeID;
+    switch (options.Type)
+    {
+    case ModelTool::ModelType::Model:
+        result = CreateModel(context, *data, &options);
+        break;
+    case ModelTool::ModelType::SkinnedModel:
+        result = CreateSkinnedModel(context, *data, &options);
+        break;
+    case ModelTool::ModelType::Animation:
+        result = CreateAnimation(context, *data, &options);
+        break;
+    case ModelTool::ModelType::Prefab:
+        result = CreatePrefab(context, *data, options, prefabObjects);
+        break;
+    }
+    for (auto mesh : meshesToDelete)
+        Delete(mesh);
+    if (result != CreateAssetResult::Ok)
+        return result;
+
+    // Create json with import context
+    rapidjson_flax::StringBuffer importOptionsMetaBuffer;
+    importOptionsMetaBuffer.Reserve(256);
+    CompactJsonWriter importOptionsMetaObj(importOptionsMetaBuffer);
+    JsonWriter& importOptionsMeta = importOptionsMetaObj;
+    importOptionsMeta.StartObject();
+    {
+        context.AddMeta(importOptionsMeta);
+        options.Serialize(importOptionsMeta, nullptr);
+    }
+    importOptionsMeta.EndObject();
+    context.Data.Metadata.Copy((const byte*)importOptionsMetaBuffer.GetString(), (uint32)importOptionsMetaBuffer.GetSize());
+
+    return CreateAssetResult::Ok;
+}
+
+CreateAssetResult ImportModel::Create(CreateAssetContext& context)
+{
+    ASSERT(context.CustomArg != nullptr);
+    auto& modelData = *(ModelData*)context.CustomArg;
+
+    // Ensure model has any meshes
+    if ((modelData.LODs.IsEmpty() || modelData.LODs[0].Meshes.IsEmpty()))
+    {
+        LOG(Warning, "Models has no valid meshes");
+        return CreateAssetResult::Error;
+    }
+
+    // Auto calculate LODs transition settings
+    modelData.CalculateLODsScreenSizes();
+
+    return CreateModel(context, modelData);
+}
+
+CreateAssetResult ImportModel::CreateModel(CreateAssetContext& context, ModelData& modelData, const Options* options)
+{
+    PROFILE_CPU();
+    IMPORT_SETUP(Model, Model::SerializedVersion);
+
+    // Save model header
+    MemoryWriteStream stream(4096);
+    if (modelData.Pack2ModelHeader(&stream))
+        return CreateAssetResult::Error;
+    if (context.AllocateChunk(0))
+        return CreateAssetResult::CannotAllocateChunk;
+    context.Data.Header.Chunks[0]->Data.Copy(stream.GetHandle(), stream.GetPosition());
+
+    // Pack model LODs data
+    const auto lodCount = modelData.GetLODsCount();
+    for (int32 lodIndex = 0; lodIndex < lodCount; lodIndex++)
+    {
+        stream.SetPosition(0);
+
+        // Pack meshes
+        auto& meshes = modelData.LODs[lodIndex].Meshes;
+        for (int32 meshIndex = 0; meshIndex < meshes.Count(); meshIndex++)
+        {
+            if (meshes[meshIndex]->Pack2Model(&stream))
+            {
+                LOG(Warning, "Cannot pack mesh.");
+                return CreateAssetResult::Error;
+            }
+        }
+
+        const int32 chunkIndex = lodIndex + 1;
+        if (context.AllocateChunk(chunkIndex))
+            return CreateAssetResult::CannotAllocateChunk;
+        context.Data.Header.Chunks[chunkIndex]->Data.Copy(stream.GetHandle(), stream.GetPosition());
+    }
+
+    // Generate SDF
+    if (options && options->GenerateSDF)
+    {
+        stream.SetPosition(0);
+        if (!ModelTool::GenerateModelSDF(nullptr, &modelData, options->SDFResolution, lodCount - 1, nullptr, &stream, context.TargetAssetPath))
+        {
+            if (context.AllocateChunk(15))
+                return CreateAssetResult::CannotAllocateChunk;
+            context.Data.Header.Chunks[15]->Data.Copy(stream.GetHandle(), stream.GetPosition());
+        }
+    }
+
+    return CreateAssetResult::Ok;
+}
+
+CreateAssetResult ImportModel::CreateSkinnedModel(CreateAssetContext& context, ModelData& modelData, const Options* options)
+{
+    PROFILE_CPU();
+    IMPORT_SETUP(SkinnedModel, SkinnedModel::SerializedVersion);
+
+    // Save skinned model header
+    MemoryWriteStream stream(4096);
+    if (modelData.Pack2SkinnedModelHeader(&stream))
+        return CreateAssetResult::Error;
+    if (context.AllocateChunk(0))
+        return CreateAssetResult::CannotAllocateChunk;
+    context.Data.Header.Chunks[0]->Data.Copy(stream.GetHandle(), stream.GetPosition());
+
+    // Pack model LODs data
+    const auto lodCount = modelData.GetLODsCount();
+    for (int32 lodIndex = 0; lodIndex < lodCount; lodIndex++)
+    {
+        stream.SetPosition(0);
+
+        // Mesh Data Version
+        stream.WriteByte(1);
+
+        // Pack meshes
+        auto& meshes = modelData.LODs[lodIndex].Meshes;
+        for (int32 meshIndex = 0; meshIndex < meshes.Count(); meshIndex++)
+        {
+            if (meshes[meshIndex]->Pack2SkinnedModel(&stream))
+            {
+                LOG(Warning, "Cannot pack mesh.");
+                return CreateAssetResult::Error;
+            }
+        }
+
+        const int32 chunkIndex = lodIndex + 1;
+        if (context.AllocateChunk(chunkIndex))
+            return CreateAssetResult::CannotAllocateChunk;
+        context.Data.Header.Chunks[chunkIndex]->Data.Copy(stream.GetHandle(), stream.GetPosition());
+    }
+
+    return CreateAssetResult::Ok;
+}
+
+CreateAssetResult ImportModel::CreateAnimation(CreateAssetContext& context, ModelData& modelData, const Options* options)
+{
+    PROFILE_CPU();
+    IMPORT_SETUP(Animation, Animation::SerializedVersion);
+
+    // Save animation data
+    MemoryWriteStream stream(8182);
+    const int32 animIndex = options && options->ObjectIndex != -1 ? options->ObjectIndex : 0; // Single animation per asset
+    if (modelData.Pack2AnimationHeader(&stream, animIndex))
+        return CreateAssetResult::Error;
+    if (context.AllocateChunk(0))
+        return CreateAssetResult::CannotAllocateChunk;
+    context.Data.Header.Chunks[0]->Data.Copy(stream.GetHandle(), stream.GetPosition());
+
+    return CreateAssetResult::Ok;
+}
+
+CreateAssetResult ImportModel::CreatePrefab(CreateAssetContext& context, ModelData& data, const Options& options, const Array<PrefabObject>& prefabObjects)
+{
+    PROFILE_CPU();
+    if (data.Nodes.Count() == 0)
+        return CreateAssetResult::Error;
+
+    // If that prefab already exists then we need to use it as base to preserve object IDs and local changes applied by user
+    const String outputPath = String(StringUtils::GetPathWithoutExtension(context.TargetAssetPath)) + DEFAULT_PREFAB_EXTENSION_DOT;
+    auto* prefab = FileSystem::FileExists(outputPath) ? Content::Load<Prefab>(outputPath) : nullptr;
+    if (prefab)
+    {
+        // Ensure that prefab has Default Instance so ObjectsCache is valid (used below)
+        prefab->GetDefaultInstance();
+    }
+
+    // Create prefab structure
+    Dictionary<int32, Actor*> nodeToActor;
+    Array<Actor*> nodeActors;
+    Actor* rootActor = nullptr;
+    for (int32 nodeIndex = 0; nodeIndex < data.Nodes.Count(); nodeIndex++)
+    {
+        const auto& node = data.Nodes[nodeIndex];
+
+        // Create actor(s) for this node
+        nodeActors.Clear();
+        for (const PrefabObject& e : prefabObjects)
+        {
+            if (e.NodeIndex == nodeIndex)
+            {
+                auto* actor = New<StaticModel>();
+                actor->SetName(e.Name);
+                if (auto* model = Content::LoadAsync<Model>(e.AssetPath))
+                {
+                    actor->Model = model;
+                }
+                nodeActors.Add(actor);
+            }
+        }
+        Actor* nodeActor = nodeActors.Count() == 1 ? nodeActors[0] : New<EmptyActor>();
+        if (nodeActors.Count() > 1)
+        {
+            for (Actor* e : nodeActors)
+            {
+                e->SetParent(nodeActor);
+            }
+        }
+        if (nodeActors.Count() != 1)
+        {
+            // Include default actor to iterate over it properly in code below
+            nodeActors.Add(nodeActor);
+        }
+
+        // Setup node in hierarchy
+        nodeToActor.Add(nodeIndex, nodeActor);
+        nodeActor->SetName(node.Name);
+        nodeActor->SetLocalTransform(node.LocalTransform);
+        if (nodeIndex == 0)
+        {
+            // Special case for root actor to link any unlinked nodes
+            nodeToActor.Add(-1, nodeActor);
+            rootActor = nodeActor;
+        }
+        else
+        {
+            Actor* parentActor;
+            if (nodeToActor.TryGet(node.ParentIndex, parentActor))
+                nodeActor->SetParent(parentActor);
+        }
+
+        // Link with object from prefab (if reimporting)
+        if (prefab)
+        {
+            for (Actor* a : nodeActors)
+            {
+                for (const auto& i : prefab->ObjectsCache)
+                {
+                    if (i.Value->GetTypeHandle() != a->GetTypeHandle()) // Type match
+                        continue;
+                    auto* o = (Actor*)i.Value;
+                    if (o->GetName() != a->GetName()) // Name match
+                        continue;
+
+                    // Mark as this object already exists in prefab so will be preserved when updating it
+                    a->LinkPrefab(o->GetPrefabID(), o->GetPrefabObjectID());
+                    break;
+                }
+            }
+        }
+    }
+    ASSERT_LOW_LAYER(rootActor);
+    {
+        // Add script with import options
+        auto* modelPrefabScript = New<ModelPrefab>();
+        modelPrefabScript->SetParent(rootActor);
+        modelPrefabScript->ImportPath = AssetsImportingManager::GetImportPath(context.InputPath);
+        modelPrefabScript->ImportOptions = options;
+
+        // Link with existing prefab instance
+        if (prefab)
+        {
+            for (const auto& i : prefab->ObjectsCache)
+            {
+                if (i.Value->GetTypeHandle() == modelPrefabScript->GetTypeHandle())
+                {
+                    modelPrefabScript->LinkPrefab(i.Value->GetPrefabID(), i.Value->GetPrefabObjectID());
+                    break;
+                }
+            }
+        }
+    }
+
+    // Create prefab instead of native asset
+    bool failed;
+    if (prefab)
+    {
+        failed = prefab->ApplyAll(rootActor);
+    }
+    else
+    {
+        failed = PrefabManager::CreatePrefab(rootActor, outputPath, false);
+    }
+
+    // Cleanup objects from memory
+    rootActor->DeleteObjectNow();
+
+    if (failed)
+        return CreateAssetResult::Error;
+    return CreateAssetResult::Skip;
+}
+
+#endif
diff --git a/Source/Engine/ContentImporters/ImportModel.h b/Source/Engine/ContentImporters/ImportModel.h
index 02e6bfc8d..710971fca 100644
--- a/Source/Engine/ContentImporters/ImportModel.h
+++ b/Source/Engine/ContentImporters/ImportModel.h
@@ -8,15 +8,10 @@
 
 #include "Engine/Tools/ModelTool/ModelTool.h"
 
-/// <summary>
-/// Enable/disable caching model import options
-/// </summary>
-#define IMPORT_MODEL_CACHE_OPTIONS 1
-
 /// <summary>
 /// Importing models utility
 /// </summary>
-class ImportModelFile
+class ImportModel
 {
 public:
     typedef ModelTool::Options Options;
@@ -45,9 +40,10 @@ public:
     static CreateAssetResult Create(CreateAssetContext& context);
 
 private:
-    static CreateAssetResult ImportModel(CreateAssetContext& context, ModelData& modelData, const Options* options = nullptr);
-    static CreateAssetResult ImportSkinnedModel(CreateAssetContext& context, ModelData& modelData, const Options* options = nullptr);
-    static CreateAssetResult ImportAnimation(CreateAssetContext& context, ModelData& modelData, const Options* options = nullptr);
+    static CreateAssetResult CreateModel(CreateAssetContext& context, ModelData& data, const Options* options = nullptr);
+    static CreateAssetResult CreateSkinnedModel(CreateAssetContext& context, ModelData& data, const Options* options = nullptr);
+    static CreateAssetResult CreateAnimation(CreateAssetContext& context, ModelData& data, const Options* options = nullptr);
+    static CreateAssetResult CreatePrefab(CreateAssetContext& context, ModelData& data, const Options& options, const Array<struct PrefabObject>& prefabObjects);
 };
 
 #endif
diff --git a/Source/Engine/ContentImporters/ImportModelFile.cpp b/Source/Engine/ContentImporters/ImportModelFile.cpp
deleted file mode 100644
index b34bbfaaf..000000000
--- a/Source/Engine/ContentImporters/ImportModelFile.cpp
+++ /dev/null
@@ -1,307 +0,0 @@
-// Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
-
-#include "ImportModel.h"
-
-#if COMPILE_WITH_ASSETS_IMPORTER
-
-#include "Engine/Core/Log.h"
-#include "Engine/Serialization/MemoryWriteStream.h"
-#include "Engine/Serialization/JsonWriters.h"
-#include "Engine/Graphics/Models/ModelData.h"
-#include "Engine/Content/Assets/Model.h"
-#include "Engine/Content/Assets/SkinnedModel.h"
-#include "Engine/Content/Storage/ContentStorageManager.h"
-#include "Engine/Content/Assets/Animation.h"
-#include "Engine/Content/Content.h"
-#include "Engine/Platform/FileSystem.h"
-#include "AssetsImportingManager.h"
-
-bool ImportModelFile::TryGetImportOptions(const StringView& path, Options& options)
-{
-#if IMPORT_MODEL_CACHE_OPTIONS
-    if (FileSystem::FileExists(path))
-    {
-        // Try to load asset file and asset info
-        auto tmpFile = ContentStorageManager::GetStorage(path);
-        AssetInitData data;
-        if (tmpFile
-            && tmpFile->GetEntriesCount() == 1
-            && (
-                (tmpFile->GetEntry(0).TypeName == Model::TypeName && !tmpFile->LoadAssetHeader(0, data) && data.SerializedVersion >= 4)
-                ||
-                (tmpFile->GetEntry(0).TypeName == SkinnedModel::TypeName && !tmpFile->LoadAssetHeader(0, data) && data.SerializedVersion >= 1)
-                ||
-                (tmpFile->GetEntry(0).TypeName == Animation::TypeName && !tmpFile->LoadAssetHeader(0, data) && data.SerializedVersion >= 1)
-            ))
-        {
-            // Check import meta
-            rapidjson_flax::Document metadata;
-            metadata.Parse((const char*)data.Metadata.Get(), data.Metadata.Length());
-            if (metadata.HasParseError() == false)
-            {
-                options.Deserialize(metadata, nullptr);
-                return true;
-            }
-        }
-    }
-#endif
-    return false;
-}
-
-void TryRestoreMaterials(CreateAssetContext& context, ModelData& modelData)
-{
-    // Skip if file is missing
-    if (!FileSystem::FileExists(context.TargetAssetPath))
-        return;
-
-    // Try to load asset that gets reimported
-    AssetReference<Asset> asset = Content::LoadAsync<Asset>(context.TargetAssetPath);
-    if (asset == nullptr)
-        return;
-    if (asset->WaitForLoaded())
-        return;
-
-    // Get model object
-    ModelBase* model = nullptr;
-    if (asset.Get()->GetTypeName() == Model::TypeName)
-    {
-        model = ((Model*)asset.Get());
-    }
-    else if (asset.Get()->GetTypeName() == SkinnedModel::TypeName)
-    {
-        model = ((SkinnedModel*)asset.Get());
-    }
-    if (!model)
-        return;
-
-    // Peek materials
-    for (int32 i = 0; i < modelData.Materials.Count(); i++)
-    {
-        auto& dstSlot = modelData.Materials[i];
-
-        if (model->MaterialSlots.Count() > i)
-        {
-            auto& srcSlot = model->MaterialSlots[i];
-
-            dstSlot.Name = srcSlot.Name;
-            dstSlot.ShadowsMode = srcSlot.ShadowsMode;
-            dstSlot.AssetID = srcSlot.Material.GetID();
-        }
-    }
-}
-
-CreateAssetResult ImportModelFile::Import(CreateAssetContext& context)
-{
-    // Get import options
-    Options options;
-    if (context.CustomArg != nullptr)
-    {
-        // Copy import options from argument
-        options = *static_cast<Options*>(context.CustomArg);
-    }
-    else
-    {
-        // Restore the previous settings or use default ones
-        if (!TryGetImportOptions(context.TargetAssetPath, options))
-        {
-            LOG(Warning, "Missing model import options. Using default values.");
-        }
-    }
-    if (options.SplitObjects)
-    {
-        options.OnSplitImport.Bind([&context](Options& splitOptions, const String& objectName)
-        {
-            // Recursive importing of the split object
-            String postFix = objectName;
-            const int32 splitPos = postFix.FindLast(TEXT('|'));
-            if (splitPos != -1)
-                postFix = postFix.Substring(splitPos + 1);
-            const String outputPath = String(StringUtils::GetPathWithoutExtension(context.TargetAssetPath)) + TEXT(" ") + postFix + TEXT(".flax");
-            return AssetsImportingManager::Import(context.InputPath, outputPath, &splitOptions);
-        });
-    }
-
-    // Import model file
-    ModelData modelData;
-    String errorMsg;
-    String autoImportOutput(StringUtils::GetDirectoryName(context.TargetAssetPath));
-    autoImportOutput /= options.SubAssetFolder.HasChars() ? options.SubAssetFolder.TrimTrailing() : String(StringUtils::GetFileNameWithoutExtension(context.InputPath));
-    if (ModelTool::ImportModel(context.InputPath, modelData, options, errorMsg, autoImportOutput))
-    {
-        LOG(Error, "Cannot import model file. {0}", errorMsg);
-        return CreateAssetResult::Error;
-    }
-
-    // Check if restore materials on model reimport
-    if (options.RestoreMaterialsOnReimport && modelData.Materials.HasItems())
-    {
-        TryRestoreMaterials(context, modelData);
-    }
-
-    // Auto calculate LODs transition settings
-    modelData.CalculateLODsScreenSizes();
-
-    // Create destination asset type
-    CreateAssetResult result = CreateAssetResult::InvalidTypeID;
-    switch (options.Type)
-    {
-    case ModelTool::ModelType::Model:
-        result = ImportModel(context, modelData, &options);
-        break;
-    case ModelTool::ModelType::SkinnedModel:
-        result = ImportSkinnedModel(context, modelData, &options);
-        break;
-    case ModelTool::ModelType::Animation:
-        result = ImportAnimation(context, modelData, &options);
-        break;
-    }
-    if (result != CreateAssetResult::Ok)
-        return result;
-
-#if IMPORT_MODEL_CACHE_OPTIONS
-    // Create json with import context
-    rapidjson_flax::StringBuffer importOptionsMetaBuffer;
-    importOptionsMetaBuffer.Reserve(256);
-    CompactJsonWriter importOptionsMetaObj(importOptionsMetaBuffer);
-    JsonWriter& importOptionsMeta = importOptionsMetaObj;
-    importOptionsMeta.StartObject();
-    {
-        context.AddMeta(importOptionsMeta);
-        options.Serialize(importOptionsMeta, nullptr);
-    }
-    importOptionsMeta.EndObject();
-    context.Data.Metadata.Copy((const byte*)importOptionsMetaBuffer.GetString(), (uint32)importOptionsMetaBuffer.GetSize());
-#endif
-
-    return CreateAssetResult::Ok;
-}
-
-CreateAssetResult ImportModelFile::Create(CreateAssetContext& context)
-{
-    ASSERT(context.CustomArg != nullptr);
-    auto& modelData = *(ModelData*)context.CustomArg;
-
-    // Ensure model has any meshes
-    if ((modelData.LODs.IsEmpty() || modelData.LODs[0].Meshes.IsEmpty()))
-    {
-        LOG(Warning, "Models has no valid meshes");
-        return CreateAssetResult::Error;
-    }
-
-    // Auto calculate LODs transition settings
-    modelData.CalculateLODsScreenSizes();
-
-    // Import
-    return ImportModel(context, modelData);
-}
-
-CreateAssetResult ImportModelFile::ImportModel(CreateAssetContext& context, ModelData& modelData, const Options* options)
-{
-    // Base
-    IMPORT_SETUP(Model, Model::SerializedVersion);
-
-    // Save model header
-    MemoryWriteStream stream(4096);
-    if (modelData.Pack2ModelHeader(&stream))
-        return CreateAssetResult::Error;
-    if (context.AllocateChunk(0))
-        return CreateAssetResult::CannotAllocateChunk;
-    context.Data.Header.Chunks[0]->Data.Copy(stream.GetHandle(), stream.GetPosition());
-
-    // Pack model LODs data
-    const auto lodCount = modelData.GetLODsCount();
-    for (int32 lodIndex = 0; lodIndex < lodCount; lodIndex++)
-    {
-        stream.SetPosition(0);
-
-        // Pack meshes
-        auto& meshes = modelData.LODs[lodIndex].Meshes;
-        for (int32 meshIndex = 0; meshIndex < meshes.Count(); meshIndex++)
-        {
-            if (meshes[meshIndex]->Pack2Model(&stream))
-            {
-                LOG(Warning, "Cannot pack mesh.");
-                return CreateAssetResult::Error;
-            }
-        }
-
-        const int32 chunkIndex = lodIndex + 1;
-        if (context.AllocateChunk(chunkIndex))
-            return CreateAssetResult::CannotAllocateChunk;
-        context.Data.Header.Chunks[chunkIndex]->Data.Copy(stream.GetHandle(), stream.GetPosition());
-    }
-
-    // Generate SDF
-    if (options && options->GenerateSDF)
-    {
-        stream.SetPosition(0);
-        if (!ModelTool::GenerateModelSDF(nullptr, &modelData, options->SDFResolution, lodCount - 1, nullptr, &stream, context.TargetAssetPath))
-        {
-            if (context.AllocateChunk(15))
-                return CreateAssetResult::CannotAllocateChunk;
-            context.Data.Header.Chunks[15]->Data.Copy(stream.GetHandle(), stream.GetPosition());
-        }
-    }
-
-    return CreateAssetResult::Ok;
-}
-
-CreateAssetResult ImportModelFile::ImportSkinnedModel(CreateAssetContext& context, ModelData& modelData, const Options* options)
-{
-    // Base
-    IMPORT_SETUP(SkinnedModel, SkinnedModel::SerializedVersion);
-
-    // Save skinned model header
-    MemoryWriteStream stream(4096);
-    if (modelData.Pack2SkinnedModelHeader(&stream))
-        return CreateAssetResult::Error;
-    if (context.AllocateChunk(0))
-        return CreateAssetResult::CannotAllocateChunk;
-    context.Data.Header.Chunks[0]->Data.Copy(stream.GetHandle(), stream.GetPosition());
-
-    // Pack model LODs data
-    const auto lodCount = modelData.GetLODsCount();
-    for (int32 lodIndex = 0; lodIndex < lodCount; lodIndex++)
-    {
-        stream.SetPosition(0);
-
-        // Mesh Data Version
-        stream.WriteByte(1);
-
-        // Pack meshes
-        auto& meshes = modelData.LODs[lodIndex].Meshes;
-        for (int32 meshIndex = 0; meshIndex < meshes.Count(); meshIndex++)
-        {
-            if (meshes[meshIndex]->Pack2SkinnedModel(&stream))
-            {
-                LOG(Warning, "Cannot pack mesh.");
-                return CreateAssetResult::Error;
-            }
-        }
-
-        const int32 chunkIndex = lodIndex + 1;
-        if (context.AllocateChunk(chunkIndex))
-            return CreateAssetResult::CannotAllocateChunk;
-        context.Data.Header.Chunks[chunkIndex]->Data.Copy(stream.GetHandle(), stream.GetPosition());
-    }
-
-    return CreateAssetResult::Ok;
-}
-
-CreateAssetResult ImportModelFile::ImportAnimation(CreateAssetContext& context, ModelData& modelData, const Options* options)
-{
-    // Base
-    IMPORT_SETUP(Animation, Animation::SerializedVersion);
-
-    // Save animation data
-    MemoryWriteStream stream(8182);
-    if (modelData.Pack2AnimationHeader(&stream))
-        return CreateAssetResult::Error;
-    if (context.AllocateChunk(0))
-        return CreateAssetResult::CannotAllocateChunk;
-    context.Data.Header.Chunks[0]->Data.Copy(stream.GetHandle(), stream.GetPosition());
-
-    return CreateAssetResult::Ok;
-}
-
-#endif
diff --git a/Source/Engine/ContentImporters/ImportModelFile.h b/Source/Engine/ContentImporters/ImportModelFile.h
deleted file mode 100644
index a40109601..000000000
--- a/Source/Engine/ContentImporters/ImportModelFile.h
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
-
-#pragma once
-
-#include "Types.h"
-
-#if COMPILE_WITH_ASSETS_IMPORTER
-
-#include "Engine/Content/Assets/Model.h"
-#include "Engine/Tools/ModelTool/ModelTool.h"
-
-/// <summary>
-/// Enable/disable caching model import options
-/// </summary>
-#define IMPORT_MODEL_CACHE_OPTIONS 1
-
-/// <summary>
-/// Importing models utility
-/// </summary>
-class ImportModelFile
-{
-public:
-    typedef ModelTool::Options Options;
-
-public:
-    /// <summary>
-    /// Tries the get model import options from the target location asset.
-    /// </summary>
-    /// <param name="path">The asset path.</param>
-    /// <param name="options">The options.</param>
-    /// <returns>True if success, otherwise false.</returns>
-    static bool TryGetImportOptions(String path, Options& options);
-
-    /// <summary>
-    /// Imports the model file.
-    /// </summary>
-    /// <param name="context">The importing context.</param>
-    /// <returns>Result.</returns>
-    static CreateAssetResult Import(CreateAssetContext& context);
-
-    /// <summary>
-    /// Creates the model asset from the ModelData storage (input argument should be pointer to ModelData).
-    /// </summary>
-    /// <param name="context">The importing context.</param>
-    /// <returns>Result.</returns>
-    static CreateAssetResult Create(CreateAssetContext& context);
-
-private:
-    static CreateAssetResult ImportModel(CreateAssetContext& context, ModelData& modelData);
-    static CreateAssetResult ImportSkinnedModel(CreateAssetContext& context, ModelData& modelData);
-    static CreateAssetResult ImportAnimation(CreateAssetContext& context, ModelData& modelData);
-};
-
-#endif
diff --git a/Source/Engine/ContentImporters/ImportTexture.cpp b/Source/Engine/ContentImporters/ImportTexture.cpp
index 51b93420c..ebc7e514c 100644
--- a/Source/Engine/ContentImporters/ImportTexture.cpp
+++ b/Source/Engine/ContentImporters/ImportTexture.cpp
@@ -8,7 +8,6 @@
 #include "Engine/Serialization/MemoryWriteStream.h"
 #include "Engine/Serialization/MemoryReadStream.h"
 #include "Engine/Graphics/Textures/TextureData.h"
-#include "Engine/Graphics/Textures/TextureUtils.h"
 #include "Engine/Graphics/PixelFormatExtensions.h"
 #include "Engine/Content/Storage/ContentStorageManager.h"
 #include "Engine/ContentImporters/ImportIES.h"
diff --git a/Source/Engine/ContentImporters/Types.h b/Source/Engine/ContentImporters/Types.h
index 4ebf55583..388c533a8 100644
--- a/Source/Engine/ContentImporters/Types.h
+++ b/Source/Engine/ContentImporters/Types.h
@@ -18,7 +18,7 @@ class CreateAssetContext;
 /// <summary>
 /// Create/Import new asset callback result
 /// </summary>
-DECLARE_ENUM_7(CreateAssetResult, Ok, Abort, Error, CannotSaveFile, InvalidPath, CannotAllocateChunk, InvalidTypeID);
+DECLARE_ENUM_8(CreateAssetResult, Ok, Abort, Error, CannotSaveFile, InvalidPath, CannotAllocateChunk, InvalidTypeID, Skip);
 
 /// <summary>
 /// Create/Import new asset callback function
diff --git a/Source/Engine/Core/Collections/Array.h b/Source/Engine/Core/Collections/Array.h
index cf45ed060..a8390f051 100644
--- a/Source/Engine/Core/Collections/Array.h
+++ b/Source/Engine/Core/Collections/Array.h
@@ -734,9 +734,7 @@ public:
         }
         else
         {
-            Array tmp = MoveTemp(other);
-            other = *this;
-            *this = MoveTemp(tmp);
+            ::Swap(other, *this);
         }
     }
 
diff --git a/Source/Engine/Core/Collections/ArrayExtensions.h b/Source/Engine/Core/Collections/ArrayExtensions.h
index 2ae6da9c8..99d454906 100644
--- a/Source/Engine/Core/Collections/ArrayExtensions.h
+++ b/Source/Engine/Core/Collections/ArrayExtensions.h
@@ -55,9 +55,7 @@ public:
         for (int32 i = 0; i < obj.Count(); i++)
         {
             if (predicate(obj[i]))
-            {
                 return i;
-            }
         }
         return INVALID_INDEX;
     }
@@ -74,9 +72,7 @@ public:
         for (int32 i = 0; i < obj.Count(); i++)
         {
             if (predicate(obj[i]))
-            {
                 return true;
-            }
         }
         return false;
     }
@@ -93,13 +89,101 @@ public:
         for (int32 i = 0; i < obj.Count(); i++)
         {
             if (!predicate(obj[i]))
-            {
                 return false;
-            }
         }
         return true;
     }
 
+    /// <summary>
+    /// Filters a sequence of values based on a predicate.
+    /// </summary>
+    /// <param name="obj">The target collection.</param>
+    /// <param name="predicate">The prediction function. Return true for elements that should be included in result list.</param>
+    /// <param name="result">The result list with items that passed the predicate.</param>
+    template<typename T, typename AllocationType>
+    static void Where(const Array<T, AllocationType>& obj, const Function<bool(const T&)>& predicate, Array<T, AllocationType>& result)
+    {
+        for (const T& i : obj)
+        {
+            if (predicate(i))
+                result.Add(i);
+        }
+    }
+
+    /// <summary>
+    /// Filters a sequence of values based on a predicate.
+    /// </summary>
+    /// <param name="obj">The target collection.</param>
+    /// <param name="predicate">The prediction function. Return true for elements that should be included in result list.</param>
+    /// <returns>The result list with items that passed the predicate.</returns>
+    template<typename T, typename AllocationType>
+    static Array<T, AllocationType> Where(const Array<T, AllocationType>& obj, const Function<bool(const T&)>& predicate)
+    {
+        Array<T, AllocationType> result;
+        Where(obj, predicate, result);
+        return result;
+    }
+
+    /// <summary>
+    /// Projects each element of a sequence into a new form.
+    /// </summary>
+    /// <param name="obj">The target collection.</param>
+    /// <param name="selector">A transform function to apply to each source element; the second parameter of the function represents the index of the source element.</param>
+    /// <param name="result">The result list whose elements are the result of invoking the transform function on each element of source.</param>
+    template<typename TResult, typename TSource, typename AllocationType>
+    static void Select(const Array<TSource, AllocationType>& obj, const Function<TResult(const TSource&)>& selector, Array<TResult, AllocationType>& result)
+    {
+        for (const TSource& i : obj)
+            result.Add(MoveTemp(selector(i)));
+    }
+
+    /// <summary>
+    /// Projects each element of a sequence into a new form.
+    /// </summary>
+    /// <param name="obj">The target collection.</param>
+    /// <param name="selector">A transform function to apply to each source element; the second parameter of the function represents the index of the source element.</param>
+    /// <returns>The result list whose elements are the result of invoking the transform function on each element of source.</returns>
+    template<typename TResult, typename TSource, typename AllocationType>
+    static Array<TResult, AllocationType> Select(const Array<TSource, AllocationType>& obj, const Function<TResult(const TSource&)>& selector)
+    {
+        Array<TResult, AllocationType> result;
+        Select(obj, selector, result);
+        return result;
+    }
+
+    /// <summary>
+    /// Removes all the elements that match the conditions defined by the specified predicate.
+    /// </summary>
+    /// <param name="obj">The target collection to modify.</param>
+    /// <param name="predicate">A transform function that defines the conditions of the elements to remove.</param>
+    template<typename T, typename AllocationType>
+    static void RemoveAll(Array<T, AllocationType>& obj, const Function<bool(const T&)>& predicate)
+    {
+        for (int32 i = obj.Count() - 1; i >= 0; i--)
+        {
+            if (predicate(obj[i]))
+                obj.RemoveAtKeepOrder(i);
+        }
+    }
+
+    /// <summary>
+    /// Removes all the elements that match the conditions defined by the specified predicate.
+    /// </summary>
+    /// <param name="obj">The target collection to process.</param>
+    /// <param name="predicate">A transform function that defines the conditions of the elements to remove.</param>
+    /// <returns>The result list whose elements are the result of invoking the transform function on each element of source.</returns>
+    template<typename T, typename AllocationType>
+    static Array<T, AllocationType> RemoveAll(const Array<T, AllocationType>& obj, const Function<bool(const T&)>& predicate)
+    {
+        Array<T, AllocationType> result;
+        for (const T& i : obj)
+        {
+            if (!predicate(i))
+                result.Ass(i);
+        }
+        return result;
+    }
+
     /// <summary>
     /// Groups the elements of a sequence according to a specified key selector function.
     /// </summary>
@@ -109,7 +193,7 @@ public:
     template<typename TSource, typename TKey, typename AllocationType>
     static void GroupBy(const Array<TSource, AllocationType>& obj, const Function<TKey(TSource const&)>& keySelector, Array<IGrouping<TKey, TSource>, AllocationType>& result)
     {
-        Dictionary<TKey, IGrouping<TKey, TSource>> data(static_cast<int32>(obj.Count() * 3.0f));
+        Dictionary<TKey, IGrouping<TKey, TSource>> data;
         for (int32 i = 0; i < obj.Count(); i++)
         {
             const TKey key = keySelector(obj[i]);
diff --git a/Source/Engine/Core/Collections/Dictionary.h b/Source/Engine/Core/Collections/Dictionary.h
index dd73be390..d2a840fff 100644
--- a/Source/Engine/Core/Collections/Dictionary.h
+++ b/Source/Engine/Core/Collections/Dictionary.h
@@ -616,9 +616,7 @@ public:
         }
         else
         {
-            Dictionary tmp = MoveTemp(other);
-            other = *this;
-            *this = MoveTemp(tmp);
+            ::Swap(other, *this);
         }
     }
 
diff --git a/Source/Engine/Core/Collections/Sorting.h b/Source/Engine/Core/Collections/Sorting.h
index 2210f6f1c..67b639c80 100644
--- a/Source/Engine/Core/Collections/Sorting.h
+++ b/Source/Engine/Core/Collections/Sorting.h
@@ -45,6 +45,16 @@ public:
     };
 
 public:
+    /// <summary>
+    /// Sorts the linear data array using Quick Sort algorithm (non recursive version, uses temporary stack collection).
+    /// </summary>
+    /// <param name="data">The data container.</param>
+    template<typename T, typename AllocationType = HeapAllocation>
+    FORCE_INLINE static void QuickSort(Array<T, AllocationType>& data)
+    {
+        QuickSort(data.Get(), data.Count());
+    }
+
     /// <summary>
     /// Sorts the linear data array using Quick Sort algorithm (non recursive version, uses temporary stack collection).
     /// </summary>
diff --git a/Source/Engine/Core/Log.cpp b/Source/Engine/Core/Log.cpp
index bb8d42aba..b6b4fa3e2 100644
--- a/Source/Engine/Core/Log.cpp
+++ b/Source/Engine/Core/Log.cpp
@@ -58,7 +58,7 @@ bool Log::Logger::Init()
         int32 remaining = oldLogs.Count() - maxLogFiles + 1;
         if (remaining > 0)
         {
-            Sorting::QuickSort(oldLogs.Get(), oldLogs.Count());
+            Sorting::QuickSort(oldLogs);
 
             // Delete the oldest logs
             int32 i = 0;
diff --git a/Source/Engine/Core/Math/Vector2.cpp b/Source/Engine/Core/Math/Vector2.cpp
index ec168de33..63e6fc4c5 100644
--- a/Source/Engine/Core/Math/Vector2.cpp
+++ b/Source/Engine/Core/Math/Vector2.cpp
@@ -15,6 +15,8 @@ const Float2 Float2::Zero(0.0f);
 template<>
 const Float2 Float2::One(1.0f);
 template<>
+const Float2 Float2::Half(0.5f);
+template<>
 const Float2 Float2::UnitX(1.0f, 0.0f);
 template<>
 const Float2 Float2::UnitY(0.0f, 1.0f);
diff --git a/Source/Engine/Core/Math/Vector2.h b/Source/Engine/Core/Math/Vector2.h
index cea03ec10..cce77788a 100644
--- a/Source/Engine/Core/Math/Vector2.h
+++ b/Source/Engine/Core/Math/Vector2.h
@@ -44,6 +44,9 @@ public:
     // Vector with all components equal 1
     static FLAXENGINE_API const Vector2Base<T> One;
 
+    // Vector with all components equal 0.5
+    static FLAXENGINE_API const Vector2Base<T> Half;
+
     // Vector X=1, Y=0
     static FLAXENGINE_API const Vector2Base<T> UnitX;
 
diff --git a/Source/Engine/Core/Math/Vector4.cpp b/Source/Engine/Core/Math/Vector4.cpp
index b5fa7a81d..372fde6db 100644
--- a/Source/Engine/Core/Math/Vector4.cpp
+++ b/Source/Engine/Core/Math/Vector4.cpp
@@ -17,6 +17,8 @@ const Float4 Float4::Zero(0.0f);
 template<>
 const Float4 Float4::One(1.0f);
 template<>
+const Float4 Float4::Half(0.5f);
+template<>
 const Float4 Float4::UnitX(1.0f, 0.0f, 0.0f, 0.0f);
 template<>
 const Float4 Float4::UnitY(0.0f, 1.0f, 0.0f, 0.0f);
diff --git a/Source/Engine/Core/Math/Vector4.h b/Source/Engine/Core/Math/Vector4.h
index 1cc6d4db8..7edb97ce5 100644
--- a/Source/Engine/Core/Math/Vector4.h
+++ b/Source/Engine/Core/Math/Vector4.h
@@ -54,6 +54,9 @@ public:
     // Vector with all components equal 1
     static FLAXENGINE_API const Vector4Base<T> One;
 
+    // Vector with all components equal 0.5
+    static FLAXENGINE_API const Vector4Base<T> Half;
+
     // Vector X=1, Y=0, Z=0, W=0
     static FLAXENGINE_API const Vector4Base<T> UnitX;
 
diff --git a/Source/Engine/Core/Templates.h b/Source/Engine/Core/Templates.h
index 75674e2d0..876a4db83 100644
--- a/Source/Engine/Core/Templates.h
+++ b/Source/Engine/Core/Templates.h
@@ -304,7 +304,7 @@ template<typename T>
 inline void Swap(T& a, T& b) noexcept
 {
     T tmp = MoveTemp(a);
-    a = b;
+    a = MoveTemp(b);
     b = MoveTemp(tmp);
 }
 
diff --git a/Source/Engine/Engine/NativeInterop.cs b/Source/Engine/Engine/NativeInterop.cs
index fc04d9668..026f54fec 100644
--- a/Source/Engine/Engine/NativeInterop.cs
+++ b/Source/Engine/Engine/NativeInterop.cs
@@ -1331,39 +1331,50 @@ namespace FlaxEngine.Interop
                 // Skip using in-built delegate for value types (eg. Transform) to properly handle instance value passing to method
                 if (invokeDelegate == null && !method.DeclaringType.IsValueType)
                 {
-                    List<Type> methodTypes = new List<Type>();
-                    if (!method.IsStatic)
-                        methodTypes.Add(method.DeclaringType);
-                    if (returnType != typeof(void))
-                        methodTypes.Add(returnType);
-                    methodTypes.AddRange(parameterTypes);
-
-                    List<Type> genericParamTypes = new List<Type>();
-                    foreach (var type in methodTypes)
+                    // Thread-safe creation
+                    lock (typeCache)
                     {
-                        if (type.IsByRef)
-                            genericParamTypes.Add(type.GetElementType());
-                        else if (type.IsPointer)
-                            genericParamTypes.Add(typeof(IntPtr));
-                        else
-                            genericParamTypes.Add(type);
-                    }
-
-                    string invokerTypeName = $"{typeof(Invoker).FullName}+Invoker{(method.IsStatic ? "Static" : "")}{(returnType != typeof(void) ? "Ret" : "NoRet")}{parameterTypes.Length}{(genericParamTypes.Count > 0 ? "`" + genericParamTypes.Count : "")}";
-                    Type invokerType = Type.GetType(invokerTypeName);
-                    if (invokerType != null)
-                    {
-                        if (genericParamTypes.Count != 0)
-                            invokerType = invokerType.MakeGenericType(genericParamTypes.ToArray());
-                        invokeDelegate = invokerType.GetMethod(nameof(Invoker.InvokerStaticNoRet0.MarshalAndInvoke), BindingFlags.Static | BindingFlags.NonPublic).CreateDelegate<Invoker.MarshalAndInvokeDelegate>();
-                        delegInvoke = invokerType.GetMethod(nameof(Invoker.InvokerStaticNoRet0.CreateDelegate), BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, new object[] { method });
+                        if (invokeDelegate == null)
+                        {
+                            TryCreateDelegate();
+                        }
                     }
                 }
-
                 outDeleg = invokeDelegate;
                 outDelegInvoke = delegInvoke;
                 return outDeleg != null;
             }
+
+            private void TryCreateDelegate()
+            {
+                var methodTypes = new List<Type>();
+                if (!method.IsStatic)
+                    methodTypes.Add(method.DeclaringType);
+                if (returnType != typeof(void))
+                    methodTypes.Add(returnType);
+                methodTypes.AddRange(parameterTypes);
+
+                var genericParamTypes = new List<Type>();
+                foreach (var type in methodTypes)
+                {
+                    if (type.IsByRef)
+                        genericParamTypes.Add(type.GetElementType());
+                    else if (type.IsPointer)
+                        genericParamTypes.Add(typeof(IntPtr));
+                    else
+                        genericParamTypes.Add(type);
+                }
+
+                string invokerTypeName = $"{typeof(Invoker).FullName}+Invoker{(method.IsStatic ? "Static" : "")}{(returnType != typeof(void) ? "Ret" : "NoRet")}{parameterTypes.Length}{(genericParamTypes.Count > 0 ? "`" + genericParamTypes.Count : "")}";
+                Type invokerType = Type.GetType(invokerTypeName);
+                if (invokerType != null)
+                {
+                    if (genericParamTypes.Count != 0)
+                        invokerType = invokerType.MakeGenericType(genericParamTypes.ToArray());
+                    delegInvoke = invokerType.GetMethod(nameof(Invoker.InvokerStaticNoRet0.CreateDelegate), BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, new object[] { method });
+                    invokeDelegate = invokerType.GetMethod(nameof(Invoker.InvokerStaticNoRet0.MarshalAndInvoke), BindingFlags.Static | BindingFlags.NonPublic).CreateDelegate<Invoker.MarshalAndInvokeDelegate>();
+                }
+            }
 #endif
         }
 
diff --git a/Source/Engine/Engine/Time.cpp b/Source/Engine/Engine/Time.cpp
index a7c4bf80d..3adccdbd9 100644
--- a/Source/Engine/Engine/Time.cpp
+++ b/Source/Engine/Engine/Time.cpp
@@ -104,7 +104,7 @@ bool Time::TickData::OnTickBegin(float targetFps, float maxDeltaTime)
 
         if (targetFps > ZeroTolerance)
         {
-            int skip = (int)(1 + (time - NextBegin) / (1.0 / targetFps));
+            int skip = (int)(1 + (time - NextBegin) * targetFps);
             NextBegin += (1.0 / targetFps) * skip;
         }
     }
@@ -160,7 +160,7 @@ bool Time::FixedStepTickData::OnTickBegin(float targetFps, float maxDeltaTime)
 
         if (targetFps > ZeroTolerance)
         {
-            int skip = (int)(1 + (time - NextBegin) / (1.0 / targetFps));
+            int skip = (int)(1 + (time - NextBegin) * targetFps);
             NextBegin += (1.0 / targetFps) * skip;
         }
     }
diff --git a/Source/Engine/Graphics/Models/ModelData.Tool.cpp b/Source/Engine/Graphics/Models/ModelData.Tool.cpp
index 727fe7754..91ee2bcd7 100644
--- a/Source/Engine/Graphics/Models/ModelData.Tool.cpp
+++ b/Source/Engine/Graphics/Models/ModelData.Tool.cpp
@@ -10,6 +10,7 @@
 #include "Engine/Core/Collections/BitArray.h"
 #include "Engine/Tools/ModelTool/ModelTool.h"
 #include "Engine/Tools/ModelTool/VertexTriangleAdjacency.h"
+#include "Engine/Profiler/ProfilerCPU.h"
 #include "Engine/Platform/Platform.h"
 #define USE_MIKKTSPACE 1
 #include "ThirdParty/MikkTSpace/mikktspace.h"
@@ -78,6 +79,7 @@ void RemapArrayHelper(Array<T>& target, const std::vector<uint32_t>& remap)
 
 bool MeshData::GenerateLightmapUVs()
 {
+    PROFILE_CPU();
 #if PLATFORM_WINDOWS
     // Prepare
     HRESULT hr;
@@ -235,6 +237,7 @@ void RemapBuffer(Array<T>& src, Array<T>& dst, const Array<int32>& mapping, int3
 
 void MeshData::BuildIndexBuffer()
 {
+    PROFILE_CPU();
     const auto startTime = Platform::GetTimeSeconds();
 
     const int32 vertexCount = Positions.Count();
@@ -341,6 +344,7 @@ bool MeshData::GenerateNormals(float smoothingAngle)
         LOG(Warning, "Missing vertex or index data to generate normals.");
         return true;
     }
+    PROFILE_CPU();
 
     const auto startTime = Platform::GetTimeSeconds();
 
@@ -520,6 +524,7 @@ bool MeshData::GenerateTangents(float smoothingAngle)
         LOG(Warning, "Missing normals or texcoors data to generate tangents.");
         return true;
     }
+    PROFILE_CPU();
 
     const auto startTime = Platform::GetTimeSeconds();
     const int32 vertexCount = Positions.Count();
@@ -706,6 +711,7 @@ void MeshData::ImproveCacheLocality()
 
     if (Positions.IsEmpty() || Indices.IsEmpty() || Positions.Count() <= VertexCacheSize)
         return;
+    PROFILE_CPU();
 
     const auto startTime = Platform::GetTimeSeconds();
 
@@ -886,6 +892,7 @@ void MeshData::ImproveCacheLocality()
 
 float MeshData::CalculateTrianglesArea() const
 {
+    PROFILE_CPU();
     float sum = 0;
     // TODO: use SIMD
     for (int32 i = 0; i + 2 < Indices.Count(); i += 3)
diff --git a/Source/Engine/Graphics/Models/ModelData.cpp b/Source/Engine/Graphics/Models/ModelData.cpp
index 1d67f4737..6e6ae04b5 100644
--- a/Source/Engine/Graphics/Models/ModelData.cpp
+++ b/Source/Engine/Graphics/Models/ModelData.cpp
@@ -625,6 +625,11 @@ bool MaterialSlotEntry::UsesProperties() const
             Normals.TextureIndex != -1;
 }
 
+ModelLodData::~ModelLodData()
+{
+    Meshes.ClearDelete();
+}
+
 BoundingBox ModelLodData::GetBox() const
 {
     if (Meshes.IsEmpty())
@@ -644,11 +649,9 @@ void ModelData::CalculateLODsScreenSizes()
 {
     const float autoComputeLodPowerBase = 0.5f;
     const int32 lodCount = LODs.Count();
-
     for (int32 lodIndex = 0; lodIndex < lodCount; lodIndex++)
     {
         auto& lod = LODs[lodIndex];
-
         if (lodIndex == 0)
         {
             lod.ScreenSize = 1.0f;
@@ -675,6 +678,8 @@ void ModelData::TransformBuffer(const Matrix& matrix)
     }
 }
 
+#if USE_EDITOR
+
 bool ModelData::Pack2ModelHeader(WriteStream* stream) const
 {
     // Validate input
@@ -724,7 +729,12 @@ bool ModelData::Pack2ModelHeader(WriteStream* stream) const
 
         // Amount of meshes
         const int32 meshes = lod.Meshes.Count();
-        if (meshes == 0 || meshes > MODEL_MAX_MESHES)
+        if (meshes == 0)
+        {
+            LOG(Warning, "Empty LOD.");
+            return true;
+        }
+        if (meshes > MODEL_MAX_MESHES)
         {
             LOG(Warning, "Too many meshes per LOD.");
             return true;
@@ -880,20 +890,21 @@ bool ModelData::Pack2SkinnedModelHeader(WriteStream* stream) const
     return false;
 }
 
-bool ModelData::Pack2AnimationHeader(WriteStream* stream) const
+bool ModelData::Pack2AnimationHeader(WriteStream* stream, int32 animIndex) const
 {
     // Validate input
-    if (stream == nullptr)
+    if (stream == nullptr || animIndex < 0 || animIndex >= Animations.Count())
     {
         Log::ArgumentNullException();
         return true;
     }
-    if (Animation.Duration <= ZeroTolerance || Animation.FramesPerSecond <= ZeroTolerance)
+    auto& anim = Animations.Get()[animIndex];
+    if (anim.Duration <= ZeroTolerance || anim.FramesPerSecond <= ZeroTolerance)
     {
         Log::InvalidOperationException(TEXT("Invalid animation duration."));
         return true;
     }
-    if (Animation.Channels.IsEmpty())
+    if (anim.Channels.IsEmpty())
     {
         Log::ArgumentOutOfRangeException(TEXT("Channels"), TEXT("Animation channels collection cannot be empty."));
         return true;
@@ -901,22 +912,23 @@ bool ModelData::Pack2AnimationHeader(WriteStream* stream) const
 
     // Info
     stream->WriteInt32(100); // Header version (for fast version upgrades without serialization format change)
-    stream->WriteDouble(Animation.Duration);
-    stream->WriteDouble(Animation.FramesPerSecond);
-    stream->WriteBool(Animation.EnableRootMotion);
-    stream->WriteString(Animation.RootNodeName, 13);
+    stream->WriteDouble(anim.Duration);
+    stream->WriteDouble(anim.FramesPerSecond);
+    stream->WriteBool(anim.EnableRootMotion);
+    stream->WriteString(anim.RootNodeName, 13);
 
     // Animation channels
-    stream->WriteInt32(Animation.Channels.Count());
-    for (int32 i = 0; i < Animation.Channels.Count(); i++)
+    stream->WriteInt32(anim.Channels.Count());
+    for (int32 i = 0; i < anim.Channels.Count(); i++)
     {
-        auto& anim = Animation.Channels[i];
-
-        stream->WriteString(anim.NodeName, 172);
-        Serialization::Serialize(*stream, anim.Position);
-        Serialization::Serialize(*stream, anim.Rotation);
-        Serialization::Serialize(*stream, anim.Scale);
+        auto& channel = anim.Channels[i];
+        stream->WriteString(channel.NodeName, 172);
+        Serialization::Serialize(*stream, channel.Position);
+        Serialization::Serialize(*stream, channel.Rotation);
+        Serialization::Serialize(*stream, channel.Scale);
     }
 
     return false;
 }
+
+#endif
diff --git a/Source/Engine/Graphics/Models/ModelData.h b/Source/Engine/Graphics/Models/ModelData.h
index d7359d905..65bedf876 100644
--- a/Source/Engine/Graphics/Models/ModelData.h
+++ b/Source/Engine/Graphics/Models/ModelData.h
@@ -366,12 +366,32 @@ struct FLAXENGINE_API MaterialSlotEntry
     bool UsesProperties() const;
 };
 
+/// <summary>
+/// Data container for model hierarchy node.
+/// </summary>
+struct FLAXENGINE_API ModelDataNode
+{
+    /// <summary>
+    /// The parent node index. The root node uses value -1.
+    /// </summary>
+    int32 ParentIndex;
+
+    /// <summary>
+    /// The local transformation of the node, relative to the parent node.
+    /// </summary>
+    Transform LocalTransform;
+
+    /// <summary>
+    /// The name of this node.
+    /// </summary>
+    String Name;
+};
+
 /// <summary>
 /// Data container for LOD metadata and sub meshes.
 /// </summary>
-class FLAXENGINE_API ModelLodData
+struct FLAXENGINE_API ModelLodData
 {
-public:
     /// <summary>
     /// The screen size to switch LODs. Bottom limit of the model screen size to render this LOD.
     /// </summary>
@@ -382,21 +402,10 @@ public:
     /// </summary>
     Array<MeshData*> Meshes;
 
-public:
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ModelLodData"/> class.
-    /// </summary>
-    ModelLodData()
-    {
-    }
-
     /// <summary>
     /// Finalizes an instance of the <see cref="ModelLodData"/> class.
     /// </summary>
-    ~ModelLodData()
-    {
-        Meshes.ClearDelete();
-    }
+    ~ModelLodData();
 
     /// <summary>
     /// Gets the bounding box combined for all meshes in this model LOD.
@@ -426,7 +435,7 @@ public:
     Array<MaterialSlotEntry> Materials;
 
     /// <summary>
-    /// Array with all LODs. The first element is the top most LOD0 followed by the LOD1, LOD2, etc.
+    /// Array with all Level Of Details that contain meshes. The first element is the top most LOD0 followed by the LOD1, LOD2, etc.
     /// </summary>
     Array<ModelLodData> LODs;
 
@@ -435,24 +444,20 @@ public:
     /// </summary>
     SkeletonData Skeleton;
 
+    /// <summary>
+    /// The scene nodes (in hierarchy).
+    /// </summary>
+    Array<ModelDataNode> Nodes;
+
     /// <summary>
     /// The node animations.
     /// </summary>
-    AnimationData Animation;
-
-public:
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ModelData"/> class.
-    /// </summary>
-    ModelData()
-    {
-    }
+    Array<AnimationData> Animations;
 
 public:
     /// <summary>
     /// Gets the valid level of details count.
     /// </summary>
-    /// <returns>The LOD count.</returns>
     FORCE_INLINE int32 GetLODsCount() const
     {
         return LODs.Count();
@@ -461,7 +466,6 @@ public:
     /// <summary>
     /// Determines whether this instance has valid skeleton structure.
     /// </summary>
-    /// <returns>True if has skeleton, otherwise false.</returns>
     FORCE_INLINE bool HasSkeleton() const
     {
         return Skeleton.Bones.HasItems();
@@ -479,6 +483,7 @@ public:
     /// <param name="matrix">The matrix to use for the transformation.</param>
     void TransformBuffer(const Matrix& matrix);
 
+#if USE_EDITOR
 public:
     /// <summary>
     /// Pack mesh data to the header stream
@@ -498,6 +503,8 @@ public:
     /// Pack animation data to the header stream
     /// </summary>
     /// <param name="stream">Output stream</param>
+    /// <param name="animIndex">Index of animation.</param>
     /// <returns>True if cannot save data, otherwise false</returns>
-    bool Pack2AnimationHeader(WriteStream* stream) const;
+    bool Pack2AnimationHeader(WriteStream* stream, int32 animIndex = 0) const;
+#endif
 };
diff --git a/Source/Engine/Graphics/Models/SkeletonMapping.h b/Source/Engine/Graphics/Models/SkeletonMapping.h
index e3ec0c793..29fd307fc 100644
--- a/Source/Engine/Graphics/Models/SkeletonMapping.h
+++ b/Source/Engine/Graphics/Models/SkeletonMapping.h
@@ -36,7 +36,7 @@ public:
     /// </summary>
     /// <param name="sourceSkeleton">The source model skeleton.</param>
     /// <param name="targetSkeleton">The target skeleton. May be null to disable nodes mapping.</param>
-    SkeletonMapping(Items& sourceSkeleton, Items* targetSkeleton)
+    SkeletonMapping(const Items& sourceSkeleton, const Items* targetSkeleton)
     {
         Size = sourceSkeleton.Count();
         SourceToTarget.Resize(Size); // model => skeleton mapping
diff --git a/Source/Engine/Graphics/PixelFormatExtensions.cpp b/Source/Engine/Graphics/PixelFormatExtensions.cpp
index 991844b22..f79530337 100644
--- a/Source/Engine/Graphics/PixelFormatExtensions.cpp
+++ b/Source/Engine/Graphics/PixelFormatExtensions.cpp
@@ -660,6 +660,37 @@ int PixelFormatExtensions::ComputeComponentsCount(const PixelFormat format)
     }
 }
 
+int32 PixelFormatExtensions::ComputeBlockSize(PixelFormat format)
+{
+    switch (format)
+    {
+    case PixelFormat::BC1_Typeless:
+    case PixelFormat::BC1_UNorm:
+    case PixelFormat::BC1_UNorm_sRGB:
+    case PixelFormat::BC2_Typeless:
+    case PixelFormat::BC2_UNorm:
+    case PixelFormat::BC2_UNorm_sRGB:
+    case PixelFormat::BC3_Typeless:
+    case PixelFormat::BC3_UNorm:
+    case PixelFormat::BC3_UNorm_sRGB:
+    case PixelFormat::BC4_Typeless:
+    case PixelFormat::BC4_UNorm:
+    case PixelFormat::BC4_SNorm:
+    case PixelFormat::BC5_Typeless:
+    case PixelFormat::BC5_UNorm:
+    case PixelFormat::BC5_SNorm:
+    case PixelFormat::BC6H_Typeless:
+    case PixelFormat::BC6H_Uf16:
+    case PixelFormat::BC6H_Sf16:
+    case PixelFormat::BC7_Typeless:
+    case PixelFormat::BC7_UNorm:
+    case PixelFormat::BC7_UNorm_sRGB:
+        return 4;
+    default:
+        return 1;
+    }
+}
+
 PixelFormat PixelFormatExtensions::TosRGB(const PixelFormat format)
 {
     switch (format)
diff --git a/Source/Engine/Graphics/PixelFormatExtensions.h b/Source/Engine/Graphics/PixelFormatExtensions.h
index 604bcb2c3..362e5634f 100644
--- a/Source/Engine/Graphics/PixelFormatExtensions.h
+++ b/Source/Engine/Graphics/PixelFormatExtensions.h
@@ -173,6 +173,13 @@ public:
     /// <returns>The components count.</returns>
     API_FUNCTION() static int ComputeComponentsCount(PixelFormat format);
 
+    /// <summary>
+    /// Computes the amount of pixels per-axis stored in the a single block of the format (eg. 4 for BC-family). Returns 1 for uncompressed formats.
+    /// </summary>
+    /// <param name="format">The <see cref="PixelFormat"/>.</param>
+    /// <returns>The block pixels count.</returns>
+    API_FUNCTION() static int32 ComputeBlockSize(PixelFormat format);
+
     /// <summary>
     /// Finds the equivalent sRGB format to the provided format.
     /// </summary>
diff --git a/Source/Engine/Graphics/PostProcessEffect.h b/Source/Engine/Graphics/PostProcessEffect.h
index 2e444c0ea..1513ad64e 100644
--- a/Source/Engine/Graphics/PostProcessEffect.h
+++ b/Source/Engine/Graphics/PostProcessEffect.h
@@ -13,7 +13,7 @@ struct RenderContext;
 /// Custom PostFx which can modify final image by processing it with material based filters. The base class for all post process effects used by the graphics pipeline. Allows to extend frame rendering logic and apply custom effects such as outline, night vision, contrast etc.
 /// </summary>
 /// <remarks>
-/// Override this class and implement custom post fx logic. Use <b>MainRenderTask.Instance.CustomPostFx.Add(myPostFx)</b> to attach your script to rendering or add script to camera actor.
+/// Override this class and implement custom post fx logic. Use <b>MainRenderTask.Instance.AddCustomPostFx(myPostFx)</b> to attach your script to rendering or add script to camera actor.
 /// </remarks>
 API_CLASS(Abstract) class FLAXENGINE_API PostProcessEffect : public Script
 {
diff --git a/Source/Engine/Graphics/RenderBuffers.cpp b/Source/Engine/Graphics/RenderBuffers.cpp
index e0f4869ad..7ee900858 100644
--- a/Source/Engine/Graphics/RenderBuffers.cpp
+++ b/Source/Engine/Graphics/RenderBuffers.cpp
@@ -192,6 +192,9 @@ bool RenderBuffers::Init(int32 width, int32 height)
     _viewport = Viewport(0, 0, static_cast<float>(width), static_cast<float>(height));
     LastEyeAdaptationTime = 0;
 
+    // Flush any pool render targets to prevent over-allocating GPU memory when resizing game viewport
+    RenderTargetPool::Flush(false, 4);
+
     return result;
 }
 
diff --git a/Source/Engine/Graphics/RenderTargetPool.cpp b/Source/Engine/Graphics/RenderTargetPool.cpp
index fe22b4eaf..891610ab8 100644
--- a/Source/Engine/Graphics/RenderTargetPool.cpp
+++ b/Source/Engine/Graphics/RenderTargetPool.cpp
@@ -7,35 +7,31 @@
 
 struct Entry
 {
-    bool IsOccupied;
     GPUTexture* RT;
-    uint64 LastFrameTaken;
     uint64 LastFrameReleased;
     uint32 DescriptionHash;
+    bool IsOccupied;
 };
 
 namespace
 {
-    Array<Entry> TemporaryRTs(64);
+    Array<Entry> TemporaryRTs;
 }
 
-void RenderTargetPool::Flush(bool force)
+void RenderTargetPool::Flush(bool force, int32 framesOffset)
 {
-    const uint64 framesOffset = 3 * 60;
+    if (framesOffset < 0)
+        framesOffset = 3 * 60; // For how many frames RTs should be cached (by default)
     const uint64 maxReleaseFrame = Engine::FrameCount - framesOffset;
     force |= Engine::ShouldExit();
 
     for (int32 i = 0; i < TemporaryRTs.Count(); i++)
     {
-        auto& tmp = TemporaryRTs[i];
-
-        if (!tmp.IsOccupied && (force || (tmp.LastFrameReleased < maxReleaseFrame)))
+        const auto& e = TemporaryRTs[i];
+        if (!e.IsOccupied && (force || e.LastFrameReleased < maxReleaseFrame))
         {
-            // Release
-            tmp.RT->DeleteObjectNow();
-            TemporaryRTs.RemoveAt(i);
-            i--;
-
+            e.RT->DeleteObjectNow();
+            TemporaryRTs.RemoveAt(i--);
             if (TemporaryRTs.IsEmpty())
                 break;
         }
@@ -48,19 +44,14 @@ GPUTexture* RenderTargetPool::Get(const GPUTextureDescription& desc)
     const uint32 descHash = GetHash(desc);
     for (int32 i = 0; i < TemporaryRTs.Count(); i++)
     {
-        auto& tmp = TemporaryRTs[i];
-
-        if (!tmp.IsOccupied && tmp.DescriptionHash == descHash)
+        auto& e = TemporaryRTs[i];
+        if (!e.IsOccupied && e.DescriptionHash == descHash)
         {
-            ASSERT(tmp.RT);
-
             // Mark as used
-            tmp.IsOccupied = true;
-            tmp.LastFrameTaken = Engine::FrameCount;
-            return tmp.RT;
+            e.IsOccupied = true;
+            return e.RT;
         }
     }
-
 #if !BUILD_RELEASE
     if (TemporaryRTs.Count() > 2000)
     {
@@ -71,24 +62,23 @@ GPUTexture* RenderTargetPool::Get(const GPUTextureDescription& desc)
 
     // Create new rt
     const String name = TEXT("TemporaryRT_") + StringUtils::ToString(TemporaryRTs.Count());
-    auto newRenderTarget = GPUDevice::Instance->CreateTexture(name);
-    if (newRenderTarget->Init(desc))
+    GPUTexture* rt = GPUDevice::Instance->CreateTexture(name);
+    if (rt->Init(desc))
     {
-        Delete(newRenderTarget);
+        Delete(rt);
         LOG(Error, "Cannot create temporary render target. Description: {0}", desc.ToString());
         return nullptr;
     }
 
     // Create temporary rt entry
-    Entry entry;
-    entry.IsOccupied = true;
-    entry.LastFrameReleased = 0;
-    entry.LastFrameTaken = Engine::FrameCount;
-    entry.RT = newRenderTarget;
-    entry.DescriptionHash = descHash;
-    TemporaryRTs.Add(entry);
+    Entry e;
+    e.IsOccupied = true;
+    e.LastFrameReleased = 0;
+    e.RT = rt;
+    e.DescriptionHash = descHash;
+    TemporaryRTs.Add(e);
 
-    return newRenderTarget;
+    return rt;
 }
 
 void RenderTargetPool::Release(GPUTexture* rt)
@@ -98,14 +88,13 @@ void RenderTargetPool::Release(GPUTexture* rt)
 
     for (int32 i = 0; i < TemporaryRTs.Count(); i++)
     {
-        auto& tmp = TemporaryRTs[i];
-
-        if (tmp.RT == rt)
+        auto& e = TemporaryRTs[i];
+        if (e.RT == rt)
         {
             // Mark as free
-            ASSERT(tmp.IsOccupied);
-            tmp.IsOccupied = false;
-            tmp.LastFrameReleased = Engine::FrameCount;
+            ASSERT(e.IsOccupied);
+            e.IsOccupied = false;
+            e.LastFrameReleased = Engine::FrameCount;
             return;
         }
     }
diff --git a/Source/Engine/Graphics/RenderTargetPool.h b/Source/Engine/Graphics/RenderTargetPool.h
index 345e5c81e..4ff69e2ea 100644
--- a/Source/Engine/Graphics/RenderTargetPool.h
+++ b/Source/Engine/Graphics/RenderTargetPool.h
@@ -15,7 +15,8 @@ public:
     /// Flushes the temporary render targets.
     /// </summary>
     /// <param name="force">True if release unused render targets by force, otherwise will use a few frames of delay.</param>
-    static void Flush(bool force = false);
+    /// <param name="framesOffset">Amount of previous frames that should persist in the pool after flush. Resources used more than given value wil be freed. Use value of -1 to auto pick default duration.</param>
+    static void Flush(bool force = false, int32 framesOffset = -1);
 
     /// <summary>
     /// Gets a temporary render target.
diff --git a/Source/Engine/Graphics/Shaders/Cache/ShaderAssetBase.cpp b/Source/Engine/Graphics/Shaders/Cache/ShaderAssetBase.cpp
index caebcfc3c..033d50466 100644
--- a/Source/Engine/Graphics/Shaders/Cache/ShaderAssetBase.cpp
+++ b/Source/Engine/Graphics/Shaders/Cache/ShaderAssetBase.cpp
@@ -115,27 +115,20 @@ bool ShaderAssetBase::Save()
 bool IsValidShaderCache(DataContainer<byte>& shaderCache, Array<String>& includes)
 {
     if (shaderCache.Length() == 0)
-    {
         return false;
-    }
-
     MemoryReadStream stream(shaderCache.Get(), shaderCache.Length());
 
     // Read cache format version
     int32 version;
     stream.ReadInt32(&version);
     if (version != GPU_SHADER_CACHE_VERSION)
-    {
         return false;
-    }
 
     // Read the location of additional data that contains list of included source files
     int32 additionalDataStart;
     stream.ReadInt32(&additionalDataStart);
     stream.SetPosition(additionalDataStart);
 
-    bool result = true;
-
     // Read all includes
     int32 includesCount;
     stream.ReadInt32(&includesCount);
@@ -144,28 +137,16 @@ bool IsValidShaderCache(DataContainer<byte>& shaderCache, Array<String>& include
     {
         String& include = includes.AddOne();
         stream.ReadString(&include, 11);
+        include  = ShadersCompilation::ResolveShaderPath(include);
         DateTime lastEditTime;
         stream.Read(lastEditTime);
 
         // Check if included file exists locally and has been modified since last compilation
         if (FileSystem::FileExists(include) && FileSystem::GetFileLastEditTime(include) > lastEditTime)
-        {
-            result = false;
-        }
+            return false;
     }
 
-#if 0
-    // Check duplicates
-    for (int32 i = 0; i < includes.Count(); i++)
-    {
-        if (includes.FindLast(includes[i]) != i)
-        {
-            CRASH;
-        }
-    }
-#endif
-
-    return result;
+    return true;
 }
 
 #endif
diff --git a/Source/Engine/Graphics/Textures/GPUTexture.cpp b/Source/Engine/Graphics/Textures/GPUTexture.cpp
index ccdf4be95..403f545ba 100644
--- a/Source/Engine/Graphics/Textures/GPUTexture.cpp
+++ b/Source/Engine/Graphics/Textures/GPUTexture.cpp
@@ -480,6 +480,16 @@ bool GPUTexture::Init(const GPUTextureDescription& desc)
         break;
     }
     }
+    const bool isCompressed = PixelFormatExtensions::IsCompressed(desc.Format);
+    if (isCompressed)
+    {
+        const int32 blockSize = PixelFormatExtensions::ComputeBlockSize(desc.Format);
+        if (desc.Width < blockSize || desc.Height < blockSize)
+        {
+            LOG(Warning, "Cannot create texture. Invalid dimensions. Description: {0}", desc.ToString());
+            return true;
+        }
+    }
 
     // Release previous data
     ReleaseGPU();
@@ -487,7 +497,7 @@ bool GPUTexture::Init(const GPUTextureDescription& desc)
     // Initialize
     _desc = desc;
     _sRGB = PixelFormatExtensions::IsSRGB(desc.Format);
-    _isBlockCompressed = PixelFormatExtensions::IsCompressed(desc.Format);
+    _isBlockCompressed = isCompressed;
     if (OnInit())
     {
         ReleaseGPU();
diff --git a/Source/Engine/Graphics/Textures/StreamingTexture.cpp b/Source/Engine/Graphics/Textures/StreamingTexture.cpp
index 015386fff..ea70a9d9e 100644
--- a/Source/Engine/Graphics/Textures/StreamingTexture.cpp
+++ b/Source/Engine/Graphics/Textures/StreamingTexture.cpp
@@ -114,9 +114,9 @@ bool StreamingTexture::Create(const TextureHeader& header)
     {
         // Ensure that streaming doesn't go too low because the hardware expects the texture to be min in size of compressed texture block
         int32 lastMip = header.MipLevels - 1;
-        while ((header.Width >> lastMip) < 4 && (header.Height >> lastMip) < 4)
+        while ((header.Width >> lastMip) < 4 && (header.Height >> lastMip) < 4 && lastMip > 0)
             lastMip--;
-        _minMipCountBlockCompressed = header.MipLevels - lastMip + 1;
+        _minMipCountBlockCompressed = Math::Min(header.MipLevels - lastMip + 1, header.MipLevels);
     }
 
     // Request resource streaming
@@ -296,6 +296,7 @@ Task* StreamingTexture::UpdateAllocation(int32 residency)
         // Setup texture
         if (texture->Init(desc))
         {
+            Streaming.Error = true;
             LOG(Error, "Cannot allocate texture {0}.", ToString());
         }
         if (allocatedResidency != 0)
diff --git a/Source/Engine/Graphics/Textures/TextureBase.cpp b/Source/Engine/Graphics/Textures/TextureBase.cpp
index 181955fce..c3d8898a5 100644
--- a/Source/Engine/Graphics/Textures/TextureBase.cpp
+++ b/Source/Engine/Graphics/Textures/TextureBase.cpp
@@ -223,6 +223,11 @@ void TextureBase::SetTextureGroup(int32 textureGroup)
     }
 }
 
+bool TextureBase::HasStreamingError() const
+{
+    return _texture.Streaming.Error;
+}
+
 BytesContainer TextureBase::GetMipData(int32 mipIndex, int32& rowPitch, int32& slicePitch)
 {
     BytesContainer result;
diff --git a/Source/Engine/Graphics/Textures/TextureBase.h b/Source/Engine/Graphics/Textures/TextureBase.h
index e47bb548d..befe16069 100644
--- a/Source/Engine/Graphics/Textures/TextureBase.h
+++ b/Source/Engine/Graphics/Textures/TextureBase.h
@@ -148,6 +148,11 @@ public:
     /// </summary>
     API_PROPERTY() void SetTextureGroup(int32 textureGroup);
 
+    /// <summary>
+    /// Returns true if texture streaming failed (eg. pixel format is unsupported or texture data cannot be uploaded to GPU due to memory limit).
+    /// </summary>
+    API_PROPERTY() bool HasStreamingError() const;
+
 public:
     /// <summary>
     /// Gets the mip data.
diff --git a/Source/Engine/Graphics/Textures/TextureUtils.h b/Source/Engine/Graphics/Textures/TextureUtils.h
deleted file mode 100644
index b021d27fe..000000000
--- a/Source/Engine/Graphics/Textures/TextureUtils.h
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
-
-#pragma once
-
-#include "Engine/Core/Types/BaseTypes.h"
-#include "Types.h"
-
-/// <summary>
-/// Texture utilities class
-/// </summary>
-class TextureUtils
-{
-public:
-    static PixelFormat ToPixelFormat(const TextureFormatType format, int32 width, int32 height, bool canCompress)
-    {
-        const bool canUseBlockCompression = width % 4 == 0 && height % 4 == 0;
-        if (canCompress && canUseBlockCompression)
-        {
-            switch (format)
-            {
-            case TextureFormatType::ColorRGB:
-                return PixelFormat::BC1_UNorm;
-            case TextureFormatType::ColorRGBA:
-                return PixelFormat::BC3_UNorm;
-            case TextureFormatType::NormalMap:
-                return PixelFormat::BC5_UNorm;
-            case TextureFormatType::GrayScale:
-                return PixelFormat::BC4_UNorm;
-            case TextureFormatType::HdrRGBA:
-                return PixelFormat::BC7_UNorm;
-            case TextureFormatType::HdrRGB:
-#if PLATFORM_LINUX
-                // TODO: support BC6H compression for Linux Editor
-                return PixelFormat::BC7_UNorm;
-#else
-                return PixelFormat::BC6H_Uf16;
-#endif
-            default:
-                return PixelFormat::Unknown;
-            }
-        }
-
-        switch (format)
-        {
-        case TextureFormatType::ColorRGB:
-            return PixelFormat::R8G8B8A8_UNorm;
-        case TextureFormatType::ColorRGBA:
-            return PixelFormat::R8G8B8A8_UNorm;
-        case TextureFormatType::NormalMap:
-            return PixelFormat::R16G16_UNorm;
-        case TextureFormatType::GrayScale:
-            return PixelFormat::R8_UNorm;
-        case TextureFormatType::HdrRGBA:
-            return PixelFormat::R16G16B16A16_Float;
-        case TextureFormatType::HdrRGB:
-            return PixelFormat::R11G11B10_Float;
-        default:
-            return PixelFormat::Unknown;
-        }
-    }
-};
diff --git a/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.Layers.cpp b/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.Layers.cpp
index 0b857d394..a69187f6f 100644
--- a/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.Layers.cpp
+++ b/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.Layers.cpp
@@ -247,7 +247,7 @@ void GPUDeviceVulkan::GetInstanceLayersAndExtensions(Array<const char*>& outInst
     if (foundUniqueLayers.HasItems())
     {
         LOG(Info, "Found instance layers:");
-        Sorting::QuickSort(foundUniqueLayers.Get(), foundUniqueLayers.Count());
+        Sorting::QuickSort(foundUniqueLayers);
         for (const StringAnsi& name : foundUniqueLayers)
         {
             LOG(Info, "- {0}", String(name));
@@ -257,7 +257,7 @@ void GPUDeviceVulkan::GetInstanceLayersAndExtensions(Array<const char*>& outInst
     if (foundUniqueExtensions.HasItems())
     {
         LOG(Info, "Found instance extensions:");
-        Sorting::QuickSort(foundUniqueExtensions.Get(), foundUniqueExtensions.Count());
+        Sorting::QuickSort(foundUniqueExtensions);
         for (const StringAnsi& name : foundUniqueExtensions)
         {
             LOG(Info, "- {0}", String(name));
@@ -455,7 +455,7 @@ void GPUDeviceVulkan::GetDeviceExtensionsAndLayers(VkPhysicalDevice gpu, Array<c
     if (foundUniqueLayers.HasItems())
     {
         LOG(Info, "Found device layers:");
-        Sorting::QuickSort(foundUniqueLayers.Get(), foundUniqueLayers.Count());
+        Sorting::QuickSort(foundUniqueLayers);
         for (const StringAnsi& name : foundUniqueLayers)
         {
             LOG(Info, "- {0}", String(name));
@@ -465,7 +465,7 @@ void GPUDeviceVulkan::GetDeviceExtensionsAndLayers(VkPhysicalDevice gpu, Array<c
     if (foundUniqueExtensions.HasItems())
     {
         LOG(Info, "Found device extensions:");
-        Sorting::QuickSort(foundUniqueExtensions.Get(), foundUniqueExtensions.Count());
+        Sorting::QuickSort(foundUniqueExtensions);
         for (const StringAnsi& name : foundUniqueExtensions)
         {
             LOG(Info, "- {0}", String(name));
diff --git a/Source/Engine/Level/Actor.cpp b/Source/Engine/Level/Actor.cpp
index addb4861e..bf544d9ad 100644
--- a/Source/Engine/Level/Actor.cpp
+++ b/Source/Engine/Level/Actor.cpp
@@ -206,10 +206,18 @@ void Actor::OnDeleteObject()
 #endif
     for (int32 i = 0; i < Scripts.Count(); i++)
     {
-        auto e = Scripts[i];
-        ASSERT(e->_parent == this);
-        e->_parent = nullptr;
-        e->DeleteObject();
+        auto script = Scripts[i];
+        ASSERT(script->_parent == this);
+        if (script->_wasAwakeCalled)
+        {
+            script->_wasAwakeCalled = false;
+            CHECK_EXECUTE_IN_EDITOR
+            {
+                script->OnDestroy();
+            }
+        }
+        script->_parent = nullptr;
+        script->DeleteObject();
     }
 #if BUILD_DEBUG
     ASSERT(callsCheck == Scripts.Count());
@@ -239,14 +247,8 @@ const Guid& Actor::GetSceneObjectId() const
 
 void Actor::SetParent(Actor* value, bool worldPositionsStays, bool canBreakPrefabLink)
 {
-    // Check if value won't change
     if (_parent == value)
         return;
-    if (IsDuringPlay() && !IsInMainThread())
-    {
-        LOG(Error, "Editing scene hierarchy is only allowed on a main thread.");
-        return;
-    }
 #if USE_EDITOR || !BUILD_RELEASE
     if (Is<Scene>())
     {
@@ -265,6 +267,13 @@ void Actor::SetParent(Actor* value, bool worldPositionsStays, bool canBreakPrefa
     // Detect it actor is not in a game but new parent is already in a game (we should spawn it)
     const bool isBeingSpawned = !IsDuringPlay() && newScene && value->IsDuringPlay();
 
+    // Actors system doesn't support editing scene hierarchy from multiple threads
+    if (!IsInMainThread() && (IsDuringPlay() || isBeingSpawned))
+    {
+        LOG(Error, "Editing scene hierarchy is only allowed on a main thread.");
+        return;
+    }
+
     // Handle changing scene (unregister from it)
     const bool isSceneChanging = prevScene != newScene;
     if (prevScene && isSceneChanging && wasActiveInTree)
@@ -888,9 +897,13 @@ void Actor::EndPlay()
 
     for (auto* script : Scripts)
     {
-        CHECK_EXECUTE_IN_EDITOR
+        if (script->_wasAwakeCalled)
         {
-            script->OnDestroy();
+            script->_wasAwakeCalled = false;
+            CHECK_EXECUTE_IN_EDITOR
+            {
+                script->OnDestroy();
+            }
         }
     }
 
@@ -1033,7 +1046,10 @@ void Actor::Deserialize(DeserializeStream& stream, ISerializeModifier* modifier)
             }
             else if (!parent && parentId.IsValid())
             {
-                LOG(Warning, "Missing parent actor {0} for \'{1}\'", parentId, ToString());
+                if (_prefabObjectID.IsValid())
+                    LOG(Warning, "Missing parent actor {0} for \'{1}\', prefab object {2}", parentId, ToString(), _prefabObjectID);
+                else
+                    LOG(Warning, "Missing parent actor {0} for \'{1}\'", parentId, ToString());
             }
         }
     }
diff --git a/Source/Engine/Level/Actors/SkyLight.cpp b/Source/Engine/Level/Actors/SkyLight.cpp
index 93e2a8276..7894ef1c3 100644
--- a/Source/Engine/Level/Actors/SkyLight.cpp
+++ b/Source/Engine/Level/Actors/SkyLight.cpp
@@ -99,6 +99,8 @@ void SkyLight::UpdateBounds()
 {
     _sphere = BoundingSphere(GetPosition(), GetScaledRadius());
     BoundingBox::FromSphere(_sphere, _box);
+    if (_sceneRenderingKey != -1)
+        GetSceneRendering()->UpdateActor(this, _sceneRenderingKey);
 }
 
 void SkyLight::Draw(RenderContext& renderContext)
diff --git a/Source/Engine/Level/Level.cpp b/Source/Engine/Level/Level.cpp
index 5f1432d31..41033876d 100644
--- a/Source/Engine/Level/Level.cpp
+++ b/Source/Engine/Level/Level.cpp
@@ -439,7 +439,7 @@ public:
 
     bool Do() const override
     {
-        auto scene = Scripting::FindObject<Scene>(TargetScene);
+        auto scene = Level::FindScene(TargetScene);
         if (!scene)
             return true;
         return unloadScene(scene);
@@ -934,13 +934,13 @@ bool Level::loadScene(rapidjson_flax::Value& data, int32 engineBuild, Scene** ou
 
     // Loaded scene objects list
     CollectionPoolCache<ActorsCache::SceneObjectsListType>::ScopeCache sceneObjects = ActorsCache::SceneObjectsListCache.Get();
-    const int32 objectsCount = (int32)data.Size();
-    sceneObjects->Resize(objectsCount);
+    const int32 dataCount = (int32)data.Size();
+    sceneObjects->Resize(dataCount);
     sceneObjects->At(0) = scene;
 
     // Spawn all scene objects
     SceneObjectsFactory::Context context(modifier.Value);
-    context.Async = JobSystem::GetThreadsCount() > 1 && objectsCount > 10;
+    context.Async = JobSystem::GetThreadsCount() > 1 && dataCount > 10;
     {
         PROFILE_CPU_NAMED("Spawn");
         SceneObject** objects = sceneObjects->Get();
@@ -963,12 +963,12 @@ bool Level::loadScene(rapidjson_flax::Value& data, int32 engineBuild, Scene** ou
                 }
                 else
                     SceneObjectsFactory::HandleObjectDeserializationError(stream);
-            }, objectsCount - 1);
+            }, dataCount - 1);
             ScenesLock.Lock();
         }
         else
         {
-            for (int32 i = 1; i < objectsCount; i++) // start from 1. at index [0] was scene
+            for (int32 i = 1; i < dataCount; i++) // start from 1. at index [0] was scene
             {
                 auto& stream = data[i];
                 auto obj = SceneObjectsFactory::Spawn(context, stream);
@@ -1012,13 +1012,13 @@ bool Level::loadScene(rapidjson_flax::Value& data, int32 engineBuild, Scene** ou
                     SceneObjectsFactory::Deserialize(context, obj, data[i]);
                     idMapping = nullptr;
                 }
-            }, objectsCount - 1);
+            }, dataCount - 1);
             ScenesLock.Lock();
         }
         else
         {
             Scripting::ObjectsLookupIdMapping.Set(&modifier.Value->IdsMapping);
-            for (int32 i = 1; i < objectsCount; i++) // start from 1. at index [0] was scene
+            for (int32 i = 1; i < dataCount; i++) // start from 1. at index [0] was scene
             {
                 auto& objData = data[i];
                 auto obj = objects[i];
@@ -1049,7 +1049,7 @@ bool Level::loadScene(rapidjson_flax::Value& data, int32 engineBuild, Scene** ou
         PROFILE_CPU_NAMED("Initialize");
 
         SceneObject** objects = sceneObjects->Get();
-        for (int32 i = 0; i < objectsCount; i++)
+        for (int32 i = 0; i < dataCount; i++)
         {
             SceneObject* obj = objects[i];
             if (obj)
diff --git a/Source/Engine/Level/Prefabs/Prefab.Apply.cpp b/Source/Engine/Level/Prefabs/Prefab.Apply.cpp
index c10ea532d..35b02bf40 100644
--- a/Source/Engine/Level/Prefabs/Prefab.Apply.cpp
+++ b/Source/Engine/Level/Prefabs/Prefab.Apply.cpp
@@ -22,6 +22,7 @@
 #include "Engine/ContentImporters/CreateJson.h"
 #include "Engine/Debug/Exceptions/ArgumentNullException.h"
 #include "Engine/Profiler/ProfilerCPU.h"
+#include "Engine/Threading/MainThreadTask.h"
 #include "Editor/Editor.h"
 
 // Apply flow:
@@ -174,6 +175,12 @@ public:
     /// <param name="newObjectIds">Collection with ids of the objects (actors and scripts) from the prefab after changes apply. Used to find new objects or old objects and use this information during changes sync (eg. generate ids for the new objects to prevent ids collisions).</param>
     /// <returns>True if failed, otherwise false.</returns>
     static bool SynchronizePrefabInstances(PrefabInstancesData& prefabInstancesData, Actor* defaultInstance, SceneObjectsListCacheType& sceneObjects, const Guid& prefabId, rapidjson_flax::StringBuffer& tmpBuffer, const Array<Guid>& oldObjectsIds, const Array<Guid>& newObjectIds);
+
+    static void DeletePrefabObject(SceneObject* obj)
+    {
+        obj->SetParent(nullptr);
+        obj->DeleteObject();
+    }
 };
 
 void PrefabInstanceData::CollectPrefabInstances(PrefabInstancesData& prefabInstancesData, const Guid& prefabId, Actor* defaultInstance, Actor* targetActor)
@@ -302,14 +309,10 @@ bool PrefabInstanceData::SynchronizePrefabInstances(PrefabInstancesData& prefabI
                 {
                     // Remove object
                     LOG(Info, "Removing object {0} from instance {1} (prefab: {2})", obj->GetSceneObjectId(), instance.TargetActor->ToString(), prefabId);
-
-                    obj->DeleteObject();
-                    obj->SetParent(nullptr);
-
+                    DeletePrefabObject(obj);
                     sceneObjects.Value->RemoveAtKeepOrder(i);
                     existingObjectsCount--;
                     i--;
-
                     continue;
                 }
 
@@ -358,10 +361,7 @@ bool PrefabInstanceData::SynchronizePrefabInstances(PrefabInstancesData& prefabI
                 {
                     // Remove object removed from the prefab
                     LOG(Info, "Removing prefab instance object {0} from instance {1} (prefab object: {2}, prefab: {3})", obj->GetSceneObjectId(), instance.TargetActor->ToString(), obj->GetPrefabObjectID(), prefabId);
-
-                    obj->DeleteObject();
-                    obj->SetParent(nullptr);
-
+                    DeletePrefabObject(obj);
                     sceneObjects.Value->RemoveAtKeepOrder(i);
                     deserializeSceneObjectIndex--;
                     existingObjectsCount--;
@@ -633,6 +633,19 @@ bool Prefab::ApplyAll(Actor* targetActor)
             }
         }
     }
+    if (!IsInMainThread())
+    {
+        // Prefabs cannot be updated on async thread so sync it with a Main Thread
+        bool result = true;
+        Function<void()> action = [&]
+        {
+            result = ApplyAll(targetActor);
+        };
+        const auto task = Task::StartNew(New<MainThreadActionTask>(action));
+        if (task->Wait(TimeSpan::FromSeconds(10)))
+            result = true;
+        return result;
+    }
 
     // Prevent cyclic references
     {
@@ -921,9 +934,7 @@ bool Prefab::ApplyAllInternal(Actor* targetActor, bool linkTargetActorObjectToPr
             {
                 // Remove object removed from the prefab
                 LOG(Info, "Removing object {0} from prefab default instance", obj->GetSceneObjectId());
-
-                obj->DeleteObject();
-                obj->SetParent(nullptr);
+                PrefabInstanceData::DeletePrefabObject(obj);
                 sceneObjects->At(i) = nullptr;
             }
         }
@@ -1219,14 +1230,14 @@ bool Prefab::SyncChangesInternal(PrefabInstancesData& prefabInstancesData)
     {
         ScopeLock lock(Locker);
         _isCreatingDefaultInstance = true;
-        _defaultInstance = PrefabManager::SpawnPrefab(this, Transform::Identity, nullptr, &ObjectsCache, true);
+        _defaultInstance = PrefabManager::SpawnPrefab(this, nullptr, &ObjectsCache, true);
         _isCreatingDefaultInstance = false;
     }
 
     // Instantiate prefab instance from prefab (default spawning logic)
     // Note: it will get any added or removed objects from the nested prefabs
     // TODO: try to optimize by using recreated default instance to ApplyAllInternal (will need special path there if apply is done with default instance to unlink it instead of destroying)
-    const auto targetActor = PrefabManager::SpawnPrefab(this, Transform::Identity, nullptr, nullptr, true);
+    const auto targetActor = PrefabManager::SpawnPrefab(this, nullptr, nullptr, true);
     if (targetActor == nullptr)
     {
         LOG(Warning, "Failed to instantiate default prefab instance from changes synchronization.");
diff --git a/Source/Engine/Level/Prefabs/Prefab.cpp b/Source/Engine/Level/Prefabs/Prefab.cpp
index b72f16633..25a2bd086 100644
--- a/Source/Engine/Level/Prefabs/Prefab.cpp
+++ b/Source/Engine/Level/Prefabs/Prefab.cpp
@@ -76,7 +76,7 @@ Actor* Prefab::GetDefaultInstance()
     _isCreatingDefaultInstance = true;
 
     // Instantiate objects from prefab (default spawning logic)
-    _defaultInstance = PrefabManager::SpawnPrefab(this, Transform::Identity, nullptr, &ObjectsCache);
+    _defaultInstance = PrefabManager::SpawnPrefab(this, nullptr, &ObjectsCache);
 
     _isCreatingDefaultInstance = false;
     return _defaultInstance;
@@ -87,17 +87,12 @@ SceneObject* Prefab::GetDefaultInstance(const Guid& objectId)
     const auto result = GetDefaultInstance();
     if (!result)
         return nullptr;
-
     if (objectId.IsValid())
     {
-        const void* object;
+        SceneObject* object;
         if (ObjectsCache.TryGet(objectId, object))
-        {
-            // Actor or Script
-            return (SceneObject*)object;
-        }
+            return object;
     }
-
     return result;
 }
 
diff --git a/Source/Engine/Level/Prefabs/Prefab.h b/Source/Engine/Level/Prefabs/Prefab.h
index 5e0075edf..9fa2b4fd0 100644
--- a/Source/Engine/Level/Prefabs/Prefab.h
+++ b/Source/Engine/Level/Prefabs/Prefab.h
@@ -44,7 +44,7 @@ public:
     /// <summary>
     /// The objects cache maps the id of the object contained in the prefab asset (actor or script) to the default instance deserialized from prefab data. Valid only if asset is loaded and GetDefaultInstance was called.
     /// </summary>
-    Dictionary<Guid, const void*> ObjectsCache;
+    Dictionary<Guid, SceneObject*> ObjectsCache;
 
 public:
     /// <summary>
diff --git a/Source/Engine/Level/Prefabs/PrefabManager.cpp b/Source/Engine/Level/Prefabs/PrefabManager.cpp
index c7b42b7d2..d99a89e39 100644
--- a/Source/Engine/Level/Prefabs/PrefabManager.cpp
+++ b/Source/Engine/Level/Prefabs/PrefabManager.cpp
@@ -76,12 +76,12 @@ Actor* PrefabManager::SpawnPrefab(Prefab* prefab, Actor* parent)
     return SpawnPrefab(prefab, Transform(Vector3::Minimum), parent, nullptr);
 }
 
-Actor* PrefabManager::SpawnPrefab(Prefab* prefab, Actor* parent, Dictionary<Guid, const void*>* objectsCache, bool withSynchronization)
+Actor* PrefabManager::SpawnPrefab(Prefab* prefab, Actor* parent, Dictionary<Guid, SceneObject*>* objectsCache, bool withSynchronization)
 {
     return SpawnPrefab(prefab, Transform(Vector3::Minimum), parent, objectsCache, withSynchronization);
 }
 
-Actor* PrefabManager::SpawnPrefab(Prefab* prefab, const Transform& transform, Actor* parent, Dictionary<Guid, const void*>* objectsCache, bool withSynchronization)
+Actor* PrefabManager::SpawnPrefab(Prefab* prefab, const Transform& transform, Actor* parent, Dictionary<Guid, SceneObject*>* objectsCache, bool withSynchronization)
 {
     PROFILE_CPU_NAMED("Prefab.Spawn");
     if (prefab == nullptr)
@@ -94,8 +94,8 @@ Actor* PrefabManager::SpawnPrefab(Prefab* prefab, const Transform& transform, Ac
         LOG(Warning, "Waiting for prefab asset be loaded failed. {0}", prefab->ToString());
         return nullptr;
     }
-    const int32 objectsCount = prefab->ObjectsCount;
-    if (objectsCount == 0)
+    const int32 dataCount = prefab->ObjectsCount;
+    if (dataCount == 0)
     {
         LOG(Warning, "Prefab has no objects. {0}", prefab->ToString());
         return nullptr;
@@ -107,7 +107,7 @@ Actor* PrefabManager::SpawnPrefab(Prefab* prefab, const Transform& transform, Ac
 
     // Prepare
     CollectionPoolCache<ActorsCache::SceneObjectsListType>::ScopeCache sceneObjects = ActorsCache::SceneObjectsListCache.Get();
-    sceneObjects->Resize(objectsCount);
+    sceneObjects->Resize(dataCount);
     CollectionPoolCache<ISerializeModifier, Cache::ISerializeModifierClearCallback>::ScopeCache modifier = Cache::ISerializeModifier.Get();
     modifier->EngineBuild = prefab->DataEngineBuild;
     modifier->IdsMapping.EnsureCapacity(prefab->ObjectsIds.Count() * 4);
@@ -126,7 +126,7 @@ Actor* PrefabManager::SpawnPrefab(Prefab* prefab, const Transform& transform, Ac
     // Deserialize prefab objects
     auto prevIdMapping = Scripting::ObjectsLookupIdMapping.Get();
     Scripting::ObjectsLookupIdMapping.Set(&modifier.Value->IdsMapping);
-    for (int32 i = 0; i < objectsCount; i++)
+    for (int32 i = 0; i < dataCount; i++)
     {
         auto& stream = data[i];
         SceneObject* obj = SceneObjectsFactory::Spawn(context, stream);
@@ -145,7 +145,7 @@ Actor* PrefabManager::SpawnPrefab(Prefab* prefab, const Transform& transform, Ac
         SceneObjectsFactory::SynchronizeNewPrefabInstances(context, prefabSyncData);
         Scripting::ObjectsLookupIdMapping.Set(&modifier.Value->IdsMapping);
     }
-    for (int32 i = 0; i < objectsCount; i++)
+    for (int32 i = 0; i < dataCount; i++)
     {
         auto& stream = data[i];
         SceneObject* obj = sceneObjects->At(i);
@@ -154,28 +154,6 @@ Actor* PrefabManager::SpawnPrefab(Prefab* prefab, const Transform& transform, Ac
     }
     Scripting::ObjectsLookupIdMapping.Set(prevIdMapping);
 
-    // Pick prefab root object
-    if (sceneObjects->IsEmpty())
-    {
-        LOG(Warning, "No valid objects in prefab.");
-        return nullptr;
-    }
-    Actor* root = nullptr;
-    const Guid prefabRootObjectId = prefab->GetRootObjectId();
-    for (int32 i = 0; i < objectsCount; i++)
-    {
-        if (JsonTools::GetGuid(data[i], "ID") == prefabRootObjectId)
-        {
-            root = dynamic_cast<Actor*>(sceneObjects->At(i));
-            break;
-        }
-    }
-    if (!root)
-    {
-        LOG(Warning, "Missing prefab root object.");
-        return nullptr;
-    }
-
     // Synchronize prefab instances (prefab may have new objects added or some removed so deserialized instances need to synchronize with it)
     if (withSynchronization)
     {
@@ -183,6 +161,30 @@ Actor* PrefabManager::SpawnPrefab(Prefab* prefab, const Transform& transform, Ac
         SceneObjectsFactory::SynchronizePrefabInstances(context, prefabSyncData);
     }
 
+    // Pick prefab root object
+    Actor* root = nullptr;
+    const Guid prefabRootObjectId = prefab->GetRootObjectId();
+    for (int32 i = 0; i < dataCount && !root; i++)
+    {
+        if (JsonTools::GetGuid(data[i], "ID") == prefabRootObjectId)
+            root = dynamic_cast<Actor*>(sceneObjects->At(i));
+    }
+    if (!root)
+    {
+        // Fallback to the first actor that has no parent
+        for (int32 i = 0; i < sceneObjects->Count() && !root; i++)
+        {
+            SceneObject* obj = sceneObjects->At(i);
+            if (obj && !obj->GetParent())
+                root = dynamic_cast<Actor*>(obj);
+        }
+    }
+    if (!root)
+    {
+        LOG(Warning, "Missing prefab root object. {0}", prefab->ToString());
+        return nullptr;
+    }
+
     // Prepare parent linkage for prefab root actor
     if (root->_parent)
         root->_parent->Children.Remove(root);
@@ -264,7 +266,7 @@ Actor* PrefabManager::SpawnPrefab(Prefab* prefab, const Transform& transform, Ac
     }
 
     // Link objects to prefab (only deserialized from prefab data)
-    for (int32 i = 0; i < objectsCount; i++)
+    for (int32 i = 0; i < dataCount; i++)
     {
         auto& stream = data[i];
         SceneObject* obj = sceneObjects->At(i);
diff --git a/Source/Engine/Level/Prefabs/PrefabManager.h b/Source/Engine/Level/Prefabs/PrefabManager.h
index 16d4a29cf..ad990da9f 100644
--- a/Source/Engine/Level/Prefabs/PrefabManager.h
+++ b/Source/Engine/Level/Prefabs/PrefabManager.h
@@ -89,7 +89,7 @@ API_CLASS(Static) class FLAXENGINE_API PrefabManager
     /// <param name="objectsCache">The options output objects cache that can be filled with prefab object id mapping to deserialized object (actor or script).</param>
     /// <param name="withSynchronization">True if perform prefab changes synchronization for the spawned objects. It will check if need to add new objects due to nested prefab modifications.</param>
     /// <returns>The created actor (root) or null if failed.</returns>
-    static Actor* SpawnPrefab(Prefab* prefab, Actor* parent, Dictionary<Guid, const void*, HeapAllocation>* objectsCache, bool withSynchronization = false);
+    static Actor* SpawnPrefab(Prefab* prefab, Actor* parent, Dictionary<Guid, SceneObject*, HeapAllocation>* objectsCache, bool withSynchronization = true);
 
     /// <summary>
     /// Spawns the instance of the prefab objects. If parent actor is specified then created actors are fully initialized (OnLoad event and BeginPlay is called if parent actor is already during gameplay).
@@ -100,7 +100,7 @@ API_CLASS(Static) class FLAXENGINE_API PrefabManager
     /// <param name="objectsCache">The options output objects cache that can be filled with prefab object id mapping to deserialized object (actor or script).</param>
     /// <param name="withSynchronization">True if perform prefab changes synchronization for the spawned objects. It will check if need to add new objects due to nested prefab modifications.</param>
     /// <returns>The created actor (root) or null if failed.</returns>
-    static Actor* SpawnPrefab(Prefab* prefab, const Transform& transform, Actor* parent, Dictionary<Guid, const void*, HeapAllocation>* objectsCache, bool withSynchronization = false);
+    static Actor* SpawnPrefab(Prefab* prefab, const Transform& transform, Actor* parent, Dictionary<Guid, SceneObject*, HeapAllocation>* objectsCache, bool withSynchronization = true);
 
 #if USE_EDITOR
 
diff --git a/Source/Engine/Level/SceneInfo.cpp b/Source/Engine/Level/SceneInfo.cpp
index 65e4aa462..9c504bad7 100644
--- a/Source/Engine/Level/SceneInfo.cpp
+++ b/Source/Engine/Level/SceneInfo.cpp
@@ -11,29 +11,6 @@ String SceneInfo::ToString() const
     return TEXT("SceneInfo");
 }
 
-const int32 lightmapAtlasSizes[] =
-{
-    32,
-    64,
-    128,
-    256,
-    512,
-    1024,
-    2048,
-    4096
-};
-DECLARE_ENUM_8(LightmapAtlasSize, _32, _64, _128, _256, _512, _1024, _2048, _4096);
-
-LightmapAtlasSize getLightmapAtlasSize(int32 size)
-{
-    for (int32 i = 0; i < LightmapAtlasSize_Count; i++)
-    {
-        if (lightmapAtlasSizes[i] == size)
-            return (LightmapAtlasSize)i;
-    }
-    return LightmapAtlasSize::_1024;
-}
-
 void SceneInfo::Serialize(SerializeStream& stream, const void* otherObj)
 {
     SERIALIZE_GET_OTHER_OBJ(SceneInfo);
diff --git a/Source/Engine/Level/SceneObjectsFactory.cpp b/Source/Engine/Level/SceneObjectsFactory.cpp
index 2ae947c85..d9c86d250 100644
--- a/Source/Engine/Level/SceneObjectsFactory.cpp
+++ b/Source/Engine/Level/SceneObjectsFactory.cpp
@@ -16,8 +16,9 @@
 #if !BUILD_RELEASE || USE_EDITOR
 #include "Engine/Level/Level.h"
 #include "Engine/Threading/Threading.h"
-#include "Engine/Level/Components/MissingScript.h"
+#include "Engine/Level/Scripts/MissingScript.h"
 #endif
+#include "Engine/Level/Scripts/ModelPrefab.h"
 
 #if USE_EDITOR
 
@@ -46,6 +47,11 @@ void MissingScript::SetReferenceScript(const ScriptingObjectReference<Script>& v
 
 #endif
 
+ModelPrefab::ModelPrefab(const SpawnParams& params)
+    : Script(params)
+{
+}
+
 SceneObjectsFactory::Context::Context(ISerializeModifier* modifier)
     : Modifier(modifier)
 {
@@ -132,7 +138,7 @@ SceneObject* SceneObjectsFactory::Spawn(Context& context, const ISerializable::D
         auto prefab = Content::LoadAsync<Prefab>(prefabId);
         if (prefab == nullptr)
         {
-            LOG(Warning, "Missing prefab with id={0}.", prefabId);
+            LOG(Warning, "Missing prefab {0}.", prefabId);
             return nullptr;
         }
         if (prefab->WaitForLoaded())
@@ -258,7 +264,7 @@ void SceneObjectsFactory::Deserialize(Context& context, SceneObject* obj, ISeria
         auto prefab = Content::LoadAsync<Prefab>(prefabId);
         if (prefab == nullptr)
         {
-            LOG(Warning, "Missing prefab with id={0}.", prefabId);
+            LOG(Warning, "Missing prefab {0}.", prefabId);
             return;
         }
         if (prefab->WaitForLoaded())
@@ -311,11 +317,13 @@ void SceneObjectsFactory::HandleObjectDeserializationError(const ISerializable::
         {
 #if USE_EDITOR
             // Add dummy script
-            auto* dummyScript = parent->AddScript<MissingScript>();
             const auto typeNameMember = value.FindMember("TypeName");
             if (typeNameMember != value.MemberEnd() && typeNameMember->value.IsString())
+            {
+                auto* dummyScript = parent->AddScript<MissingScript>();
                 dummyScript->MissingTypeName = typeNameMember->value.GetString();
-            dummyScript->Data = MoveTemp(bufferStr);
+                dummyScript->Data = MoveTemp(bufferStr);
+            }
 #endif
             LOG(Warning, "Parent actor of the missing object: {0}", parent->GetName());
         }
@@ -418,9 +426,6 @@ void SceneObjectsFactory::SetupPrefabInstances(Context& context, const PrefabSyn
     ASSERT(count <= data.SceneObjects.Count());
     for (int32 i = 0; i < count; i++)
     {
-        const SceneObject* obj = data.SceneObjects[i];
-        if (!obj)
-            continue;
         const auto& stream = data.Data[i];
         Guid prefabObjectId, prefabId;
         if (!JsonTools::GetGuidIfValid(prefabObjectId, stream, "PrefabObjectID"))
@@ -430,15 +435,18 @@ void SceneObjectsFactory::SetupPrefabInstances(Context& context, const PrefabSyn
         Guid parentId = JsonTools::GetGuid(stream, "ParentID");
         for (int32 j = i - 1; j >= 0; j--)
         {
-            // Find instance ID of the parent to this object (use data in json for relationship)
+            // Find ID of the parent to this object (use data in json for relationship)
             if (parentId == JsonTools::GetGuid(data.Data[j], "ID") && data.SceneObjects[j])
             {
                 parentId = data.SceneObjects[j]->GetID();
                 break;
             }
         }
-        const Guid id = obj->GetID();
+        const SceneObject* obj = data.SceneObjects[i];
+        const Guid id = obj ? obj->GetID() : JsonTools::GetGuid(stream, "ID");
         auto prefab = Content::LoadAsync<Prefab>(prefabId);
+        if (!prefab)
+            continue;
 
         // Check if it's parent is in the same prefab
         int32 index;
@@ -453,6 +461,8 @@ void SceneObjectsFactory::SetupPrefabInstances(Context& context, const PrefabSyn
             auto& e = context.Instances.AddOne();
             e.Prefab = prefab;
             e.RootId = id;
+            e.RootIndex = i;
+            e.StatIndex = i;
         }
         context.ObjectToInstance[id] = index;
 
@@ -484,6 +494,85 @@ void SceneObjectsFactory::SynchronizeNewPrefabInstances(Context& context, Prefab
     Scripting::ObjectsLookupIdMapping.Set(&data.Modifier->IdsMapping);
     data.InitialCount = data.SceneObjects.Count();
 
+    // Recreate any missing prefab root objects that were deleted (eg. spawned prefab got its root changed and deleted so old prefab instance needs to respawn it)
+    for (int32 instanceIndex = 0; instanceIndex < context.Instances.Count(); instanceIndex++)
+    {
+        PrefabInstance& instance = context.Instances[instanceIndex];
+        SceneObject* root = data.SceneObjects[instance.RootIndex];
+        if (!root && instance.Prefab)
+        {
+            instance.FixRootParent = true;
+
+            // Check if current prefab root existed in the deserialized data
+            const auto& oldRootData = data.Data[instance.RootIndex];
+            const Guid oldRootId = JsonTools::GetGuid(oldRootData, "ID");
+            const Guid prefabObjectId = JsonTools::GetGuid(oldRootData, "PrefabObjectID");
+            const Guid prefabRootId = instance.Prefab->GetRootObjectId();
+            Guid id;
+            int32 idInstance = -1;
+            bool syncNewRoot = false;
+            if (instance.IdsMapping.TryGet(prefabRootId, id) && context.ObjectToInstance.TryGet(id, idInstance) && idInstance == instanceIndex)
+            {
+                // Update the missing root with the valid object from this prefab instance
+                LOG(Warning, "Changed prefab instance root from ID={0}, PrefabObjectID={1} to ID={2}, PrefabObjectID={3} ({4})", instance.RootId, prefabObjectId, id, prefabRootId, instance.Prefab->ToString());
+            }
+            else
+            {
+                LOG(Warning, "Missing prefab instance root (ID={0}, PrefabObjectID={1}, {2})", instance.RootId, prefabObjectId, instance.Prefab->ToString());
+
+                // Get prefab object data from the prefab
+                const ISerializable::DeserializeStream* prefabData;
+                if (!instance.Prefab->ObjectsDataCache.TryGet(prefabRootId, prefabData))
+                {
+                    LOG(Warning, "Missing object {1} data in prefab {0}.", instance.Prefab->ToString(), prefabObjectId);
+                    continue;
+                }
+
+                // Map prefab object ID to the new prefab object instance
+                id = Guid::New();
+                data.Modifier->IdsMapping[prefabRootId] = id;
+
+                // Create prefab instance (recursive prefab loading to support nested prefabs)
+                root = Spawn(context, *prefabData);
+                if (!root)
+                {
+                    LOG(Warning, "Failed to create object {1} from prefab {0}.", instance.Prefab->ToString(), prefabRootId);
+                    continue;
+                }
+
+                // Register object
+                root->RegisterObject();
+                data.SceneObjects.Add(root);
+                auto& newObj = data.NewObjects.AddOne();
+                newObj.Prefab = instance.Prefab;
+                newObj.PrefabData = prefabData;
+                newObj.PrefabObjectId = prefabRootId;
+                newObj.Id = id;
+                context.ObjectToInstance[id] = instanceIndex;
+                syncNewRoot = true;
+            }
+
+            // Update prefab root info
+            instance.RootId = id;
+            instance.RootIndex = data.SceneObjects.Find(Scripting::FindObject<SceneObject>(id));
+            CHECK(instance.RootIndex != -1);
+
+            // Remap removed prefab root into the current root (can be different type but is needed for proper hierarchy linkage)
+            instance.IdsMapping[prefabObjectId] = id;
+            instance.IdsMapping[prefabRootId] = id;
+            instance.IdsMapping[oldRootId] = id;
+            data.Modifier->IdsMapping[prefabObjectId] = id;
+            data.Modifier->IdsMapping[prefabRootId] = id;
+            data.Modifier->IdsMapping[oldRootId] = id;
+
+            // Add any sub-objects that are missing (in case new root was created)
+            if (syncNewRoot)
+            {
+                SynchronizeNewPrefabInstances(context, data, instance.Prefab, (Actor*)root, prefabRootId, instance.RootIndex, oldRootData);
+            }
+        }
+    }
+
     // Check all actors with prefab linkage for adding missing objects
     for (int32 i = 0; i < data.InitialCount; i++)
     {
@@ -498,13 +587,12 @@ void SceneObjectsFactory::SynchronizeNewPrefabInstances(Context& context, Prefab
             continue;
         if (!JsonTools::GetGuidIfValid(actorId, stream, "ID"))
             continue;
-        const Guid actorParentId = JsonTools::GetGuid(stream, "ParentID");
 
         // Load prefab
         auto prefab = Content::LoadAsync<Prefab>(prefabId);
         if (prefab == nullptr)
         {
-            LOG(Warning, "Missing prefab with id={0}.", prefabId);
+            LOG(Warning, "Missing prefab {0}.", prefabId);
             continue;
         }
         if (prefab->WaitForLoaded())
@@ -513,66 +601,7 @@ void SceneObjectsFactory::SynchronizeNewPrefabInstances(Context& context, Prefab
             continue;
         }
 
-        // Check for RemovedObjects list
-        const auto removedObjects = SERIALIZE_FIND_MEMBER(stream, "RemovedObjects");
-
-        // Check if the given actor has new children or scripts added (inside the prefab that it uses)
-        // TODO: consider caching prefab objects structure maybe to boost this logic?
-        for (auto it = prefab->ObjectsDataCache.Begin(); it.IsNotEnd(); ++it)
-        {
-            // Use only objects that are linked to the current actor
-            const Guid parentId = JsonTools::GetGuid(*it->Value, "ParentID");
-            if (parentId != actorPrefabObjectId)
-                continue;
-
-            // Skip if object was marked to be removed per instance
-            const Guid prefabObjectId = JsonTools::GetGuid(*it->Value, "ID");
-            if (removedObjects != stream.MemberEnd())
-            {
-                auto& list = removedObjects->value;
-                const int32 size = static_cast<int32>(list.Size());
-                bool removed = false;
-                for (int32 j = 0; j < size; j++)
-                {
-                    if (JsonTools::GetGuid(list[j]) == prefabObjectId)
-                    {
-                        removed = true;
-                        break;
-                    }
-                }
-                if (removed)
-                    continue;
-            }
-
-            // Use only objects that are missing
-            bool spawned = false;
-            for (int32 j = i + 1; j < data.InitialCount; j++)
-            {
-                const auto& jData = data.Data[j];
-                const Guid jParentId = JsonTools::GetGuid(jData, "ParentID");
-                //if (jParentId == actorParentId)
-                //    break;
-                //if (jParentId != actorId)
-                //    continue;
-                const Guid jPrefabObjectId = JsonTools::GetGuid(jData, "PrefabObjectID");
-                if (jPrefabObjectId != prefabObjectId)
-                    continue;
-
-                // This object exists in the saved scene objects list
-                spawned = true;
-                break;
-            }
-            if (spawned)
-                continue;
-
-            // Map prefab object id to this actor's prefab instance so the new objects gets added to it
-            context.SetupIdsMapping(actor, data.Modifier);
-            data.Modifier->IdsMapping[actorPrefabObjectId] = actor->GetID();
-            Scripting::ObjectsLookupIdMapping.Set(&data.Modifier->IdsMapping);
-
-            // Create instance (including all children)
-            SynchronizeNewPrefabInstance(context, data, prefab, actor, prefabObjectId);
-        }
+        SynchronizeNewPrefabInstances(context, data, prefab, actor, actorPrefabObjectId, i, stream);
     }
 
     Scripting::ObjectsLookupIdMapping.Set(nullptr);
@@ -599,7 +628,7 @@ void SceneObjectsFactory::SynchronizePrefabInstances(Context& context, PrefabSyn
         auto prefab = Content::LoadAsync<Prefab>(prefabId);
         if (prefab == nullptr)
         {
-            LOG(Warning, "Missing prefab with id={0}.", prefabId);
+            LOG(Warning, "Missing prefab {0}.", prefabId);
             continue;
         }
         if (prefab->WaitForLoaded())
@@ -620,7 +649,7 @@ void SceneObjectsFactory::SynchronizePrefabInstances(Context& context, PrefabSyn
             // Invalid connection object found!
             LOG(Info, "Object {0} has invalid parent object {4} -> {5} (PrefabObjectID: {1}, PrefabID: {2}, Path: {3})", obj->GetSceneObjectId(), prefabObjectId, prefab->GetID(), prefab->GetPath(), parentPrefabObjectId, actualParentPrefabId);
 
-            // Map actual prefab object id to the current scene objects collection
+            // Map actual prefab object ID to the current scene objects collection
             context.SetupIdsMapping(obj, data.Modifier);
             data.Modifier->IdsMapping.TryGet(actualParentPrefabId, actualParentPrefabId);
 
@@ -640,15 +669,12 @@ void SceneObjectsFactory::SynchronizePrefabInstances(Context& context, PrefabSyn
         if (i != 0)
         {
             const auto defaultInstance = prefab->GetDefaultInstance(obj->GetPrefabObjectID());
-            if (defaultInstance)
-            {
-                obj->SetOrderInParent(defaultInstance->GetOrderInParent());
-            }
+            const int32 order = defaultInstance ? defaultInstance->GetOrderInParent() : -1;
+            if (order != -1)
+                obj->SetOrderInParent(order);
         }
     }
 
-    Scripting::ObjectsLookupIdMapping.Set(&data.Modifier->IdsMapping);
-
     // Synchronize new prefab objects
     for (int32 i = 0; i < data.NewObjects.Count(); i++)
     {
@@ -656,20 +682,97 @@ void SceneObjectsFactory::SynchronizePrefabInstances(Context& context, PrefabSyn
         auto& newObj = data.NewObjects[i];
 
         // Deserialize object with prefab data
+        Scripting::ObjectsLookupIdMapping.Set(&data.Modifier->IdsMapping);
         Deserialize(context, obj, *(ISerializable::DeserializeStream*)newObj.PrefabData);
         obj->LinkPrefab(newObj.Prefab->GetID(), newObj.PrefabObjectId);
 
         // Preserve order in parent (values from prefab are used)
         const auto defaultInstance = newObj.Prefab->GetDefaultInstance(newObj.PrefabObjectId);
-        if (defaultInstance)
+        const int32 order = defaultInstance ? defaultInstance->GetOrderInParent() : -1;
+        if (order != -1)
+            obj->SetOrderInParent(order);
+    }
+
+    // Setup hierarchy for the prefab instances (ensure any new objects are connected)
+    for (const auto& instance : context.Instances)
+    {
+        const auto& prefabStartData = data.Data[instance.StatIndex];
+        Guid prefabStartParentId;
+        if (instance.FixRootParent && JsonTools::GetGuidIfValid(prefabStartParentId, prefabStartData, "ParentID"))
         {
-            obj->SetOrderInParent(defaultInstance->GetOrderInParent());
+            auto* root = data.SceneObjects[instance.RootIndex];
+            const auto rootParent = Scripting::FindObject<Actor>(prefabStartParentId);
+            root->SetParent(rootParent, false);
         }
     }
 
     Scripting::ObjectsLookupIdMapping.Set(nullptr);
 }
 
+void SceneObjectsFactory::SynchronizeNewPrefabInstances(Context& context, PrefabSyncData& data, Prefab* prefab, Actor* actor, const Guid& actorPrefabObjectId, int32 i, const ISerializable::DeserializeStream& stream)
+{
+    // Check for RemovedObjects list
+    const auto removedObjects = SERIALIZE_FIND_MEMBER(stream, "RemovedObjects");
+
+    // Check if the given actor has new children or scripts added (inside the prefab that it uses)
+    // TODO: consider caching prefab objects structure maybe to boost this logic?
+    for (auto it = prefab->ObjectsDataCache.Begin(); it.IsNotEnd(); ++it)
+    {
+        // Use only objects that are linked to the current actor
+        const Guid parentId = JsonTools::GetGuid(*it->Value, "ParentID");
+        if (parentId != actorPrefabObjectId)
+            continue;
+
+        // Skip if object was marked to be removed per instance
+        const Guid prefabObjectId = JsonTools::GetGuid(*it->Value, "ID");
+        if (removedObjects != stream.MemberEnd())
+        {
+            auto& list = removedObjects->value;
+            const int32 size = static_cast<int32>(list.Size());
+            bool removed = false;
+            for (int32 j = 0; j < size; j++)
+            {
+                if (JsonTools::GetGuid(list[j]) == prefabObjectId)
+                {
+                    removed = true;
+                    break;
+                }
+            }
+            if (removed)
+                continue;
+        }
+
+        // Use only objects that are missing
+        bool spawned = false;
+        int32 childSearchStart = i + 1; // Objects are serialized with parent followed by its children
+        int32 instanceIndex = -1;
+        if (context.ObjectToInstance.TryGet(actor->GetID(), instanceIndex) && context.Instances[instanceIndex].Prefab == prefab)
+        {
+            // Start searching from the beginning of that prefab instance (eg. in case prefab objects were reordered)
+            childSearchStart = Math::Min(childSearchStart, context.Instances[instanceIndex].StatIndex);
+        }
+        for (int32 j = childSearchStart; j < data.InitialCount; j++)
+        {
+            if (JsonTools::GetGuid(data.Data[j], "PrefabObjectID") == prefabObjectId)
+            {
+                // This object exists in the saved scene objects list
+                spawned = true;
+                break;
+            }
+        }
+        if (spawned)
+            continue;
+
+        // Map prefab object ID to this actor's prefab instance so the new objects gets added to it
+        context.SetupIdsMapping(actor, data.Modifier);
+        data.Modifier->IdsMapping[actorPrefabObjectId] = actor->GetID();
+        Scripting::ObjectsLookupIdMapping.Set(&data.Modifier->IdsMapping);
+
+        // Create instance (including all children)
+        SynchronizeNewPrefabInstance(context, data, prefab, actor, prefabObjectId);
+    }
+}
+
 void SceneObjectsFactory::SynchronizeNewPrefabInstance(Context& context, PrefabSyncData& data, Prefab* prefab, Actor* actor, const Guid& prefabObjectId)
 {
     PROFILE_CPU_NAMED("SynchronizeNewPrefabInstance");
diff --git a/Source/Engine/Level/SceneObjectsFactory.h b/Source/Engine/Level/SceneObjectsFactory.h
index 86fd5364a..e152c21b2 100644
--- a/Source/Engine/Level/SceneObjectsFactory.h
+++ b/Source/Engine/Level/SceneObjectsFactory.h
@@ -15,8 +15,11 @@ class FLAXENGINE_API SceneObjectsFactory
 public:
     struct PrefabInstance
     {
+        int32 StatIndex;
+        int32 RootIndex;
         Guid RootId;
         Prefab* Prefab;
+        bool FixRootParent = false;
         Dictionary<Guid, Guid> IdsMapping;
     };
 
@@ -70,6 +73,8 @@ public:
     struct PrefabSyncData
     {
         friend SceneObjectsFactory;
+        friend class PrefabManager;
+
         // The created scene objects. Collection can be modified (eg. for spawning missing objects).
         Array<SceneObject*>& SceneObjects;
         // The scene objects data.
@@ -124,5 +129,6 @@ public:
     static void SynchronizePrefabInstances(Context& context, PrefabSyncData& data);
 
 private:
+    static void SynchronizeNewPrefabInstances(Context& context, PrefabSyncData& data, Prefab* prefab, Actor* actor, const Guid& actorPrefabObjectId, int32 i, const ISerializable::DeserializeStream& stream);
     static void SynchronizeNewPrefabInstance(Context& context, PrefabSyncData& data, Prefab* prefab, Actor* actor, const Guid& prefabObjectId);
 };
diff --git a/Source/Engine/Level/Components/MissingScript.h b/Source/Engine/Level/Scripts/MissingScript.h
similarity index 94%
rename from Source/Engine/Level/Components/MissingScript.h
rename to Source/Engine/Level/Scripts/MissingScript.h
index 7b351bd82..d512ba992 100644
--- a/Source/Engine/Level/Components/MissingScript.h
+++ b/Source/Engine/Level/Scripts/MissingScript.h
@@ -4,10 +4,8 @@
 
 #if USE_EDITOR
 
-#include "Engine/Core/Cache.h"
 #include "Engine/Scripting/Script.h"
 #include "Engine/Scripting/ScriptingObjectReference.h"
-#include "Engine/Serialization/JsonWriters.h"
 
 /// <summary>
 /// Actor script component that represents missing script.
diff --git a/Source/Engine/Level/Scripts/ModelPrefab.h b/Source/Engine/Level/Scripts/ModelPrefab.h
new file mode 100644
index 000000000..fbdb5fd18
--- /dev/null
+++ b/Source/Engine/Level/Scripts/ModelPrefab.h
@@ -0,0 +1,29 @@
+// Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
+
+#pragma once
+
+#include "Engine/Scripting/Script.h"
+#if USE_EDITOR
+#include "Engine/Tools/ModelTool/ModelTool.h"
+#endif
+
+/// <summary>
+/// Actor script component that handled model prefabs importing and setup.
+/// </summary>
+API_CLASS(Attributes="HideInEditor") class FLAXENGINE_API ModelPrefab : public Script
+{
+    API_AUTO_SERIALIZATION();
+    DECLARE_SCRIPTING_TYPE(ModelPrefab);
+
+#if USE_EDITOR
+    /// <summary>
+    /// Source model file path (absolute or relative to the project).
+    /// </summary>
+    API_FIELD(Attributes="ReadOnly") String ImportPath;
+
+    /// <summary>
+    /// Model file import settings.
+    /// </summary>
+    API_FIELD() ModelTool::Options ImportOptions;
+#endif
+};
diff --git a/Source/Engine/Level/Tags.cs b/Source/Engine/Level/Tags.cs
index 1ff9acef4..11815aa9d 100644
--- a/Source/Engine/Level/Tags.cs
+++ b/Source/Engine/Level/Tags.cs
@@ -45,7 +45,7 @@ namespace FlaxEngine
         /// <returns>True if both values are not equal, otherwise false.</returns>
         public static bool operator !=(Tag left, Tag right)
         {
-            return left.Index == right.Index;
+            return left.Index != right.Index;
         }
 
         /// <summary>
@@ -213,11 +213,11 @@ namespace FlaxEngine
         }
 
         /// <summary>
-        /// Checks if the list of tags contains all of the given tags (including parent tags check). For example, HasAll({"A.B", "C"}, {"A", "C"}) returns true, for exact check use HasAllExact.
+        /// Checks if the list of tags contains all the given tags (including parent tags check). For example, HasAll({"A.B", "C"}, {"A", "C"}) returns true, for exact check use HasAllExact.
         /// </summary>
         /// <param name="list">The tags list to use.</param>
         /// <param name="tags">The tags to check.</param>
-        /// <returns>True if all of the given tags are contained by the list of tags. Returns true for empty list.</returns>
+        /// <returns>True if all the given tags are contained by the list of tags. Returns true for empty list.</returns>
         public static bool HasAll(this Tag[] list, Tag[] tags)
         {
             if (tags == null || tags.Length == 0)
@@ -233,11 +233,11 @@ namespace FlaxEngine
         }
 
         /// <summary>
-        /// Checks if the list of tags contains all of the given tags (exact match). For example, HasAllExact({"A.B", "C"}, {"A", "C"}) returns false, for parents check use HasAll.
+        /// Checks if the list of tags contains all the given tags (exact match). For example, HasAllExact({"A.B", "C"}, {"A", "C"}) returns false, for parents check use HasAll.
         /// </summary>
         /// <param name="list">The tags list to use.</param>
         /// <param name="tags">The tags to check.</param>
-        /// <returns>True if all of the given tags are contained by the list of tags. Returns true for empty list.</returns>
+        /// <returns>True if all the given tags are contained by the list of tags. Returns true for empty list.</returns>
         public static bool HasAllExact(this Tag[] list, Tag[] tags)
         {
             if (tags == null || tags.Length == 0)
diff --git a/Source/Engine/Navigation/NavMeshRuntime.cpp b/Source/Engine/Navigation/NavMeshRuntime.cpp
index 989b1697f..4fcf0e038 100644
--- a/Source/Engine/Navigation/NavMeshRuntime.cpp
+++ b/Source/Engine/Navigation/NavMeshRuntime.cpp
@@ -36,7 +36,7 @@ NavMeshRuntime::NavMeshRuntime(const NavMeshProperties& properties)
 
 NavMeshRuntime::~NavMeshRuntime()
 {
-    dtFreeNavMesh(_navMesh);
+    Dispose();
     dtFreeNavMeshQuery(_navMeshQuery);
 }
 
@@ -336,9 +336,7 @@ void NavMeshRuntime::SetTileSize(float tileSize)
     // Dispose the existing mesh (its invalid)
     if (_navMesh)
     {
-        dtFreeNavMesh(_navMesh);
-        _navMesh = nullptr;
-        _tiles.Clear();
+        Dispose();
     }
 
     _tileSize = tileSize;
@@ -363,14 +361,9 @@ void NavMeshRuntime::EnsureCapacity(int32 tilesToAddCount)
     // Ensure to have size assigned
     ASSERT(_tileSize != 0);
 
-    // Fre previous data (if any)
-    if (_navMesh)
-    {
-        dtFreeNavMesh(_navMesh);
-    }
-
-    // Allocate new navmesh
-    _navMesh = dtAllocNavMesh();
+    // Allocate navmesh and initialize the default query
+    if (!_navMesh)
+        _navMesh = dtAllocNavMesh();
     if (dtStatusFailed(_navMeshQuery->init(_navMesh, MAX_NODES)))
     {
         LOG(Error, "Failed to initialize navmesh {0}.", Properties.Name);
@@ -517,7 +510,7 @@ void NavMeshRuntime::RemoveTile(int32 x, int32 y, int32 layer)
     }
 }
 
-void NavMeshRuntime::RemoveTiles(bool (* prediction)(const NavMeshRuntime* navMesh, const NavMeshTile& tile, void* customData), void* userData)
+void NavMeshRuntime::RemoveTiles(bool (*prediction)(const NavMeshRuntime* navMesh, const NavMeshTile& tile, void* customData), void* userData)
 {
     ScopeLock lock(Locker);
     ASSERT(prediction);
diff --git a/Source/Engine/Networking/NetworkReplicator.cpp b/Source/Engine/Networking/NetworkReplicator.cpp
index 1e9ea5b79..c6311cd7a 100644
--- a/Source/Engine/Networking/NetworkReplicator.cpp
+++ b/Source/Engine/Networking/NetworkReplicator.cpp
@@ -817,7 +817,7 @@ void InvokeObjectSpawn(const NetworkMessageObjectSpawn& msgData, const NetworkMe
                 NETWORK_REPLICATOR_LOG(Error, "[NetworkReplicator] Failed to find prefab {}", msgData.PrefabId.ToString());
                 return;
             }
-            prefabInstance = PrefabManager::SpawnPrefab(prefab, Transform::Identity, nullptr, nullptr);
+            prefabInstance = PrefabManager::SpawnPrefab(prefab, nullptr, nullptr);
             if (!prefabInstance)
             {
                 NETWORK_REPLICATOR_LOG(Error, "[NetworkReplicator] Failed to spawn object type {}", msgData.PrefabId.ToString());
diff --git a/Source/Engine/Physics/Colliders/BoxCollider.cpp b/Source/Engine/Physics/Colliders/BoxCollider.cpp
index fde3b4632..d74b3efba 100644
--- a/Source/Engine/Physics/Colliders/BoxCollider.cpp
+++ b/Source/Engine/Physics/Colliders/BoxCollider.cpp
@@ -1,8 +1,8 @@
 // Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
 
 #include "BoxCollider.h"
-#include "Engine/Serialization/Serialization.h"
 #include "Engine/Physics/PhysicsBackend.h"
+#include "Engine/Level/Scene/Scene.h"
 
 BoxCollider::BoxCollider(const SpawnParams& params)
     : Collider(params)
@@ -20,6 +20,32 @@ void BoxCollider::SetSize(const Float3& value)
     UpdateBounds();
 }
 
+void BoxCollider::AutoResize()
+{
+    Actor* parent = GetParent();
+    if (Cast<Scene>(parent))
+        return;
+
+    // Get bounds of all siblings (excluding itself)
+    const Vector3 parentScale = parent->GetScale();
+    if (parentScale.IsAnyZero())
+        return; // Avoid division by zero
+    BoundingBox parentBox = parent->GetBox();
+    for (const Actor* sibling : parent->Children)
+    {
+        if (sibling != this)
+            BoundingBox::Merge(parentBox, sibling->GetBoxWithChildren(), parentBox);
+    }
+    const Vector3 parentSize = parentBox.GetSize();
+    const Vector3 parentCenter = parentBox.GetCenter() - parent->GetPosition();
+
+    // Update bounds
+    SetLocalPosition(Vector3::Zero);
+    SetSize(parentSize / parentScale);
+    SetCenter(parentCenter / parentScale);
+    SetOrientation(GetOrientation() * Quaternion::Invert(GetOrientation()));
+}
+
 #if USE_EDITOR
 
 #include "Engine/Debug/DebugDraw.h"
@@ -116,24 +142,6 @@ bool BoxCollider::IntersectsItself(const Ray& ray, Real& distance, Vector3& norm
     return _bounds.Intersects(ray, distance, normal);
 }
 
-void BoxCollider::Serialize(SerializeStream& stream, const void* otherObj)
-{
-    // Base
-    Collider::Serialize(stream, otherObj);
-
-    SERIALIZE_GET_OTHER_OBJ(BoxCollider);
-
-    SERIALIZE_MEMBER(Size, _size);
-}
-
-void BoxCollider::Deserialize(DeserializeStream& stream, ISerializeModifier* modifier)
-{
-    // Base
-    Collider::Deserialize(stream, modifier);
-
-    DESERIALIZE_MEMBER(Size, _size);
-}
-
 void BoxCollider::UpdateBounds()
 {
     // Cache bounds
diff --git a/Source/Engine/Physics/Colliders/BoxCollider.h b/Source/Engine/Physics/Colliders/BoxCollider.h
index 0cc0e7be9..3c15ce640 100644
--- a/Source/Engine/Physics/Colliders/BoxCollider.h
+++ b/Source/Engine/Physics/Colliders/BoxCollider.h
@@ -12,6 +12,7 @@
 API_CLASS(Attributes="ActorContextMenu(\"New/Physics/Colliders/Box Collider\"), ActorToolbox(\"Physics\")")
 class FLAXENGINE_API BoxCollider : public Collider
 {
+    API_AUTO_SERIALIZATION();
     DECLARE_SCENE_OBJECT(BoxCollider);
 private:
     Float3 _size;
@@ -42,6 +43,11 @@ public:
         return _bounds;
     }
 
+    /// <summary>
+    /// Resizes the collider based on the bounds of it's parent to contain it whole (including any siblings).
+    /// </summary>
+    API_FUNCTION() void AutoResize();
+
 public:
     // [Collider]
 #if USE_EDITOR
@@ -49,8 +55,6 @@ public:
     void OnDebugDrawSelected() override;
 #endif
     bool IntersectsItself(const Ray& ray, Real& distance, Vector3& normal) override;
-    void Serialize(SerializeStream& stream, const void* otherObj) override;
-    void Deserialize(DeserializeStream& stream, ISerializeModifier* modifier) override;
 
 protected:
     // [Collider]
diff --git a/Source/Engine/Physics/Colliders/CapsuleCollider.cpp b/Source/Engine/Physics/Colliders/CapsuleCollider.cpp
index 98346b0a9..20f28e883 100644
--- a/Source/Engine/Physics/Colliders/CapsuleCollider.cpp
+++ b/Source/Engine/Physics/Colliders/CapsuleCollider.cpp
@@ -1,7 +1,6 @@
 // Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
 
 #include "CapsuleCollider.h"
-#include "Engine/Serialization/Serialization.h"
 
 CapsuleCollider::CapsuleCollider(const SpawnParams& params)
     : Collider(params)
@@ -81,26 +80,6 @@ bool CapsuleCollider::IntersectsItself(const Ray& ray, Real& distance, Vector3&
     return _orientedBox.Intersects(ray, distance, normal);
 }
 
-void CapsuleCollider::Serialize(SerializeStream& stream, const void* otherObj)
-{
-    // Base
-    Collider::Serialize(stream, otherObj);
-
-    SERIALIZE_GET_OTHER_OBJ(CapsuleCollider);
-
-    SERIALIZE_MEMBER(Radius, _radius);
-    SERIALIZE_MEMBER(Height, _height);
-}
-
-void CapsuleCollider::Deserialize(DeserializeStream& stream, ISerializeModifier* modifier)
-{
-    // Base
-    Collider::Deserialize(stream, modifier);
-
-    DESERIALIZE_MEMBER(Radius, _radius);
-    DESERIALIZE_MEMBER(Height, _height);
-}
-
 void CapsuleCollider::UpdateBounds()
 {
     // Cache bounds
diff --git a/Source/Engine/Physics/Colliders/CapsuleCollider.h b/Source/Engine/Physics/Colliders/CapsuleCollider.h
index 5ae53cf53..8eff1c164 100644
--- a/Source/Engine/Physics/Colliders/CapsuleCollider.h
+++ b/Source/Engine/Physics/Colliders/CapsuleCollider.h
@@ -13,6 +13,7 @@
 API_CLASS(Attributes="ActorContextMenu(\"New/Physics/Colliders/Capsule Collider\"), ActorToolbox(\"Physics\")")
 class FLAXENGINE_API CapsuleCollider : public Collider
 {
+    API_AUTO_SERIALIZATION();
     DECLARE_SCENE_OBJECT(CapsuleCollider);
 private:
     float _radius;
@@ -58,8 +59,6 @@ public:
     void OnDebugDrawSelected() override;
 #endif
     bool IntersectsItself(const Ray& ray, Real& distance, Vector3& normal) override;
-    void Serialize(SerializeStream& stream, const void* otherObj) override;
-    void Deserialize(DeserializeStream& stream, ISerializeModifier* modifier) override;
 
 protected:
     // [Collider]
diff --git a/Source/Engine/Physics/Colliders/CharacterController.cpp b/Source/Engine/Physics/Colliders/CharacterController.cpp
index 41ee95d04..9b36a92ff 100644
--- a/Source/Engine/Physics/Colliders/CharacterController.cpp
+++ b/Source/Engine/Physics/Colliders/CharacterController.cpp
@@ -5,7 +5,6 @@
 #include "Engine/Physics/Physics.h"
 #include "Engine/Physics/PhysicsBackend.h"
 #include "Engine/Physics/PhysicsScene.h"
-#include "Engine/Serialization/Serialization.h"
 #include "Engine/Engine/Time.h"
 
 #define CC_MIN_SIZE 0.001f
@@ -387,33 +386,3 @@ void CharacterController::OnPhysicsSceneChanged(PhysicsScene* previous)
     DeleteController();
     CreateController();
 }
-
-void CharacterController::Serialize(SerializeStream& stream, const void* otherObj)
-{
-    // Base
-    Collider::Serialize(stream, otherObj);
-
-    SERIALIZE_GET_OTHER_OBJ(CharacterController);
-
-    SERIALIZE_MEMBER(StepOffset, _stepOffset);
-    SERIALIZE_MEMBER(SlopeLimit, _slopeLimit);
-    SERIALIZE_MEMBER(NonWalkableMode, _nonWalkableMode);
-    SERIALIZE_MEMBER(Radius, _radius);
-    SERIALIZE_MEMBER(Height, _height);
-    SERIALIZE_MEMBER(MinMoveDistance, _minMoveDistance);
-    SERIALIZE_MEMBER(UpDirection, _upDirection);
-}
-
-void CharacterController::Deserialize(DeserializeStream& stream, ISerializeModifier* modifier)
-{
-    // Base
-    Collider::Deserialize(stream, modifier);
-
-    DESERIALIZE_MEMBER(StepOffset, _stepOffset);
-    DESERIALIZE_MEMBER(SlopeLimit, _slopeLimit);
-    DESERIALIZE_MEMBER(NonWalkableMode, _nonWalkableMode);
-    DESERIALIZE_MEMBER(Radius, _radius);
-    DESERIALIZE_MEMBER(Height, _height);
-    DESERIALIZE_MEMBER(MinMoveDistance, _minMoveDistance);
-    DESERIALIZE_MEMBER(UpDirection, _upDirection);
-}
diff --git a/Source/Engine/Physics/Colliders/CharacterController.h b/Source/Engine/Physics/Colliders/CharacterController.h
index 919deaafe..737d98728 100644
--- a/Source/Engine/Physics/Colliders/CharacterController.h
+++ b/Source/Engine/Physics/Colliders/CharacterController.h
@@ -12,6 +12,7 @@
 API_CLASS(Attributes="ActorContextMenu(\"New/Physics/Character Controller\"), ActorToolbox(\"Physics\")")
 class FLAXENGINE_API CharacterController : public Collider, public IPhysicsActor
 {
+    API_AUTO_SERIALIZATION();
     DECLARE_SCENE_OBJECT(CharacterController);
 public:
     /// <summary>
@@ -198,8 +199,6 @@ public:
 #if USE_EDITOR
     void OnDebugDrawSelected() override;
 #endif
-    void Serialize(SerializeStream& stream, const void* otherObj) override;
-    void Deserialize(DeserializeStream& stream, ISerializeModifier* modifier) override;
     void CreateShape() override;
     void UpdateBounds() override;
     void AddMovement(const Vector3& translation, const Quaternion& rotation) override;
diff --git a/Source/Engine/Physics/Colliders/Collider.cpp b/Source/Engine/Physics/Colliders/Collider.cpp
index 6c292bf20..4326a033d 100644
--- a/Source/Engine/Physics/Colliders/Collider.cpp
+++ b/Source/Engine/Physics/Colliders/Collider.cpp
@@ -5,7 +5,6 @@
 #if USE_EDITOR
 #include "Engine/Level/Scene/SceneRendering.h"
 #endif
-#include "Engine/Serialization/Serialization.h"
 #include "Engine/Physics/PhysicsSettings.h"
 #include "Engine/Physics/Physics.h"
 #include "Engine/Physics/PhysicsBackend.h"
@@ -292,30 +291,6 @@ void Collider::OnMaterialChanged()
         PhysicsBackend::SetShapeMaterial(_shape, Material.Get());
 }
 
-void Collider::Serialize(SerializeStream& stream, const void* otherObj)
-{
-    // Base
-    PhysicsColliderActor::Serialize(stream, otherObj);
-
-    SERIALIZE_GET_OTHER_OBJ(Collider);
-
-    SERIALIZE_MEMBER(IsTrigger, _isTrigger);
-    SERIALIZE_MEMBER(Center, _center);
-    SERIALIZE_MEMBER(ContactOffset, _contactOffset);
-    SERIALIZE(Material);
-}
-
-void Collider::Deserialize(DeserializeStream& stream, ISerializeModifier* modifier)
-{
-    // Base
-    PhysicsColliderActor::Deserialize(stream, modifier);
-
-    DESERIALIZE_MEMBER(IsTrigger, _isTrigger);
-    DESERIALIZE_MEMBER(Center, _center);
-    DESERIALIZE_MEMBER(ContactOffset, _contactOffset);
-    DESERIALIZE(Material);
-}
-
 void Collider::BeginPlay(SceneBeginData* data)
 {
     // Check if has no shape created (it means no rigidbody requested it but also collider may be spawned at runtime)
diff --git a/Source/Engine/Physics/Colliders/Collider.h b/Source/Engine/Physics/Colliders/Collider.h
index d3bae9407..bd17aa27a 100644
--- a/Source/Engine/Physics/Colliders/Collider.h
+++ b/Source/Engine/Physics/Colliders/Collider.h
@@ -17,6 +17,7 @@ class RigidBody;
 /// <seealso cref="PhysicsColliderActor" />
 API_CLASS(Abstract) class FLAXENGINE_API Collider : public PhysicsColliderActor
 {
+    API_AUTO_SERIALIZATION();
     DECLARE_SCENE_OBJECT_ABSTRACT(Collider);
 protected:
     Vector3 _center;
@@ -196,8 +197,6 @@ private:
 
 public:
     // [PhysicsColliderActor]
-    void Serialize(SerializeStream& stream, const void* otherObj) override;
-    void Deserialize(DeserializeStream& stream, ISerializeModifier* modifier) override;
     RigidBody* GetAttachedRigidBody() const override;
 
 protected:
diff --git a/Source/Engine/Physics/Colliders/MeshCollider.cpp b/Source/Engine/Physics/Colliders/MeshCollider.cpp
index 94429ab7d..c29485a64 100644
--- a/Source/Engine/Physics/Colliders/MeshCollider.cpp
+++ b/Source/Engine/Physics/Colliders/MeshCollider.cpp
@@ -3,7 +3,6 @@
 #include "MeshCollider.h"
 #include "Engine/Core/Math/Matrix.h"
 #include "Engine/Core/Math/Ray.h"
-#include "Engine/Serialization/Serialization.h"
 #include "Engine/Physics/Physics.h"
 #include "Engine/Physics/PhysicsScene.h"
 #if USE_EDITOR || !BUILD_RELEASE
@@ -117,24 +116,6 @@ bool MeshCollider::IntersectsItself(const Ray& ray, Real& distance, Vector3& nor
     return _box.Intersects(ray, distance, normal);
 }
 
-void MeshCollider::Serialize(SerializeStream& stream, const void* otherObj)
-{
-    // Base
-    Collider::Serialize(stream, otherObj);
-
-    SERIALIZE_GET_OTHER_OBJ(MeshCollider);
-
-    SERIALIZE(CollisionData);
-}
-
-void MeshCollider::Deserialize(DeserializeStream& stream, ISerializeModifier* modifier)
-{
-    // Base
-    Collider::Deserialize(stream, modifier);
-
-    DESERIALIZE(CollisionData);
-}
-
 void MeshCollider::UpdateBounds()
 {
     // Cache bounds
diff --git a/Source/Engine/Physics/Colliders/MeshCollider.h b/Source/Engine/Physics/Colliders/MeshCollider.h
index a25f4d9c8..ab3b7047a 100644
--- a/Source/Engine/Physics/Colliders/MeshCollider.h
+++ b/Source/Engine/Physics/Colliders/MeshCollider.h
@@ -13,6 +13,7 @@
 API_CLASS(Attributes="ActorContextMenu(\"New/Physics/Colliders/Mesh Collider\"), ActorToolbox(\"Physics\")")
 class FLAXENGINE_API MeshCollider : public Collider
 {
+    API_AUTO_SERIALIZATION();
     DECLARE_SCENE_OBJECT(MeshCollider);
 public:
     /// <summary>
@@ -33,8 +34,6 @@ public:
     void OnDebugDrawSelected() override;
 #endif
     bool IntersectsItself(const Ray& ray, Real& distance, Vector3& normal) override;
-    void Serialize(SerializeStream& stream, const void* otherObj) override;
-    void Deserialize(DeserializeStream& stream, ISerializeModifier* modifier) override;
 
 protected:
     // [Collider]
diff --git a/Source/Engine/Physics/Colliders/SphereCollider.cpp b/Source/Engine/Physics/Colliders/SphereCollider.cpp
index fa2fb1cca..92196eeae 100644
--- a/Source/Engine/Physics/Colliders/SphereCollider.cpp
+++ b/Source/Engine/Physics/Colliders/SphereCollider.cpp
@@ -1,7 +1,6 @@
 // Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
 
 #include "SphereCollider.h"
-#include "Engine/Serialization/Serialization.h"
 
 SphereCollider::SphereCollider(const SpawnParams& params)
     : Collider(params)
@@ -58,24 +57,6 @@ bool SphereCollider::IntersectsItself(const Ray& ray, Real& distance, Vector3& n
     return _sphere.Intersects(ray, distance, normal);
 }
 
-void SphereCollider::Serialize(SerializeStream& stream, const void* otherObj)
-{
-    // Base
-    Collider::Serialize(stream, otherObj);
-
-    SERIALIZE_GET_OTHER_OBJ(SphereCollider);
-
-    SERIALIZE_MEMBER(Radius, _radius);
-}
-
-void SphereCollider::Deserialize(DeserializeStream& stream, ISerializeModifier* modifier)
-{
-    // Base
-    Collider::Deserialize(stream, modifier);
-
-    DESERIALIZE_MEMBER(Radius, _radius);
-}
-
 void SphereCollider::UpdateBounds()
 {
     // Cache bounds
diff --git a/Source/Engine/Physics/Colliders/SphereCollider.h b/Source/Engine/Physics/Colliders/SphereCollider.h
index 39f6fd63c..061372af4 100644
--- a/Source/Engine/Physics/Colliders/SphereCollider.h
+++ b/Source/Engine/Physics/Colliders/SphereCollider.h
@@ -11,6 +11,7 @@
 API_CLASS(Attributes="ActorContextMenu(\"New/Physics/Colliders/Sphere Collider\"), ActorToolbox(\"Physics\")")
 class FLAXENGINE_API SphereCollider : public Collider
 {
+    API_AUTO_SERIALIZATION();
     DECLARE_SCENE_OBJECT(SphereCollider);
 private:
     float _radius;
@@ -38,8 +39,6 @@ public:
     void OnDebugDrawSelected() override;
 #endif
     bool IntersectsItself(const Ray& ray, Real& distance, Vector3& normal) override;
-    void Serialize(SerializeStream& stream, const void* otherObj) override;
-    void Deserialize(DeserializeStream& stream, ISerializeModifier* modifier) override;
 
 protected:
     // [Collider]
diff --git a/Source/Engine/Physics/Colliders/SplineCollider.cpp b/Source/Engine/Physics/Colliders/SplineCollider.cpp
index b85617da4..5c3c87335 100644
--- a/Source/Engine/Physics/Colliders/SplineCollider.cpp
+++ b/Source/Engine/Physics/Colliders/SplineCollider.cpp
@@ -5,7 +5,6 @@
 #include "Engine/Core/Math/Matrix.h"
 #include "Engine/Core/Math/Ray.h"
 #include "Engine/Level/Actors/Spline.h"
-#include "Engine/Serialization/Serialization.h"
 #include "Engine/Physics/Physics.h"
 #include "Engine/Physics/PhysicsBackend.h"
 #include "Engine/Physics/PhysicsScene.h"
@@ -124,26 +123,6 @@ bool SplineCollider::IntersectsItself(const Ray& ray, Real& distance, Vector3& n
     return _box.Intersects(ray, distance, normal);
 }
 
-void SplineCollider::Serialize(SerializeStream& stream, const void* otherObj)
-{
-    // Base
-    Collider::Serialize(stream, otherObj);
-
-    SERIALIZE_GET_OTHER_OBJ(SplineCollider);
-
-    SERIALIZE(CollisionData);
-    SERIALIZE_MEMBER(PreTransform, _preTransform)
-}
-
-void SplineCollider::Deserialize(DeserializeStream& stream, ISerializeModifier* modifier)
-{
-    // Base
-    Collider::Deserialize(stream, modifier);
-
-    DESERIALIZE(CollisionData);
-    DESERIALIZE_MEMBER(PreTransform, _preTransform);
-}
-
 void SplineCollider::OnParentChanged()
 {
     if (_spline)
diff --git a/Source/Engine/Physics/Colliders/SplineCollider.h b/Source/Engine/Physics/Colliders/SplineCollider.h
index bea1059d8..794e90e4e 100644
--- a/Source/Engine/Physics/Colliders/SplineCollider.h
+++ b/Source/Engine/Physics/Colliders/SplineCollider.h
@@ -15,6 +15,7 @@ class Spline;
 /// <seealso cref="Spline" />
 API_CLASS() class FLAXENGINE_API SplineCollider : public Collider
 {
+    API_AUTO_SERIALIZATION();
     DECLARE_SCENE_OBJECT(SplineCollider);
 private:
     Spline* _spline = nullptr;
@@ -61,8 +62,6 @@ public:
     void OnDebugDrawSelected() override;
 #endif
     bool IntersectsItself(const Ray& ray, Real& distance, Vector3& normal) override;
-    void Serialize(SerializeStream& stream, const void* otherObj) override;
-    void Deserialize(DeserializeStream& stream, ISerializeModifier* modifier) override;
     void OnParentChanged() override;
     void EndPlay() override;
 
diff --git a/Source/Engine/Physics/CollisionCooking.cpp b/Source/Engine/Physics/CollisionCooking.cpp
index 4c8cffdcc..805364e00 100644
--- a/Source/Engine/Physics/CollisionCooking.cpp
+++ b/Source/Engine/Physics/CollisionCooking.cpp
@@ -7,10 +7,12 @@
 #include "Engine/Graphics/Async/GPUTask.h"
 #include "Engine/Graphics/Models/MeshBase.h"
 #include "Engine/Threading/Threading.h"
+#include "Engine/Profiler/ProfilerCPU.h"
 #include "Engine/Core/Log.h"
 
 bool CollisionCooking::CookCollision(const Argument& arg, CollisionData::SerializedOptions& outputOptions, BytesContainer& outputData)
 {
+    PROFILE_CPU();
     int32 convexVertexLimit = Math::Clamp(arg.ConvexVertexLimit, CONVEX_VERTEX_MIN, CONVEX_VERTEX_MAX);
     if (arg.ConvexVertexLimit == 0)
         convexVertexLimit = CONVEX_VERTEX_MAX;
diff --git a/Source/Engine/Physics/PhysX/PhysicsBackendPhysX.cpp b/Source/Engine/Physics/PhysX/PhysicsBackendPhysX.cpp
index 768bff1fa..cbc381142 100644
--- a/Source/Engine/Physics/PhysX/PhysicsBackendPhysX.cpp
+++ b/Source/Engine/Physics/PhysX/PhysicsBackendPhysX.cpp
@@ -961,6 +961,7 @@ void PhysicalMaterial::UpdatePhysicsMaterial()
 
 bool CollisionCooking::CookConvexMesh(CookingInput& input, BytesContainer& output)
 {
+    PROFILE_CPU();
     ENSURE_CAN_COOK;
     if (input.VertexCount == 0)
         LOG(Warning, "Empty mesh data for collision cooking.");
@@ -1004,6 +1005,7 @@ bool CollisionCooking::CookConvexMesh(CookingInput& input, BytesContainer& outpu
 
 bool CollisionCooking::CookTriangleMesh(CookingInput& input, BytesContainer& output)
 {
+    PROFILE_CPU();
     ENSURE_CAN_COOK;
     if (input.VertexCount == 0 || input.IndexCount == 0)
         LOG(Warning, "Empty mesh data for collision cooking.");
@@ -1038,6 +1040,7 @@ bool CollisionCooking::CookTriangleMesh(CookingInput& input, BytesContainer& out
 
 bool CollisionCooking::CookHeightField(int32 cols, int32 rows, const PhysicsBackend::HeightFieldSample* data, WriteStream& stream)
 {
+    PROFILE_CPU();
     ENSURE_CAN_COOK;
 
     PxHeightFieldDesc heightFieldDesc;
@@ -2800,7 +2803,7 @@ void PhysicsBackend::SetHingeJointLimit(void* joint, const LimitAngularRange& va
 void PhysicsBackend::SetHingeJointDrive(void* joint, const HingeJointDrive& value)
 {
     auto jointPhysX = (PxRevoluteJoint*)joint;
-    jointPhysX->setDriveVelocity(Math::Max(value.Velocity, 0.0f));
+    jointPhysX->setDriveVelocity(value.Velocity);
     jointPhysX->setDriveForceLimit(Math::Max(value.ForceLimit, 0.0f));
     jointPhysX->setDriveGearRatio(Math::Max(value.GearRatio, 0.0f));
     jointPhysX->setRevoluteJointFlag(PxRevoluteJointFlag::eDRIVE_FREESPIN, value.FreeSpin);
diff --git a/Source/Engine/Platform/Android/AndroidPlatformSettings.h b/Source/Engine/Platform/Android/AndroidPlatformSettings.h
index 9cfe7f880..974a4c488 100644
--- a/Source/Engine/Platform/Android/AndroidPlatformSettings.h
+++ b/Source/Engine/Platform/Android/AndroidPlatformSettings.h
@@ -17,6 +17,37 @@ API_CLASS(sealed, Namespace="FlaxEditor.Content.Settings") class FLAXENGINE_API
     DECLARE_SCRIPTING_TYPE_MINIMAL(AndroidPlatformSettings);
     API_AUTO_SERIALIZATION();
 
+    /// <summary>
+    /// Android screen orientation options.
+    /// </summary>
+    API_ENUM() enum class FLAXENGINE_API ScreenOrientation
+    {
+        /// <summary>
+        /// "portrait" mode
+        /// </summary>
+        Portrait,
+
+        /// <summary>
+        /// "reversePortrait" mode
+        /// </summary>
+        PortraitReverse,
+
+        /// <summary>
+        /// "landscape" mode
+        /// </summary>
+        LandscapeRight,
+
+        /// <summary>
+        /// "reverseLandscape" mode
+        /// </summary>
+        LandscapeLeft,
+
+        /// <summary>
+        /// "fullSensor" mode
+        /// </summary>
+        AutoRotation,
+    };
+
     /// <summary>
     /// The application package name (eg. com.company.product). Custom tokens: ${PROJECT_NAME}, ${COMPANY_NAME}.
     /// </summary>
@@ -29,6 +60,12 @@ API_CLASS(sealed, Namespace="FlaxEditor.Content.Settings") class FLAXENGINE_API
     API_FIELD(Attributes="EditorOrder(100), EditorDisplay(\"General\")")
     Array<String> Permissions;
 
+    /// <summary>
+    /// The default screen orientation.
+    /// </summary>
+    API_FIELD(Attributes = "EditorOrder(110), EditorDisplay(\"General\")")
+    ScreenOrientation DefaultOrientation = ScreenOrientation::AutoRotation;
+
     /// <summary>
     /// Custom icon texture to use for the application (overrides the default one).
     /// </summary>
diff --git a/Source/Engine/Platform/Linux/LinuxPlatform.cpp b/Source/Engine/Platform/Linux/LinuxPlatform.cpp
index a7634710f..41a2a33f6 100644
--- a/Source/Engine/Platform/Linux/LinuxPlatform.cpp
+++ b/Source/Engine/Platform/Linux/LinuxPlatform.cpp
@@ -94,6 +94,7 @@ X11::XcursorImage* CursorsImg[(int32)CursorType::MAX];
 Dictionary<StringAnsi, X11::KeyCode> KeyNameMap;
 Array<KeyboardKeys> KeyCodeMap;
 Delegate<void*> LinuxPlatform::xEventRecieved;
+Window* MouseTrackingWindow = nullptr;
 
 // Message boxes configuration
 #define LINUX_DIALOG_MIN_BUTTON_WIDTH 64
@@ -1916,7 +1917,6 @@ bool LinuxPlatform::Init()
 {
     if (PlatformBase::Init())
         return true;
-
     char fileNameBuffer[1024];
 
     // Init timing
@@ -2398,7 +2398,7 @@ void LinuxPlatform::Tick()
 				// Update input context focus
 				X11::XSetICFocus(IC);
 				window = WindowsManager::GetByNativePtr((void*)event.xfocus.window);
-				if (window)
+				if (window && MouseTrackingWindow == nullptr)
 				{
 					window->OnGotFocus();
 				}
@@ -2407,7 +2407,7 @@ void LinuxPlatform::Tick()
 				// Update input context focus
 				X11::XUnsetICFocus(IC);
 				window = WindowsManager::GetByNativePtr((void*)event.xfocus.window);
-				if (window)
+				if (window && MouseTrackingWindow == nullptr)
 				{
 					window->OnLostFocus();
 				}
@@ -2514,23 +2514,32 @@ void LinuxPlatform::Tick()
 				break;
 			case ButtonPress:
 				window = WindowsManager::GetByNativePtr((void*)event.xbutton.window);
-				if (window)
+		        if (MouseTrackingWindow)
+		            MouseTrackingWindow->OnButtonPress(&event.xbutton);
+				else if (window)
 					window->OnButtonPress(&event.xbutton);
 				break;
 			case ButtonRelease:
 				window = WindowsManager::GetByNativePtr((void*)event.xbutton.window);
-				if (window)
+		        if (MouseTrackingWindow)
+		            MouseTrackingWindow->OnButtonRelease(&event.xbutton);
+				else if (window)
 					window->OnButtonRelease(&event.xbutton);
 				break;
 			case MotionNotify:
 				window = WindowsManager::GetByNativePtr((void*)event.xmotion.window);
-				if (window)
+		        if (MouseTrackingWindow)
+		            MouseTrackingWindow->OnMotionNotify(&event.xmotion);
+				else if (window)
 					window->OnMotionNotify(&event.xmotion);
 				break;
 			case EnterNotify:
+			    // nothing?
 				break;
 			case LeaveNotify:
 				window = WindowsManager::GetByNativePtr((void*)event.xcrossing.window);
+		        if (MouseTrackingWindow)
+		            MouseTrackingWindow->OnLeaveNotify(&event.xcrossing);
 				if (window)
 					window->OnLeaveNotify(&event.xcrossing);
 				break;
diff --git a/Source/Engine/Platform/Linux/LinuxWindow.cpp b/Source/Engine/Platform/Linux/LinuxWindow.cpp
index b3bae0276..9004ed84c 100644
--- a/Source/Engine/Platform/Linux/LinuxWindow.cpp
+++ b/Source/Engine/Platform/Linux/LinuxWindow.cpp
@@ -40,6 +40,7 @@ extern X11::Atom xAtomWmName;
 extern Dictionary<StringAnsi, X11::KeyCode> KeyNameMap;
 extern Array<KeyboardKeys> KeyCodeMap;
 extern X11::Cursor Cursors[(int32)CursorType::MAX];
+extern Window* MouseTrackingWindow;
 
 static constexpr uint32 MouseDoubleClickTime = 500;
 static constexpr uint32 MaxDoubleClickDistanceSquared = 10;
@@ -54,7 +55,7 @@ LinuxWindow::LinuxWindow(const CreateWindowSettings& settings)
         return;
 	auto screen = XDefaultScreen(display);
 
-	// Cache data
+    // Cache data
 	int32 width = Math::TruncToInt(settings.Size.X);
 	int32 height = Math::TruncToInt(settings.Size.Y);
 	_clientSize = Float2((float)width, (float)height);
@@ -111,6 +112,12 @@ LinuxWindow::LinuxWindow(const CreateWindowSettings& settings)
 	windowAttributes.border_pixel = XBlackPixel(display, screen);
 	windowAttributes.event_mask = KeyPressMask | KeyReleaseMask | StructureNotifyMask | ExposureMask;
 
+    if (!settings.IsRegularWindow)
+    {
+        windowAttributes.save_under = true;
+        windowAttributes.override_redirect = true;
+    }
+
 	// TODO: implement all window settings
 	/*
 	bool Fullscreen;
@@ -118,11 +125,16 @@ LinuxWindow::LinuxWindow(const CreateWindowSettings& settings)
 	bool AllowMaximize;
 	*/
 
+    unsigned long valueMask = CWBackPixel | CWBorderPixel | CWEventMask | CWColormap;
+    if (!settings.IsRegularWindow)
+    {
+        valueMask |= CWOverrideRedirect | CWSaveUnder;
+    }
 	const X11::Window window = X11::XCreateWindow(
 		display, X11::XRootWindow(display, screen), x, y,
 		width, height, 0, visualInfo->depth, InputOutput,
 		visualInfo->visual,
-		CWBackPixel | CWBorderPixel | CWEventMask | CWColormap, &windowAttributes);
+		valueMask, &windowAttributes);
 	_window = window;
 	LinuxWindow::SetTitle(settings.Title);
 
@@ -811,12 +823,13 @@ void LinuxWindow::SetTitle(const StringView& title)
 
 void LinuxWindow::StartTrackingMouse(bool useMouseScreenOffset)
 {
-	// TODO: impl this
+    MouseTrackingWindow = this;
 }
 
 void LinuxWindow::EndTrackingMouse()
 {
-	// TODO: impl this
+    if (MouseTrackingWindow == this)
+        MouseTrackingWindow = nullptr;
 }
 
 void LinuxWindow::SetCursor(CursorType type)
diff --git a/Source/Engine/Renderer/PostProcessingPass.cpp b/Source/Engine/Renderer/PostProcessingPass.cpp
index 006927639..7c93177e0 100644
--- a/Source/Engine/Renderer/PostProcessingPass.cpp
+++ b/Source/Engine/Renderer/PostProcessingPass.cpp
@@ -434,6 +434,10 @@ void PostProcessingPass::Render(RenderContext& renderContext, GPUTexture* input,
         // Set lens flares output
         context->BindSR(3, bloomTmp2->View(0, 1));
     }
+    else
+    {
+        context->BindSR(3, (GPUResourceView*)nullptr);
+    }
 
     ////////////////////////////////////////////////////////////////////////////////////
     // Final composite
diff --git a/Source/Engine/Renderer/RenderList.cpp b/Source/Engine/Renderer/RenderList.cpp
index 7570fa71e..351b3c9b8 100644
--- a/Source/Engine/Renderer/RenderList.cpp
+++ b/Source/Engine/Renderer/RenderList.cpp
@@ -194,7 +194,7 @@ void RenderList::AddSettingsBlend(IPostFxSettingsProvider* provider, float weigh
 void RenderList::BlendSettings()
 {
     PROFILE_CPU();
-    Sorting::QuickSort(Blendable.Get(), Blendable.Count());
+    Sorting::QuickSort(Blendable);
     Settings = Graphics::PostProcessSettings;
     for (auto& b : Blendable)
     {
@@ -634,7 +634,7 @@ void RenderList::SortDrawCalls(const RenderContext& renderContext, bool reverseD
     }
 
     // Sort draw calls batches by depth
-    Sorting::QuickSort(list.Batches.Get(), list.Batches.Count());
+    Sorting::QuickSort(list.Batches);
 }
 
 FORCE_INLINE bool CanUseInstancing(DrawPass pass)
diff --git a/Source/Engine/Scripting/BinaryModule.cpp b/Source/Engine/Scripting/BinaryModule.cpp
index e9465096f..44ef32503 100644
--- a/Source/Engine/Scripting/BinaryModule.cpp
+++ b/Source/Engine/Scripting/BinaryModule.cpp
@@ -1235,17 +1235,17 @@ bool ManagedBinaryModule::InvokeMethod(void* method, const Variant& instance, Sp
     const bool withInterfaces = !mMethod->IsStatic() && mMethod->GetParentClass()->IsInterface();
     if (!mMethod->IsStatic())
     {
-        // Box instance into C# object
+        // Box instance into C# object (and validate the type)
         MObject* instanceObject = MUtils::BoxVariant(instance);
-        const MClass* instanceObjectClass = MCore::Object::GetClass(instanceObject);
-
-        // Validate instance
-        if (!instanceObject || !instanceObjectClass->IsSubClassOf(mMethod->GetParentClass(), withInterfaces))
+        if (!instanceObject)
         {
-            if (!instanceObject)
-                LOG(Error, "Failed to call method '{0}.{1}' (args count: {2}) without object instance", String(mMethod->GetParentClass()->GetFullName()), String(mMethod->GetName()), parametersCount);
-            else
-                LOG(Error, "Failed to call method '{0}.{1}' (args count: {2}) with invalid object instance of type '{3}'", String(mMethod->GetParentClass()->GetFullName()), String(mMethod->GetName()), parametersCount, String(MUtils::GetClassFullname(instanceObject)));
+            LOG(Error, "Failed to call method '{0}.{1}' (args count: {2}) without object instance", String(mMethod->GetParentClass()->GetFullName()), String(mMethod->GetName()), parametersCount);
+            return true;
+        }
+        const MClass* instanceObjectClass = MCore::Object::GetClass(instanceObject);
+        if (!instanceObjectClass->IsSubClassOf(mMethod->GetParentClass(), withInterfaces))
+        {
+            LOG(Error, "Failed to call method '{0}.{1}' (args count: {2}) with invalid object instance of type '{3}'", String(mMethod->GetParentClass()->GetFullName()), String(mMethod->GetName()), parametersCount, String(MUtils::GetClassFullname(instanceObject)));
             return true;
         }
 
diff --git a/Source/Engine/Scripting/Internal/EngineInternalCalls.cpp b/Source/Engine/Scripting/Internal/EngineInternalCalls.cpp
index e3e5b4342..bbdc9abd5 100644
--- a/Source/Engine/Scripting/Internal/EngineInternalCalls.cpp
+++ b/Source/Engine/Scripting/Internal/EngineInternalCalls.cpp
@@ -108,6 +108,7 @@ namespace
     };
 
     ChunkedArray<Location, 256> ManagedSourceLocations;
+    ThreadLocal<uint32> ManagedEventsCount;
 #endif
 #endif
 }
@@ -145,7 +146,9 @@ DEFINE_INTERNAL_CALL(void) ProfilerInternal_BeginEvent(MString* nameObj)
         srcLoc->color = 0;
     }
     //static constexpr tracy::SourceLocationData tracySrcLoc{ nullptr, __FUNCTION__, __FILE__, (uint32_t)__LINE__, 0 };
-    tracy::ScopedZone::Begin(srcLoc);
+    const bool tracyActive = tracy::ScopedZone::Begin(srcLoc);
+    if (tracyActive)
+        ManagedEventsCount.Get()++;
 #endif
 #endif
 #endif
@@ -155,7 +158,12 @@ DEFINE_INTERNAL_CALL(void) ProfilerInternal_EndEvent()
 {
 #if COMPILE_WITH_PROFILER
 #if TRACY_ENABLE
-    tracy::ScopedZone::End();
+    uint32& tracyActive = ManagedEventsCount.Get();
+    if (tracyActive > 0)
+    {
+        tracyActive--;
+        tracy::ScopedZone::End();
+    }
 #endif
     ProfilerCPU::EndEvent();
 #endif
diff --git a/Source/Engine/Scripting/Runtime/DotNet.cpp b/Source/Engine/Scripting/Runtime/DotNet.cpp
index 464e60ba6..db5c57bbc 100644
--- a/Source/Engine/Scripting/Runtime/DotNet.cpp
+++ b/Source/Engine/Scripting/Runtime/DotNet.cpp
@@ -1657,7 +1657,7 @@ bool InitHostfxr()
 
     // Get path to hostfxr library
     get_hostfxr_parameters get_hostfxr_params;
-    get_hostfxr_params.size = sizeof(hostfxr_initialize_parameters);
+    get_hostfxr_params.size = sizeof(get_hostfxr_parameters);
     get_hostfxr_params.assembly_path = libraryPath.Get();
 #if PLATFORM_MAC
     ::String macOSDotnetRoot = TEXT("/usr/local/share/dotnet");
diff --git a/Source/Engine/Scripting/Script.cpp b/Source/Engine/Scripting/Script.cpp
index 8eaff42de..e9cc2a0a8 100644
--- a/Source/Engine/Scripting/Script.cpp
+++ b/Source/Engine/Scripting/Script.cpp
@@ -27,6 +27,7 @@ Script::Script(const SpawnParams& params)
     , _tickUpdate(false)
     , _tickLateUpdate(false)
     , _tickLateFixedUpdate(false)
+    , _wasAwakeCalled(false)
     , _wasStartCalled(false)
     , _wasEnableCalled(false)
 {
@@ -86,7 +87,7 @@ void Script::SetParent(Actor* value, bool canBreakPrefabLink)
     // Unlink from the old one
     if (_parent)
     {
-        if (!value && _parent->IsDuringPlay() && _parent->IsActiveInHierarchy() && GetEnabled())
+        if (!value && _parent->IsDuringPlay() && _parent->IsActiveInHierarchy() && GetEnabled() && _wasEnableCalled)
         {
             // Call disable when script is removed from actor (new actor is null)
             Disable();
@@ -241,19 +242,31 @@ String Script::ToString() const
 
 void Script::OnDeleteObject()
 {
-    // Ensure to unlink from the parent (it will call Disable event if required)
-    SetParent(nullptr);
-
-    // Check if remove object from game
-    if (IsDuringPlay())
+    // Call OnDisable
+    if (_wasEnableCalled)
     {
+        Disable();
+    }
+
+    // Call OnDestroy
+    if (_wasAwakeCalled)
+    {
+        _wasAwakeCalled = false;
         CHECK_EXECUTE_IN_EDITOR
         {
             OnDestroy();
         }
+    }
+
+    // End play
+    if (IsDuringPlay())
+    {
         EndPlay();
     }
 
+    // Unlink from parent
+    SetParent(nullptr);
+
     // Base
     SceneObject::OnDeleteObject();
 }
@@ -274,6 +287,9 @@ void Script::Initialize()
     if (!IsRegistered())
         RegisterObject();
 
+    // Call OnAwake
+    ASSERT(!_wasAwakeCalled);
+    _wasAwakeCalled = true;
     CHECK_EXECUTE_IN_EDITOR
     {
         OnAwake();
diff --git a/Source/Engine/Scripting/Script.h b/Source/Engine/Scripting/Script.h
index 8cf1d0670..919f3ecdd 100644
--- a/Source/Engine/Scripting/Script.h
+++ b/Source/Engine/Scripting/Script.h
@@ -20,6 +20,7 @@ protected:
     uint16 _tickUpdate : 1;
     uint16 _tickLateUpdate : 1;
     uint16 _tickLateFixedUpdate : 1;
+    uint16 _wasAwakeCalled : 1;
     uint16 _wasStartCalled : 1;
     uint16 _wasEnableCalled : 1;
 #if USE_EDITOR
diff --git a/Source/Engine/Serialization/JsonWriter.cpp b/Source/Engine/Serialization/JsonWriter.cpp
index 223baf77e..27ecb672b 100644
--- a/Source/Engine/Serialization/JsonWriter.cpp
+++ b/Source/Engine/Serialization/JsonWriter.cpp
@@ -466,7 +466,7 @@ void JsonWriter::SceneObject(::SceneObject* obj)
             prefab->GetDefaultInstance();
 
             // Get prefab object instance from the prefab
-            const void* prefabObject;
+            ::SceneObject* prefabObject;
             if (prefab->ObjectsCache.TryGet(obj->GetPrefabObjectID(), prefabObject))
             {
                 // Serialize modified properties compared with the default object from prefab
@@ -481,7 +481,7 @@ void JsonWriter::SceneObject(::SceneObject* obj)
         }
         else
         {
-            LOG(Warning, "Missing prefab with id={0}.", obj->GetPrefabID());
+            LOG(Warning, "Missing prefab {0}.", obj->GetPrefabID());
         }
     }
 
diff --git a/Source/Engine/Streaming/StreamableResource.h b/Source/Engine/Streaming/StreamableResource.h
index 866ec8469..27ae0a089 100644
--- a/Source/Engine/Streaming/StreamableResource.h
+++ b/Source/Engine/Streaming/StreamableResource.h
@@ -111,8 +111,9 @@ public:
     struct StreamingCache
     {
         int64 LastUpdate = 0;
-        int32 TargetResidency = 0;
         int64 TargetResidencyChange = 0;
+        int32 TargetResidency = 0;
+        bool Error = false;
         SamplesBuffer<float, 5> QualitySamples;
     };
 
@@ -131,7 +132,8 @@ public:
     /// <summary>
     /// Stops the streaming (eg. on streaming fail).
     /// </summary>
-    void ResetStreaming();
+    /// <param name="error">True if streaming failed.</param>
+    void ResetStreaming(bool error = true);
 
 protected:
 
diff --git a/Source/Engine/Streaming/Streaming.cpp b/Source/Engine/Streaming/Streaming.cpp
index 19b845fb1..a7b2cad44 100644
--- a/Source/Engine/Streaming/Streaming.cpp
+++ b/Source/Engine/Streaming/Streaming.cpp
@@ -84,8 +84,9 @@ void StreamableResource::RequestStreamingUpdate()
     Streaming.LastUpdate = 0;
 }
 
-void StreamableResource::ResetStreaming()
+void StreamableResource::ResetStreaming(bool error)
 {
+    Streaming.Error = error;
     Streaming.TargetResidency = 0;
     Streaming.LastUpdate = DateTime::MaxValue().Ticks;
 }
diff --git a/Source/Engine/Terrain/TerrainChunk.cpp b/Source/Engine/Terrain/TerrainChunk.cpp
index 737ce08f8..9bf1c1208 100644
--- a/Source/Engine/Terrain/TerrainChunk.cpp
+++ b/Source/Engine/Terrain/TerrainChunk.cpp
@@ -84,6 +84,8 @@ void TerrainChunk::Draw(const RenderContext& renderContext) const
     DrawCall drawCall;
     if (TerrainManager::GetChunkGeometry(drawCall, chunkSize, lod))
         return;
+    if (!_neighbors[0])
+        const_cast<TerrainChunk*>(this)->CacheNeighbors();
     drawCall.InstanceCount = 1;
     drawCall.Material = _cachedDrawMaterial;
     renderContext.View.GetWorldMatrix(_transform, drawCall.World);
diff --git a/Source/Engine/Tests/TestPrefabs.cpp b/Source/Engine/Tests/TestPrefabs.cpp
index 211fea930..ec3eb4af6 100644
--- a/Source/Engine/Tests/TestPrefabs.cpp
+++ b/Source/Engine/Tests/TestPrefabs.cpp
@@ -412,4 +412,149 @@ TEST_CASE("Prefabs")
         Content::DeleteAsset(prefabNested);
         Content::DeleteAsset(prefabBase);
     }
+    SECTION("Test Loading Nested Prefab After Changing and Deleting Root")
+    {
+        // https://github.com/FlaxEngine/FlaxEngine/issues/2050
+
+        // Create base prefab with 1 object
+        AssetReference<Prefab> prefabBase = Content::CreateVirtualAsset<Prefab>();
+        REQUIRE(prefabBase);
+        Guid id;
+        Guid::Parse("3b3334524c696dcfa93cabacd2a4f404", id);
+        prefabBase->ChangeID(id);
+        auto prefabBaseInit = prefabBase->Init(Prefab::TypeName,
+                                               "["
+                                               "{"
+                                               "\"ID\": \"82ce814f4d913e58eb35ab8b0b7e2eef\","
+                                               "\"TypeName\": \"FlaxEngine.DirectionalLight\","
+                                               "\"Name\": \"New Root\""
+                                               "},"
+                                               "{"
+                                               "\"ID\": \"f8fbee1349f749396ab6c2ad34f3afec\","
+                                               "\"TypeName\": \"FlaxEngine.Camera\","
+                                               "\"Name\": \"Child 1\","
+                                               "\"ParentID\": \"82ce814f4d913e58eb35ab8b0b7e2eef\""
+                                               "},"
+                                               "{"
+                                               "\"ID\": \"5632561847cf96fe2e8919848b7eca79\","
+                                               "\"TypeName\": \"FlaxEngine.EmptyActor\","
+                                               "\"Name\": \"Child 1.Child\","
+                                               "\"ParentID\": \"f8fbee1349f749396ab6c2ad34f3afec\""
+                                               "},"
+                                               "{"
+                                               "\"ID\": \"4e4f3a1847cf96fe2e8919848b7eca79\","
+                                               "\"TypeName\": \"FlaxEngine.UICanvas\","
+                                               "\"Name\": \"Child 2\","
+                                               "\"ParentID\": \"82ce814f4d913e58eb35ab8b0b7e2eef\""
+                                               "}"
+                                               "]");
+        REQUIRE(!prefabBaseInit);
+
+        // Create nested prefab but with 'old' state where root object is different
+        AssetReference<Prefab> prefabNested1 = Content::CreateVirtualAsset<Prefab>();
+        REQUIRE(prefabNested1);
+        Guid::Parse("671447e947cbd2deea018a8377636ce6", id);
+        prefabNested1->ChangeID(id);
+        auto prefabNestedInit1 = prefabNested1->Init(Prefab::TypeName,
+                                                   "["
+                                                   "{"
+                                                   "\"ID\": \"597ab8ea43a5c58b8d06f58f9364d261\","
+                                                   "\"PrefabID\": \"3b3334524c696dcfa93cabacd2a4f404\","
+                                                   "\"PrefabObjectID\": \"589bcfaa4bd1a53435129480e5bbdb3b\","
+                                                   "\"Name\": \"Old Root\""
+                                                   "},"
+                                                   "{"
+                                                   "\"ID\": \"1a6228d84897ff3b2f444ea263c3657e\","
+                                                   "\"PrefabID\": \"3b3334524c696dcfa93cabacd2a4f404\","
+                                                   "\"PrefabObjectID\": \"f8fbee1349f749396ab6c2ad34f3afec\","
+                                                   "\"ParentID\": \"597ab8ea43a5c58b8d06f58f9364d261\""
+                                                   "},"
+                                                   "{"
+                                                   "\"ID\": \"1212124f4d913e58eb35ab8b0b7e2eef\","
+                                                   "\"PrefabID\": \"3b3334524c696dcfa93cabacd2a4f404\","
+                                                   "\"PrefabObjectID\": \"82ce814f4d913e58eb35ab8b0b7e2eef\","
+                                                   "\"ParentID\": \"597ab8ea43a5c58b8d06f58f9364d261\","
+                                                   "\"Name\": \"New Root\""
+                                                   "},"
+                                                   "{"
+                                                   "\"ID\": \"468028d84897ff3b2f444ea263c3657e\","
+                                                   "\"PrefabID\": \"3b3334524c696dcfa93cabacd2a4f404\","
+                                                   "\"PrefabObjectID\": \"2468902349f749396ab6c2ad34f3afec\","
+                                                   "\"ParentID\": \"597ab8ea43a5c58b8d06f58f9364d261\","
+                                                   "\"Name\": \"Old Child\""
+                                                   "}"
+                                                   "]");
+        REQUIRE(!prefabNestedInit1);
+
+        // Create nested prefab but with 'old' state where root object is different and doesn't exist anymore
+        AssetReference<Prefab> prefabNested2 = Content::CreateVirtualAsset<Prefab>();
+        REQUIRE(prefabNested2);
+        Guid::Parse("b71447e947cbd2deea018a8377636ce6", id);
+        prefabNested2->ChangeID(id);
+        auto prefabNestedInit2 = prefabNested2->Init(Prefab::TypeName,
+                                                   "["
+                                                   "{"
+                                                   "\"ID\": \"597ab8ea43a5c58b8d06f58f9364d261\","
+                                                   "\"PrefabID\": \"3b3334524c696dcfa93cabacd2a4f404\","
+                                                   "\"PrefabObjectID\": \"589bcfaa4bd1a53435129480e5bbdb3b\","
+                                                   "\"Name\": \"Old Root\""
+                                                   "},"
+                                                   "{"
+                                                   "\"ID\": \"1a6228d84897ff3b2f444ea263c3657e\","
+                                                   "\"PrefabID\": \"3b3334524c696dcfa93cabacd2a4f404\","
+                                                   "\"PrefabObjectID\": \"f8fbee1349f749396ab6c2ad34f3afec\","
+                                                   "\"ParentID\": \"597ab8ea43a5c58b8d06f58f9364d261\""
+                                                   "},"
+                                                   "{"
+                                                   "\"ID\": \"468028d84897ff3b2f444ea263c3657e\","
+                                                   "\"PrefabID\": \"3b3334524c696dcfa93cabacd2a4f404\","
+                                                   "\"PrefabObjectID\": \"2468902349f749396ab6c2ad34f3afec\","
+                                                   "\"ParentID\": \"597ab8ea43a5c58b8d06f58f9364d261\","
+                                                   "\"Name\": \"Old Child\""
+                                                   "}"
+                                                   "]");
+        REQUIRE(!prefabNestedInit2);
+
+        // Spawn test instances of both prefabs
+        ScriptingObjectReference<Actor> instanceBase = PrefabManager::SpawnPrefab(prefabBase);
+        ScriptingObjectReference<Actor> instanceNested1 = PrefabManager::SpawnPrefab(prefabNested1);
+        ScriptingObjectReference<Actor> instanceNested2 = PrefabManager::SpawnPrefab(prefabNested2);
+
+        // Verify scenario
+        REQUIRE(instanceBase);
+        REQUIRE(instanceBase->GetName() == TEXT("New Root"));
+        REQUIRE(instanceBase->GetChildrenCount() == 2);
+        REQUIRE(instanceBase->Children[0]->GetName() == TEXT("Child 1"));
+        REQUIRE(instanceBase->Children[0]->GetChildrenCount() == 1);
+        REQUIRE(instanceBase->Children[1]->GetName() == TEXT("Child 2"));
+        REQUIRE(instanceBase->Children[1]->GetChildrenCount() == 0);
+        REQUIRE(instanceBase->Children[0]->Children[0]->GetName() == TEXT("Child 1.Child"));
+        REQUIRE(instanceBase->Children[0]->Children[0]->GetChildrenCount() == 0);
+        REQUIRE(instanceNested1);
+        REQUIRE(instanceNested1->GetName() == TEXT("New Root"));
+        REQUIRE(instanceNested1->GetChildrenCount() == 2);
+        REQUIRE(instanceNested1->Children[0]->GetName() == TEXT("Child 1"));
+        REQUIRE(instanceNested1->Children[0]->GetChildrenCount() == 1);
+        REQUIRE(instanceNested1->Children[1]->GetName() == TEXT("Child 2"));
+        REQUIRE(instanceNested1->Children[1]->GetChildrenCount() == 0);
+        REQUIRE(instanceNested1->Children[0]->Children[0]->GetName() == TEXT("Child 1.Child"));
+        REQUIRE(instanceNested1->Children[0]->Children[0]->GetChildrenCount() == 0);
+        REQUIRE(instanceNested2);
+        REQUIRE(instanceNested2->GetName() == TEXT("New Root"));
+        REQUIRE(instanceNested2->GetChildrenCount() == 2);
+        REQUIRE(instanceNested2->Children[0]->GetName() == TEXT("Child 1"));
+        REQUIRE(instanceNested2->Children[0]->GetChildrenCount() == 1);
+        REQUIRE(instanceNested2->Children[1]->GetName() == TEXT("Child 2"));
+        REQUIRE(instanceNested2->Children[1]->GetChildrenCount() == 0);
+        REQUIRE(instanceNested2->Children[0]->Children[0]->GetName() == TEXT("Child 1.Child"));
+        REQUIRE(instanceNested2->Children[0]->Children[0]->GetChildrenCount() == 0);
+
+        // Cleanup
+        instanceNested2->DeleteObject();
+        instanceNested1->DeleteObject();
+        instanceBase->DeleteObject();
+        Content::DeleteAsset(prefabNested2);
+        Content::DeleteAsset(prefabNested1);
+        Content::DeleteAsset(prefabBase);
+    }
 }
diff --git a/Source/Engine/Threading/MainThreadTask.h b/Source/Engine/Threading/MainThreadTask.h
index 36e66bfb0..fc5b9fe2d 100644
--- a/Source/Engine/Threading/MainThreadTask.h
+++ b/Source/Engine/Threading/MainThreadTask.h
@@ -66,7 +66,7 @@ public:
     /// </summary>
     /// <param name="action">The action.</param>
     /// <param name="target">The target object.</param>
-    MainThreadActionTask(Function<void()>& action, Object* target = nullptr)
+    MainThreadActionTask(const Function<void()>& action, Object* target = nullptr)
         : MainThreadTask()
         , _action1(action)
         , _target(target)
@@ -90,7 +90,7 @@ public:
     /// </summary>
     /// <param name="action">The action.</param>
     /// <param name="target">The target object.</param>
-    MainThreadActionTask(Function<bool()>& action, Object* target = nullptr)
+    MainThreadActionTask(const Function<bool()>& action, Object* target = nullptr)
         : MainThreadTask()
         , _action2(action)
         , _target(target)
diff --git a/Source/Engine/Threading/Task.cpp b/Source/Engine/Threading/Task.cpp
index a516c31c7..84737a71b 100644
--- a/Source/Engine/Threading/Task.cpp
+++ b/Source/Engine/Threading/Task.cpp
@@ -96,13 +96,13 @@ Task* Task::ContinueWith(const Action& action, Object* target)
     return result;
 }
 
-Task* Task::ContinueWith(Function<void()> action, Object* target)
+Task* Task::ContinueWith(const Function<void()>& action, Object* target)
 {
     ASSERT(action.IsBinded());
     return ContinueWith(New<ThreadPoolActionTask>(action, target));
 }
 
-Task* Task::ContinueWith(Function<bool()> action, Object* target)
+Task* Task::ContinueWith(const Function<bool()>& action, Object* target)
 {
     ASSERT(action.IsBinded());
     return ContinueWith(New<ThreadPoolActionTask>(action, target));
@@ -116,17 +116,17 @@ Task* Task::StartNew(Task* task)
     return task;
 }
 
-Task* Task::StartNew(Function<void()>& action, Object* target)
+Task* Task::StartNew(const Function<void()>& action, Object* target)
 {
     return StartNew(New<ThreadPoolActionTask>(action, target));
 }
 
-Task* Task::StartNew(Function<void()>::Signature action, Object* target)
+Task* Task::StartNew(const Function<void()>::Signature action, Object* target)
 {
     return StartNew(New<ThreadPoolActionTask>(action, target));
 }
 
-Task* Task::StartNew(Function<bool()>& action, Object* target)
+Task* Task::StartNew(const Function<bool()>& action, Object* target)
 {
     return StartNew(New<ThreadPoolActionTask>(action, target));
 }
diff --git a/Source/Engine/Threading/Task.h b/Source/Engine/Threading/Task.h
index 4a17de727..12b131d1b 100644
--- a/Source/Engine/Threading/Task.h
+++ b/Source/Engine/Threading/Task.h
@@ -221,7 +221,7 @@ public:
     /// <param name="action">Action to run.</param>
     /// <param name="target">The action target object.</param>
     /// <returns>Enqueued task.</returns>
-    Task* ContinueWith(Function<void()> action, Object* target = nullptr);
+    Task* ContinueWith(const Function<void()>& action, Object* target = nullptr);
 
     /// <summary>
     /// Continues that task execution with a given action (will spawn new async action).
@@ -229,7 +229,7 @@ public:
     /// <param name="action">Action to run.</param>
     /// <param name="target">The action target object.</param>
     /// <returns>Enqueued task.</returns>
-    Task* ContinueWith(Function<bool()> action, Object* target = nullptr);
+    Task* ContinueWith(const Function<bool()>& action, Object* target = nullptr);
 
 public:
 
@@ -246,7 +246,7 @@ public:
     /// <param name="action">The action.</param>
     /// <param name="target">The action target object.</param>
     /// <returns>Task</returns>
-    static Task* StartNew(Function<void()>& action, Object* target = nullptr);
+    static Task* StartNew(const Function<void()>& action, Object* target = nullptr);
 
     /// <summary>
     /// Starts the new task.
@@ -275,7 +275,7 @@ public:
     /// <param name="action">The action.</param>
     /// <param name="target">The action target object.</param>
     /// <returns>Task</returns>
-    static Task* StartNew(Function<bool()>& action, Object* target = nullptr);
+    static Task* StartNew(const Function<bool()>& action, Object* target = nullptr);
 
     /// <summary>
     /// Starts the new task.
diff --git a/Source/Engine/Threading/ThreadPoolTask.h b/Source/Engine/Threading/ThreadPoolTask.h
index 9e1cc6fac..6378f3ee4 100644
--- a/Source/Engine/Threading/ThreadPoolTask.h
+++ b/Source/Engine/Threading/ThreadPoolTask.h
@@ -55,7 +55,7 @@ public:
     /// </summary>
     /// <param name="action">The action.</param>
     /// <param name="target">The target object.</param>
-    ThreadPoolActionTask(Function<void()>& action, Object* target = nullptr)
+    ThreadPoolActionTask(const Function<void()>& action, Object* target = nullptr)
         : ThreadPoolTask()
         , _action1(action)
         , _target(target)
@@ -79,7 +79,7 @@ public:
     /// </summary>
     /// <param name="action">The action.</param>
     /// <param name="target">The target object.</param>
-    ThreadPoolActionTask(Function<bool()>& action, Object* target = nullptr)
+    ThreadPoolActionTask(const Function<bool()>& action, Object* target = nullptr)
         : ThreadPoolTask()
         , _action2(action)
         , _target(target)
diff --git a/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp b/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp
index 3d9be61d2..e62d03b1c 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp
@@ -4,7 +4,6 @@
 
 #include "ModelTool.h"
 #include "Engine/Core/Log.h"
-#include "Engine/Core/DeleteMe.h"
 #include "Engine/Core/Math/Matrix.h"
 #include "Engine/Core/Collections/Dictionary.h"
 #include "Engine/Platform/FileSystem.h"
@@ -28,7 +27,6 @@ using namespace Assimp;
 class AssimpLogStream : public LogStream
 {
 public:
-
     AssimpLogStream()
     {
         DefaultLogger::create("");
@@ -238,7 +236,7 @@ void ProcessNodes(AssimpImporterData& data, aiNode* aNode, int32 parentIndex)
     }
 }
 
-bool ProcessMesh(ImportedModelData& result, AssimpImporterData& data, const aiMesh* aMesh, MeshData& mesh, String& errorMsg)
+bool ProcessMesh(ModelData& result, AssimpImporterData& data, const aiMesh* aMesh, MeshData& mesh, String& errorMsg)
 {
     // Properties
     mesh.Name = aMesh->mName.C_Str();
@@ -363,7 +361,7 @@ bool ProcessMesh(ImportedModelData& result, AssimpImporterData& data, const aiMe
     }
 
     // Blend Indices and Blend Weights
-    if (aMesh->mNumBones > 0 && aMesh->mBones && EnumHasAnyFlags(result.Types, ImportDataTypes::Skeleton))
+    if (aMesh->mNumBones > 0 && aMesh->mBones && EnumHasAnyFlags(data.Options.ImportTypes, ImportDataTypes::Skeleton))
     {
         const int32 vertexCount = mesh.Positions.Count();
         mesh.BlendIndices.Resize(vertexCount);
@@ -444,7 +442,7 @@ bool ProcessMesh(ImportedModelData& result, AssimpImporterData& data, const aiMe
     }
 
     // Blend Shapes
-    if (aMesh->mNumAnimMeshes > 0 && EnumHasAnyFlags(result.Types, ImportDataTypes::Skeleton) && data.Options.ImportBlendShapes)
+    if (aMesh->mNumAnimMeshes > 0 && EnumHasAnyFlags(data.Options.ImportTypes, ImportDataTypes::Skeleton) && data.Options.ImportBlendShapes)
     {
         mesh.BlendShapes.EnsureCapacity(aMesh->mNumAnimMeshes);
         for (unsigned int animMeshIndex = 0; animMeshIndex < aMesh->mNumAnimMeshes; animMeshIndex++)
@@ -489,7 +487,7 @@ bool ProcessMesh(ImportedModelData& result, AssimpImporterData& data, const aiMe
     return false;
 }
 
-bool ImportTexture(ImportedModelData& result, AssimpImporterData& data, aiString& aFilename, int32& textureIndex, TextureEntry::TypeHint type)
+bool ImportTexture(ModelData& result, AssimpImporterData& data, aiString& aFilename, int32& textureIndex, TextureEntry::TypeHint type)
 {
     // Find texture file path
     const String filename = String(aFilename.C_Str()).TrimTrailing();
@@ -514,7 +512,7 @@ bool ImportTexture(ImportedModelData& result, AssimpImporterData& data, aiString
     return true;
 }
 
-bool ImportMaterialTexture(ImportedModelData& result, AssimpImporterData& data, const aiMaterial* aMaterial, aiTextureType aTextureType, int32& textureIndex, TextureEntry::TypeHint type)
+bool ImportMaterialTexture(ModelData& result, AssimpImporterData& data, const aiMaterial* aMaterial, aiTextureType aTextureType, int32& textureIndex, TextureEntry::TypeHint type)
 {
     aiString aFilename;
     if (aMaterial->GetTexture(aTextureType, 0, &aFilename, nullptr, nullptr, nullptr, nullptr) == AI_SUCCESS)
@@ -560,7 +558,7 @@ bool ImportMaterialTexture(ImportedModelData& result, AssimpImporterData& data,
     return false;
 }
 
-bool ImportMaterials(ImportedModelData& result, AssimpImporterData& data, String& errorMsg)
+bool ImportMaterials(ModelData& result, AssimpImporterData& data, String& errorMsg)
 {
     const uint32 materialsCount = data.Scene->mNumMaterials;
     result.Materials.Resize(materialsCount, false);
@@ -574,7 +572,7 @@ bool ImportMaterials(ImportedModelData& result, AssimpImporterData& data, String
             materialSlot.Name = String(aName.C_Str()).TrimTrailing();
         materialSlot.AssetID = Guid::Empty;
 
-        if (EnumHasAnyFlags(result.Types, ImportDataTypes::Materials))
+        if (EnumHasAnyFlags(data.Options.ImportTypes, ImportDataTypes::Materials))
         {
             aiColor3D aColor;
             if (aMaterial->Get(AI_MATKEY_COLOR_DIFFUSE, aColor) == AI_SUCCESS)
@@ -586,7 +584,7 @@ bool ImportMaterials(ImportedModelData& result, AssimpImporterData& data, String
             if (aMaterial->Get(AI_MATKEY_OPACITY, aFloat) == AI_SUCCESS)
                 materialSlot.Opacity.Value = aFloat;
 
-            if (EnumHasAnyFlags(result.Types, ImportDataTypes::Textures))
+            if (EnumHasAnyFlags(data.Options.ImportTypes, ImportDataTypes::Textures))
             {
                 ImportMaterialTexture(result, data, aMaterial, aiTextureType_DIFFUSE, materialSlot.Diffuse.TextureIndex, TextureEntry::TypeHint::ColorRGB);
                 ImportMaterialTexture(result, data, aMaterial, aiTextureType_EMISSIVE, materialSlot.Emissive.TextureIndex, TextureEntry::TypeHint::ColorRGB);
@@ -612,32 +610,35 @@ bool IsMeshInvalid(const aiMesh* aMesh)
     return aMesh->mPrimitiveTypes != aiPrimitiveType_TRIANGLE || aMesh->mNumVertices == 0 || aMesh->mNumFaces == 0 || aMesh->mFaces[0].mNumIndices != 3;
 }
 
-bool ImportMesh(int32 i, ImportedModelData& result, AssimpImporterData& data, String& errorMsg)
+bool ImportMesh(int32 index, ModelData& result, AssimpImporterData& data, String& errorMsg)
 {
-    const auto aMesh = data.Scene->mMeshes[i];
+    const auto aMesh = data.Scene->mMeshes[index];
 
     // Skip invalid meshes
     if (IsMeshInvalid(aMesh))
         return false;
 
     // Skip unused meshes
-    if (!data.MeshIndexToNodeIndex.ContainsKey(i))
+    if (!data.MeshIndexToNodeIndex.ContainsKey(index))
         return false;
 
     // Import mesh data
     MeshData* meshData = New<MeshData>();
     if (ProcessMesh(result, data, aMesh, *meshData, errorMsg))
-        return true;
-
-    auto& nodesWithMesh = data.MeshIndexToNodeIndex[i];
-    for (int32 j = 0; j < nodesWithMesh.Count(); j++)
     {
-        const auto nodeIndex = nodesWithMesh[j];
+        Delete(meshData);
+        return true;
+    }
+
+    auto& nodesWithMesh = data.MeshIndexToNodeIndex[index];
+    for (int32 i = 0; i < nodesWithMesh.Count(); i++)
+    {
+        const auto nodeIndex = nodesWithMesh[i];
         auto& node = data.Nodes[nodeIndex];
         const int32 lodIndex = node.LodIndex;
 
         // The first mesh instance uses meshData directly while others have to clone it
-        if (j != 0)
+        if (i != 0)
         {
             meshData = New<MeshData>(*meshData);
         }
@@ -739,222 +740,166 @@ void ImportCurve(aiQuatKey* keys, uint32 keysCount, LinearCurve<Quaternion>& cur
     }
 }
 
-bool ModelTool::ImportDataAssimp(const char* path, ImportedModelData& data, Options& options, String& errorMsg)
+void ImportAnimation(int32 index, ModelData& data, AssimpImporterData& importerData)
 {
-    auto context = (AssimpImporterData*)options.SplitContext;
-    if (!context)
+    const auto animations = importerData.Scene->mAnimations[index];
+    auto& anim = data.Animations.AddOne();
+    anim.Channels.Resize(animations->mNumChannels, false);
+    anim.Duration = animations->mDuration;
+    anim.FramesPerSecond = animations->mTicksPerSecond;
+    if (anim.FramesPerSecond <= 0)
     {
-        static bool AssimpInited = false;
-        if (!AssimpInited)
-        {
-            AssimpInited = true;
-            LOG(Info, "Assimp {0}.{1}.{2}", aiGetVersionMajor(), aiGetVersionMinor(), aiGetVersionRevision());
-        }
-        bool importMeshes = EnumHasAnyFlags(data.Types, ImportDataTypes::Geometry);
-        bool importAnimations = EnumHasAnyFlags(data.Types, ImportDataTypes::Animations);
-        context = New<AssimpImporterData>(path, options);
-
-        // Setup import flags
-        unsigned int flags =
-                aiProcess_JoinIdenticalVertices |
-                aiProcess_LimitBoneWeights |
-                aiProcess_Triangulate |
-                aiProcess_SortByPType |
-                aiProcess_GenUVCoords |
-                aiProcess_FindDegenerates |
-                aiProcess_FindInvalidData |
-                //aiProcess_ValidateDataStructure |
-                aiProcess_ConvertToLeftHanded;
-        if (importMeshes)
-        {
-            if (options.CalculateNormals)
-                flags |= aiProcess_FixInfacingNormals | aiProcess_GenSmoothNormals;
-            if (options.CalculateTangents)
-                flags |= aiProcess_CalcTangentSpace;
-            if (options.OptimizeMeshes)
-                flags |= aiProcess_OptimizeMeshes | aiProcess_SplitLargeMeshes | aiProcess_ImproveCacheLocality;
-            if (options.MergeMeshes)
-                flags |= aiProcess_RemoveRedundantMaterials;
-        }
-
-        // Setup import options
-        context->AssimpImporter.SetPropertyFloat(AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE, options.SmoothingNormalsAngle);
-        context->AssimpImporter.SetPropertyFloat(AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE, options.SmoothingTangentsAngle);
-        //context->AssimpImporter.SetPropertyInteger(AI_CONFIG_PP_SLM_TRIANGLE_LIMIT, MAX_uint16);
-        context->AssimpImporter.SetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_CAMERAS, false);
-        context->AssimpImporter.SetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_LIGHTS, false);
-        context->AssimpImporter.SetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_TEXTURES, false);
-        context->AssimpImporter.SetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ANIMATIONS, importAnimations);
-        //context->AssimpImporter.SetPropertyBool(AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS, false); // TODO: optimize pivots when https://github.com/assimp/assimp/issues/1068 gets fixed
-        context->AssimpImporter.SetPropertyBool(AI_CONFIG_IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES, true);
-
-        // Import file
-        context->Scene = context->AssimpImporter.ReadFile(path, flags);
-        if (context->Scene == nullptr)
-        {
-            LOG_STR(Warning, String(context->AssimpImporter.GetErrorString()));
-            LOG_STR(Warning, String(path));
-            LOG_STR(Warning, StringUtils::ToString(flags));
-            errorMsg = context->AssimpImporter.GetErrorString();
-            Delete(context);
-            return true;
-        }
-
-        // Create root node
-        AssimpNode& rootNode = context->Nodes.AddOne();
-        rootNode.ParentIndex = -1;
-        rootNode.LodIndex = 0;
-        rootNode.Name = TEXT("Root");
-        rootNode.LocalTransform = Transform::Identity;
-
-        // Process imported scene nodes
-        ProcessNodes(*context, context->Scene->mRootNode, 0);
+        anim.FramesPerSecond = importerData.Options.DefaultFrameRate;
+        if (anim.FramesPerSecond <= 0)
+            anim.FramesPerSecond = 30.0f;
     }
-    DeleteMe<AssimpImporterData> contextCleanup(options.SplitContext ? nullptr : context);
+    anim.Name = animations->mName.C_Str();
+
+    for (unsigned i = 0; i < animations->mNumChannels; i++)
+    {
+        const auto aAnim = animations->mChannels[i];
+        auto& channel = anim.Channels[i];
+
+        channel.NodeName = aAnim->mNodeName.C_Str();
+
+        ImportCurve(aAnim->mPositionKeys, aAnim->mNumPositionKeys, channel.Position);
+        ImportCurve(aAnim->mRotationKeys, aAnim->mNumRotationKeys, channel.Rotation);
+        if (importerData.Options.ImportScaleTracks)
+            ImportCurve(aAnim->mScalingKeys, aAnim->mNumScalingKeys, channel.Scale);
+    }
+}
+
+bool ModelTool::ImportDataAssimp(const char* path, ModelData& data, Options& options, String& errorMsg)
+{
+    static bool AssimpInited = false;
+    if (!AssimpInited)
+    {
+        AssimpInited = true;
+        LOG(Info, "Assimp {0}.{1}.{2}", aiGetVersionMajor(), aiGetVersionMinor(), aiGetVersionRevision());
+    }
+    bool importMeshes = EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Geometry);
+    bool importAnimations = EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Animations);
+    AssimpImporterData context(path, options);
+
+    // Setup import flags
+    unsigned int flags =
+            aiProcess_JoinIdenticalVertices |
+            aiProcess_LimitBoneWeights |
+            aiProcess_Triangulate |
+            aiProcess_SortByPType |
+            aiProcess_GenUVCoords |
+            aiProcess_FindDegenerates |
+            aiProcess_FindInvalidData |
+            //aiProcess_ValidateDataStructure |
+            aiProcess_ConvertToLeftHanded;
+    if (importMeshes)
+    {
+        if (options.CalculateNormals)
+            flags |= aiProcess_FixInfacingNormals | aiProcess_GenSmoothNormals;
+        if (options.CalculateTangents)
+            flags |= aiProcess_CalcTangentSpace;
+        if (options.OptimizeMeshes)
+            flags |= aiProcess_OptimizeMeshes | aiProcess_SplitLargeMeshes | aiProcess_ImproveCacheLocality;
+        if (options.MergeMeshes)
+            flags |= aiProcess_RemoveRedundantMaterials;
+    }
+
+    // Setup import options
+    context.AssimpImporter.SetPropertyFloat(AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE, options.SmoothingNormalsAngle);
+    context.AssimpImporter.SetPropertyFloat(AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE, options.SmoothingTangentsAngle);
+    //context.AssimpImporter.SetPropertyInteger(AI_CONFIG_PP_SLM_TRIANGLE_LIMIT, MAX_uint16);
+    context.AssimpImporter.SetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_CAMERAS, false);
+    context.AssimpImporter.SetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_LIGHTS, false);
+    context.AssimpImporter.SetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_TEXTURES, false);
+    context.AssimpImporter.SetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ANIMATIONS, importAnimations);
+    //context.AssimpImporter.SetPropertyBool(AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS, false); // TODO: optimize pivots when https://github.com/assimp/assimp/issues/1068 gets fixed
+    context.AssimpImporter.SetPropertyBool(AI_CONFIG_IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES, true);
+
+    // Import file
+    context.Scene = context.AssimpImporter.ReadFile(path, flags);
+    if (context.Scene == nullptr)
+    {
+        LOG_STR(Warning, String(context.AssimpImporter.GetErrorString()));
+        LOG_STR(Warning, String(path));
+        LOG_STR(Warning, StringUtils::ToString(flags));
+        errorMsg = context.AssimpImporter.GetErrorString();
+        return true;
+    }
+
+    // Create root node
+    AssimpNode& rootNode = context.Nodes.AddOne();
+    rootNode.ParentIndex = -1;
+    rootNode.LodIndex = 0;
+    rootNode.Name = TEXT("Root");
+    rootNode.LocalTransform = Transform::Identity;
+
+    // Process imported scene nodes
+    ProcessNodes(context, context.Scene->mRootNode, 0);
 
     // Import materials
-    if (ImportMaterials(data, *context, errorMsg))
+    if (ImportMaterials(data, context, errorMsg))
     {
         LOG(Warning, "Failed to import materials.");
         return true;
     }
 
     // Import geometry
-    if (EnumHasAnyFlags(data.Types, ImportDataTypes::Geometry) && context->Scene->HasMeshes())
+    if (EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Geometry) && context.Scene->HasMeshes())
     {
-        const int meshCount = context->Scene->mNumMeshes;
-        if (options.SplitObjects && options.ObjectIndex == -1 && meshCount > 1)
+        for (unsigned meshIndex = 0; meshIndex < context.Scene->mNumMeshes; meshIndex++)
         {
-            // Import the first object within this call
-            options.SplitObjects = false;
-            options.ObjectIndex = 0;
-
-            if (options.OnSplitImport.IsBinded())
-            {
-                // Split all animations into separate assets
-                LOG(Info, "Splitting imported {0} meshes", meshCount);
-                for (int32 i = 1; i < meshCount; i++)
-                {
-                    auto splitOptions = options;
-                    splitOptions.ObjectIndex = i;
-                    splitOptions.SplitContext = context;
-                    const auto aMesh = context->Scene->mMeshes[i];
-                    const String objectName(aMesh->mName.C_Str());
-                    options.OnSplitImport(splitOptions, objectName);
-                }
-            }
-        }
-        if (options.ObjectIndex != -1)
-        {
-            // Import the selected mesh
-            const auto meshIndex = Math::Clamp<int32>(options.ObjectIndex, 0, meshCount - 1);
-            if (ImportMesh(meshIndex, data, *context, errorMsg))
+            if (ImportMesh((int32)meshIndex, data, context, errorMsg))
                 return true;
         }
-        else
-        {
-            // Import all meshes
-            for (int32 meshIndex = 0; meshIndex < meshCount; meshIndex++)
-            {
-                if (ImportMesh(meshIndex, data, *context, errorMsg))
-                    return true;
-            }
-        }
     }
 
     // Import skeleton
-    if (EnumHasAnyFlags(data.Types, ImportDataTypes::Skeleton))
+    if (EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Skeleton))
     {
-        data.Skeleton.Nodes.Resize(context->Nodes.Count(), false);
-        for (int32 i = 0; i < context->Nodes.Count(); i++)
+        data.Skeleton.Nodes.Resize(context.Nodes.Count(), false);
+        for (int32 i = 0; i < context.Nodes.Count(); i++)
         {
             auto& node = data.Skeleton.Nodes[i];
-            auto& aNode = context->Nodes[i];
+            auto& aNode = context.Nodes[i];
 
             node.Name = aNode.Name;
             node.ParentIndex = aNode.ParentIndex;
             node.LocalTransform = aNode.LocalTransform;
         }
 
-        data.Skeleton.Bones.Resize(context->Bones.Count(), false);
-        for (int32 i = 0; i < context->Bones.Count(); i++)
+        data.Skeleton.Bones.Resize(context.Bones.Count(), false);
+        for (int32 i = 0; i < context.Bones.Count(); i++)
         {
             auto& bone = data.Skeleton.Bones[i];
-            auto& aBone = context->Bones[i];
+            auto& aBone = context.Bones[i];
 
             const auto boneNodeIndex = aBone.NodeIndex;
-            const auto parentBoneNodeIndex = aBone.ParentBoneIndex == -1 ? -1 : context->Bones[aBone.ParentBoneIndex].NodeIndex;
+            const auto parentBoneNodeIndex = aBone.ParentBoneIndex == -1 ? -1 : context.Bones[aBone.ParentBoneIndex].NodeIndex;
 
             bone.ParentIndex = aBone.ParentBoneIndex;
             bone.NodeIndex = aBone.NodeIndex;
-            bone.LocalTransform = CombineTransformsFromNodeIndices(context->Nodes, parentBoneNodeIndex, boneNodeIndex);
+            bone.LocalTransform = CombineTransformsFromNodeIndices(context.Nodes, parentBoneNodeIndex, boneNodeIndex);
             bone.OffsetMatrix = aBone.OffsetMatrix;
         }
     }
 
     // Import animations
-    if (EnumHasAnyFlags(data.Types, ImportDataTypes::Animations) && context->Scene->HasAnimations())
+    if (EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Animations))
     {
-        const int32 animCount = (int32)context->Scene->mNumAnimations;
-        if (options.SplitObjects && options.ObjectIndex == -1 && animCount > 1)
+        for (unsigned animIndex = 0; animIndex < context.Scene->mNumAnimations; animIndex++)
         {
-            // Import the first object within this call
-            options.SplitObjects = false;
-            options.ObjectIndex = 0;
-
-            if (options.OnSplitImport.IsBinded())
-            {
-                // Split all animations into separate assets
-                LOG(Info, "Splitting imported {0} animations", animCount);
-                for (int32 i = 1; i < animCount; i++)
-                {
-                    auto splitOptions = options;
-                    splitOptions.ObjectIndex = i;
-                    splitOptions.SplitContext = context;
-                    const auto animations = context->Scene->mAnimations[i];
-                    const String objectName(animations->mName.C_Str());
-                    options.OnSplitImport(splitOptions, objectName);
-                }
-            }
-        }
-
-        // Import the animation
-        {
-            const auto animIndex = Math::Clamp<int32>(options.ObjectIndex, 0, context->Scene->mNumAnimations - 1);
-            const auto animations = context->Scene->mAnimations[animIndex];
-            data.Animation.Channels.Resize(animations->mNumChannels, false);
-            data.Animation.Duration = animations->mDuration;
-            data.Animation.FramesPerSecond = animations->mTicksPerSecond;
-            if (data.Animation.FramesPerSecond <= 0)
-            {
-                data.Animation.FramesPerSecond = context->Options.DefaultFrameRate;
-                if (data.Animation.FramesPerSecond <= 0)
-                    data.Animation.FramesPerSecond = 30.0f;
-            }
-
-            for (unsigned i = 0; i < animations->mNumChannels; i++)
-            {
-                const auto aAnim = animations->mChannels[i];
-                auto& anim = data.Animation.Channels[i];
-
-                anim.NodeName = aAnim->mNodeName.C_Str();
-
-                ImportCurve(aAnim->mPositionKeys, aAnim->mNumPositionKeys, anim.Position);
-                ImportCurve(aAnim->mRotationKeys, aAnim->mNumRotationKeys, anim.Rotation);
-                if (options.ImportScaleTracks)
-                    ImportCurve(aAnim->mScalingKeys, aAnim->mNumScalingKeys, anim.Scale);
-            }
+            ImportAnimation((int32)animIndex, data, context);
         }
     }
 
     // Import nodes
-    if (EnumHasAnyFlags(data.Types, ImportDataTypes::Nodes))
+    if (EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Nodes))
     {
-        data.Nodes.Resize(context->Nodes.Count());
-        for (int32 i = 0; i < context->Nodes.Count(); i++)
+        data.Nodes.Resize(context.Nodes.Count());
+        for (int32 i = 0; i < context.Nodes.Count(); i++)
         {
             auto& node = data.Nodes[i];
-            auto& aNode = context->Nodes[i];
+            auto& aNode = context.Nodes[i];
 
             node.Name = aNode.Name;
             node.ParentIndex = aNode.ParentIndex;
diff --git a/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp b/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
index c7ee11b42..5c72d963f 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
@@ -4,12 +4,12 @@
 
 #include "ModelTool.h"
 #include "Engine/Core/Log.h"
-#include "Engine/Core/DeleteMe.h"
 #include "Engine/Core/Math/Mathd.h"
 #include "Engine/Core/Math/Matrix.h"
 #include "Engine/Core/Collections/Sorting.h"
 #include "Engine/Platform/FileSystem.h"
 #include "Engine/Tools/TextureTool/TextureTool.h"
+#include "Engine/Profiler/ProfilerCPU.h"
 #include "Engine/Platform/File.h"
 
 #define OPEN_FBX_CONVERT_SPACE 1
@@ -182,7 +182,7 @@ struct OpenFbxImporterData
 #endif
     }
 
-    bool ImportMaterialTexture(ImportedModelData& result, const ofbx::Material* mat, ofbx::Texture::TextureType textureType, int32& textureIndex, TextureEntry::TypeHint type) const
+    bool ImportMaterialTexture(ModelData& result, const ofbx::Material* mat, ofbx::Texture::TextureType textureType, int32& textureIndex, TextureEntry::TypeHint type) const
     {
         const ofbx::Texture* tex = mat->getTexture(textureType);
         if (tex)
@@ -217,7 +217,7 @@ struct OpenFbxImporterData
         return false;
     }
 
-    int32 AddMaterial(ImportedModelData& result, const ofbx::Material* mat)
+    int32 AddMaterial(ModelData& result, const ofbx::Material* mat)
     {
         int32 index = Materials.Find(mat);
         if (index == -1)
@@ -229,11 +229,11 @@ struct OpenFbxImporterData
             if (mat)
                 material.Name = String(mat->name).TrimTrailing();
 
-            if (mat && EnumHasAnyFlags(result.Types, ImportDataTypes::Materials))
+            if (mat && EnumHasAnyFlags(Options.ImportTypes, ImportDataTypes::Materials))
             {
                 material.Diffuse.Color = ToColor(mat->getDiffuseColor());
 
-                if (EnumHasAnyFlags(result.Types, ImportDataTypes::Textures))
+                if (EnumHasAnyFlags(Options.ImportTypes, ImportDataTypes::Textures))
                 {
                     ImportMaterialTexture(result, mat, ofbx::Texture::DIFFUSE, material.Diffuse.TextureIndex, TextureEntry::TypeHint::ColorRGB);
                     ImportMaterialTexture(result, mat, ofbx::Texture::EMISSIVE, material.Emissive.TextureIndex, TextureEntry::TypeHint::ColorRGB);
@@ -426,7 +426,7 @@ Matrix GetOffsetMatrix(OpenFbxImporterData& data, const ofbx::Mesh* mesh, const
             }
         }
     }
-	//return Matrix::Identity;
+    //return Matrix::Identity;
     return ToMatrix(node->getGlobalTransform());
 #else
     Matrix t = Matrix::Identity;
@@ -522,9 +522,11 @@ bool ImportBones(OpenFbxImporterData& data, String& errorMsg)
     return false;
 }
 
-bool ProcessMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofbx::Mesh* aMesh, MeshData& mesh, String& errorMsg, int32 triangleStart, int32 triangleEnd)
+bool ProcessMesh(ModelData& result, OpenFbxImporterData& data, const ofbx::Mesh* aMesh, MeshData& mesh, String& errorMsg, int32 triangleStart, int32 triangleEnd)
 {
-    // Prepare
+    PROFILE_CPU();
+    mesh.Name = aMesh->name;
+    ZoneText(*mesh.Name, mesh.Name.Length());
     const int32 firstVertexOffset = triangleStart * 3;
     const int32 lastVertexOffset = triangleEnd * 3;
     const ofbx::Geometry* aGeometry = aMesh->getGeometry();
@@ -539,7 +541,6 @@ bool ProcessMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofb
     const ofbx::BlendShape* blendShape = aGeometry->getBlendShape();
 
     // Properties
-    mesh.Name = aMesh->name;
     const ofbx::Material* aMaterial = nullptr;
     if (aMesh->getMaterialCount() > 0)
     {
@@ -682,7 +683,7 @@ bool ProcessMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofb
     }
 
     // Blend Indices and Blend Weights
-    if (skin && skin->getClusterCount() > 0 && EnumHasAnyFlags(result.Types, ImportDataTypes::Skeleton))
+    if (skin && skin->getClusterCount() > 0 && EnumHasAnyFlags(data.Options.ImportTypes, ImportDataTypes::Skeleton))
     {
         mesh.BlendIndices.Resize(vertexCount);
         mesh.BlendWeights.Resize(vertexCount);
@@ -746,7 +747,7 @@ bool ProcessMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofb
     }
 
     // Blend Shapes
-    if (blendShape && blendShape->getBlendShapeChannelCount() > 0 && EnumHasAnyFlags(result.Types, ImportDataTypes::Skeleton) && data.Options.ImportBlendShapes)
+    if (blendShape && blendShape->getBlendShapeChannelCount() > 0 && EnumHasAnyFlags(data.Options.ImportTypes, ImportDataTypes::Skeleton) && data.Options.ImportBlendShapes)
     {
         mesh.BlendShapes.EnsureCapacity(blendShape->getBlendShapeChannelCount());
         for (int32 channelIndex = 0; channelIndex < blendShape->getBlendShapeChannelCount(); channelIndex++)
@@ -843,7 +844,7 @@ bool ProcessMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofb
         mesh.OriginTranslation = scale * Vector3(translation.X, translation.Y, -translation.Z);
     else
         mesh.OriginTranslation = scale * Vector3(translation.X, translation.Y, translation.Z);
-    
+
     auto rot = aMesh->getLocalRotation();
     auto quat = Quaternion::Euler(-(float)rot.x, -(float)rot.y, -(float)rot.z);
     mesh.OriginOrientation = quat;
@@ -853,8 +854,10 @@ bool ProcessMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofb
     return false;
 }
 
-bool ImportMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofbx::Mesh* aMesh, String& errorMsg, int32 triangleStart, int32 triangleEnd)
+bool ImportMesh(ModelData& result, OpenFbxImporterData& data, const ofbx::Mesh* aMesh, String& errorMsg, int32 triangleStart, int32 triangleEnd)
 {
+    PROFILE_CPU();
+
     // Find the parent node
     int32 nodeIndex = data.FindNode(aMesh);
 
@@ -906,7 +909,7 @@ bool ImportMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofbx
     return false;
 }
 
-bool ImportMesh(int32 index, ImportedModelData& result, OpenFbxImporterData& data, String& errorMsg)
+bool ImportMesh(int32 index, ModelData& result, OpenFbxImporterData& data, String& errorMsg)
 {
     const auto aMesh = data.Scene->getMesh(index);
     const auto aGeometry = aMesh->getGeometry();
@@ -1006,27 +1009,19 @@ void ImportCurve(const ofbx::AnimationCurveNode* curveNode, LinearCurve<T>& curv
     }
 }
 
-bool ImportAnimation(int32 index, ImportedModelData& data, OpenFbxImporterData& importerData)
+void ImportAnimation(int32 index, ModelData& data, OpenFbxImporterData& importerData)
 {
     const ofbx::AnimationStack* stack = importerData.Scene->getAnimationStack(index);
     const ofbx::AnimationLayer* layer = stack->getLayer(0);
     const ofbx::TakeInfo* takeInfo = importerData.Scene->getTakeInfo(stack->name);
     if (takeInfo == nullptr)
-        return true;
+        return;
 
     // Initialize animation animation keyframes sampling
     const float frameRate = importerData.FrameRate;
-    data.Animation.FramesPerSecond = frameRate;
     const double localDuration = takeInfo->local_time_to - takeInfo->local_time_from;
     if (localDuration <= ZeroTolerance)
-        return true;
-    data.Animation.Duration = (double)(int32)(localDuration * frameRate + 0.5f);
-    AnimInfo info;
-    info.TimeStart = takeInfo->local_time_from;
-    info.TimeEnd = takeInfo->local_time_to;
-    info.Duration = localDuration;
-    info.FramesCount = (int32)data.Animation.Duration;
-    info.SamplingPeriod = 1.0f / frameRate;
+        return;
 
     // Count valid animation channels
     Array<int32> animatedNodes(importerData.Nodes.Count());
@@ -1042,15 +1037,32 @@ bool ImportAnimation(int32 index, ImportedModelData& data, OpenFbxImporterData&
             animatedNodes.Add(nodeIndex);
     }
     if (animatedNodes.IsEmpty())
-        return true;
-    data.Animation.Channels.Resize(animatedNodes.Count(), false);
+        return;
+
+    // Setup animation descriptor
+    auto& animation = data.Animations.AddOne();
+    animation.Duration = (double)(int32)(localDuration * frameRate + 0.5f);
+    animation.FramesPerSecond = frameRate;
+    char nameData[256];
+    takeInfo->name.toString(nameData);
+    animation.Name = nameData;
+    animation.Name = animation.Name.TrimTrailing();
+    if (animation.Name.IsEmpty())
+        animation.Name = String(layer->name);
+    animation.Channels.Resize(animatedNodes.Count(), false);
+    AnimInfo info;
+    info.TimeStart = takeInfo->local_time_from;
+    info.TimeEnd = takeInfo->local_time_to;
+    info.Duration = localDuration;
+    info.FramesCount = (int32)animation.Duration;
+    info.SamplingPeriod = 1.0f / frameRate;
 
     // Import curves
     for (int32 i = 0; i < animatedNodes.Count(); i++)
     {
         const int32 nodeIndex = animatedNodes[i];
         auto& aNode = importerData.Nodes[nodeIndex];
-        auto& anim = data.Animation.Channels[i];
+        auto& anim = animation.Channels[i];
 
         const ofbx::AnimationCurveNode* translationNode = layer->getCurveNode(*aNode.FbxObj, "Lcl Translation");
         const ofbx::AnimationCurveNode* rotationNode = layer->getCurveNode(*aNode.FbxObj, "Lcl Rotation");
@@ -1066,9 +1078,8 @@ bool ImportAnimation(int32 index, ImportedModelData& data, OpenFbxImporterData&
 
     if (importerData.ConvertRH)
     {
-        for (int32 i = 0; i < data.Animation.Channels.Count(); i++)
+        for (auto& anim : animation.Channels)
         {
-            auto& anim = data.Animation.Channels[i];
             auto& posKeys = anim.Position.GetKeyframes();
             auto& rotKeys = anim.Rotation.GetKeyframes();
 
@@ -1084,8 +1095,6 @@ bool ImportAnimation(int32 index, ImportedModelData& data, OpenFbxImporterData&
             }
         }
     }
-
-    return false;
 }
 
 static Float3 FbxVectorFromAxisAndSign(int axis, int sign)
@@ -1103,292 +1112,213 @@ static Float3 FbxVectorFromAxisAndSign(int axis, int sign)
     return { 0.f, 0.f, 0.f };
 }
 
-bool ModelTool::ImportDataOpenFBX(const char* path, ImportedModelData& data, Options& options, String& errorMsg)
+bool ModelTool::ImportDataOpenFBX(const char* path, ModelData& data, Options& options, String& errorMsg)
 {
-    auto context = (OpenFbxImporterData*)options.SplitContext;
-    if (!context)
+    // Import file
+    Array<byte> fileData;
+    if (File::ReadAllBytes(String(path), fileData))
     {
-        // Import file
-        Array<byte> fileData;
-        if (File::ReadAllBytes(String(path), fileData))
-        {
-            errorMsg = TEXT("Cannot load file.");
-            return true;
-        }
-        ofbx::u64 loadFlags = 0;
-        if (EnumHasAnyFlags(data.Types, ImportDataTypes::Geometry))
-            loadFlags |= (ofbx::u64)ofbx::LoadFlags::TRIANGULATE;
-        else
-            loadFlags |= (ofbx::u64)ofbx::LoadFlags::IGNORE_GEOMETRY;
+        errorMsg = TEXT("Cannot load file.");
+        return true;
+    }
+    ofbx::u64 loadFlags = 0;
+    if (EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Geometry))
+    {
+        loadFlags |= (ofbx::u64)ofbx::LoadFlags::TRIANGULATE;
         if (!options.ImportBlendShapes)
             loadFlags |= (ofbx::u64)ofbx::LoadFlags::IGNORE_BLEND_SHAPES;
-        ofbx::IScene* scene = ofbx::load(fileData.Get(), fileData.Count(), loadFlags);
-        if (!scene)
-        {
-            errorMsg = ofbx::getError();
-            return true;
-        }
-        fileData.Resize(0);
-
-        // Tweak scene if exported by Blender
-        auto& globalInfo = *scene->getGlobalInfo();
-        if (StringAnsiView(globalInfo.AppName).StartsWith(StringAnsiView("Blender"), StringSearchCase::IgnoreCase))
-        {
-            auto ptr = const_cast<ofbx::GlobalSettings*>(scene->getGlobalSettings());
-            ptr->UpAxis = (ofbx::UpVector)((int32)ptr->UpAxis + 1);
-        }
-
-        // Process imported scene
-        context = New<OpenFbxImporterData>(path, options, scene);
-        auto& globalSettings = context->GlobalSettings;
-        ProcessNodes(*context, scene->getRoot(), -1);
-
-        // Apply model scene global scale factor
-        context->Nodes[0].LocalTransform = Transform(Vector3::Zero, Quaternion::Identity, globalSettings.UnitScaleFactor) * context->Nodes[0].LocalTransform;
-
-        // Log scene info
-        LOG(Info, "Loaded FBX model, Frame Rate: {0}, Unit Scale Factor: {1}", context->FrameRate, globalSettings.UnitScaleFactor);
-        LOG(Info, "{0}, {1}, {2}", String(globalInfo.AppName), String(globalInfo.AppVersion), String(globalInfo.AppVendor));
-        LOG(Info, "Up: {1}{0}", globalSettings.UpAxis == ofbx::UpVector_AxisX ? TEXT("X") : globalSettings.UpAxis == ofbx::UpVector_AxisY ? TEXT("Y") : TEXT("Z"), globalSettings.UpAxisSign == 1 ? TEXT("+") : TEXT("-"));
-        LOG(Info, "Front: {1}{0}", globalSettings.FrontAxis == ofbx::FrontVector_ParityEven ? TEXT("ParityEven") : TEXT("ParityOdd"), globalSettings.FrontAxisSign == 1 ? TEXT("+") : TEXT("-"));
-        LOG(Info, "{0} Handed{1}", globalSettings.CoordAxis == ofbx::CoordSystem_RightHanded ? TEXT("Right") : TEXT("Left"), globalSettings.CoordAxisSign == 1 ? TEXT("") : TEXT(" (negative)"));
-#if OPEN_FBX_CONVERT_SPACE
-        LOG(Info, "Imported scene: Up={0}, Front={1}, Right={2}", context->Up, context->Front, context->Right);
-#endif
-
-        // Extract embedded textures
-        if (EnumHasAnyFlags(data.Types, ImportDataTypes::Textures))
-        {
-            String outputPath;
-            for (int i = 0, c = scene->getEmbeddedDataCount(); i < c; i++)
-            {
-                const ofbx::DataView aEmbedded = scene->getEmbeddedData(i);
-                ofbx::DataView aFilename = scene->getEmbeddedFilename(i);
-                char filenameData[256];
-                aFilename.toString(filenameData);
-                if (outputPath.IsEmpty())
-                {
-                    String pathStr(path);
-                    outputPath = String(StringUtils::GetDirectoryName(pathStr)) / TEXT("textures");
-                    FileSystem::CreateDirectory(outputPath);
-                }
-                const String filenameStr(filenameData);
-                String embeddedPath = outputPath / StringUtils::GetFileName(filenameStr);
-                if (FileSystem::FileExists(embeddedPath))
-                    continue;
-                LOG(Info, "Extracing embedded resource to {0}", embeddedPath);
-                if (File::WriteAllBytes(embeddedPath, aEmbedded.begin + 4, (int32)(aEmbedded.end - aEmbedded.begin - 4)))
-                {
-                    LOG(Error, "Failed to write data to file");
-                }
-            }
-        }
-
-#if OPEN_FBX_CONVERT_SPACE
-        // Transform nodes to match the engine coordinates system - DirectX (UpVector = +Y, FrontVector = +Z, CoordSystem = -X (LeftHanded))
-        if (context->Up == Float3(1, 0, 0) && context->Front == Float3(0, 0, 1) && context->Right == Float3(0, 1, 0))
-        {
-            context->RootConvertRotation = Quaternion::Euler(0, 180, 0);
-        }
-        else if (context->Up == Float3(0, 1, 0) && context->Front == Float3(-1, 0, 0) && context->Right == Float3(0, 0, 1))
-        {
-            context->RootConvertRotation = Quaternion::Euler(90, -90, 0);
-        }
-        /*Float3 engineUp(0, 1, 0);
-        Float3 engineFront(0, 0, 1);
-        Float3 engineRight(-1, 0, 0);*/
-        /*Float3 engineUp(1, 0, 0);
-        Float3 engineFront(0, 0, 1);
-        Float3 engineRight(0, 1, 0);
-        if (context->Up != engineUp || context->Front != engineFront || context->Right != engineRight)
-        {
-            LOG(Info, "Converting imported scene nodes to match engine coordinates system");
-            context->RootConvertRotation = Quaternion::GetRotationFromTo(context->Up, engineUp, engineUp);
-            //context->RootConvertRotation *= Quaternion::GetRotationFromTo(rotation * context->Right, engineRight, engineRight);
-            //context->RootConvertRotation *= Quaternion::GetRotationFromTo(rotation * context->Front, engineFront, engineFront);
-        }*/
-        /*Float3 hackUp = FbxVectorFromAxisAndSign(globalSettings.UpAxis, globalSettings.UpAxisSign);
-        if (hackUp == Float3::UnitX)
-            context->RootConvertRotation = Quaternion::Euler(-90, 0, 0);
-        else if (hackUp == Float3::UnitZ)
-            context->RootConvertRotation = Quaternion::Euler(90, 0, 0);*/
-        if (!context->RootConvertRotation.IsIdentity())
-        {
-            for (auto& node : context->Nodes)
-            {
-                if (node.ParentIndex == -1)
-                {
-                    node.LocalTransform.Orientation = context->RootConvertRotation * node.LocalTransform.Orientation;
-                    break;
-                }
-            }
-        }
-#endif
     }
-    DeleteMe<OpenFbxImporterData> contextCleanup(options.SplitContext ? nullptr : context);
+    else
+    {
+        loadFlags |= (ofbx::u64)ofbx::LoadFlags::IGNORE_GEOMETRY | (ofbx::u64)ofbx::LoadFlags::IGNORE_BLEND_SHAPES;
+    }
+    ofbx::IScene* scene;
+    {
+        PROFILE_CPU_NAMED("ofbx::load");
+        scene = ofbx::load(fileData.Get(), fileData.Count(), loadFlags);
+    }
+    if (!scene)
+    {
+        errorMsg = ofbx::getError();
+        return true;
+    }
+    fileData.Resize(0);
+
+    // Tweak scene if exported by Blender
+    auto& globalInfo = *scene->getGlobalInfo();
+    if (StringAnsiView(globalInfo.AppName).StartsWith(StringAnsiView("Blender"), StringSearchCase::IgnoreCase))
+    {
+        auto ptr = const_cast<ofbx::GlobalSettings*>(scene->getGlobalSettings());
+        ptr->UpAxis = (ofbx::UpVector)((int32)ptr->UpAxis + 1);
+    }
+
+    // Process imported scene
+    OpenFbxImporterData context(path, options, scene);
+    auto& globalSettings = context.GlobalSettings;
+    ProcessNodes(context, scene->getRoot(), -1);
+
+    // Apply model scene global scale factor
+    context.Nodes[0].LocalTransform = Transform(Vector3::Zero, Quaternion::Identity, globalSettings.UnitScaleFactor) * context.Nodes[0].LocalTransform;
+
+    // Log scene info
+    LOG(Info, "Loaded FBX model, Frame Rate: {0}, Unit Scale Factor: {1}", context.FrameRate, globalSettings.UnitScaleFactor);
+    LOG(Info, "{0}, {1}, {2}", String(globalInfo.AppName), String(globalInfo.AppVersion), String(globalInfo.AppVendor));
+    LOG(Info, "Up: {1}{0}", globalSettings.UpAxis == ofbx::UpVector_AxisX ? TEXT("X") : globalSettings.UpAxis == ofbx::UpVector_AxisY ? TEXT("Y") : TEXT("Z"), globalSettings.UpAxisSign == 1 ? TEXT("+") : TEXT("-"));
+    LOG(Info, "Front: {1}{0}", globalSettings.FrontAxis == ofbx::FrontVector_ParityEven ? TEXT("ParityEven") : TEXT("ParityOdd"), globalSettings.FrontAxisSign == 1 ? TEXT("+") : TEXT("-"));
+    LOG(Info, "{0} Handed{1}", globalSettings.CoordAxis == ofbx::CoordSystem_RightHanded ? TEXT("Right") : TEXT("Left"), globalSettings.CoordAxisSign == 1 ? TEXT("") : TEXT(" (negative)"));
+#if OPEN_FBX_CONVERT_SPACE
+    LOG(Info, "Imported scene: Up={0}, Front={1}, Right={2}", context.Up, context.Front, context.Right);
+#endif
+
+    // Extract embedded textures
+    if (EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Textures))
+    {
+        String outputPath;
+        for (int i = 0, c = scene->getEmbeddedDataCount(); i < c; i++)
+        {
+            const ofbx::DataView aEmbedded = scene->getEmbeddedData(i);
+            ofbx::DataView aFilename = scene->getEmbeddedFilename(i);
+            char filenameData[256];
+            aFilename.toString(filenameData);
+            if (outputPath.IsEmpty())
+            {
+                String pathStr(path);
+                outputPath = String(StringUtils::GetDirectoryName(pathStr)) / TEXT("textures");
+                FileSystem::CreateDirectory(outputPath);
+            }
+            const String filenameStr(filenameData);
+            String embeddedPath = outputPath / StringUtils::GetFileName(filenameStr);
+            if (FileSystem::FileExists(embeddedPath))
+                continue;
+            LOG(Info, "Extracing embedded resource to {0}", embeddedPath);
+            if (File::WriteAllBytes(embeddedPath, aEmbedded.begin + 4, (int32)(aEmbedded.end - aEmbedded.begin - 4)))
+            {
+                LOG(Error, "Failed to write data to file");
+            }
+        }
+    }
+
+#if OPEN_FBX_CONVERT_SPACE
+    // Transform nodes to match the engine coordinates system - DirectX (UpVector = +Y, FrontVector = +Z, CoordSystem = -X (LeftHanded))
+    if (context.Up == Float3(1, 0, 0) && context.Front == Float3(0, 0, 1) && context.Right == Float3(0, 1, 0))
+    {
+        context.RootConvertRotation = Quaternion::Euler(0, 180, 0);
+    }
+    else if (context.Up == Float3(0, 1, 0) && context.Front == Float3(-1, 0, 0) && context.Right == Float3(0, 0, 1))
+    {
+        context.RootConvertRotation = Quaternion::Euler(90, -90, 0);
+    }
+    /*Float3 engineUp(0, 1, 0);
+    Float3 engineFront(0, 0, 1);
+    Float3 engineRight(-1, 0, 0);*/
+    /*Float3 engineUp(1, 0, 0);
+    Float3 engineFront(0, 0, 1);
+    Float3 engineRight(0, 1, 0);
+    if (context.Up != engineUp || context.Front != engineFront || context.Right != engineRight)
+    {
+        LOG(Info, "Converting imported scene nodes to match engine coordinates system");
+        context.RootConvertRotation = Quaternion::GetRotationFromTo(context.Up, engineUp, engineUp);
+        //context.RootConvertRotation *= Quaternion::GetRotationFromTo(rotation * context.Right, engineRight, engineRight);
+        //context.RootConvertRotation *= Quaternion::GetRotationFromTo(rotation * context.Front, engineFront, engineFront);
+    }*/
+    /*Float3 hackUp = FbxVectorFromAxisAndSign(globalSettings.UpAxis, globalSettings.UpAxisSign);
+    if (hackUp == Float3::UnitX)
+        context.RootConvertRotation = Quaternion::Euler(-90, 0, 0);
+    else if (hackUp == Float3::UnitZ)
+        context.RootConvertRotation = Quaternion::Euler(90, 0, 0);*/
+    if (!context.RootConvertRotation.IsIdentity())
+    {
+        for (auto& node : context.Nodes)
+        {
+            if (node.ParentIndex == -1)
+            {
+                node.LocalTransform.Orientation = context.RootConvertRotation * node.LocalTransform.Orientation;
+                break;
+            }
+        }
+    }
+#endif
 
     // Build final skeleton bones hierarchy before importing meshes
-    if (EnumHasAnyFlags(data.Types, ImportDataTypes::Skeleton))
+    if (EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Skeleton))
     {
-        if (ImportBones(*context, errorMsg))
+        if (ImportBones(context, errorMsg))
         {
             LOG(Warning, "Failed to import skeleton bones.");
             return true;
         }
-
-        Sorting::QuickSort(context->Bones.Get(), context->Bones.Count());
+        Sorting::QuickSort(context.Bones);
     }
 
     // Import geometry (meshes and materials)
-    if (EnumHasAnyFlags(data.Types, ImportDataTypes::Geometry) && context->Scene->getMeshCount() > 0)
+    if (EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Geometry) && context.Scene->getMeshCount() > 0)
     {
-        const int meshCount = context->Scene->getMeshCount();
-        if (options.SplitObjects && options.ObjectIndex == -1 && meshCount > 1)
+        const int meshCount = context.Scene->getMeshCount();
+        for (int32 meshIndex = 0; meshIndex < meshCount; meshIndex++)
         {
-            // Import the first object within this call
-            options.SplitObjects = false;
-            options.ObjectIndex = 0;
-
-            if (options.OnSplitImport.IsBinded())
-            {
-                // Split all animations into separate assets
-                LOG(Info, "Splitting imported {0} meshes", meshCount);
-                for (int32 i = 1; i < meshCount; i++)
-                {
-                    auto splitOptions = options;
-                    splitOptions.ObjectIndex = i;
-                    splitOptions.SplitContext = context;
-                    const auto aMesh = context->Scene->getMesh(i);
-                    const String objectName(aMesh->name);
-                    options.OnSplitImport(splitOptions, objectName);
-                }
-            }
-        }
-        if (options.ObjectIndex != -1)
-        {
-            // Import the selected mesh
-            const auto meshIndex = Math::Clamp<int32>(options.ObjectIndex, 0, meshCount - 1);
-            if (ImportMesh(meshIndex, data, *context, errorMsg))
+            if (ImportMesh(meshIndex, data, context, errorMsg))
                 return true;
-
-            // Let the firstly imported mesh import all materials from all meshes (index 0 is importing all following ones before itself during splitting - see code above)
-            if (options.ObjectIndex == 1)
-            {
-                for (int32 i = 0; i < meshCount; i++)
-                {
-                    const auto aMesh = context->Scene->getMesh(i);
-                    if (i == 1 || IsMeshInvalid(aMesh))
-                        continue;
-                    for (int32 j = 0; j < aMesh->getMaterialCount(); j++)
-                    {
-                        const ofbx::Material* aMaterial = aMesh->getMaterial(j);
-                        context->AddMaterial(data, aMaterial);
-                    }
-                }
-            }
-        }
-        else
-        {
-            // Import all meshes
-            for (int32 meshIndex = 0; meshIndex < meshCount; meshIndex++)
-            {
-                if (ImportMesh(meshIndex, data, *context, errorMsg))
-                    return true;
-            }
         }
     }
 
     // Import skeleton
-    if (EnumHasAnyFlags(data.Types, ImportDataTypes::Skeleton))
+    if (EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Skeleton))
     {
-        data.Skeleton.Nodes.Resize(context->Nodes.Count(), false);
-        for (int32 i = 0; i < context->Nodes.Count(); i++)
+        data.Skeleton.Nodes.Resize(context.Nodes.Count(), false);
+        for (int32 i = 0; i < context.Nodes.Count(); i++)
         {
             auto& node = data.Skeleton.Nodes[i];
-            auto& aNode = context->Nodes[i];
+            auto& aNode = context.Nodes[i];
 
             node.Name = aNode.Name;
             node.ParentIndex = aNode.ParentIndex;
             node.LocalTransform = aNode.LocalTransform;
         }
 
-        data.Skeleton.Bones.Resize(context->Bones.Count(), false);
-        for (int32 i = 0; i < context->Bones.Count(); i++)
+        data.Skeleton.Bones.Resize(context.Bones.Count(), false);
+        for (int32 i = 0; i < context.Bones.Count(); i++)
         {
             auto& bone = data.Skeleton.Bones[i];
-            auto& aBone = context->Bones[i];
+            auto& aBone = context.Bones[i];
             const auto boneNodeIndex = aBone.NodeIndex;
 
             // Find the parent bone
             int32 parentBoneIndex = -1;
-            for (int32 j = context->Nodes[boneNodeIndex].ParentIndex; j != -1; j = context->Nodes[j].ParentIndex)
+            for (int32 j = context.Nodes[boneNodeIndex].ParentIndex; j != -1; j = context.Nodes[j].ParentIndex)
             {
-                parentBoneIndex = context->FindBone(j);
+                parentBoneIndex = context.FindBone(j);
                 if (parentBoneIndex != -1)
                     break;
             }
             aBone.ParentBoneIndex = parentBoneIndex;
 
-            const auto parentBoneNodeIndex = aBone.ParentBoneIndex == -1 ? -1 : context->Bones[aBone.ParentBoneIndex].NodeIndex;
+            const auto parentBoneNodeIndex = aBone.ParentBoneIndex == -1 ? -1 : context.Bones[aBone.ParentBoneIndex].NodeIndex;
 
             bone.ParentIndex = aBone.ParentBoneIndex;
             bone.NodeIndex = aBone.NodeIndex;
-            bone.LocalTransform = CombineTransformsFromNodeIndices(context->Nodes, parentBoneNodeIndex, boneNodeIndex);
+            bone.LocalTransform = CombineTransformsFromNodeIndices(context.Nodes, parentBoneNodeIndex, boneNodeIndex);
             bone.OffsetMatrix = aBone.OffsetMatrix;
         }
     }
 
     // Import animations
-    if (EnumHasAnyFlags(data.Types, ImportDataTypes::Animations))
+    if (EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Animations))
     {
-        const int animCount = context->Scene->getAnimationStackCount();
-        if (options.SplitObjects && options.ObjectIndex == -1 && animCount > 1)
+        const int animCount = context.Scene->getAnimationStackCount();
+        for (int32 animIndex = 0; animIndex < animCount; animIndex++)
         {
-            // Import the first object within this call
-            options.SplitObjects = false;
-            options.ObjectIndex = 0;
-
-            if (options.OnSplitImport.IsBinded())
-            {
-                // Split all animations into separate assets
-                LOG(Info, "Splitting imported {0} animations", animCount);
-                for (int32 i = 1; i < animCount; i++)
-                {
-                    auto splitOptions = options;
-                    splitOptions.ObjectIndex = i;
-                    splitOptions.SplitContext = context;
-                    const ofbx::AnimationStack* stack = context->Scene->getAnimationStack(i);
-                    const ofbx::AnimationLayer* layer = stack->getLayer(0);
-                    const String objectName(layer->name);
-                    options.OnSplitImport(splitOptions, objectName);
-                }
-            }
-        }
-        if (options.ObjectIndex != -1)
-        {
-            // Import selected animation
-            const auto animIndex = Math::Clamp<int32>(options.ObjectIndex, 0, animCount - 1);
-            ImportAnimation(animIndex, data, *context);
-        }
-        else
-        {
-            // Import first valid animation
-            for (int32 animIndex = 0; animIndex < animCount; animIndex++)
-            {
-                if (!ImportAnimation(animIndex, data, *context))
-                    break;
-            }
+            ImportAnimation(animIndex, data, context);
         }
     }
 
     // Import nodes
-    if (EnumHasAnyFlags(data.Types, ImportDataTypes::Nodes))
+    if (EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Nodes))
     {
-        data.Nodes.Resize(context->Nodes.Count());
-        for (int32 i = 0; i < context->Nodes.Count(); i++)
+        data.Nodes.Resize(context.Nodes.Count());
+        for (int32 i = 0; i < context.Nodes.Count(); i++)
         {
             auto& node = data.Nodes[i];
-            auto& aNode = context->Nodes[i];
+            auto& aNode = context.Nodes[i];
 
             node.Name = aNode.Name;
             node.ParentIndex = aNode.ParentIndex;
diff --git a/Source/Engine/Tools/ModelTool/ModelTool.cpp b/Source/Engine/Tools/ModelTool/ModelTool.cpp
index a07cd8f23..e2b2f5d8d 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.cpp
@@ -28,7 +28,6 @@
 #include "Engine/Core/Utilities.h"
 #include "Engine/Core/Types/StringView.h"
 #include "Engine/Platform/FileSystem.h"
-#include "Engine/Utilities/RectPack.h"
 #include "Engine/Tools/TextureTool/TextureTool.h"
 #include "Engine/ContentImporters/AssetsImportingManager.h"
 #include "Engine/ContentImporters/CreateMaterial.h"
@@ -332,26 +331,6 @@ bool ModelTool::GenerateModelSDF(Model* inputModel, ModelData* modelData, float
 
 #if USE_EDITOR
 
-BoundingBox ImportedModelData::LOD::GetBox() const
-{
-    if (Meshes.IsEmpty())
-        return BoundingBox::Empty;
-
-    BoundingBox box;
-    Meshes[0]->CalculateBox(box);
-    for (int32 i = 1; i < Meshes.Count(); i++)
-    {
-        if (Meshes[i]->Positions.HasItems())
-        {
-            BoundingBox t;
-            Meshes[i]->CalculateBox(t);
-            BoundingBox::Merge(box, t, box);
-        }
-    }
-
-    return box;
-}
-
 void ModelTool::Options::Serialize(SerializeStream& stream, const void* otherObj)
 {
     SERIALIZE_GET_OTHER_OBJ(ModelTool::Options);
@@ -463,8 +442,10 @@ void RemoveNamespace(String& name)
         name = name.Substring(namespaceStart + 1);
 }
 
-bool ModelTool::ImportData(const String& path, ImportedModelData& data, Options& options, String& errorMsg)
+bool ModelTool::ImportData(const String& path, ModelData& data, Options& options, String& errorMsg)
 {
+    PROFILE_CPU();
+
     // Validate options
     options.Scale = Math::Clamp(options.Scale, 0.0001f, 100000.0f);
     options.SmoothingNormalsAngle = Math::Clamp(options.SmoothingNormalsAngle, 0.0f, 175.0f);
@@ -472,6 +453,9 @@ bool ModelTool::ImportData(const String& path, ImportedModelData& data, Options&
     options.FramesRange.Y = Math::Max(options.FramesRange.Y, options.FramesRange.X);
     options.DefaultFrameRate = Math::Max(0.0f, options.DefaultFrameRate);
     options.SamplingRate = Math::Max(0.0f, options.SamplingRate);
+    if (options.SplitObjects || options.Type == ModelType::Prefab)
+        options.MergeMeshes = false; // Meshes merging doesn't make sense when we want to import each mesh individually
+    // TODO: maybe we could update meshes merger to collapse meshes within the same name if splitting is enabled?
 
     // Validate path
     // Note: Assimp/Autodesk supports only ANSI characters in imported file path
@@ -531,8 +515,6 @@ bool ModelTool::ImportData(const String& path, ImportedModelData& data, Options&
         FileSystem::DeleteFile(tmpPath);
     }
 
-    // TODO: check model LODs sequence (eg. {LOD0, LOD2, LOD5} is invalid)
-
     // Remove namespace prefixes from the nodes names
     {
         for (auto& node : data.Nodes)
@@ -543,9 +525,10 @@ bool ModelTool::ImportData(const String& path, ImportedModelData& data, Options&
         {
             RemoveNamespace(node.Name);
         }
-        for (auto& channel : data.Animation.Channels)
+        for (auto& animation : data.Animations)
         {
-            RemoveNamespace(channel.NodeName);
+            for (auto& channel : animation.Channels)
+                RemoveNamespace(channel.NodeName);
         }
         for (auto& lod : data.LODs)
         {
@@ -553,18 +536,19 @@ bool ModelTool::ImportData(const String& path, ImportedModelData& data, Options&
             {
                 RemoveNamespace(mesh->Name);
                 for (auto& blendShape : mesh->BlendShapes)
-                {
                     RemoveNamespace(blendShape.Name);
-                }
             }
         }
     }
 
     // Validate the animation channels
-    if (data.Animation.Channels.HasItems())
+    for (auto& animation : data.Animations)
     {
+        auto& channels = animation.Channels;
+        if (channels.IsEmpty())
+            continue;
+
         // Validate bone animations uniqueness
-        auto& channels = data.Animation.Channels;
         for (int32 i = 0; i < channels.Count(); i++)
         {
             for (int32 j = i + 1; j < channels.Count(); j++)
@@ -610,7 +594,7 @@ bool ModelTool::ImportData(const String& path, ImportedModelData& data, Options&
     }
 
     // Flip normals of the imported geometry
-    if (options.FlipNormals && EnumHasAnyFlags(data.Types, ImportDataTypes::Geometry))
+    if (options.FlipNormals && EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Geometry))
     {
         for (auto& lod : data.LODs)
         {
@@ -762,7 +746,7 @@ void TrySetupMaterialParameter(MaterialInstance* instance, Span<const Char*> par
             {
                 if (type == MaterialParameterType::Color)
                 {
-                    if (paramType != MaterialParameterType::Vector3 || 
+                    if (paramType != MaterialParameterType::Vector3 ||
                         paramType != MaterialParameterType::Vector4)
                         continue;
                 }
@@ -777,56 +761,104 @@ void TrySetupMaterialParameter(MaterialInstance* instance, Span<const Char*> par
     }
 }
 
-bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& options, String& errorMsg, const String& autoImportOutput)
+String GetAdditionalImportPath(const String& autoImportOutput, Array<String>& importedFileNames, const String& name)
 {
+    String filename = name;
+    for (int32 j = filename.Length() - 1; j >= 0; j--)
+    {
+        if (EditorUtilities::IsInvalidPathChar(filename[j]))
+            filename[j] = ' ';
+    }
+    if (importedFileNames.Contains(filename))
+    {
+        int32 counter = 1;
+        do
+        {
+            filename = name + TEXT(" ") + StringUtils::ToString(counter);
+            counter++;
+        } while (importedFileNames.Contains(filename));
+    }
+    importedFileNames.Add(filename);
+    return autoImportOutput / filename + ASSET_FILES_EXTENSION_WITH_DOT;
+}
+
+bool ModelTool::ImportModel(const String& path, ModelData& data, Options& options, String& errorMsg, const String& autoImportOutput)
+{
+    PROFILE_CPU();
     LOG(Info, "Importing model from \'{0}\'", path);
     const auto startTime = DateTime::NowUTC();
 
     // Import data
-    ImportDataTypes importDataTypes;
     switch (options.Type)
     {
     case ModelType::Model:
-        importDataTypes = ImportDataTypes::Geometry | ImportDataTypes::Nodes | ImportDataTypes::Textures;
+        options.ImportTypes = ImportDataTypes::Geometry | ImportDataTypes::Nodes;
         if (options.ImportMaterials)
-            importDataTypes |= ImportDataTypes::Materials;
+            options.ImportTypes |= ImportDataTypes::Materials;
         if (options.ImportTextures)
-            importDataTypes |= ImportDataTypes::Textures;
+            options.ImportTypes |= ImportDataTypes::Textures;
         break;
     case ModelType::SkinnedModel:
-        importDataTypes = ImportDataTypes::Geometry | ImportDataTypes::Nodes | ImportDataTypes::Skeleton;
+        options.ImportTypes = ImportDataTypes::Geometry | ImportDataTypes::Nodes | ImportDataTypes::Skeleton;
         if (options.ImportMaterials)
-            importDataTypes |= ImportDataTypes::Materials;
+            options.ImportTypes |= ImportDataTypes::Materials;
         if (options.ImportTextures)
-            importDataTypes |= ImportDataTypes::Textures;
+            options.ImportTypes |= ImportDataTypes::Textures;
         break;
     case ModelType::Animation:
-        importDataTypes = ImportDataTypes::Animations;
+        options.ImportTypes = ImportDataTypes::Animations;
+        break;
+    case ModelType::Prefab:
+        options.ImportTypes = ImportDataTypes::Geometry | ImportDataTypes::Nodes | ImportDataTypes::Animations;
+        if (options.ImportMaterials)
+            options.ImportTypes |= ImportDataTypes::Materials;
+        if (options.ImportTextures)
+            options.ImportTypes |= ImportDataTypes::Textures;
         break;
     default:
         return true;
     }
-    ImportedModelData data(importDataTypes);
     if (ImportData(path, data, options, errorMsg))
         return true;
 
     // Validate result data
-    switch (options.Type)
+    if (EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Geometry))
     {
-    case ModelType::Model:
-    {
-        // Validate
-        if (data.LODs.IsEmpty() || data.LODs[0].Meshes.IsEmpty())
-        {
-            errorMsg = TEXT("Imported model has no valid geometry.");
-            return true;
-        }
+        LOG(Info, "Imported model has {0} LODs, {1} meshes (in LOD0) and {2} materials", data.LODs.Count(), data.LODs.Count() != 0 ? data.LODs[0].Meshes.Count() : 0, data.Materials.Count());
 
-        LOG(Info, "Imported model has {0} LODs, {1} meshes (in LOD0) and {2} materials", data.LODs.Count(), data.LODs[0].Meshes.Count(), data.Materials.Count());
-        break;
+        // Process blend shapes
+        for (auto& lod : data.LODs)
+        {
+            for (auto& mesh : lod.Meshes)
+            {
+                for (int32 blendShapeIndex = mesh->BlendShapes.Count() - 1; blendShapeIndex >= 0; blendShapeIndex--)
+                {
+                    auto& blendShape = mesh->BlendShapes[blendShapeIndex];
+
+                    // Remove blend shape vertices with empty deltas
+                    for (int32 i = blendShape.Vertices.Count() - 1; i >= 0; i--)
+                    {
+                        auto& v = blendShape.Vertices.Get()[i];
+                        if (v.PositionDelta.IsZero() && v.NormalDelta.IsZero())
+                        {
+                            blendShape.Vertices.RemoveAt(i);
+                        }
+                    }
+
+                    // Remove empty blend shapes
+                    if (blendShape.Vertices.IsEmpty() || blendShape.Name.IsEmpty())
+                    {
+                        LOG(Info, "Removing empty blend shape '{0}' from mesh '{1}'", blendShape.Name, mesh->Name);
+                        mesh->BlendShapes.RemoveAt(blendShapeIndex);
+                    }
+                }
+            }
+        }
     }
-    case ModelType::SkinnedModel:
+    if (EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Skeleton))
     {
+        LOG(Info, "Imported skeleton has {0} bones and {1} nodes", data.Skeleton.Bones.Count(), data.Nodes.Count());
+
         // Add single node if imported skeleton is empty
         if (data.Skeleton.Nodes.IsEmpty())
         {
@@ -862,442 +894,12 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
             }
         }
 
-        // Validate
+        // Check bones limit currently supported by the engine
         if (data.Skeleton.Bones.Count() > MAX_BONES_PER_MODEL)
         {
             errorMsg = String::Format(TEXT("Imported model skeleton has too many bones. Imported: {0}, maximum supported: {1}. Please optimize your asset."), data.Skeleton.Bones.Count(), MAX_BONES_PER_MODEL);
             return true;
         }
-        if (data.LODs.Count() > 1)
-        {
-            LOG(Warning, "Imported skinned model has more than one LOD. Removing the lower LODs. Only single one is supported.");
-            data.LODs.Resize(1);
-        }
-        const int32 meshesCount = data.LODs.Count() != 0 ? data.LODs[0].Meshes.Count() : 0;
-        for (int32 i = 0; i < meshesCount; i++)
-        {
-            const auto mesh = data.LODs[0].Meshes[i];
-            if (mesh->BlendIndices.IsEmpty() || mesh->BlendWeights.IsEmpty())
-            {
-                auto indices = Int4::Zero;
-                auto weights = Float4::UnitX;
-
-                // Check if use a single bone for skinning
-                auto nodeIndex = data.Skeleton.FindNode(mesh->Name);
-                auto boneIndex = data.Skeleton.FindBone(nodeIndex);
-                if (boneIndex == -1 && nodeIndex != -1 && data.Skeleton.Bones.Count() < MAX_BONES_PER_MODEL)
-                {
-                    // Add missing bone to be used by skinned model from animated nodes pose
-                    boneIndex = data.Skeleton.Bones.Count();
-                    auto& bone = data.Skeleton.Bones.AddOne();
-                    bone.ParentIndex = -1;
-                    bone.NodeIndex = nodeIndex;
-                    bone.LocalTransform = CombineTransformsFromNodeIndices(data.Nodes, -1, nodeIndex);
-                    CalculateBoneOffsetMatrix(data.Skeleton.Nodes, bone.OffsetMatrix, bone.NodeIndex);
-                    LOG(Warning, "Using auto-created bone {0} (index {1}) for mesh \'{2}\'", data.Skeleton.Nodes[nodeIndex].Name, boneIndex, mesh->Name);
-                    indices.X = boneIndex;
-                }
-                else if (boneIndex != -1)
-                {
-                    // Fallback to already added bone
-                    LOG(Warning, "Using auto-detected bone {0} (index {1}) for mesh \'{2}\'", data.Skeleton.Nodes[nodeIndex].Name, boneIndex, mesh->Name);
-                    indices.X = boneIndex;
-                }
-                else
-                {
-                    // No bone
-                    LOG(Warning, "Imported mesh \'{0}\' has missing skinning data. It may result in invalid rendering.", mesh->Name);
-                }
-
-                mesh->BlendIndices.Resize(mesh->Positions.Count());
-                mesh->BlendWeights.Resize(mesh->Positions.Count());
-                mesh->BlendIndices.SetAll(indices);
-                mesh->BlendWeights.SetAll(weights);
-            }
-#if BUILD_DEBUG
-            else
-            {
-                auto& indices = mesh->BlendIndices;
-                for (int32 j = 0; j < indices.Count(); j++)
-                {
-                    const int32 min = indices[j].MinValue();
-                    const int32 max = indices[j].MaxValue();
-                    if (min < 0 || max >= data.Skeleton.Bones.Count())
-                    {
-                        LOG(Warning, "Imported mesh \'{0}\' has invalid blend indices. It may result in invalid rendering.", mesh->Name);
-                    }
-                }
-
-                auto& weights = mesh->BlendWeights;
-                for (int32 j = 0; j < weights.Count(); j++)
-                {
-                    const float sum = weights[j].SumValues();
-                    if (Math::Abs(sum - 1.0f) > ZeroTolerance)
-                    {
-                        LOG(Warning, "Imported mesh \'{0}\' has invalid blend weights. It may result in invalid rendering.", mesh->Name);
-                    }
-                }
-            }
-#endif
-        }
-
-        LOG(Info, "Imported skeleton has {0} bones, {3} nodes, {1} meshes and {2} material", data.Skeleton.Bones.Count(), meshesCount, data.Materials.Count(), data.Nodes.Count());
-        break;
-    }
-    case ModelType::Animation:
-    {
-        // Validate
-        if (data.Animation.Channels.IsEmpty())
-        {
-            errorMsg = TEXT("Imported file has no valid animations.");
-            return true;
-        }
-
-        LOG(Info, "Imported animation has {0} channels, duration: {1} frames, frames per second: {2}", data.Animation.Channels.Count(), data.Animation.Duration, data.Animation.FramesPerSecond);
-        break;
-    }
-    }
-
-    // Prepare textures
-    Array<String> importedFileNames;
-    for (int32 i = 0; i < data.Textures.Count(); i++)
-    {
-        auto& texture = data.Textures[i];
-
-        // Auto-import textures
-        if (autoImportOutput.IsEmpty() || (data.Types & ImportDataTypes::Textures) == ImportDataTypes::None || texture.FilePath.IsEmpty())
-            continue;
-        String filename = StringUtils::GetFileNameWithoutExtension(texture.FilePath);
-        for (int32 j = filename.Length() - 1; j >= 0; j--)
-        {
-            if (EditorUtilities::IsInvalidPathChar(filename[j]))
-                filename[j] = ' ';
-        }
-        if (importedFileNames.Contains(filename))
-        {
-            int32 counter = 1;
-            do
-            {
-                filename = String(StringUtils::GetFileNameWithoutExtension(texture.FilePath)) + TEXT(" ") + StringUtils::ToString(counter);
-                counter++;
-            } while (importedFileNames.Contains(filename));
-        }
-        importedFileNames.Add(filename);
-#if COMPILE_WITH_ASSETS_IMPORTER
-        auto assetPath = autoImportOutput / filename + ASSET_FILES_EXTENSION_WITH_DOT;
-        TextureTool::Options textureOptions;
-        switch (texture.Type)
-        {
-        case TextureEntry::TypeHint::ColorRGB:
-            textureOptions.Type = TextureFormatType::ColorRGB;
-            break;
-        case TextureEntry::TypeHint::ColorRGBA:
-            textureOptions.Type = TextureFormatType::ColorRGBA;
-            break;
-        case TextureEntry::TypeHint::Normals:
-            textureOptions.Type = TextureFormatType::NormalMap;
-            break;
-        default: ;
-        }
-        AssetsImportingManager::ImportIfEdited(texture.FilePath, assetPath, texture.AssetID, &textureOptions);
-#endif
-    }
-
-    // Prepare material
-    for (int32 i = 0; i < data.Materials.Count(); i++)
-    {
-        auto& material = data.Materials[i];
-
-        if (material.Name.IsEmpty())
-            material.Name = TEXT("Material ") + StringUtils::ToString(i);
-
-        // Auto-import materials
-        if (autoImportOutput.IsEmpty() || (data.Types & ImportDataTypes::Materials) == ImportDataTypes::None || !material.UsesProperties())
-            continue;
-        auto filename = material.Name;
-        for (int32 j = filename.Length() - 1; j >= 0; j--)
-        {
-            if (EditorUtilities::IsInvalidPathChar(filename[j]))
-                filename[j] = ' ';
-        }
-        if (importedFileNames.Contains(filename))
-        {
-            int32 counter = 1;
-            do
-            {
-                filename = material.Name + TEXT(" ") + StringUtils::ToString(counter);
-                counter++;
-            } while (importedFileNames.Contains(filename));
-        }
-        importedFileNames.Add(filename);
-#if COMPILE_WITH_ASSETS_IMPORTER
-        auto assetPath = autoImportOutput / filename + ASSET_FILES_EXTENSION_WITH_DOT;
-
-        // When splitting imported meshes allow only the first mesh to import assets (mesh[0] is imported after all following ones so import assets during mesh[1])
-        if (!options.SplitObjects && options.ObjectIndex != 1 && options.ObjectIndex != -1)
-        {
-            // Find that asset create previously
-            AssetInfo info;
-            if (Content::GetAssetInfo(assetPath, info))
-                material.AssetID = info.ID;
-            continue;
-        }
-
-        if (options.ImportMaterialsAsInstances)
-        {
-            // Create material instance
-            AssetsImportingManager::Create(AssetsImportingManager::CreateMaterialInstanceTag, assetPath, material.AssetID);
-            if (auto* materialInstance = Content::Load<MaterialInstance>(assetPath))
-            {
-                materialInstance->SetBaseMaterial(options.InstanceToImportAs);
-
-                // Customize base material based on imported material (blind guess based on the common names used in materials)
-                const Char* diffuseColorNames[] = { TEXT("color"), TEXT("col"), TEXT("diffuse"), TEXT("basecolor"), TEXT("base color") };
-                TrySetupMaterialParameter(materialInstance, ToSpan(diffuseColorNames, ARRAY_COUNT(diffuseColorNames)), material.Diffuse.Color, MaterialParameterType::Color);
-                const Char* emissiveColorNames[] = { TEXT("emissive"), TEXT("emission"), TEXT("light") };
-                TrySetupMaterialParameter(materialInstance, ToSpan(emissiveColorNames, ARRAY_COUNT(emissiveColorNames)), material.Emissive.Color, MaterialParameterType::Color);
-                const Char* opacityValueNames[] = { TEXT("opacity"), TEXT("alpha") };
-                TrySetupMaterialParameter(materialInstance, ToSpan(opacityValueNames, ARRAY_COUNT(opacityValueNames)), material.Opacity.Value, MaterialParameterType::Float);
-
-                materialInstance->Save();
-            }
-            else
-            {
-                LOG(Error, "Failed to load material instance after creation. ({0})", assetPath);
-            }
-        }
-        else
-        {
-            // Create material
-            CreateMaterial::Options materialOptions;
-            materialOptions.Diffuse.Color = material.Diffuse.Color;
-            if (material.Diffuse.TextureIndex != -1)
-                materialOptions.Diffuse.Texture = data.Textures[material.Diffuse.TextureIndex].AssetID;
-            materialOptions.Diffuse.HasAlphaMask = material.Diffuse.HasAlphaMask;
-            materialOptions.Emissive.Color = material.Emissive.Color;
-            if (material.Emissive.TextureIndex != -1)
-                materialOptions.Emissive.Texture = data.Textures[material.Emissive.TextureIndex].AssetID;
-            materialOptions.Opacity.Value = material.Opacity.Value;
-            if (material.Opacity.TextureIndex != -1)
-                materialOptions.Opacity.Texture = data.Textures[material.Opacity.TextureIndex].AssetID;
-            if (material.Normals.TextureIndex != -1)
-                materialOptions.Normals.Texture = data.Textures[material.Normals.TextureIndex].AssetID;
-            if (material.TwoSided || material.Diffuse.HasAlphaMask)
-                materialOptions.Info.CullMode = CullMode::TwoSided;
-            if (!Math::IsOne(material.Opacity.Value) || material.Opacity.TextureIndex != -1)
-                materialOptions.Info.BlendMode = MaterialBlendMode::Transparent;
-            AssetsImportingManager::Create(AssetsImportingManager::CreateMaterialTag, assetPath, material.AssetID, &materialOptions);
-        }
-#endif
-    }
-
-    // Prepare import transformation
-    Transform importTransform(options.Translation, options.Rotation, Float3(options.Scale));
-    if (options.UseLocalOrigin && data.LODs.HasItems() && data.LODs[0].Meshes.HasItems())
-    {
-        importTransform.Translation -= importTransform.Orientation * data.LODs[0].Meshes[0]->OriginTranslation * importTransform.Scale;
-    }
-    if (options.CenterGeometry && data.LODs.HasItems() && data.LODs[0].Meshes.HasItems())
-    {
-        // Calculate the bounding box (use LOD0 as a reference)
-        BoundingBox box = data.LODs[0].GetBox();
-        auto center = data.LODs[0].Meshes[0]->OriginOrientation * importTransform.Orientation * box.GetCenter() * importTransform.Scale * data.LODs[0].Meshes[0]->Scaling;
-        importTransform.Translation -= center;
-    }
-    const bool applyImportTransform = !importTransform.IsIdentity();
-
-    // Post-process imported data based on a target asset type
-    if (options.Type == ModelType::Model)
-    {
-        if (data.Nodes.IsEmpty())
-        {
-            errorMsg = TEXT("Missing model nodes.");
-            return true;
-        }
-
-        // Apply the import transformation
-        if (applyImportTransform)
-        {
-            // Transform the root node using the import transformation
-            auto& root = data.Nodes[0];
-            root.LocalTransform = importTransform.LocalToWorld(root.LocalTransform);
-        }
-
-        // Perform simple nodes mapping to single node (will transform meshes to model local space)
-        SkeletonMapping<ImportedModelData::Node> skeletonMapping(data.Nodes, nullptr);
-
-        // Refresh skeleton updater with model skeleton
-        SkeletonUpdater<ImportedModelData::Node> hierarchyUpdater(data.Nodes);
-        hierarchyUpdater.UpdateMatrices();
-
-        // Move meshes in the new nodes
-        for (int32 lodIndex = 0; lodIndex < data.LODs.Count(); lodIndex++)
-        {
-            for (int32 meshIndex = 0; meshIndex < data.LODs[lodIndex].Meshes.Count(); meshIndex++)
-            {
-                auto& mesh = *data.LODs[lodIndex].Meshes[meshIndex];
-
-                // Check if there was a remap using model skeleton
-                if (skeletonMapping.SourceToSource[mesh.NodeIndex] != mesh.NodeIndex)
-                {
-                    // Transform vertices
-                    const auto transformationMatrix = hierarchyUpdater.CombineMatricesFromNodeIndices(skeletonMapping.SourceToSource[mesh.NodeIndex], mesh.NodeIndex);
-                    if (!transformationMatrix.IsIdentity())
-                        mesh.TransformBuffer(transformationMatrix);
-                }
-
-                // Update new node index using real asset skeleton
-                mesh.NodeIndex = skeletonMapping.SourceToTarget[mesh.NodeIndex];
-            }
-        }
-
-        // Collision mesh output
-        if (options.CollisionMeshesPrefix.HasChars())
-        {
-            // Extract collision meshes
-            ModelData collisionModel;
-            for (auto& lod : data.LODs)
-            {
-                for (int32 i = lod.Meshes.Count() - 1; i >= 0; i--)
-                {
-                    auto mesh = lod.Meshes[i];
-                    if (mesh->Name.StartsWith(options.CollisionMeshesPrefix, StringSearchCase::IgnoreCase))
-                    {
-                        if (collisionModel.LODs.Count() == 0)
-                            collisionModel.LODs.AddOne();
-                        collisionModel.LODs[0].Meshes.Add(mesh);
-                        lod.Meshes.RemoveAtKeepOrder(i);
-                        if (lod.Meshes.IsEmpty())
-                            break;
-                    }
-                }
-            }
-            if (collisionModel.LODs.HasItems())
-            {
-#if COMPILE_WITH_PHYSICS_COOKING
-                // Create collision
-                CollisionCooking::Argument arg;
-                arg.Type = options.CollisionType;
-                arg.OverrideModelData = &collisionModel;
-                auto assetPath = autoImportOutput / StringUtils::GetFileNameWithoutExtension(path) + TEXT("Collision") ASSET_FILES_EXTENSION_WITH_DOT;
-                if (CreateCollisionData::CookMeshCollision(assetPath, arg))
-                {
-                    LOG(Error, "Failed to create collision mesh.");
-                }
-#endif
-            }
-        }
-
-        // For generated lightmap UVs coordinates needs to be moved so all meshes are in unique locations in [0-1]x[0-1] coordinates space
-        if (options.LightmapUVsSource == ModelLightmapUVsSource::Generate && data.LODs.HasItems() && data.LODs[0].Meshes.Count() > 1)
-        {
-            // Use weight-based coordinates space placement and rect-pack to allocate more space for bigger meshes in the model lightmap chart
-            int32 lodIndex = 0;
-            auto& lod = data.LODs[lodIndex];
-
-            // Build list of meshes with their area
-            struct LightmapUVsPack : RectPack<LightmapUVsPack, float>
-            {
-                LightmapUVsPack(float x, float y, float width, float height)
-                    : RectPack<LightmapUVsPack, float>(x, y, width, height)
-                {
-                }
-
-                void OnInsert()
-                {
-                }
-            };
-            struct MeshEntry
-            {
-                MeshData* Mesh;
-                float Area;
-                float Size;
-                LightmapUVsPack* Slot;
-            };
-            Array<MeshEntry> entries;
-            entries.Resize(lod.Meshes.Count());
-            float areaSum = 0;
-            for (int32 meshIndex = 0; meshIndex < lod.Meshes.Count(); meshIndex++)
-            {
-                auto& entry = entries[meshIndex];
-                entry.Mesh = lod.Meshes[meshIndex];
-                entry.Area = entry.Mesh->CalculateTrianglesArea();
-                entry.Size = Math::Sqrt(entry.Area);
-                areaSum += entry.Area;
-            }
-
-            if (areaSum > ZeroTolerance)
-            {
-                // Pack all surfaces into atlas
-                float atlasSize = Math::Sqrt(areaSum) * 1.02f;
-                int32 triesLeft = 10;
-                while (triesLeft--)
-                {
-                    bool failed = false;
-                    const float chartsPadding = (4.0f / 256.0f) * atlasSize;
-                    LightmapUVsPack root(chartsPadding, chartsPadding, atlasSize - chartsPadding, atlasSize - chartsPadding);
-                    for (auto& entry : entries)
-                    {
-                        entry.Slot = root.Insert(entry.Size, entry.Size, chartsPadding);
-                        if (entry.Slot == nullptr)
-                        {
-                            // Failed to insert surface, increase atlas size and try again
-                            atlasSize *= 1.5f;
-                            failed = true;
-                            break;
-                        }
-                    }
-
-                    if (!failed)
-                    {
-                        // Transform meshes lightmap UVs into the slots in the whole atlas
-                        const float atlasSizeInv = 1.0f / atlasSize;
-                        for (const auto& entry : entries)
-                        {
-                            Float2 uvOffset(entry.Slot->X * atlasSizeInv, entry.Slot->Y * atlasSizeInv);
-                            Float2 uvScale((entry.Slot->Width - chartsPadding) * atlasSizeInv, (entry.Slot->Height - chartsPadding) * atlasSizeInv);
-                            // TODO: SIMD
-                            for (auto& uv : entry.Mesh->LightmapUVs)
-                            {
-                                uv = uv * uvScale + uvOffset;
-                            }
-                        }
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    else if (options.Type == ModelType::SkinnedModel)
-    {
-        // Process blend shapes
-        for (auto& lod : data.LODs)
-        {
-            for (auto& mesh : lod.Meshes)
-            {
-                for (int32 blendShapeIndex = mesh->BlendShapes.Count() - 1; blendShapeIndex >= 0; blendShapeIndex--)
-                {
-                    auto& blendShape = mesh->BlendShapes[blendShapeIndex];
-
-                    // Remove blend shape vertices with empty deltas
-                    for (int32 i = blendShape.Vertices.Count() - 1; i >= 0; i--)
-                    {
-                        auto& v = blendShape.Vertices.Get()[i];
-                        if (v.PositionDelta.IsZero() && v.NormalDelta.IsZero())
-                        {
-                            blendShape.Vertices.RemoveAt(i);
-                        }
-                    }
-
-                    // Remove empty blend shapes
-                    if (blendShape.Vertices.IsEmpty() || blendShape.Name.IsEmpty())
-                    {
-                        LOG(Info, "Removing empty blend shape '{0}' from mesh '{1}'", blendShape.Name, mesh->Name);
-                        mesh->BlendShapes.RemoveAt(blendShapeIndex);
-                    }
-                }
-            }
-        }
 
         // Ensure that root node is at index 0
         int32 rootIndex = -1;
@@ -1385,9 +987,239 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
             }
         }
 #endif
+    }
+    if (EnumHasAllFlags(options.ImportTypes, ImportDataTypes::Geometry | ImportDataTypes::Skeleton))
+    {
+        // Validate skeleton bones used by the meshes
+        const int32 meshesCount = data.LODs.Count() != 0 ? data.LODs[0].Meshes.Count() : 0;
+        for (int32 i = 0; i < meshesCount; i++)
+        {
+            const auto mesh = data.LODs[0].Meshes[i];
+            if (mesh->BlendIndices.IsEmpty() || mesh->BlendWeights.IsEmpty())
+            {
+                auto indices = Int4::Zero;
+                auto weights = Float4::UnitX;
 
-        // Apply the import transformation
-        if (applyImportTransform)
+                // Check if use a single bone for skinning
+                auto nodeIndex = data.Skeleton.FindNode(mesh->Name);
+                auto boneIndex = data.Skeleton.FindBone(nodeIndex);
+                if (boneIndex == -1 && nodeIndex != -1 && data.Skeleton.Bones.Count() < MAX_BONES_PER_MODEL)
+                {
+                    // Add missing bone to be used by skinned model from animated nodes pose
+                    boneIndex = data.Skeleton.Bones.Count();
+                    auto& bone = data.Skeleton.Bones.AddOne();
+                    bone.ParentIndex = -1;
+                    bone.NodeIndex = nodeIndex;
+                    bone.LocalTransform = CombineTransformsFromNodeIndices(data.Nodes, -1, nodeIndex);
+                    CalculateBoneOffsetMatrix(data.Skeleton.Nodes, bone.OffsetMatrix, bone.NodeIndex);
+                    LOG(Warning, "Using auto-created bone {0} (index {1}) for mesh \'{2}\'", data.Skeleton.Nodes[nodeIndex].Name, boneIndex, mesh->Name);
+                    indices.X = boneIndex;
+                }
+                else if (boneIndex != -1)
+                {
+                    // Fallback to already added bone
+                    LOG(Warning, "Using auto-detected bone {0} (index {1}) for mesh \'{2}\'", data.Skeleton.Nodes[nodeIndex].Name, boneIndex, mesh->Name);
+                    indices.X = boneIndex;
+                }
+                else
+                {
+                    // No bone
+                    LOG(Warning, "Imported mesh \'{0}\' has missing skinning data. It may result in invalid rendering.", mesh->Name);
+                }
+
+                mesh->BlendIndices.Resize(mesh->Positions.Count());
+                mesh->BlendWeights.Resize(mesh->Positions.Count());
+                mesh->BlendIndices.SetAll(indices);
+                mesh->BlendWeights.SetAll(weights);
+            }
+#if BUILD_DEBUG
+            else
+            {
+                auto& indices = mesh->BlendIndices;
+                for (int32 j = 0; j < indices.Count(); j++)
+                {
+                    const int32 min = indices[j].MinValue();
+                    const int32 max = indices[j].MaxValue();
+                    if (min < 0 || max >= data.Skeleton.Bones.Count())
+                    {
+                        LOG(Warning, "Imported mesh \'{0}\' has invalid blend indices. It may result in invalid rendering.", mesh->Name);
+                    }
+                }
+
+                auto& weights = mesh->BlendWeights;
+                for (int32 j = 0; j < weights.Count(); j++)
+                {
+                    const float sum = weights[j].SumValues();
+                    if (Math::Abs(sum - 1.0f) > ZeroTolerance)
+                    {
+                        LOG(Warning, "Imported mesh \'{0}\' has invalid blend weights. It may result in invalid rendering.", mesh->Name);
+                    }
+                }
+            }
+#endif
+        }
+    }
+    if (EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Animations))
+    {
+        for (auto& animation : data.Animations)
+        {
+            LOG(Info, "Imported animation '{}' has {} channels, duration: {} frames, frames per second: {}", animation.Name, animation.Channels.Count(), animation.Duration, animation.FramesPerSecond);
+            if (animation.Duration <= ZeroTolerance || animation.FramesPerSecond <= ZeroTolerance)
+            {
+                errorMsg = TEXT("Invalid animation duration.");
+                return true;
+            }
+        }
+    }
+    switch (options.Type)
+    {
+    case ModelType::Model:
+        if (data.LODs.IsEmpty() || data.LODs[0].Meshes.IsEmpty())
+        {
+            errorMsg = TEXT("Imported model has no valid geometry.");
+            return true;
+        }
+        if (data.Nodes.IsEmpty())
+        {
+            errorMsg = TEXT("Missing model nodes.");
+            return true;
+        }
+        break;
+    case ModelType::SkinnedModel:
+        if (data.LODs.Count() > 1)
+        {
+            LOG(Warning, "Imported skinned model has more than one LOD. Removing the lower LODs. Only single one is supported.");
+            data.LODs.Resize(1);
+        }
+        break;
+    case ModelType::Animation:
+        if (data.Animations.IsEmpty())
+        {
+            errorMsg = TEXT("Imported file has no valid animations.");
+            return true;
+        }
+        break;
+    }
+
+    // Keep additionally imported files well organized
+    Array<String> importedFileNames;
+
+    // Prepare textures
+    for (int32 i = 0; i < data.Textures.Count(); i++)
+    {
+        auto& texture = data.Textures[i];
+
+        // Auto-import textures
+        if (autoImportOutput.IsEmpty() || EnumHasNoneFlags(options.ImportTypes, ImportDataTypes::Textures) || texture.FilePath.IsEmpty())
+            continue;
+        String assetPath = GetAdditionalImportPath(autoImportOutput, importedFileNames, StringUtils::GetFileNameWithoutExtension(texture.FilePath));
+#if COMPILE_WITH_ASSETS_IMPORTER
+        TextureTool::Options textureOptions;
+        switch (texture.Type)
+        {
+        case TextureEntry::TypeHint::ColorRGB:
+            textureOptions.Type = TextureFormatType::ColorRGB;
+            break;
+        case TextureEntry::TypeHint::ColorRGBA:
+            textureOptions.Type = TextureFormatType::ColorRGBA;
+            break;
+        case TextureEntry::TypeHint::Normals:
+            textureOptions.Type = TextureFormatType::NormalMap;
+            break;
+        }
+        AssetsImportingManager::ImportIfEdited(texture.FilePath, assetPath, texture.AssetID, &textureOptions);
+#endif
+    }
+
+    // Prepare materials
+    for (int32 i = 0; i < data.Materials.Count(); i++)
+    {
+        auto& material = data.Materials[i];
+
+        if (material.Name.IsEmpty())
+            material.Name = TEXT("Material ") + StringUtils::ToString(i);
+
+        // Auto-import materials
+        if (autoImportOutput.IsEmpty() || EnumHasNoneFlags(options.ImportTypes, ImportDataTypes::Materials) || !material.UsesProperties())
+            continue;
+        String assetPath = GetAdditionalImportPath(autoImportOutput, importedFileNames, material.Name);
+#if COMPILE_WITH_ASSETS_IMPORTER
+        // When splitting imported meshes allow only the first mesh to import assets (mesh[0] is imported after all following ones so import assets during mesh[1])
+        if (!options.SplitObjects && options.ObjectIndex != 1 && options.ObjectIndex != -1)
+        {
+            // Find that asset created previously
+            AssetInfo info;
+            if (Content::GetAssetInfo(assetPath, info))
+                material.AssetID = info.ID;
+            continue;
+        }
+
+        if (options.ImportMaterialsAsInstances)
+        {
+            // Create material instance
+            AssetsImportingManager::Create(AssetsImportingManager::CreateMaterialInstanceTag, assetPath, material.AssetID);
+            if (auto* materialInstance = Content::Load<MaterialInstance>(assetPath))
+            {
+                materialInstance->SetBaseMaterial(options.InstanceToImportAs);
+
+                // Customize base material based on imported material (blind guess based on the common names used in materials)
+                const Char* diffuseColorNames[] = { TEXT("color"), TEXT("col"), TEXT("diffuse"), TEXT("basecolor"), TEXT("base color") };
+                TrySetupMaterialParameter(materialInstance, ToSpan(diffuseColorNames, ARRAY_COUNT(diffuseColorNames)), material.Diffuse.Color, MaterialParameterType::Color);
+                const Char* emissiveColorNames[] = { TEXT("emissive"), TEXT("emission"), TEXT("light") };
+                TrySetupMaterialParameter(materialInstance, ToSpan(emissiveColorNames, ARRAY_COUNT(emissiveColorNames)), material.Emissive.Color, MaterialParameterType::Color);
+                const Char* opacityValueNames[] = { TEXT("opacity"), TEXT("alpha") };
+                TrySetupMaterialParameter(materialInstance, ToSpan(opacityValueNames, ARRAY_COUNT(opacityValueNames)), material.Opacity.Value, MaterialParameterType::Float);
+
+                materialInstance->Save();
+            }
+            else
+            {
+                LOG(Error, "Failed to load material instance after creation. ({0})", assetPath);
+            }
+        }
+        else
+        {
+            // Create material
+            CreateMaterial::Options materialOptions;
+            materialOptions.Diffuse.Color = material.Diffuse.Color;
+            if (material.Diffuse.TextureIndex != -1)
+                materialOptions.Diffuse.Texture = data.Textures[material.Diffuse.TextureIndex].AssetID;
+            materialOptions.Diffuse.HasAlphaMask = material.Diffuse.HasAlphaMask;
+            materialOptions.Emissive.Color = material.Emissive.Color;
+            if (material.Emissive.TextureIndex != -1)
+                materialOptions.Emissive.Texture = data.Textures[material.Emissive.TextureIndex].AssetID;
+            materialOptions.Opacity.Value = material.Opacity.Value;
+            if (material.Opacity.TextureIndex != -1)
+                materialOptions.Opacity.Texture = data.Textures[material.Opacity.TextureIndex].AssetID;
+            if (material.Normals.TextureIndex != -1)
+                materialOptions.Normals.Texture = data.Textures[material.Normals.TextureIndex].AssetID;
+            if (material.TwoSided || material.Diffuse.HasAlphaMask)
+                materialOptions.Info.CullMode = CullMode::TwoSided;
+            if (!Math::IsOne(material.Opacity.Value) || material.Opacity.TextureIndex != -1)
+                materialOptions.Info.BlendMode = MaterialBlendMode::Transparent;
+            AssetsImportingManager::Create(AssetsImportingManager::CreateMaterialTag, assetPath, material.AssetID, &materialOptions);
+        }
+#endif
+    }
+
+    // Prepare import transformation
+    Transform importTransform(options.Translation, options.Rotation, Float3(options.Scale));
+    if (options.UseLocalOrigin && data.LODs.HasItems() && data.LODs[0].Meshes.HasItems())
+    {
+        importTransform.Translation -= importTransform.Orientation * data.LODs[0].Meshes[0]->OriginTranslation * importTransform.Scale;
+    }
+    if (options.CenterGeometry && data.LODs.HasItems() && data.LODs[0].Meshes.HasItems())
+    {
+        // Calculate the bounding box (use LOD0 as a reference)
+        BoundingBox box = data.LODs[0].GetBox();
+        auto center = data.LODs[0].Meshes[0]->OriginOrientation * importTransform.Orientation * box.GetCenter() * importTransform.Scale * data.LODs[0].Meshes[0]->Scaling;
+        importTransform.Translation -= center;
+    }
+
+    // Apply the import transformation
+    if (!importTransform.IsIdentity())
+    {
+        if (options.Type == ModelType::SkinnedModel)
         {
             // Transform the root node using the import transformation
             auto& root = data.Skeleton.RootNode();
@@ -1413,20 +1245,21 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
             for (SkeletonBone& bone : data.Skeleton.Bones)
             {
                 if (bone.ParentIndex == -1)
-                {
                     bone.LocalTransform = importTransform.LocalToWorld(bone.LocalTransform);
-                }
                 bone.OffsetMatrix = importMatrixInv * bone.OffsetMatrix;
             }
         }
+        else
+        {
+            // Transform the root node using the import transformation
+            auto& root = data.Nodes[0];
+            root.LocalTransform = importTransform.LocalToWorld(root.LocalTransform);
+        }
+    }
 
-        // Perform simple nodes mapping to single node (will transform meshes to model local space)
-        SkeletonMapping<ImportedModelData::Node> skeletonMapping(data.Nodes, nullptr);
-
-        // Refresh skeleton updater with model skeleton
-        SkeletonUpdater<ImportedModelData::Node> hierarchyUpdater(data.Nodes);
-        hierarchyUpdater.UpdateMatrices();
-
+    // Post-process imported data
+    if (EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Skeleton))
+    {
         if (options.CalculateBoneOffsetMatrices)
         {
             // Calculate offset matrix (inverse bind pose transform) for every bone manually
@@ -1436,27 +1269,6 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
             }
         }
 
-        // Move meshes in the new nodes
-        for (int32 lodIndex = 0; lodIndex < data.LODs.Count(); lodIndex++)
-        {
-            for (int32 meshIndex = 0; meshIndex < data.LODs[lodIndex].Meshes.Count(); meshIndex++)
-            {
-                auto& mesh = *data.LODs[lodIndex].Meshes[meshIndex];
-
-                // Check if there was a remap using model skeleton
-                if (skeletonMapping.SourceToSource[mesh.NodeIndex] != mesh.NodeIndex)
-                {
-                    // Transform vertices
-                    const auto transformationMatrix = hierarchyUpdater.CombineMatricesFromNodeIndices(skeletonMapping.SourceToSource[mesh.NodeIndex], mesh.NodeIndex);
-                    if (!transformationMatrix.IsIdentity())
-                        mesh.TransformBuffer(transformationMatrix);
-                }
-
-                // Update new node index using real asset skeleton
-                mesh.NodeIndex = skeletonMapping.SourceToTarget[mesh.NodeIndex];
-            }
-        }
-
 #if USE_SKELETON_NODES_SORTING
         // Sort skeleton nodes and bones hierarchy (parents first)
         // Then it can be used with a simple linear loop update
@@ -1480,74 +1292,142 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
         !
 #endif
     }
-    else if (options.Type == ModelType::Animation)
+    if (EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Geometry) && options.Type != ModelType::Prefab)
     {
-        // Trim the animation keyframes range if need to
-        if (options.Duration == AnimationDuration::Custom)
-        {
-            // Custom animation import, frame index start and end
-            const float start = options.FramesRange.X;
-            const float end = options.FramesRange.Y;
-            for (int32 i = 0; i < data.Animation.Channels.Count(); i++)
-            {
-                auto& anim = data.Animation.Channels[i];
-                anim.Position.Trim(start, end);
-                anim.Rotation.Trim(start, end);
-                anim.Scale.Trim(start, end);
-            }
-            data.Animation.Duration = end - start;
-        }
+        // Perform simple nodes mapping to single node (will transform meshes to model local space)
+        SkeletonMapping<ModelDataNode> skeletonMapping(data.Nodes, nullptr);
 
-        // Change the sampling rate if need to
-        if (!Math::IsZero(options.SamplingRate))
+        // Refresh skeleton updater with model skeleton
+        SkeletonUpdater<ModelDataNode> hierarchyUpdater(data.Nodes);
+        hierarchyUpdater.UpdateMatrices();
+
+        // Move meshes in the new nodes
+        for (int32 lodIndex = 0; lodIndex < data.LODs.Count(); lodIndex++)
         {
-            const float timeScale = (float)(data.Animation.FramesPerSecond / options.SamplingRate);
-            if (!Math::IsOne(timeScale))
+            for (int32 meshIndex = 0; meshIndex < data.LODs[lodIndex].Meshes.Count(); meshIndex++)
             {
-                data.Animation.FramesPerSecond = options.SamplingRate;
-                for (int32 i = 0; i < data.Animation.Channels.Count(); i++)
+                auto& mesh = *data.LODs[lodIndex].Meshes[meshIndex];
+
+                // Check if there was a remap using model skeleton
+                if (skeletonMapping.SourceToSource[mesh.NodeIndex] != mesh.NodeIndex)
                 {
-                    auto& anim = data.Animation.Channels[i];
+                    // Transform vertices
+                    const auto transformationMatrix = hierarchyUpdater.CombineMatricesFromNodeIndices(skeletonMapping.SourceToSource[mesh.NodeIndex], mesh.NodeIndex);
+                    if (!transformationMatrix.IsIdentity())
+                        mesh.TransformBuffer(transformationMatrix);
+                }
 
-                    anim.Position.TransformTime(timeScale, 0.0f);
-                    anim.Rotation.TransformTime(timeScale, 0.0f);
-                    anim.Scale.TransformTime(timeScale, 0.0f);
+                // Update new node index using real asset skeleton
+                mesh.NodeIndex = skeletonMapping.SourceToTarget[mesh.NodeIndex];
+            }
+        }
+    }
+    if (EnumHasAnyFlags(options.ImportTypes, ImportDataTypes::Animations))
+    {
+        for (auto& animation : data.Animations)
+        {
+            // Trim the animation keyframes range if need to
+            if (options.Duration == AnimationDuration::Custom)
+            {
+                // Custom animation import, frame index start and end
+                const float start = options.FramesRange.X;
+                const float end = options.FramesRange.Y;
+                for (int32 i = 0; i < animation.Channels.Count(); i++)
+                {
+                    auto& anim = animation.Channels[i];
+                    anim.Position.Trim(start, end);
+                    anim.Rotation.Trim(start, end);
+                    anim.Scale.Trim(start, end);
+                }
+                animation.Duration = end - start;
+            }
+
+            // Change the sampling rate if need to
+            if (!Math::IsZero(options.SamplingRate))
+            {
+                const float timeScale = (float)(animation.FramesPerSecond / options.SamplingRate);
+                if (!Math::IsOne(timeScale))
+                {
+                    animation.FramesPerSecond = options.SamplingRate;
+                    for (int32 i = 0; i < animation.Channels.Count(); i++)
+                    {
+                        auto& anim = animation.Channels[i];
+                        anim.Position.TransformTime(timeScale, 0.0f);
+                        anim.Rotation.TransformTime(timeScale, 0.0f);
+                        anim.Scale.TransformTime(timeScale, 0.0f);
+                    }
+                }
+            }
+
+            // Optimize the keyframes
+            if (options.OptimizeKeyframes)
+            {
+                const int32 before = animation.GetKeyframesCount();
+                for (int32 i = 0; i < animation.Channels.Count(); i++)
+                {
+                    auto& anim = animation.Channels[i];
+
+                    // Optimize keyframes
+                    OptimizeCurve(anim.Position);
+                    OptimizeCurve(anim.Rotation);
+                    OptimizeCurve(anim.Scale);
+
+                    // Remove empty channels
+                    if (anim.GetKeyframesCount() == 0)
+                    {
+                        animation.Channels.RemoveAt(i--);
+                    }
+                }
+                const int32 after = animation.GetKeyframesCount();
+                LOG(Info, "Optimized {0} animation keyframe(s). Before: {1}, after: {2}, Ratio: {3}%", before - after, before, after, Utilities::RoundTo2DecimalPlaces((float)after / before));
+            }
+
+            animation.EnableRootMotion = options.EnableRootMotion;
+            animation.RootNodeName = options.RootNodeName;
+        }
+    }
+
+    // Collision mesh output
+    if (options.CollisionMeshesPrefix.HasChars())
+    {
+        // Extract collision meshes from the model
+        ModelData collisionModel;
+        for (auto& lod : data.LODs)
+        {
+            for (int32 i = lod.Meshes.Count() - 1; i >= 0; i--)
+            {
+                auto mesh = lod.Meshes[i];
+                if (mesh->Name.StartsWith(options.CollisionMeshesPrefix, StringSearchCase::IgnoreCase))
+                {
+                    if (collisionModel.LODs.Count() == 0)
+                        collisionModel.LODs.AddOne();
+                    collisionModel.LODs[0].Meshes.Add(mesh);
+                    lod.Meshes.RemoveAtKeepOrder(i);
+                    if (lod.Meshes.IsEmpty())
+                        break;
                 }
             }
         }
-
-        // Optimize the keyframes
-        if (options.OptimizeKeyframes)
+#if COMPILE_WITH_PHYSICS_COOKING
+        if (collisionModel.LODs.HasItems() && options.CollisionType != CollisionDataType::None)
         {
-            const int32 before = data.Animation.GetKeyframesCount();
-            for (int32 i = 0; i < data.Animation.Channels.Count(); i++)
+            // Cook collision
+            String assetPath = GetAdditionalImportPath(autoImportOutput, importedFileNames, TEXT("Collision"));
+            CollisionCooking::Argument arg;
+            arg.Type = options.CollisionType;
+            arg.OverrideModelData = &collisionModel;
+            if (CreateCollisionData::CookMeshCollision(assetPath, arg))
             {
-                auto& anim = data.Animation.Channels[i];
-
-                // Optimize keyframes
-                OptimizeCurve(anim.Position);
-                OptimizeCurve(anim.Rotation);
-                OptimizeCurve(anim.Scale);
-
-                // Remove empty channels
-                if (anim.GetKeyframesCount() == 0)
-                {
-                    data.Animation.Channels.RemoveAt(i--);
-                }
+                LOG(Error, "Failed to create collision mesh.");
             }
-            const int32 after = data.Animation.GetKeyframesCount();
-            LOG(Info, "Optimized {0} animation keyframe(s). Before: {1}, after: {2}, Ratio: {3}%", before - after, before, after, Utilities::RoundTo2DecimalPlaces((float)after / before));
         }
-
-        data.Animation.EnableRootMotion = options.EnableRootMotion;
-        data.Animation.RootNodeName = options.RootNodeName;
+#endif
     }
 
     // Merge meshes with the same parent nodes, material and skinning
     if (options.MergeMeshes)
     {
         int32 meshesMerged = 0;
-
         for (int32 lodIndex = 0; lodIndex < data.LODs.Count(); lodIndex++)
         {
             auto& meshes = data.LODs[lodIndex].Meshes;
@@ -1579,11 +1459,8 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
                 }
             }
         }
-
         if (meshesMerged)
-        {
             LOG(Info, "Merged {0} meshes", meshesMerged);
-        }
     }
 
     // Automatic LOD generation
@@ -1601,6 +1478,7 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
             baseLodTriangleCount += mesh->Indices.Count() / 3;
             baseLodVertexCount += mesh->Positions.Count();
         }
+        Array<unsigned int> indices;
         for (int32 lodIndex = Math::Clamp(baseLOD + 1, 1, lodCount - 1); lodIndex < lodCount; lodIndex++)
         {
             auto& dstLod = data.LODs[lodIndex];
@@ -1622,16 +1500,18 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
                 int32 srcMeshIndexCount = srcMesh->Indices.Count();
                 int32 srcMeshVertexCount = srcMesh->Positions.Count();
                 int32 dstMeshIndexCountTarget = int32(srcMeshIndexCount * triangleReduction) / 3 * 3;
-                Array<unsigned int> indices;
-                indices.Resize(dstMeshIndexCountTarget);
+                if (dstMeshIndexCountTarget < 3 || dstMeshIndexCountTarget >= srcMeshIndexCount)
+                    continue;
+                indices.Clear();
+                indices.Resize(srcMeshIndexCount);
                 int32 dstMeshIndexCount = {};
                 if (options.SloppyOptimization)
-                    dstMeshIndexCount = (int32)meshopt_simplifySloppy(indices.Get(), srcMesh->Indices.Get(), srcMeshIndexCount, (const float*)srcMesh->Positions.Get(), srcMeshVertexCount, sizeof(Float3), dstMeshIndexCountTarget);
+                    dstMeshIndexCount = (int32)meshopt_simplifySloppy(indices.Get(), srcMesh->Indices.Get(), srcMeshIndexCount, (const float*)srcMesh->Positions.Get(), srcMeshVertexCount, sizeof(Float3), dstMeshIndexCountTarget, options.LODTargetError);
                 else
                     dstMeshIndexCount = (int32)meshopt_simplify(indices.Get(), srcMesh->Indices.Get(), srcMeshIndexCount, (const float*)srcMesh->Positions.Get(), srcMeshVertexCount, sizeof(Float3), dstMeshIndexCountTarget, options.LODTargetError);
-                indices.Resize(dstMeshIndexCount);
-                if (dstMeshIndexCount == 0)
+                if (dstMeshIndexCount <= 0 || dstMeshIndexCount > indices.Count())
                     continue;
+                indices.Resize(dstMeshIndexCount);
 
                 // Generate simplified vertex buffer remapping table (use only vertices from LOD index buffer)
                 Array<unsigned int> remap;
@@ -1698,11 +1578,15 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
                 generatedLod++;
             }
 
-            // Remove empty meshes
+            // Remove empty meshes (no LOD was generated for them)
             for (int32 i = dstLod.Meshes.Count() - 1; i >= 0; i--)
             {
-                if (dstLod.Meshes[i]->Indices.IsEmpty())
-                    dstLod.Meshes.RemoveAt(i--);
+                MeshData* mesh = dstLod.Meshes[i];
+                if (mesh->Indices.IsEmpty() || mesh->Positions.IsEmpty())
+                {
+                    Delete(mesh);
+                    dstLod.Meshes.RemoveAtKeepOrder(i);
+                }
             }
 
             LOG(Info, "Generated LOD{0}: triangles: {1} ({2}% of base LOD), verticies: {3} ({4}% of base LOD)",
@@ -1710,6 +1594,13 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
                 lodTriangleCount, (int32)(lodTriangleCount * 100 / baseLodTriangleCount),
                 lodVertexCount, (int32)(lodVertexCount * 100 / baseLodVertexCount));
         }
+        for (int32 lodIndex = data.LODs.Count() - 1; lodIndex > 0; lodIndex--)
+        {
+            if (data.LODs[lodIndex].Meshes.IsEmpty())
+                data.LODs.RemoveAt(lodIndex);
+            else
+                break;
+        }
         if (generatedLod)
         {
             auto lodEndTime = DateTime::NowUTC();
@@ -1717,27 +1608,8 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
         }
     }
 
-    // Export imported data to the output container (we reduce vertex data copy operations to minimum)
-    {
-        meshData.Textures.Swap(data.Textures);
-        meshData.Materials.Swap(data.Materials);
-        meshData.LODs.Resize(data.LODs.Count(), false);
-        for (int32 i = 0; i < data.LODs.Count(); i++)
-        {
-            auto& dst = meshData.LODs[i];
-            auto& src = data.LODs[i];
-
-            dst.Meshes = src.Meshes;
-        }
-        meshData.Skeleton.Swap(data.Skeleton);
-        meshData.Animation.Swap(data.Animation);
-
-        // Clear meshes from imported data (we link them to result model data). This reduces amount of allocations.
-        data.LODs.Resize(0);
-    }
-
     // Calculate blend shapes vertices ranges
-    for (auto& lod : meshData.LODs)
+    for (auto& lod : data.LODs)
     {
         for (auto& mesh : lod.Meshes)
         {
@@ -1758,6 +1630,9 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
         }
     }
 
+    // Auto calculate LODs transition settings
+    data.CalculateLODsScreenSizes();
+
     const auto endTime = DateTime::NowUTC();
     LOG(Info, "Model file imported in {0} ms", static_cast<int32>((endTime - startTime).GetTotalMilliseconds()));
 
diff --git a/Source/Engine/Tools/ModelTool/ModelTool.h b/Source/Engine/Tools/ModelTool/ModelTool.h
index ac8cb231f..416505631 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.h
+++ b/Source/Engine/Tools/ModelTool/ModelTool.h
@@ -24,7 +24,7 @@ enum class ImportDataTypes : int32
     None = 0,
 
     /// <summary>
-    /// Imports materials and meshes.
+    /// Imports meshes (and LODs).
     /// </summary>
     Geometry = 1 << 0,
 
@@ -56,94 +56,6 @@ enum class ImportDataTypes : int32
 
 DECLARE_ENUM_OPERATORS(ImportDataTypes);
 
-/// <summary>
-/// Imported model data container. Represents unified model source file data (meshes, animations, skeleton, materials).
-/// </summary>
-class ImportedModelData
-{
-public:
-    struct LOD
-    {
-        Array<MeshData*> Meshes;
-
-        BoundingBox GetBox() const;
-    };
-
-    struct Node
-    {
-        /// <summary>
-        /// The parent node index. The root node uses value -1.
-        /// </summary>
-        int32 ParentIndex;
-
-        /// <summary>
-        /// The local transformation of the node, relative to the parent node.
-        /// </summary>
-        Transform LocalTransform;
-
-        /// <summary>
-        /// The name of this node.
-        /// </summary>
-        String Name;
-    };
-
-public:
-    /// <summary>
-    /// The import data types types.
-    /// </summary>
-    ImportDataTypes Types;
-
-    /// <summary>
-    /// The textures slots.
-    /// </summary>
-    Array<TextureEntry> Textures;
-
-    /// <summary>
-    /// The material slots.
-    /// </summary>
-    Array<MaterialSlotEntry> Materials;
-
-    /// <summary>
-    /// The level of details data.
-    /// </summary>
-    Array<LOD> LODs;
-
-    /// <summary>
-    /// The skeleton data.
-    /// </summary>
-    SkeletonData Skeleton;
-
-    /// <summary>
-    /// The scene nodes.
-    /// </summary>
-    Array<Node> Nodes;
-
-    /// <summary>
-    /// The node animations.
-    /// </summary>
-    AnimationData Animation;
-
-public:
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ImportedModelData"/> class.
-    /// </summary>
-    /// <param name="types">The types.</param>
-    ImportedModelData(ImportDataTypes types)
-    {
-        Types = types;
-    }
-
-    /// <summary>
-    /// Finalizes an instance of the <see cref="ImportedModelData"/> class.
-    /// </summary>
-    ~ImportedModelData()
-    {
-        // Ensure to cleanup data
-        for (int32 i = 0; i < LODs.Count(); i++)
-            LODs[i].Meshes.ClearDelete();
-    }
-};
-
 #endif
 
 struct ModelSDFHeader
@@ -202,6 +114,8 @@ public:
         SkinnedModel = 1,
         // The animation asset.
         Animation = 2,
+        // The prefab scene.
+        Prefab = 3,
     };
 
     /// <summary>
@@ -335,10 +249,10 @@ public:
         float TriangleReduction = 0.5f;
         // Whether to do a sloppy mesh optimization. This is faster but does not follow the topology of the original mesh.
         API_FIELD(Attributes="EditorOrder(1140), EditorDisplay(\"Level Of Detail\"), VisibleIf(nameof(ShowGeometry))")
-        bool SloppyOptimization = true;
+        bool SloppyOptimization = false;
         // Only used if Sloppy is false. Target error is an approximate measure of the deviation from the original mesh using distance normalized to [0..1] range (e.g. 1e-2f means that simplifier will try to maintain the error to be below 1% of the mesh extents).
         API_FIELD(Attributes="EditorOrder(1150), EditorDisplay(\"Level Of Detail\"), VisibleIf(nameof(SloppyOptimization), true), Limit(0.01f, 1, 0.001f)")
-        float LODTargetError = 0.1f;
+        float LODTargetError = 0.05f;
 
     public: // Materials
 
@@ -370,10 +284,10 @@ public:
     public: // Splitting
 
         // If checked, the imported mesh/animations are split into separate assets. Used if ObjectIndex is set to -1.
-        API_FIELD(Attributes="EditorOrder(2000), EditorDisplay(\"Splitting\")")
+        API_FIELD(Attributes="EditorOrder(2000), EditorDisplay(\"Splitting\"), VisibleIf(nameof(ShowSplitting))")
         bool SplitObjects = false;
         // The zero-based index for the mesh/animation clip to import. If the source file has more than one mesh/animation it can be used to pick a desired object. Default -1 imports all objects.
-        API_FIELD(Attributes="EditorOrder(2010), EditorDisplay(\"Splitting\")")
+        API_FIELD(Attributes="EditorOrder(2010), EditorDisplay(\"Splitting\"), VisibleIf(nameof(ShowSplitting))")
         int32 ObjectIndex = -1;
 
     public: // Other
@@ -382,9 +296,18 @@ public:
         API_FIELD(Attributes="EditorOrder(3030), EditorDisplay(\"Other\")")
         String SubAssetFolder = TEXT("");
 
-        // Runtime data for objects splitting during import (used internally)
-        void* SplitContext = nullptr;
-        Function<bool(Options& splitOptions, const String& objectName)> OnSplitImport;
+    public: // Internals
+
+        // Internal flags for objects to import.
+        ImportDataTypes ImportTypes = ImportDataTypes::None;
+
+        struct CachedData
+        {
+            ModelData* Data = nullptr;
+            void* MeshesByName = nullptr;
+        };
+        // Cached model data - used when performing nested importing (eg. via objects splitting). Allows to read and process source file only once and use those results for creation of multiple assets (permutation via ObjectIndex).
+        CachedData* Cached = nullptr;
 
     public:
         // [ISerializable]
@@ -401,18 +324,18 @@ public:
     /// <param name="options">The import options.</param>
     /// <param name="errorMsg">The error message container.</param>
     /// <returns>True if fails, otherwise false.</returns>
-    static bool ImportData(const String& path, ImportedModelData& data, Options& options, String& errorMsg);
+    static bool ImportData(const String& path, ModelData& data, Options& options, String& errorMsg);
 
     /// <summary>
     /// Imports the model.
     /// </summary>
     /// <param name="path">The file path.</param>
-    /// <param name="meshData">The output data.</param>
+    /// <param name="data">The output data.</param>
     /// <param name="options">The import options.</param>
     /// <param name="errorMsg">The error message container.</param>
     /// <param name="autoImportOutput">The output folder for the additional imported data - optional. Used to auto-import textures and material assets.</param>
     /// <returns>True if fails, otherwise false.</returns>
-    static bool ImportModel(const String& path, ModelData& meshData, Options& options, String& errorMsg, const String& autoImportOutput = String::Empty);
+    static bool ImportModel(const String& path, ModelData& data, Options& options, String& errorMsg, const String& autoImportOutput = String::Empty);
 
 public:
     static int32 DetectLodIndex(const String& nodeName);
@@ -444,13 +367,13 @@ public:
 private:
     static void CalculateBoneOffsetMatrix(const Array<SkeletonNode>& nodes, Matrix& offsetMatrix, int32 nodeIndex);
 #if USE_ASSIMP
-    static bool ImportDataAssimp(const char* path, ImportedModelData& data, Options& options, String& errorMsg);
+    static bool ImportDataAssimp(const char* path, ModelData& data, Options& options, String& errorMsg);
 #endif
 #if USE_AUTODESK_FBX_SDK
-	static bool ImportDataAutodeskFbxSdk(const char* path, ImportedModelData& data, Options& options, String& errorMsg);
+	static bool ImportDataAutodeskFbxSdk(const char* path, ModelData& data, Options& options, String& errorMsg);
 #endif
 #if USE_OPEN_FBX
-    static bool ImportDataOpenFBX(const char* path, ImportedModelData& data, Options& options, String& errorMsg);
+    static bool ImportDataOpenFBX(const char* path, ModelData& data, Options& options, String& errorMsg);
 #endif
 #endif
 };
diff --git a/Source/Engine/Tools/TextureTool/TextureTool.DirectXTex.cpp b/Source/Engine/Tools/TextureTool/TextureTool.DirectXTex.cpp
index 6588257c2..fced3423d 100644
--- a/Source/Engine/Tools/TextureTool/TextureTool.DirectXTex.cpp
+++ b/Source/Engine/Tools/TextureTool/TextureTool.DirectXTex.cpp
@@ -10,7 +10,6 @@
 #include "Engine/Platform/ConditionVariable.h"
 #include "Engine/Graphics/RenderTools.h"
 #include "Engine/Graphics/Async/GPUTask.h"
-#include "Engine/Graphics/Textures/TextureUtils.h"
 #include "Engine/Graphics/Textures/TextureData.h"
 #include "Engine/Graphics/PixelFormatExtensions.h"
 #if USE_EDITOR
@@ -318,7 +317,7 @@ bool TextureTool::ImportTextureDirectXTex(ImageType type, const StringView& path
     textureData.Width = (int32)meta.width;
     textureData.Height = (int32)meta.height;
     textureData.Depth = (int32)meta.depth;
-    textureData.Format = ToPixelFormat(meta.format);
+    textureData.Format = ::ToPixelFormat(meta.format);
     textureData.Items.Resize(1);
     textureData.Items.Resize((int32)meta.arraySize);
     for (int32 arrayIndex = 0; arrayIndex < (int32)meta.arraySize; arrayIndex++)
@@ -598,7 +597,7 @@ bool TextureTool::ImportTextureDirectXTex(ImageType type, const StringView& path
     float alphaThreshold = 0.3f;
     bool isPowerOfTwo = Math::IsPowerOfTwo(width) && Math::IsPowerOfTwo(height);
     DXGI_FORMAT sourceDxgiFormat = currentImage->GetMetadata().format;
-    PixelFormat targetFormat = TextureUtils::ToPixelFormat(options.Type, width, height, options.Compress);
+    PixelFormat targetFormat = TextureTool::ToPixelFormat(options.Type, width, height, options.Compress);
     if (options.sRGB)
         targetFormat = PixelFormatExtensions::TosRGB(targetFormat);
     DXGI_FORMAT targetDxgiFormat = ToDxgiFormat(targetFormat);
@@ -625,19 +624,26 @@ bool TextureTool::ImportTextureDirectXTex(ImageType type, const StringView& path
     }
 
     bool keepAsIs = false;
-    if (!options.FlipY && options.Compress && type == ImageType::DDS && mipLevels == sourceMipLevels && DirectX::IsCompressed(sourceDxgiFormat) && !DirectX::IsSRGB(sourceDxgiFormat))
+    if (!options.FlipY && 
+        !options.InvertGreenChannel && 
+        options.Compress && 
+        type == ImageType::DDS && 
+        mipLevels == sourceMipLevels && 
+        DirectX::IsCompressed(sourceDxgiFormat) && 
+        !DirectX::IsSRGB(sourceDxgiFormat) && 
+        width >= 4 && 
+        height >= 4)
     {
         // Keep image in the current compressed format (artist choice) so we don't have to run the slow mipmap generation
         keepAsIs = true;
         targetDxgiFormat = sourceDxgiFormat;
-        targetFormat = ToPixelFormat(currentImage->GetMetadata().format);
+        targetFormat = ::ToPixelFormat(currentImage->GetMetadata().format);
     }
 
     // Decompress if texture is compressed (next steps need decompressed input data, for eg. mip maps generation or format changing)
     if (!keepAsIs && DirectX::IsCompressed(sourceDxgiFormat))
     {
         auto& tmpImg = GET_TMP_IMG();
-
         sourceDxgiFormat = DXGI_FORMAT_R16G16B16A16_FLOAT;
         result = Decompress(currentImage->GetImages(), currentImage->GetImageCount(), currentImage->GetMetadata(), sourceDxgiFormat, tmpImg);
         if (FAILED(result))
@@ -645,14 +651,13 @@ bool TextureTool::ImportTextureDirectXTex(ImageType type, const StringView& path
             errorMsg = String::Format(TEXT("Cannot decompress texture, error: {0:x}"), static_cast<uint32>(result));
             return true;
         }
-
         SET_CURRENT_IMG(tmpImg);
     }
 
     // Fix sRGB problem
     if (!keepAsIs && DirectX::IsSRGB(sourceDxgiFormat))
     {
-        sourceDxgiFormat = ToDxgiFormat(PixelFormatExtensions::ToNonsRGB(ToPixelFormat(sourceDxgiFormat)));
+        sourceDxgiFormat = ToDxgiFormat(PixelFormatExtensions::ToNonsRGB(::ToPixelFormat(sourceDxgiFormat)));
         ((DirectX::TexMetadata&)currentImage->GetMetadata()).format = sourceDxgiFormat;
         for (size_t i = 0; i < currentImage->GetImageCount(); i++)
             ((DirectX::Image*)currentImage->GetImages())[i].format = sourceDxgiFormat;
@@ -662,12 +667,10 @@ bool TextureTool::ImportTextureDirectXTex(ImageType type, const StringView& path
     if (!keepAsIs && DirectX::HasAlpha(sourceDxgiFormat) && options.Type == TextureFormatType::ColorRGB && options.Compress)
     {
         auto& tmpImg = GET_TMP_IMG();
-
-        TransformImage(currentImage->GetImages(), currentImage->GetImageCount(), currentImage->GetMetadata(),
+        result = TransformImage(currentImage->GetImages(), currentImage->GetImageCount(), currentImage->GetMetadata(),
                        [](DirectX::XMVECTOR* outPixels, const DirectX::XMVECTOR* inPixels, size_t width, size_t y)
                        {
                            UNREFERENCED_PARAMETER(y);
-
                            for (size_t j = 0; j < width; j++)
                            {
                                outPixels[j] = DirectX::XMVectorSelect(DirectX::g_XMOne, inPixels[j], DirectX::g_XMSelect1110);
@@ -678,8 +681,6 @@ bool TextureTool::ImportTextureDirectXTex(ImageType type, const StringView& path
             errorMsg = String::Format(TEXT("Cannot transform texture to remove unwanted alpha channel, error: {0:x}"), static_cast<uint32>(result));
             return true;
         }
-
-        // Use converted image
         SET_CURRENT_IMG(tmpImg);
     }
 
@@ -687,7 +688,6 @@ bool TextureTool::ImportTextureDirectXTex(ImageType type, const StringView& path
     if (!keepAsIs && options.FlipY)
     {
         auto& tmpImg = GET_TMP_IMG();
-
         DWORD flags = DirectX::TEX_FR_FLIP_VERTICAL;
         result = FlipRotate(currentImage->GetImages(), currentImage->GetImageCount(), currentImage->GetMetadata(), flags, tmpImg);
         if (FAILED(result))
@@ -695,11 +695,37 @@ bool TextureTool::ImportTextureDirectXTex(ImageType type, const StringView& path
             errorMsg = String::Format(TEXT("Cannot rotate/flip texture, error: {0:x}"), static_cast<uint32>(result));
             return true;
         }
-
-        // Use converted image
         SET_CURRENT_IMG(tmpImg);
     }
 
+    // Check if it invert green channel
+    if (!keepAsIs && options.InvertGreenChannel)
+    {
+        auto& timage = GET_TMP_IMG();
+        result = TransformImage(currentImage->GetImages(), currentImage->GetImageCount(), currentImage->GetMetadata(),
+            [&](DirectX::XMVECTOR* outPixels, const DirectX::XMVECTOR* inPixels, size_t w, size_t y)
+            {
+                static const DirectX::XMVECTORU32 s_selecty = { { { DirectX::XM_SELECT_0, DirectX::XM_SELECT_1, DirectX::XM_SELECT_0, DirectX::XM_SELECT_0 } } };
+
+                UNREFERENCED_PARAMETER(y);
+
+                for (size_t j = 0; j < w; ++j)
+                {
+                    const DirectX::XMVECTOR value = inPixels[j];
+
+                    const DirectX::XMVECTOR inverty = DirectX::XMVectorSubtract(DirectX::g_XMOne, value);
+
+                    outPixels[j] = DirectX::XMVectorSelect(value, inverty, s_selecty);
+                }
+            }, timage);
+        if (FAILED(result))
+        {
+            errorMsg = String::Format(TEXT("Cannot invert green channel in texture, error: {0:x}"), static_cast<uint32>(result));
+            return true;
+        }
+        SET_CURRENT_IMG(timage);
+    }
+
     // Generate mip maps chain
     if (!keepAsIs && useMipLevels && options.GenerateMipMaps)
     {
@@ -719,7 +745,6 @@ bool TextureTool::ImportTextureDirectXTex(ImageType type, const StringView& path
             errorMsg = String::Format(TEXT("Cannot generate texture mip maps chain, error: {1:x}"), *path, static_cast<uint32>(result));
             return true;
         }
-
         SET_CURRENT_IMG(tmpImg);
     }
 
diff --git a/Source/Engine/Tools/TextureTool/TextureTool.cpp b/Source/Engine/Tools/TextureTool/TextureTool.cpp
index 0f9c8729c..c2f5c62dc 100644
--- a/Source/Engine/Tools/TextureTool/TextureTool.cpp
+++ b/Source/Engine/Tools/TextureTool/TextureTool.cpp
@@ -26,7 +26,7 @@ namespace
 
 String TextureTool::Options::ToString() const
 {
-    return String::Format(TEXT("Type: {}, IsAtlas: {}, NeverStream: {}, IndependentChannels: {}, sRGB: {}, GenerateMipMaps: {}, FlipY: {}, Scale: {}, MaxSize: {}, Resize: {}, PreserveAlphaCoverage: {}, PreserveAlphaCoverageReference: {}, SizeX: {}, SizeY: {}"),
+    return String::Format(TEXT("Type: {}, IsAtlas: {}, NeverStream: {}, IndependentChannels: {}, sRGB: {}, GenerateMipMaps: {}, FlipY: {}, InvertGreen: {} Scale: {}, MaxSize: {}, Resize: {}, PreserveAlphaCoverage: {}, PreserveAlphaCoverageReference: {}, SizeX: {}, SizeY: {}"),
                           ScriptingEnum::ToString(Type),
                           IsAtlas,
                           NeverStream,
@@ -34,6 +34,7 @@ String TextureTool::Options::ToString() const
                           sRGB,
                           GenerateMipMaps,
                           FlipY,
+                          InvertGreenChannel,
                           Scale,
                           MaxSize,
                           MaxSize,
@@ -71,6 +72,9 @@ void TextureTool::Options::Serialize(SerializeStream& stream, const void* otherO
     stream.JKEY("FlipY");
     stream.Bool(FlipY);
 
+    stream.JKEY("InvertGreenChannel");
+    stream.Bool(InvertGreenChannel);
+
     stream.JKEY("Resize");
     stream.Bool(Resize);
 
@@ -128,6 +132,7 @@ void TextureTool::Options::Deserialize(DeserializeStream& stream, ISerializeModi
     sRGB = JsonTools::GetBool(stream, "sRGB", sRGB);
     GenerateMipMaps = JsonTools::GetBool(stream, "GenerateMipMaps", GenerateMipMaps);
     FlipY = JsonTools::GetBool(stream, "FlipY", FlipY);
+    InvertGreenChannel = JsonTools::GetBool(stream, "InvertGreenChannel", InvertGreenChannel);
     Resize = JsonTools::GetBool(stream, "Resize", Resize);
     PreserveAlphaCoverage = JsonTools::GetBool(stream, "PreserveAlphaCoverage", PreserveAlphaCoverage);
     PreserveAlphaCoverageReference = JsonTools::GetFloat(stream, "PreserveAlphaCoverageReference", PreserveAlphaCoverageReference);
@@ -674,6 +679,54 @@ Color TextureTool::SampleLinear(const PixelFormatSampler* sampler, const Float2&
     return Color::Lerp(Color::Lerp(v00, v01, uvFraction.X), Color::Lerp(v10, v11, uvFraction.X), uvFraction.Y);
 }
 
+PixelFormat TextureTool::ToPixelFormat(TextureFormatType format, int32 width, int32 height, bool canCompress)
+{
+    const bool canUseBlockCompression = width % 4 == 0 && height % 4 == 0;
+    if (canCompress && canUseBlockCompression)
+    {
+        switch (format)
+        {
+        case TextureFormatType::ColorRGB:
+            return PixelFormat::BC1_UNorm;
+        case TextureFormatType::ColorRGBA:
+            return PixelFormat::BC3_UNorm;
+        case TextureFormatType::NormalMap:
+            return PixelFormat::BC5_UNorm;
+        case TextureFormatType::GrayScale:
+            return PixelFormat::BC4_UNorm;
+        case TextureFormatType::HdrRGBA:
+            return PixelFormat::BC7_UNorm;
+        case TextureFormatType::HdrRGB:
+#if PLATFORM_LINUX
+            // TODO: support BC6H compression for Linux Editor
+            return PixelFormat::BC7_UNorm;
+#else
+            return PixelFormat::BC6H_Uf16;
+#endif
+        default:
+            return PixelFormat::Unknown;
+        }
+    }
+
+    switch (format)
+    {
+    case TextureFormatType::ColorRGB:
+        return PixelFormat::R8G8B8A8_UNorm;
+    case TextureFormatType::ColorRGBA:
+        return PixelFormat::R8G8B8A8_UNorm;
+    case TextureFormatType::NormalMap:
+        return PixelFormat::R16G16_UNorm;
+    case TextureFormatType::GrayScale:
+        return PixelFormat::R8_UNorm;
+    case TextureFormatType::HdrRGBA:
+        return PixelFormat::R16G16B16A16_Float;
+    case TextureFormatType::HdrRGB:
+        return PixelFormat::R11G11B10_Float;
+    default:
+        return PixelFormat::Unknown;
+    }
+}
+
 bool TextureTool::GetImageType(const StringView& path, ImageType& type)
 {
     const auto extension = FileSystem::GetExtension(path).ToLower();
diff --git a/Source/Engine/Tools/TextureTool/TextureTool.h b/Source/Engine/Tools/TextureTool/TextureTool.h
index 60e9df3af..08d2e77e7 100644
--- a/Source/Engine/Tools/TextureTool/TextureTool.h
+++ b/Source/Engine/Tools/TextureTool/TextureTool.h
@@ -57,6 +57,10 @@ API_CLASS(Namespace="FlaxEngine.Tools", Static) class FLAXENGINE_API TextureTool
         API_FIELD(Attributes="EditorOrder(70)")
         bool FlipY = false;
 
+        // True if to invert the green channel on a normal map. Good for OpenGL to DirectX conversion.
+        API_FIELD(Attributes = "EditorOrder(71)")
+        bool InvertGreenChannel = false;
+
         // Texture size scale. Allows increasing or decreasing the imported texture resolution. Default is 1.
         API_FIELD(Attributes="EditorOrder(80), Limit(0.0001f, 1000.0f, 0.01f)")
         float Scale = 1.0f;
@@ -106,14 +110,12 @@ API_CLASS(Namespace="FlaxEngine.Tools", Static) class FLAXENGINE_API TextureTool
 
 public:
 #if USE_EDITOR
-
     /// <summary>
     /// Checks whenever the given texture file contains alpha channel data with values different than solid fill of 1 (non fully opaque).
     /// </summary>
     /// <param name="path">The file path.</param>
     /// <returns>True if has alpha channel, otherwise false.</returns>
     static bool HasAlpha(const StringView& path);
-
 #endif
 
     /// <summary>
@@ -236,6 +238,8 @@ public:
     /// <returns>The sampled color (linear).</returns>
     static Color SampleLinear(const PixelFormatSampler* sampler, const Float2& uv, const void* data, const Int2& size, int32 rowPitch);
 
+    static PixelFormat ToPixelFormat(TextureFormatType format, int32 width, int32 height, bool canCompress);
+
 private:
     enum class ImageType
     {
diff --git a/Source/Engine/Tools/TextureTool/TextureTool.stb.cpp b/Source/Engine/Tools/TextureTool/TextureTool.stb.cpp
index 9fd7f554b..97fe8c198 100644
--- a/Source/Engine/Tools/TextureTool/TextureTool.stb.cpp
+++ b/Source/Engine/Tools/TextureTool/TextureTool.stb.cpp
@@ -9,7 +9,6 @@
 #include "Engine/Serialization/FileWriteStream.h"
 #include "Engine/Graphics/RenderTools.h"
 #include "Engine/Graphics/Textures/TextureData.h"
-#include "Engine/Graphics/Textures/TextureUtils.h"
 #include "Engine/Graphics/PixelFormatExtensions.h"
 #include "Engine/Platform/File.h"
 
@@ -459,7 +458,7 @@ bool TextureTool::ImportTextureStb(ImageType type, const StringView& path, Textu
     // Cache data
     float alphaThreshold = 0.3f;
     bool isPowerOfTwo = Math::IsPowerOfTwo(width) && Math::IsPowerOfTwo(height);
-    PixelFormat targetFormat = TextureUtils::ToPixelFormat(options.Type, width, height, options.Compress);
+    PixelFormat targetFormat = ToPixelFormat(options.Type, width, height, options.Compress);
     if (options.sRGB)
         targetFormat = PixelFormatExtensions::TosRGB(targetFormat);
 
diff --git a/Source/Engine/UI/GUI/CanvasScaler.cs b/Source/Engine/UI/GUI/CanvasScaler.cs
index 94936c0e2..684583c32 100644
--- a/Source/Engine/UI/GUI/CanvasScaler.cs
+++ b/Source/Engine/UI/GUI/CanvasScaler.cs
@@ -98,8 +98,8 @@ namespace FlaxEngine.GUI
         private float _scale = 1.0f;
         private float _scaleFactor = 1.0f;
         private float _physicalUnitSize = 1.0f;
-        private Float2 _resolutionMin = new Float2(1, 1);
-        private Float2 _resolutionMax = new Float2(10000, 10000);
+        private Float2 _resolutionMin = new Float2(640, 480);
+        private Float2 _resolutionMax = new Float2(7680, 4320);
 
         /// <summary>
         /// Gets the current UI scale. Computed based on the setup when performing layout.
diff --git a/Source/Engine/UI/GUI/Common/Dropdown.cs b/Source/Engine/UI/GUI/Common/Dropdown.cs
index ecca2978f..31ea87948 100644
--- a/Source/Engine/UI/GUI/Common/Dropdown.cs
+++ b/Source/Engine/UI/GUI/Common/Dropdown.cs
@@ -469,7 +469,13 @@ namespace FlaxEngine.GUI
 
             var itemsHeight = 20.0f;
             var itemsMargin = 20.0f;
-
+            // Scale height and margive with text height if needed
+            var textHeight = Font.GetFont().Height;
+            if (textHeight > itemsHeight)
+            {
+                itemsHeight = textHeight;
+                itemsMargin = textHeight;
+            }
             /*
             var itemsWidth = 40.0f;
             var font = Font.GetFont();
diff --git a/Source/Engine/UI/GUI/ContainerControl.cs b/Source/Engine/UI/GUI/ContainerControl.cs
index 69a75aacb..e5b92430f 100644
--- a/Source/Engine/UI/GUI/ContainerControl.cs
+++ b/Source/Engine/UI/GUI/ContainerControl.cs
@@ -448,6 +448,8 @@ namespace FlaxEngine.GUI
         internal virtual void AddChildInternal(Control child)
         {
             Assert.IsNotNull(child, "Invalid control.");
+            if (Parent == child)
+                throw new InvalidOperationException();
 
             // Add child
             _children.Add(child);
@@ -820,13 +822,14 @@ namespace FlaxEngine.GUI
         protected virtual void DrawChildren()
         {
             // Draw all visible child controls
+            var children = _children;
             if (_cullChildren)
             {
                 Render2D.PeekClip(out var globalClipping);
                 Render2D.PeekTransform(out var globalTransform);
-                for (int i = 0; i < _children.Count; i++)
+                for (int i = 0; i < children.Count; i++)
                 {
-                    var child = _children[i];
+                    var child = children[i];
                     if (child.Visible)
                     {
                         Matrix3x3.Multiply(ref child._cachedTransform, ref globalTransform, out var globalChildTransform);
@@ -842,9 +845,9 @@ namespace FlaxEngine.GUI
             }
             else
             {
-                for (int i = 0; i < _children.Count; i++)
+                for (int i = 0; i < children.Count; i++)
                 {
-                    var child = _children[i];
+                    var child = children[i];
                     if (child.Visible)
                     {
                         Render2D.PushTransform(ref child._cachedTransform);
diff --git a/Source/Engine/UI/GUI/Tooltip.cs b/Source/Engine/UI/GUI/Tooltip.cs
index 734fb078f..d26372f34 100644
--- a/Source/Engine/UI/GUI/Tooltip.cs
+++ b/Source/Engine/UI/GUI/Tooltip.cs
@@ -207,19 +207,20 @@ namespace FlaxEngine.GUI
         /// <inheritdoc />
         public override void Update(float deltaTime)
         {
-            // Move window with mouse location
             var mousePos = Input.MouseScreenPosition;
-            WrapPosition(ref mousePos, 10);
-            if (_window)
-                _window.Position = mousePos + new Float2(15, 10);
-
-            // Auto hide if mouse leaves control area
             var location = _showTarget.PointFromScreen(mousePos);
             if (!_showTarget.OnTestTooltipOverControl(ref location))
             {
-                // Mouse left or sth
+                // Auto hide if mouse leaves control area
                 Hide();
             }
+            else
+            {
+                // Position tooltip when mouse moves
+                WrapPosition(ref mousePos, 10);
+                if (_window)
+                    _window.Position = mousePos + new Float2(15, 10);
+            }
 
             base.Update(deltaTime);
         }
diff --git a/Source/Engine/UI/UIControl.cs b/Source/Engine/UI/UIControl.cs
index 219a4fa4e..bf78bf2fd 100644
--- a/Source/Engine/UI/UIControl.cs
+++ b/Source/Engine/UI/UIControl.cs
@@ -58,10 +58,11 @@ namespace FlaxEngine
                     if (containerControl != null && IsActiveInHierarchy)
                     {
                         var children = ChildrenCount;
+                        var parent = Parent;
                         for (int i = 0; i < children; i++)
                         {
                             var child = GetChild(i) as UIControl;
-                            if (child != null && child.IsActiveInHierarchy && child.HasControl)
+                            if (child != null && child.IsActiveInHierarchy && child.HasControl && child != parent)
                             {
                                 child.Control.Parent = containerControl;
                             }
diff --git a/Source/Engine/Visject/VisjectGraph.cpp b/Source/Engine/Visject/VisjectGraph.cpp
index 4e94473f6..64164ecec 100644
--- a/Source/Engine/Visject/VisjectGraph.cpp
+++ b/Source/Engine/Visject/VisjectGraph.cpp
@@ -1420,7 +1420,7 @@ void VisjectExecutor::ProcessGroupCollections(Box* box, Node* node, Value& value
         }
         // Sort
         case 12:
-            Sorting::QuickSort(array.Get(), array.Count());
+            Sorting::QuickSort(array);
             value = MoveTemp(v);
             break;
         // Reverse
diff --git a/Source/Platforms/Android/Binaries/Project/app/src/main/AndroidManifest.xml b/Source/Platforms/Android/Binaries/Project/app/src/main/AndroidManifest.xml
index e535cef40..5169e3846 100644
--- a/Source/Platforms/Android/Binaries/Project/app/src/main/AndroidManifest.xml
+++ b/Source/Platforms/Android/Binaries/Project/app/src/main/AndroidManifest.xml
@@ -10,7 +10,7 @@
         <activity android:name="com.flaxengine.GameActivity"
             android:label="@string/app_name"
             android:configChanges="orientation|keyboardHidden|screenSize"
-            android:screenOrientation="fullSensor">
+            android:screenOrientation="${DefaultOrientation}">
             <meta-data android:name="android.app.lib_name" android:value="FlaxGame" />
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
diff --git a/Source/Shaders/SSR.shader b/Source/Shaders/SSR.shader
index 999dd93a3..91122f2ee 100644
--- a/Source/Shaders/SSR.shader
+++ b/Source/Shaders/SSR.shader
@@ -106,17 +106,20 @@ float4 PS_RayTracePass(Quad_VS2PS input) : SV_Target0
     // SRV 7-8 Global SDF
     // SRV 9-13 Global Surface Atlas
 
+    // Base layer color with reflections from probes but empty alpha so SSR blur will have valid bacground values to smooth with
+    float4 base = float4(Texture0.SampleLevel(SamplerLinearClamp, input.TexCoord, 0).rgb, 0);
+
 	// Sample GBuffer
 	GBufferData gBufferData = GetGBufferData();
 	GBufferSample gBuffer = SampleGBuffer(gBufferData, input.TexCoord);
 
     // Reject invalid pixels
     if (gBuffer.ShadingModel == SHADING_MODEL_UNLIT || gBuffer.Roughness > RoughnessFade || gBuffer.ViewPos.z > FadeOutDistance)
-        return 0;
+        return base;
 
 	// Trace depth buffer to find intersection
 	float3 screenHit = TraceScreenSpaceReflection(input.TexCoord, gBuffer, Depth, gBufferData.ViewPos, ViewMatrix, ViewProjectionMatrix, RayTraceStep, MaxTraceSamples, TemporalEffect, TemporalTime, WorldAntiSelfOcclusionBias, BRDFBias, FadeOutDistance, RoughnessFade, EdgeFadeFactor);
-	float4 result = 0;
+	float4 result = base;
 	if (screenHit.z > 0)
 	{
 	    float3 viewVector = normalize(gBufferData.ViewPos - gBuffer.WorldPos);
diff --git a/Source/ThirdParty/meshoptimizer/LICENSE.md b/Source/ThirdParty/meshoptimizer/LICENSE.md
index 4fcd766d2..962ed41ff 100644
--- a/Source/ThirdParty/meshoptimizer/LICENSE.md
+++ b/Source/ThirdParty/meshoptimizer/LICENSE.md
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2016-2020 Arseny Kapoulkine
+Copyright (c) 2016-2023 Arseny Kapoulkine
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/Source/ThirdParty/meshoptimizer/allocator.cpp b/Source/ThirdParty/meshoptimizer/allocator.cpp
index da7cc540b..072e8e51a 100644
--- a/Source/ThirdParty/meshoptimizer/allocator.cpp
+++ b/Source/ThirdParty/meshoptimizer/allocator.cpp
@@ -1,7 +1,7 @@
 // This file is part of meshoptimizer library; see meshoptimizer.h for version/license details
 #include "meshoptimizer.h"
 
-void meshopt_setAllocator(void* (*allocate)(size_t), void (*deallocate)(void*))
+void meshopt_setAllocator(void* (MESHOPTIMIZER_ALLOC_CALLCONV *allocate)(size_t), void (MESHOPTIMIZER_ALLOC_CALLCONV *deallocate)(void*))
 {
 	meshopt_Allocator::Storage::allocate = allocate;
 	meshopt_Allocator::Storage::deallocate = deallocate;
diff --git a/Source/ThirdParty/meshoptimizer/clusterizer.cpp b/Source/ThirdParty/meshoptimizer/clusterizer.cpp
index f7d88c513..c4672ad60 100644
--- a/Source/ThirdParty/meshoptimizer/clusterizer.cpp
+++ b/Source/ThirdParty/meshoptimizer/clusterizer.cpp
@@ -2,6 +2,7 @@
 #include "meshoptimizer.h"
 
 #include <assert.h>
+#include <float.h>
 #include <math.h>
 #include <string.h>
 
@@ -12,6 +13,68 @@
 namespace meshopt
 {
 
+// This must be <= 255 since index 0xff is used internally to indice a vertex that doesn't belong to a meshlet
+const size_t kMeshletMaxVertices = 255;
+
+// A reasonable limit is around 2*max_vertices or less
+const size_t kMeshletMaxTriangles = 512;
+
+struct TriangleAdjacency2
+{
+	unsigned int* counts;
+	unsigned int* offsets;
+	unsigned int* data;
+};
+
+static void buildTriangleAdjacency(TriangleAdjacency2& adjacency, const unsigned int* indices, size_t index_count, size_t vertex_count, meshopt_Allocator& allocator)
+{
+	size_t face_count = index_count / 3;
+
+	// allocate arrays
+	adjacency.counts = allocator.allocate<unsigned int>(vertex_count);
+	adjacency.offsets = allocator.allocate<unsigned int>(vertex_count);
+	adjacency.data = allocator.allocate<unsigned int>(index_count);
+
+	// fill triangle counts
+	memset(adjacency.counts, 0, vertex_count * sizeof(unsigned int));
+
+	for (size_t i = 0; i < index_count; ++i)
+	{
+		assert(indices[i] < vertex_count);
+
+		adjacency.counts[indices[i]]++;
+	}
+
+	// fill offset table
+	unsigned int offset = 0;
+
+	for (size_t i = 0; i < vertex_count; ++i)
+	{
+		adjacency.offsets[i] = offset;
+		offset += adjacency.counts[i];
+	}
+
+	assert(offset == index_count);
+
+	// fill triangle data
+	for (size_t i = 0; i < face_count; ++i)
+	{
+		unsigned int a = indices[i * 3 + 0], b = indices[i * 3 + 1], c = indices[i * 3 + 2];
+
+		adjacency.data[adjacency.offsets[a]++] = unsigned(i);
+		adjacency.data[adjacency.offsets[b]++] = unsigned(i);
+		adjacency.data[adjacency.offsets[c]++] = unsigned(i);
+	}
+
+	// fix offsets that have been disturbed by the previous pass
+	for (size_t i = 0; i < vertex_count; ++i)
+	{
+		assert(adjacency.offsets[i] >= adjacency.counts[i]);
+
+		adjacency.offsets[i] -= adjacency.counts[i];
+	}
+}
+
 static void computeBoundingSphere(float result[4], const float points[][3], size_t count)
 {
 	assert(count > 0);
@@ -82,13 +145,382 @@ static void computeBoundingSphere(float result[4], const float points[][3], size
 	result[3] = radius;
 }
 
+struct Cone
+{
+	float px, py, pz;
+	float nx, ny, nz;
+};
+
+static float getMeshletScore(float distance2, float spread, float cone_weight, float expected_radius)
+{
+	float cone = 1.f - spread * cone_weight;
+	float cone_clamped = cone < 1e-3f ? 1e-3f : cone;
+
+	return (1 + sqrtf(distance2) / expected_radius * (1 - cone_weight)) * cone_clamped;
+}
+
+static Cone getMeshletCone(const Cone& acc, unsigned int triangle_count)
+{
+	Cone result = acc;
+
+	float center_scale = triangle_count == 0 ? 0.f : 1.f / float(triangle_count);
+
+	result.px *= center_scale;
+	result.py *= center_scale;
+	result.pz *= center_scale;
+
+	float axis_length = result.nx * result.nx + result.ny * result.ny + result.nz * result.nz;
+	float axis_scale = axis_length == 0.f ? 0.f : 1.f / sqrtf(axis_length);
+
+	result.nx *= axis_scale;
+	result.ny *= axis_scale;
+	result.nz *= axis_scale;
+
+	return result;
+}
+
+static float computeTriangleCones(Cone* triangles, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
+{
+	(void)vertex_count;
+
+	size_t vertex_stride_float = vertex_positions_stride / sizeof(float);
+	size_t face_count = index_count / 3;
+
+	float mesh_area = 0;
+
+	for (size_t i = 0; i < face_count; ++i)
+	{
+		unsigned int a = indices[i * 3 + 0], b = indices[i * 3 + 1], c = indices[i * 3 + 2];
+		assert(a < vertex_count && b < vertex_count && c < vertex_count);
+
+		const float* p0 = vertex_positions + vertex_stride_float * a;
+		const float* p1 = vertex_positions + vertex_stride_float * b;
+		const float* p2 = vertex_positions + vertex_stride_float * c;
+
+		float p10[3] = {p1[0] - p0[0], p1[1] - p0[1], p1[2] - p0[2]};
+		float p20[3] = {p2[0] - p0[0], p2[1] - p0[1], p2[2] - p0[2]};
+
+		float normalx = p10[1] * p20[2] - p10[2] * p20[1];
+		float normaly = p10[2] * p20[0] - p10[0] * p20[2];
+		float normalz = p10[0] * p20[1] - p10[1] * p20[0];
+
+		float area = sqrtf(normalx * normalx + normaly * normaly + normalz * normalz);
+		float invarea = (area == 0.f) ? 0.f : 1.f / area;
+
+		triangles[i].px = (p0[0] + p1[0] + p2[0]) / 3.f;
+		triangles[i].py = (p0[1] + p1[1] + p2[1]) / 3.f;
+		triangles[i].pz = (p0[2] + p1[2] + p2[2]) / 3.f;
+
+		triangles[i].nx = normalx * invarea;
+		triangles[i].ny = normaly * invarea;
+		triangles[i].nz = normalz * invarea;
+
+		mesh_area += area;
+	}
+
+	return mesh_area;
+}
+
+static void finishMeshlet(meshopt_Meshlet& meshlet, unsigned char* meshlet_triangles)
+{
+	size_t offset = meshlet.triangle_offset + meshlet.triangle_count * 3;
+
+	// fill 4b padding with 0
+	while (offset & 3)
+		meshlet_triangles[offset++] = 0;
+}
+
+static bool appendMeshlet(meshopt_Meshlet& meshlet, unsigned int a, unsigned int b, unsigned int c, unsigned char* used, meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, size_t meshlet_offset, size_t max_vertices, size_t max_triangles)
+{
+	unsigned char& av = used[a];
+	unsigned char& bv = used[b];
+	unsigned char& cv = used[c];
+
+	bool result = false;
+
+	unsigned int used_extra = (av == 0xff) + (bv == 0xff) + (cv == 0xff);
+
+	if (meshlet.vertex_count + used_extra > max_vertices || meshlet.triangle_count >= max_triangles)
+	{
+		meshlets[meshlet_offset] = meshlet;
+
+		for (size_t j = 0; j < meshlet.vertex_count; ++j)
+			used[meshlet_vertices[meshlet.vertex_offset + j]] = 0xff;
+
+		finishMeshlet(meshlet, meshlet_triangles);
+
+		meshlet.vertex_offset += meshlet.vertex_count;
+		meshlet.triangle_offset += (meshlet.triangle_count * 3 + 3) & ~3; // 4b padding
+		meshlet.vertex_count = 0;
+		meshlet.triangle_count = 0;
+
+		result = true;
+	}
+
+	if (av == 0xff)
+	{
+		av = (unsigned char)meshlet.vertex_count;
+		meshlet_vertices[meshlet.vertex_offset + meshlet.vertex_count++] = a;
+	}
+
+	if (bv == 0xff)
+	{
+		bv = (unsigned char)meshlet.vertex_count;
+		meshlet_vertices[meshlet.vertex_offset + meshlet.vertex_count++] = b;
+	}
+
+	if (cv == 0xff)
+	{
+		cv = (unsigned char)meshlet.vertex_count;
+		meshlet_vertices[meshlet.vertex_offset + meshlet.vertex_count++] = c;
+	}
+
+	meshlet_triangles[meshlet.triangle_offset + meshlet.triangle_count * 3 + 0] = av;
+	meshlet_triangles[meshlet.triangle_offset + meshlet.triangle_count * 3 + 1] = bv;
+	meshlet_triangles[meshlet.triangle_offset + meshlet.triangle_count * 3 + 2] = cv;
+	meshlet.triangle_count++;
+
+	return result;
+}
+
+static unsigned int getNeighborTriangle(const meshopt_Meshlet& meshlet, const Cone* meshlet_cone, unsigned int* meshlet_vertices, const unsigned int* indices, const TriangleAdjacency2& adjacency, const Cone* triangles, const unsigned int* live_triangles, const unsigned char* used, float meshlet_expected_radius, float cone_weight, unsigned int* out_extra)
+{
+	unsigned int best_triangle = ~0u;
+	unsigned int best_extra = 5;
+	float best_score = FLT_MAX;
+
+	for (size_t i = 0; i < meshlet.vertex_count; ++i)
+	{
+		unsigned int index = meshlet_vertices[meshlet.vertex_offset + i];
+
+		unsigned int* neighbors = &adjacency.data[0] + adjacency.offsets[index];
+		size_t neighbors_size = adjacency.counts[index];
+
+		for (size_t j = 0; j < neighbors_size; ++j)
+		{
+			unsigned int triangle = neighbors[j];
+			unsigned int a = indices[triangle * 3 + 0], b = indices[triangle * 3 + 1], c = indices[triangle * 3 + 2];
+
+			unsigned int extra = (used[a] == 0xff) + (used[b] == 0xff) + (used[c] == 0xff);
+
+			// triangles that don't add new vertices to meshlets are max. priority
+			if (extra != 0)
+			{
+				// artificially increase the priority of dangling triangles as they're expensive to add to new meshlets
+				if (live_triangles[a] == 1 || live_triangles[b] == 1 || live_triangles[c] == 1)
+					extra = 0;
+
+				extra++;
+			}
+
+			// since topology-based priority is always more important than the score, we can skip scoring in some cases
+			if (extra > best_extra)
+				continue;
+
+			float score = 0;
+
+			// caller selects one of two scoring functions: geometrical (based on meshlet cone) or topological (based on remaining triangles)
+			if (meshlet_cone)
+			{
+				const Cone& tri_cone = triangles[triangle];
+
+				float distance2 =
+				    (tri_cone.px - meshlet_cone->px) * (tri_cone.px - meshlet_cone->px) +
+				    (tri_cone.py - meshlet_cone->py) * (tri_cone.py - meshlet_cone->py) +
+				    (tri_cone.pz - meshlet_cone->pz) * (tri_cone.pz - meshlet_cone->pz);
+
+				float spread = tri_cone.nx * meshlet_cone->nx + tri_cone.ny * meshlet_cone->ny + tri_cone.nz * meshlet_cone->nz;
+
+				score = getMeshletScore(distance2, spread, cone_weight, meshlet_expected_radius);
+			}
+			else
+			{
+				// each live_triangles entry is >= 1 since it includes the current triangle we're processing
+				score = float(live_triangles[a] + live_triangles[b] + live_triangles[c] - 3);
+			}
+
+			// note that topology-based priority is always more important than the score
+			// this helps maintain reasonable effectiveness of meshlet data and reduces scoring cost
+			if (extra < best_extra || score < best_score)
+			{
+				best_triangle = triangle;
+				best_extra = extra;
+				best_score = score;
+			}
+		}
+	}
+
+	if (out_extra)
+		*out_extra = best_extra;
+
+	return best_triangle;
+}
+
+struct KDNode
+{
+	union
+	{
+		float split;
+		unsigned int index;
+	};
+
+	// leaves: axis = 3, children = number of extra points after this one (0 if 'index' is the only point)
+	// branches: axis != 3, left subtree = skip 1, right subtree = skip 1+children
+	unsigned int axis : 2;
+	unsigned int children : 30;
+};
+
+static size_t kdtreePartition(unsigned int* indices, size_t count, const float* points, size_t stride, unsigned int axis, float pivot)
+{
+	size_t m = 0;
+
+	// invariant: elements in range [0, m) are < pivot, elements in range [m, i) are >= pivot
+	for (size_t i = 0; i < count; ++i)
+	{
+		float v = points[indices[i] * stride + axis];
+
+		// swap(m, i) unconditionally
+		unsigned int t = indices[m];
+		indices[m] = indices[i];
+		indices[i] = t;
+
+		// when v >= pivot, we swap i with m without advancing it, preserving invariants
+		m += v < pivot;
+	}
+
+	return m;
+}
+
+static size_t kdtreeBuildLeaf(size_t offset, KDNode* nodes, size_t node_count, unsigned int* indices, size_t count)
+{
+	assert(offset + count <= node_count);
+	(void)node_count;
+
+	KDNode& result = nodes[offset];
+
+	result.index = indices[0];
+	result.axis = 3;
+	result.children = unsigned(count - 1);
+
+	// all remaining points are stored in nodes immediately following the leaf
+	for (size_t i = 1; i < count; ++i)
+	{
+		KDNode& tail = nodes[offset + i];
+
+		tail.index = indices[i];
+		tail.axis = 3;
+		tail.children = ~0u >> 2; // bogus value to prevent misuse
+	}
+
+	return offset + count;
+}
+
+static size_t kdtreeBuild(size_t offset, KDNode* nodes, size_t node_count, const float* points, size_t stride, unsigned int* indices, size_t count, size_t leaf_size)
+{
+	assert(count > 0);
+	assert(offset < node_count);
+
+	if (count <= leaf_size)
+		return kdtreeBuildLeaf(offset, nodes, node_count, indices, count);
+
+	float mean[3] = {};
+	float vars[3] = {};
+	float runc = 1, runs = 1;
+
+	// gather statistics on the points in the subtree using Welford's algorithm
+	for (size_t i = 0; i < count; ++i, runc += 1.f, runs = 1.f / runc)
+	{
+		const float* point = points + indices[i] * stride;
+
+		for (int k = 0; k < 3; ++k)
+		{
+			float delta = point[k] - mean[k];
+			mean[k] += delta * runs;
+			vars[k] += delta * (point[k] - mean[k]);
+		}
+	}
+
+	// split axis is one where the variance is largest
+	unsigned int axis = vars[0] >= vars[1] && vars[0] >= vars[2] ? 0 : vars[1] >= vars[2] ? 1 : 2;
+
+	float split = mean[axis];
+	size_t middle = kdtreePartition(indices, count, points, stride, axis, split);
+
+	// when the partition is degenerate simply consolidate the points into a single node
+	if (middle <= leaf_size / 2 || middle >= count - leaf_size / 2)
+		return kdtreeBuildLeaf(offset, nodes, node_count, indices, count);
+
+	KDNode& result = nodes[offset];
+
+	result.split = split;
+	result.axis = axis;
+
+	// left subtree is right after our node
+	size_t next_offset = kdtreeBuild(offset + 1, nodes, node_count, points, stride, indices, middle, leaf_size);
+
+	// distance to the right subtree is represented explicitly
+	result.children = unsigned(next_offset - offset - 1);
+
+	return kdtreeBuild(next_offset, nodes, node_count, points, stride, indices + middle, count - middle, leaf_size);
+}
+
+static void kdtreeNearest(KDNode* nodes, unsigned int root, const float* points, size_t stride, const unsigned char* emitted_flags, const float* position, unsigned int& result, float& limit)
+{
+	const KDNode& node = nodes[root];
+
+	if (node.axis == 3)
+	{
+		// leaf
+		for (unsigned int i = 0; i <= node.children; ++i)
+		{
+			unsigned int index = nodes[root + i].index;
+
+			if (emitted_flags[index])
+				continue;
+
+			const float* point = points + index * stride;
+
+			float distance2 =
+			    (point[0] - position[0]) * (point[0] - position[0]) +
+			    (point[1] - position[1]) * (point[1] - position[1]) +
+			    (point[2] - position[2]) * (point[2] - position[2]);
+			float distance = sqrtf(distance2);
+
+			if (distance < limit)
+			{
+				result = index;
+				limit = distance;
+			}
+		}
+	}
+	else
+	{
+		// branch; we order recursion to process the node that search position is in first
+		float delta = position[node.axis] - node.split;
+		unsigned int first = (delta <= 0) ? 0 : node.children;
+		unsigned int second = first ^ node.children;
+
+		kdtreeNearest(nodes, root + 1 + first, points, stride, emitted_flags, position, result, limit);
+
+		// only process the other node if it can have a match based on closest distance so far
+		if (fabsf(delta) <= limit)
+			kdtreeNearest(nodes, root + 1 + second, points, stride, emitted_flags, position, result, limit);
+	}
+}
+
 } // namespace meshopt
 
 size_t meshopt_buildMeshletsBound(size_t index_count, size_t max_vertices, size_t max_triangles)
 {
+	using namespace meshopt;
+
 	assert(index_count % 3 == 0);
-	assert(max_vertices >= 3);
-	assert(max_triangles >= 1);
+	assert(max_vertices >= 3 && max_vertices <= kMeshletMaxVertices);
+	assert(max_triangles >= 1 && max_triangles <= kMeshletMaxTriangles);
+	assert(max_triangles % 4 == 0); // ensures the caller will compute output space properly as index data is 4b aligned
+
+	(void)kMeshletMaxVertices;
+	(void)kMeshletMaxTriangles;
 
 	// meshlet construction is limited by max vertices and max triangles per meshlet
 	// the worst case is that the input is an unindexed stream since this equally stresses both limits
@@ -100,77 +532,181 @@ size_t meshopt_buildMeshletsBound(size_t index_count, size_t max_vertices, size_
 	return meshlet_limit_vertices > meshlet_limit_triangles ? meshlet_limit_vertices : meshlet_limit_triangles;
 }
 
-size_t meshopt_buildMeshlets(meshopt_Meshlet* destination, const unsigned int* indices, size_t index_count, size_t vertex_count, size_t max_vertices, size_t max_triangles)
+size_t meshopt_buildMeshlets(meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t max_vertices, size_t max_triangles, float cone_weight)
 {
+	using namespace meshopt;
+
 	assert(index_count % 3 == 0);
-	assert(max_vertices >= 3);
-	assert(max_triangles >= 1);
+	assert(vertex_positions_stride >= 12 && vertex_positions_stride <= 256);
+	assert(vertex_positions_stride % sizeof(float) == 0);
+
+	assert(max_vertices >= 3 && max_vertices <= kMeshletMaxVertices);
+	assert(max_triangles >= 1 && max_triangles <= kMeshletMaxTriangles);
+	assert(max_triangles % 4 == 0); // ensures the caller will compute output space properly as index data is 4b aligned
+
+	assert(cone_weight >= 0 && cone_weight <= 1);
 
 	meshopt_Allocator allocator;
 
-	meshopt_Meshlet meshlet;
-	memset(&meshlet, 0, sizeof(meshlet));
+	TriangleAdjacency2 adjacency = {};
+	buildTriangleAdjacency(adjacency, indices, index_count, vertex_count, allocator);
 
-	assert(max_vertices <= sizeof(meshlet.vertices) / sizeof(meshlet.vertices[0]));
-	assert(max_triangles <= sizeof(meshlet.indices) / 3);
+	unsigned int* live_triangles = allocator.allocate<unsigned int>(vertex_count);
+	memcpy(live_triangles, adjacency.counts, vertex_count * sizeof(unsigned int));
+
+	size_t face_count = index_count / 3;
+
+	unsigned char* emitted_flags = allocator.allocate<unsigned char>(face_count);
+	memset(emitted_flags, 0, face_count);
+
+	// for each triangle, precompute centroid & normal to use for scoring
+	Cone* triangles = allocator.allocate<Cone>(face_count);
+	float mesh_area = computeTriangleCones(triangles, indices, index_count, vertex_positions, vertex_count, vertex_positions_stride);
+
+	// assuming each meshlet is a square patch, expected radius is sqrt(expected area)
+	float triangle_area_avg = face_count == 0 ? 0.f : mesh_area / float(face_count) * 0.5f;
+	float meshlet_expected_radius = sqrtf(triangle_area_avg * max_triangles) * 0.5f;
+
+	// build a kd-tree for nearest neighbor lookup
+	unsigned int* kdindices = allocator.allocate<unsigned int>(face_count);
+	for (size_t i = 0; i < face_count; ++i)
+		kdindices[i] = unsigned(i);
+
+	KDNode* nodes = allocator.allocate<KDNode>(face_count * 2);
+	kdtreeBuild(0, nodes, face_count * 2, &triangles[0].px, sizeof(Cone) / sizeof(float), kdindices, face_count, /* leaf_size= */ 8);
 
 	// index of the vertex in the meshlet, 0xff if the vertex isn't used
 	unsigned char* used = allocator.allocate<unsigned char>(vertex_count);
 	memset(used, -1, vertex_count);
 
-	size_t offset = 0;
+	meshopt_Meshlet meshlet = {};
+	size_t meshlet_offset = 0;
+
+	Cone meshlet_cone_acc = {};
+
+	for (;;)
+	{
+		Cone meshlet_cone = getMeshletCone(meshlet_cone_acc, meshlet.triangle_count);
+
+		unsigned int best_extra = 0;
+		unsigned int best_triangle = getNeighborTriangle(meshlet, &meshlet_cone, meshlet_vertices, indices, adjacency, triangles, live_triangles, used, meshlet_expected_radius, cone_weight, &best_extra);
+
+		// if the best triangle doesn't fit into current meshlet, the spatial scoring we've used is not very meaningful, so we re-select using topological scoring
+		if (best_triangle != ~0u && (meshlet.vertex_count + best_extra > max_vertices || meshlet.triangle_count >= max_triangles))
+		{
+			best_triangle = getNeighborTriangle(meshlet, NULL, meshlet_vertices, indices, adjacency, triangles, live_triangles, used, meshlet_expected_radius, 0.f, NULL);
+		}
+
+		// when we run out of neighboring triangles we need to switch to spatial search; we currently just pick the closest triangle irrespective of connectivity
+		if (best_triangle == ~0u)
+		{
+			float position[3] = {meshlet_cone.px, meshlet_cone.py, meshlet_cone.pz};
+			unsigned int index = ~0u;
+			float limit = FLT_MAX;
+
+			kdtreeNearest(nodes, 0, &triangles[0].px, sizeof(Cone) / sizeof(float), emitted_flags, position, index, limit);
+
+			best_triangle = index;
+		}
+
+		if (best_triangle == ~0u)
+			break;
+
+		unsigned int a = indices[best_triangle * 3 + 0], b = indices[best_triangle * 3 + 1], c = indices[best_triangle * 3 + 2];
+		assert(a < vertex_count && b < vertex_count && c < vertex_count);
+
+		// add meshlet to the output; when the current meshlet is full we reset the accumulated bounds
+		if (appendMeshlet(meshlet, a, b, c, used, meshlets, meshlet_vertices, meshlet_triangles, meshlet_offset, max_vertices, max_triangles))
+		{
+			meshlet_offset++;
+			memset(&meshlet_cone_acc, 0, sizeof(meshlet_cone_acc));
+		}
+
+		live_triangles[a]--;
+		live_triangles[b]--;
+		live_triangles[c]--;
+
+		// remove emitted triangle from adjacency data
+		// this makes sure that we spend less time traversing these lists on subsequent iterations
+		for (size_t k = 0; k < 3; ++k)
+		{
+			unsigned int index = indices[best_triangle * 3 + k];
+
+			unsigned int* neighbors = &adjacency.data[0] + adjacency.offsets[index];
+			size_t neighbors_size = adjacency.counts[index];
+
+			for (size_t i = 0; i < neighbors_size; ++i)
+			{
+				unsigned int tri = neighbors[i];
+
+				if (tri == best_triangle)
+				{
+					neighbors[i] = neighbors[neighbors_size - 1];
+					adjacency.counts[index]--;
+					break;
+				}
+			}
+		}
+
+		// update aggregated meshlet cone data for scoring subsequent triangles
+		meshlet_cone_acc.px += triangles[best_triangle].px;
+		meshlet_cone_acc.py += triangles[best_triangle].py;
+		meshlet_cone_acc.pz += triangles[best_triangle].pz;
+		meshlet_cone_acc.nx += triangles[best_triangle].nx;
+		meshlet_cone_acc.ny += triangles[best_triangle].ny;
+		meshlet_cone_acc.nz += triangles[best_triangle].nz;
+
+		emitted_flags[best_triangle] = 1;
+	}
+
+	if (meshlet.triangle_count)
+	{
+		finishMeshlet(meshlet, meshlet_triangles);
+
+		meshlets[meshlet_offset++] = meshlet;
+	}
+
+	assert(meshlet_offset <= meshopt_buildMeshletsBound(index_count, max_vertices, max_triangles));
+	return meshlet_offset;
+}
+
+size_t meshopt_buildMeshletsScan(meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const unsigned int* indices, size_t index_count, size_t vertex_count, size_t max_vertices, size_t max_triangles)
+{
+	using namespace meshopt;
+
+	assert(index_count % 3 == 0);
+
+	assert(max_vertices >= 3 && max_vertices <= kMeshletMaxVertices);
+	assert(max_triangles >= 1 && max_triangles <= kMeshletMaxTriangles);
+	assert(max_triangles % 4 == 0); // ensures the caller will compute output space properly as index data is 4b aligned
+
+	meshopt_Allocator allocator;
+
+	// index of the vertex in the meshlet, 0xff if the vertex isn't used
+	unsigned char* used = allocator.allocate<unsigned char>(vertex_count);
+	memset(used, -1, vertex_count);
+
+	meshopt_Meshlet meshlet = {};
+	size_t meshlet_offset = 0;
 
 	for (size_t i = 0; i < index_count; i += 3)
 	{
 		unsigned int a = indices[i + 0], b = indices[i + 1], c = indices[i + 2];
 		assert(a < vertex_count && b < vertex_count && c < vertex_count);
 
-		unsigned char& av = used[a];
-		unsigned char& bv = used[b];
-		unsigned char& cv = used[c];
-
-		unsigned int used_extra = (av == 0xff) + (bv == 0xff) + (cv == 0xff);
-
-		if (meshlet.vertex_count + used_extra > max_vertices || meshlet.triangle_count >= max_triangles)
-		{
-			destination[offset++] = meshlet;
-
-			for (size_t j = 0; j < meshlet.vertex_count; ++j)
-				used[meshlet.vertices[j]] = 0xff;
-
-			memset(&meshlet, 0, sizeof(meshlet));
-		}
-
-		if (av == 0xff)
-		{
-			av = meshlet.vertex_count;
-			meshlet.vertices[meshlet.vertex_count++] = a;
-		}
-
-		if (bv == 0xff)
-		{
-			bv = meshlet.vertex_count;
-			meshlet.vertices[meshlet.vertex_count++] = b;
-		}
-
-		if (cv == 0xff)
-		{
-			cv = meshlet.vertex_count;
-			meshlet.vertices[meshlet.vertex_count++] = c;
-		}
-
-		meshlet.indices[meshlet.triangle_count][0] = av;
-		meshlet.indices[meshlet.triangle_count][1] = bv;
-		meshlet.indices[meshlet.triangle_count][2] = cv;
-		meshlet.triangle_count++;
+		// appends triangle to the meshlet and writes previous meshlet to the output if full
+		meshlet_offset += appendMeshlet(meshlet, a, b, c, used, meshlets, meshlet_vertices, meshlet_triangles, meshlet_offset, max_vertices, max_triangles);
 	}
 
 	if (meshlet.triangle_count)
-		destination[offset++] = meshlet;
+	{
+		finishMeshlet(meshlet, meshlet_triangles);
 
-	assert(offset <= meshopt_buildMeshletsBound(index_count, max_vertices, max_triangles));
+		meshlets[meshlet_offset++] = meshlet;
+	}
 
-	return offset;
+	assert(meshlet_offset <= meshopt_buildMeshletsBound(index_count, max_vertices, max_triangles));
+	return meshlet_offset;
 }
 
 meshopt_Bounds meshopt_computeClusterBounds(const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
@@ -178,18 +714,17 @@ meshopt_Bounds meshopt_computeClusterBounds(const unsigned int* indices, size_t
 	using namespace meshopt;
 
 	assert(index_count % 3 == 0);
-	assert(vertex_positions_stride > 0 && vertex_positions_stride <= 256);
+	assert(index_count / 3 <= kMeshletMaxTriangles);
+	assert(vertex_positions_stride >= 12 && vertex_positions_stride <= 256);
 	assert(vertex_positions_stride % sizeof(float) == 0);
 
-	assert(index_count / 3 <= 256);
-
 	(void)vertex_count;
 
 	size_t vertex_stride_float = vertex_positions_stride / sizeof(float);
 
 	// compute triangle normals and gather triangle corners
-	float normals[256][3];
-	float corners[256][3][3];
+	float normals[kMeshletMaxTriangles][3];
+	float corners[kMeshletMaxTriangles][3][3];
 	size_t triangles = 0;
 
 	for (size_t i = 0; i < index_count; i += 3)
@@ -327,25 +862,23 @@ meshopt_Bounds meshopt_computeClusterBounds(const unsigned int* indices, size_t
 	return bounds;
 }
 
-meshopt_Bounds meshopt_computeMeshletBounds(const meshopt_Meshlet* meshlet, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
+meshopt_Bounds meshopt_computeMeshletBounds(const unsigned int* meshlet_vertices, const unsigned char* meshlet_triangles, size_t triangle_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
 {
-	assert(vertex_positions_stride > 0 && vertex_positions_stride <= 256);
+	using namespace meshopt;
+
+	assert(triangle_count <= kMeshletMaxTriangles);
+	assert(vertex_positions_stride >= 12 && vertex_positions_stride <= 256);
 	assert(vertex_positions_stride % sizeof(float) == 0);
 
-	unsigned int indices[sizeof(meshlet->indices) / sizeof(meshlet->indices[0][0])];
+	unsigned int indices[kMeshletMaxTriangles * 3];
 
-	for (size_t i = 0; i < meshlet->triangle_count; ++i)
+	for (size_t i = 0; i < triangle_count * 3; ++i)
 	{
-		unsigned int a = meshlet->vertices[meshlet->indices[i][0]];
-		unsigned int b = meshlet->vertices[meshlet->indices[i][1]];
-		unsigned int c = meshlet->vertices[meshlet->indices[i][2]];
+		unsigned int index = meshlet_vertices[meshlet_triangles[i]];
+		assert(index < vertex_count);
 
-		assert(a < vertex_count && b < vertex_count && c < vertex_count);
-
-		indices[i * 3 + 0] = a;
-		indices[i * 3 + 1] = b;
-		indices[i * 3 + 2] = c;
+		indices[i] = index;
 	}
 
-	return meshopt_computeClusterBounds(indices, meshlet->triangle_count * 3, vertex_positions, vertex_count, vertex_positions_stride);
+	return meshopt_computeClusterBounds(indices, triangle_count * 3, vertex_positions, vertex_count, vertex_positions_stride);
 }
diff --git a/Source/ThirdParty/meshoptimizer/indexcodec.cpp b/Source/ThirdParty/meshoptimizer/indexcodec.cpp
index eeb541e5b..4cc2fea63 100644
--- a/Source/ThirdParty/meshoptimizer/indexcodec.cpp
+++ b/Source/ThirdParty/meshoptimizer/indexcodec.cpp
@@ -4,14 +4,6 @@
 #include <assert.h>
 #include <string.h>
 
-#ifndef TRACE
-#define TRACE 0
-#endif
-
-#if TRACE
-#include <stdio.h>
-#endif
-
 // This work is based on:
 // Fabian Giesen. Simple lossless index buffer compression & follow-up. 2013
 // Conor Stokes. Vertex Cache Optimised Index Buffer Compression. 2014
@@ -21,7 +13,7 @@ namespace meshopt
 const unsigned char kIndexHeader = 0xe0;
 const unsigned char kSequenceHeader = 0xd0;
 
-static int gEncodeIndexVersion = 0;
+static int gEncodeIndexVersion = 1;
 
 typedef unsigned int VertexFifo[16];
 typedef unsigned int EdgeFifo[16][2];
@@ -116,7 +108,7 @@ static unsigned int decodeVByte(const unsigned char*& data)
 	for (int i = 0; i < 4; ++i)
 	{
 		unsigned char group = *data++;
-		result |= (group & 127) << shift;
+		result |= unsigned(group & 127) << shift;
 		shift += 7;
 
 		if (group < 128)
@@ -167,38 +159,6 @@ static void writeTriangle(void* destination, size_t offset, size_t index_size, u
 	}
 }
 
-#if TRACE
-static size_t sortTop16(unsigned char dest[16], size_t stats[256])
-{
-	size_t destsize = 0;
-
-	for (size_t i = 0; i < 256; ++i)
-	{
-		size_t j = 0;
-		for (; j < destsize; ++j)
-		{
-			if (stats[i] >= stats[dest[j]])
-			{
-				if (destsize < 16)
-					destsize++;
-
-				memmove(&dest[j + 1], &dest[j], destsize - 1 - j);
-				dest[j] = (unsigned char)i;
-				break;
-			}
-		}
-
-		if (j == destsize && destsize < 16)
-		{
-			dest[destsize] = (unsigned char)i;
-			destsize++;
-		}
-	}
-
-	return destsize;
-}
-#endif
-
 } // namespace meshopt
 
 size_t meshopt_encodeIndexBuffer(unsigned char* buffer, size_t buffer_size, const unsigned int* indices, size_t index_count)
@@ -207,11 +167,6 @@ size_t meshopt_encodeIndexBuffer(unsigned char* buffer, size_t buffer_size, cons
 
 	assert(index_count % 3 == 0);
 
-#if TRACE
-	size_t codestats[256] = {};
-	size_t codeauxstats[256] = {};
-#endif
-
 	// the minimum valid encoding is header, 1 byte per triangle and a 16-byte codeaux table
 	if (buffer_size < 1 + index_count / 3 + 16)
 		return 0;
@@ -275,10 +230,6 @@ size_t meshopt_encodeIndexBuffer(unsigned char* buffer, size_t buffer_size, cons
 
 			*code++ = (unsigned char)((fe << 4) | fec);
 
-#if TRACE
-			codestats[code[-1]]++;
-#endif
-
 			// note that we need to update the last index since free indices are delta-encoded
 			if (fec == 15)
 				encodeIndex(data, c, last), last = c;
@@ -334,11 +285,6 @@ size_t meshopt_encodeIndexBuffer(unsigned char* buffer, size_t buffer_size, cons
 				*data++ = codeaux;
 			}
 
-#if TRACE
-			codestats[code[-1]]++;
-			codeauxstats[codeaux]++;
-#endif
-
 			// note that we need to update the last index since free indices are delta-encoded
 			if (fea == 15)
 				encodeIndex(data, a, last), last = a;
@@ -387,30 +333,6 @@ size_t meshopt_encodeIndexBuffer(unsigned char* buffer, size_t buffer_size, cons
 	assert(data >= buffer + index_count / 3 + 16);
 	assert(data <= buffer + buffer_size);
 
-#if TRACE
-	unsigned char codetop[16], codeauxtop[16];
-	size_t codetopsize = sortTop16(codetop, codestats);
-	size_t codeauxtopsize = sortTop16(codeauxtop, codeauxstats);
-
-	size_t sumcode = 0, sumcodeaux = 0;
-	for (size_t i = 0; i < 256; ++i)
-		sumcode += codestats[i], sumcodeaux += codeauxstats[i];
-
-	size_t acccode = 0, acccodeaux = 0;
-
-	printf("code\t\t\t\t\tcodeaux\n");
-
-	for (size_t i = 0; i < codetopsize && i < codeauxtopsize; ++i)
-	{
-		acccode += codestats[codetop[i]];
-		acccodeaux += codeauxstats[codeauxtop[i]];
-
-		printf("%2d: %02x = %d (%.1f%% ..%.1f%%)\t\t%2d: %02x = %d (%.1f%% ..%.1f%%)\n",
-		       int(i), codetop[i], int(codestats[codetop[i]]), double(codestats[codetop[i]]) / double(sumcode) * 100, double(acccode) / double(sumcode) * 100,
-		       int(i), codeauxtop[i], int(codeauxstats[codeauxtop[i]]), double(codeauxstats[codeauxtop[i]]) / double(sumcodeaux) * 100, double(acccodeaux) / double(sumcodeaux) * 100);
-	}
-#endif
-
 	return data - buffer;
 }
 
diff --git a/Source/ThirdParty/meshoptimizer/indexgenerator.cpp b/Source/ThirdParty/meshoptimizer/indexgenerator.cpp
index aa4a30efa..f6728345a 100644
--- a/Source/ThirdParty/meshoptimizer/indexgenerator.cpp
+++ b/Source/ThirdParty/meshoptimizer/indexgenerator.cpp
@@ -4,6 +4,8 @@
 #include <assert.h>
 #include <string.h>
 
+// This work is based on:
+// John McDonald, Mark Kilgard. Crack-Free Point-Normal Triangles using Adjacent Edge Normals. 2010
 namespace meshopt
 {
 
@@ -83,10 +85,49 @@ struct VertexStreamHasher
 	}
 };
 
+struct EdgeHasher
+{
+	const unsigned int* remap;
+
+	size_t hash(unsigned long long edge) const
+	{
+		unsigned int e0 = unsigned(edge >> 32);
+		unsigned int e1 = unsigned(edge);
+
+		unsigned int h1 = remap[e0];
+		unsigned int h2 = remap[e1];
+
+		const unsigned int m = 0x5bd1e995;
+
+		// MurmurHash64B finalizer
+		h1 ^= h2 >> 18;
+		h1 *= m;
+		h2 ^= h1 >> 22;
+		h2 *= m;
+		h1 ^= h2 >> 17;
+		h1 *= m;
+		h2 ^= h1 >> 19;
+		h2 *= m;
+
+		return h2;
+	}
+
+	bool equal(unsigned long long lhs, unsigned long long rhs) const
+	{
+		unsigned int l0 = unsigned(lhs >> 32);
+		unsigned int l1 = unsigned(lhs);
+
+		unsigned int r0 = unsigned(rhs >> 32);
+		unsigned int r1 = unsigned(rhs);
+
+		return remap[l0] == remap[r0] && remap[l1] == remap[r1];
+	}
+};
+
 static size_t hashBuckets(size_t count)
 {
 	size_t buckets = 1;
-	while (buckets < count)
+	while (buckets < count + count / 4)
 		buckets *= 2;
 
 	return buckets;
@@ -116,7 +157,43 @@ static T* hashLookup(T* table, size_t buckets, const Hash& hash, const T& key, c
 	}
 
 	assert(false && "Hash table is full"); // unreachable
-	return 0;
+	return NULL;
+}
+
+static void buildPositionRemap(unsigned int* remap, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, meshopt_Allocator& allocator)
+{
+	VertexHasher vertex_hasher = {reinterpret_cast<const unsigned char*>(vertex_positions), 3 * sizeof(float), vertex_positions_stride};
+
+	size_t vertex_table_size = hashBuckets(vertex_count);
+	unsigned int* vertex_table = allocator.allocate<unsigned int>(vertex_table_size);
+	memset(vertex_table, -1, vertex_table_size * sizeof(unsigned int));
+
+	for (size_t i = 0; i < vertex_count; ++i)
+	{
+		unsigned int index = unsigned(i);
+		unsigned int* entry = hashLookup(vertex_table, vertex_table_size, vertex_hasher, index, ~0u);
+
+		if (*entry == ~0u)
+			*entry = index;
+
+		remap[index] = *entry;
+	}
+
+	allocator.deallocate(vertex_table);
+}
+
+template <size_t BlockSize>
+static void remapVertices(void* destination, const void* vertices, size_t vertex_count, size_t vertex_size, const unsigned int* remap)
+{
+	size_t block_size = BlockSize == 0 ? vertex_size : BlockSize;
+	assert(block_size == vertex_size);
+
+	for (size_t i = 0; i < vertex_count; ++i)
+		if (remap[i] != ~0u)
+		{
+			assert(remap[i] < vertex_count);
+			memcpy(static_cast<unsigned char*>(destination) + remap[i] * block_size, static_cast<const unsigned char*>(vertices) + i * block_size, block_size);
+		}
 }
 
 } // namespace meshopt
@@ -126,7 +203,7 @@ size_t meshopt_generateVertexRemap(unsigned int* destination, const unsigned int
 	using namespace meshopt;
 
 	assert(indices || index_count == vertex_count);
-	assert(index_count % 3 == 0);
+	assert(!indices || index_count % 3 == 0);
 	assert(vertex_size > 0 && vertex_size <= 256);
 
 	meshopt_Allocator allocator;
@@ -227,6 +304,8 @@ size_t meshopt_generateVertexRemapMulti(unsigned int* destination, const unsigne
 
 void meshopt_remapVertexBuffer(void* destination, const void* vertices, size_t vertex_count, size_t vertex_size, const unsigned int* remap)
 {
+	using namespace meshopt;
+
 	assert(vertex_size > 0 && vertex_size <= 256);
 
 	meshopt_Allocator allocator;
@@ -239,14 +318,23 @@ void meshopt_remapVertexBuffer(void* destination, const void* vertices, size_t v
 		vertices = vertices_copy;
 	}
 
-	for (size_t i = 0; i < vertex_count; ++i)
+	// specialize the loop for common vertex sizes to ensure memcpy is compiled as an inlined intrinsic
+	switch (vertex_size)
 	{
-		if (remap[i] != ~0u)
-		{
-			assert(remap[i] < vertex_count);
+	case 4:
+		return remapVertices<4>(destination, vertices, vertex_count, vertex_size, remap);
 
-			memcpy(static_cast<unsigned char*>(destination) + remap[i] * vertex_size, static_cast<const unsigned char*>(vertices) + i * vertex_size, vertex_size);
-		}
+	case 8:
+		return remapVertices<8>(destination, vertices, vertex_count, vertex_size, remap);
+
+	case 12:
+		return remapVertices<12>(destination, vertices, vertex_count, vertex_size, remap);
+
+	case 16:
+		return remapVertices<16>(destination, vertices, vertex_count, vertex_size, remap);
+
+	default:
+		return remapVertices<0>(destination, vertices, vertex_count, vertex_size, remap);
 	}
 }
 
@@ -345,3 +433,146 @@ void meshopt_generateShadowIndexBufferMulti(unsigned int* destination, const uns
 		destination[i] = remap[index];
 	}
 }
+
+void meshopt_generateAdjacencyIndexBuffer(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
+{
+	using namespace meshopt;
+
+	assert(index_count % 3 == 0);
+	assert(vertex_positions_stride >= 12 && vertex_positions_stride <= 256);
+	assert(vertex_positions_stride % sizeof(float) == 0);
+
+	meshopt_Allocator allocator;
+
+	static const int next[4] = {1, 2, 0, 1};
+
+	// build position remap: for each vertex, which other (canonical) vertex does it map to?
+	unsigned int* remap = allocator.allocate<unsigned int>(vertex_count);
+	buildPositionRemap(remap, vertex_positions, vertex_count, vertex_positions_stride, allocator);
+
+	// build edge set; this stores all triangle edges but we can look these up by any other wedge
+	EdgeHasher edge_hasher = {remap};
+
+	size_t edge_table_size = hashBuckets(index_count);
+	unsigned long long* edge_table = allocator.allocate<unsigned long long>(edge_table_size);
+	unsigned int* edge_vertex_table = allocator.allocate<unsigned int>(edge_table_size);
+
+	memset(edge_table, -1, edge_table_size * sizeof(unsigned long long));
+	memset(edge_vertex_table, -1, edge_table_size * sizeof(unsigned int));
+
+	for (size_t i = 0; i < index_count; i += 3)
+	{
+		for (int e = 0; e < 3; ++e)
+		{
+			unsigned int i0 = indices[i + e];
+			unsigned int i1 = indices[i + next[e]];
+			unsigned int i2 = indices[i + next[e + 1]];
+			assert(i0 < vertex_count && i1 < vertex_count && i2 < vertex_count);
+
+			unsigned long long edge = ((unsigned long long)i0 << 32) | i1;
+			unsigned long long* entry = hashLookup(edge_table, edge_table_size, edge_hasher, edge, ~0ull);
+
+			if (*entry == ~0ull)
+			{
+				*entry = edge;
+
+				// store vertex opposite to the edge
+				edge_vertex_table[entry - edge_table] = i2;
+			}
+		}
+	}
+
+	// build resulting index buffer: 6 indices for each input triangle
+	for (size_t i = 0; i < index_count; i += 3)
+	{
+		unsigned int patch[6];
+
+		for (int e = 0; e < 3; ++e)
+		{
+			unsigned int i0 = indices[i + e];
+			unsigned int i1 = indices[i + next[e]];
+			assert(i0 < vertex_count && i1 < vertex_count);
+
+			// note: this refers to the opposite edge!
+			unsigned long long edge = ((unsigned long long)i1 << 32) | i0;
+			unsigned long long* oppe = hashLookup(edge_table, edge_table_size, edge_hasher, edge, ~0ull);
+
+			patch[e * 2 + 0] = i0;
+			patch[e * 2 + 1] = (*oppe == ~0ull) ? i0 : edge_vertex_table[oppe - edge_table];
+		}
+
+		memcpy(destination + i * 2, patch, sizeof(patch));
+	}
+}
+
+void meshopt_generateTessellationIndexBuffer(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
+{
+	using namespace meshopt;
+
+	assert(index_count % 3 == 0);
+	assert(vertex_positions_stride >= 12 && vertex_positions_stride <= 256);
+	assert(vertex_positions_stride % sizeof(float) == 0);
+
+	meshopt_Allocator allocator;
+
+	static const int next[3] = {1, 2, 0};
+
+	// build position remap: for each vertex, which other (canonical) vertex does it map to?
+	unsigned int* remap = allocator.allocate<unsigned int>(vertex_count);
+	buildPositionRemap(remap, vertex_positions, vertex_count, vertex_positions_stride, allocator);
+
+	// build edge set; this stores all triangle edges but we can look these up by any other wedge
+	EdgeHasher edge_hasher = {remap};
+
+	size_t edge_table_size = hashBuckets(index_count);
+	unsigned long long* edge_table = allocator.allocate<unsigned long long>(edge_table_size);
+	memset(edge_table, -1, edge_table_size * sizeof(unsigned long long));
+
+	for (size_t i = 0; i < index_count; i += 3)
+	{
+		for (int e = 0; e < 3; ++e)
+		{
+			unsigned int i0 = indices[i + e];
+			unsigned int i1 = indices[i + next[e]];
+			assert(i0 < vertex_count && i1 < vertex_count);
+
+			unsigned long long edge = ((unsigned long long)i0 << 32) | i1;
+			unsigned long long* entry = hashLookup(edge_table, edge_table_size, edge_hasher, edge, ~0ull);
+
+			if (*entry == ~0ull)
+				*entry = edge;
+		}
+	}
+
+	// build resulting index buffer: 12 indices for each input triangle
+	for (size_t i = 0; i < index_count; i += 3)
+	{
+		unsigned int patch[12];
+
+		for (int e = 0; e < 3; ++e)
+		{
+			unsigned int i0 = indices[i + e];
+			unsigned int i1 = indices[i + next[e]];
+			assert(i0 < vertex_count && i1 < vertex_count);
+
+			// note: this refers to the opposite edge!
+			unsigned long long edge = ((unsigned long long)i1 << 32) | i0;
+			unsigned long long oppe = *hashLookup(edge_table, edge_table_size, edge_hasher, edge, ~0ull);
+
+			// use the same edge if opposite edge doesn't exist (border)
+			oppe = (oppe == ~0ull) ? edge : oppe;
+
+			// triangle index (0, 1, 2)
+			patch[e] = i0;
+
+			// opposite edge (3, 4; 5, 6; 7, 8)
+			patch[3 + e * 2 + 0] = unsigned(oppe);
+			patch[3 + e * 2 + 1] = unsigned(oppe >> 32);
+
+			// dominant vertex (9, 10, 11)
+			patch[9 + e] = remap[i0];
+		}
+
+		memcpy(destination + i * 4, patch, sizeof(patch));
+	}
+}
diff --git a/Source/ThirdParty/meshoptimizer/meshoptimizer.h b/Source/ThirdParty/meshoptimizer/meshoptimizer.h
index cb030ea29..dbafd4e6e 100644
--- a/Source/ThirdParty/meshoptimizer/meshoptimizer.h
+++ b/Source/ThirdParty/meshoptimizer/meshoptimizer.h
@@ -1,7 +1,7 @@
 /**
- * meshoptimizer - version 0.14
+ * meshoptimizer - version 0.20
  *
- * Copyright (C) 2016-2020, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+ * Copyright (C) 2016-2023, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
  * Report bugs and download new versions at https://github.com/zeux/meshoptimizer
  *
  * This library is distributed under the MIT License. See notice at the end of this file.
@@ -12,13 +12,22 @@
 #include <stddef.h>
 
 /* Version macro; major * 1000 + minor * 10 + patch */
-#define MESHOPTIMIZER_VERSION 140
+#define MESHOPTIMIZER_VERSION 200 /* 0.20 */
 
 /* If no API is defined, assume default */
 #ifndef MESHOPTIMIZER_API
 #define MESHOPTIMIZER_API
 #endif
 
+/* Set the calling-convention for alloc/dealloc function pointers */
+#ifndef MESHOPTIMIZER_ALLOC_CALLCONV
+#ifdef _MSC_VER
+#define MESHOPTIMIZER_ALLOC_CALLCONV __cdecl
+#else
+#define MESHOPTIMIZER_ALLOC_CALLCONV
+#endif
+#endif
+
 /* Experimental APIs have unstable interface and might have implementation that's not fully tested or optimized */
 #define MESHOPTIMIZER_EXPERIMENTAL MESHOPTIMIZER_API
 
@@ -28,8 +37,8 @@ extern "C" {
 #endif
 
 /**
- * Vertex attribute stream, similar to glVertexPointer
- * Each element takes size bytes, with stride controlling the spacing between successive elements.
+ * Vertex attribute stream
+ * Each element takes size bytes, beginning at data, with stride controlling the spacing between successive elements (stride >= size).
  */
 struct meshopt_Stream
 {
@@ -42,6 +51,7 @@ struct meshopt_Stream
  * Generates a vertex remap table from the vertex buffer and an optional index buffer and returns number of unique vertices
  * As a result, all vertices that are binary equivalent map to the same (new) location, with no gaps in the resulting sequence.
  * Resulting remap table maps old vertices to new vertices and can be used in meshopt_remapVertexBuffer/meshopt_remapIndexBuffer.
+ * Note that binary equivalence considers all vertex_size bytes, including padding which should be zero-initialized.
  *
  * destination must contain enough space for the resulting remap table (vertex_count elements)
  * indices can be NULL if the input is unindexed
@@ -53,9 +63,11 @@ MESHOPTIMIZER_API size_t meshopt_generateVertexRemap(unsigned int* destination,
  * As a result, all vertices that are binary equivalent map to the same (new) location, with no gaps in the resulting sequence.
  * Resulting remap table maps old vertices to new vertices and can be used in meshopt_remapVertexBuffer/meshopt_remapIndexBuffer.
  * To remap vertex buffers, you will need to call meshopt_remapVertexBuffer for each vertex stream.
+ * Note that binary equivalence considers all size bytes in each stream, including padding which should be zero-initialized.
  *
  * destination must contain enough space for the resulting remap table (vertex_count elements)
  * indices can be NULL if the input is unindexed
+ * stream_count must be <= 16
  */
 MESHOPTIMIZER_API size_t meshopt_generateVertexRemapMulti(unsigned int* destination, const unsigned int* indices, size_t index_count, size_t vertex_count, const struct meshopt_Stream* streams, size_t stream_count);
 
@@ -79,6 +91,7 @@ MESHOPTIMIZER_API void meshopt_remapIndexBuffer(unsigned int* destination, const
  * Generate index buffer that can be used for more efficient rendering when only a subset of the vertex attributes is necessary
  * All vertices that are binary equivalent (wrt first vertex_size bytes) map to the first vertex in the original vertex buffer.
  * This makes it possible to use the index buffer for Z pre-pass or shadowmap rendering, while using the original index buffer for regular rendering.
+ * Note that binary equivalence considers all vertex_size bytes, including padding which should be zero-initialized.
  *
  * destination must contain enough space for the resulting index buffer (index_count elements)
  */
@@ -88,11 +101,42 @@ MESHOPTIMIZER_API void meshopt_generateShadowIndexBuffer(unsigned int* destinati
  * Generate index buffer that can be used for more efficient rendering when only a subset of the vertex attributes is necessary
  * All vertices that are binary equivalent (wrt specified streams) map to the first vertex in the original vertex buffer.
  * This makes it possible to use the index buffer for Z pre-pass or shadowmap rendering, while using the original index buffer for regular rendering.
+ * Note that binary equivalence considers all size bytes in each stream, including padding which should be zero-initialized.
  *
  * destination must contain enough space for the resulting index buffer (index_count elements)
+ * stream_count must be <= 16
  */
 MESHOPTIMIZER_API void meshopt_generateShadowIndexBufferMulti(unsigned int* destination, const unsigned int* indices, size_t index_count, size_t vertex_count, const struct meshopt_Stream* streams, size_t stream_count);
 
+/**
+ * Generate index buffer that can be used as a geometry shader input with triangle adjacency topology
+ * Each triangle is converted into a 6-vertex patch with the following layout:
+ * - 0, 2, 4: original triangle vertices
+ * - 1, 3, 5: vertices adjacent to edges 02, 24 and 40
+ * The resulting patch can be rendered with geometry shaders using e.g. VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY.
+ * This can be used to implement algorithms like silhouette detection/expansion and other forms of GS-driven rendering.
+ *
+ * destination must contain enough space for the resulting index buffer (index_count*2 elements)
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex
+ */
+MESHOPTIMIZER_API void meshopt_generateAdjacencyIndexBuffer(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
+
+/**
+ * Generate index buffer that can be used for PN-AEN tessellation with crack-free displacement
+ * Each triangle is converted into a 12-vertex patch with the following layout:
+ * - 0, 1, 2: original triangle vertices
+ * - 3, 4: opposing edge for edge 0, 1
+ * - 5, 6: opposing edge for edge 1, 2
+ * - 7, 8: opposing edge for edge 2, 0
+ * - 9, 10, 11: dominant vertices for corners 0, 1, 2
+ * The resulting patch can be rendered with hardware tessellation using PN-AEN and displacement mapping.
+ * See "Tessellation on Any Budget" (John McDonald, GDC 2011) for implementation details.
+ *
+ * destination must contain enough space for the resulting index buffer (index_count*4 elements)
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex
+ */
+MESHOPTIMIZER_API void meshopt_generateTessellationIndexBuffer(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
+
 /**
  * Vertex transform cache optimizer
  * Reorders indices to reduce the number of GPU vertex shader invocations
@@ -129,7 +173,7 @@ MESHOPTIMIZER_API void meshopt_optimizeVertexCacheFifo(unsigned int* destination
  *
  * destination must contain enough space for the resulting index buffer (index_count elements)
  * indices must contain index data that is the result of meshopt_optimizeVertexCache (*not* the original mesh indices!)
- * vertex_positions should have float3 position in the first 12 bytes of each vertex - similar to glVertexPointer
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex
  * threshold indicates how much the overdraw optimizer can degrade vertex cache efficiency (1.05 = up to 5%) to reduce overdraw more efficiently
  */
 MESHOPTIMIZER_API void meshopt_optimizeOverdraw(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, float threshold);
@@ -168,10 +212,10 @@ MESHOPTIMIZER_API size_t meshopt_encodeIndexBuffer(unsigned char* buffer, size_t
 MESHOPTIMIZER_API size_t meshopt_encodeIndexBufferBound(size_t index_count, size_t vertex_count);
 
 /**
- * Experimental: Set index encoder format version
+ * Set index encoder format version
  * version must specify the data format version to encode; valid values are 0 (decodable by all library versions) and 1 (decodable by 0.14+)
  */
-MESHOPTIMIZER_EXPERIMENTAL void meshopt_encodeIndexVersion(int version);
+MESHOPTIMIZER_API void meshopt_encodeIndexVersion(int version);
 
 /**
  * Index buffer decoder
@@ -184,15 +228,15 @@ MESHOPTIMIZER_EXPERIMENTAL void meshopt_encodeIndexVersion(int version);
 MESHOPTIMIZER_API int meshopt_decodeIndexBuffer(void* destination, size_t index_count, size_t index_size, const unsigned char* buffer, size_t buffer_size);
 
 /**
- * Experimental: Index sequence encoder
+ * Index sequence encoder
  * Encodes index sequence into an array of bytes that is generally smaller and compresses better compared to original.
  * Input index sequence can represent arbitrary topology; for triangle lists meshopt_encodeIndexBuffer is likely to be better.
  * Returns encoded data size on success, 0 on error; the only error condition is if buffer doesn't have enough space
  *
  * buffer must contain enough space for the encoded index sequence (use meshopt_encodeIndexSequenceBound to compute worst case size)
  */
-MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_encodeIndexSequence(unsigned char* buffer, size_t buffer_size, const unsigned int* indices, size_t index_count);
-MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_encodeIndexSequenceBound(size_t index_count, size_t vertex_count);
+MESHOPTIMIZER_API size_t meshopt_encodeIndexSequence(unsigned char* buffer, size_t buffer_size, const unsigned int* indices, size_t index_count);
+MESHOPTIMIZER_API size_t meshopt_encodeIndexSequenceBound(size_t index_count, size_t vertex_count);
 
 /**
  * Index sequence decoder
@@ -202,13 +246,14 @@ MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_encodeIndexSequenceBound(size_t index_
  *
  * destination must contain enough space for the resulting index sequence (index_count elements)
  */
-MESHOPTIMIZER_EXPERIMENTAL int meshopt_decodeIndexSequence(void* destination, size_t index_count, size_t index_size, const unsigned char* buffer, size_t buffer_size);
+MESHOPTIMIZER_API int meshopt_decodeIndexSequence(void* destination, size_t index_count, size_t index_size, const unsigned char* buffer, size_t buffer_size);
 
 /**
  * Vertex buffer encoder
  * Encodes vertex data into an array of bytes that is generally smaller and compresses better compared to original.
  * Returns encoded data size on success, 0 on error; the only error condition is if buffer doesn't have enough space
  * This function works for a single vertex stream; for multiple vertex streams, call meshopt_encodeVertexBuffer for each stream.
+ * Note that all vertex_size bytes of each vertex are encoded verbatim, including padding which should be zero-initialized.
  *
  * buffer must contain enough space for the encoded vertex buffer (use meshopt_encodeVertexBufferBound to compute worst case size)
  */
@@ -216,10 +261,10 @@ MESHOPTIMIZER_API size_t meshopt_encodeVertexBuffer(unsigned char* buffer, size_
 MESHOPTIMIZER_API size_t meshopt_encodeVertexBufferBound(size_t vertex_count, size_t vertex_size);
 
 /**
- * Experimental: Set vertex encoder format version
+ * Set vertex encoder format version
  * version must specify the data format version to encode; valid values are 0 (decodable by all library versions)
  */
-MESHOPTIMIZER_EXPERIMENTAL void meshopt_encodeVertexVersion(int version);
+MESHOPTIMIZER_API void meshopt_encodeVertexVersion(int version);
 
 /**
  * Vertex buffer decoder
@@ -234,7 +279,6 @@ MESHOPTIMIZER_API int meshopt_decodeVertexBuffer(void* destination, size_t verte
 /**
  * Vertex buffer filters
  * These functions can be used to filter output of meshopt_decodeVertexBuffer in-place.
- * count must be aligned by 4 and stride is fixed for each function to facilitate SIMD implementation.
  *
  * meshopt_decodeFilterOct decodes octahedral encoding of a unit vector with K-bit (K <= 16) signed X/Y as an input; Z must store 1.0f.
  * Each component is stored as an 8-bit or 16-bit normalized integer; stride must be equal to 4 or 8. W is preserved as is.
@@ -245,12 +289,51 @@ MESHOPTIMIZER_API int meshopt_decodeVertexBuffer(void* destination, size_t verte
  * meshopt_decodeFilterExp decodes exponential encoding of floating-point data with 8-bit exponent and 24-bit integer mantissa as 2^E*M.
  * Each 32-bit component is decoded in isolation; stride must be divisible by 4.
  */
-MESHOPTIMIZER_EXPERIMENTAL void meshopt_decodeFilterOct(void* buffer, size_t vertex_count, size_t vertex_size);
-MESHOPTIMIZER_EXPERIMENTAL void meshopt_decodeFilterQuat(void* buffer, size_t vertex_count, size_t vertex_size);
-MESHOPTIMIZER_EXPERIMENTAL void meshopt_decodeFilterExp(void* buffer, size_t vertex_count, size_t vertex_size);
+MESHOPTIMIZER_EXPERIMENTAL void meshopt_decodeFilterOct(void* buffer, size_t count, size_t stride);
+MESHOPTIMIZER_EXPERIMENTAL void meshopt_decodeFilterQuat(void* buffer, size_t count, size_t stride);
+MESHOPTIMIZER_EXPERIMENTAL void meshopt_decodeFilterExp(void* buffer, size_t count, size_t stride);
 
 /**
- * Experimental: Mesh simplifier
+ * Vertex buffer filter encoders
+ * These functions can be used to encode data in a format that meshopt_decodeFilter can decode
+ *
+ * meshopt_encodeFilterOct encodes unit vectors with K-bit (K <= 16) signed X/Y as an output.
+ * Each component is stored as an 8-bit or 16-bit normalized integer; stride must be equal to 4 or 8. W is preserved as is.
+ * Input data must contain 4 floats for every vector (count*4 total).
+ *
+ * meshopt_encodeFilterQuat encodes unit quaternions with K-bit (4 <= K <= 16) component encoding.
+ * Each component is stored as an 16-bit integer; stride must be equal to 8.
+ * Input data must contain 4 floats for every quaternion (count*4 total).
+ *
+ * meshopt_encodeFilterExp encodes arbitrary (finite) floating-point data with 8-bit exponent and K-bit integer mantissa (1 <= K <= 24).
+ * Exponent can be shared between all components of a given vector as defined by stride or all values of a given component; stride must be divisible by 4.
+ * Input data must contain stride/4 floats for every vector (count*stride/4 total).
+ */
+enum meshopt_EncodeExpMode
+{
+    /* When encoding exponents, use separate values for each component (maximum quality) */
+    meshopt_EncodeExpSeparate,
+    /* When encoding exponents, use shared value for all components of each vector (better compression) */
+    meshopt_EncodeExpSharedVector,
+    /* When encoding exponents, use shared value for each component of all vectors (best compression) */
+    meshopt_EncodeExpSharedComponent,
+};
+
+MESHOPTIMIZER_EXPERIMENTAL void meshopt_encodeFilterOct(void* destination, size_t count, size_t stride, int bits, const float* data);
+MESHOPTIMIZER_EXPERIMENTAL void meshopt_encodeFilterQuat(void* destination, size_t count, size_t stride, int bits, const float* data);
+MESHOPTIMIZER_EXPERIMENTAL void meshopt_encodeFilterExp(void* destination, size_t count, size_t stride, int bits, const float* data, enum meshopt_EncodeExpMode mode);
+
+/**
+ * Simplification options
+ */
+enum
+{
+    /* Do not move vertices that are located on the topological border (vertices on triangle edges that don't have a paired triangle). Useful for simplifying portions of the larger mesh. */
+    meshopt_SimplifyLockBorder = 1 << 0,
+};
+
+/**
+ * Mesh simplifier
  * Reduces the number of triangles in the mesh, attempting to preserve mesh appearance as much as possible
  * The algorithm tries to preserve mesh topology and can stop short of the target goal based on topology constraints or target error.
  * If not all attributes from the input mesh are required, it's recommended to reindex the mesh using meshopt_generateShadowIndexBuffer prior to simplification.
@@ -258,23 +341,40 @@ MESHOPTIMIZER_EXPERIMENTAL void meshopt_decodeFilterExp(void* buffer, size_t ver
  * The resulting index buffer references vertices from the original vertex buffer.
  * If the original vertex data isn't required, creating a compact vertex buffer using meshopt_optimizeVertexFetch is recommended.
  *
- * destination must contain enough space for the *source* index buffer (since optimization is iterative, this means index_count elements - *not* target_index_count!)
- * vertex_positions should have float3 position in the first 12 bytes of each vertex - similar to glVertexPointer
+ * destination must contain enough space for the target index buffer, worst case is index_count elements (*not* target_index_count)!
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex
+ * target_error represents the error relative to mesh extents that can be tolerated, e.g. 0.01 = 1% deformation; value range [0..1]
+ * options must be a bitmask composed of meshopt_SimplifyX options; 0 is a safe default
+ * result_error can be NULL; when it's not NULL, it will contain the resulting (relative) error after simplification
  */
-MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_simplify(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error);
+MESHOPTIMIZER_API size_t meshopt_simplify(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error, unsigned int options, float* result_error);
+
+/**
+ * Experimental: Mesh simplifier with attribute metric
+ * The algorithm ehnahces meshopt_simplify by incorporating attribute values into the error metric used to prioritize simplification order; see meshopt_simplify documentation for details.
+ * Note that the number of attributes affects memory requirements and running time; this algorithm requires ~1.5x more memory and time compared to meshopt_simplify when using 4 scalar attributes.
+ *
+ * vertex_attributes should have attribute_count floats for each vertex
+ * attribute_weights should have attribute_count floats in total; the weights determine relative priority of attributes between each other and wrt position. The recommended weight range is [1e-3..1e-1], assuming attribute data is in [0..1] range.
+ * attribute_count must be <= 16
+ * TODO target_error/result_error currently use combined distance+attribute error; this may change in the future
+ */
+MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_simplifyWithAttributes(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, const float* vertex_attributes, size_t vertex_attributes_stride, const float* attribute_weights, size_t attribute_count, size_t target_index_count, float target_error, unsigned int options, float* result_error);
 
 /**
  * Experimental: Mesh simplifier (sloppy)
- * Reduces the number of triangles in the mesh, sacrificing mesh apperance for simplification performance
- * The algorithm doesn't preserve mesh topology but is always able to reach target triangle count.
+ * Reduces the number of triangles in the mesh, sacrificing mesh appearance for simplification performance
+ * The algorithm doesn't preserve mesh topology but can stop short of the target goal based on target error.
  * Returns the number of indices after simplification, with destination containing new index data
  * The resulting index buffer references vertices from the original vertex buffer.
  * If the original vertex data isn't required, creating a compact vertex buffer using meshopt_optimizeVertexFetch is recommended.
  *
- * destination must contain enough space for the target index buffer
- * vertex_positions should have float3 position in the first 12 bytes of each vertex - similar to glVertexPointer
+ * destination must contain enough space for the target index buffer, worst case is index_count elements (*not* target_index_count)!
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex
+ * target_error represents the error relative to mesh extents that can be tolerated, e.g. 0.01 = 1% deformation; value range [0..1]
+ * result_error can be NULL; when it's not NULL, it will contain the resulting (relative) error after simplification
  */
-MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_simplifySloppy(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count);
+MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_simplifySloppy(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error, float* result_error);
 
 /**
  * Experimental: Point cloud simplifier
@@ -283,10 +383,19 @@ MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_simplifySloppy(unsigned int* destinati
  * The resulting index buffer references vertices from the original vertex buffer.
  * If the original vertex data isn't required, creating a compact vertex buffer using meshopt_optimizeVertexFetch is recommended.
  *
- * destination must contain enough space for the target index buffer
- * vertex_positions should have float3 position in the first 12 bytes of each vertex - similar to glVertexPointer
+ * destination must contain enough space for the target index buffer (target_vertex_count elements)
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex
+ * vertex_colors should can be NULL; when it's not NULL, it should have float3 color in the first 12 bytes of each vertex
  */
-MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_simplifyPoints(unsigned int* destination, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_vertex_count);
+MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_simplifyPoints(unsigned int* destination, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, const float* vertex_colors, size_t vertex_colors_stride, float color_weight, size_t target_vertex_count);
+
+/**
+ * Returns the error scaling factor used by the simplifier to convert between absolute and relative extents
+ *
+ * Absolute error must be *divided* by the scaling factor before passing it to meshopt_simplify as target_error
+ * Relative error returned by meshopt_simplify via result_error must be *multiplied* by the scaling factor to get absolute error.
+ */
+MESHOPTIMIZER_API float meshopt_simplifyScale(const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
 
 /**
  * Mesh stripifier
@@ -338,7 +447,7 @@ struct meshopt_OverdrawStatistics
  * Returns overdraw statistics using a software rasterizer
  * Results may not match actual GPU performance
  *
- * vertex_positions should have float3 position in the first 12 bytes of each vertex - similar to glVertexPointer
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex
  */
 MESHOPTIMIZER_API struct meshopt_OverdrawStatistics meshopt_analyzeOverdraw(const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
 
@@ -357,23 +466,32 @@ MESHOPTIMIZER_API struct meshopt_VertexFetchStatistics meshopt_analyzeVertexFetc
 
 struct meshopt_Meshlet
 {
-	unsigned int vertices[64];
-	unsigned char indices[126][3];
-	unsigned char triangle_count;
-	unsigned char vertex_count;
+	/* offsets within meshlet_vertices and meshlet_triangles arrays with meshlet data */
+	unsigned int vertex_offset;
+	unsigned int triangle_offset;
+
+	/* number of vertices and triangles used in the meshlet; data is stored in consecutive range defined by offset and count */
+	unsigned int vertex_count;
+	unsigned int triangle_count;
 };
 
 /**
- * Experimental: Meshlet builder
+ * Meshlet builder
  * Splits the mesh into a set of meshlets where each meshlet has a micro index buffer indexing into meshlet vertices that refer to the original vertex buffer
  * The resulting data can be used to render meshes using NVidia programmable mesh shading pipeline, or in other cluster-based renderers.
- * For maximum efficiency the index buffer being converted has to be optimized for vertex cache first.
+ * When using buildMeshlets, vertex positions need to be provided to minimize the size of the resulting clusters.
+ * When using buildMeshletsScan, for maximum efficiency the index buffer being converted has to be optimized for vertex cache first.
  *
- * destination must contain enough space for all meshlets, worst case size can be computed with meshopt_buildMeshletsBound
- * max_vertices and max_triangles can't exceed limits statically declared in meshopt_Meshlet (max_vertices <= 64, max_triangles <= 126)
+ * meshlets must contain enough space for all meshlets, worst case size can be computed with meshopt_buildMeshletsBound
+ * meshlet_vertices must contain enough space for all meshlets, worst case size is equal to max_meshlets * max_vertices
+ * meshlet_triangles must contain enough space for all meshlets, worst case size is equal to max_meshlets * max_triangles * 3
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex
+ * max_vertices and max_triangles must not exceed implementation limits (max_vertices <= 255 - not 256!, max_triangles <= 512)
+ * cone_weight should be set to 0 when cone culling is not used, and a value between 0 and 1 otherwise to balance between cluster size and cone culling efficiency
  */
-MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_buildMeshlets(struct meshopt_Meshlet* destination, const unsigned int* indices, size_t index_count, size_t vertex_count, size_t max_vertices, size_t max_triangles);
-MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_buildMeshletsBound(size_t index_count, size_t max_vertices, size_t max_triangles);
+MESHOPTIMIZER_API size_t meshopt_buildMeshlets(struct meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t max_vertices, size_t max_triangles, float cone_weight);
+MESHOPTIMIZER_API size_t meshopt_buildMeshletsScan(struct meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const unsigned int* indices, size_t index_count, size_t vertex_count, size_t max_vertices, size_t max_triangles);
+MESHOPTIMIZER_API size_t meshopt_buildMeshletsBound(size_t index_count, size_t max_vertices, size_t max_triangles);
 
 struct meshopt_Bounds
 {
@@ -392,13 +510,13 @@ struct meshopt_Bounds
 };
 
 /**
- * Experimental: Cluster bounds generator
+ * Cluster bounds generator
  * Creates bounding volumes that can be used for frustum, backface and occlusion culling.
  *
  * For backface culling with orthographic projection, use the following formula to reject backfacing clusters:
  *   dot(view, cone_axis) >= cone_cutoff
  *
- * For perspective projection, you can the formula that needs cone apex in addition to axis & cutoff:
+ * For perspective projection, you can use the formula that needs cone apex in addition to axis & cutoff:
  *   dot(normalize(cone_apex - camera_position), cone_axis) >= cone_cutoff
  *
  * Alternatively, you can use the formula that doesn't need cone apex and uses bounding sphere instead:
@@ -407,29 +525,31 @@ struct meshopt_Bounds
  *   dot(center - camera_position, cone_axis) >= cone_cutoff * length(center - camera_position) + radius
  *
  * The formula that uses the apex is slightly more accurate but needs the apex; if you are already using bounding sphere
- * to do frustum/occlusion culling, the formula that doesn't use the apex may be preferable.
+ * to do frustum/occlusion culling, the formula that doesn't use the apex may be preferable (for derivation see
+ * Real-Time Rendering 4th Edition, section 19.3).
  *
- * vertex_positions should have float3 position in the first 12 bytes of each vertex - similar to glVertexPointer
- * index_count should be less than or equal to 256*3 (the function assumes clusters of limited size)
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex
+ * index_count/3 should be less than or equal to 512 (the function assumes clusters of limited size)
  */
-MESHOPTIMIZER_EXPERIMENTAL struct meshopt_Bounds meshopt_computeClusterBounds(const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
-MESHOPTIMIZER_EXPERIMENTAL struct meshopt_Bounds meshopt_computeMeshletBounds(const struct meshopt_Meshlet* meshlet, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
+MESHOPTIMIZER_API struct meshopt_Bounds meshopt_computeClusterBounds(const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
+MESHOPTIMIZER_API struct meshopt_Bounds meshopt_computeMeshletBounds(const unsigned int* meshlet_vertices, const unsigned char* meshlet_triangles, size_t triangle_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
 
 /**
- * Experimental: Spatial sorter
+ * Spatial sorter
  * Generates a remap table that can be used to reorder points for spatial locality.
  * Resulting remap table maps old vertices to new vertices and can be used in meshopt_remapVertexBuffer.
  *
  * destination must contain enough space for the resulting remap table (vertex_count elements)
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex
  */
-MESHOPTIMIZER_EXPERIMENTAL void meshopt_spatialSortRemap(unsigned int* destination, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
+MESHOPTIMIZER_API void meshopt_spatialSortRemap(unsigned int* destination, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
 
 /**
  * Experimental: Spatial sorter
  * Reorders triangles for spatial locality, and generates a new index buffer. The resulting index buffer can be used with other functions like optimizeVertexCache.
  *
  * destination must contain enough space for the resulting index buffer (index_count elements)
- * vertex_positions should have float3 position in the first 12 bytes of each vertex - similar to glVertexPointer
+ * vertex_positions should have float3 position in the first 12 bytes of each vertex
  */
 MESHOPTIMIZER_EXPERIMENTAL void meshopt_spatialSortTriangles(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
 
@@ -439,7 +559,7 @@ MESHOPTIMIZER_EXPERIMENTAL void meshopt_spatialSortTriangles(unsigned int* desti
  * Note that all algorithms only allocate memory for temporary use.
  * allocate/deallocate are always called in a stack-like order - last pointer to be allocated is deallocated first.
  */
-MESHOPTIMIZER_API void meshopt_setAllocator(void* (*allocate)(size_t), void (*deallocate)(void*));
+MESHOPTIMIZER_API void meshopt_setAllocator(void* (MESHOPTIMIZER_ALLOC_CALLCONV *allocate)(size_t), void (MESHOPTIMIZER_ALLOC_CALLCONV *deallocate)(void*));
 
 #ifdef __cplusplus
 } /* extern "C" */
@@ -462,19 +582,25 @@ inline int meshopt_quantizeUnorm(float v, int N);
 inline int meshopt_quantizeSnorm(float v, int N);
 
 /**
- * Quantize a float into half-precision floating point value
+ * Quantize a float into half-precision (as defined by IEEE-754 fp16) floating point value
  * Generates +-inf for overflow, preserves NaN, flushes denormals to zero, rounds to nearest
  * Representable magnitude range: [6e-5; 65504]
  * Maximum relative reconstruction error: 5e-4
  */
-inline unsigned short meshopt_quantizeHalf(float v);
+MESHOPTIMIZER_API unsigned short meshopt_quantizeHalf(float v);
 
 /**
- * Quantize a float into a floating point value with a limited number of significant mantissa bits
+ * Quantize a float into a floating point value with a limited number of significant mantissa bits, preserving the IEEE-754 fp32 binary representation
  * Generates +-inf for overflow, preserves NaN, flushes denormals to zero, rounds to nearest
  * Assumes N is in a valid mantissa precision range, which is 1..23
  */
-inline float meshopt_quantizeFloat(float v, int N);
+MESHOPTIMIZER_API float meshopt_quantizeFloat(float v, int N);
+
+/**
+ * Reverse quantization of a half-precision (as defined by IEEE-754 fp16) floating point value
+ * Preserves Inf/NaN, flushes denormals to zero
+ */
+MESHOPTIMIZER_API float meshopt_dequantizeHalf(unsigned short h);
 #endif
 
 /**
@@ -497,6 +623,10 @@ inline void meshopt_generateShadowIndexBuffer(T* destination, const T* indices,
 template <typename T>
 inline void meshopt_generateShadowIndexBufferMulti(T* destination, const T* indices, size_t index_count, size_t vertex_count, const meshopt_Stream* streams, size_t stream_count);
 template <typename T>
+inline void meshopt_generateAdjacencyIndexBuffer(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
+template <typename T>
+inline void meshopt_generateTessellationIndexBuffer(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
+template <typename T>
 inline void meshopt_optimizeVertexCache(T* destination, const T* indices, size_t index_count, size_t vertex_count);
 template <typename T>
 inline void meshopt_optimizeVertexCacheStrip(T* destination, const T* indices, size_t index_count, size_t vertex_count);
@@ -517,9 +647,11 @@ inline size_t meshopt_encodeIndexSequence(unsigned char* buffer, size_t buffer_s
 template <typename T>
 inline int meshopt_decodeIndexSequence(T* destination, size_t index_count, const unsigned char* buffer, size_t buffer_size);
 template <typename T>
-inline size_t meshopt_simplify(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error);
+inline size_t meshopt_simplify(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error, unsigned int options = 0, float* result_error = NULL);
 template <typename T>
-inline size_t meshopt_simplifySloppy(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count);
+inline size_t meshopt_simplifyWithAttributes(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, const float* vertex_attributes, size_t vertex_attributes_stride, const float* attribute_weights, size_t attribute_count, size_t target_index_count, float target_error, unsigned int options = 0, float* result_error = NULL);
+template <typename T>
+inline size_t meshopt_simplifySloppy(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error, float* result_error = NULL);
 template <typename T>
 inline size_t meshopt_stripify(T* destination, const T* indices, size_t index_count, size_t vertex_count, T restart_index);
 template <typename T>
@@ -531,7 +663,9 @@ inline meshopt_OverdrawStatistics meshopt_analyzeOverdraw(const T* indices, size
 template <typename T>
 inline meshopt_VertexFetchStatistics meshopt_analyzeVertexFetch(const T* indices, size_t index_count, size_t vertex_count, size_t vertex_size);
 template <typename T>
-inline size_t meshopt_buildMeshlets(meshopt_Meshlet* destination, const T* indices, size_t index_count, size_t vertex_count, size_t max_vertices, size_t max_triangles);
+inline size_t meshopt_buildMeshlets(meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t max_vertices, size_t max_triangles, float cone_weight);
+template <typename T>
+inline size_t meshopt_buildMeshletsScan(meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const T* indices, size_t index_count, size_t vertex_count, size_t max_vertices, size_t max_triangles);
 template <typename T>
 inline meshopt_Bounds meshopt_computeClusterBounds(const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
 template <typename T>
@@ -561,50 +695,6 @@ inline int meshopt_quantizeSnorm(float v, int N)
 
 	return int(v * scale + round);
 }
-
-inline unsigned short meshopt_quantizeHalf(float v)
-{
-	union { float f; unsigned int ui; } u = {v};
-	unsigned int ui = u.ui;
-
-	int s = (ui >> 16) & 0x8000;
-	int em = ui & 0x7fffffff;
-
-	/* bias exponent and round to nearest; 112 is relative exponent bias (127-15) */
-	int h = (em - (112 << 23) + (1 << 12)) >> 13;
-
-	/* underflow: flush to zero; 113 encodes exponent -14 */
-	h = (em < (113 << 23)) ? 0 : h;
-
-	/* overflow: infinity; 143 encodes exponent 16 */
-	h = (em >= (143 << 23)) ? 0x7c00 : h;
-
-	/* NaN; note that we convert all types of NaN to qNaN */
-	h = (em > (255 << 23)) ? 0x7e00 : h;
-
-	return (unsigned short)(s | h);
-}
-
-inline float meshopt_quantizeFloat(float v, int N)
-{
-	union { float f; unsigned int ui; } u = {v};
-	unsigned int ui = u.ui;
-
-	const int mask = (1 << (23 - N)) - 1;
-	const int round = (1 << (23 - N)) >> 1;
-
-	int e = ui & 0x7f800000;
-	unsigned int rui = (ui + round) & ~mask;
-
-	/* round all numbers except inf/nan; this is important to make sure nan doesn't overflow into -0 */
-	ui = e == 0x7f800000 ? ui : rui;
-
-	/* flush denormals to zero */
-	ui = e == 0 ? 0 : ui;
-
-	u.ui = ui;
-	return u.f;
-}
 #endif
 
 /* Internal implementation helpers */
@@ -615,8 +705,8 @@ public:
 	template <typename T>
 	struct StorageT
 	{
-		static void* (*allocate)(size_t);
-		static void (*deallocate)(void*);
+		static void* (MESHOPTIMIZER_ALLOC_CALLCONV *allocate)(size_t);
+		static void (MESHOPTIMIZER_ALLOC_CALLCONV *deallocate)(void*);
 	};
 
 	typedef StorageT<void> Storage;
@@ -641,14 +731,21 @@ public:
 		return result;
 	}
 
+	void deallocate(void* ptr)
+	{
+		assert(count > 0 && blocks[count - 1] == ptr);
+		Storage::deallocate(ptr);
+		count--;
+	}
+
 private:
-	void* blocks[16];
+	void* blocks[24];
 	size_t count;
 };
 
 // This makes sure that allocate/deallocate are lazily generated in translation units that need them and are deduplicated by the linker
-template <typename T> void* (*meshopt_Allocator::StorageT<T>::allocate)(size_t) = operator new;
-template <typename T> void (*meshopt_Allocator::StorageT<T>::deallocate)(void*) = operator delete;
+template <typename T> void* (MESHOPTIMIZER_ALLOC_CALLCONV *meshopt_Allocator::StorageT<T>::allocate)(size_t) = operator new;
+template <typename T> void (MESHOPTIMIZER_ALLOC_CALLCONV *meshopt_Allocator::StorageT<T>::deallocate)(void*) = operator delete;
 #endif
 
 /* Inline implementation for C++ templated wrappers */
@@ -665,7 +762,7 @@ struct meshopt_IndexAdapter<T, false>
 
 	meshopt_IndexAdapter(T* result_, const T* input, size_t count_)
 	    : result(result_)
-	    , data(0)
+	    , data(NULL)
 	    , count(count_)
 	{
 		size_t size = count > size_t(-1) / sizeof(unsigned int) ? size_t(-1) : count * sizeof(unsigned int);
@@ -705,33 +802,33 @@ struct meshopt_IndexAdapter<T, true>
 template <typename T>
 inline size_t meshopt_generateVertexRemap(unsigned int* destination, const T* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size)
 {
-	meshopt_IndexAdapter<T> in(0, indices, indices ? index_count : 0);
+	meshopt_IndexAdapter<T> in(NULL, indices, indices ? index_count : 0);
 
-	return meshopt_generateVertexRemap(destination, indices ? in.data : 0, index_count, vertices, vertex_count, vertex_size);
+	return meshopt_generateVertexRemap(destination, indices ? in.data : NULL, index_count, vertices, vertex_count, vertex_size);
 }
 
 template <typename T>
 inline size_t meshopt_generateVertexRemapMulti(unsigned int* destination, const T* indices, size_t index_count, size_t vertex_count, const meshopt_Stream* streams, size_t stream_count)
 {
-	meshopt_IndexAdapter<T> in(0, indices, indices ? index_count : 0);
+	meshopt_IndexAdapter<T> in(NULL, indices, indices ? index_count : 0);
 
-	return meshopt_generateVertexRemapMulti(destination, indices ? in.data : 0, index_count, vertex_count, streams, stream_count);
+	return meshopt_generateVertexRemapMulti(destination, indices ? in.data : NULL, index_count, vertex_count, streams, stream_count);
 }
 
 template <typename T>
 inline void meshopt_remapIndexBuffer(T* destination, const T* indices, size_t index_count, const unsigned int* remap)
 {
-	meshopt_IndexAdapter<T> in(0, indices, indices ? index_count : 0);
+	meshopt_IndexAdapter<T> in(NULL, indices, indices ? index_count : 0);
 	meshopt_IndexAdapter<T> out(destination, 0, index_count);
 
-	meshopt_remapIndexBuffer(out.data, indices ? in.data : 0, index_count, remap);
+	meshopt_remapIndexBuffer(out.data, indices ? in.data : NULL, index_count, remap);
 }
 
 template <typename T>
 inline void meshopt_generateShadowIndexBuffer(T* destination, const T* indices, size_t index_count, const void* vertices, size_t vertex_count, size_t vertex_size, size_t vertex_stride)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
-	meshopt_IndexAdapter<T> out(destination, 0, index_count);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, NULL, index_count);
 
 	meshopt_generateShadowIndexBuffer(out.data, in.data, index_count, vertices, vertex_count, vertex_size, vertex_stride);
 }
@@ -739,17 +836,35 @@ inline void meshopt_generateShadowIndexBuffer(T* destination, const T* indices,
 template <typename T>
 inline void meshopt_generateShadowIndexBufferMulti(T* destination, const T* indices, size_t index_count, size_t vertex_count, const meshopt_Stream* streams, size_t stream_count)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
-	meshopt_IndexAdapter<T> out(destination, 0, index_count);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, NULL, index_count);
 
 	meshopt_generateShadowIndexBufferMulti(out.data, in.data, index_count, vertex_count, streams, stream_count);
 }
 
+template <typename T>
+inline void meshopt_generateAdjacencyIndexBuffer(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
+{
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, NULL, index_count * 2);
+
+	meshopt_generateAdjacencyIndexBuffer(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride);
+}
+
+template <typename T>
+inline void meshopt_generateTessellationIndexBuffer(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
+{
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, NULL, index_count * 4);
+
+	meshopt_generateTessellationIndexBuffer(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride);
+}
+
 template <typename T>
 inline void meshopt_optimizeVertexCache(T* destination, const T* indices, size_t index_count, size_t vertex_count)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
-	meshopt_IndexAdapter<T> out(destination, 0, index_count);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, NULL, index_count);
 
 	meshopt_optimizeVertexCache(out.data, in.data, index_count, vertex_count);
 }
@@ -757,8 +872,8 @@ inline void meshopt_optimizeVertexCache(T* destination, const T* indices, size_t
 template <typename T>
 inline void meshopt_optimizeVertexCacheStrip(T* destination, const T* indices, size_t index_count, size_t vertex_count)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
-	meshopt_IndexAdapter<T> out(destination, 0, index_count);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, NULL, index_count);
 
 	meshopt_optimizeVertexCacheStrip(out.data, in.data, index_count, vertex_count);
 }
@@ -766,8 +881,8 @@ inline void meshopt_optimizeVertexCacheStrip(T* destination, const T* indices, s
 template <typename T>
 inline void meshopt_optimizeVertexCacheFifo(T* destination, const T* indices, size_t index_count, size_t vertex_count, unsigned int cache_size)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
-	meshopt_IndexAdapter<T> out(destination, 0, index_count);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, NULL, index_count);
 
 	meshopt_optimizeVertexCacheFifo(out.data, in.data, index_count, vertex_count, cache_size);
 }
@@ -775,8 +890,8 @@ inline void meshopt_optimizeVertexCacheFifo(T* destination, const T* indices, si
 template <typename T>
 inline void meshopt_optimizeOverdraw(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, float threshold)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
-	meshopt_IndexAdapter<T> out(destination, 0, index_count);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, NULL, index_count);
 
 	meshopt_optimizeOverdraw(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, threshold);
 }
@@ -784,7 +899,7 @@ inline void meshopt_optimizeOverdraw(T* destination, const T* indices, size_t in
 template <typename T>
 inline size_t meshopt_optimizeVertexFetchRemap(unsigned int* destination, const T* indices, size_t index_count, size_t vertex_count)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
 
 	return meshopt_optimizeVertexFetchRemap(destination, in.data, index_count, vertex_count);
 }
@@ -800,7 +915,7 @@ inline size_t meshopt_optimizeVertexFetch(void* destination, T* indices, size_t
 template <typename T>
 inline size_t meshopt_encodeIndexBuffer(unsigned char* buffer, size_t buffer_size, const T* indices, size_t index_count)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
 
 	return meshopt_encodeIndexBuffer(buffer, buffer_size, in.data, index_count);
 }
@@ -817,7 +932,7 @@ inline int meshopt_decodeIndexBuffer(T* destination, size_t index_count, const u
 template <typename T>
 inline size_t meshopt_encodeIndexSequence(unsigned char* buffer, size_t buffer_size, const T* indices, size_t index_count)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
 
 	return meshopt_encodeIndexSequence(buffer, buffer_size, in.data, index_count);
 }
@@ -832,28 +947,37 @@ inline int meshopt_decodeIndexSequence(T* destination, size_t index_count, const
 }
 
 template <typename T>
-inline size_t meshopt_simplify(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error)
+inline size_t meshopt_simplify(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error, unsigned int options, float* result_error)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
-	meshopt_IndexAdapter<T> out(destination, 0, index_count);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, NULL, index_count);
 
-	return meshopt_simplify(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, target_index_count, target_error);
+	return meshopt_simplify(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, target_index_count, target_error, options, result_error);
 }
 
 template <typename T>
-inline size_t meshopt_simplifySloppy(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count)
+inline size_t meshopt_simplifyWithAttributes(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, const float* vertex_attributes, size_t vertex_attributes_stride, const float* attribute_weights, size_t attribute_count, size_t target_index_count, float target_error, unsigned int options, float* result_error)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
-	meshopt_IndexAdapter<T> out(destination, 0, target_index_count);
+    meshopt_IndexAdapter<T> in(NULL, indices, index_count);
+    meshopt_IndexAdapter<T> out(destination, NULL, index_count);
 
-	return meshopt_simplifySloppy(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, target_index_count);
+    return meshopt_simplifyWithAttributes(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, vertex_attributes, vertex_attributes_stride, attribute_weights, attribute_count, target_index_count, target_error, options, result_error);
+}
+
+template <typename T>
+inline size_t meshopt_simplifySloppy(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error, float* result_error)
+{
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, NULL, index_count);
+
+	return meshopt_simplifySloppy(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, target_index_count, target_error, result_error);
 }
 
 template <typename T>
 inline size_t meshopt_stripify(T* destination, const T* indices, size_t index_count, size_t vertex_count, T restart_index)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
-	meshopt_IndexAdapter<T> out(destination, 0, (index_count / 3) * 5);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, NULL, (index_count / 3) * 5);
 
 	return meshopt_stripify(out.data, in.data, index_count, vertex_count, unsigned(restart_index));
 }
@@ -861,8 +985,8 @@ inline size_t meshopt_stripify(T* destination, const T* indices, size_t index_co
 template <typename T>
 inline size_t meshopt_unstripify(T* destination, const T* indices, size_t index_count, T restart_index)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
-	meshopt_IndexAdapter<T> out(destination, 0, (index_count - 2) * 3);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, NULL, (index_count - 2) * 3);
 
 	return meshopt_unstripify(out.data, in.data, index_count, unsigned(restart_index));
 }
@@ -870,7 +994,7 @@ inline size_t meshopt_unstripify(T* destination, const T* indices, size_t index_
 template <typename T>
 inline meshopt_VertexCacheStatistics meshopt_analyzeVertexCache(const T* indices, size_t index_count, size_t vertex_count, unsigned int cache_size, unsigned int warp_size, unsigned int buffer_size)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
 
 	return meshopt_analyzeVertexCache(in.data, index_count, vertex_count, cache_size, warp_size, buffer_size);
 }
@@ -878,7 +1002,7 @@ inline meshopt_VertexCacheStatistics meshopt_analyzeVertexCache(const T* indices
 template <typename T>
 inline meshopt_OverdrawStatistics meshopt_analyzeOverdraw(const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
 
 	return meshopt_analyzeOverdraw(in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride);
 }
@@ -886,23 +1010,31 @@ inline meshopt_OverdrawStatistics meshopt_analyzeOverdraw(const T* indices, size
 template <typename T>
 inline meshopt_VertexFetchStatistics meshopt_analyzeVertexFetch(const T* indices, size_t index_count, size_t vertex_count, size_t vertex_size)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
 
 	return meshopt_analyzeVertexFetch(in.data, index_count, vertex_count, vertex_size);
 }
 
 template <typename T>
-inline size_t meshopt_buildMeshlets(meshopt_Meshlet* destination, const T* indices, size_t index_count, size_t vertex_count, size_t max_vertices, size_t max_triangles)
+inline size_t meshopt_buildMeshlets(meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride, size_t max_vertices, size_t max_triangles, float cone_weight)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
 
-	return meshopt_buildMeshlets(destination, in.data, index_count, vertex_count, max_vertices, max_triangles);
+	return meshopt_buildMeshlets(meshlets, meshlet_vertices, meshlet_triangles, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride, max_vertices, max_triangles, cone_weight);
+}
+
+template <typename T>
+inline size_t meshopt_buildMeshletsScan(meshopt_Meshlet* meshlets, unsigned int* meshlet_vertices, unsigned char* meshlet_triangles, const T* indices, size_t index_count, size_t vertex_count, size_t max_vertices, size_t max_triangles)
+{
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
+
+	return meshopt_buildMeshletsScan(meshlets, meshlet_vertices, meshlet_triangles, in.data, index_count, vertex_count, max_vertices, max_triangles);
 }
 
 template <typename T>
 inline meshopt_Bounds meshopt_computeClusterBounds(const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
 
 	return meshopt_computeClusterBounds(in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride);
 }
@@ -910,15 +1042,15 @@ inline meshopt_Bounds meshopt_computeClusterBounds(const T* indices, size_t inde
 template <typename T>
 inline void meshopt_spatialSortTriangles(T* destination, const T* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
 {
-	meshopt_IndexAdapter<T> in(0, indices, index_count);
-	meshopt_IndexAdapter<T> out(destination, 0, index_count);
+	meshopt_IndexAdapter<T> in(NULL, indices, index_count);
+	meshopt_IndexAdapter<T> out(destination, NULL, index_count);
 
 	meshopt_spatialSortTriangles(out.data, in.data, index_count, vertex_positions, vertex_count, vertex_positions_stride);
 }
 #endif
 
 /**
- * Copyright (c) 2016-2020 Arseny Kapoulkine
+ * Copyright (c) 2016-2023 Arseny Kapoulkine
  *
  * Permission is hereby granted, free of charge, to any person
  * obtaining a copy of this software and associated documentation
diff --git a/Source/ThirdParty/meshoptimizer/overdrawanalyzer.cpp b/Source/ThirdParty/meshoptimizer/overdrawanalyzer.cpp
index 8d5859ba3..8b6f25413 100644
--- a/Source/ThirdParty/meshoptimizer/overdrawanalyzer.cpp
+++ b/Source/ThirdParty/meshoptimizer/overdrawanalyzer.cpp
@@ -147,7 +147,7 @@ meshopt_OverdrawStatistics meshopt_analyzeOverdraw(const unsigned int* indices,
 	using namespace meshopt;
 
 	assert(index_count % 3 == 0);
-	assert(vertex_positions_stride > 0 && vertex_positions_stride <= 256);
+	assert(vertex_positions_stride >= 12 && vertex_positions_stride <= 256);
 	assert(vertex_positions_stride % sizeof(float) == 0);
 
 	meshopt_Allocator allocator;
diff --git a/Source/ThirdParty/meshoptimizer/overdrawoptimizer.cpp b/Source/ThirdParty/meshoptimizer/overdrawoptimizer.cpp
index 143656ed7..cc22dbcff 100644
--- a/Source/ThirdParty/meshoptimizer/overdrawoptimizer.cpp
+++ b/Source/ThirdParty/meshoptimizer/overdrawoptimizer.cpp
@@ -272,7 +272,7 @@ void meshopt_optimizeOverdraw(unsigned int* destination, const unsigned int* ind
 	using namespace meshopt;
 
 	assert(index_count % 3 == 0);
-	assert(vertex_positions_stride > 0 && vertex_positions_stride <= 256);
+	assert(vertex_positions_stride >= 12 && vertex_positions_stride <= 256);
 	assert(vertex_positions_stride % sizeof(float) == 0);
 
 	meshopt_Allocator allocator;
diff --git a/Source/ThirdParty/meshoptimizer/quantization.cpp b/Source/ThirdParty/meshoptimizer/quantization.cpp
new file mode 100644
index 000000000..09a314d60
--- /dev/null
+++ b/Source/ThirdParty/meshoptimizer/quantization.cpp
@@ -0,0 +1,70 @@
+// This file is part of meshoptimizer library; see meshoptimizer.h for version/license details
+#include "meshoptimizer.h"
+
+#include <assert.h>
+
+unsigned short meshopt_quantizeHalf(float v)
+{
+	union { float f; unsigned int ui; } u = {v};
+	unsigned int ui = u.ui;
+
+	int s = (ui >> 16) & 0x8000;
+	int em = ui & 0x7fffffff;
+
+	// bias exponent and round to nearest; 112 is relative exponent bias (127-15)
+	int h = (em - (112 << 23) + (1 << 12)) >> 13;
+
+	// underflow: flush to zero; 113 encodes exponent -14
+	h = (em < (113 << 23)) ? 0 : h;
+
+	// overflow: infinity; 143 encodes exponent 16
+	h = (em >= (143 << 23)) ? 0x7c00 : h;
+
+	// NaN; note that we convert all types of NaN to qNaN
+	h = (em > (255 << 23)) ? 0x7e00 : h;
+
+	return (unsigned short)(s | h);
+}
+
+float meshopt_quantizeFloat(float v, int N)
+{
+	assert(N >= 0 && N <= 23);
+
+	union { float f; unsigned int ui; } u = {v};
+	unsigned int ui = u.ui;
+
+	const int mask = (1 << (23 - N)) - 1;
+	const int round = (1 << (23 - N)) >> 1;
+
+	int e = ui & 0x7f800000;
+	unsigned int rui = (ui + round) & ~mask;
+
+	// round all numbers except inf/nan; this is important to make sure nan doesn't overflow into -0
+	ui = e == 0x7f800000 ? ui : rui;
+
+	// flush denormals to zero
+	ui = e == 0 ? 0 : ui;
+
+	u.ui = ui;
+	return u.f;
+}
+
+float meshopt_dequantizeHalf(unsigned short h)
+{
+	unsigned int s = unsigned(h & 0x8000) << 16;
+	int em = h & 0x7fff;
+
+	// bias exponent and pad mantissa with 0; 112 is relative exponent bias (127-15)
+	int r = (em + (112 << 10)) << 13;
+
+	// denormal: flush to zero
+	r = (em < (1 << 10)) ? 0 : r;
+
+	// infinity/NaN; note that we preserve NaN payload as a byproduct of unifying inf/nan cases
+	// 112 is an exponent bias fixup; since we already applied it once, applying it twice converts 31 to 255
+	r += (em >= (31 << 10)) ? (112 << 23) : 0;
+
+	union { float f; unsigned int ui; } u;
+	u.ui = s | r;
+	return u.f;
+}
diff --git a/Source/ThirdParty/meshoptimizer/simplifier.cpp b/Source/ThirdParty/meshoptimizer/simplifier.cpp
index dd0ff9b07..5ba857007 100644
--- a/Source/ThirdParty/meshoptimizer/simplifier.cpp
+++ b/Source/ThirdParty/meshoptimizer/simplifier.cpp
@@ -14,39 +14,55 @@
 #include <stdio.h>
 #endif
 
+#if TRACE
+#define TRACESTATS(i) stats[i]++;
+#else
+#define TRACESTATS(i) (void)0
+#endif
+
 // This work is based on:
 // Michael Garland and Paul S. Heckbert. Surface simplification using quadric error metrics. 1997
 // Michael Garland. Quadric-based polygonal surface simplification. 1999
 // Peter Lindstrom. Out-of-Core Simplification of Large Polygonal Models. 2000
 // Matthias Teschner, Bruno Heidelberger, Matthias Mueller, Danat Pomeranets, Markus Gross. Optimized Spatial Hashing for Collision Detection of Deformable Objects. 2003
 // Peter Van Sandt, Yannis Chronis, Jignesh M. Patel. Efficiently Searching In-Memory Sorted Arrays: Revenge of the Interpolation Search? 2019
+// Hugues Hoppe. New Quadric Metric for Simplifying Meshes with Appearance Attributes. 1999
 namespace meshopt
 {
 
 struct EdgeAdjacency
 {
-	unsigned int* counts;
+	struct Edge
+	{
+		unsigned int next;
+		unsigned int prev;
+	};
+
 	unsigned int* offsets;
-	unsigned int* data;
+	Edge* data;
 };
 
-static void buildEdgeAdjacency(EdgeAdjacency& adjacency, const unsigned int* indices, size_t index_count, size_t vertex_count, meshopt_Allocator& allocator)
+static void prepareEdgeAdjacency(EdgeAdjacency& adjacency, size_t index_count, size_t vertex_count, meshopt_Allocator& allocator)
+{
+	adjacency.offsets = allocator.allocate<unsigned int>(vertex_count + 1);
+	adjacency.data = allocator.allocate<EdgeAdjacency::Edge>(index_count);
+}
+
+static void updateEdgeAdjacency(EdgeAdjacency& adjacency, const unsigned int* indices, size_t index_count, size_t vertex_count, const unsigned int* remap)
 {
 	size_t face_count = index_count / 3;
-
-	// allocate arrays
-	adjacency.counts = allocator.allocate<unsigned int>(vertex_count);
-	adjacency.offsets = allocator.allocate<unsigned int>(vertex_count);
-	adjacency.data = allocator.allocate<unsigned int>(index_count);
+	unsigned int* offsets = adjacency.offsets + 1;
+	EdgeAdjacency::Edge* data = adjacency.data;
 
 	// fill edge counts
-	memset(adjacency.counts, 0, vertex_count * sizeof(unsigned int));
+	memset(offsets, 0, vertex_count * sizeof(unsigned int));
 
 	for (size_t i = 0; i < index_count; ++i)
 	{
-		assert(indices[i] < vertex_count);
+		unsigned int v = remap ? remap[indices[i]] : indices[i];
+		assert(v < vertex_count);
 
-		adjacency.counts[indices[i]]++;
+		offsets[v]++;
 	}
 
 	// fill offset table
@@ -54,8 +70,9 @@ static void buildEdgeAdjacency(EdgeAdjacency& adjacency, const unsigned int* ind
 
 	for (size_t i = 0; i < vertex_count; ++i)
 	{
-		adjacency.offsets[i] = offset;
-		offset += adjacency.counts[i];
+		unsigned int count = offsets[i];
+		offsets[i] = offset;
+		offset += count;
 	}
 
 	assert(offset == index_count);
@@ -65,18 +82,29 @@ static void buildEdgeAdjacency(EdgeAdjacency& adjacency, const unsigned int* ind
 	{
 		unsigned int a = indices[i * 3 + 0], b = indices[i * 3 + 1], c = indices[i * 3 + 2];
 
-		adjacency.data[adjacency.offsets[a]++] = b;
-		adjacency.data[adjacency.offsets[b]++] = c;
-		adjacency.data[adjacency.offsets[c]++] = a;
+		if (remap)
+		{
+			a = remap[a];
+			b = remap[b];
+			c = remap[c];
+		}
+
+		data[offsets[a]].next = b;
+		data[offsets[a]].prev = c;
+		offsets[a]++;
+
+		data[offsets[b]].next = c;
+		data[offsets[b]].prev = a;
+		offsets[b]++;
+
+		data[offsets[c]].next = a;
+		data[offsets[c]].prev = b;
+		offsets[c]++;
 	}
 
-	// fix offsets that have been disturbed by the previous pass
-	for (size_t i = 0; i < vertex_count; ++i)
-	{
-		assert(adjacency.offsets[i] >= adjacency.counts[i]);
-
-		adjacency.offsets[i] -= adjacency.counts[i];
-	}
+	// finalize offsets
+	adjacency.offsets[0] = 0;
+	assert(adjacency.offsets[vertex_count] == index_count);
 }
 
 struct PositionHasher
@@ -86,26 +114,15 @@ struct PositionHasher
 
 	size_t hash(unsigned int index) const
 	{
-		// MurmurHash2
-		const unsigned int m = 0x5bd1e995;
-		const int r = 24;
-
-		unsigned int h = 0;
 		const unsigned int* key = reinterpret_cast<const unsigned int*>(vertex_positions + index * vertex_stride_float);
 
-		for (size_t i = 0; i < 3; ++i)
-		{
-			unsigned int k = key[i];
+		// scramble bits to make sure that integer coordinates have entropy in lower bits
+		unsigned int x = key[0] ^ (key[0] >> 17);
+		unsigned int y = key[1] ^ (key[1] >> 17);
+		unsigned int z = key[2] ^ (key[2] >> 17);
 
-			k *= m;
-			k ^= k >> r;
-			k *= m;
-
-			h *= m;
-			h ^= k;
-		}
-
-		return h;
+		// Optimized Spatial Hashing for Collision Detection of Deformable Objects
+		return (x * 73856093) ^ (y * 19349663) ^ (z * 83492791);
 	}
 
 	bool equal(unsigned int lhs, unsigned int rhs) const
@@ -117,7 +134,7 @@ struct PositionHasher
 static size_t hashBuckets2(size_t count)
 {
 	size_t buckets = 1;
-	while (buckets < count)
+	while (buckets < count + count / 4)
 		buckets *= 2;
 
 	return buckets;
@@ -147,7 +164,7 @@ static T* hashLookup2(T* table, size_t buckets, const Hash& hash, const T& key,
 	}
 
 	assert(false && "Hash table is full"); // unreachable
-	return 0;
+	return NULL;
 }
 
 static void buildPositionRemap(unsigned int* remap, unsigned int* wedge, const float* vertex_positions_data, size_t vertex_count, size_t vertex_positions_stride, meshopt_Allocator& allocator)
@@ -184,6 +201,8 @@ static void buildPositionRemap(unsigned int* remap, unsigned int* wedge, const f
 			wedge[i] = wedge[r];
 			wedge[r] = unsigned(i);
 		}
+
+	allocator.deallocate(table);
 }
 
 enum VertexKind
@@ -223,60 +242,56 @@ const unsigned char kHasOpposite[Kind_Count][Kind_Count] = {
 
 static bool hasEdge(const EdgeAdjacency& adjacency, unsigned int a, unsigned int b)
 {
-	unsigned int count = adjacency.counts[a];
-	const unsigned int* data = adjacency.data + adjacency.offsets[a];
+	unsigned int count = adjacency.offsets[a + 1] - adjacency.offsets[a];
+	const EdgeAdjacency::Edge* edges = adjacency.data + adjacency.offsets[a];
 
 	for (size_t i = 0; i < count; ++i)
-		if (data[i] == b)
+		if (edges[i].next == b)
 			return true;
 
 	return false;
 }
 
-static unsigned int findWedgeEdge(const EdgeAdjacency& adjacency, const unsigned int* wedge, unsigned int a, unsigned int b)
+static void classifyVertices(unsigned char* result, unsigned int* loop, unsigned int* loopback, size_t vertex_count, const EdgeAdjacency& adjacency, const unsigned int* remap, const unsigned int* wedge, unsigned int options)
 {
-	unsigned int v = a;
+	memset(loop, -1, vertex_count * sizeof(unsigned int));
+	memset(loopback, -1, vertex_count * sizeof(unsigned int));
 
-	do
-	{
-		if (hasEdge(adjacency, v, b))
-			return v;
+	// incoming & outgoing open edges: ~0u if no open edges, i if there are more than 1
+	// note that this is the same data as required in loop[] arrays; loop[] data is only valid for border/seam
+	// but here it's okay to fill the data out for other types of vertices as well
+	unsigned int* openinc = loopback;
+	unsigned int* openout = loop;
 
-		v = wedge[v];
-	} while (v != a);
-
-	return ~0u;
-}
-
-static size_t countOpenEdges(const EdgeAdjacency& adjacency, unsigned int vertex, unsigned int* last = 0)
-{
-	size_t result = 0;
-
-	unsigned int count = adjacency.counts[vertex];
-	const unsigned int* data = adjacency.data + adjacency.offsets[vertex];
-
-	for (size_t i = 0; i < count; ++i)
-		if (!hasEdge(adjacency, data[i], vertex))
-		{
-			result++;
-
-			if (last)
-				*last = data[i];
-		}
-
-	return result;
-}
-
-static void classifyVertices(unsigned char* result, unsigned int* loop, size_t vertex_count, const EdgeAdjacency& adjacency, const unsigned int* remap, const unsigned int* wedge)
-{
 	for (size_t i = 0; i < vertex_count; ++i)
-		loop[i] = ~0u;
+	{
+		unsigned int vertex = unsigned(i);
+
+		unsigned int count = adjacency.offsets[vertex + 1] - adjacency.offsets[vertex];
+		const EdgeAdjacency::Edge* edges = adjacency.data + adjacency.offsets[vertex];
+
+		for (size_t j = 0; j < count; ++j)
+		{
+			unsigned int target = edges[j].next;
+
+			if (target == vertex)
+			{
+				// degenerate triangles have two distinct edges instead of three, and the self edge
+				// is bi-directional by definition; this can break border/seam classification by "closing"
+				// the open edge from another triangle and falsely marking the vertex as manifold
+				// instead we mark the vertex as having >1 open edges which turns it into locked/complex
+				openinc[vertex] = openout[vertex] = vertex;
+			}
+			else if (!hasEdge(adjacency, target, vertex))
+			{
+				openinc[target] = (openinc[target] == ~0u) ? vertex : target;
+				openout[vertex] = (openout[vertex] == ~0u) ? target : vertex;
+			}
+		}
+	}
 
 #if TRACE
-	size_t lockedstats[4] = {};
-#define TRACELOCKED(i) lockedstats[i]++;
-#else
-#define TRACELOCKED(i) (void)0
+	size_t stats[4] = {};
 #endif
 
 	for (size_t i = 0; i < vertex_count; ++i)
@@ -286,67 +301,57 @@ static void classifyVertices(unsigned char* result, unsigned int* loop, size_t v
 			if (wedge[i] == i)
 			{
 				// no attribute seam, need to check if it's manifold
-				unsigned int v = 0;
-				size_t edges = countOpenEdges(adjacency, unsigned(i), &v);
+				unsigned int openi = openinc[i], openo = openout[i];
 
 				// note: we classify any vertices with no open edges as manifold
 				// this is technically incorrect - if 4 triangles share an edge, we'll classify vertices as manifold
 				// it's unclear if this is a problem in practice
-				// also note that we classify vertices as border if they have *one* open edge, not two
-				// this is because we only have half-edges - so a border vertex would have one incoming and one outgoing edge
-				if (edges == 0)
+				if (openi == ~0u && openo == ~0u)
 				{
 					result[i] = Kind_Manifold;
 				}
-				else if (edges == 1)
+				else if (openi != i && openo != i)
 				{
 					result[i] = Kind_Border;
-					loop[i] = v;
 				}
 				else
 				{
 					result[i] = Kind_Locked;
-					TRACELOCKED(0);
+					TRACESTATS(0);
 				}
 			}
 			else if (wedge[wedge[i]] == i)
 			{
 				// attribute seam; need to distinguish between Seam and Locked
-				unsigned int a = 0;
-				size_t a_count = countOpenEdges(adjacency, unsigned(i), &a);
-				unsigned int b = 0;
-				size_t b_count = countOpenEdges(adjacency, wedge[i], &b);
+				unsigned int w = wedge[i];
+				unsigned int openiv = openinc[i], openov = openout[i];
+				unsigned int openiw = openinc[w], openow = openout[w];
 
 				// seam should have one open half-edge for each vertex, and the edges need to "connect" - point to the same vertex post-remap
-				if (a_count == 1 && b_count == 1)
+				if (openiv != ~0u && openiv != i && openov != ~0u && openov != i &&
+				    openiw != ~0u && openiw != w && openow != ~0u && openow != w)
 				{
-					unsigned int ao = findWedgeEdge(adjacency, wedge, a, wedge[i]);
-					unsigned int bo = findWedgeEdge(adjacency, wedge, b, unsigned(i));
-
-					if (ao != ~0u && bo != ~0u)
+					if (remap[openiv] == remap[openow] && remap[openov] == remap[openiw])
 					{
 						result[i] = Kind_Seam;
-
-						loop[i] = a;
-						loop[wedge[i]] = b;
 					}
 					else
 					{
 						result[i] = Kind_Locked;
-						TRACELOCKED(1);
+						TRACESTATS(1);
 					}
 				}
 				else
 				{
 					result[i] = Kind_Locked;
-					TRACELOCKED(2);
+					TRACESTATS(2);
 				}
 			}
 			else
 			{
 				// more than one vertex maps to this one; we don't have classification available
 				result[i] = Kind_Locked;
-				TRACELOCKED(3);
+				TRACESTATS(3);
 			}
 		}
 		else
@@ -357,9 +362,14 @@ static void classifyVertices(unsigned char* result, unsigned int* loop, size_t v
 		}
 	}
 
+	if (options & meshopt_SimplifyLockBorder)
+		for (size_t i = 0; i < vertex_count; ++i)
+			if (result[i] == Kind_Border)
+				result[i] = Kind_Locked;
+
 #if TRACE
 	printf("locked: many open edges %d, disconnected seam %d, many seam edges %d, many wedges %d\n",
-	       int(lockedstats[0]), int(lockedstats[1]), int(lockedstats[2]), int(lockedstats[3]));
+	    int(stats[0]), int(stats[1]), int(stats[2]), int(stats[3]));
 #endif
 }
 
@@ -368,7 +378,7 @@ struct Vector3
 	float x, y, z;
 };
 
-static void rescalePositions(Vector3* result, const float* vertex_positions_data, size_t vertex_count, size_t vertex_positions_stride)
+static float rescalePositions(Vector3* result, const float* vertex_positions_data, size_t vertex_count, size_t vertex_positions_stride)
 {
 	size_t vertex_stride_float = vertex_positions_stride / sizeof(float);
 
@@ -379,9 +389,12 @@ static void rescalePositions(Vector3* result, const float* vertex_positions_data
 	{
 		const float* v = vertex_positions_data + i * vertex_stride_float;
 
-		result[i].x = v[0];
-		result[i].y = v[1];
-		result[i].z = v[2];
+		if (result)
+		{
+			result[i].x = v[0];
+			result[i].y = v[1];
+			result[i].z = v[2];
+		}
 
 		for (int j = 0; j < 3; ++j)
 		{
@@ -398,30 +411,67 @@ static void rescalePositions(Vector3* result, const float* vertex_positions_data
 	extent = (maxv[1] - minv[1]) < extent ? extent : (maxv[1] - minv[1]);
 	extent = (maxv[2] - minv[2]) < extent ? extent : (maxv[2] - minv[2]);
 
-	float scale = extent == 0 ? 0.f : 1.f / extent;
+	if (result)
+	{
+		float scale = extent == 0 ? 0.f : 1.f / extent;
+
+		for (size_t i = 0; i < vertex_count; ++i)
+		{
+			result[i].x = (result[i].x - minv[0]) * scale;
+			result[i].y = (result[i].y - minv[1]) * scale;
+			result[i].z = (result[i].z - minv[2]) * scale;
+		}
+	}
+
+	return extent;
+}
+
+static void rescaleAttributes(float* result, const float* vertex_attributes_data, size_t vertex_count, size_t vertex_attributes_stride, const float* attribute_weights, size_t attribute_count)
+{
+	size_t vertex_attributes_stride_float = vertex_attributes_stride / sizeof(float);
 
 	for (size_t i = 0; i < vertex_count; ++i)
 	{
-		result[i].x = (result[i].x - minv[0]) * scale;
-		result[i].y = (result[i].y - minv[1]) * scale;
-		result[i].z = (result[i].z - minv[2]) * scale;
+		for (size_t k = 0; k < attribute_count; ++k)
+		{
+			float a = vertex_attributes_data[i * vertex_attributes_stride_float + k];
+
+			result[i * attribute_count + k] = a * attribute_weights[k];
+		}
 	}
 }
 
+static const size_t kMaxAttributes = 16;
+
 struct Quadric
 {
+	// a00*x^2 + a11*y^2 + a22*z^2 + 2*(a10*xy + a20*xz + a21*yz) + b0*x + b1*y + b2*z + c
 	float a00, a11, a22;
 	float a10, a20, a21;
 	float b0, b1, b2, c;
 	float w;
 };
 
+struct QuadricGrad
+{
+	// gx*x + gy*y + gz*z + gw
+	float gx, gy, gz, gw;
+};
+
+struct Reservoir
+{
+	float x, y, z;
+	float r, g, b;
+	float w;
+};
+
 struct Collapse
 {
 	unsigned int v0;
 	unsigned int v1;
 
-	union {
+	union
+	{
 		unsigned int bidi;
 		float error;
 		unsigned int errorui;
@@ -457,6 +507,17 @@ static void quadricAdd(Quadric& Q, const Quadric& R)
 	Q.w += R.w;
 }
 
+static void quadricAdd(QuadricGrad* G, const QuadricGrad* R, size_t attribute_count)
+{
+	for (size_t k = 0; k < attribute_count; ++k)
+	{
+		G[k].gx += R[k].gx;
+		G[k].gy += R[k].gy;
+		G[k].gz += R[k].gz;
+		G[k].gw += R[k].gw;
+	}
+}
+
 static float quadricError(const Quadric& Q, const Vector3& v)
 {
 	float rx = Q.b0;
@@ -485,6 +546,45 @@ static float quadricError(const Quadric& Q, const Vector3& v)
 	return fabsf(r) * s;
 }
 
+static float quadricError(const Quadric& Q, const QuadricGrad* G, size_t attribute_count, const Vector3& v, const float* va)
+{
+	float rx = Q.b0;
+	float ry = Q.b1;
+	float rz = Q.b2;
+
+	rx += Q.a10 * v.y;
+	ry += Q.a21 * v.z;
+	rz += Q.a20 * v.x;
+
+	rx *= 2;
+	ry *= 2;
+	rz *= 2;
+
+	rx += Q.a00 * v.x;
+	ry += Q.a11 * v.y;
+	rz += Q.a22 * v.z;
+
+	float r = Q.c;
+	r += rx * v.x;
+	r += ry * v.y;
+	r += rz * v.z;
+
+	// see quadricFromAttributes for general derivation; here we need to add the parts of (eval(pos) - attr)^2 that depend on attr
+	for (size_t k = 0; k < attribute_count; ++k)
+	{
+		float a = va[k];
+		float g = v.x * G[k].gx + v.y * G[k].gy + v.z * G[k].gz + G[k].gw;
+
+		r += a * a * Q.w;
+		r -= 2 * a * g;
+	}
+
+	// TODO: weight normalization is breaking attribute error somehow
+	float s = 1;// Q.w == 0.f ? 0.f : 1.f / Q.w;
+
+	return fabsf(r) * s;
+}
+
 static void quadricFromPlane(Quadric& Q, float a, float b, float c, float d, float w)
 {
 	float aw = a * w;
@@ -505,22 +605,6 @@ static void quadricFromPlane(Quadric& Q, float a, float b, float c, float d, flo
 	Q.w = w;
 }
 
-static void quadricFromPoint(Quadric& Q, float x, float y, float z, float w)
-{
-	// we need to encode (x - X) ^ 2 + (y - Y)^2 + (z - Z)^2 into the quadric
-	Q.a00 = w;
-	Q.a11 = w;
-	Q.a22 = w;
-	Q.a10 = 0.f;
-	Q.a20 = 0.f;
-	Q.a21 = 0.f;
-	Q.b0 = -2.f * x * w;
-	Q.b1 = -2.f * y * w;
-	Q.b2 = -2.f * z * w;
-	Q.c = (x * x + y * y + z * z) * w;
-	Q.w = w;
-}
-
 static void quadricFromTriangle(Quadric& Q, const Vector3& p0, const Vector3& p1, const Vector3& p2, float weight)
 {
 	Vector3 p10 = {p1.x - p0.x, p1.y - p0.y, p1.z - p0.z};
@@ -555,6 +639,82 @@ static void quadricFromTriangleEdge(Quadric& Q, const Vector3& p0, const Vector3
 	quadricFromPlane(Q, normal.x, normal.y, normal.z, -distance, length * weight);
 }
 
+static void quadricFromAttributes(Quadric& Q, QuadricGrad* G, const Vector3& p0, const Vector3& p1, const Vector3& p2, const float* va0, const float* va1, const float* va2, size_t attribute_count)
+{
+	// for each attribute we want to encode the following function into the quadric:
+	// (eval(pos) - attr)^2
+	// where eval(pos) interpolates attribute across the triangle like so:
+	// eval(pos) = pos.x * gx + pos.y * gy + pos.z * gz + gw
+	// where gx/gy/gz/gw are gradients
+	Vector3 p10 = {p1.x - p0.x, p1.y - p0.y, p1.z - p0.z};
+	Vector3 p20 = {p2.x - p0.x, p2.y - p0.y, p2.z - p0.z};
+
+	// weight is scaled linearly with edge length
+	Vector3 normal = {p10.y * p20.z - p10.z * p20.y, p10.z * p20.x - p10.x * p20.z, p10.x * p20.y - p10.y * p20.x};
+	float area = sqrtf(normal.x * normal.x + normal.y * normal.y + normal.z * normal.z);
+	float w = sqrtf(area); // TODO this needs more experimentation
+
+	// we compute gradients using barycentric coordinates; barycentric coordinates can be computed as follows:
+	// v = (d11 * d20 - d01 * d21) / denom
+	// w = (d00 * d21 - d01 * d20) / denom
+	// u = 1 - v - w
+	// here v0, v1 are triangle edge vectors, v2 is a vector from point to triangle corner, and dij = dot(vi, vj)
+	const Vector3& v0 = p10;
+	const Vector3& v1 = p20;
+	float d00 = v0.x * v0.x + v0.y * v0.y + v0.z * v0.z;
+	float d01 = v0.x * v1.x + v0.y * v1.y + v0.z * v1.z;
+	float d11 = v1.x * v1.x + v1.y * v1.y + v1.z * v1.z;
+	float denom = d00 * d11 - d01 * d01;
+	float denomr = denom == 0 ? 0.f : 1.f / denom;
+
+	// precompute gradient factors
+	// these are derived by directly computing derivative of eval(pos) = a0 * u + a1 * v + a2 * w and factoring out common factors that are shared between attributes
+	float gx1 = (d11 * v0.x - d01 * v1.x) * denomr;
+	float gx2 = (d00 * v1.x - d01 * v0.x) * denomr;
+	float gy1 = (d11 * v0.y - d01 * v1.y) * denomr;
+	float gy2 = (d00 * v1.y - d01 * v0.y) * denomr;
+	float gz1 = (d11 * v0.z - d01 * v1.z) * denomr;
+	float gz2 = (d00 * v1.z - d01 * v0.z) * denomr;
+
+	memset(&Q, 0, sizeof(Quadric));
+
+	Q.w = w;
+
+	for (size_t k = 0; k < attribute_count; ++k)
+	{
+		float a0 = va0[k], a1 = va1[k], a2 = va2[k];
+
+		// compute gradient of eval(pos) for x/y/z/w
+		// the formulas below are obtained by directly computing derivative of eval(pos) = a0 * u + a1 * v + a2 * w
+		float gx = gx1 * (a1 - a0) + gx2 * (a2 - a0);
+		float gy = gy1 * (a1 - a0) + gy2 * (a2 - a0);
+		float gz = gz1 * (a1 - a0) + gz2 * (a2 - a0);
+		float gw = a0 - p0.x * gx - p0.y * gy - p0.z * gz;
+
+		// quadric encodes (eval(pos)-attr)^2; this means that the resulting expansion needs to compute, for example, pos.x * pos.y * K
+		// since quadrics already encode factors for pos.x * pos.y, we can accumulate almost everything in basic quadric fields
+		Q.a00 += w * (gx * gx);
+		Q.a11 += w * (gy * gy);
+		Q.a22 += w * (gz * gz);
+
+		Q.a10 += w * (gy * gx);
+		Q.a20 += w * (gz * gx);
+		Q.a21 += w * (gz * gy);
+
+		Q.b0 += w * (gx * gw);
+		Q.b1 += w * (gy * gw);
+		Q.b2 += w * (gz * gw);
+
+		Q.c += w * (gw * gw);
+
+		// the only remaining sum components are ones that depend on attr; these will be addded during error evaluation, see quadricError
+		G[k].gx = w * gx;
+		G[k].gy = w * gy;
+		G[k].gz = w * gz;
+		G[k].gw = w * gw;
+	}
+}
+
 static void fillFaceQuadrics(Quadric* vertex_quadrics, const unsigned int* indices, size_t index_count, const Vector3* vertex_positions, const unsigned int* remap)
 {
 	for (size_t i = 0; i < index_count; i += 3)
@@ -572,11 +732,11 @@ static void fillFaceQuadrics(Quadric* vertex_quadrics, const unsigned int* indic
 	}
 }
 
-static void fillEdgeQuadrics(Quadric* vertex_quadrics, const unsigned int* indices, size_t index_count, const Vector3* vertex_positions, const unsigned int* remap, const unsigned char* vertex_kind, const unsigned int* loop)
+static void fillEdgeQuadrics(Quadric* vertex_quadrics, const unsigned int* indices, size_t index_count, const Vector3* vertex_positions, const unsigned int* remap, const unsigned char* vertex_kind, const unsigned int* loop, const unsigned int* loopback)
 {
 	for (size_t i = 0; i < index_count; i += 3)
 	{
-		static const int next[3] = {1, 2, 0};
+		static const int next[4] = {1, 2, 0, 1};
 
 		for (int e = 0; e < 3; ++e)
 		{
@@ -586,19 +746,30 @@ static void fillEdgeQuadrics(Quadric* vertex_quadrics, const unsigned int* indic
 			unsigned char k0 = vertex_kind[i0];
 			unsigned char k1 = vertex_kind[i1];
 
-			// check that i0 and i1 are border/seam and are on the same edge loop
-			// loop[] tracks half edges so we only need to check i0->i1
-			if (k0 != k1 || (k0 != Kind_Border && k0 != Kind_Seam) || loop[i0] != i1)
+			// check that either i0 or i1 are border/seam and are on the same edge loop
+			// note that we need to add the error even for edged that connect e.g. border & locked
+			// if we don't do that, the adjacent border->border edge won't have correct errors for corners
+			if (k0 != Kind_Border && k0 != Kind_Seam && k1 != Kind_Border && k1 != Kind_Seam)
 				continue;
 
-			unsigned int i2 = indices[i + next[next[e]]];
+			if ((k0 == Kind_Border || k0 == Kind_Seam) && loop[i0] != i1)
+				continue;
+
+			if ((k1 == Kind_Border || k1 == Kind_Seam) && loopback[i1] != i0)
+				continue;
+
+			// seam edges should occur twice (i0->i1 and i1->i0) - skip redundant edges
+			if (kHasOpposite[k0][k1] && remap[i1] > remap[i0])
+				continue;
+
+			unsigned int i2 = indices[i + next[e + 1]];
 
 			// we try hard to maintain border edge geometry; seam edges can move more freely
 			// due to topological restrictions on collapses, seam quadrics slightly improves collapse structure but aren't critical
 			const float kEdgeWeightSeam = 1.f;
 			const float kEdgeWeightBorder = 10.f;
 
-			float edgeWeight = (k0 == Kind_Seam) ? kEdgeWeightSeam : kEdgeWeightBorder;
+			float edgeWeight = (k0 == Kind_Border || k1 == Kind_Border) ? kEdgeWeightBorder : kEdgeWeightSeam;
 
 			Quadric Q;
 			quadricFromTriangleEdge(Q, vertex_positions[i0], vertex_positions[i1], vertex_positions[i2], edgeWeight);
@@ -609,7 +780,89 @@ static void fillEdgeQuadrics(Quadric* vertex_quadrics, const unsigned int* indic
 	}
 }
 
-static size_t pickEdgeCollapses(Collapse* collapses, const unsigned int* indices, size_t index_count, const unsigned int* remap, const unsigned char* vertex_kind, const unsigned int* loop)
+static void fillAttributeQuadrics(Quadric* attribute_quadrics, QuadricGrad* attribute_gradients, const unsigned int* indices, size_t index_count, const Vector3* vertex_positions, const float* vertex_attributes, size_t attribute_count, const unsigned int* remap)
+{
+	for (size_t i = 0; i < index_count; i += 3)
+	{
+		unsigned int i0 = indices[i + 0];
+		unsigned int i1 = indices[i + 1];
+		unsigned int i2 = indices[i + 2];
+
+		Quadric QA;
+		QuadricGrad G[kMaxAttributes];
+		quadricFromAttributes(QA, G, vertex_positions[i0], vertex_positions[i1], vertex_positions[i2], &vertex_attributes[i0 * attribute_count], &vertex_attributes[i1 * attribute_count], &vertex_attributes[i2 * attribute_count], attribute_count);
+
+		// TODO: This blends together attribute weights across attribute discontinuities, which is probably not a great idea
+		quadricAdd(attribute_quadrics[remap[i0]], QA);
+		quadricAdd(attribute_quadrics[remap[i1]], QA);
+		quadricAdd(attribute_quadrics[remap[i2]], QA);
+
+		quadricAdd(&attribute_gradients[remap[i0] * attribute_count], G, attribute_count);
+		quadricAdd(&attribute_gradients[remap[i1] * attribute_count], G, attribute_count);
+		quadricAdd(&attribute_gradients[remap[i2] * attribute_count], G, attribute_count);
+	}
+}
+
+// does triangle ABC flip when C is replaced with D?
+static bool hasTriangleFlip(const Vector3& a, const Vector3& b, const Vector3& c, const Vector3& d)
+{
+	Vector3 eb = {b.x - a.x, b.y - a.y, b.z - a.z};
+	Vector3 ec = {c.x - a.x, c.y - a.y, c.z - a.z};
+	Vector3 ed = {d.x - a.x, d.y - a.y, d.z - a.z};
+
+	Vector3 nbc = {eb.y * ec.z - eb.z * ec.y, eb.z * ec.x - eb.x * ec.z, eb.x * ec.y - eb.y * ec.x};
+	Vector3 nbd = {eb.y * ed.z - eb.z * ed.y, eb.z * ed.x - eb.x * ed.z, eb.x * ed.y - eb.y * ed.x};
+
+	return nbc.x * nbd.x + nbc.y * nbd.y + nbc.z * nbd.z <= 0;
+}
+
+static bool hasTriangleFlips(const EdgeAdjacency& adjacency, const Vector3* vertex_positions, const unsigned int* collapse_remap, unsigned int i0, unsigned int i1)
+{
+	assert(collapse_remap[i0] == i0);
+	assert(collapse_remap[i1] == i1);
+
+	const Vector3& v0 = vertex_positions[i0];
+	const Vector3& v1 = vertex_positions[i1];
+
+	const EdgeAdjacency::Edge* edges = &adjacency.data[adjacency.offsets[i0]];
+	size_t count = adjacency.offsets[i0 + 1] - adjacency.offsets[i0];
+
+	for (size_t i = 0; i < count; ++i)
+	{
+		unsigned int a = collapse_remap[edges[i].next];
+		unsigned int b = collapse_remap[edges[i].prev];
+
+		// skip triangles that will get collapsed by i0->i1 collapse or already got collapsed previously
+		if (a == i1 || b == i1 || a == b)
+			continue;
+
+		// early-out when at least one triangle flips due to a collapse
+		if (hasTriangleFlip(vertex_positions[a], vertex_positions[b], v0, v1))
+			return true;
+	}
+
+	return false;
+}
+
+static size_t boundEdgeCollapses(const EdgeAdjacency& adjacency, size_t vertex_count, size_t index_count, unsigned char* vertex_kind)
+{
+	size_t dual_count = 0;
+
+	for (size_t i = 0; i < vertex_count; ++i)
+	{
+		unsigned char k = vertex_kind[i];
+		unsigned int e = adjacency.offsets[i + 1] - adjacency.offsets[i];
+
+		dual_count += (k == Kind_Manifold || k == Kind_Seam) ? e : 0;
+	}
+
+	assert(dual_count <= index_count);
+
+	// pad capacity by 3 so that we can check for overflow once per triangle instead of once per edge
+	return (index_count - dual_count / 2) + 3;
+}
+
+static size_t pickEdgeCollapses(Collapse* collapses, size_t collapse_capacity, const unsigned int* indices, size_t index_count, const unsigned int* remap, const unsigned char* vertex_kind, const unsigned int* loop)
 {
 	size_t collapse_count = 0;
 
@@ -617,6 +870,10 @@ static size_t pickEdgeCollapses(Collapse* collapses, const unsigned int* indices
 	{
 		static const int next[3] = {1, 2, 0};
 
+		// this should never happen as boundEdgeCollapses should give an upper bound for the collapse count, but in an unlikely event it does we can just drop extra collapses
+		if (collapse_count + 3 > collapse_capacity)
+			break;
+
 		for (int e = 0; e < 3; ++e)
 		{
 			unsigned int i0 = indices[i + e];
@@ -667,7 +924,7 @@ static size_t pickEdgeCollapses(Collapse* collapses, const unsigned int* indices
 	return collapse_count;
 }
 
-static void rankEdgeCollapses(Collapse* collapses, size_t collapse_count, const Vector3* vertex_positions, const Quadric* vertex_quadrics, const unsigned int* remap)
+static void rankEdgeCollapses(Collapse* collapses, size_t collapse_count, const Vector3* vertex_positions, const float* vertex_attributes, const Quadric* vertex_quadrics, const Quadric* attribute_quadrics, const QuadricGrad* attribute_gradients, size_t attribute_count, const unsigned int* remap)
 {
 	for (size_t i = 0; i < collapse_count; ++i)
 	{
@@ -681,11 +938,14 @@ static void rankEdgeCollapses(Collapse* collapses, size_t collapse_count, const
 		unsigned int j0 = c.bidi ? i1 : i0;
 		unsigned int j1 = c.bidi ? i0 : i1;
 
-		const Quadric& qi = vertex_quadrics[remap[i0]];
-		const Quadric& qj = vertex_quadrics[remap[j0]];
+		float ei = quadricError(vertex_quadrics[remap[i0]], vertex_positions[i1]);
+		float ej = quadricError(vertex_quadrics[remap[j0]], vertex_positions[j1]);
 
-		float ei = quadricError(qi, vertex_positions[i1]);
-		float ej = quadricError(qj, vertex_positions[j1]);
+		if (attribute_count)
+		{
+			ei += quadricError(attribute_quadrics[remap[i0]], &attribute_gradients[remap[i0] * attribute_count], attribute_count, vertex_positions[i1], &vertex_attributes[i1 * attribute_count]);
+			ej += quadricError(attribute_quadrics[remap[j0]], &attribute_gradients[remap[j0] * attribute_count], attribute_count, vertex_positions[j1], &vertex_attributes[j1 * attribute_count]);
+		}
 
 		// pick edge direction with minimal error
 		c.v0 = ei <= ej ? i0 : j0;
@@ -694,61 +954,6 @@ static void rankEdgeCollapses(Collapse* collapses, size_t collapse_count, const
 	}
 }
 
-#if TRACE > 1
-static void dumpEdgeCollapses(const Collapse* collapses, size_t collapse_count, const unsigned char* vertex_kind)
-{
-	size_t ckinds[Kind_Count][Kind_Count] = {};
-	float cerrors[Kind_Count][Kind_Count] = {};
-
-	for (int k0 = 0; k0 < Kind_Count; ++k0)
-		for (int k1 = 0; k1 < Kind_Count; ++k1)
-			cerrors[k0][k1] = FLT_MAX;
-
-	for (size_t i = 0; i < collapse_count; ++i)
-	{
-		unsigned int i0 = collapses[i].v0;
-		unsigned int i1 = collapses[i].v1;
-
-		unsigned char k0 = vertex_kind[i0];
-		unsigned char k1 = vertex_kind[i1];
-
-		ckinds[k0][k1]++;
-		cerrors[k0][k1] = (collapses[i].error < cerrors[k0][k1]) ? collapses[i].error : cerrors[k0][k1];
-	}
-
-	for (int k0 = 0; k0 < Kind_Count; ++k0)
-		for (int k1 = 0; k1 < Kind_Count; ++k1)
-			if (ckinds[k0][k1])
-				printf("collapses %d -> %d: %d, min error %e\n", k0, k1, int(ckinds[k0][k1]), cerrors[k0][k1]);
-}
-
-static void dumpLockedCollapses(const unsigned int* indices, size_t index_count, const unsigned char* vertex_kind)
-{
-	size_t locked_collapses[Kind_Count][Kind_Count] = {};
-
-	for (size_t i = 0; i < index_count; i += 3)
-	{
-		static const int next[3] = {1, 2, 0};
-
-		for (int e = 0; e < 3; ++e)
-		{
-			unsigned int i0 = indices[i + e];
-			unsigned int i1 = indices[i + next[e]];
-
-			unsigned char k0 = vertex_kind[i0];
-			unsigned char k1 = vertex_kind[i1];
-
-			locked_collapses[k0][k1] += !kCanCollapse[k0][k1] && !kCanCollapse[k1][k0];
-		}
-	}
-
-	for (int k0 = 0; k0 < Kind_Count; ++k0)
-		for (int k1 = 0; k1 < Kind_Count; ++k1)
-			if (locked_collapses[k0][k1])
-				printf("locked collapses %d -> %d: %d\n", k0, k1, int(locked_collapses[k0][k1]));
-}
-#endif
-
 static void sortEdgeCollapses(unsigned int* sort_order, const Collapse* collapses, size_t collapse_count)
 {
 	const int sort_bits = 11;
@@ -787,22 +992,38 @@ static void sortEdgeCollapses(unsigned int* sort_order, const Collapse* collapse
 	}
 }
 
-static size_t performEdgeCollapses(unsigned int* collapse_remap, unsigned char* collapse_locked, Quadric* vertex_quadrics, const Collapse* collapses, size_t collapse_count, const unsigned int* collapse_order, const unsigned int* remap, const unsigned int* wedge, const unsigned char* vertex_kind, size_t triangle_collapse_goal, float error_goal, float error_limit)
+static size_t performEdgeCollapses(unsigned int* collapse_remap, unsigned char* collapse_locked, Quadric* vertex_quadrics, Quadric* attribute_quadrics, QuadricGrad* attribute_gradients, size_t attribute_count, const Collapse* collapses, size_t collapse_count, const unsigned int* collapse_order, const unsigned int* remap, const unsigned int* wedge, const unsigned char* vertex_kind, const Vector3* vertex_positions, const EdgeAdjacency& adjacency, size_t triangle_collapse_goal, float error_limit, float& result_error)
 {
 	size_t edge_collapses = 0;
 	size_t triangle_collapses = 0;
 
+	// most collapses remove 2 triangles; use this to establish a bound on the pass in terms of error limit
+	// note that edge_collapse_goal is an estimate; triangle_collapse_goal will be used to actually limit collapses
+	size_t edge_collapse_goal = triangle_collapse_goal / 2;
+
+#if TRACE
+	size_t stats[4] = {};
+#endif
+
 	for (size_t i = 0; i < collapse_count; ++i)
 	{
 		const Collapse& c = collapses[collapse_order[i]];
 
+		TRACESTATS(0);
+
 		if (c.error > error_limit)
 			break;
 
-		if (c.error > error_goal && triangle_collapses > triangle_collapse_goal / 10)
+		if (triangle_collapses >= triangle_collapse_goal)
 			break;
 
-		if (triangle_collapses >= triangle_collapse_goal)
+		// we limit the error in each pass based on the error of optimal last collapse; since many collapses will be locked
+		// as they will share vertices with other successfull collapses, we need to increase the acceptable error by some factor
+		float error_goal = edge_collapse_goal < collapse_count ? 1.5f * collapses[collapse_order[edge_collapse_goal]].error : FLT_MAX;
+
+		// on average, each collapse is expected to lock 6 other collapses; to avoid degenerate passes on meshes with odd
+		// topology, we only abort if we got over 1/6 collapses accordingly.
+		if (c.error > error_goal && triangle_collapses > triangle_collapse_goal / 6)
 			break;
 
 		unsigned int i0 = c.v0;
@@ -815,13 +1036,31 @@ static size_t performEdgeCollapses(unsigned int* collapse_remap, unsigned char*
 		// it's important to not move the vertices twice since it complicates the tracking/remapping logic
 		// it's important to not move other vertices towards a moved vertex to preserve error since we don't re-rank collapses mid-pass
 		if (collapse_locked[r0] | collapse_locked[r1])
+		{
+			TRACESTATS(1);
 			continue;
+		}
+
+		if (hasTriangleFlips(adjacency, vertex_positions, collapse_remap, r0, r1))
+		{
+			// adjust collapse goal since this collapse is invalid and shouldn't factor into error goal
+			edge_collapse_goal++;
+
+			TRACESTATS(2);
+			continue;
+		}
 
 		assert(collapse_remap[r0] == r0);
 		assert(collapse_remap[r1] == r1);
 
 		quadricAdd(vertex_quadrics[r1], vertex_quadrics[r0]);
 
+		if (attribute_count)
+		{
+			quadricAdd(attribute_quadrics[r1], attribute_quadrics[r0]);
+			quadricAdd(&attribute_gradients[r1 * attribute_count], &attribute_gradients[r0 * attribute_count], attribute_count);
+		}
+
 		if (vertex_kind[i0] == Kind_Complex)
 		{
 			unsigned int v = i0;
@@ -857,8 +1096,18 @@ static size_t performEdgeCollapses(unsigned int* collapse_remap, unsigned char*
 		// border edges collapse 1 triangle, other edges collapse 2 or more
 		triangle_collapses += (vertex_kind[i0] == Kind_Border) ? 1 : 2;
 		edge_collapses++;
+
+		result_error = result_error < c.error ? c.error : result_error;
 	}
 
+#if TRACE
+	float error_goal_perfect = edge_collapse_goal < collapse_count ? collapses[collapse_order[edge_collapse_goal]].error : 0.f;
+
+	printf("removed %d triangles, error %e (goal %e); evaluated %d/%d collapses (done %d, skipped %d, invalid %d)\n",
+	    int(triangle_collapses), sqrtf(result_error), sqrtf(error_goal_perfect),
+	    int(stats[0]), int(collapse_count), int(edge_collapses), int(stats[1]), int(stats[2]));
+#endif
+
 	return edge_collapses;
 }
 
@@ -946,7 +1195,7 @@ struct IdHasher
 
 struct TriangleHasher
 {
-	unsigned int* indices;
+	const unsigned int* indices;
 
 	size_t hash(unsigned int i) const
 	{
@@ -1074,17 +1323,41 @@ static void fillCellQuadrics(Quadric* cell_quadrics, const unsigned int* indices
 	}
 }
 
-static void fillCellQuadrics(Quadric* cell_quadrics, const Vector3* vertex_positions, size_t vertex_count, const unsigned int* vertex_cells)
+static void fillCellReservoirs(Reservoir* cell_reservoirs, size_t cell_count, const Vector3* vertex_positions, const float* vertex_colors, size_t vertex_colors_stride, size_t vertex_count, const unsigned int* vertex_cells)
 {
+	static const float dummy_color[] = { 0.f, 0.f, 0.f };
+
+	size_t vertex_colors_stride_float = vertex_colors_stride / sizeof(float);
+
 	for (size_t i = 0; i < vertex_count; ++i)
 	{
-		unsigned int c = vertex_cells[i];
+		unsigned int cell = vertex_cells[i];
 		const Vector3& v = vertex_positions[i];
+		Reservoir& r = cell_reservoirs[cell];
 
-		Quadric Q;
-		quadricFromPoint(Q, v.x, v.y, v.z, 1.f);
+		const float* color = vertex_colors ? &vertex_colors[i * vertex_colors_stride_float] : dummy_color;
 
-		quadricAdd(cell_quadrics[c], Q);
+		r.x += v.x;
+		r.y += v.y;
+		r.z += v.z;
+		r.r += color[0];
+		r.g += color[1];
+		r.b += color[2];
+		r.w += 1.f;
+	}
+
+	for (size_t i = 0; i < cell_count; ++i)
+	{
+		Reservoir& r = cell_reservoirs[i];
+
+		float iw = r.w == 0.f ? 0.f : 1.f / r.w;
+
+		r.x *= iw;
+		r.y *= iw;
+		r.z *= iw;
+		r.r *= iw;
+		r.g *= iw;
+		r.b *= iw;
 	}
 }
 
@@ -1105,6 +1378,34 @@ static void fillCellRemap(unsigned int* cell_remap, float* cell_errors, size_t c
 	}
 }
 
+static void fillCellRemap(unsigned int* cell_remap, float* cell_errors, size_t cell_count, const unsigned int* vertex_cells, const Reservoir* cell_reservoirs, const Vector3* vertex_positions, const float* vertex_colors, size_t vertex_colors_stride, float color_weight, size_t vertex_count)
+{
+	static const float dummy_color[] = { 0.f, 0.f, 0.f };
+
+	size_t vertex_colors_stride_float = vertex_colors_stride / sizeof(float);
+
+	memset(cell_remap, -1, cell_count * sizeof(unsigned int));
+
+	for (size_t i = 0; i < vertex_count; ++i)
+	{
+		unsigned int cell = vertex_cells[i];
+		const Vector3& v = vertex_positions[i];
+		const Reservoir& r = cell_reservoirs[cell];
+
+		const float* color = vertex_colors ? &vertex_colors[i * vertex_colors_stride_float] : dummy_color;
+
+		float pos_error = (v.x - r.x) * (v.x - r.x) + (v.y - r.y) * (v.y - r.y) + (v.z - r.z) * (v.z - r.z);
+		float col_error = (color[0] - r.r) * (color[0] - r.r) + (color[1] - r.g) * (color[1] - r.g) + (color[2] - r.b) * (color[2] - r.b);
+		float error = pos_error + color_weight * col_error;
+
+		if (cell_remap[cell] == ~0u || cell_errors[cell] > error)
+		{
+			cell_remap[cell] = unsigned(i);
+			cell_errors[cell] = error;
+		}
+	}
+}
+
 static size_t filterTriangles(unsigned int* destination, unsigned int* tritable, size_t tritable_size, const unsigned int* indices, size_t index_count, const unsigned int* vertex_cells, const unsigned int* cell_remap)
 {
 	TriangleHasher hasher = {destination};
@@ -1160,19 +1461,25 @@ static float interpolate(float y, float x0, float y0, float x1, float y1, float
 
 } // namespace meshopt
 
-#if TRACE
-unsigned char* meshopt_simplifyDebugKind = 0;
-unsigned int* meshopt_simplifyDebugLoop = 0;
+#ifndef NDEBUG
+// Note: this is only exposed for debug visualization purposes; do *not* use these in debug builds
+MESHOPTIMIZER_API unsigned char* meshopt_simplifyDebugKind = NULL;
+MESHOPTIMIZER_API unsigned int* meshopt_simplifyDebugLoop = NULL;
+MESHOPTIMIZER_API unsigned int* meshopt_simplifyDebugLoopBack = NULL;
 #endif
 
-size_t meshopt_simplify(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions_data, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error)
+size_t meshopt_simplifyEdge(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions_data, size_t vertex_count, size_t vertex_positions_stride, const float* vertex_attributes_data, size_t vertex_attributes_stride, const float* attribute_weights, size_t attribute_count, size_t target_index_count, float target_error, unsigned int options, float* out_result_error)
 {
 	using namespace meshopt;
 
 	assert(index_count % 3 == 0);
-	assert(vertex_positions_stride > 0 && vertex_positions_stride <= 256);
+	assert(vertex_positions_stride >= 12 && vertex_positions_stride <= 256);
 	assert(vertex_positions_stride % sizeof(float) == 0);
 	assert(target_index_count <= index_count);
+	assert((options & ~(meshopt_SimplifyLockBorder)) == 0);
+	assert(vertex_attributes_stride >= attribute_count * sizeof(float) && vertex_attributes_stride <= 256);
+	assert(vertex_attributes_stride % sizeof(float) == 0);
+	assert(attribute_count <= kMaxAttributes);
 
 	meshopt_Allocator allocator;
 
@@ -1180,7 +1487,8 @@ size_t meshopt_simplify(unsigned int* destination, const unsigned int* indices,
 
 	// build adjacency information
 	EdgeAdjacency adjacency = {};
-	buildEdgeAdjacency(adjacency, indices, index_count, vertex_count, allocator);
+	prepareEdgeAdjacency(adjacency, index_count, vertex_count, allocator);
+	updateEdgeAdjacency(adjacency, indices, index_count, vertex_count, NULL);
 
 	// build position remap that maps each vertex to the one with identical position
 	unsigned int* remap = allocator.allocate<unsigned int>(vertex_count);
@@ -1190,7 +1498,8 @@ size_t meshopt_simplify(unsigned int* destination, const unsigned int* indices,
 	// classify vertices; vertex kind determines collapse rules, see kCanCollapse
 	unsigned char* vertex_kind = allocator.allocate<unsigned char>(vertex_count);
 	unsigned int* loop = allocator.allocate<unsigned int>(vertex_count);
-	classifyVertices(vertex_kind, loop, vertex_count, adjacency, remap, wedge);
+	unsigned int* loopback = allocator.allocate<unsigned int>(vertex_count);
+	classifyVertices(vertex_kind, loop, loopback, vertex_count, adjacency, remap, wedge, options);
 
 #if TRACE
 	size_t unique_positions = 0;
@@ -1204,132 +1513,147 @@ size_t meshopt_simplify(unsigned int* destination, const unsigned int* indices,
 		kinds[vertex_kind[i]] += remap[i] == i;
 
 	printf("kinds: manifold %d, border %d, seam %d, complex %d, locked %d\n",
-	       int(kinds[Kind_Manifold]), int(kinds[Kind_Border]), int(kinds[Kind_Seam]), int(kinds[Kind_Complex]), int(kinds[Kind_Locked]));
+	    int(kinds[Kind_Manifold]), int(kinds[Kind_Border]), int(kinds[Kind_Seam]), int(kinds[Kind_Complex]), int(kinds[Kind_Locked]));
 #endif
 
 	Vector3* vertex_positions = allocator.allocate<Vector3>(vertex_count);
 	rescalePositions(vertex_positions, vertex_positions_data, vertex_count, vertex_positions_stride);
 
+	float* vertex_attributes = NULL;
+
+	if (attribute_count)
+	{
+		vertex_attributes = allocator.allocate<float>(vertex_count * attribute_count);
+		rescaleAttributes(vertex_attributes, vertex_attributes_data, vertex_count, vertex_attributes_stride, attribute_weights, attribute_count);
+	}
+
 	Quadric* vertex_quadrics = allocator.allocate<Quadric>(vertex_count);
 	memset(vertex_quadrics, 0, vertex_count * sizeof(Quadric));
 
+	Quadric* attribute_quadrics = NULL;
+	QuadricGrad* attribute_gradients = NULL;
+
+	if (attribute_count)
+	{
+		attribute_quadrics = allocator.allocate<Quadric>(vertex_count);
+		memset(attribute_quadrics, 0, vertex_count * sizeof(Quadric));
+
+		attribute_gradients = allocator.allocate<QuadricGrad>(vertex_count * attribute_count);
+		memset(attribute_gradients, 0, vertex_count * attribute_count * sizeof(QuadricGrad));
+	}
+
 	fillFaceQuadrics(vertex_quadrics, indices, index_count, vertex_positions, remap);
-	fillEdgeQuadrics(vertex_quadrics, indices, index_count, vertex_positions, remap, vertex_kind, loop);
+	fillEdgeQuadrics(vertex_quadrics, indices, index_count, vertex_positions, remap, vertex_kind, loop, loopback);
+
+	if (attribute_count)
+		fillAttributeQuadrics(attribute_quadrics, attribute_gradients, indices, index_count, vertex_positions, vertex_attributes, attribute_count, remap);
 
 	if (result != indices)
 		memcpy(result, indices, index_count * sizeof(unsigned int));
 
 #if TRACE
 	size_t pass_count = 0;
-	float worst_error = 0;
 #endif
 
-	Collapse* edge_collapses = allocator.allocate<Collapse>(index_count);
-	unsigned int* collapse_order = allocator.allocate<unsigned int>(index_count);
+	size_t collapse_capacity = boundEdgeCollapses(adjacency, vertex_count, index_count, vertex_kind);
+
+	Collapse* edge_collapses = allocator.allocate<Collapse>(collapse_capacity);
+	unsigned int* collapse_order = allocator.allocate<unsigned int>(collapse_capacity);
 	unsigned int* collapse_remap = allocator.allocate<unsigned int>(vertex_count);
 	unsigned char* collapse_locked = allocator.allocate<unsigned char>(vertex_count);
 
 	size_t result_count = index_count;
+	float result_error = 0;
 
 	// target_error input is linear; we need to adjust it to match quadricError units
 	float error_limit = target_error * target_error;
 
 	while (result_count > target_index_count)
 	{
-		size_t edge_collapse_count = pickEdgeCollapses(edge_collapses, result, result_count, remap, vertex_kind, loop);
+		// note: throughout the simplification process adjacency structure reflects welded topology for result-in-progress
+		updateEdgeAdjacency(adjacency, result, result_count, vertex_count, remap);
+
+		size_t edge_collapse_count = pickEdgeCollapses(edge_collapses, collapse_capacity, result, result_count, remap, vertex_kind, loop);
+		assert(edge_collapse_count <= collapse_capacity);
 
 		// no edges can be collapsed any more due to topology restrictions
 		if (edge_collapse_count == 0)
 			break;
 
-		rankEdgeCollapses(edge_collapses, edge_collapse_count, vertex_positions, vertex_quadrics, remap);
-
-#if TRACE > 1
-		dumpEdgeCollapses(edge_collapses, edge_collapse_count, vertex_kind);
-#endif
+		rankEdgeCollapses(edge_collapses, edge_collapse_count, vertex_positions, vertex_attributes, vertex_quadrics, attribute_quadrics, attribute_gradients, attribute_count, remap);
 
 		sortEdgeCollapses(collapse_order, edge_collapses, edge_collapse_count);
 
-		// most collapses remove 2 triangles; use this to establish a bound on the pass in terms of error limit
-		// note that edge_collapse_goal is an estimate; triangle_collapse_goal will be used to actually limit collapses
 		size_t triangle_collapse_goal = (result_count - target_index_count) / 3;
-		size_t edge_collapse_goal = triangle_collapse_goal / 2;
-
-		// we limit the error in each pass based on the error of optimal last collapse; since many collapses will be locked
-		// as they will share vertices with other successfull collapses, we need to increase the acceptable error by this factor
-		const float kPassErrorBound = 1.5f;
-
-		float error_goal = edge_collapse_goal < edge_collapse_count ? edge_collapses[collapse_order[edge_collapse_goal]].error * kPassErrorBound : FLT_MAX;
 
 		for (size_t i = 0; i < vertex_count; ++i)
 			collapse_remap[i] = unsigned(i);
 
 		memset(collapse_locked, 0, vertex_count);
 
-		size_t collapses = performEdgeCollapses(collapse_remap, collapse_locked, vertex_quadrics, edge_collapses, edge_collapse_count, collapse_order, remap, wedge, vertex_kind, triangle_collapse_goal, error_goal, error_limit);
+#if TRACE
+		printf("pass %d: ", int(pass_count++));
+#endif
+
+		size_t collapses = performEdgeCollapses(collapse_remap, collapse_locked, vertex_quadrics, attribute_quadrics, attribute_gradients, attribute_count, edge_collapses, edge_collapse_count, collapse_order, remap, wedge, vertex_kind, vertex_positions, adjacency, triangle_collapse_goal, error_limit, result_error);
 
 		// no edges can be collapsed any more due to hitting the error limit or triangle collapse limit
 		if (collapses == 0)
 			break;
 
 		remapEdgeLoops(loop, vertex_count, collapse_remap);
+		remapEdgeLoops(loopback, vertex_count, collapse_remap);
 
 		size_t new_count = remapIndexBuffer(result, result_count, collapse_remap);
 		assert(new_count < result_count);
 
-#if TRACE
-		float pass_error = 0.f;
-		for (size_t i = 0; i < edge_collapse_count; ++i)
-		{
-			Collapse& c = edge_collapses[collapse_order[i]];
-
-			if (collapse_remap[c.v0] == c.v1)
-				pass_error = c.error;
-		}
-
-		pass_count++;
-		worst_error = (worst_error < pass_error) ? pass_error : worst_error;
-
-		printf("pass %d: triangles: %d -> %d, collapses: %d/%d (goal: %d), error: %e (limit %e goal %e)\n", int(pass_count), int(result_count / 3), int(new_count / 3), int(collapses), int(edge_collapse_count), int(edge_collapse_goal), pass_error, error_limit, error_goal);
-#endif
-
 		result_count = new_count;
 	}
 
 #if TRACE
-	printf("passes: %d, worst error: %e\n", int(pass_count), worst_error);
+	printf("result: %d triangles, error: %e; total %d passes\n", int(result_count), sqrtf(result_error), int(pass_count));
 #endif
 
-#if TRACE > 1
-	dumpLockedCollapses(result, result_count, vertex_kind);
-#endif
-
-#if TRACE
+#ifndef NDEBUG
 	if (meshopt_simplifyDebugKind)
 		memcpy(meshopt_simplifyDebugKind, vertex_kind, vertex_count);
 
 	if (meshopt_simplifyDebugLoop)
 		memcpy(meshopt_simplifyDebugLoop, loop, vertex_count * sizeof(unsigned int));
+
+	if (meshopt_simplifyDebugLoopBack)
+		memcpy(meshopt_simplifyDebugLoopBack, loopback, vertex_count * sizeof(unsigned int));
 #endif
 
+	// result_error is quadratic; we need to remap it back to linear
+	if (out_result_error)
+		*out_result_error = sqrtf(result_error);
+
 	return result_count;
 }
 
-size_t meshopt_simplifySloppy(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions_data, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count)
+size_t meshopt_simplify(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions_data, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error, unsigned int options, float* out_result_error)
+{
+	return meshopt_simplifyEdge(destination, indices, index_count, vertex_positions_data, vertex_count, vertex_positions_stride, NULL, 0, NULL, 0, target_index_count, target_error, options, out_result_error);
+}
+
+size_t meshopt_simplifyWithAttributes(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions_data, size_t vertex_count, size_t vertex_positions_stride, const float* vertex_attributes_data, size_t vertex_attributes_stride, const float* attribute_weights, size_t attribute_count, size_t target_index_count, float target_error, unsigned int options, float* out_result_error)
+{
+	return meshopt_simplifyEdge(destination, indices, index_count, vertex_positions_data, vertex_count, vertex_positions_stride, vertex_attributes_data, vertex_attributes_stride, attribute_weights, attribute_count, target_index_count, target_error, options, out_result_error);
+}
+
+size_t meshopt_simplifySloppy(unsigned int* destination, const unsigned int* indices, size_t index_count, const float* vertex_positions_data, size_t vertex_count, size_t vertex_positions_stride, size_t target_index_count, float target_error, float* out_result_error)
 {
 	using namespace meshopt;
 
 	assert(index_count % 3 == 0);
-	assert(vertex_positions_stride > 0 && vertex_positions_stride <= 256);
+	assert(vertex_positions_stride >= 12 && vertex_positions_stride <= 256);
 	assert(vertex_positions_stride % sizeof(float) == 0);
 	assert(target_index_count <= index_count);
 
 	// we expect to get ~2 triangles/vertex in the output
 	size_t target_cell_count = target_index_count / 6;
 
-	if (target_cell_count == 0)
-		return 0;
-
 	meshopt_Allocator allocator;
 
 	Vector3* vertex_positions = allocator.allocate<Vector3>(vertex_count);
@@ -1346,18 +1670,25 @@ size_t meshopt_simplifySloppy(unsigned int* destination, const unsigned int* ind
 	const int kInterpolationPasses = 5;
 
 	// invariant: # of triangles in min_grid <= target_count
-	int min_grid = 0;
+	int min_grid = int(1.f / (target_error < 1e-3f ? 1e-3f : target_error));
 	int max_grid = 1025;
 	size_t min_triangles = 0;
 	size_t max_triangles = index_count / 3;
 
+	// when we're error-limited, we compute the triangle count for the min. size; this accelerates convergence and provides the correct answer when we can't use a larger grid
+	if (min_grid > 1)
+	{
+		computeVertexIds(vertex_ids, vertex_positions, vertex_count, min_grid);
+		min_triangles = countTriangles(vertex_ids, indices, index_count);
+	}
+
 	// instead of starting in the middle, let's guess as to what the answer might be! triangle count usually grows as a square of grid size...
 	int next_grid_size = int(sqrtf(float(target_cell_count)) + 0.5f);
 
 	for (int pass = 0; pass < 10 + kInterpolationPasses; ++pass)
 	{
-		assert(min_triangles < target_index_count / 3);
-		assert(max_grid - min_grid > 1);
+		if (min_triangles >= target_index_count / 3 || max_grid - min_grid <= 1)
+			break;
 
 		// we clamp the prediction of the grid size to make sure that the search converges
 		int grid_size = next_grid_size;
@@ -1368,9 +1699,9 @@ size_t meshopt_simplifySloppy(unsigned int* destination, const unsigned int* ind
 
 #if TRACE
 		printf("pass %d (%s): grid size %d, triangles %d, %s\n",
-		       pass, (pass == 0) ? "guess" : (pass <= kInterpolationPasses) ? "lerp" : "binary",
-		       grid_size, int(triangles),
-		       (triangles <= target_index_count / 3) ? "under" : "over");
+		    pass, (pass == 0) ? "guess" : (pass <= kInterpolationPasses) ? "lerp" : "binary",
+		    grid_size, int(triangles),
+		    (triangles <= target_index_count / 3) ? "under" : "over");
 #endif
 
 		float tip = interpolate(float(target_index_count / 3), float(min_grid), float(min_triangles), float(grid_size), float(triangles), float(max_grid), float(max_triangles));
@@ -1386,16 +1717,18 @@ size_t meshopt_simplifySloppy(unsigned int* destination, const unsigned int* ind
 			max_triangles = triangles;
 		}
 
-		if (triangles == target_index_count / 3 || max_grid - min_grid <= 1)
-			break;
-
 		// we start by using interpolation search - it usually converges faster
 		// however, interpolation search has a worst case of O(N) so we switch to binary search after a few iterations which converges in O(logN)
 		next_grid_size = (pass < kInterpolationPasses) ? int(tip + 0.5f) : (min_grid + max_grid) / 2;
 	}
 
 	if (min_triangles == 0)
+	{
+		if (out_result_error)
+			*out_result_error = 1.f;
+
 		return 0;
+	}
 
 	// build vertex->cell association by mapping all vertices with the same quantized position to the same cell
 	size_t table_size = hashBuckets2(vertex_count);
@@ -1418,27 +1751,38 @@ size_t meshopt_simplifySloppy(unsigned int* destination, const unsigned int* ind
 
 	fillCellRemap(cell_remap, cell_errors, cell_count, vertex_cells, cell_quadrics, vertex_positions, vertex_count);
 
+	// compute error
+	float result_error = 0.f;
+
+	for (size_t i = 0; i < cell_count; ++i)
+		result_error = result_error < cell_errors[i] ? cell_errors[i] : result_error;
+
 	// collapse triangles!
 	// note that we need to filter out triangles that we've already output because we very frequently generate redundant triangles between cells :(
 	size_t tritable_size = hashBuckets2(min_triangles);
 	unsigned int* tritable = allocator.allocate<unsigned int>(tritable_size);
 
 	size_t write = filterTriangles(destination, tritable, tritable_size, indices, index_count, vertex_cells, cell_remap);
-	assert(write <= target_index_count);
 
 #if TRACE
-	printf("result: %d cells, %d triangles (%d unfiltered)\n", int(cell_count), int(write / 3), int(min_triangles));
+	printf("result: %d cells, %d triangles (%d unfiltered), error %e\n", int(cell_count), int(write / 3), int(min_triangles), sqrtf(result_error));
 #endif
 
+	if (out_result_error)
+		*out_result_error = sqrtf(result_error);
+
 	return write;
 }
 
-size_t meshopt_simplifyPoints(unsigned int* destination, const float* vertex_positions_data, size_t vertex_count, size_t vertex_positions_stride, size_t target_vertex_count)
+size_t meshopt_simplifyPoints(unsigned int* destination, const float* vertex_positions_data, size_t vertex_count, size_t vertex_positions_stride, const float* vertex_colors, size_t vertex_colors_stride, float color_weight, size_t target_vertex_count)
 {
 	using namespace meshopt;
 
-	assert(vertex_positions_stride > 0 && vertex_positions_stride <= 256);
+	assert(vertex_positions_stride >= 12 && vertex_positions_stride <= 256);
 	assert(vertex_positions_stride % sizeof(float) == 0);
+	assert(vertex_colors_stride == 0 || (vertex_colors_stride >= 12 && vertex_colors_stride <= 256));
+	assert(vertex_colors_stride % sizeof(float) == 0);
+	assert(vertex_colors == NULL || vertex_colors_stride != 0);
 	assert(target_vertex_count <= vertex_count);
 
 	size_t target_cell_count = target_vertex_count;
@@ -1487,9 +1831,9 @@ size_t meshopt_simplifyPoints(unsigned int* destination, const float* vertex_pos
 
 #if TRACE
 		printf("pass %d (%s): grid size %d, vertices %d, %s\n",
-		       pass, (pass == 0) ? "guess" : (pass <= kInterpolationPasses) ? "lerp" : "binary",
-		       grid_size, int(vertices),
-		       (vertices <= target_vertex_count) ? "under" : "over");
+		    pass, (pass == 0) ? "guess" : (pass <= kInterpolationPasses) ? "lerp" : "binary",
+		    grid_size, int(vertices),
+		    (vertices <= target_vertex_count) ? "under" : "over");
 #endif
 
 		float tip = interpolate(float(target_vertex_count), float(min_grid), float(min_vertices), float(grid_size), float(vertices), float(max_grid), float(max_vertices));
@@ -1522,25 +1866,43 @@ size_t meshopt_simplifyPoints(unsigned int* destination, const float* vertex_pos
 	computeVertexIds(vertex_ids, vertex_positions, vertex_count, min_grid);
 	size_t cell_count = fillVertexCells(table, table_size, vertex_cells, vertex_ids, vertex_count);
 
-	// build a quadric for each target cell
-	Quadric* cell_quadrics = allocator.allocate<Quadric>(cell_count);
-	memset(cell_quadrics, 0, cell_count * sizeof(Quadric));
+	// accumulate points into a reservoir for each target cell
+	Reservoir* cell_reservoirs = allocator.allocate<Reservoir>(cell_count);
+	memset(cell_reservoirs, 0, cell_count * sizeof(Reservoir));
 
-	fillCellQuadrics(cell_quadrics, vertex_positions, vertex_count, vertex_cells);
+	fillCellReservoirs(cell_reservoirs, cell_count, vertex_positions, vertex_colors, vertex_colors_stride, vertex_count, vertex_cells);
 
 	// for each target cell, find the vertex with the minimal error
 	unsigned int* cell_remap = allocator.allocate<unsigned int>(cell_count);
 	float* cell_errors = allocator.allocate<float>(cell_count);
 
-	fillCellRemap(cell_remap, cell_errors, cell_count, vertex_cells, cell_quadrics, vertex_positions, vertex_count);
+	fillCellRemap(cell_remap, cell_errors, cell_count, vertex_cells, cell_reservoirs, vertex_positions, vertex_colors, vertex_colors_stride, color_weight * color_weight, vertex_count);
 
 	// copy results to the output
 	assert(cell_count <= target_vertex_count);
 	memcpy(destination, cell_remap, sizeof(unsigned int) * cell_count);
 
 #if TRACE
-	printf("result: %d cells\n", int(cell_count));
+	// compute error
+	float result_error = 0.f;
+
+	for (size_t i = 0; i < cell_count; ++i)
+		result_error = result_error < cell_errors[i] ? cell_errors[i] : result_error;
+
+	printf("result: %d cells, %e error\n", int(cell_count), sqrtf(result_error));
 #endif
 
 	return cell_count;
 }
+
+float meshopt_simplifyScale(const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride)
+{
+	using namespace meshopt;
+
+	assert(vertex_positions_stride >= 12 && vertex_positions_stride <= 256);
+	assert(vertex_positions_stride % sizeof(float) == 0);
+
+	float extent = rescalePositions(NULL, vertex_positions, vertex_count, vertex_positions_stride);
+
+	return extent;
+}
diff --git a/Source/ThirdParty/meshoptimizer/spatialorder.cpp b/Source/ThirdParty/meshoptimizer/spatialorder.cpp
index b09f80ac6..7b1a06945 100644
--- a/Source/ThirdParty/meshoptimizer/spatialorder.cpp
+++ b/Source/ThirdParty/meshoptimizer/spatialorder.cpp
@@ -113,7 +113,7 @@ void meshopt_spatialSortRemap(unsigned int* destination, const float* vertex_pos
 {
 	using namespace meshopt;
 
-	assert(vertex_positions_stride > 0 && vertex_positions_stride <= 256);
+	assert(vertex_positions_stride >= 12 && vertex_positions_stride <= 256);
 	assert(vertex_positions_stride % sizeof(float) == 0);
 
 	meshopt_Allocator allocator;
@@ -144,7 +144,7 @@ void meshopt_spatialSortTriangles(unsigned int* destination, const unsigned int*
 	using namespace meshopt;
 
 	assert(index_count % 3 == 0);
-	assert(vertex_positions_stride > 0 && vertex_positions_stride <= 256);
+	assert(vertex_positions_stride >= 12 && vertex_positions_stride <= 256);
 	assert(vertex_positions_stride % sizeof(float) == 0);
 
 	(void)vertex_count;
diff --git a/Source/ThirdParty/meshoptimizer/vcacheoptimizer.cpp b/Source/ThirdParty/meshoptimizer/vcacheoptimizer.cpp
index fb8ade4b7..d4b08ba34 100644
--- a/Source/ThirdParty/meshoptimizer/vcacheoptimizer.cpp
+++ b/Source/ThirdParty/meshoptimizer/vcacheoptimizer.cpp
@@ -110,7 +110,7 @@ static unsigned int getNextVertexDeadEnd(const unsigned int* dead_end, unsigned
 	return ~0u;
 }
 
-static unsigned int getNextVertexNeighbour(const unsigned int* next_candidates_begin, const unsigned int* next_candidates_end, const unsigned int* live_triangles, const unsigned int* cache_timestamps, unsigned int timestamp, unsigned int cache_size)
+static unsigned int getNextVertexNeighbor(const unsigned int* next_candidates_begin, const unsigned int* next_candidates_end, const unsigned int* live_triangles, const unsigned int* cache_timestamps, unsigned int timestamp, unsigned int cache_size)
 {
 	unsigned int best_candidate = ~0u;
 	int best_priority = -1;
@@ -221,9 +221,9 @@ void meshopt_optimizeVertexCacheTable(unsigned int* destination, const unsigned
 		triangle_scores[i] = vertex_scores[a] + vertex_scores[b] + vertex_scores[c];
 	}
 
-	unsigned int cache_holder[2 * (kCacheSizeMax + 3)];
+	unsigned int cache_holder[2 * (kCacheSizeMax + 4)];
 	unsigned int* cache = cache_holder;
-	unsigned int* cache_new = cache_holder + kCacheSizeMax + 3;
+	unsigned int* cache_new = cache_holder + kCacheSizeMax + 4;
 	size_t cache_count = 0;
 
 	unsigned int current_triangle = 0;
@@ -260,10 +260,8 @@ void meshopt_optimizeVertexCacheTable(unsigned int* destination, const unsigned
 		{
 			unsigned int index = cache[i];
 
-			if (index != a && index != b && index != c)
-			{
-				cache_new[cache_write++] = index;
-			}
+			cache_new[cache_write] = index;
+			cache_write += (index != a && index != b && index != c);
 		}
 
 		unsigned int* cache_temp = cache;
@@ -281,16 +279,16 @@ void meshopt_optimizeVertexCacheTable(unsigned int* destination, const unsigned
 		{
 			unsigned int index = indices[current_triangle * 3 + k];
 
-			unsigned int* neighbours = &adjacency.data[0] + adjacency.offsets[index];
-			size_t neighbours_size = adjacency.counts[index];
+			unsigned int* neighbors = &adjacency.data[0] + adjacency.offsets[index];
+			size_t neighbors_size = adjacency.counts[index];
 
-			for (size_t i = 0; i < neighbours_size; ++i)
+			for (size_t i = 0; i < neighbors_size; ++i)
 			{
-				unsigned int tri = neighbours[i];
+				unsigned int tri = neighbors[i];
 
 				if (tri == current_triangle)
 				{
-					neighbours[i] = neighbours[neighbours_size - 1];
+					neighbors[i] = neighbors[neighbors_size - 1];
 					adjacency.counts[index]--;
 					break;
 				}
@@ -305,6 +303,10 @@ void meshopt_optimizeVertexCacheTable(unsigned int* destination, const unsigned
 		{
 			unsigned int index = cache[i];
 
+			// no need to update scores if we are never going to use this vertex
+			if (adjacency.counts[index] == 0)
+				continue;
+
 			int cache_position = i >= cache_size ? -1 : int(i);
 
 			// update vertex score
@@ -314,10 +316,10 @@ void meshopt_optimizeVertexCacheTable(unsigned int* destination, const unsigned
 			vertex_scores[index] = score;
 
 			// update scores of vertex triangles
-			const unsigned int* neighbours_begin = &adjacency.data[0] + adjacency.offsets[index];
-			const unsigned int* neighbours_end = neighbours_begin + adjacency.counts[index];
+			const unsigned int* neighbors_begin = &adjacency.data[0] + adjacency.offsets[index];
+			const unsigned int* neighbors_end = neighbors_begin + adjacency.counts[index];
 
-			for (const unsigned int* it = neighbours_begin; it != neighbours_end; ++it)
+			for (const unsigned int* it = neighbors_begin; it != neighbors_end; ++it)
 			{
 				unsigned int tri = *it;
 				assert(!emitted_flags[tri]);
@@ -325,11 +327,8 @@ void meshopt_optimizeVertexCacheTable(unsigned int* destination, const unsigned
 				float tri_score = triangle_scores[tri] + score_diff;
 				assert(tri_score > 0);
 
-				if (best_score < tri_score)
-				{
-					best_triangle = tri;
-					best_score = tri_score;
-				}
+				best_triangle = best_score < tri_score ? tri : best_triangle;
+				best_score = best_score < tri_score ? tri_score : best_score;
 
 				triangle_scores[tri] = tri_score;
 			}
@@ -412,11 +411,11 @@ void meshopt_optimizeVertexCacheFifo(unsigned int* destination, const unsigned i
 	{
 		const unsigned int* next_candidates_begin = &dead_end[0] + dead_end_top;
 
-		// emit all vertex neighbours
-		const unsigned int* neighbours_begin = &adjacency.data[0] + adjacency.offsets[current_vertex];
-		const unsigned int* neighbours_end = neighbours_begin + adjacency.counts[current_vertex];
+		// emit all vertex neighbors
+		const unsigned int* neighbors_begin = &adjacency.data[0] + adjacency.offsets[current_vertex];
+		const unsigned int* neighbors_end = neighbors_begin + adjacency.counts[current_vertex];
 
-		for (const unsigned int* it = neighbours_begin; it != neighbours_end; ++it)
+		for (const unsigned int* it = neighbors_begin; it != neighbors_end; ++it)
 		{
 			unsigned int triangle = *it;
 
@@ -461,7 +460,7 @@ void meshopt_optimizeVertexCacheFifo(unsigned int* destination, const unsigned i
 		const unsigned int* next_candidates_end = &dead_end[0] + dead_end_top;
 
 		// get next vertex
-		current_vertex = getNextVertexNeighbour(next_candidates_begin, next_candidates_end, &live_triangles[0], &cache_timestamps[0], timestamp, cache_size);
+		current_vertex = getNextVertexNeighbor(next_candidates_begin, next_candidates_end, &live_triangles[0], &cache_timestamps[0], timestamp, cache_size);
 
 		if (current_vertex == ~0u)
 		{
diff --git a/Source/ThirdParty/meshoptimizer/vertexcodec.cpp b/Source/ThirdParty/meshoptimizer/vertexcodec.cpp
index 30fbcd454..8ab0662d8 100644
--- a/Source/ThirdParty/meshoptimizer/vertexcodec.cpp
+++ b/Source/ThirdParty/meshoptimizer/vertexcodec.cpp
@@ -42,16 +42,24 @@
 #endif
 
 // When targeting Wasm SIMD we can't use runtime cpuid checks so we unconditionally enable SIMD
-// Note that we need unimplemented-simd128 subset for a few functions that are implemented de-facto
 #if defined(__wasm_simd128__)
 #define SIMD_WASM
-#define SIMD_TARGET __attribute__((target("unimplemented-simd128")))
+// Prevent compiling other variant when wasm simd compilation is active
+#undef SIMD_NEON
+#undef SIMD_SSE
+#undef SIMD_AVX
 #endif
 
 #ifndef SIMD_TARGET
 #define SIMD_TARGET
 #endif
 
+// When targeting AArch64/x64, optimize for latency to allow decoding of individual 16-byte groups to overlap
+// We don't do this for 32-bit systems because we need 64-bit math for this and this will hurt in-order CPUs
+#if defined(__x86_64__) || defined(_M_X64) || defined(__aarch64__) || defined(_M_ARM64)
+#define SIMD_LATENCYOPT
+#endif
+
 #endif // !MESHOPTIMIZER_NO_SIMD
 
 #ifdef SIMD_SSE
@@ -82,31 +90,14 @@
 #include <wasm_simd128.h>
 #endif
 
-#ifndef TRACE
-#define TRACE 0
-#endif
-
-#if TRACE
-#include <stdio.h>
-#endif
-
 #ifdef SIMD_WASM
-#define wasmx_splat_v32x4(v, i) wasm_v32x4_shuffle(v, v, i, i, i, i)
-#define wasmx_unpacklo_v8x16(a, b) wasm_v8x16_shuffle(a, b, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23)
-#define wasmx_unpackhi_v8x16(a, b) wasm_v8x16_shuffle(a, b, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31)
-#define wasmx_unpacklo_v16x8(a, b) wasm_v16x8_shuffle(a, b, 0, 8, 1, 9, 2, 10, 3, 11)
-#define wasmx_unpackhi_v16x8(a, b) wasm_v16x8_shuffle(a, b, 4, 12, 5, 13, 6, 14, 7, 15)
-#define wasmx_unpacklo_v64x2(a, b) wasm_v64x2_shuffle(a, b, 0, 2)
-#define wasmx_unpackhi_v64x2(a, b) wasm_v64x2_shuffle(a, b, 1, 3)
-#endif
-
-#if defined(SIMD_WASM)
-// v128_t wasm_v8x16_swizzle(v128_t a, v128_t b)
-SIMD_TARGET
-static __inline__ v128_t wasm_v8x16_swizzle(v128_t a, v128_t b)
-{
-	return (v128_t)__builtin_wasm_swizzle_v8x16((__i8x16)a, (__i8x16)b);
-}
+#define wasmx_splat_v32x4(v, i) wasm_i32x4_shuffle(v, v, i, i, i, i)
+#define wasmx_unpacklo_v8x16(a, b) wasm_i8x16_shuffle(a, b, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23)
+#define wasmx_unpackhi_v8x16(a, b) wasm_i8x16_shuffle(a, b, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31)
+#define wasmx_unpacklo_v16x8(a, b) wasm_i16x8_shuffle(a, b, 0, 8, 1, 9, 2, 10, 3, 11)
+#define wasmx_unpackhi_v16x8(a, b) wasm_i16x8_shuffle(a, b, 4, 12, 5, 13, 6, 14, 7, 15)
+#define wasmx_unpacklo_v64x2(a, b) wasm_i64x2_shuffle(a, b, 0, 2)
+#define wasmx_unpackhi_v64x2(a, b) wasm_i64x2_shuffle(a, b, 1, 3)
 #endif
 
 namespace meshopt
@@ -144,19 +135,6 @@ inline unsigned char unzigzag8(unsigned char v)
 	return -(v & 1) ^ (v >> 1);
 }
 
-#if TRACE
-struct Stats
-{
-	size_t size;
-	size_t header;
-	size_t bitg[4];
-	size_t bitb[4];
-};
-
-Stats* bytestats;
-Stats vertexstats[256];
-#endif
-
 static bool encodeBytesGroupZero(const unsigned char* buffer)
 {
 	for (size_t i = 0; i < kByteGroupSize; ++i)
@@ -242,7 +220,7 @@ static unsigned char* encodeBytes(unsigned char* data, unsigned char* data_end,
 	size_t header_size = (buffer_size / kByteGroupSize + 3) / 4;
 
 	if (size_t(data_end - data) < header_size)
-		return 0;
+		return NULL;
 
 	data += header_size;
 
@@ -251,7 +229,7 @@ static unsigned char* encodeBytes(unsigned char* data, unsigned char* data_end,
 	for (size_t i = 0; i < buffer_size; i += kByteGroupSize)
 	{
 		if (size_t(data_end - data) < kByteGroupDecodeLimit)
-			return 0;
+			return NULL;
 
 		int best_bits = 8;
 		size_t best_size = encodeBytesGroupMeasure(buffer + i, 8);
@@ -278,17 +256,8 @@ static unsigned char* encodeBytes(unsigned char* data, unsigned char* data_end,
 
 		assert(data + best_size == next);
 		data = next;
-
-#if TRACE > 1
-		bytestats->bitg[bitslog2]++;
-		bytestats->bitb[bitslog2] += best_size;
-#endif
 	}
 
-#if TRACE > 1
-	bytestats->header += header_size;
-#endif
-
 	return data;
 }
 
@@ -317,19 +286,9 @@ static unsigned char* encodeVertexBlock(unsigned char* data, unsigned char* data
 			vertex_offset += vertex_size;
 		}
 
-#if TRACE
-		const unsigned char* olddata = data;
-		bytestats = &vertexstats[k];
-#endif
-
 		data = encodeBytes(data, data_end, buffer, (vertex_count + kByteGroupSize - 1) & ~(kByteGroupSize - 1));
 		if (!data)
-			return 0;
-
-#if TRACE
-		bytestats = 0;
-		vertexstats[k].size += data - olddata;
-#endif
+			return NULL;
 	}
 
 	memcpy(last_vertex, &vertex_data[vertex_size * (vertex_count - 1)], vertex_size);
@@ -337,7 +296,7 @@ static unsigned char* encodeVertexBlock(unsigned char* data, unsigned char* data
 	return data;
 }
 
-#if defined(SIMD_FALLBACK) || (!defined(SIMD_SSE) && !defined(SIMD_NEON) && !defined(SIMD_AVX))
+#if defined(SIMD_FALLBACK) || (!defined(SIMD_SSE) && !defined(SIMD_NEON) && !defined(SIMD_AVX) && !defined(SIMD_WASM))
 static const unsigned char* decodeBytesGroup(const unsigned char* data, unsigned char* buffer, int bitslog2)
 {
 #define READ() byte = *data++
@@ -397,14 +356,14 @@ static const unsigned char* decodeBytes(const unsigned char* data, const unsigne
 	size_t header_size = (buffer_size / kByteGroupSize + 3) / 4;
 
 	if (size_t(data_end - data) < header_size)
-		return 0;
+		return NULL;
 
 	data += header_size;
 
 	for (size_t i = 0; i < buffer_size; i += kByteGroupSize)
 	{
 		if (size_t(data_end - data) < kByteGroupDecodeLimit)
-			return 0;
+			return NULL;
 
 		size_t header_offset = i / kByteGroupSize;
 
@@ -429,7 +388,7 @@ static const unsigned char* decodeVertexBlock(const unsigned char* data, const u
 	{
 		data = decodeBytes(data, data_end, buffer, vertex_count_aligned);
 		if (!data)
-			return 0;
+			return NULL;
 
 		size_t vertex_offset = k;
 
@@ -458,7 +417,7 @@ static const unsigned char* decodeVertexBlock(const unsigned char* data, const u
 static unsigned char kDecodeBytesGroupShuffle[256][8];
 static unsigned char kDecodeBytesGroupCount[256];
 
-#ifdef EMSCRIPTEN
+#ifdef __wasm__
 __attribute__((cold)) // this saves 500 bytes in the output binary - we don't need to vectorize this loop!
 #endif
 static bool
@@ -521,6 +480,18 @@ static const unsigned char* decodeBytesGroupSimd(const unsigned char* data, unsi
 		typedef int unaligned_int;
 #endif
 
+#ifdef SIMD_LATENCYOPT
+		unsigned int data32;
+		memcpy(&data32, data, 4);
+		data32 &= data32 >> 1;
+
+		// arrange bits such that low bits of nibbles of data64 contain all 2-bit elements of data32
+		unsigned long long data64 = ((unsigned long long)data32 << 30) | (data32 & 0x3fffffff);
+
+		// adds all 1-bit nibbles together; the sum fits in 4 bits because datacnt=16 would have used mode 3
+		int datacnt = int(((data64 & 0x1111111111111111ull) * 0x1111111111111111ull) >> 60);
+#endif
+
 		__m128i sel2 = _mm_cvtsi32_si128(*reinterpret_cast<const unaligned_int*>(data));
 		__m128i rest = _mm_loadu_si128(reinterpret_cast<const __m128i*>(data + 4));
 
@@ -539,11 +510,25 @@ static const unsigned char* decodeBytesGroupSimd(const unsigned char* data, unsi
 
 		_mm_storeu_si128(reinterpret_cast<__m128i*>(buffer), result);
 
+#ifdef SIMD_LATENCYOPT
+		return data + 4 + datacnt;
+#else
 		return data + 4 + kDecodeBytesGroupCount[mask0] + kDecodeBytesGroupCount[mask1];
+#endif
 	}
 
 	case 2:
 	{
+#ifdef SIMD_LATENCYOPT
+		unsigned long long data64;
+		memcpy(&data64, data, 8);
+		data64 &= data64 >> 1;
+		data64 &= data64 >> 2;
+
+		// adds all 1-bit nibbles together; the sum fits in 4 bits because datacnt=16 would have used mode 3
+		int datacnt = int(((data64 & 0x1111111111111111ull) * 0x1111111111111111ull) >> 60);
+#endif
+
 		__m128i sel4 = _mm_loadl_epi64(reinterpret_cast<const __m128i*>(data));
 		__m128i rest = _mm_loadu_si128(reinterpret_cast<const __m128i*>(data + 8));
 
@@ -561,7 +546,11 @@ static const unsigned char* decodeBytesGroupSimd(const unsigned char* data, unsi
 
 		_mm_storeu_si128(reinterpret_cast<__m128i*>(buffer), result);
 
+#ifdef SIMD_LATENCYOPT
+		return data + 8 + datacnt;
+#else
 		return data + 8 + kDecodeBytesGroupCount[mask0] + kDecodeBytesGroupCount[mask1];
+#endif
 	}
 
 	case 3:
@@ -653,24 +642,13 @@ static uint8x16_t shuffleBytes(unsigned char mask0, unsigned char mask1, uint8x8
 
 static void neonMoveMask(uint8x16_t mask, unsigned char& mask0, unsigned char& mask1)
 {
-	static const unsigned char byte_mask_data[16] = {1, 2, 4, 8, 16, 32, 64, 128, 1, 2, 4, 8, 16, 32, 64, 128};
+	// magic constant found using z3 SMT assuming mask has 8 groups of 0xff or 0x00
+	const uint64_t magic = 0x000103070f1f3f80ull;
 
-	uint8x16_t byte_mask = vld1q_u8(byte_mask_data);
-	uint8x16_t masked = vandq_u8(mask, byte_mask);
+	uint64x2_t mask2 = vreinterpretq_u64_u8(mask);
 
-#ifdef __aarch64__
-	// aarch64 has horizontal sums; MSVC doesn't expose this via arm64_neon.h so this path is exclusive to clang/gcc
-	mask0 = vaddv_u8(vget_low_u8(masked));
-	mask1 = vaddv_u8(vget_high_u8(masked));
-#else
-	// we need horizontal sums of each half of masked, which can be done in 3 steps (yielding sums of sizes 2, 4, 8)
-	uint8x8_t sum1 = vpadd_u8(vget_low_u8(masked), vget_high_u8(masked));
-	uint8x8_t sum2 = vpadd_u8(sum1, sum1);
-	uint8x8_t sum3 = vpadd_u8(sum2, sum2);
-
-	mask0 = vget_lane_u8(sum3, 0);
-	mask1 = vget_lane_u8(sum3, 1);
-#endif
+	mask0 = uint8_t((vgetq_lane_u64(mask2, 0) * magic) >> 56);
+	mask1 = uint8_t((vgetq_lane_u64(mask2, 1) * magic) >> 56);
 }
 
 static const unsigned char* decodeBytesGroupSimd(const unsigned char* data, unsigned char* buffer, int bitslog2)
@@ -688,6 +666,18 @@ static const unsigned char* decodeBytesGroupSimd(const unsigned char* data, unsi
 
 	case 1:
 	{
+#ifdef SIMD_LATENCYOPT
+		unsigned int data32;
+		memcpy(&data32, data, 4);
+		data32 &= data32 >> 1;
+
+		// arrange bits such that low bits of nibbles of data64 contain all 2-bit elements of data32
+		unsigned long long data64 = ((unsigned long long)data32 << 30) | (data32 & 0x3fffffff);
+
+		// adds all 1-bit nibbles together; the sum fits in 4 bits because datacnt=16 would have used mode 3
+		int datacnt = int(((data64 & 0x1111111111111111ull) * 0x1111111111111111ull) >> 60);
+#endif
+
 		uint8x8_t sel2 = vld1_u8(data);
 		uint8x8_t sel22 = vzip_u8(vshr_n_u8(sel2, 4), sel2).val[0];
 		uint8x8x2_t sel2222 = vzip_u8(vshr_n_u8(sel22, 2), sel22);
@@ -704,11 +694,25 @@ static const unsigned char* decodeBytesGroupSimd(const unsigned char* data, unsi
 
 		vst1q_u8(buffer, result);
 
+#ifdef SIMD_LATENCYOPT
+		return data + 4 + datacnt;
+#else
 		return data + 4 + kDecodeBytesGroupCount[mask0] + kDecodeBytesGroupCount[mask1];
+#endif
 	}
 
 	case 2:
 	{
+#ifdef SIMD_LATENCYOPT
+		unsigned long long data64;
+		memcpy(&data64, data, 8);
+		data64 &= data64 >> 1;
+		data64 &= data64 >> 2;
+
+		// adds all 1-bit nibbles together; the sum fits in 4 bits because datacnt=16 would have used mode 3
+		int datacnt = int(((data64 & 0x1111111111111111ull) * 0x1111111111111111ull) >> 60);
+#endif
+
 		uint8x8_t sel4 = vld1_u8(data);
 		uint8x8x2_t sel44 = vzip_u8(vshr_n_u8(sel4, 4), vand_u8(sel4, vdup_n_u8(15)));
 		uint8x16_t sel = vcombine_u8(sel44.val[0], sel44.val[1]);
@@ -724,7 +728,11 @@ static const unsigned char* decodeBytesGroupSimd(const unsigned char* data, unsi
 
 		vst1q_u8(buffer, result);
 
+#ifdef SIMD_LATENCYOPT
+		return data + 8 + datacnt;
+#else
 		return data + 8 + kDecodeBytesGroupCount[mask0] + kDecodeBytesGroupCount[mask1];
+#endif
 	}
 
 	case 3:
@@ -747,13 +755,11 @@ static const unsigned char* decodeBytesGroupSimd(const unsigned char* data, unsi
 SIMD_TARGET
 static v128_t decodeShuffleMask(unsigned char mask0, unsigned char mask1)
 {
-	// TODO: 8b buffer overrun - should we use splat or extend buffers?
 	v128_t sm0 = wasm_v128_load(&kDecodeBytesGroupShuffle[mask0]);
 	v128_t sm1 = wasm_v128_load(&kDecodeBytesGroupShuffle[mask1]);
 
-	// TODO: we should use v8x16_load_splat
 	v128_t sm1off = wasm_v128_load(&kDecodeBytesGroupCount[mask0]);
-	sm1off = wasm_v8x16_shuffle(sm1off, sm1off, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+	sm1off = wasm_i8x16_shuffle(sm1off, sm1off, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 
 	v128_t sm1r = wasm_i8x16_add(sm1, sm1off);
 
@@ -763,26 +769,16 @@ static v128_t decodeShuffleMask(unsigned char mask0, unsigned char mask1)
 SIMD_TARGET
 static void wasmMoveMask(v128_t mask, unsigned char& mask0, unsigned char& mask1)
 {
-	v128_t mask_0 = wasm_v32x4_shuffle(mask, mask, 0, 2, 1, 3);
+	// magic constant found using z3 SMT assuming mask has 8 groups of 0xff or 0x00
+	const uint64_t magic = 0x000103070f1f3f80ull;
 
-	// TODO: when Chrome supports v128.const we can try doing vectorized and?
-	uint64_t mask_1a = wasm_i64x2_extract_lane(mask_0, 0) & 0x0804020108040201ull;
-	uint64_t mask_1b = wasm_i64x2_extract_lane(mask_0, 1) & 0x8040201080402010ull;
-
-	uint64_t mask_2 = mask_1a | mask_1b;
-	uint64_t mask_4 = mask_2 | (mask_2 >> 16);
-	uint64_t mask_8 = mask_4 | (mask_4 >> 8);
-
-	mask0 = uint8_t(mask_8);
-	mask1 = uint8_t(mask_8 >> 32);
+	mask0 = uint8_t((wasm_i64x2_extract_lane(mask, 0) * magic) >> 56);
+	mask1 = uint8_t((wasm_i64x2_extract_lane(mask, 1) * magic) >> 56);
 }
 
 SIMD_TARGET
 static const unsigned char* decodeBytesGroupSimd(const unsigned char* data, unsigned char* buffer, int bitslog2)
 {
-	unsigned char byte, enc, encv;
-	const unsigned char* data_var;
-
 	switch (bitslog2)
 	{
 	case 0:
@@ -796,7 +792,6 @@ static const unsigned char* decodeBytesGroupSimd(const unsigned char* data, unsi
 
 	case 1:
 	{
-		// TODO: test 4b load splat
 		v128_t sel2 = wasm_v128_load(data);
 		v128_t rest = wasm_v128_load(data + 4);
 
@@ -811,8 +806,7 @@ static const unsigned char* decodeBytesGroupSimd(const unsigned char* data, unsi
 
 		v128_t shuf = decodeShuffleMask(mask0, mask1);
 
-		// TODO: test or/andnot
-		v128_t result = wasm_v128_bitselect(wasm_v8x16_swizzle(rest, shuf), sel, mask);
+		v128_t result = wasm_v128_bitselect(wasm_i8x16_swizzle(rest, shuf), sel, mask);
 
 		wasm_v128_store(buffer, result);
 
@@ -821,7 +815,6 @@ static const unsigned char* decodeBytesGroupSimd(const unsigned char* data, unsi
 
 	case 2:
 	{
-		// TODO: test 8b load splat
 		v128_t sel4 = wasm_v128_load(data);
 		v128_t rest = wasm_v128_load(data + 8);
 
@@ -835,8 +828,7 @@ static const unsigned char* decodeBytesGroupSimd(const unsigned char* data, unsi
 
 		v128_t shuf = decodeShuffleMask(mask0, mask1);
 
-		// TODO: test or/andnot
-		v128_t result = wasm_v128_bitselect(wasm_v8x16_swizzle(rest, shuf), sel, mask);
+		v128_t result = wasm_v128_bitselect(wasm_i8x16_swizzle(rest, shuf), sel, mask);
 
 		wasm_v128_store(buffer, result);
 
@@ -927,8 +919,7 @@ SIMD_TARGET
 static v128_t unzigzag8(v128_t v)
 {
 	v128_t xl = wasm_i8x16_neg(wasm_v128_and(v, wasm_i8x16_splat(1)));
-	// TODO: use wasm_u8x16_shr when v8 fixes codegen for constant shifts
-	v128_t xr = wasm_v128_and(wasm_u16x8_shr(v, 1), wasm_i8x16_splat(127));
+	v128_t xr = wasm_u8x16_shr(v, 1);
 
 	return wasm_v128_xor(xl, xr);
 }
@@ -947,7 +938,7 @@ static const unsigned char* decodeBytesSimd(const unsigned char* data, const uns
 	size_t header_size = (buffer_size / kByteGroupSize + 3) / 4;
 
 	if (size_t(data_end - data) < header_size)
-		return 0;
+		return NULL;
 
 	data += header_size;
 
@@ -969,7 +960,7 @@ static const unsigned char* decodeBytesSimd(const unsigned char* data, const uns
 	for (; i < buffer_size; i += kByteGroupSize)
 	{
 		if (size_t(data_end - data) < kByteGroupDecodeLimit)
-			return 0;
+			return NULL;
 
 		size_t header_offset = i / kByteGroupSize;
 
@@ -997,7 +988,7 @@ static const unsigned char* decodeVertexBlockSimd(const unsigned char* data, con
 		{
 			data = decodeBytesSimd(data, data_end, buffer + j * vertex_count_aligned, vertex_count_aligned);
 			if (!data)
-				return 0;
+				return NULL;
 		}
 
 #if defined(SIMD_SSE) || defined(SIMD_AVX)
@@ -1020,7 +1011,7 @@ static const unsigned char* decodeVertexBlockSimd(const unsigned char* data, con
 
 #ifdef SIMD_WASM
 #define TEMP v128_t
-#define PREP() v128_t pi = wasm_v128_load(last_vertex + k) // TODO: use wasm_v32x4_load_splat to avoid buffer overrun
+#define PREP() v128_t pi = wasm_v128_load(last_vertex + k)
 #define LOAD(i) v128_t r##i = wasm_v128_load(buffer + j + i * vertex_count_aligned)
 #define GRP4(i) t0 = wasmx_splat_v32x4(r##i, 0), t1 = wasmx_splat_v32x4(r##i, 1), t2 = wasmx_splat_v32x4(r##i, 2), t3 = wasmx_splat_v32x4(r##i, 3)
 #define FIXD(i) t##i = pi = wasm_i8x16_add(pi, t##i)
@@ -1092,7 +1083,7 @@ static unsigned int getCpuFeatures()
 	return cpuinfo[2];
 }
 
-unsigned int cpuid = getCpuFeatures();
+static unsigned int cpuid = getCpuFeatures();
 #endif
 
 } // namespace meshopt
@@ -1104,10 +1095,6 @@ size_t meshopt_encodeVertexBuffer(unsigned char* buffer, size_t buffer_size, con
 	assert(vertex_size > 0 && vertex_size <= 256);
 	assert(vertex_size % 4 == 0);
 
-#if TRACE
-	memset(vertexstats, 0, sizeof(vertexstats));
-#endif
-
 	const unsigned char* vertex_data = static_cast<const unsigned char*>(vertices);
 
 	unsigned char* data = buffer;
@@ -1160,28 +1147,6 @@ size_t meshopt_encodeVertexBuffer(unsigned char* buffer, size_t buffer_size, con
 	assert(data >= buffer + tail_size);
 	assert(data <= buffer + buffer_size);
 
-#if TRACE
-	size_t total_size = data - buffer;
-
-	for (size_t k = 0; k < vertex_size; ++k)
-	{
-		const Stats& vsk = vertexstats[k];
-
-		printf("%2d: %d bytes\t%.1f%%\t%.1f bpv", int(k), int(vsk.size), double(vsk.size) / double(total_size) * 100, double(vsk.size) / double(vertex_count) * 8);
-
-#if TRACE > 1
-		printf("\t\thdr %d bytes\tbit0 %d (%d bytes)\tbit1 %d (%d bytes)\tbit2 %d (%d bytes)\tbit3 %d (%d bytes)",
-		       int(vsk.header),
-		       int(vsk.bitg[0]), int(vsk.bitb[0]),
-		       int(vsk.bitg[1]), int(vsk.bitb[1]),
-		       int(vsk.bitg[2]), int(vsk.bitb[2]),
-		       int(vsk.bitg[3]), int(vsk.bitb[3]));
-#endif
-
-		printf("\n");
-	}
-#endif
-
 	return data - buffer;
 }
 
@@ -1217,7 +1182,7 @@ int meshopt_decodeVertexBuffer(void* destination, size_t vertex_count, size_t ve
 	assert(vertex_size > 0 && vertex_size <= 256);
 	assert(vertex_size % 4 == 0);
 
-	const unsigned char* (*decode)(const unsigned char*, const unsigned char*, unsigned char*, size_t, size_t, unsigned char[256]) = 0;
+	const unsigned char* (*decode)(const unsigned char*, const unsigned char*, unsigned char*, size_t, size_t, unsigned char[256]) = NULL;
 
 #if defined(SIMD_SSE) && defined(SIMD_FALLBACK)
 	decode = (cpuid & (1 << 9)) ? decodeVertexBlockSimd : decodeVertexBlock;
diff --git a/Source/ThirdParty/meshoptimizer/vertexfilter.cpp b/Source/ThirdParty/meshoptimizer/vertexfilter.cpp
index e07d11a7d..4b5f444f0 100644
--- a/Source/ThirdParty/meshoptimizer/vertexfilter.cpp
+++ b/Source/ThirdParty/meshoptimizer/vertexfilter.cpp
@@ -2,6 +2,7 @@
 #include "meshoptimizer.h"
 
 #include <math.h>
+#include <string.h>
 
 // The block below auto-detects SIMD ISA that can be used on the target platform
 #ifndef MESHOPTIMIZER_NO_SIMD
@@ -29,6 +30,9 @@
 // When targeting Wasm SIMD we can't use runtime cpuid checks so we unconditionally enable SIMD
 #if defined(__wasm_simd128__)
 #define SIMD_WASM
+// Prevent compiling other variant when wasm simd compilation is active
+#undef SIMD_NEON
+#undef SIMD_SSE
 #endif
 
 #endif // !MESHOPTIMIZER_NO_SIMD
@@ -51,6 +55,7 @@
 #endif
 
 #ifdef SIMD_WASM
+#undef __DEPRECATED
 #include <wasm_simd128.h>
 #endif
 
@@ -61,6 +66,10 @@
 #define wasmx_unziphi_v32x4(a, b) wasm_v32x4_shuffle(a, b, 1, 3, 5, 7)
 #endif
 
+#ifndef __has_builtin
+#define __has_builtin(x) 0
+#endif
+
 namespace meshopt
 {
 
@@ -143,7 +152,8 @@ static void decodeFilterExp(unsigned int* data, size_t count)
 		int m = int(v << 8) >> 8;
 		int e = int(v) >> 24;
 
-		union {
+		union
+		{
 			float f;
 			unsigned int ui;
 		} u;
@@ -158,11 +168,31 @@ static void decodeFilterExp(unsigned int* data, size_t count)
 #endif
 
 #if defined(SIMD_SSE) || defined(SIMD_NEON) || defined(SIMD_WASM)
+template <typename T>
+static void dispatchSimd(void (*process)(T*, size_t), T* data, size_t count, size_t stride)
+{
+	assert(stride <= 4);
+
+	size_t count4 = count & ~size_t(3);
+	process(data, count4);
+
+	if (count4 < count)
+	{
+		T tail[4 * 4] = {}; // max stride 4, max count 4
+		size_t tail_size = (count - count4) * stride * sizeof(T);
+		assert(tail_size <= sizeof(tail));
+
+		memcpy(tail, data + count4 * stride, tail_size);
+		process(tail, count - count4);
+		memcpy(data + count4 * stride, tail, tail_size);
+	}
+}
+
 inline uint64_t rotateleft64(uint64_t v, int x)
 {
 #if defined(_MSC_VER) && !defined(__clang__)
 	return _rotl64(v, x);
-#elif defined(__clang__) && __clang_major__ >= 8
+#elif defined(__clang__) && __has_builtin(__builtin_rotateleft64)
 	return __builtin_rotateleft64(v, x);
 #else
 	return (v << (x & 63)) | (v >> ((64 - x) & 63));
@@ -620,7 +650,7 @@ static void decodeFilterOctSimd(signed char* data, size_t count)
 static void decodeFilterOctSimd(short* data, size_t count)
 {
 	const v128_t sign = wasm_f32x4_splat(-0.f);
-	volatile v128_t zmask = wasm_i32x4_splat(0x7fff); // TODO: volatile works around LLVM shuffle "optimizations"
+	const v128_t zmask = wasm_i32x4_splat(0x7fff);
 
 	for (size_t i = 0; i < count; i += 4)
 	{
@@ -732,7 +762,8 @@ static void decodeFilterQuatSimd(short* data, size_t count)
 		v128_t res_1 = wasmx_unpackhi_v16x8(wyr, xzr);
 
 		// compute component index shifted left by 4 (and moved into i32x4 slot)
-		v128_t cm = wasm_i32x4_shl(cf, 4);
+		// TODO: volatile here works around LLVM mis-optimizing code; https://github.com/emscripten-core/emscripten/issues/11449
+		volatile v128_t cm = wasm_i32x4_shl(cf, 4);
 
 		// rotate and store
 		uint64_t* out = reinterpret_cast<uint64_t*>(&data[i * 4]);
@@ -765,57 +796,238 @@ static void decodeFilterExpSimd(unsigned int* data, size_t count)
 }
 #endif
 
+// optimized variant of frexp
+inline int optlog2(float v)
+{
+	union
+	{
+		float f;
+		unsigned int ui;
+	} u;
+
+	u.f = v;
+	// +1 accounts for implicit 1. in mantissa; denormalized numbers will end up clamped to min_exp by calling code
+	return u.ui == 0 ? 0 : int((u.ui >> 23) & 0xff) - 127 + 1;
+}
+
+// optimized variant of ldexp
+inline float optexp2(int e)
+{
+	union
+	{
+		float f;
+		unsigned int ui;
+	} u;
+
+	u.ui = unsigned(e + 127) << 23;
+	return u.f;
+}
+
 } // namespace meshopt
 
-void meshopt_decodeFilterOct(void* buffer, size_t vertex_count, size_t vertex_size)
+void meshopt_decodeFilterOct(void* buffer, size_t count, size_t stride)
 {
 	using namespace meshopt;
 
-	assert(vertex_count % 4 == 0);
-	assert(vertex_size == 4 || vertex_size == 8);
+	assert(stride == 4 || stride == 8);
 
 #if defined(SIMD_SSE) || defined(SIMD_NEON) || defined(SIMD_WASM)
-	if (vertex_size == 4)
-		decodeFilterOctSimd(static_cast<signed char*>(buffer), vertex_count);
+	if (stride == 4)
+		dispatchSimd(decodeFilterOctSimd, static_cast<signed char*>(buffer), count, 4);
 	else
-		decodeFilterOctSimd(static_cast<short*>(buffer), vertex_count);
+		dispatchSimd(decodeFilterOctSimd, static_cast<short*>(buffer), count, 4);
 #else
-	if (vertex_size == 4)
-		decodeFilterOct(static_cast<signed char*>(buffer), vertex_count);
+	if (stride == 4)
+		decodeFilterOct(static_cast<signed char*>(buffer), count);
 	else
-		decodeFilterOct(static_cast<short*>(buffer), vertex_count);
+		decodeFilterOct(static_cast<short*>(buffer), count);
 #endif
 }
 
-void meshopt_decodeFilterQuat(void* buffer, size_t vertex_count, size_t vertex_size)
+void meshopt_decodeFilterQuat(void* buffer, size_t count, size_t stride)
 {
 	using namespace meshopt;
 
-	assert(vertex_count % 4 == 0);
-	assert(vertex_size == 8);
-	(void)vertex_size;
+	assert(stride == 8);
+	(void)stride;
 
 #if defined(SIMD_SSE) || defined(SIMD_NEON) || defined(SIMD_WASM)
-	decodeFilterQuatSimd(static_cast<short*>(buffer), vertex_count);
+	dispatchSimd(decodeFilterQuatSimd, static_cast<short*>(buffer), count, 4);
 #else
-	decodeFilterQuat(static_cast<short*>(buffer), vertex_count);
+	decodeFilterQuat(static_cast<short*>(buffer), count);
 #endif
 }
 
-void meshopt_decodeFilterExp(void* buffer, size_t vertex_count, size_t vertex_size)
+void meshopt_decodeFilterExp(void* buffer, size_t count, size_t stride)
 {
 	using namespace meshopt;
 
-	assert(vertex_count % 4 == 0);
-	assert(vertex_size % 4 == 0);
+	assert(stride > 0 && stride % 4 == 0);
 
 #if defined(SIMD_SSE) || defined(SIMD_NEON) || defined(SIMD_WASM)
-	decodeFilterExpSimd(static_cast<unsigned int*>(buffer), vertex_count * (vertex_size / 4));
+	dispatchSimd(decodeFilterExpSimd, static_cast<unsigned int*>(buffer), count * (stride / 4), 1);
 #else
-	decodeFilterExp(static_cast<unsigned int*>(buffer), vertex_count * (vertex_size / 4));
+	decodeFilterExp(static_cast<unsigned int*>(buffer), count * (stride / 4));
 #endif
 }
 
+void meshopt_encodeFilterOct(void* destination, size_t count, size_t stride, int bits, const float* data)
+{
+	assert(stride == 4 || stride == 8);
+	assert(bits >= 1 && bits <= 16);
+
+	signed char* d8 = static_cast<signed char*>(destination);
+	short* d16 = static_cast<short*>(destination);
+
+	int bytebits = int(stride * 2);
+
+	for (size_t i = 0; i < count; ++i)
+	{
+		const float* n = &data[i * 4];
+
+		// octahedral encoding of a unit vector
+		float nx = n[0], ny = n[1], nz = n[2], nw = n[3];
+		float nl = fabsf(nx) + fabsf(ny) + fabsf(nz);
+		float ns = nl == 0.f ? 0.f : 1.f / nl;
+
+		nx *= ns;
+		ny *= ns;
+
+		float u = (nz >= 0.f) ? nx : (1 - fabsf(ny)) * (nx >= 0.f ? 1.f : -1.f);
+		float v = (nz >= 0.f) ? ny : (1 - fabsf(nx)) * (ny >= 0.f ? 1.f : -1.f);
+
+		int fu = meshopt_quantizeSnorm(u, bits);
+		int fv = meshopt_quantizeSnorm(v, bits);
+		int fo = meshopt_quantizeSnorm(1.f, bits);
+		int fw = meshopt_quantizeSnorm(nw, bytebits);
+
+		if (stride == 4)
+		{
+			d8[i * 4 + 0] = (signed char)(fu);
+			d8[i * 4 + 1] = (signed char)(fv);
+			d8[i * 4 + 2] = (signed char)(fo);
+			d8[i * 4 + 3] = (signed char)(fw);
+		}
+		else
+		{
+			d16[i * 4 + 0] = short(fu);
+			d16[i * 4 + 1] = short(fv);
+			d16[i * 4 + 2] = short(fo);
+			d16[i * 4 + 3] = short(fw);
+		}
+	}
+}
+
+void meshopt_encodeFilterQuat(void* destination_, size_t count, size_t stride, int bits, const float* data)
+{
+	assert(stride == 8);
+	assert(bits >= 4 && bits <= 16);
+	(void)stride;
+
+	short* destination = static_cast<short*>(destination_);
+
+	const float scaler = sqrtf(2.f);
+
+	for (size_t i = 0; i < count; ++i)
+	{
+		const float* q = &data[i * 4];
+		short* d = &destination[i * 4];
+
+		// establish maximum quaternion component
+		int qc = 0;
+		qc = fabsf(q[1]) > fabsf(q[qc]) ? 1 : qc;
+		qc = fabsf(q[2]) > fabsf(q[qc]) ? 2 : qc;
+		qc = fabsf(q[3]) > fabsf(q[qc]) ? 3 : qc;
+
+		// we use double-cover properties to discard the sign
+		float sign = q[qc] < 0.f ? -1.f : 1.f;
+
+		// note: we always encode a cyclical swizzle to be able to recover the order via rotation
+		d[0] = short(meshopt_quantizeSnorm(q[(qc + 1) & 3] * scaler * sign, bits));
+		d[1] = short(meshopt_quantizeSnorm(q[(qc + 2) & 3] * scaler * sign, bits));
+		d[2] = short(meshopt_quantizeSnorm(q[(qc + 3) & 3] * scaler * sign, bits));
+		d[3] = short((meshopt_quantizeSnorm(1.f, bits) & ~3) | qc);
+	}
+}
+
+void meshopt_encodeFilterExp(void* destination_, size_t count, size_t stride, int bits, const float* data, enum meshopt_EncodeExpMode mode)
+{
+	using namespace meshopt;
+
+	assert(stride > 0 && stride % 4 == 0 && stride <= 256);
+	assert(bits >= 1 && bits <= 24);
+
+	unsigned int* destination = static_cast<unsigned int*>(destination_);
+	size_t stride_float = stride / sizeof(float);
+
+	int component_exp[64];
+	assert(stride_float <= sizeof(component_exp) / sizeof(int));
+
+	const int min_exp = -100;
+
+	if (mode == meshopt_EncodeExpSharedComponent)
+	{
+		for (size_t j = 0; j < stride_float; ++j)
+			component_exp[j] = min_exp;
+
+		for (size_t i = 0; i < count; ++i)
+		{
+			const float* v = &data[i * stride_float];
+
+			// use maximum exponent to encode values; this guarantees that mantissa is [-1, 1]
+			for (size_t j = 0; j < stride_float; ++j)
+			{
+				int e = optlog2(v[j]);
+
+				component_exp[j] = (component_exp[j] < e) ? e : component_exp[j];
+			}
+		}
+	}
+
+	for (size_t i = 0; i < count; ++i)
+	{
+		const float* v = &data[i * stride_float];
+		unsigned int* d = &destination[i * stride_float];
+
+		int vector_exp = min_exp;
+
+		if (mode == meshopt_EncodeExpSharedVector)
+		{
+			// use maximum exponent to encode values; this guarantees that mantissa is [-1, 1]
+			for (size_t j = 0; j < stride_float; ++j)
+			{
+				int e = optlog2(v[j]);
+
+				vector_exp = (vector_exp < e) ? e : vector_exp;
+			}
+		}
+		else if (mode == meshopt_EncodeExpSeparate)
+		{
+			for (size_t j = 0; j < stride_float; ++j)
+			{
+				int e = optlog2(v[j]);
+
+				component_exp[j] = (min_exp < e) ? e : min_exp;
+			}
+		}
+
+		for (size_t j = 0; j < stride_float; ++j)
+		{
+			int exp = (mode == meshopt_EncodeExpSharedVector) ? vector_exp : component_exp[j];
+
+			// note that we additionally scale the mantissa to make it a K-bit signed integer (K-1 bits for magnitude)
+			exp -= (bits - 1);
+
+			// compute renormalized rounded mantissa for each component
+			int mmask = (1 << 24) - 1;
+
+			int m = int(v[j] * optexp2(-exp) + (v[j] >= 0 ? 0.5f : -0.5f));
+
+			d[j] = (m & mmask) | (unsigned(exp) << 24);
+		}
+	}
+}
+
 #undef SIMD_SSE
 #undef SIMD_NEON
 #undef SIMD_WASM
diff --git a/Source/ThirdParty/recastnavigation/DetourNavMesh.cpp b/Source/ThirdParty/recastnavigation/DetourNavMesh.cpp
index 2240526eb..eba1b4dc3 100644
--- a/Source/ThirdParty/recastnavigation/DetourNavMesh.cpp
+++ b/Source/ThirdParty/recastnavigation/DetourNavMesh.cpp
@@ -208,21 +208,13 @@ dtNavMesh::dtNavMesh() :
 
 dtNavMesh::~dtNavMesh()
 {
-	for (int i = 0; i < m_maxTiles; ++i)
-	{
-		if (m_tiles[i].flags & DT_TILE_FREE_DATA)
-		{
-			dtFree(m_tiles[i].data);
-			m_tiles[i].data = 0;
-			m_tiles[i].dataSize = 0;
-		}
-	}
-	dtFree(m_posLookup);
-	dtFree(m_tiles);
+	purge();
 }
 		
 dtStatus dtNavMesh::init(const dtNavMeshParams* params)
 {
+    if (m_tiles)
+        purge();
 	memcpy(&m_params, params, sizeof(dtNavMeshParams));
 	dtVcopy(m_orig, params->orig);
 	m_tileWidth = params->tileWidth;
@@ -1178,6 +1170,24 @@ int dtNavMesh::getMaxTiles() const
 	return m_maxTiles;
 }
 
+void dtNavMesh::purge()
+{
+	for (int i = 0; i < m_maxTiles; ++i)
+	{
+		if (m_tiles[i].flags & DT_TILE_FREE_DATA)
+		{
+			dtFree(m_tiles[i].data);
+			m_tiles[i].data = 0;
+			m_tiles[i].dataSize = 0;
+		}
+	}
+    m_maxTiles = 0;
+	dtFree(m_posLookup);
+    m_posLookup = 0;
+	dtFree(m_tiles);
+    m_tiles = 0;
+}
+
 dtMeshTile* dtNavMesh::getTile(int i)
 {
 	return &m_tiles[i];
diff --git a/Source/ThirdParty/recastnavigation/DetourNavMesh.h b/Source/ThirdParty/recastnavigation/DetourNavMesh.h
index 4c1277d78..8837d576d 100644
--- a/Source/ThirdParty/recastnavigation/DetourNavMesh.h
+++ b/Source/ThirdParty/recastnavigation/DetourNavMesh.h
@@ -613,6 +613,9 @@ private:
 	dtNavMesh(const dtNavMesh&);
 	dtNavMesh& operator=(const dtNavMesh&);
 
+    /// Clears all tiles from memory. Can be called before init to rebuild navigation mesh with different parameters.
+    void purge();
+
 	/// Returns pointer to tile in the tile array.
 	dtMeshTile* getTile(int i);
 
diff --git a/Source/ThirdParty/tracy/client/TracyScoped.hpp b/Source/ThirdParty/tracy/client/TracyScoped.hpp
index bb916aa57..2182bf65b 100644
--- a/Source/ThirdParty/tracy/client/TracyScoped.hpp
+++ b/Source/ThirdParty/tracy/client/TracyScoped.hpp
@@ -12,15 +12,16 @@
 
 namespace tracy
 {
-void ScopedZone::Begin(const SourceLocationData* srcloc)
+bool ScopedZone::Begin(const SourceLocationData* srcloc)
 {
 #ifdef TRACY_ON_DEMAND
-    if (!GetProfiler().IsConnected()) return;
+    if (!GetProfiler().IsConnected()) return false;
 #endif
     TracyLfqPrepare( QueueType::ZoneBegin );
     MemWrite( &item->zoneBegin.time, Profiler::GetTime() );
     MemWrite( &item->zoneBegin.srcloc, (uint64_t)srcloc );
     TracyQueueCommit( zoneBeginThread );
+    return true;
 }
 
 void ScopedZone::End()
diff --git a/Source/ThirdParty/tracy/common/TracySystem.hpp b/Source/ThirdParty/tracy/common/TracySystem.hpp
index 7a88a00b1..497d047e5 100644
--- a/Source/ThirdParty/tracy/common/TracySystem.hpp
+++ b/Source/ThirdParty/tracy/common/TracySystem.hpp
@@ -39,7 +39,7 @@ struct TRACY_API SourceLocationData
 class TRACY_API ScopedZone
 {
 public:
-    static void Begin( const SourceLocationData* srcloc );
+    static bool Begin( const SourceLocationData* srcloc );
     static void End();
 
     ScopedZone( const ScopedZone& ) = delete;
diff --git a/Source/Tools/Flax.Build/Projects/VisualStudio/CSSDKProjectGenerator.cs b/Source/Tools/Flax.Build/Projects/VisualStudio/CSSDKProjectGenerator.cs
index c678b2521..2d4b0cc02 100644
--- a/Source/Tools/Flax.Build/Projects/VisualStudio/CSSDKProjectGenerator.cs
+++ b/Source/Tools/Flax.Build/Projects/VisualStudio/CSSDKProjectGenerator.cs
@@ -91,11 +91,6 @@ namespace Flax.Build.Projects.VisualStudio
             var baseConfiguration = project.Configurations.First();
             var baseOutputDir = Utilities.MakePathRelativeTo(project.CSharp.OutputPath ?? baseConfiguration.TargetBuildOptions.OutputFolder, projectDirectory);
             var baseIntermediateOutputPath = Utilities.MakePathRelativeTo(project.CSharp.IntermediateOutputPath ?? Path.Combine(baseConfiguration.TargetBuildOptions.IntermediateFolder, "CSharp"), projectDirectory);
-            
-            bool isMainProject = Globals.Project.ProjectFolderPath == project.WorkspaceRootPath && project.Name != "BuildScripts" && (Globals.Project.Name != "Flax" || project.Name != "FlaxEngine");
-            var flaxBuildTargetsFilename = isMainProject ? "Flax.Build.CSharp.targets" : "Flax.Build.CSharp.SkipBuild.targets";
-            var cacheProjectsPath = Utilities.MakePathRelativeTo(Path.Combine(Globals.Root, "Cache", "Projects"), projectDirectory);
-            var flaxBuildTargetsPath = !string.IsNullOrEmpty(cacheProjectsPath) ? Path.Combine(cacheProjectsPath, flaxBuildTargetsFilename) : flaxBuildTargetsFilename;
 
             csProjectFileContent.AppendLine($"    <TargetFramework>net{dotnetSdk.Version.Major}.{dotnetSdk.Version.Minor}</TargetFramework>");
             csProjectFileContent.AppendLine("    <ImplicitUsings>disable</ImplicitUsings>");
@@ -114,7 +109,11 @@ namespace Flax.Build.Projects.VisualStudio
 
             //csProjectFileContent.AppendLine("    <CopyLocalLockFileAssemblies>false</CopyLocalLockFileAssemblies>"); // TODO: use it to reduce burden of framework libs
 
-            // Custom .targets file for overriding MSBuild build tasks
+            // Custom .targets file for overriding MSBuild build tasks, only invoke Flax.Build once per Flax project
+            bool isMainProject = Globals.Project.IsCSharpOnlyProject && Globals.Project.ProjectFolderPath == project.WorkspaceRootPath && project.Name != "BuildScripts" && (Globals.Project.Name != "Flax" || project.Name != "FlaxEngine");
+            var flaxBuildTargetsFilename = isMainProject ? "Flax.Build.CSharp.targets" : "Flax.Build.CSharp.SkipBuild.targets";
+            var cacheProjectsPath = Utilities.MakePathRelativeTo(Path.Combine(Globals.Root, "Cache", "Projects"), projectDirectory);
+            var flaxBuildTargetsPath = !string.IsNullOrEmpty(cacheProjectsPath) ? Path.Combine(cacheProjectsPath, flaxBuildTargetsFilename) : flaxBuildTargetsFilename;
             csProjectFileContent.AppendLine(string.Format("    <CustomAfterMicrosoftCommonTargets>$(MSBuildThisFileDirectory){0}</CustomAfterMicrosoftCommonTargets>", flaxBuildTargetsPath));
 
             // Hide annoying warnings during build
diff --git a/Source/Tools/Flax.Build/Projects/VisualStudio/VisualStudioProjectGenerator.cs b/Source/Tools/Flax.Build/Projects/VisualStudio/VisualStudioProjectGenerator.cs
index b04531d9f..5cc1b2205 100644
--- a/Source/Tools/Flax.Build/Projects/VisualStudio/VisualStudioProjectGenerator.cs
+++ b/Source/Tools/Flax.Build/Projects/VisualStudio/VisualStudioProjectGenerator.cs
@@ -702,7 +702,7 @@ namespace Flax.Build.Projects.VisualStudio
             // Override MSBuild build tasks to run Flax.Build in C#-only projects
             {
                 // Build command for the build tool
-                var buildToolPath = Path.ChangeExtension(Utilities.MakePathRelativeTo(typeof(Builder).Assembly.Location, Path.GetDirectoryName(solution.MainProject.Path)), null);
+                var buildToolPath = Path.ChangeExtension(typeof(Builder).Assembly.Location, null);
                 
                 var targetsFileContent = new StringBuilder();
                 targetsFileContent.AppendLine("<Project>");
@@ -724,16 +724,16 @@ namespace Flax.Build.Projects.VisualStudio
                 {
                     foreach (var configuration in solution.MainProject.Configurations)
                     {
-                        var cmdLine = string.Format("{0} -log -mutex -workspace={1} -arch={2} -configuration={3} -platform={4} -buildTargets={5}",
-                                                FixPath(buildToolPath),
-                                                FixPath(solution.MainProject.WorkspaceRootPath),
+                        var cmdLine = string.Format("\"{0}\" -log -mutex -workspace=\"{1}\" -arch={2} -configuration={3} -platform={4} -buildTargets={5}",
+                                                buildToolPath,
+                                                solution.MainProject.WorkspaceRootPath,
                                                 configuration.Architecture,
                                                 configuration.Configuration,
                                                 configuration.Platform,
                                                 configuration.Target);
                         Configuration.PassArgs(ref cmdLine);
 
-                        str.AppendLine(string.Format("    <Exec Command=\"{0} {1}\" Condition=\"'$(Configuration)|$(Platform)'=='{2}'\"/>", cmdLine, extraArgs, configuration.Name));
+                        str.AppendLine(string.Format("    <Exec Command='{0} {1}' Condition=\"'$(Configuration)|$(Platform)'=='{2}'\"/>", cmdLine, extraArgs, configuration.Name));
                     }
                 }
             }
@@ -774,14 +774,5 @@ namespace Flax.Build.Projects.VisualStudio
                 projects.Add(project);
             }
         }
-
-        private static string FixPath(string path)
-        {
-            if (path.Contains(' '))
-            {
-                path = "\"" + path + "\"";
-            }
-            return path;
-        }
     }
 }