Allow reimporting model prefabs from Content window context menu

The Spatial Sort version was being too greedy when merging vertices

.lfsconfig

@@ -1,4 +1,4 @@
 # Redirect to our own Git LFS server
 [lfs]
 #url="https://gitlab.flaxengine.com/flax/flaxengine.git/info/lfs"
-locksverify = false
+locksverify = false

GenerateProjectFiles.bat

@@ -14,8 +14,8 @@ call "Development\Scripts\Windows\CallBuildTool.bat" -genproject  %*
 if errorlevel 1 goto BuildToolFailed
 
 :: Build bindings for all editor configurations
-echo Building C# bindings...
-Binaries\Tools\Flax.Build.exe -build -BuildBindingsOnly -arch=x64 -platform=Windows --buildTargets=FlaxEditor
+::echo Building C# bindings...
+::Binaries\Tools\Flax.Build.exe -build -BuildBindingsOnly -arch=x64 -platform=Windows --buildTargets=FlaxEditor
 
 popd
 echo Done!

Source/Editor/Content/AssetPickerValidator.cs

@@ -1,3 +1,5 @@
+// Copyright (c) 2012-2024 Wojciech Figat. All rights reserved.
+
 using System;
 using System.IO;
 using FlaxEditor.Scripting;
@@ -94,30 +96,8 @@ public class AssetPickerValidator : IContentItemOwner
     /// </summary>
     public string SelectedPath
     {
-        get
-        {
-            string path = _selectedItem?.Path ?? _selected?.Path;
-            if (path != null)
-            {
-                // Convert into path relative to the project (cross-platform)
-                var projectFolder = Globals.ProjectFolder;
-                if (path.StartsWith(projectFolder))
-                    path = path.Substring(projectFolder.Length + 1);
-            }
-            return path;
-        }
-        set
-        {
-            if (string.IsNullOrEmpty(value))
-            {
-                SelectedItem = null;
-            }
-            else
-            {
-                var path = StringUtils.IsRelative(value) ? Path.Combine(Globals.ProjectFolder, value) : value;
-                SelectedItem = Editor.Instance.ContentDatabase.Find(path);
-            }
-        }
+        get => Utilities.Utils.ToPathProject(_selectedItem?.Path ?? _selected?.Path);
+        set => SelectedItem = string.IsNullOrEmpty(value) ? null : Editor.Instance.ContentDatabase.Find(Utilities.Utils.ToPathAbsolute(value));
     }
 
     /// <summary>
@@ -242,7 +222,7 @@ public class AssetPickerValidator : IContentItemOwner
     /// <summary>
     /// Initializes a new instance of the <see cref="AssetPickerValidator"/> class.
     /// </summary>
-    /// <param name="assetType">The assets types that this picker accepts.</param>
+    /// <param name="assetType">The asset types that this picker accepts.</param>
     public AssetPickerValidator(ScriptType assetType)
     {
         _type = assetType;

Source/Editor/Content/Items/VideoItem.cs

@@ -0,0 +1,28 @@
+// Copyright (c) 2012-2024 Wojciech Figat. All rights reserved.
+
+using FlaxEngine;
+
+namespace FlaxEditor.Content
+{
+    /// <summary>
+    /// Content item that contains video media file.
+    /// </summary>
+    /// <seealso cref="FlaxEditor.Content.JsonAssetItem" />
+    public sealed class VideoItem : FileItem
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VideoItem"/> class.
+        /// </summary>
+        /// <param name="path">The file path.</param>
+        public VideoItem(string path)
+        : base(path)
+        {
+        }
+
+        /// <inheritdoc />
+        public override string TypeDescription => "Video";
+
+        /// <inheritdoc />
+        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Document128;
+    }
+}

Source/Editor/Content/Proxy/AssetProxy.cs

@@ -30,9 +30,7 @@ namespace FlaxEditor.Content
         /// <summary>
         /// Determines whether [is virtual proxy].
         /// </summary>
-        /// <returns>
-        ///   <c>true</c> if [is virtual proxy]; otherwise, <c>false</c>.
-        /// </returns>
+        /// <returns><c>true</c> if [is virtual proxy]; otherwise, <c>false</c>.</returns>
         public bool IsVirtualProxy()
         {
             return IsVirtual && CanExport == false;

Source/Editor/Content/Proxy/CSharpScriptProxy.cs

@@ -29,6 +29,12 @@ namespace FlaxEditor.Content
             return item is CSharpScriptItem;
         }
 
+        /// <inheritdoc />
+        public override ContentItem ConstructItem(string path)
+        {
+            return new CSharpScriptItem(path);
+        }
+
         /// <inheritdoc />
         public override void Create(string outputPath, object arg)
         {

Source/Editor/Content/Proxy/ContentProxy.cs

@@ -39,6 +39,16 @@ namespace FlaxEditor.Content
             return false;
         }
 
+        /// <summary>
+        /// Constructs the item for the file.
+        /// </summary>
+        /// <param name="path">The file path.</param>
+        /// <returns>Created item or null.</returns>
+        public virtual ContentItem ConstructItem(string path)
+        {
+            return null;
+        }
+
         /// <summary>
         /// Gets a value indicating whether this proxy if for assets.
         /// </summary>

Source/Editor/Content/Proxy/CppProxy.cs

@@ -87,6 +87,12 @@ namespace FlaxEditor.Content
             return item is CppScriptItem;
         }
 
+        /// <inheritdoc />
+        public override ContentItem ConstructItem(string path)
+        {
+            return new CppScriptItem(path);
+        }
+
         /// <inheritdoc />
         protected override void GetTemplatePaths(out string headerTemplate, out string sourceTemplate)
         {

Source/Editor/Content/Proxy/FileProxy.cs

@@ -20,6 +20,12 @@ namespace FlaxEditor.Content
             return item is FileItem;
         }
 
+        /// <inheritdoc />
+        public override ContentItem ConstructItem(string path)
+        {
+            return new FileItem(path);
+        }
+
         /// <inheritdoc />
         public override string FileExtension => string.Empty;
 

Source/Editor/Content/Proxy/PrefabProxy.cs

@@ -73,6 +73,16 @@ namespace FlaxEditor.Content
             return targetLocation.CanHaveAssets;
         }
 
+        /// <inheritdoc />
+        public override bool CanReimport(ContentItem item)
+        {
+            if (item is not PrefabItem prefabItem)
+                return base.CanReimport(item);
+
+            var prefab = FlaxEngine.Content.Load<Prefab>(prefabItem.ID);
+            return prefab.GetDefaultInstance().GetScript<ModelPrefab>() != null;
+        }
+
         /// <inheritdoc />
         public override void Create(string outputPath, object arg)
         {

Source/Editor/Content/Proxy/VideoProxy.cs

@@ -0,0 +1,48 @@
+// Copyright (c) 2012-2024 Wojciech Figat. All rights reserved.
+
+using FlaxEditor.Windows;
+using FlaxEditor.Windows.Assets;
+using FlaxEngine;
+
+namespace FlaxEditor.Content
+{
+    /// <summary>
+    /// A video media file proxy object.
+    /// </summary>
+    public class VideoProxy : ContentProxy
+    {
+        private readonly string _extension;
+
+        internal VideoProxy(string extension)
+        {
+            _extension = extension;
+        }
+
+        /// <inheritdoc />
+        public override string Name => "Video";
+
+        /// <inheritdoc />
+        public override string FileExtension => _extension;
+
+        /// <inheritdoc />
+        public override Color AccentColor => Color.FromRGB(0x11f7f1);
+
+        /// <inheritdoc />
+        public override bool IsProxyFor(ContentItem item)
+        {
+            return item is VideoItem;
+        }
+
+        /// <inheritdoc />
+        public override ContentItem ConstructItem(string path)
+        {
+            return new VideoItem(path);
+        }
+
+        /// <inheritdoc />
+        public override EditorWindow Open(Editor editor, ContentItem item)
+        {
+            return new VideoWindow(editor, (VideoItem)item);
+        }
+    }
+}

Source/Editor/Cooker/CookingData.h

@@ -134,6 +134,12 @@ API_ENUM() enum class BuildPlatform
     /// </summary>
     API_ENUM(Attributes="EditorDisplay(null, \"iOS ARM64\")")
     iOSARM64 = 14,
+
+    /// <summary>
+    /// Windows (ARM64)
+    /// </summary>
+    API_ENUM(Attributes = "EditorDisplay(null, \"Windows ARM64\")")
+    WindowsARM64 = 15,
 };
 
 /// <summary>
@@ -285,24 +291,22 @@ public:
         /// <summary>
         /// The total assets amount in the build.
         /// </summary>
-        int32 TotalAssets;
+        int32 TotalAssets = 0;
 
         /// <summary>
         /// The cooked assets (TotalAssets - CookedAssets is amount of reused cached assets).
         /// </summary>
-        int32 CookedAssets;
+        int32 CookedAssets = 0;
 
         /// <summary>
-        /// The final output content size in MB.
+        /// The final output content size (in bytes).
         /// </summary>
-        int32 ContentSizeMB;
+        uint64 ContentSize = 0;
 
         /// <summary>
         /// The asset type stats. Key is the asset typename, value is the stats container.
         /// </summary>
         Dictionary<String, AssetTypeStatistics> AssetStats;
-
-        Statistics();
     };
 
     /// <summary>
@@ -328,6 +332,11 @@ public:
     /// </summary>
     HashSet<Guid> Assets;
 
+    /// <summary>
+    /// The final files collection to include in build (valid only after CollectAssetsStep).
+    /// </summary>
+    HashSet<String> Files;
+
     struct BinaryModuleInfo
     {
         String Name;

Source/Editor/Cooker/GameCooker.cpp

@@ -148,6 +148,8 @@ const Char* ToString(const BuildPlatform platform)
         return TEXT("Mac ARM64");
     case BuildPlatform::iOSARM64:
         return TEXT("iOS ARM64");
+    case BuildPlatform::WindowsARM64:
+        return TEXT("Windows ARM64");
     default:
         return TEXT("");
     }
@@ -202,13 +204,6 @@ bool CookingData::AssetTypeStatistics::operator<(const AssetTypeStatistics& othe
     return Count > other.Count;
 }
 
-CookingData::Statistics::Statistics()
-{
-    TotalAssets = 0;
-    CookedAssets = 0;
-    ContentSizeMB = 0;
-}
-
 CookingData::CookingData(const SpawnParams& params)
     : ScriptingObject(params)
 {
@@ -307,6 +302,10 @@ void CookingData::GetBuildPlatformName(const Char*& platform, const Char*& archi
         platform = TEXT("iOS");
         architecture = TEXT("ARM64");
         break;
+    case BuildPlatform::WindowsARM64:
+        platform = TEXT("Windows");
+        architecture = TEXT("ARM64");
+        break;
     default:
         LOG(Fatal, "Unknown or unsupported build platform.");
     }
@@ -393,6 +392,9 @@ PlatformTools* GameCooker::GetTools(BuildPlatform platform)
         case BuildPlatform::Windows64:
             result = New<WindowsPlatformTools>(ArchitectureType::x64);
             break;
+        case BuildPlatform::WindowsARM64:
+            result = New<WindowsPlatformTools>(ArchitectureType::ARM64);
+            break;
 #endif
 #if PLATFORM_TOOLS_UWP
         case BuildPlatform::UWPx86:
@@ -554,7 +556,12 @@ void GameCooker::GetCurrentPlatform(PlatformType& platform, BuildPlatform& build
     switch (PLATFORM_TYPE)
     {
     case PlatformType::Windows:
-        buildPlatform = PLATFORM_64BITS ? BuildPlatform::Windows64 : BuildPlatform::Windows32;
+        if (PLATFORM_ARCH == ArchitectureType::x64)
+            buildPlatform = BuildPlatform::Windows64;
+        else if (PLATFORM_ARCH == ArchitectureType::ARM64)
+            buildPlatform = BuildPlatform::WindowsARM64;
+        else
+            buildPlatform = BuildPlatform::Windows32;
         break;
     case PlatformType::XboxOne:
         buildPlatform = BuildPlatform::XboxOne;

Source/Editor/Cooker/Platform/Android/AndroidPlatformTools.cpp

@@ -325,9 +325,7 @@ bool AndroidPlatformTools::OnPostProcess(CookingData& data)
 
     const auto buildSettings = BuildSettings::Get();
     if (buildSettings->SkipPackaging)
-    {
         return false;
-    }
     GameCooker::PackageFiles();
 
     // Validate environment variables
@@ -365,7 +363,7 @@ bool AndroidPlatformTools::OnPostProcess(CookingData& data)
         Platform::CreateProcess(procSettings);
     }
 #endif
-    const bool distributionPackage = buildSettings->ForDistribution;
+    const bool distributionPackage = buildSettings->ForDistribution || data.Configuration == BuildConfiguration::Release;
     {
         CreateProcessSettings procSettings;
         procSettings.FileName = String::Format(TEXT("\"{0}\" {1}"), data.OriginalOutputPath / gradlew, distributionPackage ? TEXT("assemble") : TEXT("assembleDebug"));

Source/Editor/Cooker/Steps/CollectAssetsStep.cpp

@@ -10,47 +10,26 @@
 #include "Engine/Content/Assets/Shader.h"
 #include "Engine/Content/Cache/AssetsCache.h"
 
-bool CollectAssetsStep::Process(CookingData& data, Asset* asset)
-{
-    // Skip virtual/temporary assets
-    if (asset->IsVirtual())
-        return false;
-
-    // Keep reference to the asset
-    AssetReference<Asset> ref(asset);
-
-    // Asset should have loaded data
-    if (asset->WaitForLoaded())
-        return false;
-
-    // Gather asset references
-    _references.Clear();
-    asset->Locker.Lock();
-    asset->GetReferences(_references);
-    asset->Locker.Unlock();
-    _assetsQueue.Add(_references);
-
-    return false;
-}
-
 bool CollectAssetsStep::Perform(CookingData& data)
 {
     LOG(Info, "Searching for assets to include in a build. Using {0} root assets.", data.RootAssets.Count());
     data.StepProgress(TEXT("Collecting assets"), 0);
 
     // Initialize assets queue
-    _assetsQueue.Clear();
-    _assetsQueue.EnsureCapacity(1024);
+    Array<Guid> assetsQueue;
+    assetsQueue.Clear();
+    assetsQueue.EnsureCapacity(1024);
     for (auto i = data.RootAssets.Begin(); i.IsNotEnd(); ++i)
-        _assetsQueue.Add(i->Item);
+        assetsQueue.Add(i->Item);
 
     // Iterate through the assets graph
     AssetInfo assetInfo;
-    while (_assetsQueue.HasItems())
+    Array<Guid> references;
+    Array<String> files;
+    while (assetsQueue.HasItems())
     {
         BUILD_STEP_CANCEL_CHECK;
-
-        const auto assetId = _assetsQueue.Dequeue();
+        const Guid assetId = assetsQueue.Dequeue();
 
         // Skip already processed or invalid assets
         if (!assetId.IsValid()
@@ -69,14 +48,31 @@ bool CollectAssetsStep::Perform(CookingData& data)
         }
 
         // Load asset
-        const auto asset = Content::LoadAsync<Asset>(assetId);
+        AssetReference<Asset> asset = Content::LoadAsync<Asset>(assetId);
         if (asset == nullptr)
             continue;
-
-        // Process that asset
         LOG_STR(Info, asset->GetPath());
         data.Assets.Add(assetId);
-        Process(data, asset);
+
+        // Skip virtual/temporary assets
+        if (asset->IsVirtual())
+            continue;
+
+        // Asset should have loaded data
+        if (asset->WaitForLoaded())
+            continue;
+
+        // Gather asset references
+        references.Clear();
+        asset->Locker.Lock();
+        asset->GetReferences(references, files);
+        asset->Locker.Unlock();
+        assetsQueue.Add(references);
+        for (String& file : files)
+        {
+            if (file.HasChars())
+                data.Files.Add(MoveTemp(file));
+        }
     }
 
     data.Stats.TotalAssets = data.Assets.Count();

Source/Editor/Cooker/Steps/CollectAssetsStep.h

@@ -12,15 +12,7 @@ class Asset;
 /// <seealso cref="GameCooker::BuildStep" />
 class CollectAssetsStep : public GameCooker::BuildStep
 {
-private:
-
-    Array<Guid> _assetsQueue;
-    Array<Guid> _references;
-
-    bool Process(CookingData& data, Asset* asset);
-
 public:
-
     // [BuildStep]
     bool Perform(CookingData& data) override;
 };

Source/Editor/Cooker/Steps/CookAssetsStep.cpp

@@ -447,6 +447,7 @@ bool ProcessShaderBase(CookAssetsStep::AssetCookData& data, ShaderAssetBase* ass
 #if PLATFORM_TOOLS_WINDOWS
     case BuildPlatform::Windows32:
     case BuildPlatform::Windows64:
+    case BuildPlatform::WindowsARM64:
     {
         const char* platformDefineName = "PLATFORM_WINDOWS";
         const auto settings = WindowsPlatformSettings::Get();
@@ -891,7 +892,6 @@ bool CookAssetsStep::Process(CookingData& data, CacheData& cache, JsonAssetBase*
 class PackageBuilder : public NonCopyable
 {
 private:
-
     int32 _packageIndex;
     int32 MaxAssetsPerPackage;
     int32 MaxPackageSize;
@@ -904,7 +904,6 @@ private:
     uint64 packagesSizeTotal;
 
 public:
-
     /// <summary>
     /// Initializes a new instance of the <see cref="PackageBuilder" /> class.
     /// </summary>
@@ -933,7 +932,6 @@ public:
     }
 
 public:
-
     uint64 GetPackagesSizeTotal() const
     {
         return packagesSizeTotal;
@@ -1042,8 +1040,11 @@ bool CookAssetsStep::Perform(CookingData& data)
     float Step1ProgressEnd = 0.6f;
     String Step1Info = TEXT("Cooking assets");
     float Step2ProgressStart = Step1ProgressEnd;
-    float Step2ProgressEnd = 0.9f;
-    String Step2Info = TEXT("Packaging assets");
+    float Step2ProgressEnd = 0.8f;
+    String Step2Info = TEXT("Cooking files");
+    float Step3ProgressStart = Step2ProgressStart;
+    float Step3ProgressEnd = 0.9f;
+    String Step3Info = TEXT("Packaging assets");
 
     data.StepProgress(TEXT("Loading build cache"), 0);
 
@@ -1100,11 +1101,14 @@ bool CookAssetsStep::Perform(CookingData& data)
 #endif
     int32 subStepIndex = 0;
     AssetReference<Asset> assetRef;
-    assetRef.Unload.Bind([]() { LOG(Error, "Asset gets unloaded while cooking it!"); Platform::Sleep(100); });
+    assetRef.Unload.Bind([]
+    {
+        LOG(Error, "Asset got unloaded while cooking it!");
+        Platform::Sleep(100);
+    });
     for (auto i = data.Assets.Begin(); i.IsNotEnd(); ++i)
     {
         BUILD_STEP_CANCEL_CHECK;
-
         data.StepProgress(Step1Info, Math::Lerp(Step1ProgressStart, Step1ProgressEnd, static_cast<float>(subStepIndex++) / data.Assets.Count()));
         const Guid assetId = i->Item;
 
@@ -1184,6 +1188,35 @@ bool CookAssetsStep::Perform(CookingData& data)
     // Save build cache header
     cache.Save(data);
 
+    // Process all files
+    for (auto i = data.Files.Begin(); i.IsNotEnd(); ++i)
+    {
+        BUILD_STEP_CANCEL_CHECK;
+        data.StepProgress(Step2Info, Math::Lerp(Step2ProgressStart, Step2ProgressEnd, (float)subStepIndex++ / data.Files.Count()));
+        const String& filePath = i->Item;
+
+        // Calculate destination path
+        String cookedPath = data.DataOutputPath;
+        if (FileSystem::IsRelative(filePath))
+            cookedPath /= filePath;
+        else
+            cookedPath /= String(TEXT("Content")) / StringUtils::GetFileName(filePath);
+
+        // Copy file
+        if (!FileSystem::FileExists(cookedPath) || FileSystem::GetFileLastEditTime(cookedPath) >= FileSystem::GetFileLastEditTime(filePath))
+        {
+            if (FileSystem::CreateDirectory(StringUtils::GetDirectoryName(cookedPath)))
+                return true;
+            if (FileSystem::CopyFile(cookedPath, filePath))
+                return true;
+        }
+
+        // Count stats of file extension
+        auto& assetStats = data.Stats.AssetStats[FileSystem::GetExtension(cookedPath)];
+        assetStats.Count++;
+        assetStats.ContentSize += FileSystem::GetFileSize(cookedPath);
+    }
+
     // Create build game header
     {
         GameHeaderFlags gameFlags = GameHeaderFlags::None;
@@ -1229,13 +1262,11 @@ bool CookAssetsStep::Perform(CookingData& data)
         for (auto i = AssetsRegistry.Begin(); i.IsNotEnd(); ++i)
         {
             BUILD_STEP_CANCEL_CHECK;
-
-            data.StepProgress(Step2Info, Math::Lerp(Step2ProgressStart, Step2ProgressEnd, static_cast<float>(subStepIndex++) / AssetsRegistry.Count()));
+            data.StepProgress(Step3Info, Math::Lerp(Step3ProgressStart, Step3ProgressEnd, (float)subStepIndex++ / AssetsRegistry.Count()));
             const auto assetId = i->Key;
 
             String cookedFilePath;
             cache.GetFilePath(assetId, cookedFilePath);
-
             if (!FileSystem::FileExists(cookedFilePath))
             {
                 LOG(Warning, "Missing cooked file for asset \'{0}\'", assetId);
@@ -1246,8 +1277,6 @@ bool CookAssetsStep::Perform(CookingData& data)
             assetStats.Count++;
             assetStats.ContentSize += FileSystem::GetFileSize(cookedFilePath);
 
-            LOG(Info, "Cooked size of {0}: {1}KB", assetId, (FileSystem::GetFileSize(cookedFilePath) / (1024)));
-
             if (packageBuilder.Add(data, i->Value, cookedFilePath))
                 return true;
         }
@@ -1255,12 +1284,12 @@ bool CookAssetsStep::Perform(CookingData& data)
             return true;
         for (auto& e : data.Stats.AssetStats)
             e.Value.TypeName = e.Key;
-        data.Stats.ContentSizeMB = static_cast<int32>(packageBuilder.GetPackagesSizeTotal() / (1024 * 1024));
+        data.Stats.ContentSize += packageBuilder.GetPackagesSizeTotal();
     }
 
     BUILD_STEP_CANCEL_CHECK;
 
-    data.StepProgress(TEXT("Creating assets cache"), Step2ProgressEnd);
+    data.StepProgress(TEXT("Creating assets cache"), Step3ProgressEnd);
 
     // Create asset paths mapping for the assets.
     // Assets mapping is use to convert paths used in Content::Load(path) into the asset id.
@@ -1293,7 +1322,7 @@ bool CookAssetsStep::Perform(CookingData& data)
     }
 
     // Print stats
-    LOG(Info, "Cooked {0} assets, total assets: {1}, total content packages size: {2} MB", data.Stats.CookedAssets, AssetsRegistry.Count(), data.Stats.ContentSizeMB);
+    LOG(Info, "Cooked {0} assets, total assets: {1}, total content packages size: {2} MB", data.Stats.CookedAssets, AssetsRegistry.Count(), (int32)(data.Stats.ContentSize / (1024 * 1024)));
     {
         Array<CookingData::AssetTypeStatistics> assetTypes;
         data.Stats.AssetStats.GetValues(assetTypes);

Source/Editor/Cooker/Steps/DeployDataStep.cpp

@@ -73,6 +73,7 @@ bool DeployDataStep::Perform(CookingData& data)
             {
             case BuildPlatform::Windows32:
             case BuildPlatform::Windows64:
+            case BuildPlatform::WindowsARM64:
                 canUseSystemDotnet = PLATFORM_TYPE == PlatformType::Windows;
                 break;
             case BuildPlatform::LinuxX64:
@@ -159,7 +160,20 @@ bool DeployDataStep::Perform(CookingData& data)
                 }
                 else
                 {
-                    failed |= EditorUtilities::CopyDirectoryIfNewer(dstDotnet / TEXT("host/fxr") / version, srcDotnet / TEXT("host/fxr") / version, true);
+                    // TODO: hostfxr for target platform should be copied from nuget package location: microsoft.netcore.app.runtime.<RID>/<VERSION>/runtimes/<RID>/native/hostfxr.dll
+                    String dstHostfxr = dstDotnet / TEXT("host/fxr") / version;
+                    if (!FileSystem::DirectoryExists(dstHostfxr))
+                        FileSystem::CreateDirectory(dstHostfxr);
+                    const Char *platformName, *archName;
+                    data.GetBuildPlatformName(platformName, archName);
+                    if (data.Platform == BuildPlatform::Windows64 || data.Platform == BuildPlatform::WindowsARM64 || data.Platform == BuildPlatform::Windows32)
+                        failed |= FileSystem::CopyFile(dstHostfxr / TEXT("hostfxr.dll"), depsRoot / TEXT("ThirdParty") / archName / TEXT("hostfxr.dll"));
+                    else if (data.Platform == BuildPlatform::LinuxX64)
+                        failed |= FileSystem::CopyFile(dstHostfxr / TEXT("hostfxr.so"), depsRoot / TEXT("ThirdParty") / archName / TEXT("hostfxr.so"));
+                    else if (data.Platform == BuildPlatform::MacOSx64 || data.Platform == BuildPlatform::MacOSARM64)
+                        failed |= FileSystem::CopyFile(dstHostfxr / TEXT("hostfxr.dylib"), depsRoot / TEXT("ThirdParty") / archName / TEXT("hostfxr.dylib"));
+                    else
+                        failed |= true;
                     failed |= EditorUtilities::CopyDirectoryIfNewer(dstDotnet / TEXT("shared/Microsoft.NETCore.App") / version, srcDotnet / TEXT("shared/Microsoft.NETCore.App") / version, true);
                 }
                 if (failed)
@@ -353,9 +367,9 @@ bool DeployDataStep::Perform(CookingData& data)
     data.AddRootEngineAsset(TEXT("Engine/Textures/NormalTexture"));
     data.AddRootEngineAsset(TEXT("Engine/Textures/BlackTexture"));
     data.AddRootEngineAsset(TEXT("Engine/Textures/WhiteTexture"));
-    //data.AddRootEngineAsset(TEXT("Engine/Textures/DefaultLensStarburst"));
-    //data.AddRootEngineAsset(TEXT("Engine/Textures/DefaultLensColor"));
-    //data.AddRootEngineAsset(TEXT("Engine/Textures/DefaultLensDirt"));
+    data.AddRootEngineAsset(TEXT("Engine/Textures/DefaultLensStarburst"));
+    data.AddRootEngineAsset(TEXT("Engine/Textures/DefaultLensColor"));
+    data.AddRootEngineAsset(TEXT("Engine/Textures/DefaultLensDirt"));
     data.AddRootEngineAsset(TEXT("Engine/Textures/Bokeh/Circle"));
     data.AddRootEngineAsset(TEXT("Engine/Textures/Bokeh/Hexagon"));
     data.AddRootEngineAsset(TEXT("Engine/Textures/Bokeh/Octagon"));

Source/Editor/CustomEditors/CustomEditor.cs

@@ -663,7 +663,7 @@ namespace FlaxEditor.CustomEditors
                 }
             }
 
-            if ((obj == null && !Values.Type.IsValueType) || Values.Type.IsInstanceOfType(obj))
+            if (obj == null || Values.Type.IsInstanceOfType(obj))
             {
                 result = obj;
                 return true;
@@ -675,7 +675,20 @@ namespace FlaxEditor.CustomEditors
         /// <summary>
         /// Gets a value indicating whether can paste value from the system clipboard to the property value container.
         /// </summary>
-        public bool CanPaste => !string.IsNullOrEmpty(Clipboard.Text);
+        public bool CanPaste
+        {
+            get
+            {
+                try
+                {
+                    return GetClipboardObject(out _, false);
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+        }
 
         /// <summary>
         /// Sets the value from the system clipboard.

Source/Editor/CustomEditors/CustomEditorPresenter.cs

@@ -192,15 +192,6 @@ namespace FlaxEditor.CustomEditors
                 Presenter.AfterLayout?.Invoke(layout);
             }
 
-            /// <inheritdoc />
-            protected override void Deinitialize()
-            {
-                Editor = null;
-                _overrideEditor = null;
-
-                base.Deinitialize();
-            }
-
             /// <inheritdoc />
             protected override void OnModified()
             {

Source/Editor/CustomEditors/CustomEditorsUtil.cs

@@ -52,13 +52,18 @@ namespace FlaxEditor.CustomEditors
             // Check if use provided editor
             if (overrideEditor != null)
                 return overrideEditor;
+            ScriptType targetType = values.Type;
 
             // Special case if property is a pure object type and all values are the same type
-            if (values.Type.Type == typeof(object) && values.Count > 0 && values[0] != null && !values.HasDifferentTypes)
+            if (targetType.Type == typeof(object) && values.Count > 0 && values[0] != null && !values.HasDifferentTypes)
                 return CreateEditor(TypeUtils.GetObjectType(values[0]), canUseRefPicker);
 
+            // Special case if property is interface but the value is implemented as Scripting Object that should use reference picker
+            if (targetType.IsInterface && canUseRefPicker && values.Count > 0 && values[0] is FlaxEngine.Object)
+                return new DummyEditor();
+
             // Use editor for the property type
-            return CreateEditor(values.Type, canUseRefPicker);
+            return CreateEditor(targetType, canUseRefPicker);
         }
 
         internal static CustomEditor CreateEditor(ScriptType targetType, bool canUseRefPicker = true)

Source/Editor/CustomEditors/Dedicated/ActorEditor.cs

@@ -186,7 +186,7 @@ namespace FlaxEditor.CustomEditors.Dedicated
             if (_linkedPrefabId != Guid.Empty)
             {
                 _linkedPrefabId = Guid.Empty;
-                Editor.Instance.Prefabs.PrefabApplying -= OnPrefabApplying;
+                Editor.Instance.Prefabs.PrefabApplied -= OnPrefabApplying;
                 Editor.Instance.Prefabs.PrefabApplied -= OnPrefabApplied;
             }
         }

Source/Editor/CustomEditors/Dedicated/LayersMaskEditor.cs

@@ -1,5 +1,6 @@
 // Copyright (c) 2012-2024 Wojciech Figat. All rights reserved.
 
+using System.Collections.Generic;
 using FlaxEditor.Content.Settings;
 using FlaxEngine;
 using FlaxEngine.GUI;
@@ -12,7 +13,7 @@ namespace FlaxEditor.CustomEditors.Dedicated
     [CustomEditor(typeof(LayersMask)), DefaultEditor]
     internal class LayersMaskEditor : CustomEditor
     {
-        private CheckBox[] _checkBoxes;
+        private List<CheckBox> _checkBoxes;
 
         /// <inheritdoc />
         public override void Initialize(LayoutElementsContainer layout)
@@ -24,16 +25,18 @@ namespace FlaxEditor.CustomEditors.Dedicated
                 return;
             }
 
-            _checkBoxes = new CheckBox[layers.Length];
+            _checkBoxes = new List<CheckBox>();
             for (int i = 0; i < layers.Length; i++)
             {
                 var layer = layers[i];
-                var property = layout.AddPropertyItem(layer);
+                if (string.IsNullOrEmpty(layer))
+                    continue;
+                var property = layout.AddPropertyItem($"{i}: {layer}");
                 var checkbox = property.Checkbox().CheckBox;
                 UpdateCheckbox(checkbox, i);
                 checkbox.Tag = i;
                 checkbox.StateChanged += OnCheckboxStateChanged;
-                _checkBoxes[i] = checkbox;
+                _checkBoxes.Add(checkbox);
             }
         }
 
@@ -50,9 +53,9 @@ namespace FlaxEditor.CustomEditors.Dedicated
         {
             if (_checkBoxes != null)
             {
-                for (int i = 0; i < _checkBoxes.Length; i++)
+                for (int i = 0; i < _checkBoxes.Count; i++)
                 {
-                    UpdateCheckbox(_checkBoxes[i], i);
+                    UpdateCheckbox(_checkBoxes[i], (int)_checkBoxes[i].Tag);
                 }
             }
 

Source/Editor/CustomEditors/Dedicated/ScriptsEditor.cs

@@ -1029,7 +1029,6 @@ namespace FlaxEditor.CustomEditors.Dedicated
         protected override void Deinitialize()
         {
             _scriptToggles = null;
-            _scripts.Clear();
 
             base.Deinitialize();
         }

Source/Editor/CustomEditors/Dedicated/UIControlEditor.cs

@@ -456,14 +456,57 @@ namespace FlaxEditor.CustomEditors.Dedicated
 
             for (int i = 0; i < layout.Children.Count; i++)
             {
-                if (layout.Children[i] is GroupElement group && group.Panel.HeaderText == "Transform")
+                if (layout.Children[i] is GroupElement group && group.Panel.HeaderText.Equals("Transform", StringComparison.Ordinal))
                 {
-                    VerticalPanelElement mainHor = VerticalPanelWithoutMargin(group);
-                    CreateTransformElements(mainHor, ValuesTypes);
-                    group.ContainerControl.ChangeChildIndex(mainHor.Control, 0);
+                    layout.Children.Remove(group);
+                    layout.ContainerControl.Children.Remove(group.Panel);
                     break;
                 }
             }
+
+            // Setup transform
+            if (Presenter is LayoutElementsContainer l)
+            {
+                for (int i = 0; i < l.Children.Count; i++)
+                {
+                    if (l.Children[i] is GroupElement g && g.Panel.HeaderText.Equals("Transform", StringComparison.Ordinal))
+                    {
+                        l.Children.Remove(g);
+                        l.ContainerControl.Children.Remove(g.Panel);
+                        break;
+                    }
+                }
+
+                var transformGroup = l.Group("Transform");
+                VerticalPanelElement mainHor = VerticalPanelWithoutMargin(transformGroup);
+                CreateTransformElements(mainHor, ValuesTypes);
+
+                ScriptMemberInfo scaleInfo = ValuesTypes[0].GetProperty("Scale");
+                ItemInfo scaleItem = new ItemInfo(scaleInfo);
+                transformGroup.Property("Scale", scaleItem.GetValues(Values));
+
+                ScriptMemberInfo pivotInfo = ValuesTypes[0].GetProperty("Pivot");
+                ItemInfo pivotItem = new ItemInfo(pivotInfo);
+                transformGroup.Property("Pivot", pivotItem.GetValues(Values));
+
+                ScriptMemberInfo shearInfo = ValuesTypes[0].GetProperty("Shear");
+                ItemInfo shearItem = new ItemInfo(shearInfo);
+                transformGroup.Property("Shear", shearItem.GetValues(Values));
+
+                ScriptMemberInfo rotationInfo = ValuesTypes[0].GetProperty("Rotation");
+                ItemInfo rotationItem = new ItemInfo(rotationInfo);
+                transformGroup.Property("Rotation", rotationItem.GetValues(Values));
+
+                // Get position of general tab
+                for (int i = 0; i < l.Children.Count; i++)
+                {
+                    if (l.Children[i] is GroupElement g && g.Panel.HeaderText.Equals("General", StringComparison.Ordinal) && i + 1 <= l.Children.Count)
+                    {
+                        Presenter.ContainerControl.ChangeChildIndex(transformGroup.Control, i + 1);
+                        break;
+                    }
+                }
+            }
         }
 
         private void CreateTransformElements(LayoutElementsContainer main, ScriptType[] valueTypes)
@@ -645,7 +688,7 @@ namespace FlaxEditor.CustomEditors.Dedicated
         {
             var grid = UniformGridTwoByOne(el);
             grid.CustomControl.SlotPadding = new Margin(5, 5, 1, 1);
-            var label = grid.Label(text);
+            var label = grid.Label(text, TextAlignment.Far);
             var editor = grid.Object(values);
             if (editor is FloatEditor floatEditor && floatEditor.Element is FloatValueElement floatEditorElement)
             {

Source/Editor/CustomEditors/Editors/AssetRefEditor.cs

@@ -6,6 +6,7 @@ using FlaxEditor.Content;
 using FlaxEditor.GUI;
 using FlaxEditor.Scripting;
 using FlaxEngine;
+using FlaxEngine.GUI;
 using FlaxEngine.Utilities;
 
 namespace FlaxEditor.CustomEditors.Editors
@@ -50,7 +51,6 @@ namespace FlaxEditor.CustomEditors.Editors
             if (HasDifferentTypes)
                 return;
             Picker = layout.Custom<AssetPicker>().CustomControl;
-
             var value = Values[0];
             _valueType = Values.Type.Type != typeof(object) || value == null ? Values.Type : TypeUtils.GetObjectType(value);
             var assetType = _valueType;
@@ -58,37 +58,8 @@ namespace FlaxEditor.CustomEditors.Editors
                 assetType = new ScriptType(typeof(Asset));
             else if (_valueType.Type != null && _valueType.Type.Name == typeof(JsonAssetReference<>).Name)
                 assetType = new ScriptType(_valueType.Type.GenericTypeArguments[0]);
-
-            float height = 48;
-            var attributes = Values.GetAttributes();
-            var assetReference = (AssetReferenceAttribute)attributes?.FirstOrDefault(x => x is AssetReferenceAttribute);
-            if (assetReference != null)
-            {
-                if (assetReference.UseSmallPicker)
-                    height = 32;
-
-                if (string.IsNullOrEmpty(assetReference.TypeName))
-                {
-                }
-                else if (assetReference.TypeName.Length > 1 && assetReference.TypeName[0] == '.')
-                {
-                    // Generic file picker
-                    assetType = ScriptType.Null;
-                    Picker.Validator.FileExtension = assetReference.TypeName;
-                }
-                else
-                {
-                    var customType = TypeUtils.GetType(assetReference.TypeName);
-                    if (customType != ScriptType.Null)
-                        assetType = customType;
-                    else if (!Content.Settings.GameSettings.OptionalPlatformSettings.Contains(assetReference.TypeName))
-                        Debug.LogWarning(string.Format("Unknown asset type '{0}' to use for asset picker filter.", assetReference.TypeName));
-                    else
-                        assetType = ScriptType.Void;
-                }
-            }
-
             Picker.Validator.AssetType = assetType;
+            ApplyAssetReferenceAttribute(Values, out var height, Picker.Validator);
             Picker.Height = height;
             Picker.SelectedItemChanged += OnSelectedItemChanged;
         }
@@ -115,6 +86,37 @@ namespace FlaxEditor.CustomEditors.Editors
                 SetValue(Picker.Validator.SelectedAsset);
         }
 
+        internal static void ApplyAssetReferenceAttribute(ValueContainer values, out float height, AssetPickerValidator validator)
+        {
+            height = 48;
+            var attributes = values.GetAttributes();
+            var assetReference = (AssetReferenceAttribute)attributes?.FirstOrDefault(x => x is AssetReferenceAttribute);
+            if (assetReference != null)
+            {
+                if (assetReference.UseSmallPicker)
+                    height = 32;
+                if (string.IsNullOrEmpty(assetReference.TypeName))
+                {
+                }
+                else if (assetReference.TypeName.Length > 1 && assetReference.TypeName[0] == '.')
+                {
+                    // Generic file picker
+                    validator.AssetType = ScriptType.Null;
+                    validator.FileExtension = assetReference.TypeName;
+                }
+                else
+                {
+                    var customType = TypeUtils.GetType(assetReference.TypeName);
+                    if (customType != ScriptType.Null)
+                        validator.AssetType = customType;
+                    else if (!Content.Settings.GameSettings.OptionalPlatformSettings.Contains(assetReference.TypeName))
+                        Debug.LogWarning(string.Format("Unknown asset type '{0}' to use for asset picker filter.", assetReference.TypeName));
+                    else
+                        validator.AssetType = ScriptType.Void;
+                }
+            }
+        }
+
         /// <inheritdoc />
         public override void Refresh()
         {
@@ -140,4 +142,155 @@ namespace FlaxEditor.CustomEditors.Editors
             }
         }
     }
+
+    /// <summary>
+    /// Default implementation of the inspector used to edit reference to the files via path (absolute or relative to the project).
+    /// </summary>
+    /// <remarks>Supports editing reference to the asset via path using various containers: <see cref="Asset"/> or <see cref="AssetItem"/> or <see cref="System.String"/>.</remarks>
+    public class FilePathEditor : CustomEditor
+    {
+        private sealed class TextBoxWithPicker : TextBox
+        {
+            private const float DropdownIconMargin = 3.0f;
+            private const float DropdownIconSize = 12.0f;
+            private Rectangle DropdownRect => new Rectangle(Width - DropdownIconSize - DropdownIconMargin, DropdownIconMargin, DropdownIconSize, DropdownIconSize);
+
+            public Action ShowPicker;
+
+            public override void Draw()
+            {
+                base.Draw();
+
+                var style = FlaxEngine.GUI.Style.Current;
+                var dropdownRect = DropdownRect;
+                Render2D.DrawSprite(style.ArrowDown, dropdownRect, Enabled ? (DropdownRect.Contains(PointFromWindow(RootWindow.MousePosition)) ? style.BorderSelected : style.Foreground) : style.ForegroundDisabled);
+            }
+
+            public override bool OnMouseDown(Float2 location, MouseButton button)
+            {
+                if (DropdownRect.Contains(ref location))
+                {
+                    Focus();
+                    ShowPicker();
+                    return true;
+                }
+
+                return base.OnMouseDown(location, button);
+            }
+
+            public override void OnMouseMove(Float2 location)
+            {
+                base.OnMouseMove(location);
+
+                if (DropdownRect.Contains(ref location))
+                    Cursor = CursorType.Default;
+                else
+                    Cursor = CursorType.IBeam;
+            }
+
+            protected override Rectangle TextRectangle
+            {
+                get
+                {
+                    var result = base.TextRectangle;
+                    result.Size.X -= DropdownIconSize + DropdownIconMargin * 2;
+                    return result;
+                }
+            }
+
+            protected override Rectangle TextClipRectangle
+            {
+                get
+                {
+                    var result = base.TextClipRectangle;
+                    result.Size.X -= DropdownIconSize + DropdownIconMargin * 2;
+                    return result;
+                }
+            }
+        }
+
+        private TextBoxWithPicker _textBox;
+        private AssetPickerValidator _validator;
+        private bool _isRefreshing;
+
+        /// <inheritdoc />
+        public override DisplayStyle Style => DisplayStyle.Inline;
+
+        /// <inheritdoc />
+        public override void Initialize(LayoutElementsContainer layout)
+        {
+            if (HasDifferentTypes)
+                return;
+            _textBox = layout.Custom<TextBoxWithPicker>().CustomControl;
+            _textBox.ShowPicker = OnShowPicker;
+            _textBox.EditEnd += OnEditEnd;
+            _validator = new AssetPickerValidator(ScriptType.Null);
+            AssetRefEditor.ApplyAssetReferenceAttribute(Values, out _, _validator);
+        }
+
+        private void OnShowPicker()
+        {
+            if (_validator.AssetType != ScriptType.Null)
+                AssetSearchPopup.Show(_textBox, _textBox.BottomLeft, _validator.IsValid, SetPickerPath);
+            else
+                ContentSearchPopup.Show(_textBox, _textBox.BottomLeft, _validator.IsValid, SetPickerPath);
+        }
+
+        private void SetPickerPath(ContentItem item)
+        {
+            var path = Utilities.Utils.ToPathProject(item.Path);
+            SetPath(path);
+
+            _isRefreshing = true;
+            _textBox.Defocus();
+            _textBox.Text = path;
+            _isRefreshing = false;
+
+            _textBox.RootWindow.Focus();
+            _textBox.Focus();
+        }
+
+        private void OnEditEnd()
+        {
+            SetPath(_textBox.Text);
+        }
+
+        private string GetPath()
+        {
+            var value = Values[0];
+            if (value is AssetItem assetItem)
+                return Utilities.Utils.ToPathProject(assetItem.Path);
+            if (value is Asset asset)
+                return Utilities.Utils.ToPathProject(asset.Path);
+            if (value is string str)
+                return str;
+            return null;
+        }
+
+        private void SetPath(string path)
+        {
+            if (_isRefreshing)
+                return;
+            var value = Values[0];
+            if (value is AssetItem)
+                SetValue(Editor.Instance.ContentDatabase.Find(Utilities.Utils.ToPathAbsolute(path)));
+            else if (value is Asset)
+                SetValue(FlaxEngine.Content.LoadAsync(path));
+            else if (value is string)
+                SetValue(path);
+        }
+
+        /// <inheritdoc />
+        public override void Refresh()
+        {
+            base.Refresh();
+
+            if (!HasDifferentValues)
+            {
+                _isRefreshing = true;
+                _textBox.Text = GetPath();
+                _isRefreshing = false;
+            }
+        }
+    }
 }

Source/Editor/CustomEditors/Editors/CollectionEditor.cs

@@ -57,17 +57,18 @@ namespace FlaxEditor.CustomEditors.Editors
                 menu.ItemsContainer.RemoveChildren();
 
                 menu.AddButton("Copy", linkedEditor.Copy);
-                var paste = menu.AddButton("Paste", linkedEditor.Paste);
-                paste.Enabled = linkedEditor.CanPaste;
+                var b = menu.AddButton("Paste", linkedEditor.Paste);
+                b.Enabled = linkedEditor.CanPaste && !Editor._readOnly;
 
                 menu.AddSeparator();
-                var moveUpButton = menu.AddButton("Move up", OnMoveUpClicked);
-                moveUpButton.Enabled = Index > 0;
+                b = menu.AddButton("Move up", OnMoveUpClicked);
+                b.Enabled = Index > 0 && !Editor._readOnly;
 
-                var moveDownButton = menu.AddButton("Move down", OnMoveDownClicked);
-                moveDownButton.Enabled = Index + 1 < Editor.Count;
-
-                menu.AddButton("Remove", OnRemoveClicked);
+                b = menu.AddButton("Move down", OnMoveDownClicked);
+                b.Enabled = Index + 1 < Editor.Count && !Editor._readOnly;
+                
+                b = menu.AddButton("Remove", OnRemoveClicked);
+                b.Enabled = !Editor._readOnly;
             }
 
             private void OnMoveUpClicked()
@@ -177,6 +178,7 @@ namespace FlaxEditor.CustomEditors.Editors
         private IntValueBox _sizeBox;
         private Color _background;
         private int _elementsCount, _minCount, _maxCount;
+        private bool _readOnly;
         private bool _canResize;
         private bool _canReorderItems;
         private CollectionAttribute.DisplayType _displayType;
@@ -209,6 +211,7 @@ namespace FlaxEditor.CustomEditors.Editors
                 return;
 
             var size = Count;
+            _readOnly = false;
             _canResize = true;
             _canReorderItems = true;
             _minCount = 0;
@@ -225,6 +228,7 @@ namespace FlaxEditor.CustomEditors.Editors
             if (collection != null)
             {
                 _canResize = !collection.ReadOnly;
+                _readOnly = collection.ReadOnly;
                 _minCount = collection.MinCount;
                 _maxCount = collection.MaxCount;
                 _canReorderItems = collection.CanReorderItems;
@@ -235,6 +239,12 @@ namespace FlaxEditor.CustomEditors.Editors
                 spacing = collection.Spacing;
                 _displayType = collection.Display;
             }
+            if (attributes != null && attributes.Any(x => x is ReadOnlyAttribute))
+            {
+                _readOnly = true;
+                _canResize = false;
+                _canReorderItems = false;
+            }
             if (_maxCount == 0)
                 _maxCount = ushort.MaxValue;
             _canResize &= _minCount < _maxCount;
@@ -243,8 +253,7 @@ namespace FlaxEditor.CustomEditors.Editors
             dragArea.CustomControl.Editor = this;
             dragArea.CustomControl.ElementType = ElementType;
 
-            // Check for the AssetReferenceAttribute. In JSON assets, it can be used to filter
-            // which scripts can be dragged over and dropped on this collection editor.
+            // Check for the AssetReferenceAttribute. In JSON assets, it can be used to filter which scripts can be dragged over and dropped on this collection editor
             var assetReference = (AssetReferenceAttribute)attributes?.FirstOrDefault(x => x is AssetReferenceAttribute);
             if (assetReference != null)
             {
@@ -333,6 +342,8 @@ namespace FlaxEditor.CustomEditors.Editors
                         var property = panel.AddPropertyItem(itemLabel);
                         var itemLayout = (LayoutElementsContainer)property;
                         itemLabel.LinkedEditor = itemLayout.Object(new ListValueContainer(elementType, i, Values, attributes), overrideEditor);
+                        if (_readOnly && itemLayout.Children.Count > 0)
+                            GenericEditor.OnReadOnlyProperty(itemLayout);
                     }
                     else if (_displayType == CollectionAttribute.DisplayType.Header || (_displayType == CollectionAttribute.DisplayType.Default && !single))
                     {
@@ -340,13 +351,15 @@ namespace FlaxEditor.CustomEditors.Editors
                         cdp.CustomControl.Setup(this, i, _canReorderItems);
                         var itemLayout = cdp.VerticalPanel();
                         cdp.CustomControl.LinkedEditor = itemLayout.Object(new ListValueContainer(elementType, i, Values, attributes), overrideEditor);
+                        if (_readOnly && itemLayout.Children.Count > 0)
+                            GenericEditor.OnReadOnlyProperty(itemLayout);
                     }
                 }
             }
             _elementsCount = size;
 
             // Add/Remove buttons
-            if (_canResize)
+            if (_canResize && !_readOnly)
             {
                 var panel = dragArea.HorizontalPanel();
                 panel.Panel.Size = new Float2(0, 20);

Source/Editor/CustomEditors/Editors/DictionaryEditor.cs

@@ -131,7 +131,7 @@ namespace FlaxEditor.CustomEditors.Editors
             /// <inheritdoc />
             public override bool OnMouseDoubleClick(Float2 location, MouseButton button)
             {
-                if (button == MouseButton.Left)
+                if (button == MouseButton.Left && _editor._canEditKeys)
                 {
                     OnEditClicked(null);
                     return true;
@@ -197,6 +197,11 @@ namespace FlaxEditor.CustomEditors.Editors
                 spacing = collection.Spacing;
                 _displayType = collection.Display;
             }
+            if (attributes != null && attributes.Any(x => x is ReadOnlyAttribute))
+            {
+                _readOnly = true;
+                _canEditKeys = false;
+            }
 
             // Size
             if (layout.ContainerControl is DropPanel dropPanel)
@@ -239,14 +244,6 @@ namespace FlaxEditor.CustomEditors.Editors
                 var keysEnumerable = ((IDictionary)Values[0]).Keys.OfType<object>();
                 var keys = keysEnumerable as object[] ?? keysEnumerable.ToArray();
                 var valuesType = new ScriptType(valueType);
-                
-                bool single = valuesType.IsPrimitive ||
-                              valuesType.Equals(new ScriptType(typeof(string))) ||
-                              valuesType.IsEnum ||
-                              (valuesType.GetFields().Length == 1 && valuesType.GetProperties().Length == 0) ||
-                              (valuesType.GetProperties().Length == 1 && valuesType.GetFields().Length == 0) ||
-                              valuesType.Equals(new ScriptType(typeof(JsonAsset))) ||
-                              valuesType.Equals(new ScriptType(typeof(SettingsBase)));
 
                 // Use separate layout cells for each collection items to improve layout updates for them in separation
                 var useSharedLayout = valueType.IsPrimitive || valueType.IsEnum;
@@ -263,6 +260,8 @@ namespace FlaxEditor.CustomEditors.Editors
                     var property = panel.AddPropertyItem(new DictionaryItemLabel(this, key));
                     var itemLayout = useSharedLayout ? (LayoutElementsContainer)property : property.VerticalPanel();
                     itemLayout.Object(new DictionaryValueContainer(valuesType, key, Values), overrideEditor);
+                    if (_readOnly && itemLayout.Children.Count > 0)
+                        GenericEditor.OnReadOnlyProperty(itemLayout);
                 }
             }
             _elementsCount = size;

Source/Editor/CustomEditors/Editors/DummyEditor.cs

@@ -0,0 +1,17 @@
+// Copyright (c) 2012-2024 Wojciech Figat. All rights reserved.
+
+namespace FlaxEditor.CustomEditors.Editors
+{
+    internal sealed class DummyEditor : CustomEditor
+    {
+        public override void Initialize(LayoutElementsContainer layout)
+        {
+            string valueName;
+            if (Values.Count != 0 && Values[0] != null)
+                valueName = Values[0].ToString();
+            else
+                valueName = "null";
+            layout.Label($"{valueName} ({Values.Type})");
+        }
+    }
+}

Source/Editor/CustomEditors/Editors/GenericEditor.cs

@@ -474,7 +474,32 @@ namespace FlaxEditor.CustomEditors.Editors
             }
             if (layout.Editors.Count != 0)
             {
-                return !string.IsNullOrEmpty(Clipboard.Text);
+                var sb = Clipboard.Text;
+                if (!string.IsNullOrEmpty(sb))
+                {
+                    try
+                    {
+                        var data = JsonSerializer.Deserialize<string[]>(sb);
+                        if (data == null || data.Length != layout.Editors.Count)
+                            return false;
+                        for (var i = 0; i < layout.Editors.Count; i++)
+                        {
+                            Clipboard.Text = data[i];
+                            if (!layout.Editors[i].CanPaste)
+                                return false;
+                        }
+                        return true;
+                    }
+                    catch
+                    {
+                        return false;
+                    }
+                    finally
+                    {
+                        Clipboard.Text = sb;
+                    }
+                }
+                return false;
             }
             if (layout.Children.Any(x => x is LayoutElementsContainer))
             {
@@ -556,6 +581,43 @@ namespace FlaxEditor.CustomEditors.Editors
             return layout;
         }
 
+        internal static void OnReadOnlyProperty(LayoutElementsContainer itemLayout, int labelIndex = -1)
+        {
+            PropertiesListElement list = null;
+            int firstChildControlIndex = 0;
+            bool disableSingle = true;
+            var control = itemLayout.Children[itemLayout.Children.Count - 1];
+            if (control is GroupElement group && group.Children.Count > 0)
+            {
+                list = group.Children[0] as PropertiesListElement;
+                disableSingle = false; // Disable all nested editors
+            }
+            else if (control is PropertiesListElement list1 && labelIndex != -1)
+            {
+                list = list1;
+                firstChildControlIndex = list.Labels[labelIndex].FirstChildControlIndex;
+            }
+            else if (control?.Control != null)
+            {
+                control.Control.Enabled = false;
+            }
+
+            if (list != null)
+            {
+                // Disable controls added to the editor
+                var count = list.Properties.Children.Count;
+                for (int j = firstChildControlIndex; j < count; j++)
+                {
+                    var child = list.Properties.Children[j];
+                    if (disableSingle && child is PropertyNameLabel)
+                        break;
+
+                    if (child != null)
+                        child.Enabled = false;
+                }
+            }
+        }
+
         /// <summary>
         /// Evaluate the <see cref="VisibleIfAttribute"/> cache for a given property item.
         /// </summary>
@@ -635,35 +697,7 @@ namespace FlaxEditor.CustomEditors.Editors
 
             if (item.IsReadOnly && itemLayout.Children.Count > 0)
             {
-                PropertiesListElement list = null;
-                int firstChildControlIndex = 0;
-                bool disableSingle = true;
-                var control = itemLayout.Children[itemLayout.Children.Count - 1];
-                if (control is GroupElement group && group.Children.Count > 0)
-                {
-                    list = group.Children[0] as PropertiesListElement;
-                    disableSingle = false; // Disable all nested editors
-                }
-                else if (control is PropertiesListElement list1)
-                {
-                    list = list1;
-                    firstChildControlIndex = list.Labels[labelIndex].FirstChildControlIndex;
-                }
-
-                if (list != null)
-                {
-                    // Disable controls added to the editor
-                    var count = list.Properties.Children.Count;
-                    for (int j = firstChildControlIndex; j < count; j++)
-                    {
-                        var child = list.Properties.Children[j];
-                        if (disableSingle && child is PropertyNameLabel)
-                            break;
-
-                        if (child != null)
-                            child.Enabled = false;
-                    }
-                }
+                OnReadOnlyProperty(itemLayout, labelIndex);
             }
 
             EvaluateVisibleIf(itemLayout, item, labelIndex);
@@ -799,15 +833,6 @@ namespace FlaxEditor.CustomEditors.Editors
             OnGroupsEnd();
         }
 
-        /// <inheritdoc />
-        protected override void Deinitialize()
-        {
-            _visibleIfCaches = null;
-            _visibleIfPropertiesListsCache = null;
-
-            base.Deinitialize();
-        }
-
         /// <inheritdoc />
         public override void Refresh()
         {

Source/Editor/CustomEditors/Editors/IBrushEditor.cs

@@ -25,6 +25,7 @@ namespace FlaxEditor.CustomEditors.Editors
             new OptionType("Linear Gradient", typeof(LinearGradientBrush)),
             new OptionType("Texture 9-Slicing", typeof(Texture9SlicingBrush)),
             new OptionType("Sprite 9-Slicing", typeof(Sprite9SlicingBrush)),
+            new OptionType("Video", typeof(VideoBrush)),
         };
     }
 }

Source/Editor/CustomEditors/GUI/PropertiesList.cs

@@ -242,7 +242,7 @@ namespace FlaxEditor.CustomEditors.GUI
             float namesWidth = _splitterValue * Width;
             int count = _element.Labels.Count;
             float[] yStarts = new float[count + 1];
-            for (int i = 1; i < count; i++)
+            for (int i = 0; i < count; i++)
             {
                 var label = _element.Labels[i];
 
@@ -251,9 +251,13 @@ namespace FlaxEditor.CustomEditors.GUI
                 else if (_children.Count <= label.FirstChildControlIndex)
                     yStarts[i] = y;
                 else
+                {
                     yStarts[i] = _children[label.FirstChildControlIndex].Top;
+                    if (i == count - 1)
+                        yStarts[i + 1] = _children[label.FirstChildControlIndex].Bottom;
+                }
+                   
             }
-            yStarts[count] = y;
             for (int i = 0; i < count; i++)
             {
                 var label = _element.Labels[i];

Source/Editor/Editor.cs

@@ -497,8 +497,6 @@ namespace FlaxEditor
                 Debug.LogException(ex);
             }
 
-            ManagedHandle.ManagedHandlePool.TryCollectWeakHandles();
-
             Profiler.EndEvent();
         }
 

Source/Editor/GUI/AssetPicker.cs

@@ -5,10 +5,8 @@ using System.IO;
 using FlaxEditor.Content;
 using FlaxEditor.GUI.Drag;
 using FlaxEditor.Scripting;
-using FlaxEditor.Utilities;
 using FlaxEngine;
 using FlaxEngine.GUI;
-using FlaxEngine.Utilities;
 
 namespace FlaxEditor.GUI
 {

Source/Editor/GUI/ContextMenu/ContextMenuBase.cs

@@ -235,9 +235,6 @@ namespace FlaxEditor.GUI.ContextMenu
             _previouslyFocused = parentWin.FocusedControl;
             Focus();
             OnShow();
-
-            // Throttle rendering of static content
-            _window.RenderTask.RenderFPS = 2;
         }
 
         /// <summary>

Source/Editor/GUI/Dialogs/ColorPickerDialog.cs

@@ -264,6 +264,7 @@ namespace FlaxEditor.GUI.Dialogs
                     {
                         Text = "+",
                         Parent = this,
+                        TooltipText = "Save Color.",
                         Tag = null,
                     };
                     savedColorButton.ButtonClicked += (b) => OnSavedColorButtonClicked(b);
@@ -370,9 +371,25 @@ namespace FlaxEditor.GUI.Dialogs
             Render2D.DrawText(style.FontMedium, "Hex", hex, textColor, TextAlignment.Near, TextAlignment.Center);
 
             // Color difference
-            var newRect = new Rectangle(_cOK.X, _cHex.Bottom + PickerMargin, _cCancel.Right - _cOK.Left, 0);
-            newRect.Size.Y = _cValue.Bottom - newRect.Y;
-            Render2D.FillRectangle(newRect, _value * _value.A);
+            var newRect = new Rectangle(_cOK.X - 3, _cHex.Bottom + PickerMargin, 130, 0);
+            newRect.Size.Y = 50;
+            Render2D.FillRectangle(newRect, Color.White);
+            var smallRectSize = 10;
+            var numHor = Mathf.FloorToInt(newRect.Width / smallRectSize);
+            var numVer = Mathf.FloorToInt(newRect.Height / smallRectSize);
+            // Draw checkerboard for background of color to help with transparency
+            for (int i = 0; i < numHor; i++)
+            {
+                for (int j = 0; j < numVer; j++)
+                {
+                    if ((i + j) % 2 == 0 )
+                    {
+                        var rect = new Rectangle(newRect.X + smallRectSize * i, newRect.Y + smallRectSize * j, new Float2(smallRectSize));
+                        Render2D.FillRectangle(rect, Color.Gray);
+                    }
+                }
+            }
+            Render2D.FillRectangle(newRect, _value);
         }
 
         /// <inheritdoc />
@@ -498,6 +515,7 @@ namespace FlaxEditor.GUI.Dialogs
                 {
                     Text = "+",
                     Parent = this,
+                    TooltipText = "Save Color.",
                     Tag = null,
                 };
                 savedColorButton.ButtonClicked += (b) => OnSavedColorButtonClicked(b);

Source/Editor/GUI/Dialogs/ColorSelector.cs

@@ -311,7 +311,9 @@ namespace FlaxEditor.GUI.Dialogs
             // Alpha
             float alphaY = _slider2Rect.Height * (1 - _color.A);
             var alphaR = new Rectangle(_slider2Rect.X - slidersOffset, _slider2Rect.Y + alphaY - slidersThickness / 2, _slider2Rect.Width + slidersOffset * 2, slidersThickness);
-            Render2D.FillRectangle(_slider2Rect, _color, _color, Color.Transparent, Color.Transparent);
+            var color = _color;
+            color.A = 1; // Keep slider 2 fill rect from changing color alpha while selecting.
+            Render2D.FillRectangle(_slider2Rect, color, color, Color.Transparent, Color.Transparent);
             Render2D.DrawRectangle(_slider2Rect, _isMouseDownSlider2 ? style.BackgroundSelected : Color.Black);
             Render2D.DrawRectangle(alphaR, _isMouseDownSlider2 ? Color.White : Color.Gray);
         }

Source/Editor/GUI/Dialogs/Dialog.cs

@@ -178,9 +178,6 @@ namespace FlaxEditor.GUI.Dialogs
             windowGUI.PerformLayout();
 
             OnShow();
-
-            // Throttle rendering of static content
-            _window.RenderTask.RenderFPS = 2;
         }
 
         private void OnClosing(ClosingReason reason, ref bool cancel)

Source/Editor/GUI/Docking/DockHintWindow.cs

@@ -346,10 +346,6 @@ namespace FlaxEditor.GUI.Docking
         {
             if (button == MouseButton.Left)
             {
-                // Workaround to make sure the mouse down event which initiated dragging in moved window gets properly
-                // released when this window gets destroyed.
-                _toMove.Window.Window.Internal_OnMouseUp(ref location, button);
-
                 Dispose();
             }
         }
@@ -451,9 +447,6 @@ namespace FlaxEditor.GUI.Docking
                     Window = Platform.CreateWindow(ref settings);
                     Window.Opacity = 0.6f;
                     Window.GUI.BackgroundColor = Style.Current.DragWindow;
-
-                    // Throttle rendering of static content
-                    Window.RenderTask.RenderFPS = 2;
                 }
                 else
                 {
@@ -487,9 +480,6 @@ namespace FlaxEditor.GUI.Docking
                 win = Platform.CreateWindow(ref settings);
                 win.Opacity = 0.6f;
                 win.GUI.BackgroundColor = Style.Current.DragWindow;
-
-                // Throttle rendering of static content
-                win.RenderTask.RenderFPS = 2;
             }
 
             /// <summary>

Source/Editor/GUI/Tabs/Tabs.cs

@@ -418,9 +418,19 @@ namespace FlaxEditor.GUI.Tabs
             {
                 // If scroll bar is visible it covers part of the tab header so include this in tab size to improve usability
                 if (_orientation == Orientation.Horizontal && TabsPanel.HScrollBar.Visible)
+                {
                     tabsSize.Y += TabsPanel.HScrollBar.Height;
+                    var style = Style.Current;
+                    TabsPanel.HScrollBar.TrackColor = style.Background;
+                    TabsPanel.HScrollBar.ThumbColor = style.ForegroundGrey;
+                }
                 else if (_orientation == Orientation.Vertical && TabsPanel.VScrollBar.Visible)
+                {
                     tabsSize.X += TabsPanel.VScrollBar.Width;
+                    var style = Style.Current;
+                    TabsPanel.VScrollBar.TrackColor = style.Background;
+                    TabsPanel.VScrollBar.ThumbColor = style.ForegroundGrey;
+                }
             }
 
             // Fit the tabs panel

Source/Editor/GUI/Tree/TreeNode.cs

@@ -698,6 +698,38 @@ namespace FlaxEditor.GUI.Tree
                 }
             }
 
+            // Show tree guide lines
+            if (Editor.Instance.Options.Options.Interface.ShowTreeLines)
+            {
+                TreeNode parentNode = Parent as TreeNode;
+                bool thisNodeIsLast = false;
+                while (parentNode != null && parentNode != ParentTree.Children[0])
+                {
+                    float bottomOffset = 0;
+                    float topOffset = 0;
+
+                    if (Parent == parentNode && this == Parent.Children[0])
+                        topOffset = 2;
+
+                    if (thisNodeIsLast && parentNode.Children.Count == 1)
+                        bottomOffset = topOffset != 0 ? 4 : 2;
+
+                    if (Parent == parentNode && this == Parent.Children[Parent.Children.Count - 1] && !_opened)
+                    {
+                        thisNodeIsLast = true;
+                        bottomOffset = topOffset != 0 ? 4 : 2;
+                    }
+
+                    float leftOffset = 9;
+                    // Adjust offset for icon image
+                    if (_iconCollaped.IsValid)
+                        leftOffset += 18;
+                    var lineRect1 = new Rectangle(parentNode.TextRect.Left - leftOffset, parentNode.HeaderRect.Top + topOffset, 1, parentNode.HeaderRect.Height - bottomOffset);
+                    Render2D.FillRectangle(lineRect1, isSelected ? style.ForegroundGrey : style.LightBackground);
+                    parentNode = parentNode.Parent as TreeNode;
+                }
+            }
+
             // Base
             if (_opened)
             {
@@ -729,7 +761,7 @@ namespace FlaxEditor.GUI.Tree
 
                 // Try to estimate the rough location of the first node, assuming the node height is constant
                 var firstChildGlobalRect = GetChildGlobalRectangle(children[0], ref globalTransform);
-                var firstVisibleChild = Math.Clamp((int)Math.Floor((globalClipping.Y - firstChildGlobalRect.Top) / firstChildGlobalRect.Height) + 1, 0, children.Count - 1);
+                var firstVisibleChild = Math.Clamp((int)Math.Floor((globalClipping.Y - firstChildGlobalRect.Top) / _headerHeight) + 1, 0, children.Count - 1);
                 if (GetChildGlobalRectangle(children[firstVisibleChild], ref globalTransform).Top > globalClipping.Top || !children[firstVisibleChild].Visible)
                 {
                     // Estimate overshoot, either it's partially visible or hidden in the tree

Source/Editor/Gizmo/UIEditorGizmo.cs

@@ -499,6 +499,15 @@ namespace FlaxEditor
             bool drawAnySelectedControl = false;
             var transformGizmo = TransformGizmo;
             var mousePos = PointFromWindow(RootWindow.MousePosition);
+            if (EnableSelecting && !_mouseMovesControl && !_mouseMovesWidget && IsMouseOver)
+            {
+                // Highlight control under mouse for easier selecting (except if already selected)
+                if (RayCastControl(ref mousePos, out var hitControl) &&
+                    (transformGizmo == null || !transformGizmo.Selection.Any(x => x.EditableObject is UIControl controlActor && controlActor.Control == hitControl)))
+                {
+                    DrawControl(null, hitControl, false, ref mousePos, ref drawAnySelectedControl);
+                }
+            }
             if (transformGizmo != null)
             {
                 // Selected UI controls outline
@@ -511,15 +520,6 @@ namespace FlaxEditor
                     }
                 }
             }
-            if (EnableSelecting && !_mouseMovesControl && !_mouseMovesWidget && IsMouseOver)
-            {
-                // Highlight control under mouse for easier selecting (except if already selected)
-                if (RayCastControl(ref mousePos, out var hitControl) &&
-                    (transformGizmo == null || !transformGizmo.Selection.Any(x => x.EditableObject is UIControl controlActor && controlActor.Control == hitControl)))
-                {
-                    DrawControl(null, hitControl, false, ref mousePos, ref drawAnySelectedControl);
-                }
-            }
             if (drawAnySelectedControl)
                 Render2D.PopTransform();
 
@@ -617,40 +617,39 @@ namespace FlaxEditor
                 // Draw sizing widgets
                 if (_widgets == null)
                     _widgets = new List<Widget>();
-                var widgetSize = 8.0f;
+                var widgetSize = 10.0f;
                 var viewScale = ViewScale;
                 if (viewScale < 0.7f)
                     widgetSize *= viewScale;
                 var controlSize = control.Size.Absolute.MinValue / 50.0f;
                 if (controlSize < 1.0f)
                     widgetSize *= Mathf.Clamp(controlSize + 0.1f, 0.1f, 1.0f);
-                var cornerSize = new Float2(widgetSize);
-                DrawControlWidget(uiControl, ref ul, ref mousePos, ref cornerSize, new Float2(-1, -1), CursorType.SizeNWSE);
-                DrawControlWidget(uiControl, ref ur, ref mousePos, ref cornerSize, new Float2(1, -1), CursorType.SizeNESW);
-                DrawControlWidget(uiControl, ref bl, ref mousePos, ref cornerSize, new Float2(-1, 1), CursorType.SizeNESW);
-                DrawControlWidget(uiControl, ref br, ref mousePos, ref cornerSize, new Float2(1, 1), CursorType.SizeNWSE);
-                var edgeSizeV = new Float2(widgetSize * 2, widgetSize);
-                var edgeSizeH = new Float2(edgeSizeV.Y, edgeSizeV.X);
+                var widgetHandleSize = new Float2(widgetSize);
+                DrawControlWidget(uiControl, ref ul, ref mousePos, ref widgetHandleSize, viewScale, new Float2(-1, -1), CursorType.SizeNWSE);
+                DrawControlWidget(uiControl, ref ur, ref mousePos, ref widgetHandleSize, viewScale, new Float2(1, -1), CursorType.SizeNESW);
+                DrawControlWidget(uiControl, ref bl, ref mousePos, ref widgetHandleSize, viewScale, new Float2(-1, 1), CursorType.SizeNESW);
+                DrawControlWidget(uiControl, ref br, ref mousePos, ref widgetHandleSize, viewScale, new Float2(1, 1), CursorType.SizeNWSE);
                 Float2.Lerp(ref ul, ref bl, 0.5f, out var el);
                 Float2.Lerp(ref ur, ref br, 0.5f, out var er);
                 Float2.Lerp(ref ul, ref ur, 0.5f, out var eu);
                 Float2.Lerp(ref bl, ref br, 0.5f, out var eb);
-                DrawControlWidget(uiControl, ref el, ref mousePos, ref edgeSizeH, new Float2(-1, 0), CursorType.SizeWE);
-                DrawControlWidget(uiControl, ref er, ref mousePos, ref edgeSizeH, new Float2(1, 0), CursorType.SizeWE);
-                DrawControlWidget(uiControl, ref eu, ref mousePos, ref edgeSizeV, new Float2(0, -1), CursorType.SizeNS);
-                DrawControlWidget(uiControl, ref eb, ref mousePos, ref edgeSizeV, new Float2(0, 1), CursorType.SizeNS);
+                DrawControlWidget(uiControl, ref el, ref mousePos, ref widgetHandleSize, viewScale, new Float2(-1, 0), CursorType.SizeWE);
+                DrawControlWidget(uiControl, ref er, ref mousePos, ref widgetHandleSize, viewScale, new Float2(1, 0), CursorType.SizeWE);
+                DrawControlWidget(uiControl, ref eu, ref mousePos, ref widgetHandleSize, viewScale, new Float2(0, -1), CursorType.SizeNS);
+                DrawControlWidget(uiControl, ref eb, ref mousePos, ref widgetHandleSize, viewScale, new Float2(0, 1), CursorType.SizeNS);
 
                 // TODO: draw anchors
             }
         }
 
-        private void DrawControlWidget(UIControl uiControl, ref Float2 pos, ref Float2 mousePos, ref Float2 size, Float2 resizeAxis, CursorType cursor)
+        private void DrawControlWidget(UIControl uiControl, ref Float2 pos, ref Float2 mousePos, ref Float2 size,float scale, Float2 resizeAxis, CursorType cursor)
         {
             var style = Style.Current;
-            var rect = new Rectangle(pos - size * 0.5f, size);
+            var rect = new Rectangle((pos + resizeAxis * 10 * scale) - size * 0.5f, size);
             if (rect.Contains(ref mousePos))
             {
                 Render2D.FillRectangle(rect, style.Foreground);
+                Render2D.DrawRectangle(rect, style.SelectionBorder);
             }
             else
             {

Source/Editor/Modules/ContentDatabaseModule.cs

@@ -88,8 +88,6 @@ namespace FlaxEditor.Modules
 
             // Register AssetItems serialization helper (serialize ref ID only)
             FlaxEngine.Json.JsonSerializer.Settings.Converters.Add(new AssetItemConverter());
-
-            ScriptsBuilder.ScriptsReloadBegin += OnScriptsReloadBegin;
         }
 
         private void OnContentAssetDisposing(Asset asset)
@@ -131,12 +129,9 @@ namespace FlaxEditor.Modules
                 for (int i = 0; i < Proxy.Count; i++)
                 {
                     if (Proxy[i].IsProxyFor(item))
-                    {
                         return Proxy[i];
-                    }
                 }
             }
-
             return null;
         }
 
@@ -149,11 +144,8 @@ namespace FlaxEditor.Modules
             for (int i = 0; i < Proxy.Count; i++)
             {
                 if (Proxy[i].IsProxyFor<T>())
-                {
                     return Proxy[i];
-                }
             }
-
             return null;
         }
 
@@ -166,17 +158,12 @@ namespace FlaxEditor.Modules
         {
             if (string.IsNullOrEmpty(extension))
                 throw new ArgumentNullException();
-
             extension = StringUtils.NormalizeExtension(extension);
-
             for (int i = 0; i < Proxy.Count; i++)
             {
-                if (Proxy[i].FileExtension == extension)
-                {
+                if (string.Equals(Proxy[i].FileExtension, extension, StringComparison.Ordinal))
                     return Proxy[i];
-                }
             }
-
             return null;
         }
 
@@ -191,30 +178,23 @@ namespace FlaxEditor.Modules
             for (int i = 0; i < Proxy.Count; i++)
             {
                 if (Proxy[i] is AssetProxy proxy && proxy.AcceptsAsset(typeName, path))
-                {
                     return proxy;
-                }
             }
-
             return null;
         }
+
         /// <summary>
         /// Gets the virtual proxy object from given path.
-        /// <br></br>use case if the asset u trying to display is not a flax asset but u like to add custom functionality
-        /// <br></br>to context menu,or display it the asset
         /// </summary>
         /// <param name="path">The asset path.</param>
         /// <returns>Asset proxy or null if cannot find.</returns>
-        public AssetProxy GetAssetVirtuallProxy(string path)
+        public AssetProxy GetAssetVirtualProxy(string path)
         {
             for (int i = 0; i < Proxy.Count; i++)
             {
                 if (Proxy[i] is AssetProxy proxy && proxy.IsVirtualProxy() && path.EndsWith(proxy.FileExtension, StringComparison.OrdinalIgnoreCase))
-                {
                     return proxy;
-                }
             }
-
             return null;
         }
 
@@ -1018,11 +998,13 @@ namespace FlaxEditor.Modules
                     }
                     if (item == null)
                     {
-                        var proxy = GetAssetVirtuallProxy(path);
+                        var proxy = GetAssetVirtualProxy(path);
                         item = proxy?.ConstructItem(path, assetInfo.TypeName, ref assetInfo.ID);
                         if (item == null)
                         {
-                            item = new FileItem(path);
+                            item = GetProxy(Path.GetExtension(path))?.ConstructItem(path);
+                            if (item == null)
+                                item = new FileItem(path);
                         }
                     }
 
@@ -1108,6 +1090,7 @@ namespace FlaxEditor.Modules
             Proxy.Add(new VisualScriptProxy());
             Proxy.Add(new BehaviorTreeProxy());
             Proxy.Add(new LocalizedStringTableProxy());
+            Proxy.Add(new VideoProxy("mp4"));
             Proxy.Add(new WidgetProxy());
             Proxy.Add(new FileProxy());
             Proxy.Add(new SpawnableJsonAssetProxy<PhysicalMaterial>());
@@ -1262,47 +1245,6 @@ namespace FlaxEditor.Modules
             }
         }
 
-        private void OnScriptsReloadBegin()
-        {
-            var enabledEvents = _enableEvents;
-            _enableEvents = false;
-            _isDuringFastSetup = true;
-            var startItems = _itemsCreated;
-            foreach (var project in Projects)
-            {
-                if (project.Content != null)
-                {
-                    //Dispose(project.Content.Folder);
-                    for (int i = 0; i < project.Content.Folder.Children.Count; i++)
-                    {
-                        Dispose(project.Content.Folder.Children[i]);
-                        i--;
-                    }
-                }
-                if (project.Source != null)
-                {
-                    //Dispose(project.Source.Folder);
-                    for (int i = 0; i < project.Source.Folder.Children.Count; i++)
-                    {
-                        Dispose(project.Source.Folder.Children[i]);
-                        i--;
-                    }
-                }
-            }
-
-            List<ContentProxy> removeProxies = new List<ContentProxy>();
-            foreach (var proxy in Editor.Instance.ContentDatabase.Proxy)
-            {
-                if (proxy.GetType().IsCollectible)
-                    removeProxies.Add(proxy);
-            }
-            foreach (var proxy in removeProxies)
-                RemoveProxy(proxy, false);
-
-            _isDuringFastSetup = false;
-            _enableEvents = enabledEvents;
-        }
-
         /// <inheritdoc />
         public override void OnUpdate()
         {
@@ -1328,7 +1270,6 @@ namespace FlaxEditor.Modules
         public override void OnExit()
         {
             FlaxEngine.Content.AssetDisposing -= OnContentAssetDisposing;
-            ScriptsBuilder.ScriptsReloadBegin -= OnScriptsReloadBegin;
 
             // Disable events
             _enableEvents = false;

Source/Editor/Modules/ContentImportingModule.cs

@@ -391,20 +391,6 @@ namespace FlaxEditor.Modules
         public override void OnInit()
         {
             ImportFileEntry.RegisterDefaultTypes();
-            ScriptsBuilder.ScriptsReloadBegin += OnScriptsReloadBegin;
-        }
-
-        private void OnScriptsReloadBegin()
-        {
-            // Remove import file types from scripting assemblies
-            List<string> removeFileTypes = new List<string>();
-            foreach (var pair in ImportFileEntry.FileTypes)
-            {
-                if (pair.Value.Method.IsCollectible || (pair.Value.Target != null && pair.Value.Target.GetType().IsCollectible))
-                    removeFileTypes.Add(pair.Key);
-            }
-            foreach (var fileType in removeFileTypes)
-                ImportFileEntry.FileTypes.Remove(fileType);
         }
 
         /// <inheritdoc />
@@ -465,7 +451,6 @@ namespace FlaxEditor.Modules
         /// <inheritdoc />
         public override void OnExit()
         {
-            ScriptsBuilder.ScriptsReloadBegin -= OnScriptsReloadBegin;
             EndWorker();
         }
     }

Source/Editor/Modules/WindowsModule.cs

@@ -5,12 +5,10 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Reflection;
-using System.Runtime.InteropServices;
 using System.Text;
 using System.Xml;
 using FlaxEditor.Content;
 using FlaxEditor.GUI.Dialogs;
-using FlaxEditor.GUI.Docking;
 using FlaxEditor.Windows;
 using FlaxEditor.Windows.Assets;
 using FlaxEditor.Windows.Profiler;
@@ -41,7 +39,6 @@ namespace FlaxEditor.Modules
             
             public DockState DockState;
             public DockPanel DockedTo;
-            public int DockedTabIndex;
             public float? SplitterValue = null;
 
             public bool SelectOnShow = false;
@@ -51,8 +48,6 @@ namespace FlaxEditor.Modules
             public Float2 FloatSize;
             public Float2 FloatPosition;
 
-            public AssetItem Item;
-
             // Constructor, to allow for default values
             public WindowRestoreData()
             {
@@ -812,56 +807,6 @@ namespace FlaxEditor.Modules
             Editor.StateMachine.StateChanged += OnEditorStateChanged;
         }
 
-        internal void AddToRestore(PrefabWindow win)
-        {
-            var type = win.GetType();
-            var winData = new WindowRestoreData();
-            var panel = win.ParentDockPanel;
-
-            // Ensure that this window is only selected following recompilation
-            // if it was the active tab in its dock panel. Otherwise, there is a
-            // risk of interrupting the user's workflow by potentially selecting
-            // background tabs.
-            var window = win.RootWindow?.Window;
-            winData.SelectOnShow = panel.SelectedTab == win;
-            winData.DockedTabIndex = 0;
-            if (panel is FloatWindowDockPanel && window != null && panel.TabsCount == 1)
-            {
-                winData.DockState = DockState.Float;
-                winData.FloatPosition = window.Position;
-                winData.FloatSize = window.ClientSize;
-                winData.Maximize = window.IsMaximized;
-                winData.Minimize = window.IsMinimized;
-                winData.DockedTo = panel;
-            }
-            else
-            {
-                for (int i = 0; i < panel.Tabs.Count; i++)
-                {
-                    if (panel.Tabs[i] == win)
-                    {
-                        winData.DockedTabIndex = i;
-                        break;
-                    }
-                }
-                if (panel.TabsCount > 1)
-                {
-                    winData.DockState = DockState.DockFill;
-                    winData.DockedTo = panel;
-                }
-                else
-                {
-                    winData.DockState = panel.TryGetDockState(out var splitterValue);
-                    winData.DockedTo = panel.ParentDockPanel;
-                    winData.SplitterValue = splitterValue;
-                }
-            }
-            winData.AssemblyName = type.Assembly.GetName().Name;
-            winData.TypeName = type.FullName;
-            winData.Item = win.Item;
-            _restoreWindows.Add(winData);
-        }
-
         internal void AddToRestore(CustomEditorWindow win)
         {
             var type = win.GetType();
@@ -894,8 +839,7 @@ namespace FlaxEditor.Modules
                 {
                     winData.DockState = DockState.DockFill;
                     winData.DockedTo = panel;
-                }
-                else
+                }else
                 {
                     winData.DockState = panel.TryGetDockState(out var splitterValue);
                     winData.DockedTo = panel.ParentDockPanel;
@@ -909,89 +853,36 @@ namespace FlaxEditor.Modules
 
         private void OnScriptsReloadEnd()
         {
-            // Go in reverse order to create floating Prefab windows first before docked windows
-            for (int i = _restoreWindows.Count - 1; i >= 0; i--)
+            for (int i = 0; i < _restoreWindows.Count; i++)
             {
                 var winData = _restoreWindows[i];
 
                 try
                 {
                     var assembly = Utils.GetAssemblyByName(winData.AssemblyName);
-                    if (assembly == null)
-                        continue;
-                    
-                    var type = assembly.GetType(winData.TypeName);
-                    if (type == null)
-                        continue;
-
-                    if (type == typeof(PrefabWindow))
+                    if (assembly != null)
                     {
-                        var win = new PrefabWindow(Editor.Instance, winData.Item);
-                        win.Show(winData.DockState, winData.DockState != DockState.Float ? winData.DockedTo : null, winData.SelectOnShow, winData.SplitterValue);
-                        if (winData.DockState == DockState.Float)
+                        var type = assembly.GetType(winData.TypeName);
+                        if (type != null)
                         {
-                            var window = win.RootWindow.Window;
-                            window.Position = winData.FloatPosition;
-                            if (winData.Maximize)
+                            var win = (CustomEditorWindow)Activator.CreateInstance(type);
+                            win.Show(winData.DockState, winData.DockedTo, winData.SelectOnShow, winData.SplitterValue);
+                            if (winData.DockState == DockState.Float)
                             {
-                                window.Maximize();
-                            }
-                            else if (winData.Minimize)
-                            {
-                                window.Minimize();
-                            }
-                            else
-                            {
-                                window.ClientSize = winData.FloatSize;
-                            }
-
-                            // Update panel reference in other windows docked to this panel
-                            foreach (ref var otherData in CollectionsMarshal.AsSpan(_restoreWindows))
-                            {
-                                if (otherData.DockedTo == winData.DockedTo)
-                                    otherData.DockedTo = win.ParentDockPanel;
-                            }
-                        }
-                        var panel = win.ParentDockPanel;
-                        int currentTabIndex = 0;
-                        for (int pi = 0; pi < panel.TabsCount; pi++)
-                        {
-                            if (panel.Tabs[pi] == win)
-                            {
-                                currentTabIndex = pi;
-                                break;
-                            }
-                        }
-                        while (currentTabIndex > winData.DockedTabIndex)
-                        {
-                            win.ParentDockPanel.MoveTabLeft(currentTabIndex);
-                            currentTabIndex--;
-                        }
-                        while (currentTabIndex < winData.DockedTabIndex)
-                        {
-                            win.ParentDockPanel.MoveTabRight(currentTabIndex);
-                            currentTabIndex++;
-                        }
-                    }
-                    else
-                    {
-                        var win = (CustomEditorWindow)Activator.CreateInstance(type);
-                        win.Show(winData.DockState, winData.DockedTo, winData.SelectOnShow, winData.SplitterValue);
-                        if (winData.DockState == DockState.Float)
-                        {
-                            var window = win.Window.RootWindow.Window;
-                            window.Position = winData.FloatPosition;
-                            if (winData.Maximize)
-                            {
-                                window.Maximize();
-                            }
-                            else if (winData.Minimize)
-                            {
-                                window.Minimize();
-                            }
-                            else
-                            {
-                                window.ClientSize = winData.FloatSize;
+                                var window = win.Window.RootWindow.Window;
+                                window.Position = winData.FloatPosition;
+                                if (winData.Maximize)
+                                {
+                                    window.Maximize();
+                                }
+                                else if (winData.Minimize)
+                                {
+                                    window.Minimize();
+                                }
+                                else 
+                                {
+                                    window.ClientSize = winData.FloatSize;
+                                }
                             }
                         }
                     }

Source/Editor/Options/InterfaceOptions.cs

@@ -175,6 +175,13 @@ namespace FlaxEditor.Options
         [EditorDisplay("Interface", "New Window Location"), EditorOrder(150), Tooltip("Define the opening method for new windows, open in a new tab by default.")]
         public DockStateProxy NewWindowLocation { get; set; } = DockStateProxy.Float;
 
+        /// <summary>
+        /// Gets or sets the timestamps prefix mode for debug log messages.
+        /// </summary>
+        [DefaultValue(TimestampsFormats.None)]
+        [EditorDisplay("Interface"), EditorOrder(210), Tooltip("The timestamps prefix mode for debug log messages.")]
+        public TimestampsFormats DebugLogTimestampsFormat { get; set; } = TimestampsFormats.None;
+
         /// <summary>
         /// Gets or sets the editor icons scale. Editor restart required.
         /// </summary>
@@ -204,72 +211,30 @@ namespace FlaxEditor.Options
         public bool SeparateValueAndUnit { get; set; }
 
         /// <summary>
-        /// Gets or sets the timestamps prefix mode for debug log messages.
-        /// </summary>
-        [DefaultValue(TimestampsFormats.None)]
-        [EditorDisplay("Debug Log"), EditorOrder(350), Tooltip("The timestamps prefix mode for debug log messages.")]
-        public TimestampsFormats DebugLogTimestampsFormat { get; set; } = TimestampsFormats.None;
-
-        /// <summary>
-        /// Gets or sets the clear on play for debug log messages.
+        /// Gets or sets the option to put a space between numbers and units for unit formatting.
         /// </summary>
         [DefaultValue(true)]
-        [EditorDisplay("Debug Log", "Clear on Play"), EditorOrder(360), Tooltip("Clears all log entries on enter playmode.")]
-        public bool DebugLogClearOnPlay { get; set; } = true;
-
-        /// <summary>
-        /// Gets or sets the collapse mode for debug log messages.
-        /// </summary>
-        [DefaultValue(true)]
-        [EditorDisplay("Debug Log"), EditorOrder(361), Tooltip("Collapses similar or repeating log entries.")]
-        public bool DebugLogCollapse { get; set; } = true;
-
-        /// <summary>
-        /// Gets or sets the automatic pause on error for debug log messages.
-        /// </summary>
-        [DefaultValue(false)]
-        [EditorDisplay("Debug Log", "Pause on Error"), EditorOrder(362), Tooltip("Performs auto pause on error.")]
-        public bool DebugLogPauseOnError { get; set; } = false;
-
-        /// <summary>
-        /// Gets or sets the automatic pause on error for debug log messages.
-        /// </summary>
-        [DefaultValue(true)]
-        [EditorDisplay("Debug Log", "Show error messages"), EditorOrder(370), Tooltip("Shows/hides error messages.")]
-        public bool DebugLogShowErrorMessages { get; set; } = true;
-
-        /// <summary>
-        /// Gets or sets the automatic pause on error for debug log messages.
-        /// </summary>
-        [DefaultValue(true)]
-        [EditorDisplay("Debug Log", "Show warning messages"), EditorOrder(371), Tooltip("Shows/hides warning messages.")]
-        public bool DebugLogShowWarningMessages { get; set; } = true;
-
-        /// <summary>
-        /// Gets or sets the automatic pause on error for debug log messages.
-        /// </summary>
-        [DefaultValue(true)]
-        [EditorDisplay("Debug Log", "Show info messages"), EditorOrder(372), Tooltip("Shows/hides info messages.")]
-        public bool DebugLogShowInfoMessages { get; set; } = true;
+        [EditorDisplay("Interface"), EditorOrder(320)]
+        public bool ShowTreeLines { get; set; } = true;
 
         /// <summary>
         /// Gets or sets the timestamps prefix mode for output log messages.
         /// </summary>
         [DefaultValue(TimestampsFormats.TimeSinceStartup)]
-        [EditorDisplay("Output Log", "Timestamps Format"), EditorOrder(400), Tooltip("The timestamps prefix mode for output log messages.")]
+        [EditorDisplay("Output Log", "Timestamps Format"), EditorOrder(300), Tooltip("The timestamps prefix mode for output log messages.")]
         public TimestampsFormats OutputLogTimestampsFormat { get; set; } = TimestampsFormats.TimeSinceStartup;
 
         /// <summary>
-        /// Gets or sets the log type prefix mode for output log messages.
+        /// Gets or sets the timestamps prefix mode for output log messages.
         /// </summary>
         [DefaultValue(true)]
-        [EditorDisplay("Output Log", "Show Log Type"), EditorOrder(410), Tooltip("Determines whether show log type prefix in output log messages.")]
+        [EditorDisplay("Output Log", "Show Log Type"), EditorOrder(310), Tooltip("Determines whether show log type prefix in output log messages.")]
         public bool OutputLogShowLogType { get; set; } = true;
 
         /// <summary>
         /// Gets or sets the output log text font.
         /// </summary>
-        [EditorDisplay("Output Log", "Text Font"), EditorOrder(420), Tooltip("The output log text font.")]
+        [EditorDisplay("Output Log", "Text Font"), EditorOrder(320), Tooltip("The output log text font.")]
         public FontReference OutputLogTextFont
         {
             get => _outputLogFont;
@@ -288,70 +253,63 @@ namespace FlaxEditor.Options
         /// Gets or sets the output log text color.
         /// </summary>
         [DefaultValue(typeof(Color), "1,1,1,1")]
-        [EditorDisplay("Output Log", "Text Color"), EditorOrder(430), Tooltip("The output log text color.")]
+        [EditorDisplay("Output Log", "Text Color"), EditorOrder(330), Tooltip("The output log text color.")]
         public Color OutputLogTextColor { get; set; } = Color.White;
 
         /// <summary>
         /// Gets or sets the output log text shadow color.
         /// </summary>
         [DefaultValue(typeof(Color), "0,0,0,0.5")]
-        [EditorDisplay("Output Log", "Text Shadow Color"), EditorOrder(440), Tooltip("The output log text shadow color.")]
+        [EditorDisplay("Output Log", "Text Shadow Color"), EditorOrder(340), Tooltip("The output log text shadow color.")]
         public Color OutputLogTextShadowColor { get; set; } = new Color(0, 0, 0, 0.5f);
 
         /// <summary>
         /// Gets or sets the output log text shadow offset. Set to 0 to disable this feature.
         /// </summary>
         [DefaultValue(typeof(Float2), "1,1")]
-        [EditorDisplay("Output Log", "Text Shadow Offset"), EditorOrder(445), Tooltip("The output log text shadow offset. Set to 0 to disable this feature.")]
+        [EditorDisplay("Output Log", "Text Shadow Offset"), EditorOrder(340), Tooltip("The output log text shadow offset. Set to 0 to disable this feature.")]
         public Float2 OutputLogTextShadowOffset { get; set; } = new Float2(1);
 
         /// <summary>
         /// Gets or sets a value indicating whether auto-focus output log window on code compilation error.
         /// </summary>
         [DefaultValue(true)]
-        [EditorDisplay("Output Log", "Focus Output Log On Compilation Error"), EditorOrder(450), Tooltip("Determines whether auto-focus output log window on code compilation error.")]
+        [EditorDisplay("Output Log", "Focus Output Log On Compilation Error"), EditorOrder(350), Tooltip("Determines whether auto-focus output log window on code compilation error.")]
         public bool FocusOutputLogOnCompilationError { get; set; } = true;
 
         /// <summary>
         /// Gets or sets a value indicating whether auto-focus output log window on game build error.
         /// </summary>
         [DefaultValue(true)]
-        [EditorDisplay("Output Log", "Focus Output Log On Game Build Error"), EditorOrder(460), Tooltip("Determines whether auto-focus output log window on game build error.")]
+        [EditorDisplay("Output Log", "Focus Output Log On Game Build Error"), EditorOrder(360), Tooltip("Determines whether auto-focus output log window on game build error.")]
         public bool FocusOutputLogOnGameBuildError { get; set; } = true;
 
-        /// <summary>
-        /// Gets or sets the value for automatic scroll to bottom in output log.
-        /// </summary>
-        [DefaultValue(true)]
-        [EditorDisplay("Output Log", "Scroll to bottom"), EditorOrder(470), Tooltip("Scroll the output log view to bottom automatically after new lines are added.")]
-        public bool OutputLogScrollToBottom { get; set; } = true;
-
         /// <summary>
         /// Gets or sets a value indicating whether auto-focus game window on play mode start.
         /// </summary>
         [DefaultValue(true)]
-        [EditorDisplay("Play In-Editor", "Focus Game Window On Play"), EditorOrder(500), Tooltip("Determines whether auto-focus game window on play mode start.")]
+        [EditorDisplay("Play In-Editor", "Focus Game Window On Play"), EditorOrder(400), Tooltip("Determines whether auto-focus game window on play mode start.")]
         public bool FocusGameWinOnPlay { get; set; } = true;
 
         /// <summary>
         /// Gets or sets a value indicating what action should be taken upon pressing the play button.
         /// </summary>
         [DefaultValue(PlayAction.PlayScenes)]
-        [EditorDisplay("Play In-Editor", "Play Button Action"), EditorOrder(510)]
+        [EditorDisplay("Play In-Editor", "Play Button Action"), EditorOrder(410)]
         public PlayAction PlayButtonAction { get; set; } = PlayAction.PlayScenes;
 
         /// <summary>
         /// Gets or sets a value indicating how the game window should be displayed when the game is launched.
         /// </summary>
         [DefaultValue(GameWindowMode.Docked)]
-        [EditorDisplay("Play In-Editor", "Game Window Mode"), EditorOrder(520), Tooltip("Determines how the game window is displayed when the game is launched.")]
+        [EditorDisplay("Play In-Editor", "Game Window Mode"), EditorOrder(420), Tooltip("Determines how the game window is displayed when the game is launched.")]
         public GameWindowMode DefaultGameWindowMode { get; set; } = GameWindowMode.Docked;
 
         /// <summary>
         /// Gets or sets a value indicating the number of game clients to launch when building and/or running cooked game.
         /// </summary>
         [DefaultValue(1), Range(1, 4)]
-        [EditorDisplay("Cook & Run"), EditorOrder(600)]
+        [EditorDisplay("Cook & Run"), EditorOrder(500)]
         public int NumberOfGameClientsToLaunch = 1;
 
         private static FontAsset DefaultFont => FlaxEngine.Content.LoadAsyncInternal<FontAsset>(EditorAssets.PrimaryFont);
@@ -366,13 +324,13 @@ namespace FlaxEditor.Options
         /// <summary>
         /// The list of fallback fonts to use when main text font is missing certain characters. Empty to use fonts from GraphicsSettings.
         /// </summary>
-        [EditorDisplay("Fonts"), EditorOrder(750)]
+        [EditorDisplay("Fonts"), EditorOrder(650)]
         public FontAsset[] FallbackFonts = new FontAsset[1] { FlaxEngine.Content.LoadAsyncInternal<FontAsset>(EditorAssets.FallbackFont) };
 
         /// <summary>
         /// Gets or sets the title font for editor UI.
         /// </summary>
-        [EditorDisplay("Fonts"), EditorOrder(700), Tooltip("The title font for editor UI.")]
+        [EditorDisplay("Fonts"), EditorOrder(600), Tooltip("The title font for editor UI.")]
         public FontReference TitleFont
         {
             get => _titleFont;
@@ -390,7 +348,7 @@ namespace FlaxEditor.Options
         /// <summary>
         /// Gets or sets the large font for editor UI.
         /// </summary>
-        [EditorDisplay("Fonts"), EditorOrder(710), Tooltip("The large font for editor UI.")]
+        [EditorDisplay("Fonts"), EditorOrder(610), Tooltip("The large font for editor UI.")]
         public FontReference LargeFont
         {
             get => _largeFont;
@@ -408,7 +366,7 @@ namespace FlaxEditor.Options
         /// <summary>
         /// Gets or sets the medium font for editor UI.
         /// </summary>
-        [EditorDisplay("Fonts"), EditorOrder(720), Tooltip("The medium font for editor UI.")]
+        [EditorDisplay("Fonts"), EditorOrder(620), Tooltip("The medium font for editor UI.")]
         public FontReference MediumFont
         {
             get => _mediumFont;
@@ -426,7 +384,7 @@ namespace FlaxEditor.Options
         /// <summary>
         /// Gets or sets the small font for editor UI.
         /// </summary>
-        [EditorDisplay("Fonts"), EditorOrder(730), Tooltip("The small font for editor UI.")]
+        [EditorDisplay("Fonts"), EditorOrder(630), Tooltip("The small font for editor UI.")]
         public FontReference SmallFont
         {
             get => _smallFont;

Source/Editor/Options/OptionsModule.cs

@@ -255,6 +255,17 @@ namespace FlaxEditor.Options
                 }
             }
 
+            // Ensure custom fonts are valid, reset if not
+            var defaultInterfaceOptions = new InterfaceOptions();
+            if (Style.Current.FontTitle == null)
+                Style.Current.FontTitle = defaultInterfaceOptions.TitleFont.GetFont();
+            if (Style.Current.FontSmall == null)
+                Style.Current.FontSmall = defaultInterfaceOptions.SmallFont.GetFont();
+            if (Style.Current.FontMedium == null)
+                Style.Current.FontMedium = defaultInterfaceOptions.MediumFont.GetFont();
+            if (Style.Current.FontLarge == null)
+                Style.Current.FontLarge = defaultInterfaceOptions.LargeFont.GetFont();
+
             // Set fallback fonts
             var fallbackFonts = Options.Interface.FallbackFonts;
             if (fallbackFonts == null || fallbackFonts.Length == 0 || fallbackFonts.All(x => x == null))

Source/Editor/SceneGraph/Actors/VideoPlayerEditor.cs

@@ -0,0 +1,69 @@
+// Copyright (c) 2012-2024 Wojciech Figat. All rights reserved.
+
+using System;
+using FlaxEngine;
+using FlaxEngine.GUI;
+
+namespace FlaxEditor.CustomEditors.Dedicated
+{
+    /// <summary>
+    /// Custom editor for <see cref="VideoPlayer"/>.
+    /// </summary>
+    [CustomEditor(typeof(VideoPlayer)), DefaultEditor]
+    public class VideoPlayerEditor : ActorEditor
+    {
+        private Label _infoLabel;
+
+        /// <inheritdoc />
+        public override void Initialize(LayoutElementsContainer layout)
+        {
+            base.Initialize(layout);
+
+            // Show playback options during simulation
+            if (Editor.IsPlayMode)
+            {
+                var playbackGroup = layout.Group("Playback");
+                playbackGroup.Panel.Open();
+
+                _infoLabel = playbackGroup.Label(string.Empty).Label;
+                _infoLabel.AutoHeight = true;
+
+                var grid = playbackGroup.CustomContainer<UniformGridPanel>();
+                var gridControl = grid.CustomControl;
+                gridControl.ClipChildren = false;
+                gridControl.Height = Button.DefaultHeight;
+                gridControl.SlotsHorizontally = 3;
+                gridControl.SlotsVertically = 1;
+                grid.Button("Play").Button.Clicked += () => Foreach(x => x.Play());
+                grid.Button("Pause").Button.Clicked += () => Foreach(x => x.Pause());
+                grid.Button("Stop").Button.Clicked += () => Foreach(x => x.Stop());
+            }
+        }
+
+        /// <inheritdoc />
+        public override void Refresh()
+        {
+            base.Refresh();
+
+            if (_infoLabel != null)
+            {
+                var text = string.Empty;
+                foreach (var value in Values)
+                {
+                    if (value is VideoPlayer player)
+                        text += $"Time: {player.Time:##0.0}s / {player.Duration:##0.0}s\nResolution: {player.Size.X}x{player.Size.Y}, Frame Rate: {player.FrameRate}";
+                }
+                _infoLabel.Text = text;
+            }
+        }
+
+        private void Foreach(Action<VideoPlayer> func)
+        {
+            foreach (var value in Values)
+            {
+                if (value is VideoPlayer player)
+                    func(player);
+            }
+        }
+    }
+}

Source/Editor/SceneGraph/GUI/ActorTreeNode.cs

@@ -15,6 +15,7 @@ using FlaxEditor.Windows.Assets;
 using FlaxEngine;
 using FlaxEngine.GUI;
 using FlaxEngine.Utilities;
+using Object = FlaxEngine.Object;
 
 namespace FlaxEditor.SceneGraph.GUI
 {
@@ -355,7 +356,7 @@ namespace FlaxEditor.SceneGraph.GUI
         private void OnRenamed(RenamePopup renamePopup)
         {
             using (new UndoBlock(ActorNode.Root.Undo, Actor, "Rename"))
-                Actor.Name = renamePopup.Text;
+                Actor.Name = renamePopup.Text.Trim();
         }
 
         /// <inheritdoc />
@@ -625,6 +626,7 @@ namespace FlaxEditor.SceneGraph.GUI
                 {
                     var item = _dragScriptItems.Objects[i];
                     var actorType = Editor.Instance.CodeEditing.Actors.Get(item);
+                    var scriptType = Editor.Instance.CodeEditing.Scripts.Get(item);
                     if (actorType != ScriptType.Null)
                     {
                         var actor = actorType.CreateInstance() as Actor;
@@ -639,6 +641,18 @@ namespace FlaxEditor.SceneGraph.GUI
                         ActorNode.Root.Spawn(actor, spawnParent);
                         actor.OrderInParent = newOrder;
                     }
+                    else if (scriptType != ScriptType.Null)
+                    {
+                        if (DragOverMode == DragItemPositioning.Above || DragOverMode == DragItemPositioning.Below)
+                        {
+                            Editor.LogWarning("Failed to spawn script of type " + actorType.TypeName);
+                            continue;
+                        }
+                        IUndoAction action = new AddRemoveScript(true, newParent, scriptType);
+                        Select();
+                        ActorNode.Root.Undo?.AddAction(action);
+                        action.Do();
+                    }
                 }
                 result = DragDropEffect.Move;
             }
@@ -699,9 +713,9 @@ namespace FlaxEditor.SceneGraph.GUI
             return Editor.Instance.CodeEditing.Controls.Get().Contains(controlType);
         }
 
-        private static bool ValidateDragScriptItem(ScriptItem script)
+        private bool ValidateDragScriptItem(ScriptItem script)
         {
-            return Editor.Instance.CodeEditing.Actors.Get(script) != ScriptType.Null;
+            return Editor.Instance.CodeEditing.Actors.Get(script) != ScriptType.Null || Editor.Instance.CodeEditing.Scripts.Get(script) != ScriptType.Null;
         }
 
         /// <inheritdoc />

Source/Editor/SceneGraph/SceneGraphNode.cs

@@ -469,7 +469,6 @@ namespace FlaxEditor.SceneGraph
             {
                 ChildNodes[i].OnDispose();
             }
-            ChildNodes.Clear();
 
             SceneGraphFactory.Nodes.Remove(ID);
         }

Source/Editor/Surface/AnimGraphSurface.cs

@@ -19,8 +19,6 @@ namespace FlaxEditor.Surface
     [HideInEditor]
     public class AnimGraphSurface : VisjectSurface
     {
-        private static NodesCache _nodesCache = new NodesCache(IterateNodesCache);
-
         private static readonly List<GroupArchetype> StateMachineGroupArchetypes = new List<GroupArchetype>(new[]
         {
             // Customized Animations group with special nodes to use here
@@ -89,6 +87,8 @@ namespace FlaxEditor.Surface
             }
         };
 
+        private static NodesCache _nodesCache = new NodesCache(IterateNodesCache);
+
         /// <summary>
         /// The state machine editing context menu.
         /// </summary>
@@ -158,8 +158,6 @@ namespace FlaxEditor.Surface
 
         private void OnScriptsReloadBegin()
         {
-            _nodesCache.Clear();
-
             // Check if any of the nodes comes from the game scripts - those can be reloaded at runtime so prevent crashes
             bool hasTypeFromGameScripts = Editor.Instance.CodeEditing.AnimGraphNodes.HasTypeFromGameScripts;
 

Source/Editor/Surface/Archetypes/Math.cs

@@ -430,7 +430,7 @@ namespace FlaxEditor.Surface.Archetypes
                 Title = "Smoothstep",
                 Description = "Returns a smooth Hermite interpolation between 0 and 1, if value is in the range [min, max].",
                 Flags = NodeFlags.MaterialGraph,
-                Size = new Float2(120, 60),
+                Size = new Float2(200, 60),
                 ConnectionsHints = ConnectionsHint.Numeric,
                 IndependentBoxes = new[] { 0, 1, 2 },
                 DependentBoxes = new[] { 3 },

Source/Editor/Surface/BehaviorTreeSurface.cs

@@ -24,7 +24,6 @@ namespace FlaxEditor.Surface
         public BehaviorTreeSurface(IVisjectSurfaceOwner owner, Action onSave, FlaxEditor.Undo undo)
         : base(owner, onSave, undo, CreateStyle())
         {
-            ScriptsBuilder.ScriptsReloadBegin += OnScriptsReloadBegin;
         }
 
         private static SurfaceStyle CreateStyle()
@@ -36,11 +35,6 @@ namespace FlaxEditor.Surface
             return style;
         }
 
-        private void OnScriptsReloadBegin()
-        {
-            _nodesCache.Clear();
-        }
-
         private static void DrawBox(Box box)
         {
             var rect = new Rectangle(Float2.Zero, box.Size);
@@ -192,7 +186,6 @@ namespace FlaxEditor.Surface
         {
             if (IsDisposing)
                 return;
-            ScriptsBuilder.ScriptsReloadBegin -= OnScriptsReloadBegin;
             _nodesCache.Wait();
 
             base.OnDestroy();

Source/Editor/Surface/VisjectSurface.CopyPaste.cs

@@ -190,7 +190,15 @@ namespace FlaxEditor.Surface
             if (data == null || data.Length < 2)
                 return false;
 
-            return true;
+            try
+            {
+                var model = JsonConvert.DeserializeObject<DataModel>(data);
+                return model?.Nodes != null && model.Nodes.Length != 0;
+            }
+            catch (Exception)
+            {
+                return false;
+            }
         }
 
         /// <summary>
@@ -207,15 +215,7 @@ namespace FlaxEditor.Surface
             try
             {
                 // Load Mr Json
-                DataModel model;
-                try
-                {
-                    model = FlaxEngine.Json.JsonSerializer.Deserialize<DataModel>(data);
-                }
-                catch
-                {
-                    return;
-                }
+                var model = FlaxEngine.Json.JsonSerializer.Deserialize<DataModel>(data);
                 if (model.Nodes == null)
                     model.Nodes = new DataModelNode[0];
 

Source/Editor/Surface/VisjectSurface.cs

@@ -397,15 +397,6 @@ namespace FlaxEditor.Surface
             // Init drag handlers
             DragHandlers.Add(_dragAssets = new DragAssets<DragDropEventArgs>(ValidateDragItem));
             DragHandlers.Add(_dragParameters = new DragNames<DragDropEventArgs>(SurfaceParameter.DragPrefix, ValidateDragParameter));
-
-            ScriptsBuilder.ScriptsReloadBegin += OnScriptsReloadBegin;
-        }
-
-        private void OnScriptsReloadBegin()
-        {
-            _activeVisjectCM = null;
-            _cmPrimaryMenu?.Dispose();
-            _cmPrimaryMenu = null;
         }
 
         /// <summary>
@@ -1004,8 +995,6 @@ namespace FlaxEditor.Surface
             _activeVisjectCM = null;
             _cmPrimaryMenu?.Dispose();
 
-            ScriptsBuilder.ScriptsReloadBegin -= OnScriptsReloadBegin;
-
             base.OnDestroy();
         }
     }

Source/Editor/Surface/VisualScriptSurface.cs

@@ -55,12 +55,6 @@ namespace FlaxEditor.Surface
         {
             _supportsImplicitCastFromObjectToBoolean = true;
             DragHandlers.Add(_dragActors = new DragActors(ValidateDragActor));
-            ScriptsBuilder.ScriptsReloadBegin += OnScriptsReloadBegin;
-        }
-
-        private void OnScriptsReloadBegin()
-        {
-            _nodesCache.Clear();
         }
 
         private bool ValidateDragActor(ActorNode actor)
@@ -602,7 +596,6 @@ namespace FlaxEditor.Surface
         {
             if (IsDisposing)
                 return;
-            ScriptsBuilder.ScriptsReloadBegin -= OnScriptsReloadBegin;
             _nodesCache.Wait();
 
             base.OnDestroy();

Source/Editor/Utilities/DuplicateScenes.cs

@@ -2,7 +2,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using FlaxEngine;
 
@@ -102,7 +101,6 @@ namespace FlaxEditor.Utilities
 
             Editor.Log("Creating scenes");
 
-            Stopwatch sw = Stopwatch.StartNew();
             // Deserialize new scenes
             int scenesCount = _scenesData.Count;
             for (int i = 0; i < scenesCount; i++)
@@ -115,9 +113,6 @@ namespace FlaxEditor.Utilities
                     throw new Exception("Failed to deserialize scene");
                 }
             }
-            sw.Stop();
-
-            Editor.Log("Creating scenes time: " + sw.Elapsed.TotalMilliseconds + "ms");
 
             Profiler.EndEvent();
         }

Source/Editor/Utilities/EditorUtilities.h

@@ -7,7 +7,7 @@
 
 enum class PixelFormat : unsigned;
 enum class DirectorySearchOption;
-struct TextureData;
+class TextureData;
 
 /// <summary>
 /// Helper functions for the editor.

Source/Editor/Utilities/Utils.cs

@@ -1471,5 +1471,27 @@ namespace FlaxEditor.Utilities
             inputActions.Add(options => options.GenerateScriptsProject, () => Editor.Instance.ProgressReporting.GenerateScriptsProjectFiles.RunAsync());
             inputActions.Add(options => options.RecompileScripts, ScriptsBuilder.Compile);
         }
+
+        internal static string ToPathProject(string path)
+        {
+            if (path != null)
+            {
+                // Convert into path relative to the project (cross-platform)
+                var projectFolder = Globals.ProjectFolder;
+                if (path.StartsWith(projectFolder))
+                    path = path.Substring(projectFolder.Length + 1);
+            }
+            return path;
+        }
+
+        internal static string ToPathAbsolute(string path)
+        {
+            if (path != null)
+            {
+                // Convert into global path to if relative to the project
+                path = StringUtils.IsRelative(path) ? Path.Combine(Globals.ProjectFolder, path) : path;
+            }
+            return path;
+        }
     }
 }

Source/Editor/Utilities/ViewportIconsRenderer.cpp

@@ -21,6 +21,7 @@
 #include "Engine/Level/Actors/Sky.h"
 #include "Engine/Level/Actors/SkyLight.h"
 #include "Engine/Level/Actors/SpotLight.h"
+#include "Engine/Video/VideoPlayer.h"
 
 #define ICON_RADIUS 7.0f
 
@@ -283,6 +284,7 @@ bool ViewportIconsRendererService::Init()
     MAP_TYPE(Sky, Skybox);
     MAP_TYPE(SkyLight, SkyLight);
     MAP_TYPE(SpotLight, PointLight);
+    MAP_TYPE(VideoPlayer, SceneAnimationPlayer);
 #undef MAP_TYPE
 
     return false;

Source/Editor/Viewport/EditorViewport.cs

@@ -1241,10 +1241,6 @@ namespace FlaxEditor.Viewport
 
         private class FpsCounter : Control
         {
-            private int fps;
-            private int accumFrames;
-            private float lastUpdate;
-
             public FpsCounter(float x, float y)
             : base(x, y, 64, 32)
             {
@@ -1254,15 +1250,7 @@ namespace FlaxEditor.Viewport
             {
                 base.Draw();
 
-                accumFrames++;
-                float timeNow = Time.TimeSinceStartup;
-                if (timeNow - lastUpdate >= 1.0f)
-                {
-                    fps = accumFrames;
-                    lastUpdate = timeNow;
-                    accumFrames = 0;
-                }
-
+                int fps = Engine.FramesPerSecond;
                 Color color = Color.Green;
                 if (fps < 13)
                     color = Color.Red;

Source/Editor/Viewport/MainEditorGizmoViewport.cs

@@ -351,6 +351,8 @@ namespace FlaxEditor.Viewport
 
         private void OnCollectDrawCalls(ref RenderContext renderContext)
         {
+            if (renderContext.View.Pass == DrawPass.Depth)
+                return;
             DragHandlers.CollectDrawCalls(_debugDrawData, ref renderContext);
             if (ShowNavigation)
                 Editor.Internal_DrawNavMesh();
@@ -471,13 +473,7 @@ namespace FlaxEditor.Viewport
                     trans.SetRotation(ref world);
                     trans.Translation += world.TranslationVector;
                 }
-                if (obj is ActorNode actorNode)
-                {
-                    actorNode.Actor.Position = trans.Translation;
-                    actorNode.Actor.Orientation = trans.Orientation;
-                }
-                else
-                    obj.Transform = trans;
+                obj.Transform = trans;
             }
             TransformGizmo.EndTransforming();
         }
@@ -526,9 +522,7 @@ namespace FlaxEditor.Viewport
         /// <param name="scaleDelta">The scale delta.</param>
         public void ApplyTransform(List<SceneGraphNode> selection, ref Vector3 translationDelta, ref Quaternion rotationDelta, ref Vector3 scaleDelta)
         {
-            bool applyTranslation = !translationDelta.IsZero;
             bool applyRotation = !rotationDelta.IsIdentity;
-            bool applyScale = !scaleDelta.IsZero;
             bool useObjCenter = TransformGizmo.ActivePivot == TransformGizmoBase.PivotType.ObjectCenter;
             Vector3 gizmoPosition = TransformGizmo.Position;
 
@@ -563,29 +557,13 @@ namespace FlaxEditor.Viewport
                 }
 
                 // Apply scale
-                if (applyScale)
-                {
-                    const float scaleLimit = 99_999_999.0f;
-                    trans.Scale = Float3.Clamp(trans.Scale + scaleDelta, new Float3(-scaleLimit), new Float3(scaleLimit)); ;
-                }
+                const float scaleLimit = 99_999_999.0f;
+                trans.Scale = Float3.Clamp(trans.Scale + scaleDelta, new Float3(-scaleLimit), new Float3(scaleLimit));
 
                 // Apply translation
-                if (applyTranslation)
-                {
-                    trans.Translation += translationDelta;
-                }
+                trans.Translation += translationDelta;
 
-                if (obj is ActorNode actorNode)
-                {
-                    if (applyTranslation)
-                        actorNode.Actor.Position = trans.Translation;
-                    if (applyRotation)
-                        actorNode.Actor.Orientation = trans.Orientation;
-                    if (applyScale)
-                        actorNode.Actor.Scale = trans.Scale;
-                }
-                else
-                    obj.Transform = trans;
+                obj.Transform = trans;
             }
         }
 
@@ -644,12 +622,12 @@ namespace FlaxEditor.Viewport
 
         private static bool ValidateDragActorType(ScriptType actorType)
         {
-            return Level.IsAnySceneLoaded;
+            return Level.IsAnySceneLoaded && Editor.Instance.CodeEditing.Actors.Get().Contains(actorType);
         }
 
         private static bool ValidateDragScriptItem(ScriptItem script)
         {
-            return Editor.Instance.CodeEditing.Actors.Get(script) != ScriptType.Null;
+            return Level.IsAnySceneLoaded && Editor.Instance.CodeEditing.Actors.Get(script) != ScriptType.Null;
         }
 
         /// <inheritdoc />

Source/Editor/Viewport/PrefabWindowViewport.cs

@@ -98,7 +98,6 @@ namespace FlaxEditor.Viewport
             ShowDebugDraw = true;
             ShowEditorPrimitives = true;
             Gizmos = new GizmosCollection(this);
-            var inputOptions = window.Editor.Options.Options.Input;
 
             // Prepare rendering task
             Task.ActorsSource = ActorsSources.CustomActors;
@@ -219,6 +218,8 @@ namespace FlaxEditor.Viewport
 
         private void OnCollectDrawCalls(ref RenderContext renderContext)
         {
+            if (renderContext.View.Pass == DrawPass.Depth)
+                return;
             DragHandlers.CollectDrawCalls(_debugDrawData, ref renderContext);
             _debugDrawData.OnDraw(ref renderContext);
         }
@@ -357,9 +358,7 @@ namespace FlaxEditor.Viewport
         /// <param name="scaleDelta">The scale delta.</param>
         public void ApplyTransform(List<SceneGraphNode> selection, ref Vector3 translationDelta, ref Quaternion rotationDelta, ref Vector3 scaleDelta)
         {
-            bool applyTranslation = !translationDelta.IsZero;
             bool applyRotation = !rotationDelta.IsIdentity;
-            bool applyScale = !scaleDelta.IsZero;
             bool useObjCenter = TransformGizmo.ActivePivot == TransformGizmoBase.PivotType.ObjectCenter;
             Vector3 gizmoPosition = TransformGizmo.Position;
 
@@ -389,29 +388,13 @@ namespace FlaxEditor.Viewport
                 }
 
                 // Apply scale
-                if (applyScale)
-                {
-                    const float scaleLimit = 99_999_999.0f;
-                    trans.Scale = Float3.Clamp(trans.Scale + scaleDelta, new Float3(-scaleLimit), new Float3(scaleLimit));
-                }
+                const float scaleLimit = 99_999_999.0f;
+                trans.Scale = Float3.Clamp(trans.Scale + scaleDelta, new Float3(-scaleLimit), new Float3(scaleLimit));
 
                 // Apply translation
-                if (applyTranslation)
-                {
-                    trans.Translation += translationDelta;
-                }
+                trans.Translation += translationDelta;
 
-                if (obj is ActorNode actorNode)
-                {
-                    if (applyTranslation)
-                        actorNode.Actor.Position = trans.Translation;
-                    if (applyRotation)
-                        actorNode.Actor.Orientation = trans.Orientation;
-                    if (applyScale)
-                        actorNode.Actor.Scale = trans.Scale;
-                }
-                else
-                    obj.Transform = trans;
+                obj.Transform = trans;
             }
         }
 
@@ -516,7 +499,7 @@ namespace FlaxEditor.Viewport
 
         private static bool ValidateDragActorType(ScriptType actorType)
         {
-            return true;
+            return Editor.Instance.CodeEditing.Actors.Get().Contains(actorType);
         }
 
         private static bool ValidateDragScriptItem(ScriptItem script)

Source/Editor/Windows/Assets/AssetEditorWindow.cs

@@ -459,8 +459,7 @@ namespace FlaxEditor.Windows.Assets
         /// <returns>True if failed, otherwise false.</returns>
         protected virtual bool SaveToOriginal()
         {
-            // Wait until temporary asset file be fully loaded
-            if (_asset.WaitForLoaded())
+            if (_asset.LastLoadFailed)
             {
                 Editor.LogError(string.Format("Cannot save asset {0}. Wait for temporary asset loaded failed.", _item.Path));
                 return true;
@@ -494,12 +493,6 @@ namespace FlaxEditor.Windows.Assets
                 return true;
             }
 
-            // Reload original asset
-            if (originalAsset)
-            {
-                originalAsset.Reload();
-            }
-
             // Refresh thumbnail
             _item.RefreshThumbnail();
 

Source/Editor/Windows/Assets/GameplayGlobalsWindow.cs

@@ -302,8 +302,17 @@ namespace FlaxEditor.Windows.Assets
                     // TODO: improve the UI
                     layout.Space(40);
                     var addParamType = layout.ComboBox().ComboBox;
-                    addParamType.Items = AllowedTypes.Select(CustomEditorsUtil.GetTypeNameUI).ToList();
-                    addParamType.SelectedIndex = 0;
+                    object lastValue = null;
+                    foreach (var e in _proxy.DefaultValues)
+                        lastValue = e.Value;
+
+                    var allowedTypes = AllowedTypes.Select(CustomEditorsUtil.GetTypeNameUI).ToList();
+                    int index = 0;
+                    if (lastValue != null)
+                        index = allowedTypes.FindIndex(x => x.Equals(CustomEditorsUtil.GetTypeNameUI(lastValue.GetType()), StringComparison.Ordinal));
+
+                    addParamType.Items = allowedTypes;
+                    addParamType.SelectedIndex = index;
                     _addParamType = addParamType;
                     var addParamButton = layout.Button("Add").Button;
                     addParamButton.Clicked += OnAddParamButtonClicked;

Source/Editor/Windows/Assets/MaterialWindow.cs

@@ -355,7 +355,6 @@ namespace FlaxEditor.Windows.Assets
                     Editor.LogError("Failed to save surface data");
                 }
                 _asset.Reload();
-                _asset.WaitForLoaded();
             }
         }
 

Source/Editor/Windows/Assets/PrefabWindow.cs

@@ -193,6 +193,7 @@ namespace FlaxEditor.Windows.Assets
 
             Editor.Prefabs.PrefabApplied += OnPrefabApplied;
             ScriptsBuilder.ScriptsReloadBegin += OnScriptsReloadBegin;
+            ScriptsBuilder.ScriptsReloadEnd += OnScriptsReloadEnd;
 
             // Setup input actions
             InputActions.Add(options => options.Undo, () =>
@@ -304,18 +305,24 @@ namespace FlaxEditor.Windows.Assets
                 }
             }
 
-            if (!IsHidden)
-            {
-                Editor.Instance.Windows.AddToRestore(this);
-            }
-
             // Cleanup
             Deselect();
             Graph.MainActor = null;
             _viewport.Prefab = null;
             _undo?.Clear(); // TODO: maybe don't clear undo?
+        }
 
-            Close();
+        private void OnScriptsReloadEnd()
+        {
+            _isScriptsReloading = false;
+
+            if (_asset == null || !_asset.IsLoaded)
+                return;
+
+            // Restore
+            OnPrefabOpened();
+            _undo.Clear();
+            ClearEditedFlag();
         }
 
         private void OnUndoEvent(IUndoAction action)
@@ -525,6 +532,7 @@ namespace FlaxEditor.Windows.Assets
         {
             Editor.Prefabs.PrefabApplied -= OnPrefabApplied;
             ScriptsBuilder.ScriptsReloadBegin -= OnScriptsReloadBegin;
+            ScriptsBuilder.ScriptsReloadEnd -= OnScriptsReloadEnd;
 
             _undo.Dispose();
             Graph.Dispose();

Source/Editor/Windows/Assets/VideoWindow.cs

@@ -0,0 +1,234 @@
+// Copyright (c) 2012-2024 Wojciech Figat. All rights reserved.
+
+using FlaxEditor.Content;
+using FlaxEngine;
+using FlaxEngine.GUI;
+
+namespace FlaxEditor.Windows.Assets
+{
+    /// <summary>
+    /// Editor window to view video media.
+    /// </summary>
+    public sealed class VideoWindow : EditorWindow, IContentItemOwner
+    {
+        private VideoItem _item;
+        private Image _frame;
+        private VideoPlayer _videoPlayer;
+        private Image _seekBegin, _seekEnd, _seekLeft, _seekRight, _playPause, _stop;
+
+        /// <inheritdoc />
+        public VideoWindow(Editor editor, VideoItem item)
+        : base(editor, false, ScrollBars.None)
+        {
+            _item = item;
+            _item.AddReference(this);
+            Title = _item.ShortName;
+
+            // Setup video player
+            _videoPlayer = new VideoPlayer
+            {
+                PlayOnStart = false,
+                Url = item.Path,
+            };
+
+            // Setup UI
+            var style = Style.Current;
+            var icons = Editor.Icons;
+            var playbackButtonsSize = 24.0f;
+            var playbackButtonsMouseOverColor = Color.FromBgra(0xFFBBBBBB);
+            _frame = new Image
+            {
+                Brush = new VideoBrush(_videoPlayer),
+                AnchorPreset = AnchorPresets.StretchAll,
+                Offsets = new Margin(0.0f, 0.0f, 0.0f, playbackButtonsSize),
+                Parent = this,
+            };
+            var playbackButtonsArea = new ContainerControl
+            {
+                AutoFocus = false,
+                ClipChildren = false,
+                BackgroundColor = style.LightBackground,
+                AnchorPreset = AnchorPresets.HorizontalStretchBottom,
+                Offsets = new Margin(0, 0, -playbackButtonsSize, playbackButtonsSize),
+                Parent = this
+            };
+            var playbackButtonsPanel = new ContainerControl
+            {
+                AutoFocus = false,
+                ClipChildren = false,
+                AnchorPreset = AnchorPresets.VerticalStretchCenter,
+                Offsets = Margin.Zero,
+                Parent = playbackButtonsArea,
+            };
+            _seekBegin = new Image(playbackButtonsPanel.Width, 0, playbackButtonsSize, playbackButtonsSize)
+            {
+                TooltipText = "Rewind to timeline start (Home)",
+                Brush = new SpriteBrush(icons.Skip64),
+                MouseOverColor = playbackButtonsMouseOverColor,
+                Rotation = 180.0f,
+                Parent = playbackButtonsPanel
+            };
+            _seekBegin.Clicked += (image, button) => SeekBegin();
+            playbackButtonsPanel.Width += playbackButtonsSize;
+            _seekLeft = new Image(playbackButtonsPanel.Width, 0, playbackButtonsSize, playbackButtonsSize)
+            {
+                TooltipText = "Move one frame back (Left Arrow)",
+                Brush = new SpriteBrush(icons.Left32),
+                MouseOverColor = playbackButtonsMouseOverColor,
+                Parent = playbackButtonsPanel
+            };
+            _seekLeft.Clicked += (image, button) => SeekLeft();
+            playbackButtonsPanel.Width += playbackButtonsSize;
+            _stop = new Image(playbackButtonsPanel.Width, 0, playbackButtonsSize, playbackButtonsSize)
+            {
+                TooltipText = "Stop playback",
+                Brush = new SpriteBrush(icons.Stop64),
+                MouseOverColor = playbackButtonsMouseOverColor,
+                Parent = playbackButtonsPanel
+            };
+            _stop.Clicked += (image, button) => Stop();
+            playbackButtonsPanel.Width += playbackButtonsSize;
+            _playPause = new Image(playbackButtonsPanel.Width, 0, playbackButtonsSize, playbackButtonsSize)
+            {
+                TooltipText = "Play/pause playback (Space)",
+                Brush = new SpriteBrush(icons.Play64),
+                MouseOverColor = playbackButtonsMouseOverColor,
+                Parent = playbackButtonsPanel
+            };
+            _playPause.Clicked += (image, button) => PlayPause();
+            playbackButtonsPanel.Width += playbackButtonsSize;
+            _seekRight = new Image(playbackButtonsPanel.Width, 0, playbackButtonsSize, playbackButtonsSize)
+            {
+                TooltipText = "Move one frame forward (Right Arrow)",
+                Brush = new SpriteBrush(icons.Right32),
+                MouseOverColor = playbackButtonsMouseOverColor,
+                Parent = playbackButtonsPanel
+            };
+            _seekRight.Clicked += (image, button) => SeekRight();
+            playbackButtonsPanel.Width += playbackButtonsSize;
+            _seekEnd = new Image(playbackButtonsPanel.Width, 0, playbackButtonsSize, playbackButtonsSize)
+            {
+                TooltipText = "Rewind to timeline end (End)",
+                Brush = new SpriteBrush(icons.Skip64),
+                MouseOverColor = playbackButtonsMouseOverColor,
+                Parent = playbackButtonsPanel
+            };
+            _seekEnd.Clicked += (image, button) => SeekEnd();
+            playbackButtonsPanel.Width += playbackButtonsSize;
+            playbackButtonsPanel.X = (playbackButtonsPanel.Parent.Width - playbackButtonsPanel.Width) * 0.5f;
+        }
+
+        private void PlayPause()
+        {
+            if (_videoPlayer.State == VideoPlayer.States.Playing)
+                _videoPlayer.Pause();
+            else
+                _videoPlayer.Play();
+        }
+
+        private void Stop()
+        {
+            _videoPlayer.Stop();
+        }
+
+        private void SeekBegin()
+        {
+            _videoPlayer.Time = 0.0f;
+        }
+
+        private void SeekEnd()
+        {
+            _videoPlayer.Time = _videoPlayer.Duration;
+        }
+
+        private void SeekLeft()
+        {
+            if (_videoPlayer.State == VideoPlayer.States.Paused)
+                _videoPlayer.Time -= 1.0f / _videoPlayer.FrameRate;
+        }
+
+        private void SeekRight()
+        {
+            if (_videoPlayer.State == VideoPlayer.States.Paused)
+                _videoPlayer.Time += 1.0f / _videoPlayer.FrameRate;
+        }
+
+        /// <inheritdoc />
+        public override bool OnKeyDown(KeyboardKeys key)
+        {
+            if (base.OnKeyDown(key))
+                return true;
+
+            switch (key)
+            {
+            case KeyboardKeys.ArrowLeft:
+                SeekLeft();
+                return true;
+            case KeyboardKeys.ArrowRight:
+                SeekRight();
+                return true;
+            case KeyboardKeys.Home:
+                SeekBegin();
+                return true;
+            case KeyboardKeys.End:
+                SeekEnd();
+                return true;
+            case KeyboardKeys.Spacebar:
+                PlayPause();
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <inheritdoc />
+        public override void Update(float deltaTime)
+        {
+            base.Update(deltaTime);
+
+            // Update UI
+            var state = _videoPlayer.State;
+            var icons = Editor.Icons;
+            _stop.Enabled = state != VideoPlayer.States.Stopped;
+            _seekLeft.Enabled = _seekRight.Enabled = state != VideoPlayer.States.Playing;
+            ((SpriteBrush)_playPause.Brush).Sprite = state == VideoPlayer.States.Playing ? icons.Pause64 : icons.Play64;
+        }
+
+        /// <inheritdoc />
+        public override void OnDestroy()
+        {
+            if (IsDisposing)
+                return;
+            _videoPlayer.Stop();
+            Object.Destroy(ref _videoPlayer);
+            _item.RemoveReference(this);
+            _item = null;
+
+            base.OnDestroy();
+        }
+
+        /// <inheritdoc />
+        public void OnItemDeleted(ContentItem item)
+        {
+            if (item == _item)
+                Close();
+        }
+
+        /// <inheritdoc />
+        public void OnItemRenamed(ContentItem item)
+        {
+        }
+
+        /// <inheritdoc />
+        public void OnItemReimported(ContentItem item)
+        {
+        }
+
+        /// <inheritdoc />
+        public void OnItemDispose(ContentItem item)
+        {
+            if (item == _item)
+                Close();
+        }
+    }
+}

Source/Editor/Windows/ContentWindow.ContextMenu.cs

@@ -311,6 +311,23 @@ namespace FlaxEditor.Windows
             {
                 if (selection[i] is BinaryAssetItem binaryAssetItem)
                     Editor.ContentImporting.Reimport(binaryAssetItem);
+                else if (selection[i] is PrefabItem prefabItem)
+                {
+                    var prefab = FlaxEngine.Content.Load<Prefab>(prefabItem.ID);
+                    var modelPrefab = prefab.GetDefaultInstance().GetScript<ModelPrefab>();
+                    if (!modelPrefab)
+                        continue;
+                    var importPath = modelPrefab.ImportPath;
+                    var editor = Editor.Instance;
+                    if (editor.ContentImporting.GetReimportPath("Model Prefab", ref importPath))
+                        continue;
+                    var folder = editor.ContentDatabase.Find(Path.GetDirectoryName(prefab.Path)) as ContentFolder;
+                    if (folder == null)
+                        continue;
+                    var importOptions = modelPrefab.ImportOptions;
+                    importOptions.Type = FlaxEngine.Tools.ModelTool.ModelType.Prefab;
+                    editor.ContentImporting.Import(importPath, folder, true, importOptions);
+                }
             }
         }
 

Source/Editor/Windows/ContentWindow.cs

@@ -29,7 +29,6 @@ namespace FlaxEditor.Windows
         private const string ProjectDataLastViewedFolder = "LastViewedFolder";
         private bool _isWorkspaceDirty;
         private string _workspaceRebuildLocation;
-        private string _lastViewedFolderBeforeReload;
         private SplitPanel _split;
         private Panel _contentViewPanel;
         private Panel _contentTreePanel;
@@ -145,6 +144,26 @@ namespace FlaxEditor.Windows
 
             FlaxEditor.Utilities.Utils.SetupCommonInputActions(this);
 
+            // Content database events
+            editor.ContentDatabase.WorkspaceModified += () => _isWorkspaceDirty = true;
+            editor.ContentDatabase.ItemRemoved += OnContentDatabaseItemRemoved;
+            editor.ContentDatabase.WorkspaceRebuilding += () => { _workspaceRebuildLocation = SelectedNode?.Path; };
+            editor.ContentDatabase.WorkspaceRebuilt += () =>
+            {
+                var selected = Editor.ContentDatabase.Find(_workspaceRebuildLocation);
+                if (selected is ContentFolder selectedFolder)
+                {
+                    _navigationUnlocked = false;
+                    RefreshView(selectedFolder.Node);
+                    _tree.Select(selectedFolder.Node);
+                    UpdateItemsSearch();
+                    _navigationUnlocked = true;
+                    UpdateUI();
+                }
+                else
+                    ShowRoot();
+            };
+
             var options = Editor.Options;
             options.OptionsChanged += OnOptionsChanged;
 
@@ -523,6 +542,8 @@ namespace FlaxEditor.Windows
                 return;
             }
 
+            newShortName = newShortName.Trim();
+
             // Cache data
             string extension = item.IsFolder ? "" : Path.GetExtension(item.Path);
             var newPath = StringUtils.CombinePaths(item.ParentFolder.Path, newShortName + extension);
@@ -1009,61 +1030,6 @@ namespace FlaxEditor.Windows
 
         /// <inheritdoc />
         public override void OnInit()
-        {
-            // Content database events
-            Editor.ContentDatabase.WorkspaceModified += () => _isWorkspaceDirty = true;
-            Editor.ContentDatabase.ItemRemoved += OnContentDatabaseItemRemoved;
-            Editor.ContentDatabase.WorkspaceRebuilding += () => { _workspaceRebuildLocation = SelectedNode?.Path; };
-            Editor.ContentDatabase.WorkspaceRebuilt += () =>
-            {
-                var selected = Editor.ContentDatabase.Find(_workspaceRebuildLocation);
-                if (selected is ContentFolder selectedFolder)
-                {
-                    _navigationUnlocked = false;
-                    RefreshView(selectedFolder.Node);
-                    _tree.Select(selectedFolder.Node);
-                    UpdateItemsSearch();
-                    _navigationUnlocked = true;
-                    UpdateUI();
-                }
-                else if (_root != null)
-                    ShowRoot();
-            };
-
-            Refresh();
-
-            // Load last viewed folder
-            if (Editor.ProjectCache.TryGetCustomData(ProjectDataLastViewedFolder, out var lastViewedFolder))
-            {
-                if (Editor.ContentDatabase.Find(lastViewedFolder) is ContentFolder folder)
-                    _tree.Select(folder.Node);
-            }
-
-            ScriptsBuilder.ScriptsReloadBegin += OnScriptsReloadBegin;
-            ScriptsBuilder.ScriptsReloadEnd += OnScriptsReloadEnd;
-        }
-
-        private void OnScriptsReloadBegin()
-        {
-            var lastViewedFolder = _tree.Selection.Count == 1 ? _tree.SelectedNode as ContentTreeNode : null;
-            _lastViewedFolderBeforeReload = lastViewedFolder?.Path ?? string.Empty;
-
-            _tree.RemoveChild(_root);
-            _root = null;
-        }
-
-        private void OnScriptsReloadEnd()
-        {
-            Refresh();
-
-            if (!string.IsNullOrEmpty(_lastViewedFolderBeforeReload))
-            {
-                if (Editor.ContentDatabase.Find(_lastViewedFolderBeforeReload) is ContentFolder folder)
-                    _tree.Select(folder.Node);
-            }
-        }
-
-        private void Refresh()
         {
             // Setup content root node
             _root = new RootContentTreeNode
@@ -1100,6 +1066,13 @@ namespace FlaxEditor.Windows
             // Update UI layout
             _isLayoutLocked = false;
             PerformLayout();
+
+            // Load last viewed folder
+            if (Editor.ProjectCache.TryGetCustomData(ProjectDataLastViewedFolder, out var lastViewedFolder))
+            {
+                if (Editor.ContentDatabase.Find(lastViewedFolder) is ContentFolder folder)
+                    _tree.Select(folder.Node);
+            }
         }
 
         /// <inheritdoc />
@@ -1247,8 +1220,6 @@ namespace FlaxEditor.Windows
             _viewDropdown = null;
 
             Editor.Options.OptionsChanged -= OnOptionsChanged;
-            ScriptsBuilder.ScriptsReloadBegin -= OnScriptsReloadBegin;
-            ScriptsBuilder.ScriptsReloadEnd -= OnScriptsReloadEnd;
 
             base.OnDestroy();
         }