Increase maximum window width limit to 8k

3cf3f58db1

.github/workflows/build_linux.yml

@@ -8,15 +8,18 @@ jobs:
     name: Editor (Linux, Development x64)
     runs-on: "ubuntu-20.04"
     steps:
-    - name: Install dependencies
-      run: |
-        sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev build-essential gettext libtool libtool-bin libpulse-dev libasound2-dev libjack-dev portaudio19-dev
     - name: Checkout repo
       uses: actions/checkout@v2
     - name: Checkout LFS
       run: |
         git lfs version
         git lfs pull
+    - name: Install dependencies
+      run: |
+        sudo rm -f /etc/apt/sources.list.d/*
+        sudo cp -f .github/workflows/build_linux_sources.list /etc/apt/sources.list
+        sudo apt-get update
+        sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev build-essential gettext libtool libtool-bin libpulse-dev libasound2-dev libjack-dev portaudio19-dev
     - name: Build
       run: |
         ./Development/Scripts/Linux/CallBuildTool.sh -build -log -arch=x64 -platform=Linux -configuration=Development -buildtargets=FlaxEditor

.github/workflows/build_linux_sources.list

@@ -0,0 +1,4 @@
+deb http://archive.ubuntu.com/ubuntu/ focal main restricted universe multiverse
+deb http://archive.ubuntu.com/ubuntu/ focal-updates main restricted universe multiverse
+deb http://archive.ubuntu.com/ubuntu/ focal-security main restricted universe multiverse
+deb http://archive.ubuntu.com/ubuntu/ focal-backports main restricted universe multiverse

.github/workflows/cd.yml

@@ -0,0 +1,100 @@
+name: Continuous Deployment
+on:
+  schedule:
+    - cron: '15 4 * * *'
+  workflow_dispatch:
+
+jobs:
+
+  # Windows
+  package-windows-editor:
+    name: Editor (Windows)
+    runs-on: "windows-latest"
+    steps:
+    - name: Checkout repo
+      uses: actions/checkout@v2
+    - name: Checkout LFS
+      run: |
+        git lfs version
+        git lfs pull
+    - name: Build
+      run: |
+        .\PackageEditor.bat -arch=x64 -platform=Windows -deployOutput=Output
+    - name: Upload
+      uses: actions/upload-artifact@v2
+      with:
+        name: Windows-Editor
+        path: Output/Editor.zip
+    - name: Upload
+      uses: actions/upload-artifact@v2
+      with:
+        name: Windows-EditorDebugSymbols
+        path: Output/EditorDebugSymbols.zip
+  package-windows-game:
+    name: Game (Windows)
+    runs-on: "windows-latest"
+    steps:
+    - name: Checkout repo
+      uses: actions/checkout@v2
+    - name: Checkout LFS
+      run: |
+        git lfs version
+        git lfs pull
+    - name: Build
+      run: |
+        .\PackagePlatforms.bat -arch=x64 -platform=Windows -deployOutput=Output
+    - name: Upload
+      uses: actions/upload-artifact@v2
+      with:
+        name: Windows-Game
+        path: Output/Windows.zip
+
+  # Linux
+  package-linux-editor:
+    name: Editor (Linux)
+    runs-on: "ubuntu-20.04"
+    steps:
+    - name: Checkout repo
+      uses: actions/checkout@v2
+    - name: Checkout LFS
+      run: |
+        git lfs version
+        git lfs pull
+    - name: Install dependencies
+      run: |
+        sudo rm -f /etc/apt/sources.list.d/*
+        sudo cp -f .github/workflows/build_linux_sources.list /etc/apt/sources.list
+        sudo apt-get update
+        sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev build-essential gettext libtool libtool-bin libpulse-dev libasound2-dev libjack-dev portaudio19-dev
+    - name: Build
+      run: |
+        ./PackageEditor.sh -arch=x64 -platform=Linux -deployOutput=Output
+    - name: Upload
+      uses: actions/upload-artifact@v2
+      with:
+        name: Linux-Editor
+        path: Output/FlaxEditorLinux.zip
+  package-linux-game:
+    name: Game (Linux)
+    runs-on: "ubuntu-20.04"
+    steps:
+    - name: Checkout repo
+      uses: actions/checkout@v2
+    - name: Checkout LFS
+      run: |
+        git lfs version
+        git lfs pull
+    - name: Install dependencies
+      run: |
+        sudo rm -f /etc/apt/sources.list.d/*
+        sudo cp -f .github/workflows/build_linux_sources.list /etc/apt/sources.list
+        sudo apt-get update
+        sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev build-essential gettext libtool libtool-bin libpulse-dev libasound2-dev libjack-dev portaudio19-dev
+    - name: Build
+      run: |
+        ./PackagePlatforms.sh -arch=x64 -platform=Linux -deployOutput=Output
+    - name: Upload
+      uses: actions/upload-artifact@v2
+      with:
+        name: Linux-Game
+        path: Output/Linux.zip

Content/Editor/MaterialTemplates/Decal.shader

@@ -194,16 +194,16 @@ void PS_Decal(
 	Out2 = float4(material.Emissive, material.Opacity);
 #if USE_NORMAL
 	// GBuffer1
-	Out3 = float4(material.WorldNormal * 0.5f + 0.5f, 1);
+	Out3 = float4(material.WorldNormal * 0.5f + 0.5f, material.Opacity);
 #endif
 #elif USE_NORMAL
 	// GBuffer1
-	Out2 = float4(material.WorldNormal * 0.5f + 0.5f, 1);
+	Out2 = float4(material.WorldNormal * 0.5f + 0.5f, material.Opacity);
 #endif
 #elif DECAL_BLEND_MODE == DECAL_BLEND_MODE_STAIN
 	Out0 = float4(material.Color, material.Opacity);
 #elif DECAL_BLEND_MODE == DECAL_BLEND_MODE_NORMAL
-	Out0 = float4(material.WorldNormal * 0.5f + 0.5f, 1);
+	Out0 = float4(material.WorldNormal * 0.5f + 0.5f, material.Opacity);
 #elif DECAL_BLEND_MODE == DECAL_BLEND_MODE_EMISSIVE
 	Out0 = float4(material.Emissive * material.Opacity, material.Opacity);
 #else

Content/Editor/MaterialTemplates/Terrain.shader

@@ -112,7 +112,7 @@ MaterialInput GetGeometryMaterialInput(GeometryData geometry)
 #if USE_LIGHTMAP
 	output.LightmapUV = geometry.LightmapUV;
 #endif
-	output.TBN = CalcTangentBasisFromWorldNormal(geometry.WorldNormal);
+	output.TBN = CalcTangentBasis(geometry.WorldNormal, geometry.WorldPosition, geometry.TexCoord);
 	output.HolesMask = geometry.HolesMask;
 #if USE_TERRAIN_LAYERS
 	output.Layers = geometry.Layers;
@@ -415,7 +415,7 @@ VertexOutput VS(TerrainVertexInput input)
 #if USE_LIGHTMAP
 	materialInput.LightmapUV = output.Geometry.LightmapUV;
 #endif
-	materialInput.TBN = CalcTangentBasisFromWorldNormal(output.Geometry.WorldNormal);
+	materialInput.TBN = tangentToWorld;
 	materialInput.TwoSidedSign = WorldDeterminantSign;
 	materialInput.SvPosition = output.Position;
 	materialInput.PreSkinnedPosition = position;

Content/Editor/Scripting/CppAssetTemplate.h

@@ -0,0 +1,23 @@
+%copyright%
+#pragma once
+
+#include "Engine/Core/ISerializable.h"
+#include "Engine/Core/Types/BaseTypes.h"
+#include "Engine/Content/Assets/Model.h"
+#include "Engine/Scripting/ScriptingType.h"
+
+/// <summary>
+/// %class% Json Asset. 
+/// </summary>
+API_CLASS() class %module%%class% : public ISerializable
+{
+    API_AUTO_SERIALIZATION();
+    DECLARE_SCRIPTING_TYPE_NO_SPAWN(%class%);
+public:
+	// Custom float value.
+    API_FIELD(Attributes = "Range(0, 20), EditorOrder(0), EditorDisplay(\"Data\")") 
+    float FloatValue = 20.0f;
+	// Custom vector data.
+    API_FIELD(Attributes = "EditorOrder(1), EditorDisplay(\"Data\")")
+    Vector3 Vector3Value = Vector3(0.1f);
+};

Content/Editor/Scripting/CppStaticClassTemplate.cpp

@@ -0,0 +1,8 @@
+%copyright%
+#include "%filename%.h"
+#include "Engine/Core/Log.h"
+
+void %class%::RunNativeAction(Vector4 data)
+{
+    LOG(Warning, "Data in RunNativeAction: {0}", data);
+}

Content/Editor/Scripting/CppStaticClassTemplate.h

@@ -0,0 +1,20 @@
+%copyright%
+#pragma once
+
+#include "Engine/Scripting/Script.h"
+#include "Engine/Core/Math/Vector4.h"
+
+/// <summary>
+/// %class% Function Library
+/// </summary>
+API_CLASS(Static) class %module%%class% 
+{
+    DECLARE_SCRIPTING_TYPE_MINIMAL(%class%);
+public:
+
+    /// <summary>
+    /// Logs the function parameter natively.
+    /// </summary>
+    /// <param name="data">Data to pass to native code</param>
+    API_FUNCTION() static void RunNativeAction(Vector4 data);
+};

Content/Editor/Scripting/ScriptTemplate.cs

@@ -4,23 +4,30 @@ using FlaxEngine;
 
 namespace %namespace%
 {
+    /// <summary>
+    /// %class% Script.
+    /// </summary>
     public class %class% : Script
     {
+        /// <inheritdoc/>
         public override void OnStart()
         {
             // Here you can add code that needs to be called when script is created, just before the first game update
         }
-
+        
+        /// <inheritdoc/>
         public override void OnEnable()
         {
             // Here you can add code that needs to be called when script is enabled (eg. register for events)
         }
 
+        /// <inheritdoc/>
         public override void OnDisable()
         {
             // Here you can add code that needs to be called when script is disabled (eg. unregister from events)
         }
 
+        /// <inheritdoc/>
         public override void OnUpdate()
         {
             // Here you can add code that needs to be called every frame

Development/Documentation/mono.md

@@ -5,6 +5,7 @@ Custom fork: [https://github.com/FlaxEngine/mono](https://github.com/FlaxEngine/
 ### Notes
 
 Some useful notes and tips for devs:
+* Use `-monolog` to print Mono logs to Flax logs
 * When working with mono fork set `localRepoPath` to local repo location in `Source\Tools\Flax.Build\Deps\Dependencies\mono.cs`
 * To update mono deps when developing/updating use `.\Development\Scripts\Windows\CallBuildTool.bat -log -ReBuildDeps -verbose -depsToBuild=mono -platform=Windows`, then build engine and run it
 * `MONO_GC_DEBUG=check-remset-consistency` - it will do additional checks at each collection to see if there are any missing write barriers

Flax.flaxproj

@@ -2,8 +2,8 @@
   "Name": "Flax",
   "Version": {
     "Major": 1,
-    "Minor": 1,
+    "Minor": 2,
-    "Build": 6218
+    "Build": 6224
   },
   "Company": "Flax",
   "Copyright": "Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.",

Flax.sln.DotSettings

@@ -234,6 +234,7 @@
 	<s:String x:Key="/Default/PatternsAndTemplates/Todo/TodoPatterns/=EEA05B0ED8200E4BA9D2D3F1052EBFFD/Name/@EntryValue">Deprecated</s:String>
 	<s:String x:Key="/Default/PatternsAndTemplates/Todo/TodoPatterns/=EEA05B0ED8200E4BA9D2D3F1052EBFFD/Pattern/@EntryValue">(?&lt;=\W|^)(?&lt;TAG&gt;\[Deprecated)(\W|$)(.*)</s:String>
 	<s:String x:Key="/Default/PatternsAndTemplates/Todo/TodoPatterns/=EEA05B0ED8200E4BA9D2D3F1052EBFFD/TodoIconStyle/@EntryValue">Normal</s:String>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Ackermann/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=analytics/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Antialiasing/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=backbuffer/@EntryIndexedValue">True</s:Boolean>

README.md

@@ -42,6 +42,16 @@ Flax Visual Studio extension provides better programming workflow, C# scripts de
 * Compile Flax project (hit F7 or CTRL+Shift+B)
 * Run Flax (hit F5 key)
 
+---
+
+**Note**
+
+If building on Windows to support Vulkan rendering, first install the Vulkan SDK then  set an environment variable to provide the path to the SDK prior to running GenerateProjectFiles.bat:
+
+    set VULKAN_SDK=C:\VulkanSDK\version\
+
+---
+
 ## Linux
 
 * Install Visual Studio Code

Source/Editor/Analytics/EditorAnalytics.cpp

@@ -10,6 +10,7 @@
 #include "Editor/Editor.h"
 #include "Editor/ProjectInfo.h"
 #include "Engine/Engine/EngineService.h"
+#include "Engine/Engine/Globals.h"
 #include "Engine/Graphics/GPUDevice.h"
 #include "Engine/Utilities/StringConverter.h"
 #include "FlaxEngine.Gen.h"

Source/Editor/Analytics/EditorAnalyticsController.cpp

@@ -7,7 +7,8 @@
 
 void RegisterGameCookingStart(GameCooker::EventType type)
 {
-    auto platform = ToString(GameCooker::GetCurrentData().Platform);
+    auto& data = *GameCooker::GetCurrentData();
+    auto platform = ToString(data.Platform);
     if (type == GameCooker::EventType::BuildStarted)
     {
         EditorAnalytics::SendEvent("Actions", "GameCooker.Start", platform);

Source/Editor/Content/Create/SettingsCreateEntry.cs

@@ -3,6 +3,7 @@
 using System;
 using FlaxEditor.Content.Settings;
 using FlaxEditor.Scripting;
+using FlaxEditor.Windows.Assets;
 using FlaxEngine;
 
 namespace FlaxEditor.Content.Create
@@ -11,87 +12,31 @@ namespace FlaxEditor.Content.Create
     /// Engine settings asset creating handler. Allows to specify type of the settings to create (e.g. <see cref="GameSettings"/>, <see cref="TimeSettings"/>, etc.).
     /// </summary>
     /// <seealso cref="FlaxEditor.Content.Create.CreateFileEntry" />
-    public class SettingsCreateEntry : CreateFileEntry
+    internal class SettingsCreateEntry : CreateFileEntry
     {
         /// <summary>
         /// Types of the settings assets that can be created.
         /// </summary>
-        public enum SettingsTypes
+        internal enum SettingsTypes
         {
-            /// <summary>
-            /// The game settings.
-            /// </summary>
             GameSettings,
-
-            /// <summary>
-            /// The audio settings.
-            /// </summary>
             AudioSettings,
-
-            /// <summary>
-            /// The time settings.
-            /// </summary>
             TimeSettings,
-
-            /// <summary>
-            /// The layers and tags settings.
-            /// </summary>
             LayersAndTagsSettings,
-
-            /// <summary>
-            /// The physics settings.
-            /// </summary>
             PhysicsSettings,
-
-            /// <summary>
-            /// The graphics settings.
-            /// </summary>
             GraphicsSettings,
-
-            /// <summary>
-            /// The navigation settings.
-            /// </summary>
             NavigationSettings,
-
+            LocalizationSettings,
-            /// <summary>
-            /// The build settings.
-            /// </summary>
             BuildSettings,
-
-            /// <summary>
-            /// The input settings.
-            /// </summary>
             InputSettings,
-
+            StreamingSettings,
-            /// <summary>
-            /// The Windows settings.
-            /// </summary>
             WindowsPlatformSettings,
-
-            /// <summary>
-            /// The UWP settings.
-            /// </summary>
             UWPPlatformSettings,
-
-            /// <summary>
-            /// The Linux settings.
-            /// </summary>
             LinuxPlatformSettings,
-
-            /// <summary>
-            /// The PS4 settings
-            /// </summary>
             PS4PlatformSettings,
-
-            /// <summary>
-            /// The Xbox Scarlett settings
-            /// </summary>
             XboxScarlettPlatformSettings,
-
-            /// <summary>
-            /// The Android settings
-            /// </summary>
             AndroidPlatformSettings,
+            SwitchPlatformSettings,
         }
 
         private static readonly Type[] _types =
@@ -103,20 +48,20 @@ namespace FlaxEditor.Content.Create
             typeof(PhysicsSettings),
             typeof(GraphicsSettings),
             typeof(NavigationSettings),
+            typeof(LocalizationSettings),
             typeof(BuildSettings),
             typeof(InputSettings),
+            typeof(StreamingSettings),
             typeof(WindowsPlatformSettings),
             typeof(UWPPlatformSettings),
             typeof(LinuxPlatformSettings),
             TypeUtils.GetManagedType(GameSettings.PS4PlatformSettingsTypename),
             TypeUtils.GetManagedType(GameSettings.XboxScarlettPlatformSettingsTypename),
             typeof(AndroidPlatformSettings),
+            TypeUtils.GetManagedType(GameSettings.SwitchPlatformSettingsTypename),
         };
 
-        /// <summary>
+        internal class Options
-        /// The create options.
-        /// </summary>
-        public class Options
         {
             /// <summary>
             /// The type.
@@ -150,7 +95,134 @@ namespace FlaxEditor.Content.Create
                 return true;
             }
             var data = Activator.CreateInstance(type);
-            return Editor.SaveJsonAsset(ResultUrl, data);
+            if (Editor.SaveJsonAsset(ResultUrl, data))
+                return true;
+
+            // Automatic settings linking to game settings for easier usage
+            var gameSettingsItem = Editor.Instance.ContentDatabase.Game.Content.Folder.FindChild(GameSettings.GameSettingsAssetPath) as JsonAssetItem;
+            if (gameSettingsItem != null)
+            {
+                var gameSettingsWindow = Editor.Instance.Windows.FindEditor(gameSettingsItem) as JsonAssetWindow;
+                if (gameSettingsWindow?.Instance is GameSettings)
+                {
+                    if (TrySet(gameSettingsWindow.Instance as GameSettings, ResultUrl, _options.Type))
+                        gameSettingsWindow.MarkAsEdited();
+                }
+                else
+                {
+                    var gameSettingsAsset = FlaxEngine.Content.LoadAsync<JsonAsset>(gameSettingsItem.ID);
+                    if (gameSettingsAsset && !gameSettingsAsset.WaitForLoaded())
+                    {
+                        if (gameSettingsAsset.CreateInstance() is GameSettings settings)
+                        {
+                            if (TrySet(settings, ResultUrl, _options.Type))
+                            {
+                                Editor.SaveJsonAsset(GameSettings.GameSettingsAssetPath, settings);
+                            }
+                        }
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        private static bool TrySet(GameSettings instance, string resultUrl, SettingsTypes type)
+        {
+            var asset = FlaxEngine.Content.LoadAsync<JsonAsset>(resultUrl);
+            if (instance != null && asset != null)
+            {
+                switch (type)
+                {
+                case SettingsTypes.AudioSettings:
+                    if (instance.Audio != null)
+                        return false;
+                    instance.Audio = asset;
+                    break;
+                case SettingsTypes.TimeSettings:
+                    if (instance.Time != null)
+                        return false;
+                    instance.Time = asset;
+                    break;
+                case SettingsTypes.LayersAndTagsSettings:
+                    if (instance.LayersAndTags != null)
+                        return false;
+                    instance.LayersAndTags = asset;
+                    break;
+                case SettingsTypes.PhysicsSettings:
+                    if (instance.Physics != null)
+                        return false;
+                    instance.Physics = asset;
+                    break;
+                case SettingsTypes.GraphicsSettings:
+                    if (instance.Graphics != null)
+                        return false;
+                    instance.Graphics = asset;
+                    break;
+                case SettingsTypes.NavigationSettings:
+                    if (instance.Navigation != null)
+                        return false;
+                    instance.Navigation = asset;
+                    break;
+                case SettingsTypes.LocalizationSettings:
+                    if (instance.Localization != null)
+                        return false;
+                    instance.Localization = asset;
+                    break;
+                case SettingsTypes.BuildSettings:
+                    if (instance.GameCooking != null)
+                        return false;
+                    instance.GameCooking = asset;
+                    break;
+                case SettingsTypes.InputSettings:
+                    if (instance.Input != null)
+                        return false;
+                    instance.Input = asset;
+                    break;
+                case SettingsTypes.StreamingSettings:
+                    if (instance.Streaming != null)
+                        return false;
+                    instance.Streaming = asset;
+                    break;
+                case SettingsTypes.WindowsPlatformSettings:
+                    if (instance.WindowsPlatform != null)
+                        return false;
+                    instance.WindowsPlatform = asset;
+                    break;
+                case SettingsTypes.UWPPlatformSettings:
+                    if (instance.UWPPlatform != null)
+                        return false;
+                    instance.UWPPlatform = asset;
+                    break;
+                case SettingsTypes.LinuxPlatformSettings:
+                    if (instance.LinuxPlatform != null)
+                        return false;
+                    instance.LinuxPlatform = asset;
+                    break;
+                case SettingsTypes.PS4PlatformSettings:
+                    if (instance.PS4Platform != null)
+                        return false;
+                    instance.PS4Platform = asset;
+                    break;
+                case SettingsTypes.XboxScarlettPlatformSettings:
+                    if (instance.XboxScarlettPlatform != null)
+                        return false;
+                    instance.XboxScarlettPlatform = asset;
+                    break;
+                case SettingsTypes.AndroidPlatformSettings:
+                    if (instance.AndroidPlatform != null)
+                        return false;
+                    instance.AndroidPlatform = asset;
+                    break;
+                case SettingsTypes.SwitchPlatformSettings:
+                    if (instance.SwitchPlatform != null)
+                        return false;
+                    instance.SwitchPlatform = asset;
+                    break;
+                }
+                return true;
+            }
+            return false;
         }
     }
 }

Source/Editor/Content/Create/VisualScriptCreateEntry.cs

@@ -25,7 +25,7 @@ namespace FlaxEditor.Content.Create
 
             private static bool IsValid(Type type)
             {
-                return type.IsPublic && !type.IsSealed && !type.IsGenericType;
+                return (type.IsPublic || type.IsNestedPublic) && !type.IsSealed && !type.IsGenericType;
             }
         }
 

Source/Editor/Content/GUI/ContentView.cs

@@ -27,6 +27,22 @@ namespace FlaxEditor.Content.GUI
         List,
     }
 
+    /// <summary>
+    /// The method sort for items.
+    /// </summary>
+    public enum SortType
+    {
+        /// <summary> 
+        /// The classic alphabetic sort method (A-Z).
+        /// </summary>
+        AlphabeticOrder,
+        
+        /// <summary>                    
+        /// The reverse alphabetic sort method (Z-A).
+        /// </summary>                   
+        AlphabeticReverse
+    }
+
     /// <summary>
     /// Main control for <see cref="ContentWindow"/> used to present collection of <see cref="ContentItem"/>.
     /// </summary>
@@ -218,8 +234,9 @@ namespace FlaxEditor.Content.GUI
         /// Shows the items collection in the view.
         /// </summary>
         /// <param name="items">The items to show.</param>
+        /// <param name="sortType">The sort method for items.</param>
         /// <param name="additive">If set to <c>true</c> items will be added to the current selection. Otherwise selection will be cleared before.</param>
-        public void ShowItems(List<ContentItem> items, bool additive = false)
+        public void ShowItems(List<ContentItem> items, SortType sortType, bool additive = false)
         {
             if (items == null)
                 throw new ArgumentNullException();
@@ -249,9 +266,24 @@ namespace FlaxEditor.Content.GUI
                 items[i].AddReference(this);
             }
 
-            // Sort items
+            // Sort items depending on sortMethod parameter
-            _children.Sort();
+            _children.Sort(((control, control1) =>
-
+                               {
+                                   if (sortType == SortType.AlphabeticReverse)
+                                   {
+                                       if (control.CompareTo(control1) > 0)
+                                       {
+                                           return -1; 
+                                       }
+                                       if (control.CompareTo(control1) == 0)
+                                       {
+                                           return 0;    
+                                       }
+                                       return 1;
+                                   }
+                                   return control.CompareTo(control1);
+                               }));
+            
             // Unload and perform UI layout
             IsLayoutLocked = wasLayoutLocked;
             PerformLayout();

Source/Editor/Content/Import/ImportFileEntry.cs

@@ -116,8 +116,7 @@ namespace FlaxEditor.Content.Import
             if (FileTypes.TryGetValue(extension, out ImportFileEntryHandler createDelegate))
                 return createDelegate(ref request);
 
-            // Use default type
+            return request.IsInBuilt ? new AssetImportEntry(ref request) : new ImportFileEntry(ref request);
-            return request.IsBinaryAsset ? new AssetImportEntry(ref request) : new ImportFileEntry(ref request);
         }
 
         internal static void RegisterDefaultTypes()

Source/Editor/Content/Import/ModelImportEntry.cs

@@ -117,8 +117,8 @@ namespace FlaxEditor.Content.Import
         /// <summary>
         /// True if calculate model tangents, otherwise will import them.
         /// </summary>
-        [EditorOrder(40), DefaultValue(true), EditorDisplay("Geometry"), Tooltip("Enable model tangent vectors recalculating")]
+        [EditorOrder(40), DefaultValue(false), EditorDisplay("Geometry"), Tooltip("Enable model tangent vectors recalculating")]
-        public bool CalculateTangents { get; set; } = true;
+        public bool CalculateTangents { get; set; } = false;
 
         /// <summary>
         /// Calculated normals smoothing angle.

Source/Editor/Content/Import/Request.cs

@@ -21,9 +21,9 @@ namespace FlaxEditor.Content.Import
         public string OutputPath;
 
         /// <summary>
-        /// Flag set to true for binary assets handled by the engine internally.
+        /// Flag set to true for the assets handled by the engine internally.
         /// </summary>
-        public bool IsBinaryAsset;
+        public bool IsInBuilt;
 
         /// <summary>
         /// Flag used to skip showing import settings dialog to used. Can be used for importing assets from code by plugins.

Source/Editor/Content/Import/TextureImportEntry.cs

@@ -283,6 +283,13 @@ namespace FlaxEditor.Content.Import
         [EditorOrder(250), VisibleIf("PreserveAlphaCoverage"), DefaultValue(0.5f), Tooltip("The reference value for the alpha coverage preserving.")]
         public float PreserveAlphaCoverageReference { get; set; } = 0.5f;
 
+        /// <summary>
+        /// Texture group for streaming (negative if unused). See Streaming Settings.
+        /// </summary>
+        [CustomEditor(typeof(CustomEditors.Dedicated.TextureGroupEditor))]
+        [EditorOrder(300), Tooltip("Texture group for streaming (negative if unused). See Streaming Settings.")]
+        public int TextureGroup = -1;
+
         /// <summary>
         /// The sprites. Used to keep created sprites on sprite atlas reimport.
         /// </summary>
@@ -305,6 +312,7 @@ namespace FlaxEditor.Content.Import
             public float PreserveAlphaCoverageReference;
             public float Scale;
             public int MaxSize;
+            public int TextureGroup;
             public Int2 Size;
             public Rectangle[] SpriteAreas;
             public string[] SpriteNames;
@@ -327,7 +335,8 @@ namespace FlaxEditor.Content.Import
                 PreserveAlphaCoverageReference = PreserveAlphaCoverageReference,
                 Scale = Scale,
                 Size = Size,
-                MaxSize = (int)MaxSize
+                MaxSize = (int)MaxSize,
+                TextureGroup = TextureGroup,
             };
             if (Sprites != null && Sprites.Count > 0)
             {
@@ -362,6 +371,7 @@ namespace FlaxEditor.Content.Import
             PreserveAlphaCoverageReference = options.PreserveAlphaCoverageReference;
             Scale = options.Scale;
             MaxSize = ConvertMaxSize(options.MaxSize);
+            TextureGroup = options.TextureGroup;
             Size = options.Size;
             if (options.SpriteAreas != null)
             {
@@ -483,7 +493,9 @@ namespace FlaxEditor.Content.Import
         {
             if (settings is TextureImportSettings o)
             {
+                var sprites = o.Sprites ?? _settings.Sprites; // Preserve sprites if not specified to override
                 _settings = o;
+                _settings.Sprites = sprites;
                 return true;
             }
             return false;

Source/Editor/Content/Items/AssetItem.cs

@@ -108,6 +108,26 @@ namespace FlaxEditor.Content
             return false;
         }
 
+        /// <summary>
+        /// Called when user dags this item into editor viewport or scene tree node.
+        /// </summary>
+        /// <param name="context">The editor context (eg. editor viewport or scene tree node).</param>
+        /// <returns>True if item can be dropped in, otherwise false.</returns>
+        public virtual bool OnEditorDrag(object context)
+        {
+            return false;
+        }
+
+        /// <summary>
+        /// Called when user drops the item into editor viewport or scene tree node.
+        /// </summary>
+        /// <param name="context">The editor context (eg. editor viewport or scene tree node).</param>
+        /// <returns>The spawned object.</returns>
+        public virtual Actor OnEditorDrop(object context)
+        {
+            throw new NotSupportedException($"Asset {GetType()} doesn't support dropping into viewport.");
+        }
+
         /// <inheritdoc />
         protected override bool DrawShadow => true;
 

Source/Editor/Content/Items/BinaryAssetItem.cs

@@ -103,14 +103,26 @@ namespace FlaxEditor.Content
     /// Implementation of <see cref="BinaryAssetItem"/> for <see cref="Model"/> assets.
     /// </summary>
     /// <seealso cref="FlaxEditor.Content.BinaryAssetItem" />
-    public class ModelAssetItem : BinaryAssetItem
+    public class ModelItem : BinaryAssetItem
     {
         /// <inheritdoc />
-        public ModelAssetItem(string path, ref Guid id, string typeName, Type type)
+        public ModelItem(string path, ref Guid id, string typeName, Type type)
         : base(path, ref id, typeName, type, ContentItemSearchFilter.Model)
         {
         }
 
+        /// <inheritdoc />
+        public override bool OnEditorDrag(object context)
+        {
+            return true;
+        }
+
+        /// <inheritdoc />
+        public override Actor OnEditorDrop(object context)
+        {
+            return new StaticModel { Model = FlaxEngine.Content.LoadAsync<Model>(ID) };
+        }
+
         /// <inheritdoc />
         protected override void OnBuildTooltipText(StringBuilder sb)
         {
@@ -142,14 +154,26 @@ namespace FlaxEditor.Content
     /// Implementation of <see cref="BinaryAssetItem"/> for <see cref="SkinnedModel"/> assets.
     /// </summary>
     /// <seealso cref="FlaxEditor.Content.BinaryAssetItem" />
-    public class SkinnedModelAssetItem : BinaryAssetItem
+    public class SkinnedModeItem : BinaryAssetItem
     {
         /// <inheritdoc />
-        public SkinnedModelAssetItem(string path, ref Guid id, string typeName, Type type)
+        public SkinnedModeItem(string path, ref Guid id, string typeName, Type type)
         : base(path, ref id, typeName, type, ContentItemSearchFilter.Model)
         {
         }
 
+        /// <inheritdoc />
+        public override bool OnEditorDrag(object context)
+        {
+            return true;
+        }
+
+        /// <inheritdoc />
+        public override Actor OnEditorDrop(object context)
+        {
+            return new AnimatedModel { SkinnedModel = FlaxEngine.Content.LoadAsync<SkinnedModel>(ID) };
+        }
+
         /// <inheritdoc />
         protected override void OnBuildTooltipText(StringBuilder sb)
         {

Source/Editor/Content/Items/CSharpScriptItem.cs

@@ -20,6 +20,6 @@ namespace FlaxEditor.Content
         }
         
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.CSharpScript64;
+        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.CSharpScript128;
     }
 }

Source/Editor/Content/Items/ContentFolder.cs

@@ -121,7 +121,7 @@ namespace FlaxEditor.Content
         public override bool Exists => Directory.Exists(Path);
 
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Folder64;
+        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Folder128;
 
         /// <inheritdoc />
         internal override void UpdatePath(string value)

Source/Editor/Content/Items/ContentItem.cs

@@ -455,7 +455,7 @@ namespace FlaxEditor.Content
                 const float thumbnailInShadowSize = 50.0f;
                 var shadowRect = rectangle.MakeExpanded((DefaultThumbnailSize - thumbnailInShadowSize) * rectangle.Width / DefaultThumbnailSize * 1.3f);
                 if (!_shadowIcon.IsValid)
-                    _shadowIcon = Editor.Instance.Icons.AssetShadow;
+                    _shadowIcon = Editor.Instance.Icons.AssetShadow128;
                 Render2D.DrawSprite(_shadowIcon, shadowRect);
             }
 

Source/Editor/Content/Items/CppScriptItem.cs

@@ -20,6 +20,6 @@ namespace FlaxEditor.Content
         }
 
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.CppScript64;
+        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.CPPScript128;
     }
 }

Source/Editor/Content/Items/FileItem.cs

@@ -26,6 +26,6 @@ namespace FlaxEditor.Content
         public override ContentItemSearchFilter SearchFilter => ContentItemSearchFilter.Other;
 
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Document64;
+        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Document128;
     }
 }

Source/Editor/Content/Items/JsonAssetItem.cs

@@ -11,6 +11,8 @@ namespace FlaxEditor.Content
     /// <seealso cref="FlaxEditor.Content.AssetItem" />
     public class JsonAssetItem : AssetItem
     {
+        private readonly SpriteHandle _thumbnail;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="JsonAssetItem"/> class.
         /// </summary>
@@ -20,13 +22,27 @@ namespace FlaxEditor.Content
         public JsonAssetItem(string path, Guid id, string typeName)
         : base(path, typeName, ref id)
         {
+            _thumbnail = Editor.Instance.Icons.Json128;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonAssetItem"/> class.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <param name="id">The identifier.</param>
+        /// <param name="typeName">Name of the resource type.</param>
+        /// <param name="thumbnail">Asset icon.</param>
+        public JsonAssetItem(string path, Guid id, string typeName, SpriteHandle thumbnail)
+        : base(path, typeName, ref id)
+        {
+            _thumbnail = thumbnail;
         }
 
         /// <inheritdoc />
         public override ContentItemSearchFilter SearchFilter => ContentItemSearchFilter.Json;
 
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Document64;
+        public override SpriteHandle DefaultThumbnail => _thumbnail;
 
         /// <inheritdoc />
         protected override bool DrawShadow => false;

Source/Editor/Content/Items/NewItem.cs

@@ -40,7 +40,7 @@ namespace FlaxEditor.Content
         public override ContentItemSearchFilter SearchFilter => ContentItemSearchFilter.Other;
 
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Document64;
+        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Document128;
 
         /// <inheritdoc />
         protected override bool DrawShadow => true;

Source/Editor/Content/Items/PrefabItem.cs

@@ -21,6 +21,18 @@ namespace FlaxEditor.Content
         {
         }
 
+        /// <inheritdoc />
+        public override bool OnEditorDrag(object context)
+        {
+            return true;
+        }
+
+        /// <inheritdoc />
+        public override Actor OnEditorDrop(object context)
+        {
+            return PrefabManager.SpawnPrefab(FlaxEngine.Content.LoadAsync<Prefab>(ID), null);
+        }
+
         /// <inheritdoc />
         public override ContentItemType ItemType => ContentItemType.Asset;
 

Source/Editor/Content/Items/SceneItem.cs

@@ -28,7 +28,7 @@ namespace FlaxEditor.Content
         public override ContentItemSearchFilter SearchFilter => ContentItemSearchFilter.Scene;
 
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Scene64;
+        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Scene128;
 
         /// <inheritdoc />
         public override bool IsOfType(Type type)

Source/Editor/Content/Items/ShaderSourceItem.cs

@@ -27,6 +27,6 @@ namespace FlaxEditor.Content
         public override ContentItemSearchFilter SearchFilter => ContentItemSearchFilter.Shader;
 
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Document64;
+        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Document128;
     }
 }

Source/Editor/Content/Items/VisualScriptItem.cs

@@ -75,6 +75,7 @@ namespace FlaxEditor.Content
             }
         }
 
+        /// <inheritdoc />
         public int MetadataToken => 0;
 
         /// <inheritdoc />
@@ -538,7 +539,19 @@ namespace FlaxEditor.Content
         }
 
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.CodeScript64;
+        public override bool OnEditorDrag(object context)
+        {
+            return new ScriptType(typeof(Actor)).IsAssignableFrom(ScriptType) && ScriptType.CanCreateInstance;
+        }
+
+        /// <inheritdoc />
+        public override Actor OnEditorDrop(object context)
+        {
+            return (Actor)ScriptType.CreateInstance();
+        }
+
+        /// <inheritdoc />
+        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.VisualScript128;
 
         /// <inheritdoc />
         protected override bool DrawShadow => false;

Source/Editor/Content/PreviewsCache.cpp

@@ -76,7 +76,7 @@ void PreviewsCache::FlushTask::OnEnd()
     ThreadPoolTask::OnEnd();
 }
 
-REGISTER_BINARY_ASSET(PreviewsCache, "FlaxEditor.PreviewsCache", ::New<TextureAssetUpgrader>(), false);
+REGISTER_BINARY_ASSET_WITH_UPGRADER(PreviewsCache, "FlaxEditor.PreviewsCache", TextureAssetUpgrader, false);
 
 PreviewsCache::PreviewsCache(const SpawnParams& params, const AssetInfo* info)
     : SpriteAtlas(params, info)
@@ -241,16 +241,13 @@ CreateAssetResult PreviewsCache::create(CreateAssetContext& context)
     IMPORT_SETUP(PreviewsCache, 4);
 
     // Create texture header (custom data)
-    TextureHeader header;
+    TextureHeader textureHeader;
-    header.Width = ASSETS_ICONS_ATLAS_SIZE;
+    textureHeader.Width = ASSETS_ICONS_ATLAS_SIZE;
-    header.Height = ASSETS_ICONS_ATLAS_SIZE;
+    textureHeader.Height = ASSETS_ICONS_ATLAS_SIZE;
-    header.Format = ASSETS_ICONS_ATLAS_FORMAT;
+    textureHeader.Format = ASSETS_ICONS_ATLAS_FORMAT;
-    header.IsSRGB = false;
+    textureHeader.MipLevels = 1;
-    header.IsCubeMap = false;
+    textureHeader.NeverStream = true;
-    header.MipLevels = 1;
+    context.Data.CustomData.Copy(&textureHeader);
-    header.NeverStream = true;
-    header.Type = TextureFormatType::Unknown;
-    context.Data.CustomData.Copy(&header);
 
     // Create blank image (chunk 0)
     uint64 imageSize = CalculateTextureMemoryUsage(ASSETS_ICONS_ATLAS_FORMAT, ASSETS_ICONS_ATLAS_SIZE, ASSETS_ICONS_ATLAS_SIZE, 1);

Source/Editor/Content/Proxy/AudioClipProxy.cs

@@ -2,6 +2,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Text;
 using FlaxEditor.Content.Thumbnails;
 using FlaxEditor.Viewport.Previews;
 using FlaxEditor.Windows;
@@ -11,11 +12,51 @@ using FlaxEngine.GUI;
 
 namespace FlaxEditor.Content
 {
+    /// <summary>
+    /// Implementation of <see cref="BinaryAssetItem"/> for <see cref="AudioClip"/> assets.
+    /// </summary>
+    /// <seealso cref="FlaxEditor.Content.BinaryAssetItem" />
+    class AudioClipItem : BinaryAssetItem
+    {
+        /// <inheritdoc />
+        public AudioClipItem(string path, ref Guid id, string typeName, Type type)
+        : base(path, ref id, typeName, type, ContentItemSearchFilter.Audio)
+        {
+        }
+
+        /// <inheritdoc />
+        public override bool OnEditorDrag(object context)
+        {
+            return true;
+        }
+
+        /// <inheritdoc />
+        public override Actor OnEditorDrop(object context)
+        {
+            return new AudioSource { Clip = FlaxEngine.Content.LoadAsync<AudioClip>(ID) };
+        }
+
+        /// <inheritdoc />
+        protected override void OnBuildTooltipText(StringBuilder sb)
+        {
+            base.OnBuildTooltipText(sb);
+
+            var asset = FlaxEngine.Content.Load<AudioClip>(ID, 100);
+            if (asset)
+            {
+                var info = asset.Info;
+                sb.Append("Duration: ").Append(asset.Length).AppendLine();
+                sb.Append("Channels: ").Append(info.NumChannels).AppendLine();
+                sb.Append("Bit Depth: ").Append(info.BitDepth).AppendLine();
+            }
+        }
+    }
+
     /// <summary>
     /// A <see cref="AudioClip"/> asset proxy object.
     /// </summary>
     /// <seealso cref="FlaxEditor.Content.BinaryAssetProxy" />
-    public class AudioClipProxy : BinaryAssetProxy
+    class AudioClipProxy : BinaryAssetProxy
     {
         private List<AudioClipPreview> _previews;
 
@@ -34,6 +75,12 @@ namespace FlaxEditor.Content
             return new AudioClipWindow(editor, (AssetItem)item);
         }
 
+        /// <inheritdoc />
+        public override AssetItem ConstructItem(string path, string typeName, ref Guid id)
+        {
+            return new AudioClipItem(path, ref id, typeName, AssetType);
+        }
+
         /// <inheritdoc />
         public override Color AccentColor => Color.FromRGB(0xB3452B);
 

Source/Editor/Content/Proxy/BinaryAssetProxy.cs

@@ -47,9 +47,9 @@ namespace FlaxEditor.Content
             if (typeof(TextureBase).IsAssignableFrom(type))
                 return new TextureAssetItem(path, ref id, typeName, type);
             if (typeof(Model).IsAssignableFrom(type))
-                return new ModelAssetItem(path, ref id, typeName, type);
+                return new ModelItem(path, ref id, typeName, type);
             if (typeof(SkinnedModel).IsAssignableFrom(type))
-                return new SkinnedModelAssetItem(path, ref id, typeName, type);
+                return new SkinnedModeItem(path, ref id, typeName, type);
 
             ContentItemSearchFilter searchFilter;
             if (typeof(MaterialBase).IsAssignableFrom(type))
@@ -58,11 +58,9 @@ namespace FlaxEditor.Content
                 searchFilter = ContentItemSearchFilter.Prefab;
             else if (typeof(SceneAsset).IsAssignableFrom(type))
                 searchFilter = ContentItemSearchFilter.Scene;
-            else if (typeof(AudioClip).IsAssignableFrom(type))
-                searchFilter = ContentItemSearchFilter.Audio;
             else if (typeof(Animation).IsAssignableFrom(type))
                 searchFilter = ContentItemSearchFilter.Animation;
-            else if (typeof(ParticleEmitter).IsAssignableFrom(type) || typeof(ParticleSystem).IsAssignableFrom(type))
+            else if (typeof(ParticleEmitter).IsAssignableFrom(type))
                 searchFilter = ContentItemSearchFilter.Particles;
             else
                 searchFilter = ContentItemSearchFilter.Other;

Source/Editor/Content/Proxy/CollisionDataProxy.cs

@@ -8,11 +8,36 @@ using FlaxEngine;
 
 namespace FlaxEditor.Content
 {
+    /// <summary>
+    /// Implementation of <see cref="BinaryAssetItem"/> for <see cref="CollisionData"/> assets.
+    /// </summary>
+    /// <seealso cref="FlaxEditor.Content.BinaryAssetItem" />
+    class CollisionDataItem : BinaryAssetItem
+    {
+        /// <inheritdoc />
+        public CollisionDataItem(string path, ref Guid id, string typeName, Type type)
+        : base(path, ref id, typeName, type, ContentItemSearchFilter.Other)
+        {
+        }
+
+        /// <inheritdoc />
+        public override bool OnEditorDrag(object context)
+        {
+            return true;
+        }
+
+        /// <inheritdoc />
+        public override Actor OnEditorDrop(object context)
+        {
+            return new MeshCollider { CollisionData = FlaxEngine.Content.LoadAsync<CollisionData>(ID) };
+        }
+    }
+
     /// <summary>
     /// A <see cref="CollisionData"/> asset proxy object.
     /// </summary>
     /// <seealso cref="FlaxEditor.Content.BinaryAssetProxy" />
-    public class CollisionDataProxy : BinaryAssetProxy
+    class CollisionDataProxy : BinaryAssetProxy
     {
         /// <inheritdoc />
         public override string Name => "Collision Data";
@@ -23,6 +48,12 @@ namespace FlaxEditor.Content
             return new CollisionDataWindow(editor, item as AssetItem);
         }
 
+        /// <inheritdoc />
+        public override AssetItem ConstructItem(string path, string typeName, ref Guid id)
+        {
+            return new CollisionDataItem(path, ref id, typeName, AssetType);
+        }
+
         /// <inheritdoc />
         public override Color AccentColor => Color.FromRGB(0x2c3e50);
 

Source/Editor/Content/Proxy/ContentProxy.cs

@@ -73,6 +73,16 @@ namespace FlaxEditor.Content
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Determines whether the specified filename is valid for this proxy.
+        /// </summary>
+        /// <param name="filename">The filename.</param>
+        /// <returns><c>true</c> if the filename is valid, otherwise <c>false</c>.</returns>
+        public virtual bool IsFileNameValid(string filename)
+        {
+            return true;
+        }
+        
         /// <summary>
         /// Determines whether this proxy can create items in the specified target location.
         /// </summary>

Source/Editor/Content/Proxy/CppProxy.cs

@@ -0,0 +1,134 @@
+// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
+
+using System;
+using System.IO;
+using System.Text;
+using FlaxEditor.Content.Settings;
+using FlaxEngine;
+
+namespace FlaxEditor.Content
+{
+    /// <summary>
+    /// Context proxy object for C++ files.
+    /// </summary>
+    /// <seealso cref="FlaxEditor.Content.CSharpScriptProxy" />
+    public abstract class CppProxy : ScriptProxy
+    {
+        /// <summary>
+        /// Gets the paths for header and source files to format.
+        /// </summary>
+        /// <param name="headerTemplate">The header template path.</param>
+        /// <param name="sourceTemplate">The source template path.</param>
+        protected abstract void GetTemplatePaths(out string headerTemplate, out string sourceTemplate);
+
+        /// <inheritdoc />
+        public override bool IsProxyFor(ContentItem item)
+        {
+            return false;
+        }
+
+        /// <inheritdoc />
+        public override void Create(string outputPath, object arg)
+        {
+            // Find the module that this script is being added (based on the path)
+            var module = string.Empty;
+            var project = TryGetProjectAtFolder(outputPath, out var moduleName);
+            if (project != null)
+            {
+                module = moduleName.ToUpperInvariant() + "_API ";
+            }
+
+            var gameSettings = GameSettings.Load();
+            var scriptName = ScriptItem.CreateScriptName(outputPath);
+            var filename = Path.GetFileNameWithoutExtension(outputPath);
+            var copyrightComment = string.IsNullOrEmpty(gameSettings.CopyrightNotice) ? string.Empty : string.Format("// {0}{1}{1}", gameSettings.CopyrightNotice, Environment.NewLine);
+
+            GetTemplatePaths(out var headerTemplatePath, out var sourceTemplatePath);
+            if (headerTemplatePath != null)
+            {
+                var headerTemplate = File.ReadAllText(headerTemplatePath);
+                headerTemplate = headerTemplate.Replace("%copyright%", copyrightComment);
+                headerTemplate = headerTemplate.Replace("%class%", scriptName);
+                headerTemplate = headerTemplate.Replace("%module%", module);
+                headerTemplate = headerTemplate.Replace("%filename%", filename);
+                File.WriteAllText(Path.ChangeExtension(outputPath, ".h"), headerTemplate, Encoding.UTF8);
+            }
+            if (sourceTemplatePath != null)
+            {
+                var sourceTemplate = File.ReadAllText(sourceTemplatePath);
+                sourceTemplate = sourceTemplate.Replace("%copyright%", copyrightComment);
+                sourceTemplate = sourceTemplate.Replace("%class%", scriptName);
+                sourceTemplate = sourceTemplate.Replace("%module%", module);
+                sourceTemplate = sourceTemplate.Replace("%filename%", filename);
+                File.WriteAllText(outputPath, sourceTemplate, Encoding.UTF8);
+            }
+        }
+
+        /// <inheritdoc />
+        public override string FileExtension => "cpp";
+
+        /// <inheritdoc />
+        public override Color AccentColor => Color.FromRGB(0x9c1c9c);
+    }
+
+    /// <summary>
+    /// Context proxy object for C++ script files.
+    /// </summary>
+    /// <seealso cref="FlaxEditor.Content.CSharpScriptProxy" />
+    public class CppScriptProxy : CppProxy
+    {
+        /// <inheritdoc />
+        public override string Name => "C++ Script";
+
+        /// <inheritdoc />
+        public override bool IsProxyFor(ContentItem item)
+        {
+            return item is CppScriptItem;
+        }
+
+        /// <inheritdoc />
+        protected override void GetTemplatePaths(out string headerTemplate, out string sourceTemplate)
+        {
+            headerTemplate = StringUtils.CombinePaths(Globals.EngineContentFolder, "Editor/Scripting/ScriptTemplate.h");
+            sourceTemplate = StringUtils.CombinePaths(Globals.EngineContentFolder, "Editor/Scripting/ScriptTemplate.cpp");
+        }
+    }
+
+    /// <summary>
+    /// Context proxy object for C++ Json Asset files.
+    /// </summary>
+    /// <seealso cref="FlaxEditor.Content.CSharpScriptProxy" />
+    public class CppStaticClassProxy : CppProxy
+    {
+        /// <inheritdoc />
+        public override string Name => "C++ Function Library";
+
+        /// <inheritdoc />
+        protected override void GetTemplatePaths(out string headerTemplate, out string sourceTemplate)
+        {
+            headerTemplate = StringUtils.CombinePaths(Globals.EngineContentFolder, "Editor/Scripting/CppStaticClassTemplate.h");
+            sourceTemplate = StringUtils.CombinePaths(Globals.EngineContentFolder, "Editor/Scripting/CppStaticClassTemplate.cpp");
+        }
+    }
+
+    /// <summary>
+    /// Context proxy object for C++ Json Asset files.
+    /// </summary>
+    /// <seealso cref="FlaxEditor.Content.CSharpScriptProxy" />
+    public class CppAssetProxy : CppProxy
+    {
+        /// <inheritdoc />
+        public override string Name => "C++ Json Asset";
+
+        /// <inheritdoc />
+        protected override void GetTemplatePaths(out string headerTemplate, out string sourceTemplate)
+        {
+            headerTemplate = null;
+            sourceTemplate = StringUtils.CombinePaths(Globals.EngineContentFolder, "Editor/Scripting/CppAssetTemplate.h");
+            //sourceTemplate = StringUtils.CombinePaths(Globals.EngineContentFolder, "Editor/Scripting/CppAssetTemplate.cpp");
+        }
+
+        /// <inheritdoc />
+        public override string FileExtension => "h";
+    }
+}

Source/Editor/Content/Proxy/CppScriptProxy.cs

@@ -1,65 +0,0 @@
-// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
-
-using System;
-using System.IO;
-using System.Text;
-using FlaxEditor.Content.Settings;
-using FlaxEngine;
-
-namespace FlaxEditor.Content
-{
-    /// <summary>
-    /// Context proxy object for C++ script files.
-    /// </summary>
-    /// <seealso cref="FlaxEditor.Content.CSharpScriptProxy" />
-    public class CppScriptProxy : ScriptProxy
-    {
-        /// <inheritdoc />
-        public override string Name => "C++ Script";
-
-        /// <inheritdoc />
-        public override bool IsProxyFor(ContentItem item)
-        {
-            return item is CppScriptItem;
-        }
-
-        /// <inheritdoc />
-        public override void Create(string outputPath, object arg)
-        {
-            // Load templates
-            var headerTemplate = File.ReadAllText(StringUtils.CombinePaths(Globals.EngineContentFolder, "Editor/Scripting/ScriptTemplate.h"));
-            var sourceTemplate = File.ReadAllText(StringUtils.CombinePaths(Globals.EngineContentFolder, "Editor/Scripting/ScriptTemplate.cpp"));
-
-            // Find the module that this script is being added (based on the path)
-            var module = string.Empty;
-            var project = TryGetProjectAtFolder(outputPath, out var moduleName);
-            if (project != null)
-            {
-                module = moduleName.ToUpperInvariant() + "_API ";
-            }
-
-            // Format
-            var gameSettings = GameSettings.Load();
-            var scriptName = ScriptItem.CreateScriptName(outputPath);
-            var filename = Path.GetFileNameWithoutExtension(outputPath);
-            var copyrightComment = string.IsNullOrEmpty(gameSettings.CopyrightNotice) ? string.Empty : string.Format("// {0}{1}{1}", gameSettings.CopyrightNotice, Environment.NewLine);
-            headerTemplate = headerTemplate.Replace("%copyright%", copyrightComment);
-            headerTemplate = headerTemplate.Replace("%class%", scriptName);
-            headerTemplate = headerTemplate.Replace("%module%", module);
-            sourceTemplate = sourceTemplate.Replace("%filename%", filename);
-            sourceTemplate = sourceTemplate.Replace("%copyright%", copyrightComment);
-            sourceTemplate = sourceTemplate.Replace("%class%", scriptName);
-            sourceTemplate = sourceTemplate.Replace("%filename%", filename);
-
-            // Save
-            File.WriteAllText(Path.ChangeExtension(outputPath, ".h"), headerTemplate, Encoding.UTF8);
-            File.WriteAllText(outputPath, sourceTemplate, Encoding.UTF8);
-        }
-
-        /// <inheritdoc />
-        public override string FileExtension => "cpp";
-
-        /// <inheritdoc />
-        public override Color AccentColor => Color.FromRGB(0x9c1c9c);
-    }
-}

Source/Editor/Content/Proxy/JsonAssetProxy.cs

@@ -2,7 +2,6 @@
 
 using System;
 using FlaxEditor.Content.Create;
-using FlaxEditor.Content.Settings;
 using FlaxEditor.CustomEditors;
 using FlaxEditor.CustomEditors.Editors;
 using FlaxEditor.Windows;
@@ -45,18 +44,12 @@ namespace FlaxEditor.Content
         /// <inheritdoc />
         public override bool IsProxyFor(ContentItem item)
         {
-            return item is JsonAssetItem;
+            return item is JsonAssetItem json && json.TypeName == TypeName;
         }
 
         /// <inheritdoc />
         public override Color AccentColor => Color.FromRGB(0xd14f67);
 
-        /// <inheritdoc />
-        public override bool AcceptsAsset(string typeName, string path)
-        {
-            return typeName == TypeName && base.AcceptsAsset(typeName, path);
-        }
-
         /// <inheritdoc />
         public override AssetItem ConstructItem(string path, string typeName, ref Guid id)
         {
@@ -99,6 +92,7 @@ namespace FlaxEditor.Content
                         !type.IsAbstract &&
                         !type.IsGenericType &&
                         type.Type.GetConstructor(Type.EmptyTypes) != null &&
+                        !typeof(FlaxEngine.GUI.Control).IsAssignableFrom(type.Type) &&
                         !typeof(FlaxEngine.Object).IsAssignableFrom(type.Type);
                     }
                 }
@@ -143,6 +137,12 @@ namespace FlaxEditor.Content
             return path.EndsWith(FileExtension, StringComparison.OrdinalIgnoreCase);
         }
 
+        /// <inheritdoc />
+        public override bool IsProxyFor(ContentItem item)
+        {
+            return item is JsonAssetItem;
+        }
+
         /// <inheritdoc />
         public override bool CanCreate(ContentFolder targetLocation)
         {

Source/Editor/Content/Proxy/LocalizedStringTableProxy.cs

@@ -0,0 +1,24 @@
+// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
+
+using FlaxEditor.Windows;
+using FlaxEditor.Windows.Assets;
+using FlaxEngine;
+
+namespace FlaxEditor.Content
+{
+    /// <summary>
+    /// <see cref="LocalizedStringTable"/> proxy.
+    /// </summary>
+    /// <seealso cref="FlaxEditor.Content.JsonAssetProxy" />
+    public class LocalizedStringTableProxy : JsonAssetProxy
+    {
+        /// <inheritdoc />
+        public override EditorWindow Open(Editor editor, ContentItem item)
+        {
+            return new LocalizedStringTableWindow(editor, (JsonAssetItem)item);
+        }
+
+        /// <inheritdoc />
+        public override string TypeName => "FlaxEngine.LocalizedStringTable";
+    }
+}

Source/Editor/Content/Proxy/ModelProxy.cs

@@ -47,7 +47,7 @@ namespace FlaxEditor.Content
 
             menu.AddButton("Create collision data", () =>
             {
-                var model = FlaxEngine.Content.LoadAsync<Model>(((ModelAssetItem)item).ID);
+                var model = FlaxEngine.Content.LoadAsync<Model>(((ModelItem)item).ID);
                 var collisionDataProxy = (CollisionDataProxy)Editor.Instance.ContentDatabase.GetProxy<CollisionData>();
                 collisionDataProxy.CreateCollisionDataFromModel(model);
             });

Source/Editor/Content/Proxy/ParticleSystemProxy.cs

@@ -10,6 +10,31 @@ using FlaxEngine.GUI;
 
 namespace FlaxEditor.Content
 {
+    /// <summary>
+    /// Implementation of <see cref="BinaryAssetItem"/> for <see cref="ParticleSystem"/> assets.
+    /// </summary>
+    /// <seealso cref="FlaxEditor.Content.BinaryAssetItem" />
+    class ParticleSystemItem : BinaryAssetItem
+    {
+        /// <inheritdoc />
+        public ParticleSystemItem(string path, ref Guid id, string typeName, Type type)
+        : base(path, ref id, typeName, type, ContentItemSearchFilter.Particles)
+        {
+        }
+
+        /// <inheritdoc />
+        public override bool OnEditorDrag(object context)
+        {
+            return true;
+        }
+
+        /// <inheritdoc />
+        public override Actor OnEditorDrop(object context)
+        {
+            return new ParticleEffect { ParticleSystem = FlaxEngine.Content.LoadAsync<ParticleSystem>(ID) };
+        }
+    }
+
     /// <summary>
     /// A <see cref="ParticleSystem"/> asset proxy object.
     /// </summary>
@@ -28,6 +53,12 @@ namespace FlaxEditor.Content
             return new ParticleSystemWindow(editor, item as AssetItem);
         }
 
+        /// <inheritdoc />
+        public override AssetItem ConstructItem(string path, string typeName, ref Guid id)
+        {
+            return new ParticleSystemItem(path, ref id, typeName, AssetType);
+        }
+
         /// <inheritdoc />
         public override Color AccentColor => Color.FromRGB(0xFF790200);
 

Source/Editor/Content/Proxy/SceneAnimationProxy.cs

@@ -7,6 +7,31 @@ using FlaxEngine;
 
 namespace FlaxEditor.Content
 {
+    /// <summary>
+    /// Implementation of <see cref="BinaryAssetItem"/> for <see cref="SceneAnimation"/> assets.
+    /// </summary>
+    /// <seealso cref="FlaxEditor.Content.BinaryAssetItem" />
+    class SceneAnimationItem : BinaryAssetItem
+    {
+        /// <inheritdoc />
+        public SceneAnimationItem(string path, ref Guid id, string typeName, Type type)
+        : base(path, ref id, typeName, type, ContentItemSearchFilter.Other)
+        {
+        }
+
+        /// <inheritdoc />
+        public override bool OnEditorDrag(object context)
+        {
+            return true;
+        }
+
+        /// <inheritdoc />
+        public override Actor OnEditorDrop(object context)
+        {
+            return new SceneAnimationPlayer { Animation = FlaxEngine.Content.LoadAsync<SceneAnimation>(ID) };
+        }
+    }
+
     /// <summary>
     /// A <see cref="SceneAnimation"/> asset proxy object.
     /// </summary>
@@ -22,6 +47,12 @@ namespace FlaxEditor.Content
             return new SceneAnimationWindow(editor, item as AssetItem);
         }
 
+        /// <inheritdoc />
+        public override AssetItem ConstructItem(string path, string typeName, ref Guid id)
+        {
+            return new SceneAnimationItem(path, ref id, typeName, AssetType);
+        }
+
         /// <inheritdoc />
         public override Color AccentColor => Color.FromRGB(0xff5c4a87);
 

Source/Editor/Content/Proxy/ScriptProxy.cs

@@ -66,6 +66,15 @@ namespace FlaxEditor.Content
             return false;
         }
 
+        /// <inheritdoc />
+        public override bool IsFileNameValid(string filename)
+        {
+            // Scripts cannot start with digit. 
+            if (Char.IsDigit(filename[0]))
+                return false;
+            return true;
+        }
+        
         /// <inheritdoc />
         public override void Create(string outputPath, object arg)
         {

Source/Editor/Content/Proxy/SettingsProxy.cs

@@ -3,6 +3,7 @@
 using System;
 using FlaxEditor.Content.Create;
 using FlaxEditor.Content.Settings;
+using FlaxEngine;
 
 namespace FlaxEditor.Content
 {
@@ -13,15 +14,18 @@ namespace FlaxEditor.Content
     public sealed class SettingsProxy : JsonAssetProxy
     {
         private readonly Type _type;
+        private readonly SpriteHandle _thumbnail;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="SettingsProxy"/> class.
         /// </summary>
         /// <param name="type">The settings asset type (must be subclass of SettingsBase type).</param>
-        public SettingsProxy(Type type)
+        /// <param name="thumbnail">Asset icon.</param>
+        public SettingsProxy(Type type, SpriteHandle thumbnail)
         {
             _type = type;
             TypeName = type.FullName;
+            _thumbnail = thumbnail;
         }
 
         /// <inheritdoc />
@@ -44,6 +48,12 @@ namespace FlaxEditor.Content
             Editor.Instance.ContentImporting.Create(new SettingsCreateEntry(outputPath));
         }
 
+        /// <inheritdoc />
+        public override AssetItem ConstructItem(string path, string typeName, ref Guid id)
+        {
+            return new JsonAssetItem(path, id, typeName, _thumbnail);
+        }
+
         /// <inheritdoc />
         public override bool IsProxyFor<T>()
         {

Source/Editor/Content/Tree/ContentTreeNode.cs

@@ -77,7 +77,7 @@ namespace FlaxEditor.Content
         /// <param name="type">The folder type.</param>
         /// <param name="path">The folder path.</param>
         protected ContentTreeNode(ContentTreeNode parent, ContentFolderType type, string path)
-        : base(false, Editor.Instance.Icons.FolderClosed12, Editor.Instance.Icons.FolderOpened12)
+        : base(false, Editor.Instance.Icons.FolderClosed32, Editor.Instance.Icons.FolderOpen32)
         {
             _folder = new ContentFolder(type, path, this);
             Text = _folder.ShortName;

Source/Editor/Cooker/CookingData.h

@@ -3,10 +3,11 @@
 #pragma once
 
 #include "Engine/Core/Log.h"
-#include "Engine/Core/Enums.h"
+#include "Engine/Core/Types/Guid.h"
 #include "Engine/Core/Collections/Array.h"
 #include "Engine/Core/Collections/HashSet.h"
 #include "Engine/Core/Collections/Dictionary.h"
+#include "Engine/Scripting/ScriptingObject.h"
 
 class GameCooker;
 class PlatformTools;
@@ -87,34 +88,14 @@ API_ENUM() enum class BuildPlatform
     /// </summary>
     API_ENUM(Attributes="EditorDisplay(null, \"Android ARM64 (arm64-v8a)\")")
     AndroidARM64 = 9,
+
+    /// <summary>
+    /// Switch.
+    /// </summary>
+    Switch = 10,
 };
 
-inline const Char* ToString(const BuildPlatform platform)
+extern FLAXENGINE_API const Char* ToString(const BuildPlatform platform);
-{
-    switch (platform)
-    {
-    case BuildPlatform::Windows32:
-        return TEXT("Windows x86");
-    case BuildPlatform::Windows64:
-        return TEXT("Windows x64");
-    case BuildPlatform::UWPx86:
-        return TEXT("Windows Store x86");
-    case BuildPlatform::UWPx64:
-        return TEXT("Windows Store x64");
-    case BuildPlatform::XboxOne:
-        return TEXT("Xbox One");
-    case BuildPlatform::LinuxX64:
-        return TEXT("Linux x64");
-    case BuildPlatform::PS4:
-        return TEXT("PlayStation 4");
-    case BuildPlatform::XboxScarlett:
-        return TEXT("Xbox Scarlett");
-    case BuildPlatform::AndroidARM64:
-        return TEXT("Android ARM64");
-    default:
-        return TEXT("?");
-    }
-}
 
 /// <summary>
 /// Game build configuration modes.
@@ -137,57 +118,67 @@ API_ENUM() enum class BuildConfiguration
     Release = 2,
 };
 
-inline const Char* ToString(const BuildConfiguration configuration)
+extern FLAXENGINE_API const Char* ToString(const BuildConfiguration configuration);
-{
-    switch (configuration)
-    {
-    case BuildConfiguration::Debug:
-        return TEXT("Debug");
-    case BuildConfiguration::Development:
-        return TEXT("Development");
-    case BuildConfiguration::Release:
-        return TEXT("Release");
-    default:
-        return TEXT("?");
-    }
-}
 
 #define BUILD_STEP_CANCEL_CHECK if (GameCooker::IsCancelRequested()) return true
 
 /// <summary>
 /// Game cooking temporary data.
 /// </summary>
-struct FLAXENGINE_API CookingData
+API_CLASS(Sealed, Namespace="FlaxEditor") class FLAXENGINE_API CookingData : public PersistentScriptingObject
 {
+DECLARE_SCRIPTING_TYPE(CookingData);
+public:
+
     /// <summary>
     /// The platform.
     /// </summary>
-    BuildPlatform Platform;
+    API_FIELD(ReadOnly) BuildPlatform Platform;
 
     /// <summary>
     /// The configuration.
     /// </summary>
-    BuildConfiguration Configuration;
+    API_FIELD(ReadOnly) BuildConfiguration Configuration;
 
     /// <summary>
     /// The options.
     /// </summary>
-    BuildOptions Options;
+    API_FIELD(ReadOnly) BuildOptions Options;
+
+    /// <summary>
+    /// The name of build preset used for cooking (can be used by editor and game plugins).
+    /// </summary>
+    API_FIELD(ReadOnly) String Preset;
+
+    /// <summary>
+    /// The name of build preset target used for cooking (can be used by editor and game plugins).
+    /// </summary>
+    API_FIELD(ReadOnly) String PresetTarget;
 
     /// <summary>
     /// The list of custom defines passed to the build tool when compiling project scripts. Can be used in build scripts for configuration (Configuration.CustomDefines).
     /// </summary>
-    Array<String> CustomDefines;
+    API_FIELD(ReadOnly) Array<String> CustomDefines;
 
     /// <summary>
     /// The original output path (actual OutputPath could be modified by the Platform Tools or a plugin for additional layout customizations or packaging). This path is preserved.
     /// </summary>
-    String OriginalOutputPath;
+    API_FIELD(ReadOnly) String OriginalOutputPath;
 
     /// <summary>
-    /// The output path.
+    /// The output path for data files (Content, Mono, etc.).
     /// </summary>
-    String OutputPath;
+    API_FIELD(ReadOnly) String DataOutputPath;
+
+    /// <summary>
+    /// The output path for binaries (native executable and native code libraries).
+    /// </summary>
+    API_FIELD(ReadOnly) String NativeCodeOutputPath;
+
+    /// <summary>
+    /// The output path for binaries (C# code libraries).
+    /// </summary>
+    API_FIELD(ReadOnly) String ManagedCodeOutputPath;
 
     /// <summary>
     /// The platform tools.
@@ -270,7 +261,7 @@ public:
     /// </summary>
     HashSet<Guid> Assets;
 
-    struct BinaryModule
+    struct BinaryModuleInfo
     {
         String Name;
         String NativePath;
@@ -280,17 +271,10 @@ public:
     /// <summary>
     /// The binary modules used in the build. Valid after scripts compilation step. This list includes game, all plugins modules and engine module.
     /// </summary>
-    Array<BinaryModule, InlinedAllocation<64>> BinaryModules;
+    Array<BinaryModuleInfo, InlinedAllocation<64>> BinaryModules;
 
 public:
 
-    void Init()
-    {
-        RootAssets.Clear();
-        Assets.Clear();
-        Stats = Statistics();
-    }
-
     /// <summary>
     /// Gets the absolute path to the Platform Data folder that contains the binary files used by the current build configuration.
     /// </summary>

Source/Editor/Cooker/GameCooker.cpp

@@ -10,6 +10,7 @@
 #include "Engine/Serialization/JsonTools.h"
 #include "Engine/Content/Content.h"
 #include "Engine/Engine/EngineService.h"
+#include "Engine/Engine/Globals.h"
 #include "Engine/Threading/ThreadSpawner.h"
 #include "Engine/Platform/FileSystem.h"
 #include "Steps/ValidateStep.h"
@@ -25,6 +26,7 @@
 #include "Engine/Scripting/ManagedCLR/MAssembly.h"
 #include "Engine/Content/JsonAsset.h"
 #include "Engine/Content/AssetReference.h"
+#include "Engine/Scripting/MException.h"
 #if PLATFORM_TOOLS_WINDOWS
 #include "Platform/Windows/WindowsPlatformTools.h"
 #include "Engine/Platform/Windows/WindowsPlatformSettings.h"
@@ -39,7 +41,6 @@
 #endif
 #if PLATFORM_TOOLS_PS4
 #include "Platforms/PS4/Editor/PlatformTools/PS4PlatformTools.h"
-#include "Platforms/PS4/Engine/Platform/PS4PlatformSettings.h"
 #endif
 #if PLATFORM_TOOLS_XBOX_SCARLETT
 #include "Platforms/XboxScarlett/Editor/PlatformTools/XboxScarlettPlatformTools.h"
@@ -47,12 +48,15 @@
 #if PLATFORM_TOOLS_ANDROID
 #include "Platform/Android/AndroidPlatformTools.h"
 #endif
+#if PLATFORM_TOOLS_SWITCH
+#include "Platforms/Switch/Editor/PlatformTools/SwitchPlatformTools.h"
+#endif
 
 namespace GameCookerImpl
 {
     MMethod* Internal_OnEvent = nullptr;
     MMethod* Internal_OnProgress = nullptr;
-    MMethod* Internal_CanDeployPlugin = nullptr;
+    MMethod* Internal_OnCollectAssets = nullptr;
 
     bool IsRunning = false;
     bool IsThreadRunning = false;
@@ -64,7 +68,7 @@ namespace GameCookerImpl
     String ProgressMsg;
     float ProgressValue;
 
-    CookingData Data;
+    CookingData* Data = nullptr;
     Array<GameCooker::BuildStep*> Steps;
     Dictionary<BuildPlatform, PlatformTools*> Tools;
 
@@ -74,6 +78,7 @@ namespace GameCookerImpl
 
     void CallEvent(GameCooker::EventType type);
     void ReportProgress(const String& info, float totalProgress);
+    void OnCollectAssets(HashSet<Guid>& assets);
     bool Build();
     int32 ThreadFunction();
 
@@ -81,6 +86,7 @@ namespace GameCookerImpl
     {
         Internal_OnEvent = nullptr;
         Internal_OnProgress = nullptr;
+        Internal_OnCollectAssets = nullptr;
     }
 }
 
@@ -88,6 +94,51 @@ using namespace GameCookerImpl;
 
 Delegate<GameCooker::EventType> GameCooker::OnEvent;
 Delegate<const String&, float> GameCooker::OnProgress;
+Delegate<HashSet<Guid>&> GameCooker::OnCollectAssets;
+
+const Char* ToString(const BuildPlatform platform)
+{
+    switch (platform)
+    {
+    case BuildPlatform::Windows32:
+        return TEXT("Windows x86");
+    case BuildPlatform::Windows64:
+        return TEXT("Windows x64");
+    case BuildPlatform::UWPx86:
+        return TEXT("Windows Store x86");
+    case BuildPlatform::UWPx64:
+        return TEXT("Windows Store x64");
+    case BuildPlatform::XboxOne:
+        return TEXT("Xbox One");
+    case BuildPlatform::LinuxX64:
+        return TEXT("Linux x64");
+    case BuildPlatform::PS4:
+        return TEXT("PlayStation 4");
+    case BuildPlatform::XboxScarlett:
+        return TEXT("Xbox Scarlett");
+    case BuildPlatform::AndroidARM64:
+        return TEXT("Android ARM64");
+    case BuildPlatform::Switch:
+        return TEXT("Switch");
+    default:
+        return TEXT("?");
+    }
+}
+
+const Char* ToString(const BuildConfiguration configuration)
+{
+    switch (configuration)
+    {
+    case BuildConfiguration::Debug:
+        return TEXT("Debug");
+    case BuildConfiguration::Development:
+        return TEXT("Development");
+    case BuildConfiguration::Release:
+        return TEXT("Release");
+    default:
+        return TEXT("?");
+    }
+}
 
 bool CookingData::AssetTypeStatistics::operator<(const AssetTypeStatistics& other) const
 {
@@ -103,6 +154,11 @@ CookingData::Statistics::Statistics()
     ContentSizeMB = 0;
 }
 
+CookingData::CookingData(const SpawnParams& params)
+    : PersistentScriptingObject(params)
+{
+}
+
 String CookingData::GetGameBinariesPath() const
 {
     const Char* archDir;
@@ -128,7 +184,7 @@ String CookingData::GetGameBinariesPath() const
         return String::Empty;
     }
 
-    return GetPlatformBinariesRoot() / TEXT("Game") / archDir / ToString(Configuration);
+    return GetPlatformBinariesRoot() / TEXT("Game") / archDir / ::ToString(Configuration);
 }
 
 String CookingData::GetPlatformBinariesRoot() const
@@ -188,7 +244,7 @@ public:
 
 GameCookerService GameCookerServiceInstance;
 
-const CookingData& GameCooker::GetCurrentData()
+CookingData* GameCooker::GetCurrentData()
 {
     return Data;
 }
@@ -250,6 +306,11 @@ PlatformTools* GameCooker::GetTools(BuildPlatform platform)
         case BuildPlatform::AndroidARM64:
             result = New<AndroidPlatformTools>(ArchitectureType::ARM64);
             break;
+#endif
+#if PLATFORM_TOOLS_SWITCH
+        case BuildPlatform::Switch:
+            result = New<SwitchPlatformTools>();
+            break;
 #endif
         }
         Tools.Add(platform, result);
@@ -257,7 +318,7 @@ PlatformTools* GameCooker::GetTools(BuildPlatform platform)
     return result;
 }
 
-void GameCooker::Build(BuildPlatform platform, BuildConfiguration configuration, const StringView& outputPath, BuildOptions options, const Array<String>& customDefines)
+void GameCooker::Build(BuildPlatform platform, BuildConfiguration configuration, const StringView& outputPath, BuildOptions options, const Array<String>& customDefines, const StringView& preset, const StringView& presetTarget)
 {
     if (IsRunning())
     {
@@ -275,16 +336,19 @@ void GameCooker::Build(BuildPlatform platform, BuildConfiguration configuration,
     CancelFlag = 0;
     ProgressMsg.Clear();
     ProgressValue = 1.0f;
-    CookingData& data = Data;
+    Data = New<CookingData>();
-    data.Init();
+    CookingData& data = *Data;
     data.Tools = tools;
     data.Platform = platform;
     data.Configuration = configuration;
     data.Options = options;
+    data.Preset = preset;
+    data.PresetTarget = presetTarget;
     data.CustomDefines = customDefines;
-    data.OutputPath = outputPath;
+    data.OriginalOutputPath = outputPath;
-    FileSystem::NormalizePath(data.OutputPath);
+    FileSystem::NormalizePath(data.OriginalOutputPath);
-    data.OutputPath = data.OriginalOutputPath = FileSystem::ConvertRelativePathToAbsolute(Globals::ProjectFolder, data.OutputPath);
+    data.OriginalOutputPath = FileSystem::ConvertRelativePathToAbsolute(Globals::ProjectFolder, data.OriginalOutputPath);
+    data.NativeCodeOutputPath = data.ManagedCodeOutputPath = data.DataOutputPath = data.OriginalOutputPath;
     data.CacheDirectory = Globals::ProjectCacheFolder / TEXT("Cooker") / tools->GetName();
     if (!FileSystem::DirectoryExists(data.CacheDirectory))
     {
@@ -362,12 +426,39 @@ void GameCookerImpl::ReportProgress(const String& info, float totalProgress)
     ProgressValue = totalProgress;
 }
 
+void GameCookerImpl::OnCollectAssets(HashSet<Guid>& assets)
+{
+    if (Internal_OnCollectAssets == nullptr)
+    {
+        auto c = GameCooker::GetStaticClass();
+        if (c)
+            Internal_OnCollectAssets = c->GetMethod("Internal_OnCollectAssets", 0);
+        ASSERT(GameCookerImpl::Internal_OnCollectAssets);
+    }
+
+    MCore::AttachThread();
+    MonoObject* exception = nullptr;
+    auto list = (MonoArray*)Internal_OnCollectAssets->Invoke(nullptr, nullptr, &exception);
+    if (exception)
+    {
+        MException ex(exception);
+        ex.Log(LogType::Error, TEXT("OnCollectAssets"));
+    }
+
+    if (list)
+    {
+        auto ids = MUtils::ToSpan<Guid>(list);
+        for (int32 i = 0; i < ids.Length(); i++)
+            assets.Add(ids[i]);
+    }
+}
+
 bool GameCookerImpl::Build()
 {
-    CookingData& data = Data;
+    CookingData& data = *Data;
     LOG(Info, "Starting Game Cooker...");
     LOG(Info, "Platform: {0}, Configuration: {2}, Options: {1}", ::ToString(data.Platform), (int32)data.Options, ::ToString(data.Configuration));
-    LOG(Info, "Output Path: {0}", data.OutputPath);
+    LOG(Info, "Output Path: {0}", data.OriginalOutputPath);
 
     // Late init feature
     if (Steps.IsEmpty())
@@ -388,7 +479,7 @@ bool GameCookerImpl::Build()
     CallEvent(GameCooker::EventType::BuildStarted);
     for (int32 stepIndex = 0; stepIndex < Steps.Count(); stepIndex++)
         Steps[stepIndex]->OnBuildStarted(data);
-    Data.Tools->OnBuildStarted(data);
+    data.Tools->OnBuildStarted(data);
     data.InitProgress(Steps.Count());
 
     // Execute all steps in a sequence
@@ -427,10 +518,12 @@ bool GameCookerImpl::Build()
     }
     IsRunning = false;
     CancelFlag = 0;
-    Data.Tools->OnBuildEnded(data, failed);
+    data.Tools->OnBuildEnded(data, failed);
     for (int32 stepIndex = 0; stepIndex < Steps.Count(); stepIndex++)
         Steps[stepIndex]->OnBuildEnded(data, failed);
     CallEvent(failed ? GameCooker::EventType::BuildFailed : GameCooker::EventType::BuildDone);
+    Delete(Data);
+    Data = nullptr;
 
     return failed;
 }
@@ -458,6 +551,7 @@ bool GameCookerService::Init()
 {
     auto editorAssembly = ((NativeBinaryModule*)GetBinaryModuleFlaxEngine())->Assembly;
     editorAssembly->Unloading.Bind(OnEditorAssemblyUnloading);
+    GameCooker::OnCollectAssets.Bind(OnCollectAssets);
 
     return false;
 }

Source/Editor/Cooker/GameCooker.cs

@@ -1,9 +1,7 @@
 // Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
 
 using System;
-using System.Linq;
+using System.Collections.Generic;
-using System.Reflection;
-using System.Runtime.CompilerServices;
 using FlaxEngine;
 
 namespace FlaxEditor
@@ -80,6 +78,11 @@ namespace FlaxEditor
         /// </summary>
         public static event BuildProgressDelegate Progress;
 
+        /// <summary>
+        /// Occurs when building collects assets to cook.
+        /// </summary>
+        public static event Action<List<Guid>> CollectAssets;
+
         /// <summary>
         /// Gets the type of the platform from the game build platform type.
         /// </summary>
@@ -96,6 +99,9 @@ namespace FlaxEditor
             case BuildPlatform.XboxOne: return PlatformType.XboxOne;
             case BuildPlatform.LinuxX64: return PlatformType.Linux;
             case BuildPlatform.PS4: return PlatformType.PS4;
+            case BuildPlatform.AndroidARM64: return PlatformType.Android;
+            case BuildPlatform.XboxScarlett: return PlatformType.XboxScarlett;
+            case BuildPlatform.Switch: return PlatformType.Switch;
             default: throw new ArgumentOutOfRangeException(nameof(buildPlatform), buildPlatform, null);
             }
         }
@@ -109,5 +115,23 @@ namespace FlaxEditor
         {
             Progress?.Invoke(info, totalProgress);
         }
+
+        internal static Guid[] Internal_OnCollectAssets()
+        {
+            var list = new List<Guid>();
+
+            // Custom assets
+            CollectAssets?.Invoke(list);
+
+            // Plugin assets
+            foreach (var plugin in PluginManager.GamePlugins)
+            {
+                plugin.OnCollectAssets(list);
+            }
+
+            if (list.Count == 0)
+                return null;
+            return list.ToArray();
+        }
     }
 }

Source/Editor/Cooker/GameCooker.h

@@ -56,18 +56,16 @@ public:
     /// <summary>
     /// Gets the current build data. Valid only during active build process.
     /// </summary>
-    static const CookingData& GetCurrentData();
+    API_PROPERTY() static CookingData* GetCurrentData();
 
     /// <summary>
     /// Determines whether game building is running.
     /// </summary>
-    /// <returns><c>true</c> if game building is running; otherwise, <c>false</c>.</returns>
     API_PROPERTY() static bool IsRunning();
 
     /// <summary>
     /// Determines whether building cancel has been requested.
     /// </summary>
-    /// <returns><c>true</c> if building cancel has been requested; otherwise, <c>false</c>.</returns>
     API_PROPERTY() static bool IsCancelRequested();
 
     /// <summary>
@@ -85,7 +83,9 @@ public:
     /// <param name="outputPath">The output path (output directory).</param>
     /// <param name="options">The build options.</param>
     /// <param name="customDefines">The list of custom defines passed to the build tool when compiling project scripts. Can be used in build scripts for configuration (Configuration.CustomDefines).</param>
-    API_FUNCTION() static void Build(BuildPlatform platform, BuildConfiguration configuration, const StringView& outputPath, BuildOptions options, const Array<String>& customDefines);
+    /// <param name="preset">The name of build preset used for cooking (can be used by editor and game plugins).</param>
+    /// <param name="presetTarget">The name of build preset target used for cooking (can be used by editor and game plugins).</param>
+    API_FUNCTION() static void Build(BuildPlatform platform, BuildConfiguration configuration, const StringView& outputPath, BuildOptions options, const Array<String>& customDefines, const StringView& preset = StringView::Empty, const StringView& presetTarget = StringView::Empty);
 
     /// <summary>
     /// Sends a cancel event to the game building service.
@@ -123,4 +123,9 @@ public:
     /// Occurs when building game progress fires.
     /// </summary>
     static Delegate<const String&, float> OnProgress;
+
+    /// <summary>
+    /// Occurs when building collects assets to cook.
+    /// </summary>
+    static Delegate<HashSet<Guid>&> OnCollectAssets;
 };

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

@@ -104,7 +104,9 @@ PixelFormat AndroidPlatformTools::GetTextureFormat(CookingData& data, TextureBas
 void AndroidPlatformTools::OnBuildStarted(CookingData& data)
 {
     // Adjust the cooking output folder to be located inside the Gradle assets directory
-    data.OutputPath /= TEXT("app/assets");
+    data.DataOutputPath /= TEXT("app/assets");
+    data.NativeCodeOutputPath /= TEXT("app/assets");
+    data.ManagedCodeOutputPath /= TEXT("app/assets");
 
     PlatformTools::OnBuildStarted(data);
 }
@@ -114,7 +116,7 @@ bool AndroidPlatformTools::OnPostProcess(CookingData& data)
     const auto gameSettings = GameSettings::Get();
     const auto platformSettings = AndroidPlatformSettings::Get();
     const auto platformDataPath = data.GetPlatformBinariesRoot();
-    const auto assetsPath = data.OutputPath;
+    const auto assetsPath = data.DataOutputPath;
     const auto jniLibsPath = data.OriginalOutputPath / TEXT("app/jniLibs");
     const auto projectVersion = Editor::Project->Version.ToString();
     const Char* abi;

Source/Editor/Cooker/Platform/Linux/LinuxPlatformTools.cpp

@@ -38,7 +38,7 @@ bool LinuxPlatformTools::OnDeployBinaries(CookingData& data)
 {
     const auto gameSettings = GameSettings::Get();
     const auto platformSettings = LinuxPlatformSettings::Get();
-    const auto outputPath = data.OutputPath;
+    const auto outputPath = data.DataOutputPath;
 
     // Copy binaries
     {
@@ -66,7 +66,7 @@ bool LinuxPlatformTools::OnDeployBinaries(CookingData& data)
 #if !BUILD_DEBUG
 	const String outputExePath = outputPath / TEXT("FlaxGame");
 	const String gameExePath = outputPath / gameSettings->ProductName;
-	if (FileSystem::FileExists(outputExePath) && gameExePath.Compare(outputExePath, StringSearchCase::IgnoreCase) == 0)
+	if (FileSystem::FileExists(outputExePath) && gameExePath.Compare(outputExePath, StringSearchCase::IgnoreCase) != 0)
 	{
 		if (FileSystem::MoveFile(gameExePath, outputExePath, true))
 		{

Source/Editor/Cooker/Platform/UWP/UWPPlatformTools.cpp

@@ -25,7 +25,7 @@ bool UWPPlatformTools::OnScriptsStepDone(CookingData& data)
 {
     // Override Newtonsoft.Json.dll for some platforms (that don't support runtime code generation)
     const String customBinPath = data.GetPlatformBinariesRoot() / TEXT("Newtonsoft.Json.dll");
-    const String assembliesPath = data.OutputPath;
+    const String assembliesPath = data.ManagedCodeOutputPath;
     if (FileSystem::CopyFile(assembliesPath / TEXT("Newtonsoft.Json.dll"), customBinPath))
     {
         data.Error(TEXT("Failed to copy deploy custom assembly."));
@@ -64,7 +64,7 @@ bool UWPPlatformTools::OnDeployBinaries(CookingData& data)
             return true;
         }
 
-        if (FileSystem::CopyFile(data.OutputPath / StringUtils::GetFileName(files[i]), files[i]))
+        if (FileSystem::CopyFile(data.DataOutputPath / StringUtils::GetFileName(files[i]), files[i]))
         {
             data.Error(TEXT("Failed to setup output directory."));
             return true;
@@ -92,7 +92,7 @@ bool UWPPlatformTools::OnDeployBinaries(CookingData& data)
 
     // Prepare certificate
     const auto srcCertificatePath = Globals::ProjectFolder / platformSettings->CertificateLocation;
-    const auto dstCertificatePath = data.OutputPath / TEXT("WSACertificate.pfx");
+    const auto dstCertificatePath = data.DataOutputPath / TEXT("WSACertificate.pfx");
     if (platformSettings->CertificateLocation.HasChars() && FileSystem::FileExists(srcCertificatePath))
     {
         // Use cert from settings
@@ -115,7 +115,7 @@ bool UWPPlatformTools::OnDeployBinaries(CookingData& data)
     }
 
     // Copy assets
-    const auto dstAssetsPath = data.OutputPath / TEXT("Assets");
+    const auto dstAssetsPath = data.DataOutputPath / TEXT("Assets");
     const auto srcAssetsPath = uwpDataPath / TEXT("Assets");
     if (!FileSystem::DirectoryExists(dstAssetsPath))
     {
@@ -125,7 +125,7 @@ bool UWPPlatformTools::OnDeployBinaries(CookingData& data)
             return true;
         }
     }
-    const auto dstPropertiesPath = data.OutputPath / TEXT("Properties");
+    const auto dstPropertiesPath = data.DataOutputPath / TEXT("Properties");
     if (!FileSystem::DirectoryExists(dstPropertiesPath))
     {
         if (FileSystem::CreateDirectory(dstPropertiesPath))
@@ -176,7 +176,7 @@ bool UWPPlatformTools::OnDeployBinaries(CookingData& data)
             return true;
         }
     }
-    const auto dstAppPath = data.OutputPath / TEXT("App.cs");
+    const auto dstAppPath = data.DataOutputPath / TEXT("App.cs");
     const auto srcAppPath = uwpDataPath / TEXT("App.cs");
     if (!FileSystem::FileExists(dstAppPath))
     {
@@ -205,7 +205,7 @@ bool UWPPlatformTools::OnDeployBinaries(CookingData& data)
             return true;
         }
     }
-    const auto dstFlaxGeneratedPath = data.OutputPath / TEXT("FlaxGenerated.cs");
+    const auto dstFlaxGeneratedPath = data.DataOutputPath / TEXT("FlaxGenerated.cs");
     const auto srcFlaxGeneratedPath = uwpDataPath / TEXT("FlaxGenerated.cs");
     {
         // Get template
@@ -264,7 +264,7 @@ bool UWPPlatformTools::OnDeployBinaries(CookingData& data)
     }
 
     // Create solution
-    const auto dstSolutionPath = data.OutputPath / projectName + TEXT(".sln");
+    const auto dstSolutionPath = data.DataOutputPath / projectName + TEXT(".sln");
     const auto srcSolutionPath = uwpDataPath / TEXT("Solution.sln");
     if (!FileSystem::FileExists(dstSolutionPath))
     {
@@ -297,7 +297,7 @@ bool UWPPlatformTools::OnDeployBinaries(CookingData& data)
     }
 
     // Create project
-    const auto dstProjectPath = data.OutputPath / projectName + TEXT(".csproj");
+    const auto dstProjectPath = data.DataOutputPath / projectName + TEXT(".csproj");
     const auto srcProjectPath = uwpDataPath / TEXT("Project.csproj");
     {
         // Get template
@@ -347,7 +347,7 @@ bool UWPPlatformTools::OnDeployBinaries(CookingData& data)
     }
 
     // Create manifest
-    const auto dstManifestPath = data.OutputPath / TEXT("Package.appxmanifest");
+    const auto dstManifestPath = data.DataOutputPath / TEXT("Package.appxmanifest");
     const auto srcManifestPath = uwpDataPath / TEXT("Package.appxmanifest");
     if (!FileSystem::FileExists(dstManifestPath))
     {
@@ -484,8 +484,8 @@ bool UWPPlatformTools::OnPostProcess(CookingData& data)
     // Special case for UWP
     // FlaxEngine.dll cannot be added to the solution as `Content` item (due to conflicts with C++ /CX FlaxEngine.dll)
     // Use special directory for it (generated UWP project handles this case and copies lib to the output)
-    const String assembliesPath = data.OutputPath;
+    const String assembliesPath = data.DataOutputPath;
-    const auto dstPath1 = data.OutputPath / TEXT("DataSecondary");
+    const auto dstPath1 = data.DataOutputPath / TEXT("DataSecondary");
     if (!FileSystem::DirectoryExists(dstPath1))
     {
         if (FileSystem::CreateDirectory(dstPath1))

Source/Editor/Cooker/Platform/Windows/WindowsPlatformTools.cpp

@@ -36,7 +36,7 @@ ArchitectureType WindowsPlatformTools::GetArchitecture() const
 bool WindowsPlatformTools::OnDeployBinaries(CookingData& data)
 {
     const auto platformSettings = WindowsPlatformSettings::Get();
-    const auto& outputPath = data.OutputPath;
+    const auto& outputPath = data.NativeCodeOutputPath;
 
     // Apply executable icon
     Array<String> files;

Source/Editor/Cooker/PlatformTools.h

@@ -66,6 +66,17 @@ public:
         return format;
     }
 
+    /// <summary>
+    /// Checks if the given file is a native code.
+    /// </summary>
+    /// <param name="data">The cooking data.</param>
+    /// <param name="file">The file path.</param>
+    /// <returns>True if it's a native file, otherwise false.<returns>
+    virtual bool IsNativeCodeFile(CookingData& data, const String& file)
+    {
+        return false;
+    }
+
 public:
 
     /// <summary>
@@ -136,6 +147,8 @@ public:
         String AssemblerArgs;
         String ArchiverPath;
         String ArchiverArgs;
+        String AuxToolPath;
+        String AuxToolArgs;
         String AotCachePath;
         Dictionary<String, String> EnvVars;
         Array<String> AssembliesSearchDirs;
@@ -144,8 +157,8 @@ public:
         AotConfig(CookingData& data)
         {
             Platform::GetEnvironmentVariables(EnvVars);
-            EnvVars[TEXT("MONO_PATH")] = data.OutputPath / TEXT("Mono/lib/mono/4.5");
+            EnvVars[TEXT("MONO_PATH")] = data.DataOutputPath / TEXT("Mono/lib/mono/4.5");
-            AssembliesSearchDirs.Add(data.OutputPath / TEXT("Mono/lib/mono/4.5"));
+            AssembliesSearchDirs.Add(data.DataOutputPath / TEXT("Mono/lib/mono/4.5"));
         }
     };
 

Source/Editor/Cooker/Steps/CompileScriptsStep.cpp

@@ -119,7 +119,8 @@ bool CompileScriptsStep::DeployBinaries(CookingData& data, const String& path, c
     }
     for (auto& file : files)
     {
-        const String dst = data.OutputPath / StringUtils::GetFileName(file);
+        const String& dstPath = data.Tools->IsNativeCodeFile(data, file) ? data.NativeCodeOutputPath : data.ManagedCodeOutputPath;
+        const String dst = dstPath / StringUtils::GetFileName(file);
         if (dst != file && FileSystem::CopyFile(dst, file))
         {
             data.Error(TEXT("Failed to copy file from {0} to {1}."), file, dst);
@@ -180,7 +181,12 @@ bool CompileScriptsStep::Perform(CookingData& data)
         platform = TEXT("Android");
         architecture = TEXT("ARM64");
         break;
+    case BuildPlatform::Switch:
+        platform = TEXT("Switch");
+        architecture = TEXT("ARM64");
+        break;
     default:
+        LOG(Error, "Unknown or unsupported build platform.");
         return true;
     }
     _extensionsToSkip.Clear();
@@ -289,7 +295,7 @@ bool CompileScriptsStep::Perform(CookingData& data)
         }
         writer.EndObject();
 
-        const String outputBuildInfo = data.OutputPath / TEXT("Game.Build.json");
+        const String outputBuildInfo = data.DataOutputPath / TEXT("Game.Build.json");
         if (File::WriteAllBytes(outputBuildInfo, (byte*)buffer.GetString(), (int32)buffer.GetSize()))
         {
             LOG(Error, "Failed to save binary modules info file {0}.", outputBuildInfo);

Source/Editor/Cooker/Steps/CookAssetsStep.cpp

@@ -25,10 +25,12 @@
 #include "Engine/Core/Config/PlatformSettings.h"
 #include "Engine/Core/Config/GameSettings.h"
 #include "Engine/Core/Config/BuildSettings.h"
+#include "Engine/Streaming/StreamingSettings.h"
 #include "Engine/ShadersCompilation/ShadersCompilation.h"
 #include "Engine/Graphics/RenderTools.h"
 #include "Engine/Graphics/Textures/TextureData.h"
 #include "Engine/Engine/Base/GameBase.h"
+#include "Engine/Engine/Globals.h"
 #include "Engine/Tools/TextureTool/TextureTool.h"
 #if PLATFORM_TOOLS_WINDOWS
 #include "Engine/Platform/Windows/WindowsPlatformSettings.h"
@@ -43,6 +45,35 @@
 
 Dictionary<String, CookAssetsStep::ProcessAssetFunc> CookAssetsStep::AssetProcessors;
 
+bool CookAssetsStep::CacheEntry::IsValid(bool withDependencies)
+{
+    AssetInfo assetInfo;
+    if (Content::GetAssetInfo(ID, assetInfo))
+    {
+        if (TypeName == assetInfo.TypeName)
+        {
+            if (FileSystem::GetFileLastEditTime(assetInfo.Path) <= FileModified)
+            {
+                bool isValid = true;
+                if (withDependencies)
+                {
+                    for (auto& f : FileDependencies)
+                    {
+                        if (FileSystem::GetFileLastEditTime(f.First) > f.Second)
+                        {
+                            isValid = false;
+                            break;
+                        }
+                    }
+                }
+                if (isValid)
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+
 CookAssetsStep::CacheEntry& CookAssetsStep::CacheData::CreateEntry(const JsonAssetBase* asset, String& cachedFilePath)
 {
     ASSERT(asset->DataTypeName.HasChars());
@@ -67,7 +98,6 @@ CookAssetsStep::CacheEntry& CookAssetsStep::CacheData::CreateEntry(const Asset*
 void CookAssetsStep::CacheData::InvalidateShaders()
 {
     LOG(Info, "Invalidating cached shader assets.");
-
     for (auto e = Entries.Begin(); e.IsNotEnd(); ++e)
     {
         auto& typeName = e->Value.TypeName;
@@ -82,6 +112,23 @@ void CookAssetsStep::CacheData::InvalidateShaders()
     }
 }
 
+void CookAssetsStep::CacheData::InvalidateTextures()
+{
+    LOG(Info, "Invalidating cached texture assets.");
+    for (auto e = Entries.Begin(); e.IsNotEnd(); ++e)
+    {
+        auto& typeName = e->Value.TypeName;
+        if (
+            typeName == Texture::TypeName ||
+            typeName == CubeTexture::TypeName ||
+            typeName == SpriteAtlas::TypeName
+        )
+        {
+            Entries.Remove(e);
+        }
+    }
+}
+
 void CookAssetsStep::CacheData::Load(CookingData& data)
 {
     HeaderFilePath = data.CacheDirectory / String::Format(TEXT("CookedHeader_{0}.bin"), FLAXENGINE_VERSION_BUILD);
@@ -158,17 +205,17 @@ void CookAssetsStep::CacheData::Load(CookingData& data)
         Entries.Clear();
     }
 
+    const auto buildSettings = BuildSettings::Get();
+    const auto gameSettings = GameSettings::Get();
+
     // Invalidate shaders and assets with shaders if need to rebuild them
     bool invalidateShaders = false;
-    const auto buildSettings = BuildSettings::Get();
+    if (buildSettings->ShadersNoOptimize != Settings.Global.ShadersNoOptimize)
-    const bool shadersNoOptimize = buildSettings->ShadersNoOptimize;
-    const bool shadersGenerateDebugData = buildSettings->ShadersGenerateDebugData;
-    if (shadersNoOptimize != Settings.Global.ShadersNoOptimize)
     {
         LOG(Info, "ShadersNoOptimize option has been modified.");
         invalidateShaders = true;
     }
-    if (shadersGenerateDebugData != Settings.Global.ShadersGenerateDebugData)
+    if (buildSettings->ShadersGenerateDebugData != Settings.Global.ShadersGenerateDebugData)
     {
         LOG(Info, "ShadersGenerateDebugData option has been modified.");
         invalidateShaders = true;
@@ -217,6 +264,12 @@ void CookAssetsStep::CacheData::Load(CookingData& data)
 #endif
     if (invalidateShaders)
         InvalidateShaders();
+
+    // Invalidate textures if streaming settings gets modified
+    if (Settings.Global.StreamingSettingsAssetId != gameSettings->Streaming || (Entries.ContainsKey(gameSettings->Streaming) && !Entries[gameSettings->Streaming].IsValid()))
+    {
+        InvalidateTextures();
+    }
 }
 
 void CookAssetsStep::CacheData::Save()
@@ -453,6 +506,14 @@ bool ProcessShaderBase(CookAssetsStep::AssetCookData& data, ShaderAssetBase* ass
         COMPILE_PROFILE(Vulkan_SM5, SHADER_FILE_CHUNK_INTERNAL_VULKAN_SM5_CACHE);
         break;
     }
+#endif
+#if PLATFORM_TOOLS_SWITCH
+    case BuildPlatform::Switch:
+    {
+        const char* platformDefineName = "PLATFORM_SWITCH";
+        COMPILE_PROFILE(Vulkan_SM5, SHADER_FILE_CHUNK_INTERNAL_VULKAN_SM5_CACHE);
+        break;
+    }
 #endif
     default:
     {
@@ -532,91 +593,129 @@ bool ProcessParticleEmitter(CookAssetsStep::AssetCookData& data)
 bool ProcessTextureBase(CookAssetsStep::AssetCookData& data)
 {
     const auto asset = static_cast<TextureBase*>(data.Asset);
-
+    const auto& assetHeader = asset->StreamingTexture()->GetHeader();
-    // Check if target platform doesn't support the texture format
     const auto format = asset->Format();
     const auto targetFormat = data.Data.Tools->GetTextureFormat(data.Data, asset, format);
+    const auto streamingSettings = StreamingSettings::Get();
+    int32 mipLevelsMax = GPU_MAX_TEXTURE_MIP_LEVELS;
+    if (assetHeader->TextureGroup >= 0 && assetHeader->TextureGroup < streamingSettings->TextureGroups.Count())
+    {
+        auto& group = streamingSettings->TextureGroups[assetHeader->TextureGroup];
+        mipLevelsMax = group.MipLevelsMax;
+        group.MipLevelsMaxPerPlatform.TryGet(data.Data.Tools->GetPlatform(), mipLevelsMax);
+    }
+
+    // Faster path if don't need to modify texture for the target platform
+    if (format == targetFormat && assetHeader->MipLevels <= mipLevelsMax)
+    {
+        return CookAssetsStep::ProcessDefaultAsset(data);
+    }
+
+    // Extract texture data from the asset
+    TextureData textureDataSrc;
+    auto assetLock = asset->LockData();
+    if (asset->GetTextureData(textureDataSrc, false))
+    {
+        LOG(Error, "Failed to load data from texture {0}", asset->ToString());
+        return true;
+    }
+
+    TextureData* textureData = &textureDataSrc;
+    TextureData textureDataTmp1;
+
     if (format != targetFormat)
     {
-        // Extract texture data from the asset
-        TextureData textureData;
-        auto assetLock = asset->LockData();
-        if (asset->GetTextureData(textureData, false))
-        {
-            LOG(Error, "Failed to load data from texture {0}", asset->ToString());
-            return true;
-        }
-
         // Convert texture data to the target format
-        TextureData targetTextureData;
+        if (TextureTool::Convert(textureDataTmp1, *textureData, targetFormat))
-        if (TextureTool::Convert(targetTextureData, textureData, targetFormat))
         {
             LOG(Error, "Failed to convert texture {0} from format {1} to {2}", asset->ToString(), (int32)format, (int32)targetFormat);
             return true;
         }
-
+        textureData = &textureDataTmp1;
-        // Adjust texture header
-        auto& header = *(TextureHeader*)data.InitData.CustomData.Get();
-        header.Width = targetTextureData.Width;
-        header.Height = targetTextureData.Height;
-        header.Format = targetTextureData.Format;
-        header.MipLevels = targetTextureData.GetMipLevels();
-
-        // Serialize texture data into the asset chunks
-        for (int32 mipIndex = 0; mipIndex < targetTextureData.GetMipLevels(); mipIndex++)
-        {
-            auto chunk = New<FlaxChunk>();
-            data.InitData.Header.Chunks[mipIndex] = chunk;
-
-            // Calculate the texture data storage layout
-            uint32 rowPitch, slicePitch;
-            const int32 mipWidth = Math::Max(1, targetTextureData.Width >> mipIndex);
-            const int32 mipHeight = Math::Max(1, targetTextureData.Height >> mipIndex);
-            RenderTools::ComputePitch(targetTextureData.Format, mipWidth, mipHeight, rowPitch, slicePitch);
-            chunk->Data.Allocate(slicePitch * targetTextureData.GetArraySize());
-
-            // Copy array slices into mip data (sequential)
-            for (int32 arrayIndex = 0; arrayIndex < targetTextureData.Items.Count(); arrayIndex++)
-            {
-                auto& mipData = targetTextureData.Items[arrayIndex].Mips[mipIndex];
-                byte* src = mipData.Data.Get();
-                byte* dst = chunk->Data.Get() + (slicePitch * arrayIndex);
-
-                // Faster path if source and destination data layout matches
-                if (rowPitch == mipData.RowPitch && slicePitch == mipData.DepthPitch)
-                {
-                    Platform::MemoryCopy(dst, src, slicePitch);
-                }
-                else
-                {
-                    const auto copyRowSize = Math::Min(mipData.RowPitch, rowPitch);
-                    for (uint32 line = 0; line < mipData.Lines; line++)
-                    {
-                        Platform::MemoryCopy(dst, src, copyRowSize);
-                        src += mipData.RowPitch;
-                        dst += rowPitch;
-                    }
-                }
-            }
-        }
-
-        // Clone any custom asset chunks (eg. sprite atlas data, mips are in 0-13 chunks)
-        for (int32 i = 14; i < ASSET_FILE_DATA_CHUNKS; i++)
-        {
-            const auto chunk = asset->GetChunk(i);
-            if (chunk != nullptr && chunk->IsMissing() && chunk->ExistsInFile())
-            {
-                if (asset->Storage->LoadAssetChunk(chunk))
-                    return true;
-                data.InitData.Header.Chunks[i] = chunk->Clone();
-            }
-        }
-
-        return false;
     }
 
-    // Fallback to the default asset processing
+    if (assetHeader->MipLevels > mipLevelsMax)
-    return CookAssetsStep::ProcessDefaultAsset(data);
+    {
+        // Reduce texture quality
+        const int32 mipLevelsToStrip = assetHeader->MipLevels - mipLevelsMax;
+        textureData->Width = Math::Max(1, textureData->Width >> mipLevelsToStrip);
+        textureData->Height = Math::Max(1, textureData->Height >> mipLevelsToStrip);
+        textureData->Depth = Math::Max(1, textureData->Depth >> mipLevelsToStrip);
+        for (int32 arrayIndex = 0; arrayIndex < textureData->Items.Count(); arrayIndex++)
+        {
+            auto& item = textureData->Items[arrayIndex];
+            Array<TextureMipData, FixedAllocation<GPU_MAX_TEXTURE_MIP_LEVELS>> oldMips(MoveTemp(item.Mips));
+            item.Mips.Resize(mipLevelsMax);
+            for (int32 mipIndex = 0; mipIndex < mipLevelsMax; mipIndex++)
+            {
+                auto& dstMip = item.Mips[mipIndex];
+                auto& srcMip = oldMips[mipIndex + mipLevelsToStrip];
+                dstMip = MoveTemp(srcMip);
+            }
+        }
+    }
+
+    // Adjust texture header
+    data.InitData.CustomData.Allocate(sizeof(TextureHeader));
+    auto& header = *(TextureHeader*)data.InitData.CustomData.Get();
+    header = *assetHeader;
+    header.Width = textureData->Width;
+    header.Height = textureData->Height;
+    header.Depth = textureData->Depth;
+    header.Format = textureData->Format;
+    header.MipLevels = textureData->GetMipLevels();
+
+    // Serialize texture data into the asset chunks
+    for (int32 mipIndex = 0; mipIndex < header.MipLevels; mipIndex++)
+    {
+        auto chunk = New<FlaxChunk>();
+        data.InitData.Header.Chunks[mipIndex] = chunk;
+
+        // Calculate the texture data storage layout
+        uint32 rowPitch, slicePitch;
+        const int32 mipWidth = Math::Max(1, textureData->Width >> mipIndex);
+        const int32 mipHeight = Math::Max(1, textureData->Height >> mipIndex);
+        RenderTools::ComputePitch(textureData->Format, mipWidth, mipHeight, rowPitch, slicePitch);
+        chunk->Data.Allocate(slicePitch * textureData->GetArraySize());
+
+        // Copy array slices into mip data (sequential)
+        for (int32 arrayIndex = 0; arrayIndex < textureData->Items.Count(); arrayIndex++)
+        {
+            auto& mipData = textureData->Items[arrayIndex].Mips[mipIndex];
+            byte* src = mipData.Data.Get();
+            byte* dst = chunk->Data.Get() + (slicePitch * arrayIndex);
+
+            // Faster path if source and destination data layout matches
+            if (rowPitch == mipData.RowPitch && slicePitch == mipData.DepthPitch)
+            {
+                Platform::MemoryCopy(dst, src, slicePitch);
+            }
+            else
+            {
+                const auto copyRowSize = Math::Min(mipData.RowPitch, rowPitch);
+                for (uint32 line = 0; line < mipData.Lines; line++)
+                {
+                    Platform::MemoryCopy(dst, src, copyRowSize);
+                    src += mipData.RowPitch;
+                    dst += rowPitch;
+                }
+            }
+        }
+    }
+
+    // Clone any custom asset chunks (eg. sprite atlas data, mips are in 0-13 chunks)
+    for (int32 i = 14; i < ASSET_FILE_DATA_CHUNKS; i++)
+    {
+        const auto chunk = asset->GetChunk(i);
+        if (chunk != nullptr && chunk->IsMissing() && chunk->ExistsInFile())
+        {
+            if (asset->Storage->LoadAssetChunk(chunk))
+                return true;
+            data.InitData.Header.Chunks[i] = chunk->Clone();
+        }
+    }
+
+    return false;
 }
 
 CookAssetsStep::CookAssetsStep()
@@ -861,7 +960,7 @@ public:
         // Create package
         // Note: FlaxStorage::Create overrides chunks locations in file so don't use files anymore (only readonly)
         const String localPath = String::Format(TEXT("Content/Data_{0}.{1}"), _packageIndex, PACKAGE_FILES_EXTENSION);
-        const String path = data.OutputPath / localPath;
+        const String path = data.DataOutputPath / localPath;
         if (FlaxStorage::Create(path, assetsData, false, &CustomData))
         {
             data.Error(TEXT("Failed to create assets package."));
@@ -929,6 +1028,7 @@ bool CookAssetsStep::Perform(CookingData& data)
     {
         cache.Settings.Global.ShadersNoOptimize = buildSettings->ShadersNoOptimize;
         cache.Settings.Global.ShadersGenerateDebugData = buildSettings->ShadersGenerateDebugData;
+        cache.Settings.Global.StreamingSettingsAssetId = gameSettings->Streaming;
     }
 
     // Note: this step converts all the assets (even the json) into the binary files (FlaxStorage format).
@@ -1027,7 +1127,7 @@ bool CookAssetsStep::Perform(CookingData& data)
             gameFlags |= GameHeaderFlags::ShowSplashScreen;
 
         // Open file
-        auto stream = FileWriteStream::Open(data.OutputPath / TEXT("Content/head"));
+        auto stream = FileWriteStream::Open(data.DataOutputPath / TEXT("Content/head"));
         if (stream == nullptr)
         {
             data.Error(TEXT("Failed to create game data file."));
@@ -1121,7 +1221,7 @@ bool CookAssetsStep::Perform(CookingData& data)
     BUILD_STEP_CANCEL_CHECK;
 
     // Save assets cache
-    if (AssetsCache::Save(data.OutputPath / TEXT("Content/AssetsCache.dat"), AssetsRegistry, AssetPathsMapping, AssetsCacheFlags::RelativePaths))
+    if (AssetsCache::Save(data.DataOutputPath / TEXT("Content/AssetsCache.dat"), AssetsRegistry, AssetPathsMapping, AssetsCacheFlags::RelativePaths))
     {
         data.Error(TEXT("Failed to create assets registry."));
         return true;

Source/Editor/Cooker/Steps/CookAssetsStep.h

@@ -49,6 +49,8 @@ public:
         /// The list of files on which this entry depends on. Cached date is the last edit time used to discard cache result on modification.
         /// </summary>
         FileDependenciesList FileDependencies;
+
+        bool IsValid(bool withDependencies = false);
     };
 
     /// <summary>
@@ -93,6 +95,7 @@ public:
             {
                 bool ShadersNoOptimize;
                 bool ShadersGenerateDebugData;
+                Guid StreamingSettingsAssetId;
             } Global;
         } Settings;
 
@@ -134,6 +137,11 @@ public:
         /// </summary>
         void InvalidateShaders();
 
+        /// <summary>
+        /// Removes all cached entries for assets that contain a texture. This forces rebuild for them.
+        /// </summary>
+        void InvalidateTextures();
+
         /// <summary>
         /// Loads the cache for the given cooking data.
         /// </summary>

Source/Editor/Cooker/Steps/DeployDataStep.cpp

@@ -7,6 +7,7 @@
 #include "Engine/Core/Config/GameSettings.h"
 #include "Engine/Renderer/ReflectionsPass.h"
 #include "Engine/Renderer/AntiAliasing/SMAA.h"
+#include "Engine/Engine/Globals.h"
 
 bool DeployDataStep::Perform(CookingData& data)
 {
@@ -15,7 +16,7 @@ bool DeployDataStep::Perform(CookingData& data)
     const auto gameSettings = GameSettings::Get();
 
     // Setup output folders and copy required data
-    const auto contentDir = data.OutputPath / TEXT("Content");
+    const auto contentDir = data.DataOutputPath / TEXT("Content");
     if (FileSystem::DirectoryExists(contentDir))
     {
         // Remove old content files
@@ -26,7 +27,7 @@ bool DeployDataStep::Perform(CookingData& data)
     }
     FileSystem::CreateDirectory(contentDir);
     const auto srcMono = depsRoot / TEXT("Mono");
-    const auto dstMono = data.OutputPath / TEXT("Mono");
+    const auto dstMono = data.DataOutputPath / TEXT("Mono");
     if (!FileSystem::DirectoryExists(dstMono))
     {
         if (!FileSystem::DirectoryExists(srcMono))
@@ -100,6 +101,10 @@ bool DeployDataStep::Perform(CookingData& data)
     if (data.Configuration != BuildConfiguration::Release)
         data.AddRootEngineAsset(TEXT("Editor/Fonts/Roboto-Regular"));
 
+    // Register custom assets (eg. plugins)
+    data.StepProgress(TEXT("Deploying custom data"), 30);
+    GameCooker::OnCollectAssets(data.RootAssets);
+
     // Register game assets
     data.StepProgress(TEXT("Deploying game data"), 50);
     auto& buildSettings = *BuildSettings::Get();

Source/Editor/Cooker/Steps/PrecompileAssembliesStep.cpp

@@ -24,7 +24,7 @@ bool PrecompileAssembliesStep::Perform(CookingData& data)
     data.Tools->OnConfigureAOT(data, config);
 
     // Prepare output directory
-    config.AotCachePath = data.OutputPath / TEXT("Mono/lib/mono/aot-cache");
+    config.AotCachePath = data.DataOutputPath / TEXT("Mono/lib/mono/aot-cache");
     switch (data.Tools->GetArchitecture())
     {
     case ArchitectureType::x86:
@@ -52,9 +52,9 @@ bool PrecompileAssembliesStep::Perform(CookingData& data)
         FileSystem::DirectoryGetFiles(config.Assemblies, dir, TEXT("*.dll"), DirectorySearchOption::TopDirectoryOnly);
     for (auto& binaryModule : data.BinaryModules)
         if (binaryModule.ManagedPath.HasChars())
-            config.Assemblies.Add(data.OutputPath / binaryModule.ManagedPath);
+            config.Assemblies.Add(data.ManagedCodeOutputPath / binaryModule.ManagedPath);
     // TODO: move AOT to Flax.Build and perform it on all C# assemblies used in target build
-    config.Assemblies.Add(data.OutputPath / TEXT("Newtonsoft.Json.dll"));
+    config.Assemblies.Add(data.ManagedCodeOutputPath / TEXT("Newtonsoft.Json.dll"));
 
     // Perform AOT for the assemblies
     for (int32 i = 0; i < config.Assemblies.Count(); i++)

Source/Editor/Cooker/Steps/ValidateStep.cpp

@@ -11,21 +11,25 @@ bool ValidateStep::Perform(CookingData& data)
     data.StepProgress(TEXT("Performing validation"), 0);
 
     // Ensure output and cache directories exist
-    if (!FileSystem::DirectoryExists(data.OutputPath))
+    if (!FileSystem::DirectoryExists(data.NativeCodeOutputPath) && FileSystem::CreateDirectory(data.NativeCodeOutputPath))
     {
-        if (FileSystem::CreateDirectory(data.OutputPath))
+        data.Error(TEXT("Failed to create build output directory."));
-        {
+        return true;
-            data.Error(TEXT("Failed to create build output directory."));
-            return true;
-        }
     }
-    if (!FileSystem::DirectoryExists(data.CacheDirectory))
+    if (!FileSystem::DirectoryExists(data.ManagedCodeOutputPath) && FileSystem::CreateDirectory(data.ManagedCodeOutputPath))
     {
-        if (FileSystem::CreateDirectory(data.CacheDirectory))
+        data.Error(TEXT("Failed to create build output directory."));
-        {
+        return true;
-            data.Error(TEXT("Failed to create build cache directory."));
+    }
-            return true;
+    if (!FileSystem::DirectoryExists(data.DataOutputPath) && FileSystem::CreateDirectory(data.DataOutputPath))
-        }
+    {
+        data.Error(TEXT("Failed to create build output directory."));
+        return true;
+    }
+    if (!FileSystem::DirectoryExists(data.CacheDirectory) && FileSystem::CreateDirectory(data.CacheDirectory))
+    {
+        data.Error(TEXT("Failed to create build cache directory."));
+        return true;
     }
 
 #if OFFICIAL_BUILD

Source/Editor/CustomEditors/CustomEditor.cs

@@ -101,11 +101,6 @@ namespace FlaxEditor.CustomEditors
         /// </summary>
         protected bool IsSetBlocked => _isSetBlocked;
 
-        /// <summary>
-        /// Gets a value indicating whether this editor needs value propagation up (value synchronization when one of the child editors changes value, used by the struct types).
-        /// </summary>
-        protected virtual bool NeedsValuePropagationUp => Values.HasValueType;
-
         /// <summary>
         /// The linked label used to show this custom editor. Can be null if not used (eg. editor is inlined or is using a very customized UI layout).
         /// </summary>
@@ -142,6 +137,10 @@ namespace FlaxEditor.CustomEditors
         /// </summary>
         public void RebuildLayout()
         {
+            // Skip rebuilding during init
+            if (CurrentCustomEditor == this)
+                return;
+
             // Special case for root objects to run normal layout build
             if (_presenter.Selection == Values)
             {
@@ -250,6 +249,15 @@ namespace FlaxEditor.CustomEditors
                 _children[i].RefreshInternal();
         }
 
+        /// <summary>
+        /// Synchronizes the value of the <see cref="Values"/> container. Called during Refresh to flush property after editing it in UI.
+        /// </summary>
+        /// <param name="value">The value to set.</param>
+        protected virtual void SynchronizeValue(object value)
+        {
+            _values.Set(_parent.Values, value);
+        }
+
         internal virtual void RefreshInternal()
         {
             if (_values == null)
@@ -264,11 +272,11 @@ namespace FlaxEditor.CustomEditors
                 _valueToSet = null;
 
                 // Assign value
-                _values.Set(_parent.Values, val);
+                SynchronizeValue(val);
 
                 // Propagate values up (eg. when member of structure gets modified, also structure should be updated as a part of the other object)
                 var obj = _parent;
-                while (obj._parent != null && !(obj._parent is SyncPointEditor)) // && obj.NeedsValuePropagationUp)
+                while (obj._parent != null && !(obj._parent is SyncPointEditor))
                 {
                     obj.Values.Set(obj._parent.Values, obj.Values);
                     obj = obj._parent;
@@ -288,12 +296,15 @@ namespace FlaxEditor.CustomEditors
             _isSetBlocked = false;
 
             // Update children
+            if (_skipChildrenRefresh)
+            {
+                _skipChildrenRefresh = false;
+                return;
+            }
             try
             {
-                var childrenCount = _skipChildrenRefresh ? 0 : _children.Count;
+                for (int i = 0; i < _children.Count; i++)
-                for (int i = 0; i < childrenCount; i++)
                     _children[i].RefreshInternal();
-                _skipChildrenRefresh = false;
             }
             catch (TargetException ex)
             {
@@ -780,12 +791,11 @@ namespace FlaxEditor.CustomEditors
         /// <returns>True if allow to handle this event, otherwise false.</returns>
         protected virtual bool OnDirty(CustomEditor editor, object value, object token = null)
         {
-            ParentEditor.OnDirty(editor, value, token);
+            return ParentEditor.OnDirty(editor, value, token);
-            return true;
         }
 
         /// <summary>
-        /// Called when custom editor sets the value to the object and resets the dirty state. Can be sued to perform custom work after editing the target object.
+        /// Called when custom editor sets the value to the object and resets the dirty state. Can be used to perform custom work after editing the target object.
         /// </summary>
         protected virtual void OnUnDirty()
         {