Merge remote-tracking branch 'upstream/master'

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;
         }
     }
 }

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;
 }
 

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();
         }

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); });
+            }
+        }
     }
 }

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;
         }
 

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)
                         {

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);

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:");

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;
             }
         }

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;

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;
+        }
+    }
+}

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);

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)
             {

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];

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++)

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);
 

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()
         {

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);
+                        }
                     }
                 }
 

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)

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());

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);
 

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>

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();
+        }
     }
 }

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);

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);
         }
     }
 }

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";

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 />

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;
         }

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();
             }
 

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[]

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);

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();
         }

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;

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"));
                 }
             }
 

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;
                     }
                 }

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);
 

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++)
             {

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)

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)

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);
             }

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();

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);

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;

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:

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.

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();

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();
         }
     }

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;
 }

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>

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;
             }
         }

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
     {

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); \
 	}
 

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); \
 	}
 

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

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

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();

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.

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 },

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);
 };

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;
             }
         }

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

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

Source/Engine/ContentImporters/ImportModelFile.cpp

@@ -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

Source/Engine/ContentImporters/ImportModelFile.h

@@ -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

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"

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

Source/Engine/Core/Collections/Array.h

@@ -734,9 +734,7 @@ public:
         }
         else
         {
-            Array tmp = MoveTemp(other);
-            other = *this;
-            *this = MoveTemp(tmp);
+            ::Swap(other, *this);
         }
     }
 

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]);

Source/Engine/Core/Collections/Dictionary.h

@@ -616,9 +616,7 @@ public:
         }
         else
         {
-            Dictionary tmp = MoveTemp(other);
-            other = *this;
-            *this = MoveTemp(tmp);
+            ::Swap(other, *this);
         }
     }
 

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>

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;

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);

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;
 

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);

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;
 

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);
 }
 

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
         }
 

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;
         }
     }

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)

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

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
 };

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

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)

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>

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
 {

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;
 }
 

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;
         }
     }

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.

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

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();

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)

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;

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.

Source/Engine/Graphics/Textures/TextureUtils.h

@@ -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;
-        }
-    }
-};

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));

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());
             }
         }
     }

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)

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)

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.");