Fix compilation with MSVC 140 tools

#576

.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 curl libtool libtool-bin libpulse-dev libasound2-dev libjack-dev portaudio19-dev libcurl4-gnutls-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

CONTRIBUTING.md

@@ -32,3 +32,19 @@ Go check out our [Trello](https://trello.com/b/NQjLXRCP/flax-roadmap).
 
 
 Thank you for taking interest in contributing to Flax!
+
+## **Common issues**
+
+Below are some common issues that someone working with the FlaxEngine source code might run into. Hopefully some of those issues will get fixed in the future. If you know how, please contribute!
+
+* Missing MSVC toolset
+  * Install it through the Visual Studio Installer
+* Building or attaching fails
+  * Run `GenerateProjectFiles.bat`
+  * Rebuild `Flax.Build`
+  * Make sure that there isn't a stray FlaxEngine process running in the background
+  * First start Flax and then attach the C# debugger
+  * Configure the C# FlaxEngine project by going into the project properties, then the debug tab and selecting "Start external program" `Flax\FlaxEngine\Binaries\Editor\Win64\Debug\FlaxEditor.exe`
+    * Then you can also set command line arguments such as `-project "C:\Users\PROFILE\Documents\Flax Projects\FlaxSamples\BasicTemplate"`
+* Git LFS
+  * Push with `git push --no-verify`

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,
-    "Build": 6217
+    "Minor": 2,
+    "Build": 6222
   },
   "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,12 +42,22 @@ 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
 * Install Mono ([https://www.mono-project.com/download/stable](https://www.mono-project.com/download/stable))
 * Install Git with LFS
-* Install requried packages: `sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev nuget autoconf libogg-dev automake build-essential gettext cmake python curl libtool libtool-bin libpulse-dev libasound2-dev libjack-dev portaudio19-dev libcurl4-gnutls-dev`
+* Install requried packages: `sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev nuget autoconf libogg-dev automake build-essential gettext cmake python libtool libtool-bin libpulse-dev libasound2-dev libjack-dev portaudio19-dev`
 * Install compiler `sudo apt-get install clang lldb lld` (Clang 6 or newer)
 * Clone repo (with LFS)
 * Run `./GenerateProjectFiles.sh`

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/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,
-
-            /// <summary>
-            /// The build settings.
-            /// </summary>
+            LocalizationSettings,
             BuildSettings,
-
-            /// <summary>
-            /// The input settings.
-            /// </summary>
             InputSettings,
-
-            /// <summary>
-            /// The Windows settings.
-            /// </summary>
+            StreamingSettings,
             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>
-        /// The create options.
-        /// </summary>
-        public class Options
+        internal 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/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.IsBinaryAsset ? new AssetImportEntry(ref request) : new ImportFileEntry(ref request);
+            return request.IsInBuilt ? 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")]
-        public bool CalculateTangents { get; set; } = true;
+        [EditorOrder(40), DefaultValue(false), EditorDisplay("Geometry"), Tooltip("Enable model tangent vectors recalculating")]
+        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;
-    header.Width = ASSETS_ICONS_ATLAS_SIZE;
-    header.Height = ASSETS_ICONS_ATLAS_SIZE;
-    header.Format = ASSETS_ICONS_ATLAS_FORMAT;
-    header.IsSRGB = false;
-    header.IsCubeMap = false;
-    header.MipLevels = 1;
-    header.NeverStream = true;
-    header.Type = TextureFormatType::Unknown;
-    context.Data.CustomData.Copy(&header);
+    TextureHeader textureHeader;
+    textureHeader.Width = ASSETS_ICONS_ATLAS_SIZE;
+    textureHeader.Height = ASSETS_ICONS_ATLAS_SIZE;
+    textureHeader.Format = ASSETS_ICONS_ATLAS_FORMAT;
+    textureHeader.MipLevels = 1;
+    textureHeader.NeverStream = true;
+    context.Data.CustomData.Copy(&textureHeader);
 
     // 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

@@ -7,6 +7,7 @@
 #include "Engine/Core/Collections/Array.h"
 #include "Engine/Core/Collections/HashSet.h"
 #include "Engine/Core/Collections/Dictionary.h"
+#include "Engine/Core/Types/Guid.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)
-{
-    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("?");
-    }
-}
+extern FLAXENGINE_API const Char* ToString(const BuildPlatform platform);
 
 /// <summary>
 /// Game build configuration modes.
@@ -137,20 +118,7 @@ API_ENUM() enum class BuildConfiguration
     Release = 2,
 };
 
-inline 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("?");
-    }
-}
+extern FLAXENGINE_API const Char* ToString(const BuildConfiguration configuration);
 
 #define BUILD_STEP_CANCEL_CHECK if (GameCooker::IsCancelRequested()) return true
 
@@ -185,9 +153,19 @@ struct FLAXENGINE_API CookingData
     String OriginalOutputPath;
 
     /// <summary>
-    /// The output path.
+    /// The output path for data files (Content, Mono, etc.).
     /// </summary>
-    String OutputPath;
+    String DataOutputPath;
+
+    /// <summary>
+    /// The output path for binaries (native executable and native code libraries).
+    /// </summary>
+    String NativeCodeOutputPath;
+
+    /// <summary>
+    /// The output path for binaries (C# code libraries).
+    /// </summary>
+    String ManagedCodeOutputPath;
 
     /// <summary>
     /// The platform tools.

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;
@@ -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
 {
@@ -250,6 +301,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);
@@ -282,9 +338,10 @@ void GameCooker::Build(BuildPlatform platform, BuildConfiguration configuration,
     data.Configuration = configuration;
     data.Options = options;
     data.CustomDefines = customDefines;
-    data.OutputPath = outputPath;
-    FileSystem::NormalizePath(data.OutputPath);
-    data.OutputPath = data.OriginalOutputPath = FileSystem::ConvertRelativePathToAbsolute(Globals::ProjectFolder, data.OutputPath);
+    data.OriginalOutputPath = outputPath;
+    FileSystem::NormalizePath(data.OriginalOutputPath);
+    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 +419,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;
     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())
@@ -458,6 +542,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.Reflection;
-using System.Runtime.CompilerServices;
+using System.Collections.Generic;
 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

@@ -61,13 +61,11 @@ public:
     /// <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>
@@ -123,4 +121,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."));
@@ -43,7 +43,7 @@ bool UWPPlatformTools::OnDeployBinaries(CookingData& data)
     const auto uwpDataPath = platformDataPath / (isXboxOne ? TEXT("XboxOne") : TEXT("UWP")) / TEXT("Binaries");
     const auto gameSettings = GameSettings::Get();
     const auto platformSettings = UWPPlatformSettings::Get();
-    Array<byte> fileTemplate;
+    StringAnsi fileTemplate;
 
     // Copy binaries
     const auto binPath = data.GetGameBinariesPath();
@@ -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))
@@ -149,12 +149,11 @@ bool UWPPlatformTools::OnDeployBinaries(CookingData& data)
     if (!FileSystem::FileExists(dstAssemblyInfoPath))
     {
         // Get template
-        if (File::ReadAllBytes(srcAssemblyInfoPath, fileTemplate))
+        if (File::ReadAllText(srcAssemblyInfoPath, fileTemplate))
         {
             data.Error(TEXT("Failed to load AssemblyInfo.cs template."));
             return true;
         }
-        fileTemplate[fileTemplate.Count() - 1] = 0;
 
         // Write data to file
         auto file = FileWriteStream::Open(dstAssemblyInfoPath);
@@ -163,7 +162,7 @@ bool UWPPlatformTools::OnDeployBinaries(CookingData& data)
         {
             auto now = DateTime::Now();
             file->WriteTextFormatted(
-                (char*)fileTemplate.Get()
+                fileTemplate.Get()
                 , gameSettings->ProductName.ToStringAnsi()
                 , gameSettings->CompanyName.ToStringAnsi()
                 , now.GetYear()
@@ -177,17 +176,16 @@ 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))
     {
         // Get template
-        if (File::ReadAllBytes(srcAppPath, fileTemplate))
+        if (File::ReadAllText(srcAppPath, fileTemplate))
         {
             data.Error(TEXT("Failed to load App.cs template."));
             return true;
         }
-        fileTemplate[fileTemplate.Count() - 1] = 0;
 
         // Write data to file
         auto file = FileWriteStream::Open(dstAppPath);
@@ -195,7 +193,7 @@ bool UWPPlatformTools::OnDeployBinaries(CookingData& data)
         if (file)
         {
             file->WriteTextFormatted(
-                (char*)fileTemplate.Get()
+                fileTemplate.Get()
                 , defaultNamespace.ToStringAnsi() // {0} Default Namespace
             );
             hasError = file->HasError();
@@ -207,16 +205,15 @@ 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
-        if (File::ReadAllBytes(srcFlaxGeneratedPath, fileTemplate))
+        if (File::ReadAllText(srcFlaxGeneratedPath, fileTemplate))
         {
             data.Error(TEXT("Failed to load FlaxGenerated.cs template."));
             return true;
         }
-        fileTemplate[fileTemplate.Count() - 1] = 0;
 
         // Prepare
         StringAnsi autoRotationPreferences;
@@ -252,7 +249,7 @@ bool UWPPlatformTools::OnDeployBinaries(CookingData& data)
         if (file)
         {
             file->WriteTextFormatted(
-                (char*)fileTemplate.Get()
+                fileTemplate.Get()
                 , autoRotationPreferences.Get()
                 , preferredLaunchWindowingMode.Get()
             );
@@ -267,17 +264,16 @@ 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))
     {
         // Get template
-        if (File::ReadAllBytes(srcSolutionPath, fileTemplate))
+        if (File::ReadAllText(srcSolutionPath, fileTemplate))
         {
             data.Error(TEXT("Failed to load Solution.sln template."));
             return true;
         }
-        fileTemplate[fileTemplate.Count() - 1] = 0;
 
         // Write data to file
         auto file = FileWriteStream::Open(dstSolutionPath);
@@ -285,7 +281,7 @@ bool UWPPlatformTools::OnDeployBinaries(CookingData& data)
         if (file)
         {
             file->WriteTextFormatted(
-                (char*)fileTemplate.Get()
+                fileTemplate.Get()
                 , projectName.ToStringAnsi() // {0} Project Name
                 , mode // {1} Platform Mode
                 , projectGuid.ToStringAnsi() // {2} Project ID
@@ -301,16 +297,15 @@ 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
-        if (File::ReadAllBytes(srcProjectPath, fileTemplate))
+        if (File::ReadAllText(srcProjectPath, fileTemplate))
         {
             data.Error(TEXT("Failed to load Project.csproj template."));
             return true;
         }
-        fileTemplate[fileTemplate.Count() - 1] = 0;
 
         // Build included files data
         StringBuilder filesInclude(2048);
@@ -334,7 +329,7 @@ bool UWPPlatformTools::OnDeployBinaries(CookingData& data)
         if (file)
         {
             file->WriteTextFormatted(
-                (char*)fileTemplate.Get()
+                fileTemplate.Get()
                 , projectName.ToStringAnsi() // {0} Project Name
                 , mode // {1} Platform Mode
                 , projectGuid.Get() // {2} Project ID
@@ -352,17 +347,16 @@ 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))
     {
         // Get template
-        if (File::ReadAllBytes(srcManifestPath, fileTemplate))
+        if (File::ReadAllText(srcManifestPath, fileTemplate))
         {
             data.Error(TEXT("Failed to load Package.appxmanifest template."));
             return true;
         }
-        fileTemplate[fileTemplate.Count() - 1] = 0;
 
         // Build included files data
         StringBuilder filesInclude(2048);
@@ -385,7 +379,7 @@ bool UWPPlatformTools::OnDeployBinaries(CookingData& data)
         if (file)
         {
             file->WriteTextFormatted(
-                (char*)fileTemplate.Get()
+                fileTemplate.Get()
                 , projectName.ToStringAnsi() // {0} Display Name
                 , gameSettings->CompanyName.ToStringAnsi() // {1} Company Name
                 , productId.ToStringAnsi() // {2} Product ID
@@ -490,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 auto dstPath1 = data.OutputPath / TEXT("DataSecondary");
+    const String assembliesPath = data.DataOutputPath;
+    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");
-            AssembliesSearchDirs.Add(data.OutputPath / TEXT("Mono/lib/mono/4.5"));
+            EnvVars[TEXT("MONO_PATH")] = data.DataOutputPath / 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();
-    const bool shadersNoOptimize = buildSettings->ShadersNoOptimize;
-    const bool shadersGenerateDebugData = buildSettings->ShadersGenerateDebugData;
-    if (shadersNoOptimize != Settings.Global.ShadersNoOptimize)
+    if (buildSettings->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);
-
-    // Check if target platform doesn't support the texture format
+    const auto& assetHeader = asset->StreamingTexture()->GetHeader();
     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(targetTextureData, textureData, targetFormat))
+        if (TextureTool::Convert(textureDataTmp1, *textureData, targetFormat))
         {
             LOG(Error, "Failed to convert texture {0} from format {1} to {2}", asset->ToString(), (int32)format, (int32)targetFormat);
             return true;
         }
-
-        // 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;
+        textureData = &textureDataTmp1;
     }
 
-    // Fallback to the default asset processing
-    return CookAssetsStep::ProcessDefaultAsset(data);
+    if (assetHeader->MipLevels > mipLevelsMax)
+    {
+        // 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 cache directory."));
-            return true;
-        }
+        data.Error(TEXT("Failed to create build output 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

@@ -142,6 +142,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 +254,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,7 +277,7 @@ 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;
@@ -780,12 +793,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 true;
+            return ParentEditor.OnDirty(editor, value, token);
         }
 
         /// <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()
         {

Source/Editor/CustomEditors/CustomEditorPresenter.cs

@@ -139,7 +139,7 @@ namespace FlaxEditor.CustomEditors
             /// <inheritdoc />
             protected override void OnModified()
             {
-                Presenter.Modified?.Invoke();
+                Presenter.OnModified();
 
                 base.OnModified();
             }
@@ -354,6 +354,14 @@ namespace FlaxEditor.CustomEditors
             ExpandGroups(this, false);
         }
 
+        /// <summary>
+        /// Invokes <see cref="Modified"/> event.
+        /// </summary>
+        public void OnModified()
+        {
+            Modified?.Invoke();
+        }
+
         /// <summary>
         /// Called when selection gets changed.
         /// </summary>

Source/Editor/CustomEditors/CustomEditorsUtil.cpp

@@ -3,6 +3,7 @@
 #include "CustomEditorsUtil.h"
 #include "Engine/Core/Log.h"
 #include "Engine/Core/Types/DateTime.h"
+#include "Engine/Core/Types/TimeSpan.h"
 #include "Engine/Core/Collections/Dictionary.h"
 #include "Engine/Engine/EngineService.h"
 #include "Engine/Scripting/Scripting.h"