From fd4b9a5a9f18cdfa5c52aea56dd819431fb4be36 Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Fri, 16 Dec 2022 16:29:43 -0600
Subject: [PATCH 001/103] Return focus to parent on mouse leave.

---
 Source/Editor/Windows/GameWindow.cs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/Source/Editor/Windows/GameWindow.cs b/Source/Editor/Windows/GameWindow.cs
index 23558c396..89598265c 100644
--- a/Source/Editor/Windows/GameWindow.cs
+++ b/Source/Editor/Windows/GameWindow.cs
@@ -345,6 +345,13 @@ namespace FlaxEditor.Windows
             Cursor = CursorType.Default;
         }
 
+        /// <inheritdoc />
+        public override void OnMouseLeave()
+        {
+            Parent?.Focus();
+            base.OnMouseLeave();
+        }
+
         /// <inheritdoc />
         public override void OnShowContextMenu(ContextMenu menu)
         {

From 9a71e0274f5fef4e9282dea1a4e14f6db9372b6e Mon Sep 17 00:00:00 2001
From: Menotdan <32620310+Menotdan@users.noreply.github.com>
Date: Sat, 20 May 2023 00:03:40 -0400
Subject: [PATCH 002/103] Add required options for material instance importing.

---
 .../Editor/Content/Import/ModelImportEntry.cs | 21 +++++++++++++++++++
 .../Editor/Managed/ManagedEditor.Internal.cpp |  6 ++++++
 .../Tools/ModelTool/ModelTool.Options.cpp     |  4 ++++
 Source/Engine/Tools/ModelTool/ModelTool.h     |  3 +++
 4 files changed, 34 insertions(+)

diff --git a/Source/Editor/Content/Import/ModelImportEntry.cs b/Source/Editor/Content/Import/ModelImportEntry.cs
index b17c8314d..8bdd7264a 100644
--- a/Source/Editor/Content/Import/ModelImportEntry.cs
+++ b/Source/Editor/Content/Import/ModelImportEntry.cs
@@ -1,5 +1,6 @@
 // Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
 
+using System;
 using System.ComponentModel;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -316,6 +317,20 @@ namespace FlaxEditor.Content.Import
         [EditorOrder(400), DefaultValue(true)]
         public bool ImportMaterials { get; set; } = true;
 
+        /// <summary>
+        /// If checked, materials will be imported as instances of a base material.
+        /// </summary>
+        [EditorDisplay("Materials"), VisibleIf(nameof(ImportMaterials))]
+        [EditorOrder(405), DefaultValue(false)]
+        public bool ImportMaterialsAsInstances = false;
+
+        /// <summary>
+        /// The material to import the model's materials as an instance of.
+        /// </summary>
+        [EditorDisplay("Materials"), VisibleIf(nameof(ImportMaterialsAsInstances))]
+        [EditorOrder(406)]
+        public Material InstanceToImportAs = null; // TODO: only show if BOTH ImportMaterials and ImportMaterialsAsInstances are true.
+
         /// <summary>
         /// If checked, the importer will import texture files used by the model and any embedded texture resources.
         /// </summary>
@@ -406,6 +421,8 @@ namespace FlaxEditor.Content.Import
 
             // Misc
             public byte ImportMaterials;
+            public byte ImportMaterialsAsInstances;
+            public Guid InstanceToImportAs;
             public byte ImportTextures;
             public byte RestoreMaterialsOnReimport;
 
@@ -454,6 +471,8 @@ namespace FlaxEditor.Content.Import
                 LODCount = LODCount,
                 TriangleReduction = TriangleReduction,
                 ImportMaterials = (byte)(ImportMaterials ? 1 : 0),
+                ImportMaterialsAsInstances = (byte)(ImportMaterialsAsInstances ? 1 : 0),
+                InstanceToImportAs = InstanceToImportAs.ID,
                 ImportTextures = (byte)(ImportTextures ? 1 : 0),
                 RestoreMaterialsOnReimport = (byte)(RestoreMaterialsOnReimport ? 1 : 0),
                 GenerateSDF = (byte)(GenerateSDF ? 1 : 0),
@@ -496,6 +515,8 @@ namespace FlaxEditor.Content.Import
             LODCount = options.LODCount;
             TriangleReduction = options.TriangleReduction;
             ImportMaterials = options.ImportMaterials != 0;
+            ImportMaterialsAsInstances = options.ImportMaterialsAsInstances != 0;
+            InstanceToImportAs = FlaxEngine.Content.Load<Material>(options.InstanceToImportAs);
             ImportTextures = options.ImportTextures != 0;
             RestoreMaterialsOnReimport = options.RestoreMaterialsOnReimport != 0;
             GenerateSDF = options.GenerateSDF != 0;
diff --git a/Source/Editor/Managed/ManagedEditor.Internal.cpp b/Source/Editor/Managed/ManagedEditor.Internal.cpp
index dcaa25e6c..17708dab5 100644
--- a/Source/Editor/Managed/ManagedEditor.Internal.cpp
+++ b/Source/Editor/Managed/ManagedEditor.Internal.cpp
@@ -195,6 +195,8 @@ struct InternalModelOptions
 
     // Misc
     byte ImportMaterials;
+    byte ImportMaterialsAsInstances;
+    Guid InstanceToImportAs;
     byte ImportTextures;
     byte RestoreMaterialsOnReimport;
 
@@ -240,6 +242,8 @@ struct InternalModelOptions
         to->LODCount = from->LODCount;
         to->TriangleReduction = from->TriangleReduction;
         to->ImportMaterials = from->ImportMaterials;
+        to->ImportMaterialsAsInstances = from->ImportMaterialsAsInstances;
+        to->InstanceToImportAs = from->InstanceToImportAs;
         to->ImportTextures = from->ImportTextures;
         to->RestoreMaterialsOnReimport = from->RestoreMaterialsOnReimport;
         to->GenerateSDF = from->GenerateSDF;
@@ -282,6 +286,8 @@ struct InternalModelOptions
         to->LODCount = from->LODCount;
         to->TriangleReduction = from->TriangleReduction;
         to->ImportMaterials = from->ImportMaterials;
+        to->ImportMaterialsAsInstances = from->ImportMaterialsAsInstances;
+        to->InstanceToImportAs = from->InstanceToImportAs;
         to->ImportTextures = from->ImportTextures;
         to->RestoreMaterialsOnReimport = from->RestoreMaterialsOnReimport;
         to->GenerateSDF = from->GenerateSDF;
diff --git a/Source/Engine/Tools/ModelTool/ModelTool.Options.cpp b/Source/Engine/Tools/ModelTool/ModelTool.Options.cpp
index b7fb04855..7d1315a1f 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.Options.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.Options.cpp
@@ -61,6 +61,8 @@ void ModelTool::Options::Serialize(SerializeStream& stream, const void* otherObj
     SERIALIZE(LODCount);
     SERIALIZE(TriangleReduction);
     SERIALIZE(ImportMaterials);
+    SERIALIZE(ImportMaterialsAsInstances);
+    SERIALIZE(InstanceToImportAs);
     SERIALIZE(ImportTextures);
     SERIALIZE(RestoreMaterialsOnReimport);
     SERIALIZE(GenerateSDF);
@@ -102,6 +104,8 @@ void ModelTool::Options::Deserialize(DeserializeStream& stream, ISerializeModifi
     DESERIALIZE(LODCount);
     DESERIALIZE(TriangleReduction);
     DESERIALIZE(ImportMaterials);
+    DESERIALIZE(ImportMaterialsAsInstances);
+    DESERIALIZE(InstanceToImportAs);
     DESERIALIZE(ImportTextures);
     DESERIALIZE(RestoreMaterialsOnReimport);
     DESERIALIZE(GenerateSDF);
diff --git a/Source/Engine/Tools/ModelTool/ModelTool.h b/Source/Engine/Tools/ModelTool/ModelTool.h
index b29bed71f..cf6b15c3f 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.h
+++ b/Source/Engine/Tools/ModelTool/ModelTool.h
@@ -11,6 +11,7 @@
 #include "Engine/Graphics/Models/ModelData.h"
 #include "Engine/Graphics/Models/SkeletonData.h"
 #include "Engine/Animations/AnimationData.h"
+#include <Engine/Content/Assets/Material.h>
 
 class JsonWriter;
 
@@ -247,6 +248,8 @@ public:
 
         // Materials
         bool ImportMaterials = true;
+        bool ImportMaterialsAsInstances = false;
+        Guid InstanceToImportAs;
         bool ImportTextures = true;
         bool RestoreMaterialsOnReimport = true;
 

From 89ce2b087ec1b00852f56665a1720b45fa7fd0b6 Mon Sep 17 00:00:00 2001
From: Menotdan <32620310+Menotdan@users.noreply.github.com>
Date: Sat, 20 May 2023 00:13:45 -0400
Subject: [PATCH 003/103] Add parameter for AddMaterial() as an experiment,
 messing around with ideas.

---
 Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp b/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
index 1eb9e1f27..a4eebe830 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
@@ -207,7 +207,7 @@ struct OpenFbxImporterData
         return false;
     }
 
-    int32 AddMaterial(ImportedModelData& result, const ofbx::Material* mat)
+    int32 AddMaterial(ImportedModelData& result, const ofbx::Material* mat, const Material* instanceOf)
     {
         int32 index = Materials.Find(mat);
         if (index == -1)

From f03bb60d5bad400e0e67836d8d3e273c12d8de7f Mon Sep 17 00:00:00 2001
From: Menotdan <32620310+Menotdan@users.noreply.github.com>
Date: Sun, 21 May 2023 00:20:54 -0400
Subject: [PATCH 004/103] Figured out where I actually need to add code, and
 added code there.

---
 .../Tools/ModelTool/ModelTool.OpenFBX.cpp     |  3 +-
 Source/Engine/Tools/ModelTool/ModelTool.cpp   | 70 ++++++++++++++-----
 Source/ThirdParty/OpenFBX/ofbx.h              |  1 +
 3 files changed, 55 insertions(+), 19 deletions(-)

diff --git a/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp b/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
index a4eebe830..37b3f45a8 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
@@ -207,7 +207,7 @@ struct OpenFbxImporterData
         return false;
     }
 
-    int32 AddMaterial(ImportedModelData& result, const ofbx::Material* mat, const Material* instanceOf)
+    int32 AddMaterial(ImportedModelData& result, const ofbx::Material* mat)
     {
         int32 index = Materials.Find(mat);
         if (index == -1)
@@ -542,6 +542,7 @@ bool ProcessMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofb
         else
             aMaterial = aMesh->getMaterial(0);
     }
+
     mesh.MaterialSlotIndex = data.AddMaterial(result, aMaterial);
 
     // Vertex positions
diff --git a/Source/Engine/Tools/ModelTool/ModelTool.cpp b/Source/Engine/Tools/ModelTool/ModelTool.cpp
index 103d2187a..e15891a62 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.cpp
@@ -30,6 +30,7 @@
 #include "Engine/Tools/TextureTool/TextureTool.h"
 #include "Engine/ContentImporters/AssetsImportingManager.h"
 #include "Engine/ContentImporters/CreateMaterial.h"
+#include "Engine/ContentImporters/CreateMaterialInstance.h"
 #include "Engine/ContentImporters/CreateCollisionData.h"
 #include "Editor/Utilities/EditorUtilities.h"
 #include <ThirdParty/meshoptimizer/meshoptimizer.h>
@@ -862,24 +863,57 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
         importedFileNames.Add(filename);
 #if COMPILE_WITH_ASSETS_IMPORTER
         auto assetPath = autoImportOutput / filename + ASSET_FILES_EXTENSION_WITH_DOT;
-        CreateMaterial::Options materialOptions;
-        materialOptions.Diffuse.Color = material.Diffuse.Color;
-        if (material.Diffuse.TextureIndex != -1)
-            materialOptions.Diffuse.Texture = data.Textures[material.Diffuse.TextureIndex].AssetID;
-        materialOptions.Diffuse.HasAlphaMask = material.Diffuse.HasAlphaMask;
-        materialOptions.Emissive.Color = material.Emissive.Color;
-        if (material.Emissive.TextureIndex != -1)
-            materialOptions.Emissive.Texture = data.Textures[material.Emissive.TextureIndex].AssetID;
-        materialOptions.Opacity.Value = material.Opacity.Value;
-        if (material.Opacity.TextureIndex != -1)
-            materialOptions.Opacity.Texture = data.Textures[material.Opacity.TextureIndex].AssetID;
-        if (material.Normals.TextureIndex != -1)
-            materialOptions.Normals.Texture = data.Textures[material.Normals.TextureIndex].AssetID;
-        if (material.TwoSided || material.Diffuse.HasAlphaMask)
-            materialOptions.Info.CullMode = CullMode::TwoSided;
-        if (!Math::IsOne(material.Opacity.Value) || material.Opacity.TextureIndex != -1)
-            materialOptions.Info.BlendMode = MaterialBlendMode::Transparent;
-        AssetsImportingManager::Create(AssetsImportingManager::CreateMaterialTag, assetPath, material.AssetID, &materialOptions);
+        if (options.ImportMaterialsAsInstances) {
+            LOG(Warning, "Did work poggers");
+            if (AssetsImportingManager::Create(AssetsImportingManager::CreateMaterialInstanceTag, assetPath, material.AssetID))
+            {
+                LOG(Error, "Failed to create material instance.");
+                return true;
+            }
+            else
+            {
+                MaterialInstance* materialInstance = (MaterialInstance*) LoadAsset(material.AssetID, ScriptingTypeHandle());
+                if (materialInstance == nullptr)
+                {
+                    LOG(Error, "Failed to find created material instance.");
+                    return true;
+                }
+
+                MaterialBase *materialInstanceOf = (MaterialBase*) LoadAsset(options.InstanceToImportAs, ScriptingTypeHandle());
+                if (materialInstanceOf == nullptr)
+                {
+                    LOG(Error, "Failed to find the material to create an instance of.");
+                    return true;
+                }
+
+                materialInstance->SetBaseMaterial(materialInstanceOf);
+                if (materialInstance->Save())
+                {
+                    LOG(Error, "Failed to save the material instance.");
+                    return true;
+                }
+            }
+        }
+        else {
+            CreateMaterial::Options materialOptions;
+            materialOptions.Diffuse.Color = material.Diffuse.Color;
+            if (material.Diffuse.TextureIndex != -1)
+                materialOptions.Diffuse.Texture = data.Textures[material.Diffuse.TextureIndex].AssetID;
+            materialOptions.Diffuse.HasAlphaMask = material.Diffuse.HasAlphaMask;
+            materialOptions.Emissive.Color = material.Emissive.Color;
+            if (material.Emissive.TextureIndex != -1)
+                materialOptions.Emissive.Texture = data.Textures[material.Emissive.TextureIndex].AssetID;
+            materialOptions.Opacity.Value = material.Opacity.Value;
+            if (material.Opacity.TextureIndex != -1)
+                materialOptions.Opacity.Texture = data.Textures[material.Opacity.TextureIndex].AssetID;
+            if (material.Normals.TextureIndex != -1)
+                materialOptions.Normals.Texture = data.Textures[material.Normals.TextureIndex].AssetID;
+            if (material.TwoSided || material.Diffuse.HasAlphaMask)
+                materialOptions.Info.CullMode = CullMode::TwoSided;
+            if (!Math::IsOne(material.Opacity.Value) || material.Opacity.TextureIndex != -1)
+                materialOptions.Info.BlendMode = MaterialBlendMode::Transparent;
+            AssetsImportingManager::Create(AssetsImportingManager::CreateMaterialTag, assetPath, material.AssetID, &materialOptions);
+        }
 #endif
     }
 
diff --git a/Source/ThirdParty/OpenFBX/ofbx.h b/Source/ThirdParty/OpenFBX/ofbx.h
index 7066659e3..87dd5999f 100644
--- a/Source/ThirdParty/OpenFBX/ofbx.h
+++ b/Source/ThirdParty/OpenFBX/ofbx.h
@@ -1,4 +1,5 @@
 #pragma once
+#include <Engine/Core/Types/Guid.h>
 
 
 namespace ofbx

From 37fe1154a3a00e6259b14303b415a534e79e662c Mon Sep 17 00:00:00 2001
From: Menotdan <32620310+Menotdan@users.noreply.github.com>
Date: Mon, 22 May 2023 10:12:00 -0400
Subject: [PATCH 005/103] Importing as instances works now

---
 Source/Engine/Content/Asset.h               |  1 +
 Source/Engine/Content/Content.cpp           |  5 +++
 Source/Engine/Tools/ModelTool/ModelTool.cpp | 40 ++++++++-------------
 3 files changed, 20 insertions(+), 26 deletions(-)

diff --git a/Source/Engine/Content/Asset.h b/Source/Engine/Content/Asset.h
index 2d2ba4b3f..0ecc6db3f 100644
--- a/Source/Engine/Content/Asset.h
+++ b/Source/Engine/Content/Asset.h
@@ -246,3 +246,4 @@ public:
 
 // Don't include Content.h but just Load method
 extern FLAXENGINE_API Asset* LoadAsset(const Guid& id, const ScriptingTypeHandle& type);
+extern FLAXENGINE_API Asset* LoadAsset(const StringView& path, const ScriptingTypeHandle& type);
diff --git a/Source/Engine/Content/Content.cpp b/Source/Engine/Content/Content.cpp
index e58aa458d..f12619c52 100644
--- a/Source/Engine/Content/Content.cpp
+++ b/Source/Engine/Content/Content.cpp
@@ -449,6 +449,11 @@ FLAXENGINE_API Asset* LoadAsset(const Guid& id, const ScriptingTypeHandle& type)
     return Content::LoadAsync(id, type);
 }
 
+FLAXENGINE_API Asset* LoadAsset(const StringView& path, const ScriptingTypeHandle& type)
+{
+    return Content::LoadAsync(path, type);
+}
+
 Asset* Content::LoadAsync(const StringView& path, MClass* type)
 {
     CHECK_RETURN(type, nullptr);
diff --git a/Source/Engine/Tools/ModelTool/ModelTool.cpp b/Source/Engine/Tools/ModelTool/ModelTool.cpp
index e15891a62..c3015ea30 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.cpp
@@ -864,40 +864,28 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
 #if COMPILE_WITH_ASSETS_IMPORTER
         auto assetPath = autoImportOutput / filename + ASSET_FILES_EXTENSION_WITH_DOT;
         if (options.ImportMaterialsAsInstances) {
-            LOG(Warning, "Did work poggers");
-            if (AssetsImportingManager::Create(AssetsImportingManager::CreateMaterialInstanceTag, assetPath, material.AssetID))
-            {
-                LOG(Error, "Failed to create material instance.");
+            LOG(Warning, "Adding material instance for {0}", assetPath);
+
+            AssetsImportingManager::Create(AssetsImportingManager::CreateMaterialInstanceTag, assetPath);
+            MaterialInstance* materialInstance = (MaterialInstance*) LoadAsset(assetPath, MaterialInstance::TypeInitializer);
+            if (materialInstance->WaitForLoaded()) {
+                LOG(Error, "Failed to load material instance after creation. ({0})", assetPath);
                 return true;
             }
-            else
-            {
-                MaterialInstance* materialInstance = (MaterialInstance*) LoadAsset(material.AssetID, ScriptingTypeHandle());
-                if (materialInstance == nullptr)
-                {
-                    LOG(Error, "Failed to find created material instance.");
-                    return true;
-                }
 
-                MaterialBase *materialInstanceOf = (MaterialBase*) LoadAsset(options.InstanceToImportAs, ScriptingTypeHandle());
-                if (materialInstanceOf == nullptr)
-                {
-                    LOG(Error, "Failed to find the material to create an instance of.");
-                    return true;
-                }
-
-                materialInstance->SetBaseMaterial(materialInstanceOf);
-                if (materialInstance->Save())
-                {
-                    LOG(Error, "Failed to save the material instance.");
-                    return true;
-                }
+            MaterialBase* materialInstanceOf = (MaterialBase*) LoadAsset(options.InstanceToImportAs, MaterialBase::TypeInitializer);
+            if (materialInstanceOf->WaitForLoaded()) {
+                LOG(Error, "Failed to load material to create an instance of. ({0})", options.InstanceToImportAs);
+                return true;
             }
+
+            materialInstance->SetBaseMaterial(materialInstanceOf);
+            materialInstance->Save();
         }
         else {
             CreateMaterial::Options materialOptions;
             materialOptions.Diffuse.Color = material.Diffuse.Color;
-            if (material.Diffuse.TextureIndex != -1)
+            if (material.Diffuse.TextureIndex != -1) 
                 materialOptions.Diffuse.Texture = data.Textures[material.Diffuse.TextureIndex].AssetID;
             materialOptions.Diffuse.HasAlphaMask = material.Diffuse.HasAlphaMask;
             materialOptions.Emissive.Color = material.Emissive.Color;

From 4acfffeaf48dcf41e0bef7cf1ab8df4b59b72a61 Mon Sep 17 00:00:00 2001
From: Menotdan <32620310+Menotdan@users.noreply.github.com>
Date: Mon, 22 May 2023 13:51:13 -0400
Subject: [PATCH 006/103] Make it so the material instances get linked to the
 material slots.

---
 Source/Engine/Tools/ModelTool/ModelTool.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Source/Engine/Tools/ModelTool/ModelTool.cpp b/Source/Engine/Tools/ModelTool/ModelTool.cpp
index c3015ea30..d1736e246 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.cpp
@@ -866,7 +866,7 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
         if (options.ImportMaterialsAsInstances) {
             LOG(Warning, "Adding material instance for {0}", assetPath);
 
-            AssetsImportingManager::Create(AssetsImportingManager::CreateMaterialInstanceTag, assetPath);
+            AssetsImportingManager::Create(AssetsImportingManager::CreateMaterialInstanceTag, assetPath, material.AssetID);
             MaterialInstance* materialInstance = (MaterialInstance*) LoadAsset(assetPath, MaterialInstance::TypeInitializer);
             if (materialInstance->WaitForLoaded()) {
                 LOG(Error, "Failed to load material instance after creation. ({0})", assetPath);

From 284c3d832a9212953777d80ff3c268fcaea43401 Mon Sep 17 00:00:00 2001
From: Menotdan <32620310+Menotdan@users.noreply.github.com>
Date: Mon, 22 May 2023 14:26:20 -0400
Subject: [PATCH 007/103] fix a couple of bugs with importing without material
 instances

---
 .../Editor/Content/Import/ModelImportEntry.cs | 20 +++++++++++++++++--
 Source/Engine/Content/Content.cpp             |  2 ++
 Source/Engine/Tools/ModelTool/ModelTool.cpp   | 14 +++++++------
 3 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/Source/Editor/Content/Import/ModelImportEntry.cs b/Source/Editor/Content/Import/ModelImportEntry.cs
index 8bdd7264a..88ace184a 100644
--- a/Source/Editor/Content/Import/ModelImportEntry.cs
+++ b/Source/Editor/Content/Import/ModelImportEntry.cs
@@ -437,6 +437,12 @@ namespace FlaxEditor.Content.Import
 
         internal void ToInternal(out InternalOptions options)
         {
+            Guid instanceToImportAsGuid = Guid.Empty;
+            if (InstanceToImportAs != null)
+            {
+                instanceToImportAsGuid = InstanceToImportAs.ID;
+            }
+
             options = new InternalOptions
             {
                 Type = Type,
@@ -472,7 +478,7 @@ namespace FlaxEditor.Content.Import
                 TriangleReduction = TriangleReduction,
                 ImportMaterials = (byte)(ImportMaterials ? 1 : 0),
                 ImportMaterialsAsInstances = (byte)(ImportMaterialsAsInstances ? 1 : 0),
-                InstanceToImportAs = InstanceToImportAs.ID,
+                InstanceToImportAs = instanceToImportAsGuid,
                 ImportTextures = (byte)(ImportTextures ? 1 : 0),
                 RestoreMaterialsOnReimport = (byte)(RestoreMaterialsOnReimport ? 1 : 0),
                 GenerateSDF = (byte)(GenerateSDF ? 1 : 0),
@@ -484,6 +490,16 @@ namespace FlaxEditor.Content.Import
 
         internal void FromInternal(ref InternalOptions options)
         {
+            Material instanceToImportAsMat = null;
+            if (options.InstanceToImportAs != Guid.Empty)
+            {
+                AssetInfo assetInfo;
+                if (FlaxEngine.Content.GetAssetInfo(options.InstanceToImportAs, out assetInfo))
+                {
+                    instanceToImportAsMat = FlaxEngine.Content.Load<Material>(options.InstanceToImportAs);
+                }
+            }
+
             Type = options.Type;
             CalculateNormals = options.CalculateNormals != 0;
             SmoothingNormalsAngle = options.SmoothingNormalsAngle;
@@ -516,7 +532,7 @@ namespace FlaxEditor.Content.Import
             TriangleReduction = options.TriangleReduction;
             ImportMaterials = options.ImportMaterials != 0;
             ImportMaterialsAsInstances = options.ImportMaterialsAsInstances != 0;
-            InstanceToImportAs = FlaxEngine.Content.Load<Material>(options.InstanceToImportAs);
+            InstanceToImportAs = instanceToImportAsMat;
             ImportTextures = options.ImportTextures != 0;
             RestoreMaterialsOnReimport = options.RestoreMaterialsOnReimport != 0;
             GenerateSDF = options.GenerateSDF != 0;
diff --git a/Source/Engine/Content/Content.cpp b/Source/Engine/Content/Content.cpp
index f12619c52..d4015da7b 100644
--- a/Source/Engine/Content/Content.cpp
+++ b/Source/Engine/Content/Content.cpp
@@ -30,6 +30,7 @@
 #if ENABLE_ASSETS_DISCOVERY
 #include "Engine/Core/Collections/HashSet.h"
 #endif
+#include <Engine/Debug/DebugLog.h>
 
 TimeSpan Content::AssetsUpdateInterval = TimeSpan::FromMilliseconds(500);
 TimeSpan Content::AssetsUnloadInterval = TimeSpan::FromSeconds(10);
@@ -1003,6 +1004,7 @@ Asset* Content::load(const Guid& id, const ScriptingTypeHandle& type, AssetInfo&
     if (!GetAssetInfo(id, assetInfo))
     {
         LOG(Warning, "Invalid or missing asset ({0}, {1}).", id.ToString(Guid::FormatType::N), type.ToString());
+        LOG(Warning, "{0}", DebugLog::GetStackTrace());
         return nullptr;
     }
 
diff --git a/Source/Engine/Tools/ModelTool/ModelTool.cpp b/Source/Engine/Tools/ModelTool/ModelTool.cpp
index d1736e246..d5e5ebb10 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.cpp
@@ -863,18 +863,19 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
         importedFileNames.Add(filename);
 #if COMPILE_WITH_ASSETS_IMPORTER
         auto assetPath = autoImportOutput / filename + ASSET_FILES_EXTENSION_WITH_DOT;
-        if (options.ImportMaterialsAsInstances) {
-            LOG(Warning, "Adding material instance for {0}", assetPath);
-
+        if (options.ImportMaterialsAsInstances)
+        {
             AssetsImportingManager::Create(AssetsImportingManager::CreateMaterialInstanceTag, assetPath, material.AssetID);
             MaterialInstance* materialInstance = (MaterialInstance*) LoadAsset(assetPath, MaterialInstance::TypeInitializer);
-            if (materialInstance->WaitForLoaded()) {
+            if (materialInstance->WaitForLoaded())
+            {
                 LOG(Error, "Failed to load material instance after creation. ({0})", assetPath);
                 return true;
             }
 
             MaterialBase* materialInstanceOf = (MaterialBase*) LoadAsset(options.InstanceToImportAs, MaterialBase::TypeInitializer);
-            if (materialInstanceOf->WaitForLoaded()) {
+            if (materialInstanceOf->WaitForLoaded())
+            {
                 LOG(Error, "Failed to load material to create an instance of. ({0})", options.InstanceToImportAs);
                 return true;
             }
@@ -882,7 +883,8 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
             materialInstance->SetBaseMaterial(materialInstanceOf);
             materialInstance->Save();
         }
-        else {
+        else
+        {
             CreateMaterial::Options materialOptions;
             materialOptions.Diffuse.Color = material.Diffuse.Color;
             if (material.Diffuse.TextureIndex != -1) 

From e3f004b831f5906b4867bd7dfea8a12b9e5c890c Mon Sep 17 00:00:00 2001
From: Menotdan <32620310+Menotdan@users.noreply.github.com>
Date: Mon, 22 May 2023 14:26:55 -0400
Subject: [PATCH 008/103] remove extraneous stack trace print that i used for
 debugging

---
 Source/Engine/Content/Content.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Source/Engine/Content/Content.cpp b/Source/Engine/Content/Content.cpp
index d4015da7b..026ae821c 100644
--- a/Source/Engine/Content/Content.cpp
+++ b/Source/Engine/Content/Content.cpp
@@ -1004,7 +1004,6 @@ Asset* Content::load(const Guid& id, const ScriptingTypeHandle& type, AssetInfo&
     if (!GetAssetInfo(id, assetInfo))
     {
         LOG(Warning, "Invalid or missing asset ({0}, {1}).", id.ToString(Guid::FormatType::N), type.ToString());
-        LOG(Warning, "{0}", DebugLog::GetStackTrace());
         return nullptr;
     }
 

From af3d9d0eb3acb07dcb078ff23cf08e96ecec1caf Mon Sep 17 00:00:00 2001
From: Menotdan <32620310+Menotdan@users.noreply.github.com>
Date: Wed, 9 Aug 2023 15:28:47 -0400
Subject: [PATCH 009/103] Re-implement functionality for importing materials as
 instances.

---
 Source/Engine/Tools/ModelTool/ModelTool.cpp | 10 +++++++---
 Source/Engine/Tools/ModelTool/ModelTool.h   |  7 +++++++
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/Source/Engine/Tools/ModelTool/ModelTool.cpp b/Source/Engine/Tools/ModelTool/ModelTool.cpp
index 13fc753af..dfc249c6a 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.cpp
@@ -385,6 +385,8 @@ void ModelTool::Options::Serialize(SerializeStream& stream, const void* otherObj
     SERIALIZE(LODCount);
     SERIALIZE(TriangleReduction);
     SERIALIZE(ImportMaterials);
+    SERIALIZE(ImportMaterialsAsInstances);
+    SERIALIZE(InstanceToImportAs);
     SERIALIZE(ImportTextures);
     SERIALIZE(RestoreMaterialsOnReimport);
     SERIALIZE(GenerateSDF);
@@ -426,6 +428,8 @@ void ModelTool::Options::Deserialize(DeserializeStream& stream, ISerializeModifi
     DESERIALIZE(LODCount);
     DESERIALIZE(TriangleReduction);
     DESERIALIZE(ImportMaterials);
+    DESERIALIZE(ImportMaterialsAsInstances);
+    DESERIALIZE(InstanceToImportAs);
     DESERIALIZE(ImportTextures);
     DESERIALIZE(RestoreMaterialsOnReimport);
     DESERIALIZE(GenerateSDF);
@@ -977,17 +981,17 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
         if (options.ImportMaterialsAsInstances)
         {
             AssetsImportingManager::Create(AssetsImportingManager::CreateMaterialInstanceTag, assetPath, material.AssetID);
-            MaterialInstance* materialInstance = (MaterialInstance*) LoadAsset(assetPath, MaterialInstance::TypeInitializer);
+            MaterialInstance* materialInstance = (MaterialInstance*)LoadAsset(assetPath, MaterialInstance::TypeInitializer);
             if (materialInstance->WaitForLoaded())
             {
                 LOG(Error, "Failed to load material instance after creation. ({0})", assetPath);
                 return true;
             }
 
-            MaterialBase* materialInstanceOf = (MaterialBase*) LoadAsset(options.InstanceToImportAs, MaterialBase::TypeInitializer);
+            MaterialBase* materialInstanceOf = options.InstanceToImportAs;
             if (materialInstanceOf->WaitForLoaded())
             {
-                LOG(Error, "Failed to load material to create an instance of. ({0})", options.InstanceToImportAs);
+                LOG(Error, "Failed to load material to create an instance of. ({0})", options.InstanceToImportAs->GetID());
                 return true;
             }
 
diff --git a/Source/Engine/Tools/ModelTool/ModelTool.h b/Source/Engine/Tools/ModelTool/ModelTool.h
index 992a929ca..f6aaefa2b 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.h
+++ b/Source/Engine/Tools/ModelTool/ModelTool.h
@@ -12,6 +12,7 @@
 #include "Engine/Graphics/Models/SkeletonData.h"
 #include "Engine/Animations/AnimationData.h"
 #include <Engine/Content/Assets/Material.h>
+#include <Engine/Graphics/GPUDevice.h>
 
 class JsonWriter;
 
@@ -329,6 +330,12 @@ public:
         // If checked, the importer will create materials for model meshes as specified in the file.
         API_FIELD(Attributes="EditorOrder(400), EditorDisplay(\"Materials\"), VisibleIf(nameof(ShowGeometry))")
         bool ImportMaterials = true;
+        // If checked, the importer will create the model's materials as instances of a base material.
+        API_FIELD(Attributes = "EditorOrder(401), EditorDisplay(\"Materials\"), VisibleIf(nameof(ImportMaterials))")
+        bool ImportMaterialsAsInstances = false;
+        // The material to import the model's materials as an instance of.
+        API_FIELD(Attributes = "EditorOrder(402), EditorDisplay(\"Materials\"), VisibleIf(nameof(ImportMaterialsAsInstances))")
+        AssetReference<Material> InstanceToImportAs = (Material*) GPUDevice::Instance->GetDefaultMaterial();
         // If checked, the importer will import texture files used by the model and any embedded texture resources.
         API_FIELD(Attributes="EditorOrder(410), EditorDisplay(\"Materials\"), VisibleIf(nameof(ShowGeometry))")
         bool ImportTextures = true;

From 52e546b3ba936e66928ac46b2fab0d6bf0942df3 Mon Sep 17 00:00:00 2001
From: Menotdan <32620310+Menotdan@users.noreply.github.com>
Date: Wed, 9 Aug 2023 15:29:14 -0400
Subject: [PATCH 010/103] fix unneeded include.

---
 Source/ThirdParty/OpenFBX/ofbx.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Source/ThirdParty/OpenFBX/ofbx.h b/Source/ThirdParty/OpenFBX/ofbx.h
index 87dd5999f..7066659e3 100644
--- a/Source/ThirdParty/OpenFBX/ofbx.h
+++ b/Source/ThirdParty/OpenFBX/ofbx.h
@@ -1,5 +1,4 @@
 #pragma once
-#include <Engine/Core/Types/Guid.h>
 
 
 namespace ofbx

From 72488c4250a39e3f0381808c990f50a4341cb49e Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Tue, 22 Aug 2023 21:14:33 -0500
Subject: [PATCH 011/103] Update cs script temple to use non-indented
 namespace.

---
 Content/Editor/Scripting/ScriptTemplate.cs    | 50 +++++++++----------
 .../Editor/Content/Proxy/CSharpScriptProxy.cs |  2 +-
 2 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/Content/Editor/Scripting/ScriptTemplate.cs b/Content/Editor/Scripting/ScriptTemplate.cs
index 2a150306d..8d43ad590 100644
--- a/Content/Editor/Scripting/ScriptTemplate.cs
+++ b/Content/Editor/Scripting/ScriptTemplate.cs
@@ -3,34 +3,34 @@ using System.Collections.Generic;
 using FlaxEngine;
 
 namespace %namespace%
+
+/// <summary>
+/// %class% Script.
+/// </summary>
+public class %class% : Script
 {
-    /// <summary>
-    /// %class% Script.
-    /// </summary>
-    public class %class% : Script
+    /// <inheritdoc/>
+    public override void OnStart()
     {
-        /// <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)
-        }
+        // 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 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
-        }
+    /// <inheritdoc/>
+    public override void OnUpdate()
+    {
+        // Here you can add code that needs to be called every frame
     }
 }
+
diff --git a/Source/Editor/Content/Proxy/CSharpScriptProxy.cs b/Source/Editor/Content/Proxy/CSharpScriptProxy.cs
index 24c44aa20..09440d43a 100644
--- a/Source/Editor/Content/Proxy/CSharpScriptProxy.cs
+++ b/Source/Editor/Content/Proxy/CSharpScriptProxy.cs
@@ -51,7 +51,7 @@ namespace FlaxEditor.Content
             var copyrightComment = string.IsNullOrEmpty(gameSettings.CopyrightNotice) ? string.Empty : string.Format("// {0}{1}{1}", gameSettings.CopyrightNotice, Environment.NewLine);
             scriptTemplate = scriptTemplate.Replace("%copyright%", copyrightComment);
             scriptTemplate = scriptTemplate.Replace("%class%", scriptName);
-            scriptTemplate = scriptTemplate.Replace("%namespace%", scriptNamespace);
+            scriptTemplate = scriptTemplate.Replace("%namespace%", $"{scriptNamespace};");
 
             // Save
             File.WriteAllText(outputPath, scriptTemplate, Encoding.UTF8);

From 3295d58684894d39945ee6e803b1f3fe237ab6de Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Tue, 22 Aug 2023 21:34:36 -0500
Subject: [PATCH 012/103] Simplify

---
 Content/Editor/Scripting/ScriptTemplate.cs       | 2 +-
 Source/Editor/Content/Proxy/CSharpScriptProxy.cs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Content/Editor/Scripting/ScriptTemplate.cs b/Content/Editor/Scripting/ScriptTemplate.cs
index 8d43ad590..663acf05f 100644
--- a/Content/Editor/Scripting/ScriptTemplate.cs
+++ b/Content/Editor/Scripting/ScriptTemplate.cs
@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using FlaxEngine;
 
-namespace %namespace%
+namespace %namespace%;
 
 /// <summary>
 /// %class% Script.
diff --git a/Source/Editor/Content/Proxy/CSharpScriptProxy.cs b/Source/Editor/Content/Proxy/CSharpScriptProxy.cs
index 09440d43a..24c44aa20 100644
--- a/Source/Editor/Content/Proxy/CSharpScriptProxy.cs
+++ b/Source/Editor/Content/Proxy/CSharpScriptProxy.cs
@@ -51,7 +51,7 @@ namespace FlaxEditor.Content
             var copyrightComment = string.IsNullOrEmpty(gameSettings.CopyrightNotice) ? string.Empty : string.Format("// {0}{1}{1}", gameSettings.CopyrightNotice, Environment.NewLine);
             scriptTemplate = scriptTemplate.Replace("%copyright%", copyrightComment);
             scriptTemplate = scriptTemplate.Replace("%class%", scriptName);
-            scriptTemplate = scriptTemplate.Replace("%namespace%", $"{scriptNamespace};");
+            scriptTemplate = scriptTemplate.Replace("%namespace%", scriptNamespace);
 
             // Save
             File.WriteAllText(outputPath, scriptTemplate, Encoding.UTF8);

From 23b6b93726c371cb88d72013acc58998348cf3f6 Mon Sep 17 00:00:00 2001
From: Ruan Lucas <79365912+RuanLucasGD@users.noreply.github.com>
Date: Fri, 15 Sep 2023 19:13:32 -0400
Subject: [PATCH 013/103] add collision type to model importer

---
 Source/Engine/Tools/ModelTool/ModelTool.cpp | 2 +-
 Source/Engine/Tools/ModelTool/ModelTool.h   | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/Source/Engine/Tools/ModelTool/ModelTool.cpp b/Source/Engine/Tools/ModelTool/ModelTool.cpp
index 19f203667..922627b77 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.cpp
@@ -1079,7 +1079,7 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
 #if COMPILE_WITH_PHYSICS_COOKING
                 // Create collision
                 CollisionCooking::Argument arg;
-                arg.Type = CollisionDataType::TriangleMesh;
+                arg.Type = options.CollisionType;
                 arg.OverrideModelData = &collisionModel;
                 auto assetPath = autoImportOutput / StringUtils::GetFileNameWithoutExtension(path) + TEXT("Collision") ASSET_FILES_EXTENSION_WITH_DOT;
                 if (CreateCollisionData::CookMeshCollision(assetPath, arg))
diff --git a/Source/Engine/Tools/ModelTool/ModelTool.h b/Source/Engine/Tools/ModelTool/ModelTool.h
index 9dc5bf067..ab5f79ddf 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.h
+++ b/Source/Engine/Tools/ModelTool/ModelTool.h
@@ -6,6 +6,7 @@
 
 #include "Engine/Core/Config.h"
 #include "Engine/Content/Assets/ModelBase.h"
+#include "Engine/Physics/CollisionData.h"
 #if USE_EDITOR
 #include "Engine/Core/ISerializable.h"
 #include "Engine/Graphics/Models/ModelData.h"
@@ -262,6 +263,9 @@ public:
         // If specified, all meshes which name starts with this prefix will be imported as a separate collision data (excluded used for rendering).
         API_FIELD(Attributes="EditorOrder(100), EditorDisplay(\"Geometry\"), VisibleIf(nameof(ShowGeometry))")
         String CollisionMeshesPrefix = TEXT("");
+        // The type of collision that should be generated if has collision prefix especified
+        API_FIELD(Attributes = "EditorOrder(105), EditorDisplay(\"Geometry\"), VisibleIf(nameof(ShowGeometry))")
+        CollisionDataType CollisionType = CollisionDataType::TriangleMesh;
 
     public: // Transform
 

From 5cc3e409025246917e6f4a8988f1acd64526fba5 Mon Sep 17 00:00:00 2001
From: Red Kitsune <krakers114pl@gmail.com>
Date: Sun, 17 Sep 2023 20:28:34 +0200
Subject: [PATCH 014/103] Implemented better missing script handling

---
 Source/Engine/Level/Components/DummyScript.h | 67 ++++++++++++++++++++
 Source/Engine/Level/SceneObjectsFactory.cpp  |  3 +
 2 files changed, 70 insertions(+)
 create mode 100644 Source/Engine/Level/Components/DummyScript.h

diff --git a/Source/Engine/Level/Components/DummyScript.h b/Source/Engine/Level/Components/DummyScript.h
new file mode 100644
index 000000000..380648f5a
--- /dev/null
+++ b/Source/Engine/Level/Components/DummyScript.h
@@ -0,0 +1,67 @@
+#pragma once
+
+#include "Engine/Core/Cache.h"
+#include "Engine/Scripting/Script.h"
+#include "Engine/Scripting/ScriptingObjectReference.h"
+#include "Engine/Serialization/JsonWriters.h"
+
+API_CLASS(Attributes="HideInEditor") class FLAXENGINE_API DummyScript : public Script
+{
+    API_AUTO_SERIALIZATION();
+    DECLARE_SCRIPTING_TYPE(DummyScript);
+
+public:
+    API_PROPERTY(Attributes="ReadOnly")
+    FORCE_INLINE String GetMissingTypeName() const
+    {
+        if(Data.IsEmpty()) return TEXT("");
+        
+        rapidjson_flax::Document doc;
+        doc.Parse(Data.ToStringAnsi().GetText());
+        
+        String str (doc["TypeName"].GetString());
+        
+        return str;
+    }
+    
+    API_PROPERTY()
+    void SetMissingTypeName(String value)
+    {
+        _missingTypeName = value;
+    }
+    
+    API_FIELD(Hidden, Attributes="HideInEditor") String Data;
+    
+    API_PROPERTY()
+    FORCE_INLINE ScriptingObjectReference<Script> GetReferenceScript() const
+    {
+        return _referenceScript;
+    }
+    
+    API_PROPERTY()
+    void SetReferenceScript(ScriptingObjectReference<Script> value)
+    {
+        _referenceScript = value;
+
+        if(Data.IsEmpty()) return;
+        
+        MapToReferenceScript();
+    }
+
+private:
+    ScriptingObjectReference<Script> _referenceScript;
+    String _missingTypeName;
+    
+    void MapToReferenceScript()
+    {
+        rapidjson_flax::Document doc;
+        doc.Parse(Data.ToStringAnsi().GetText());
+        
+        auto modifier = Cache::ISerializeModifier.Get();
+        _referenceScript->Deserialize(doc, modifier.Value);
+
+        this->DeleteObject();
+    }
+};
+
+inline DummyScript::DummyScript(const SpawnParams& params) : Script(params){}
diff --git a/Source/Engine/Level/SceneObjectsFactory.cpp b/Source/Engine/Level/SceneObjectsFactory.cpp
index f8193c257..13321a88f 100644
--- a/Source/Engine/Level/SceneObjectsFactory.cpp
+++ b/Source/Engine/Level/SceneObjectsFactory.cpp
@@ -1,6 +1,7 @@
 // Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
 
 #include "SceneObjectsFactory.h"
+#include "Components/DummyScript.h"
 #include "Engine/Level/Actor.h"
 #include "Engine/Level/Prefabs/Prefab.h"
 #include "Engine/Content/Content.h"
@@ -238,6 +239,8 @@ void SceneObjectsFactory::HandleObjectDeserializationError(const ISerializable::
     {
         const Guid parentId = JsonTools::GetGuid(parentIdMember->value);
         Actor* parent = Scripting::FindObject<Actor>(parentId);
+        DummyScript* dummyScript = parent->AddScript<DummyScript>();
+        dummyScript->Data = String(buffer.GetString());
         if (parent)
         {
             LOG(Warning, "Parent actor of the missing object: {0}", parent->GetName());

From 7c0546c68d8653e06ad3f64ac875bac6c8020a4e Mon Sep 17 00:00:00 2001
From: Red Kitsune <krakers114pl@gmail.com>
Date: Tue, 19 Sep 2023 00:21:56 +0200
Subject: [PATCH 015/103] After CR changes

---
 .../{DummyScript.h => MissingScript.h}        | 25 +++----------------
 Source/Engine/Level/SceneObjectsFactory.cpp   | 10 +++++---
 2 files changed, 11 insertions(+), 24 deletions(-)
 rename Source/Engine/Level/Components/{DummyScript.h => MissingScript.h} (60%)

diff --git a/Source/Engine/Level/Components/DummyScript.h b/Source/Engine/Level/Components/MissingScript.h
similarity index 60%
rename from Source/Engine/Level/Components/DummyScript.h
rename to Source/Engine/Level/Components/MissingScript.h
index 380648f5a..641f905eb 100644
--- a/Source/Engine/Level/Components/DummyScript.h
+++ b/Source/Engine/Level/Components/MissingScript.h
@@ -5,30 +5,14 @@
 #include "Engine/Scripting/ScriptingObjectReference.h"
 #include "Engine/Serialization/JsonWriters.h"
 
-API_CLASS(Attributes="HideInEditor") class FLAXENGINE_API DummyScript : public Script
+API_CLASS(Attributes="HideInEditor") class FLAXENGINE_API MissingScript : public Script
 {
     API_AUTO_SERIALIZATION();
-    DECLARE_SCRIPTING_TYPE(DummyScript);
+    DECLARE_SCRIPTING_TYPE(MissingScript);
 
 public:
-    API_PROPERTY(Attributes="ReadOnly")
-    FORCE_INLINE String GetMissingTypeName() const
-    {
-        if(Data.IsEmpty()) return TEXT("");
-        
-        rapidjson_flax::Document doc;
-        doc.Parse(Data.ToStringAnsi().GetText());
-        
-        String str (doc["TypeName"].GetString());
-        
-        return str;
-    }
     
-    API_PROPERTY()
-    void SetMissingTypeName(String value)
-    {
-        _missingTypeName = value;
-    }
+    API_FIELD(Attributes="ReadOnly") String MissingTypeName;
     
     API_FIELD(Hidden, Attributes="HideInEditor") String Data;
     
@@ -50,7 +34,6 @@ public:
 
 private:
     ScriptingObjectReference<Script> _referenceScript;
-    String _missingTypeName;
     
     void MapToReferenceScript()
     {
@@ -64,4 +47,4 @@ private:
     }
 };
 
-inline DummyScript::DummyScript(const SpawnParams& params) : Script(params){}
+inline MissingScript::MissingScript(const SpawnParams& params) : Script(params){}
diff --git a/Source/Engine/Level/SceneObjectsFactory.cpp b/Source/Engine/Level/SceneObjectsFactory.cpp
index 13321a88f..2eb341a2f 100644
--- a/Source/Engine/Level/SceneObjectsFactory.cpp
+++ b/Source/Engine/Level/SceneObjectsFactory.cpp
@@ -1,7 +1,7 @@
 // Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
 
 #include "SceneObjectsFactory.h"
-#include "Components/DummyScript.h"
+#include "Components/MissingScript.h"
 #include "Engine/Level/Actor.h"
 #include "Engine/Level/Prefabs/Prefab.h"
 #include "Engine/Content/Content.h"
@@ -239,10 +239,14 @@ void SceneObjectsFactory::HandleObjectDeserializationError(const ISerializable::
     {
         const Guid parentId = JsonTools::GetGuid(parentIdMember->value);
         Actor* parent = Scripting::FindObject<Actor>(parentId);
-        DummyScript* dummyScript = parent->AddScript<DummyScript>();
-        dummyScript->Data = String(buffer.GetString());
         if (parent)
         {
+            MissingScript* dummyScript = parent->AddScript<MissingScript>();
+
+            const auto parentIdMember = value.FindMember("TypeName");
+            dummyScript->MissingTypeName = parentIdMember->value.GetString();
+            dummyScript->Data = String(buffer.GetString());
+            
             LOG(Warning, "Parent actor of the missing object: {0}", parent->GetName());
         }
     }

From 2b1266147cd5ab91d514e135397ae738cfbf15b2 Mon Sep 17 00:00:00 2001
From: Menotdan <32620310+Menotdan@users.noreply.github.com>
Date: Wed, 20 Sep 2023 11:02:19 -0400
Subject: [PATCH 016/103] Add new condition from split object bugfix on master.

---
 Source/Engine/Tools/ModelTool/ModelTool.cpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/Source/Engine/Tools/ModelTool/ModelTool.cpp b/Source/Engine/Tools/ModelTool/ModelTool.cpp
index 27423adb0..2b3beae2f 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.cpp
@@ -16,6 +16,7 @@
 #include "Engine/Graphics/Textures/TextureData.h"
 #include "Engine/Graphics/Models/ModelData.h"
 #include "Engine/Content/Assets/Model.h"
+#include "Engine/Content/Content.h"
 #include "Engine/Serialization/MemoryWriteStream.h"
 #if USE_EDITOR
 #include "Engine/Core/Types/DateTime.h"
@@ -984,6 +985,15 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
         auto assetPath = autoImportOutput / filename + ASSET_FILES_EXTENSION_WITH_DOT;
         if (options.ImportMaterialsAsInstances)
         {
+            if (!options.SplitObjects && options.ObjectIndex != 1 && options.ObjectIndex != -1)
+            {
+                // Find that asset create previously
+                AssetInfo info;
+                if (Content::GetAssetInfo(assetPath, info))
+                    material.AssetID = info.ID;
+                continue;
+            }
+
             AssetsImportingManager::Create(AssetsImportingManager::CreateMaterialInstanceTag, assetPath, material.AssetID);
             MaterialInstance* materialInstance = (MaterialInstance*)LoadAsset(assetPath, MaterialInstance::TypeInitializer);
             if (materialInstance->WaitForLoaded())
@@ -1021,6 +1031,15 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
                 materialOptions.Info.CullMode = CullMode::TwoSided;
             if (!Math::IsOne(material.Opacity.Value) || material.Opacity.TextureIndex != -1)
                 materialOptions.Info.BlendMode = MaterialBlendMode::Transparent;
+
+            if (!options.SplitObjects && options.ObjectIndex != 1 && options.ObjectIndex != -1)
+            {
+                // Find that asset create previously
+                AssetInfo info;
+                if (Content::GetAssetInfo(assetPath, info))
+                    material.AssetID = info.ID;
+                continue;
+            }
             AssetsImportingManager::Create(AssetsImportingManager::CreateMaterialTag, assetPath, material.AssetID, &materialOptions);
         }
 #endif

From 74acc93c0cf23e4109f86e03c3efabe1db88fc10 Mon Sep 17 00:00:00 2001
From: Red Kitsune <krakers114pl@gmail.com>
Date: Thu, 21 Sep 2023 01:03:35 +0200
Subject: [PATCH 017/103] Add XML comments

---
 .../Engine/Level/Components/MissingScript.h   | 23 +++++++++++++++----
 1 file changed, 19 insertions(+), 4 deletions(-)

diff --git a/Source/Engine/Level/Components/MissingScript.h b/Source/Engine/Level/Components/MissingScript.h
index 641f905eb..601346203 100644
--- a/Source/Engine/Level/Components/MissingScript.h
+++ b/Source/Engine/Level/Components/MissingScript.h
@@ -5,23 +5,38 @@
 #include "Engine/Scripting/ScriptingObjectReference.h"
 #include "Engine/Serialization/JsonWriters.h"
 
+/// <summary>
+/// Actor script component that represents missing script.
+/// </summary>
 API_CLASS(Attributes="HideInEditor") class FLAXENGINE_API MissingScript : public Script
 {
     API_AUTO_SERIALIZATION();
     DECLARE_SCRIPTING_TYPE(MissingScript);
 
 public:
-    
+
+    /// <summary>
+    /// Namespace and type name of missing script.
+    /// </summary>
     API_FIELD(Attributes="ReadOnly") String MissingTypeName;
-    
+
+    /// <summary>
+    /// Missing script serialized data.
+    /// </summary>
     API_FIELD(Hidden, Attributes="HideInEditor") String Data;
-    
+
+    /// <summary>
+    /// Field for assigning new script to transfer data to.
+    /// </summary>
     API_PROPERTY()
     FORCE_INLINE ScriptingObjectReference<Script> GetReferenceScript() const
     {
         return _referenceScript;
     }
-    
+
+    /// <summary>
+    /// Field for assigning new script to transfer data to.
+    /// </summary>
     API_PROPERTY()
     void SetReferenceScript(ScriptingObjectReference<Script> value)
     {

From 794ccd42ff88df1f6eb12a07fb3c1003367d2646 Mon Sep 17 00:00:00 2001
From: Red Kitsune <krakers114pl@gmail.com>
Date: Thu, 21 Sep 2023 22:00:20 +0200
Subject: [PATCH 018/103] - Added MissingScriptEditor

---
 .../Dedicated/MissingScriptEditor.cs          | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Source/Editor/CustomEditors/Dedicated/MissingScriptEditor.cs

diff --git a/Source/Editor/CustomEditors/Dedicated/MissingScriptEditor.cs b/Source/Editor/CustomEditors/Dedicated/MissingScriptEditor.cs
new file mode 100644
index 000000000..03d5ddd55
--- /dev/null
+++ b/Source/Editor/CustomEditors/Dedicated/MissingScriptEditor.cs
@@ -0,0 +1,26 @@
+using FlaxEditor.CustomEditors.Editors;
+using FlaxEngine;
+using FlaxEngine.GUI;
+
+namespace FlaxEditor.CustomEditors.Dedicated;
+
+/// <summary>
+/// The missing script editor.
+/// </summary>
+[CustomEditor(typeof(MissingScript)), DefaultEditor]
+public class MissingScriptEditor : GenericEditor
+{
+    /// <inheritdoc />
+    public override void Initialize(LayoutElementsContainer layout)
+    {
+        if (layout.ContainerControl is not DropPanel dropPanel)
+        {
+            base.Initialize(layout);
+            return;
+        }
+
+        dropPanel.HeaderTextColor = Color.OrangeRed;
+        
+        base.Initialize(layout);
+    }
+}

From dbbd6ce045fb7caa642e3317ae30cb24e37aaa5d Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Fri, 22 Sep 2023 17:19:14 +0200
Subject: [PATCH 019/103] Add codesigning to macOS editor package binaries

---
 Source/Platforms/Mac/Default.entitlements     | 16 +++++++++++++++
 Source/Tools/Flax.Build/Configuration.cs      |  6 ------
 Source/Tools/Flax.Build/Deploy/Deployer.cs    | 10 ++++++++--
 .../Flax.Build/Deploy/Deployment.Editor.cs    |  8 ++++++++
 .../Flax.Build/Platforms/Mac/MacPlatform.cs   | 20 +++++++++++++++++++
 5 files changed, 52 insertions(+), 8 deletions(-)
 create mode 100644 Source/Platforms/Mac/Default.entitlements

diff --git a/Source/Platforms/Mac/Default.entitlements b/Source/Platforms/Mac/Default.entitlements
new file mode 100644
index 000000000..1918049d1
--- /dev/null
+++ b/Source/Platforms/Mac/Default.entitlements
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+ <key>com.apple.security.cs.allow-dyld-environment-variables</key>
+ <true/>
+ <key>com.apple.security.cs.allow-jit</key>
+ <true/>
+ <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+ <true/>
+ <key>com.apple.security.cs.disable-executable-page-protection</key>
+ <true/>
+ <key>com.apple.security.cs.disable-library-validation</key>
+ <true/>
+</dict>
+</plist>
diff --git a/Source/Tools/Flax.Build/Configuration.cs b/Source/Tools/Flax.Build/Configuration.cs
index 8fa17a235..9094f7b9e 100644
--- a/Source/Tools/Flax.Build/Configuration.cs
+++ b/Source/Tools/Flax.Build/Configuration.cs
@@ -39,12 +39,6 @@ namespace Flax.Build
         [CommandLine("deploy", "Runs the deploy tool.")]
         public static bool Deploy = false;
 
-        /// <summary>
-        /// Compresses deployed files.
-        /// </summary>
-        [CommandLine("deployDontCompress", "Skips compressing deployed files, and keeps files.")]
-        public static bool DontCompress = false;
-
         /// <summary>
         /// Builds the targets. Builds all the targets, use <see cref="BuildTargets"/> to select a custom set of targets for the build.
         /// </summary>
diff --git a/Source/Tools/Flax.Build/Deploy/Deployer.cs b/Source/Tools/Flax.Build/Deploy/Deployer.cs
index f05fda788..5882bd366 100644
--- a/Source/Tools/Flax.Build/Deploy/Deployer.cs
+++ b/Source/Tools/Flax.Build/Deploy/Deployer.cs
@@ -9,6 +9,12 @@ namespace Flax.Build
 {
     public static partial class Configuration
     {
+        /// <summary>
+        /// Compresses deployed files.
+        /// </summary>
+        [CommandLine("deployDontCompress", "Skips compressing deployed files, and keeps files.")]
+        public static bool DontCompress = false;
+
         /// <summary>
         /// Package deployment output path.
         /// </summary>
@@ -28,9 +34,9 @@ namespace Flax.Build
         public static bool DeployPlatforms;
 
         /// <summary>
-        /// Certificate file path for binaries signing.
+        /// Certificate file path for binaries signing. Or sign identity for Apple platforms.
         /// </summary>
-        [CommandLine("deployCert", "Certificate file path for binaries signing.")]
+        [CommandLine("deployCert", "Certificate file path for binaries signing. Or sign identity for Apple platforms.")]
         public static string DeployCert;
 
         /// <summary>
diff --git a/Source/Tools/Flax.Build/Deploy/Deployment.Editor.cs b/Source/Tools/Flax.Build/Deploy/Deployment.Editor.cs
index 95eb1f331..981c15a55 100644
--- a/Source/Tools/Flax.Build/Deploy/Deployment.Editor.cs
+++ b/Source/Tools/Flax.Build/Deploy/Deployment.Editor.cs
@@ -17,11 +17,15 @@ namespace Flax.Deploy
         {
             if (string.IsNullOrEmpty(Configuration.DeployCert))
                 return;
+            Log.Info("Code signing file: " + file);
             switch (Platform.BuildTargetPlatform)
             {
             case TargetPlatform.Windows:
                 VCEnvironment.CodeSign(file, Configuration.DeployCert, Configuration.DeployCertPass);
                 break;
+            case TargetPlatform.Mac:
+                MacPlatform.CodeSign(file, Configuration.DeployCert);
+                break;
             }
         }
 
@@ -254,6 +258,10 @@ namespace Flax.Deploy
                     Utilities.Run("strip", "FlaxEditor", null, dst, Utilities.RunOptions.None);
                     Utilities.Run("strip", "FlaxEditor.dylib", null, dst, Utilities.RunOptions.None);
                     Utilities.Run("strip", "libMoltenVK.dylib", null, dst, Utilities.RunOptions.None);
+
+                    CodeSign(Path.Combine(dst, "FlaxEditor"));
+                    CodeSign(Path.Combine(dst, "FlaxEditor.dylib"));
+                    CodeSign(Path.Combine(dst, "libMoltenVK.dylib"));
                 }
             }
         }
diff --git a/Source/Tools/Flax.Build/Platforms/Mac/MacPlatform.cs b/Source/Tools/Flax.Build/Platforms/Mac/MacPlatform.cs
index ef89c8b4e..3be0beb76 100644
--- a/Source/Tools/Flax.Build/Platforms/Mac/MacPlatform.cs
+++ b/Source/Tools/Flax.Build/Platforms/Mac/MacPlatform.cs
@@ -1,5 +1,7 @@
 // Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
 
+using System;
+using System.IO;
 using System.Runtime.InteropServices;
 
 namespace Flax.Build.Platforms
@@ -44,6 +46,24 @@ namespace Flax.Build.Platforms
             }
         }
 
+        /// <summary>
+        /// Runs codesign tool on macOS to sign the code with a given identity from local keychain.
+        /// </summary>
+        /// <param name="file">Path to file to codesign.</param>
+        /// <param name="signIdenity">App code signing idenity name (from local Mac keychain). Use 'security find-identity -v -p codesigning' to list possible options.</param>
+        public static void CodeSign(string file, string signIdenity)
+        {
+            if (!File.Exists(file))
+                throw new FileNotFoundException("Missing file to sign.", file);
+            string cmdLine = string.Format("--force --timestamp -s \"{0}\" \"{1}\"", signIdenity, file);
+            if (string.IsNullOrEmpty(Path.GetExtension(file)))
+            {
+                // Add entitlements file with some settings for the app execution
+                cmdLine += string.Format(" --entitlements \"{0}\"", Path.Combine(Globals.EngineRoot, "Source/Platforms/Mac/Default.entitlements"));
+            }
+            Utilities.Run("codesign", cmdLine, null, null, Utilities.RunOptions.Default | Utilities.RunOptions.ThrowExceptionOnError);
+        }
+
         /// <summary>
         /// Returns true if running an x64 binary an arm64 host machine.
         /// </summary>

From f09aebacad0eae95b6f89616ad8a58556fbac85b Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Sat, 23 Sep 2023 14:42:05 +0200
Subject: [PATCH 020/103] Add editor app packaging for macOS

---
 Source/Engine/Engine/Engine.cpp               |  12 ++++-
 Source/Platforms/Mac/Default.icns             | Bin 0 -> 193857 bytes
 Source/Platforms/Mac/Default.plist            |  43 ++++++++++++++++++
 .../Flax.Build/Deploy/Deployment.Editor.cs    |  40 ++++++++++++++++
 4 files changed, 93 insertions(+), 2 deletions(-)
 create mode 100644 Source/Platforms/Mac/Default.icns
 create mode 100644 Source/Platforms/Mac/Default.plist

diff --git a/Source/Engine/Engine/Engine.cpp b/Source/Engine/Engine/Engine.cpp
index bafcd30b3..228a47856 100644
--- a/Source/Engine/Engine/Engine.cpp
+++ b/Source/Engine/Engine/Engine.cpp
@@ -108,6 +108,14 @@ int32 Engine::Main(const Char* cmdLine)
     Globals::StartupFolder = Globals::BinariesFolder = Platform::GetMainDirectory();
 #if USE_EDITOR
     Globals::StartupFolder /= TEXT("../../../..");
+#if PLATFORM_MAC
+    if (Globals::BinariesFolder.EndsWith(TEXT(".app/Contents")))
+    {
+        // If running editor from application package on macOS
+        Globals::StartupFolder = Globals::BinariesFolder;
+        Globals::BinariesFolder /= TEXT("MacOS");
+    }
+#endif
 #endif
     StringUtils::PathRemoveRelativeParts(Globals::StartupFolder);
     FileSystem::NormalizePath(Globals::BinariesFolder);
@@ -125,7 +133,6 @@ int32 Engine::Main(const Char* cmdLine)
     }
 
     EngineImpl::InitPaths();
-
     EngineImpl::InitLog();
 
 #if USE_EDITOR
@@ -545,7 +552,8 @@ void EngineImpl::InitLog()
     LOG(Info, "Product: {0}, Company: {1}", Globals::ProductName, Globals::CompanyName);
     LOG(Info, "Current culture: {0}", Platform::GetUserLocaleName());
     LOG(Info, "Command line: {0}", CommandLine);
-    LOG(Info, "Base directory: {0}", Globals::StartupFolder);
+    LOG(Info, "Base folder: {0}", Globals::StartupFolder);
+    LOG(Info, "Binaries folder: {0}", Globals::BinariesFolder);
     LOG(Info, "Temporary folder: {0}", Globals::TemporaryFolder);
     LOG(Info, "Project folder: {0}", Globals::ProjectFolder);
 #if USE_EDITOR
diff --git a/Source/Platforms/Mac/Default.icns b/Source/Platforms/Mac/Default.icns
new file mode 100644
index 0000000000000000000000000000000000000000..455acd991a7572831f097c615562180774495fd7
GIT binary patch
literal 193857
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%0A>9LdZ9oAsE@>)QlAl$t0#bRiK)~
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%0AIs&*bb=ae
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

literal 0
HcmV?d00001

diff --git a/Source/Platforms/Mac/Default.plist b/Source/Platforms/Mac/Default.plist
new file mode 100644
index 000000000..3041bba71
--- /dev/null
+++ b/Source/Platforms/Mac/Default.plist
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleIconFile</key>
+	<string>icon.icns</string>
+	<key>CFBundleExecutable</key>
+	<string>{Executable}</string>
+	<key>CFBundleName</key>
+	<string>FlaxEditor</string>
+	<key>CFBundleIdentifier</key>
+	<string>com.flaxengine.editor</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>{Version}</string>
+	<key>CFBundleVersion</key>
+	<string>{Version}</string>
+	<key>NSRequiresAquaSystemAppearance</key>
+	<false/>
+	<key>NSHumanReadableCopyright</key>
+	<string>{Copyright}</string>
+	<key>CFBundleSupportedPlatforms</key>
+	<array>
+		<string>MacOSX</string>
+	</array>
+	<key>NSPrincipalClass</key>
+	<string>NSApplication</string>
+	<key>LSApplicationCategoryType</key>
+	<string>public.app-category.developer-tools</string>
+	<key>LSMinimumSystemVersion</key>
+	<string>10.15</string>
+	<key>LSMinimumSystemVersionByArchitecture</key>
+	<dict>
+		<key>{Arch}</key>
+		<string>10.15</string>
+	</dict>
+	<key>NSHighResolutionCapable</key>
+	<true/>
+</dict>
+</plist>
diff --git a/Source/Tools/Flax.Build/Deploy/Deployment.Editor.cs b/Source/Tools/Flax.Build/Deploy/Deployment.Editor.cs
index 981c15a55..91da6d83d 100644
--- a/Source/Tools/Flax.Build/Deploy/Deployment.Editor.cs
+++ b/Source/Tools/Flax.Build/Deploy/Deployment.Editor.cs
@@ -6,6 +6,7 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
+using System.Text;
 using Flax.Build;
 using Flax.Build.Platforms;
 
@@ -126,6 +127,45 @@ namespace Flax.Deploy
                 // Deploy project
                 DeployFile(RootPath, OutputPath, "Flax.flaxproj");
 
+                // Package Editor into macOS app
+                if (Platform.BuildTargetPlatform == TargetPlatform.Mac)
+                {
+                    var arch = Platform.BuildTargetArchitecture;
+                    Log.Info(string.Empty);
+                    Log.Info("Creating macOS app...");
+                    var appPath = Path.Combine(Deployer.PackageOutputPath, "FlaxEditor.app");
+                    var appContentsPath = Path.Combine(appPath, "Contents");
+                    var appBinariesPath = Path.Combine(appContentsPath, "MacOS");
+                    Utilities.DirectoryDelete(appPath);
+                    Directory.CreateDirectory(appPath);
+                    Directory.CreateDirectory(appContentsPath);
+                    Directory.CreateDirectory(appBinariesPath);
+
+                    // Copy icons set
+                    Directory.CreateDirectory(Path.Combine(appContentsPath, "Resources"));
+                    Utilities.FileCopy(Path.Combine(Globals.EngineRoot, "Source/Platforms/Mac/Default.icns"), Path.Combine(appContentsPath, "Resources/icon.icns"));
+
+                    // Create PkgInfo file
+                    File.WriteAllText(Path.Combine(appContentsPath, "PkgInfo"), "APPL???", Encoding.ASCII);
+
+                    // Create Info.plist
+                    var plist = File.ReadAllText(Path.Combine(Globals.EngineRoot, "Source/Platforms/Mac/Default.plist"));
+                    var flaxProject = EngineTarget.EngineProject;
+                    plist = plist.Replace("{Version}", flaxProject.Version.ToString());
+                    plist = plist.Replace("{Copyright}", flaxProject.Copyright);
+                    plist = plist.Replace("{Executable}", "FlaxEditor");
+                    plist = plist.Replace("{Arch}", arch == TargetArchitecture.ARM64 ? "arm64" : "x86_64");
+                    File.WriteAllText(Path.Combine(appContentsPath, "Info.plist"), plist, Encoding.ASCII);
+
+                    // Copy output editor files
+                    Utilities.DirectoryCopy(OutputPath, appContentsPath);
+
+                    // Copy native binaries for app execution
+                    var defaultEditorConfig = "Development";
+                    var ediotrBinariesPath = Path.Combine(appContentsPath, "Binaries/Editor/Mac", defaultEditorConfig);
+                    Utilities.DirectoryCopy(ediotrBinariesPath, appBinariesPath, true, true);
+                }
+
                 // Compress
                 if (Configuration.DontCompress)
                     return;

From dc324b4ec69a1fdc94a149ad09bf05f5cae2f797 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Sat, 23 Sep 2023 14:47:16 +0200
Subject: [PATCH 021/103] Fix crash when max files open limit is too small on
 macOS/iOS

---
 Source/Engine/Platform/Apple/ApplePlatform.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/Source/Engine/Platform/Apple/ApplePlatform.cpp b/Source/Engine/Platform/Apple/ApplePlatform.cpp
index eeef5b91f..25964ff83 100644
--- a/Source/Engine/Platform/Apple/ApplePlatform.cpp
+++ b/Source/Engine/Platform/Apple/ApplePlatform.cpp
@@ -30,6 +30,7 @@
 #include <stdlib.h>
 #include <sys/sysctl.h>
 #include <sys/time.h>
+#include <sys/resource.h>
 #include <mach/mach_time.h>
 #include <mach-o/dyld.h>
 #include <uuid/uuid.h>
@@ -309,6 +310,14 @@ bool ApplePlatform::Init()
         OnPlatformUserAdd(New<User>(username));
     }
 
+    // Increase the maximum number of simultaneously open files
+    {
+        struct rlimit limit;
+        limit.rlim_cur = OPEN_MAX;
+        limit.rlim_max = RLIM_INFINITY;
+        setrlimit(RLIMIT_NOFILE, &limit);
+    }
+
     AutoreleasePool = [[NSAutoreleasePool alloc] init];
 
     return false;

From 10bcb2600503f6cab181a94aaafeb69cca0f6646 Mon Sep 17 00:00:00 2001
From: Ari Vuollet <ari.vuollet@kapsi.fi>
Date: Sat, 23 Sep 2023 18:29:27 +0300
Subject: [PATCH 022/103] Fix invalid characters in generated C# launch
 settings paths

---
 .../Projects/VisualStudio/VisualStudioProjectGenerator.cs     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Source/Tools/Flax.Build/Projects/VisualStudio/VisualStudioProjectGenerator.cs b/Source/Tools/Flax.Build/Projects/VisualStudio/VisualStudioProjectGenerator.cs
index ecf70f9f8..74ade53ac 100644
--- a/Source/Tools/Flax.Build/Projects/VisualStudio/VisualStudioProjectGenerator.cs
+++ b/Source/Tools/Flax.Build/Projects/VisualStudio/VisualStudioProjectGenerator.cs
@@ -558,8 +558,8 @@ namespace Flax.Build.Projects.VisualStudio
             {
                 var profiles = new Dictionary<string, string>();
                 var profile = new StringBuilder();
-                var editorPath = Utilities.NormalizePath(Path.Combine(Globals.EngineRoot, Platform.GetEditorBinaryDirectory(), $"Development/FlaxEditor{Utilities.GetPlatformExecutableExt()}"));
-                var workspacePath = Utilities.NormalizePath(solutionDirectory);
+                var editorPath = Utilities.NormalizePath(Path.Combine(Globals.EngineRoot, Platform.GetEditorBinaryDirectory(), $"Development/FlaxEditor{Utilities.GetPlatformExecutableExt()}")).Replace('\\', '/');
+                var workspacePath = Utilities.NormalizePath(solutionDirectory).Replace('\\', '/');
                 foreach (var project in projects)
                 {
                     if (project.Type == TargetType.DotNetCore)

From 038a3603e41f4d44323655657607dfc447967253 Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Sun, 24 Sep 2023 19:33:03 +0200
Subject: [PATCH 023/103] - Possible nodes get filtered now depending on the
 available node ports

---
 .../Editor/Surface/ContextMenu/VisjectCM.cs   | 14 ++++--
 .../Surface/ContextMenu/VisjectCMGroup.cs     | 39 ++++++++++++++---
 .../Surface/ContextMenu/VisjectCMItem.cs      | 43 ++++++++++++++++++-
 3 files changed, 86 insertions(+), 10 deletions(-)

diff --git a/Source/Editor/Surface/ContextMenu/VisjectCM.cs b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
index bae62556e..24cb29cb9 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCM.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
@@ -419,7 +419,7 @@ namespace FlaxEditor.Surface.ContextMenu
 
             Profiler.BeginEvent("VisjectCM.OnSearchFilterChanged");
             
-            if (string.IsNullOrEmpty(_searchBox.Text))
+            if (string.IsNullOrEmpty(_searchBox.Text) && _selectedBox == null)
             {
                 ResetView();
                 Profiler.EndEvent();
@@ -430,7 +430,7 @@ namespace FlaxEditor.Surface.ContextMenu
             LockChildrenRecursive();
             for (int i = 0; i < _groups.Count; i++)
             {
-                _groups[i].UpdateFilter(_searchBox.Text);
+                _groups[i].UpdateFilter(_searchBox.Text, _selectedBox);
                 _groups[i].UpdateItemSort(_selectedBox);
             }
             SortGroups();
@@ -503,12 +503,19 @@ namespace FlaxEditor.Surface.ContextMenu
             _searchBox.Clear();
             SelectedItem = null;
             for (int i = 0; i < _groups.Count; i++)
+            {
                 _groups[i].ResetView();
+            }
             UnlockChildrenRecursive();
 
             SortGroups();
             PerformLayout();
 
+            for (int i = 0; i < _groups.Count; i++)
+            {
+                _groups[i].EvaluateVisibilityWithBox(_selectedBox);
+            }
+            
             Profiler.EndEvent();
         }
 
@@ -626,10 +633,11 @@ namespace FlaxEditor.Surface.ContextMenu
             // Prepare
             UpdateSurfaceParametersGroup();
             ResetView();
+            
             _panel1.VScrollBar.TargetValue = 0;
             Focus();
             _waitingForInput = true;
-
+            
             base.OnShow();
         }
 
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
index 446840f2c..cd189ab94 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
@@ -66,7 +66,7 @@ namespace FlaxEditor.Surface.ContextMenu
             {
                 if (_children[i] is VisjectCMItem item)
                 {
-                    item.UpdateFilter(null);
+                    item.UpdateFilter(null, null);
                     item.UpdateScore(null);
                 }
             }
@@ -84,7 +84,7 @@ namespace FlaxEditor.Surface.ContextMenu
         /// Updates the filter.
         /// </summary>
         /// <param name="filterText">The filter text.</param>
-        public void UpdateFilter(string filterText)
+        public void UpdateFilter(string filterText, Box selectedBox)
         {
             Profiler.BeginEvent("VisjectCMGroup.UpdateFilter");
 
@@ -94,13 +94,13 @@ namespace FlaxEditor.Surface.ContextMenu
             {
                 if (_children[i] is VisjectCMItem item)
                 {
-                    item.UpdateFilter(filterText);
+                    item.UpdateFilter(filterText, selectedBox);
                     isAnyVisible |= item.Visible;
                 }
             }
 
             // Update header title
-            if (QueryFilterHelper.Match(filterText, HeaderText))
+            /*if (QueryFilterHelper.Match(filterText, HeaderText))
             {
                 for (int i = 0; i < _children.Count; i++)
                 {
@@ -110,7 +110,7 @@ namespace FlaxEditor.Surface.ContextMenu
                     }
                 }
                 isAnyVisible = true;
-            }
+            }*/
 
             // Update itself
             if (isAnyVisible)
@@ -128,6 +128,35 @@ namespace FlaxEditor.Surface.ContextMenu
             Profiler.EndEvent();
         }
 
+        public void EvaluateVisibilityWithBox(Box selectedBox)
+        {
+            if (selectedBox == null)
+            {
+                Visible = true;
+                return;
+            }
+
+            bool isAnyVisible = false;
+            for (int i = 0; i < _children.Count; i++)
+            {
+                if (_children[i] is VisjectCMItem item)
+                {
+                    isAnyVisible |= item.IsCompatibleWithBox(selectedBox);
+                }
+            }
+            
+            // Update itself
+            if (isAnyVisible)
+            {
+                Visible = true;
+            }
+            else
+            {
+                // Hide group if none of the items matched the filter
+                Visible = false;
+            }
+        }
+        
         /// <summary>
         /// Updates the sorting of the <see cref="VisjectCMItem"/>s of this <see cref="VisjectCMGroup"/>
         /// Also updates the <see cref="SortScore"/>
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index b68d529a1..b2d5fd7a8 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -113,12 +113,51 @@ namespace FlaxEditor.Surface.ContextMenu
             return false;
         }
 
+        public bool IsCompatibleWithBox(Box box)
+        {
+            if (box == null)
+                return true;
+            
+            if(_archetype?.Elements == null)
+                return false;
+            
+            bool isCompatible = false;
+            foreach (NodeElementArchetype element in _archetype.Elements)
+            {
+                if(element.Type != NodeElementType.Output && element.Type != NodeElementType.Input)
+                    continue;
+                
+                if ((box.IsOutput && element.Type == NodeElementType.Output) || (!box.IsOutput && element.Type == NodeElementType.Input))
+                    continue;
+                
+                bool checkCompatibility = box.CanUseType(element.ConnectionsType);;
+                if (!checkCompatibility)
+                {
+                    if ((element.ConnectionsType == null || element.ConnectionsType == typeof(void)) && box.CurrentType != typeof(FlaxEngine.Object))
+                        checkCompatibility = true;
+                }
+                isCompatible |= checkCompatibility;
+                
+                /*if(!isCompatible)
+                    Debug.Log($"Is {_archetype.Title} cant connect type {element.ConnectionsType}");*/
+            }
+            
+            Visible = isCompatible;
+            return isCompatible;
+        }
+        
         /// <summary>
         /// Updates the filter.
         /// </summary>
         /// <param name="filterText">The filter text.</param>
-        public void UpdateFilter(string filterText)
+        public void UpdateFilter(string filterText, Box selectedBox)
         {
+            if (selectedBox != null)
+            {
+                if (!IsCompatibleWithBox(selectedBox))
+                    return;
+            }
+            
             _isStartsWithMatch = _isFullMatch = false;
             if (filterText == null)
             {
@@ -192,7 +231,7 @@ namespace FlaxEditor.Surface.ContextMenu
                 }
             }
         }
-
+        
         /// <inheritdoc />
         public override void Draw()
         {

From 8d39d51f900dd879f2975b299c2e192050508f97 Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Sun, 24 Sep 2023 20:22:44 +0200
Subject: [PATCH 024/103] - Added profiling

---
 Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs |  4 ++++
 Source/Editor/Surface/ContextMenu/VisjectCMItem.cs  | 10 +++++++---
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
index cd189ab94..9b5da5913 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
@@ -136,6 +136,8 @@ namespace FlaxEditor.Surface.ContextMenu
                 return;
             }
 
+            Profiler.BeginEvent("VisjectCMGroup.EvaluateVisibilityWithBox");
+            
             bool isAnyVisible = false;
             for (int i = 0; i < _children.Count; i++)
             {
@@ -155,6 +157,8 @@ namespace FlaxEditor.Surface.ContextMenu
                 // Hide group if none of the items matched the filter
                 Visible = false;
             }
+            
+            Profiler.EndEvent();
         }
         
         /// <summary>
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index b2d5fd7a8..dc13a0e2b 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -121,6 +121,8 @@ namespace FlaxEditor.Surface.ContextMenu
             if(_archetype?.Elements == null)
                 return false;
             
+            Profiler.BeginEvent("VisjectCMItem.IsCompatibleWithBox");
+            
             bool isCompatible = false;
             foreach (NodeElementArchetype element in _archetype.Elements)
             {
@@ -129,11 +131,11 @@ namespace FlaxEditor.Surface.ContextMenu
                 
                 if ((box.IsOutput && element.Type == NodeElementType.Output) || (!box.IsOutput && element.Type == NodeElementType.Input))
                     continue;
-                
-                bool checkCompatibility = box.CanUseType(element.ConnectionsType);;
+
+                bool checkCompatibility = ((element.ConnectionsType == null || element.ConnectionsType == typeof(void)) && box.CurrentType != typeof(FlaxEngine.Object));
                 if (!checkCompatibility)
                 {
-                    if ((element.ConnectionsType == null || element.ConnectionsType == typeof(void)) && box.CurrentType != typeof(FlaxEngine.Object))
+                    if (box.CanUseType(element.ConnectionsType))
                         checkCompatibility = true;
                 }
                 isCompatible |= checkCompatibility;
@@ -143,6 +145,8 @@ namespace FlaxEditor.Surface.ContextMenu
             }
             
             Visible = isCompatible;
+            
+            Profiler.EndEvent();
             return isCompatible;
         }
         

From 50ebd5cb8727a3d54fcde07f5cf3f30ffa50d153 Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Sun, 24 Sep 2023 20:31:22 +0200
Subject: [PATCH 025/103] - Fixed massive UI freeze because of perform layout
 oversight

---
 Source/Editor/Surface/ContextMenu/VisjectCM.cs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/Source/Editor/Surface/ContextMenu/VisjectCM.cs b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
index 24cb29cb9..3a3dfe027 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCM.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
@@ -506,15 +506,14 @@ namespace FlaxEditor.Surface.ContextMenu
             {
                 _groups[i].ResetView();
             }
-            UnlockChildrenRecursive();
-
-            SortGroups();
-            PerformLayout();
-
             for (int i = 0; i < _groups.Count; i++)
             {
                 _groups[i].EvaluateVisibilityWithBox(_selectedBox);
             }
+            UnlockChildrenRecursive();
+
+            SortGroups();
+            PerformLayout();
             
             Profiler.EndEvent();
         }

From 33c51d0a8eaac7ec6190d3c784b4189baadfd873 Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Mon, 25 Sep 2023 19:10:05 +0200
Subject: [PATCH 026/103] - Filtering is functioning now for all default groups

---
 .../Editor/Surface/ContextMenu/VisjectCM.cs   |   3 -
 .../Surface/ContextMenu/VisjectCMGroup.cs     |   2 +-
 .../Surface/ContextMenu/VisjectCMItem.cs      | 110 ++++++++++++++++--
 3 files changed, 99 insertions(+), 16 deletions(-)

diff --git a/Source/Editor/Surface/ContextMenu/VisjectCM.cs b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
index 3a3dfe027..1cec9554b 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCM.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
@@ -505,9 +505,6 @@ namespace FlaxEditor.Surface.ContextMenu
             for (int i = 0; i < _groups.Count; i++)
             {
                 _groups[i].ResetView();
-            }
-            for (int i = 0; i < _groups.Count; i++)
-            {
                 _groups[i].EvaluateVisibilityWithBox(_selectedBox);
             }
             UnlockChildrenRecursive();
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
index 9b5da5913..9560aecbb 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
@@ -143,7 +143,7 @@ namespace FlaxEditor.Surface.ContextMenu
             {
                 if (_children[i] is VisjectCMItem item)
                 {
-                    isAnyVisible |= item.IsCompatibleWithBox(selectedBox);
+                    isAnyVisible |= item.CanConnectTo(selectedBox);
                 }
             }
             
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index dc13a0e2b..4030017a7 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -3,6 +3,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using FlaxEditor.Scripting;
 using FlaxEditor.Surface.Elements;
 using FlaxEditor.Utilities;
 using FlaxEngine;
@@ -113,31 +114,45 @@ namespace FlaxEditor.Surface.ContextMenu
             return false;
         }
 
-        public bool IsCompatibleWithBox(Box box)
+        public bool CanConnectTo(Box startBox)
         {
-            if (box == null)
+            if (startBox == null)
                 return true;
             
             if(_archetype?.Elements == null)
                 return false;
             
-            Profiler.BeginEvent("VisjectCMItem.IsCompatibleWithBox");
-            
             bool isCompatible = false;
             foreach (NodeElementArchetype element in _archetype.Elements)
             {
                 if(element.Type != NodeElementType.Output && element.Type != NodeElementType.Input)
                     continue;
                 
-                if ((box.IsOutput && element.Type == NodeElementType.Output) || (!box.IsOutput && element.Type == NodeElementType.Input))
+                if ((startBox.IsOutput && element.Type == NodeElementType.Output) || (!startBox.IsOutput && element.Type == NodeElementType.Input))
                     continue;
-
-                bool checkCompatibility = ((element.ConnectionsType == null || element.ConnectionsType == typeof(void)) && box.CurrentType != typeof(FlaxEngine.Object));
-                if (!checkCompatibility)
+                
+                ScriptType inType;
+                ScriptType outType;
+                ConnectionsHint hint;
+                if (startBox.IsOutput)
                 {
-                    if (box.CanUseType(element.ConnectionsType))
-                        checkCompatibility = true;
+                    inType = element.ConnectionsType;
+                    outType = startBox.CurrentType;
+                    hint = _archetype.ConnectionsHints;
                 }
+                else
+                {
+                    inType = startBox.CurrentType;
+                    outType = element.ConnectionsType;
+                    hint = startBox.ParentNode.Archetype.ConnectionsHints;
+                }
+                
+                bool checkCompatibility = CanCastToType(inType, outType, hint);
+                /*if (!checkCompatibility)
+                {
+                    /*checkCompatibility = element.ConnectionsType == null && startBox.CurrentType != ScriptType.Object;#1#
+                    checkCompatibility = 
+                }*/
                 isCompatible |= checkCompatibility;
                 
                 /*if(!isCompatible)
@@ -146,9 +161,80 @@ namespace FlaxEditor.Surface.ContextMenu
             
             Visible = isCompatible;
             
-            Profiler.EndEvent();
             return isCompatible;
         }
+
+        private bool CanCastToType(ScriptType currentType, ScriptType type, ConnectionsHint hint)
+        {
+            if (VisjectSurface.CanUseDirectCastStatic(type, currentType, false))
+                return true;
+
+            var connectionsHints = hint;
+            if (currentType == ScriptType.Null && connectionsHints != ConnectionsHint.None)
+            {
+                if ((connectionsHints & ConnectionsHint.Anything) == ConnectionsHint.Anything)
+                    return true;
+                if ((connectionsHints & ConnectionsHint.Value) == ConnectionsHint.Value && type.Type != typeof(void))
+                    return true;
+                if ((connectionsHints & ConnectionsHint.Enum) == ConnectionsHint.Enum && type.IsEnum)
+                    return true;
+                if ((connectionsHints & ConnectionsHint.Array) == ConnectionsHint.Array && type.IsArray)
+                    return true;
+                if ((connectionsHints & ConnectionsHint.Dictionary) == ConnectionsHint.Dictionary && type.IsDictionary)
+                    return true;
+                if ((connectionsHints & ConnectionsHint.Vector) == ConnectionsHint.Vector)
+                {
+                    var t = type.Type;
+                    if (t == typeof(Vector2) ||
+                        t == typeof(Vector3) ||
+                        t == typeof(Vector4) ||
+                        t == typeof(Float2) ||
+                        t == typeof(Float3) ||
+                        t == typeof(Float4) ||
+                        t == typeof(Double2) ||
+                        t == typeof(Double3) ||
+                        t == typeof(Double4) ||
+                        t == typeof(Int2) ||
+                        t == typeof(Int3) ||
+                        t == typeof(Int4) ||
+                        t == typeof(Color))
+                    {
+                        return true;
+                    }
+                }
+                if ((connectionsHints & ConnectionsHint.Scalar) == ConnectionsHint.Scalar)
+                {
+                    var t = type.Type;
+                    if (t == typeof(bool) ||
+                        t == typeof(char) ||
+                        t == typeof(byte) ||
+                        t == typeof(short) ||
+                        t == typeof(ushort) ||
+                        t == typeof(int) ||
+                        t == typeof(uint) ||
+                        t == typeof(long) ||
+                        t == typeof(ulong) ||
+                        t == typeof(float) ||
+                        t == typeof(double))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return CanCast(type, currentType);
+        }
+        
+        private static bool CanCast(ScriptType oB, ScriptType iB)
+        {
+            if (oB == iB)
+                return true;
+            if (oB == ScriptType.Null || iB == ScriptType.Null)
+                return false;
+            return (oB.Type != typeof(void) && oB.Type != typeof(FlaxEngine.Object)) &&
+                   (iB.Type != typeof(void) && iB.Type != typeof(FlaxEngine.Object)) &&
+                   oB.IsAssignableFrom(iB);
+        }
         
         /// <summary>
         /// Updates the filter.
@@ -158,7 +244,7 @@ namespace FlaxEditor.Surface.ContextMenu
         {
             if (selectedBox != null)
             {
-                if (!IsCompatibleWithBox(selectedBox))
+                if (!CanConnectTo(selectedBox))
                     return;
             }
             

From 3b393ef4db27e2ccb629ba006646be973ba2fe0a Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Mon, 25 Sep 2023 21:58:05 +0200
Subject: [PATCH 027/103] Groups now get filtered by box type when added after
 the context menu was opened

---
 Source/Editor/Surface/ContextMenu/VisjectCM.cs  |  5 +++++
 .../Editor/Surface/ContextMenu/VisjectCMItem.cs | 17 +++++++++++++++--
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/Source/Editor/Surface/ContextMenu/VisjectCM.cs b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
index 1cec9554b..04130fc1e 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCM.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
@@ -288,6 +288,10 @@ namespace FlaxEditor.Surface.ContextMenu
                         OnSearchFilterChanged();
                     }
                 }
+                else
+                {
+                    group.EvaluateVisibilityWithBox(_selectedBox);
+                }
 
                 Profiler.EndEvent();
             }
@@ -321,6 +325,7 @@ namespace FlaxEditor.Surface.ContextMenu
                             Parent = group
                         };
                     }
+                    group.EvaluateVisibilityWithBox(_selectedBox); 
                     group.SortChildren();
                     group.Parent = _groupsPanel;
                     _groups.Add(group);
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index 4030017a7..00854ef5a 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -117,10 +117,23 @@ namespace FlaxEditor.Surface.ContextMenu
         public bool CanConnectTo(Box startBox)
         {
             if (startBox == null)
-                return true;
+            {
+                Visible = true;
+                return true;   
+            }
+
+            if (_archetype.Title == "GetChild")
+            {
+                Debug.Log("");
+                Debug.Log(_archetype.Create == null);
+                Debug.Log(_archetype.Create.GetType() == typeof(FlaxEditor.Surface.Archetypes.Function.MethodOverrideNode));
+            }
             
-            if(_archetype?.Elements == null)
+            if (_archetype?.Elements == null)
+            {
+                Visible = false;
                 return false;
+            }
             
             bool isCompatible = false;
             foreach (NodeElementArchetype element in _archetype.Elements)

From d8e2b06c3828e53cea73ee98f4183166c54bcbb7 Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Mon, 25 Sep 2023 23:26:33 +0200
Subject: [PATCH 028/103] - Minor cleanup

---
 .../Editor/Surface/ContextMenu/VisjectCMItem.cs   | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index 00854ef5a..7b0ce6c85 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -121,13 +121,6 @@ namespace FlaxEditor.Surface.ContextMenu
                 Visible = true;
                 return true;   
             }
-
-            if (_archetype.Title == "GetChild")
-            {
-                Debug.Log("");
-                Debug.Log(_archetype.Create == null);
-                Debug.Log(_archetype.Create.GetType() == typeof(FlaxEditor.Surface.Archetypes.Function.MethodOverrideNode));
-            }
             
             if (_archetype?.Elements == null)
             {
@@ -161,15 +154,7 @@ namespace FlaxEditor.Surface.ContextMenu
                 }
                 
                 bool checkCompatibility = CanCastToType(inType, outType, hint);
-                /*if (!checkCompatibility)
-                {
-                    /*checkCompatibility = element.ConnectionsType == null && startBox.CurrentType != ScriptType.Object;#1#
-                    checkCompatibility = 
-                }*/
                 isCompatible |= checkCompatibility;
-                
-                /*if(!isCompatible)
-                    Debug.Log($"Is {_archetype.Title} cant connect type {element.ConnectionsType}");*/
             }
             
             Visible = isCompatible;

From 0f53c486ede20258d564c1927a1e444a8bdd8a8f Mon Sep 17 00:00:00 2001
From: Menotdan <32620310+Menotdan@users.noreply.github.com>
Date: Tue, 26 Sep 2023 00:05:50 -0400
Subject: [PATCH 029/103] Fixed formatting to match master branch

---
 Source/Editor/Content/Import/ModelImportEntry.cs    | 1 -
 Source/Engine/Content/Content.cpp                   | 1 -
 Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp | 1 -
 3 files changed, 3 deletions(-)

diff --git a/Source/Editor/Content/Import/ModelImportEntry.cs b/Source/Editor/Content/Import/ModelImportEntry.cs
index a29036c88..bbb384562 100644
--- a/Source/Editor/Content/Import/ModelImportEntry.cs
+++ b/Source/Editor/Content/Import/ModelImportEntry.cs
@@ -1,6 +1,5 @@
 // Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
 
-using System;
 using System.Collections.Generic;
 using FlaxEditor.CustomEditors.Editors;
 using FlaxEditor.Scripting;
diff --git a/Source/Engine/Content/Content.cpp b/Source/Engine/Content/Content.cpp
index 4ad97ebc2..eabf58cf2 100644
--- a/Source/Engine/Content/Content.cpp
+++ b/Source/Engine/Content/Content.cpp
@@ -28,7 +28,6 @@
 #if ENABLE_ASSETS_DISCOVERY
 #include "Engine/Core/Collections/HashSet.h"
 #endif
-#include <Engine/Debug/DebugLog.h>
 
 TimeSpan Content::AssetsUpdateInterval = TimeSpan::FromMilliseconds(500);
 TimeSpan Content::AssetsUnloadInterval = TimeSpan::FromSeconds(10);
diff --git a/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp b/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
index f91c1b4b3..215eadaba 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
@@ -542,7 +542,6 @@ bool ProcessMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofb
         else
             aMaterial = aMesh->getMaterial(0);
     }
-
     mesh.MaterialSlotIndex = data.AddMaterial(result, aMaterial);
 
     // Vertex positions

From f06af4d58970691d05778c6083f1f59ecd8b6961 Mon Sep 17 00:00:00 2001
From: Menotdan <32620310+Menotdan@users.noreply.github.com>
Date: Tue, 26 Sep 2023 00:09:57 -0400
Subject: [PATCH 030/103] Visual studio auto-formatting fixed by just editing
 it in notepad :)

---
 .../Editor/Managed/ManagedEditor.Internal.cpp  | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/Source/Editor/Managed/ManagedEditor.Internal.cpp b/Source/Editor/Managed/ManagedEditor.Internal.cpp
index 49a25f4e7..49c3af87e 100644
--- a/Source/Editor/Managed/ManagedEditor.Internal.cpp
+++ b/Source/Editor/Managed/ManagedEditor.Internal.cpp
@@ -118,7 +118,7 @@ DEFINE_INTERNAL_CALL(bool) EditorInternal_IsDevInstance()
 #if COMPILE_WITH_DEV_ENV
     return true;
 #else
-    return false;
+	return false;
 #endif
 }
 
@@ -151,7 +151,7 @@ DEFINE_INTERNAL_CALL(int32) EditorInternal_ReadOutputLogs(MArray** outMessages,
     int64* outLogTimesPtr = MCore::Array::GetAddress<int64>(*outLogTimes);
     while (count < maxCount && ptr != end)
     {
-        auto type = (byte) * (int32*)ptr;
+        auto type = (byte)*(int32*)ptr;
         ptr += 4;
 
         auto time = *(int64*)ptr;
@@ -338,7 +338,7 @@ DEFINE_INTERNAL_CALL(bool) EditorInternal_CanExport(MString* pathObj)
 
     return AssetsExportingManager::CanExport(path);
 #else
-    return false;
+	return false;
 #endif
 }
 
@@ -355,7 +355,7 @@ DEFINE_INTERNAL_CALL(bool) EditorInternal_Export(MString* inputPathObj, MString*
 
     return AssetsExportingManager::Export(inputPath, outputFolder);
 #else
-    return false;
+	return false;
 #endif
 }
 
@@ -413,8 +413,8 @@ DEFINE_INTERNAL_CALL(bool) EditorInternal_CookMeshCollision(MString* pathObj, Co
     arg.ConvexVertexLimit = convexVertexLimit;
     return CreateCollisionData::CookMeshCollision(path, arg);
 #else
-    LOG(Warning, "Collision cooking is disabled.");
-    return true;
+	LOG(Warning, "Collision cooking is disabled.");
+	return true;
 #endif
 }
 
@@ -522,7 +522,7 @@ DEFINE_INTERNAL_CALL(void) EditorInternal_RunVisualScriptBreakpointLoopTick(floa
                 continue;
             switch (e.Type)
             {
-                // Keyboard events
+            // Keyboard events
             case InputDevice::EventType::Char:
                 window->OnCharInput(e.CharData.Char);
                 break;
@@ -532,7 +532,7 @@ DEFINE_INTERNAL_CALL(void) EditorInternal_RunVisualScriptBreakpointLoopTick(floa
             case InputDevice::EventType::KeyUp:
                 window->OnKeyUp(e.KeyData.Key);
                 break;
-                // Mouse events
+            // Mouse events
             case InputDevice::EventType::MouseDown:
                 window->OnMouseDown(window->ScreenToClient(e.MouseData.Position), e.MouseData.Button);
                 break;
@@ -829,4 +829,4 @@ bool ManagedEditor::TryRestoreImportOptions(ModelTool::Options& options, String
     // Get options from model
     FileSystem::NormalizePath(assetPath);
     return ImportModelFile::TryGetImportOptions(assetPath, options);
-}
+}
\ No newline at end of file

From ea1da0481fee1fc2ef2b69de8dd75abe21e305e9 Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Tue, 26 Sep 2023 08:35:10 -0500
Subject: [PATCH 031/103] Change input event to trigger different input states.

---
 Source/Engine/Engine/InputEvent.cs | 37 +++++++++++++++++++++++++-----
 Source/Engine/Input/Input.cpp      |  6 ++---
 Source/Engine/Input/Input.h        |  2 +-
 3 files changed, 35 insertions(+), 10 deletions(-)

diff --git a/Source/Engine/Engine/InputEvent.cs b/Source/Engine/Engine/InputEvent.cs
index 176d21fd0..c6c46c43d 100644
--- a/Source/Engine/Engine/InputEvent.cs
+++ b/Source/Engine/Engine/InputEvent.cs
@@ -16,14 +16,24 @@ namespace FlaxEngine
         public string Name;
 
         /// <summary>
-        /// Returns true if the event has been triggered during the current frame (e.g. user pressed a key). Use <see cref="Triggered"/> to catch events without active waiting.
+        /// Returns true if the event has been triggered during the current frame (e.g. user pressed a key). Use <see cref="Pressed"/>, <see cref="Pressing"/>, <see cref="Released"/> to catch events without active waiting.
         /// </summary>
         public bool Active => Input.GetAction(Name);
 
         /// <summary>
-        /// Occurs when event is triggered (e.g. user pressed a key). Called before scripts update.
+        /// Occurs when event is pressed (e.g. user pressed a key). Called before scripts update.
         /// </summary>
-        public event Action Triggered;
+        public event Action Pressed;
+        
+        /// <summary>
+        /// Occurs when event is being pressing (e.g. user pressing a key). Called before scripts update.
+        /// </summary>
+        public event Action Pressing;
+        
+        /// <summary>
+        /// Occurs when event is released (e.g. user releases a key). Called before scripts update.
+        /// </summary>
+        public event Action Released;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="InputEvent"/> class.
@@ -51,10 +61,25 @@ namespace FlaxEngine
             Input.ActionTriggered -= Handler;
         }
 
-        private void Handler(string name)
+        private void Handler(string name, InputActionState state)
         {
-            if (string.Equals(name, Name, StringComparison.OrdinalIgnoreCase))
-                Triggered?.Invoke();
+            if (!string.Equals(name, Name, StringComparison.OrdinalIgnoreCase))
+                return;
+            switch (state)
+            {
+            case InputActionState.None: break;
+            case InputActionState.Waiting: break;
+            case InputActionState.Pressing:
+                Pressing?.Invoke();
+                break;
+            case InputActionState.Press:
+                Pressed?.Invoke();
+                break;
+            case InputActionState.Release:
+                Released?.Invoke();
+                break;
+            default: break;
+            }
         }
 
         /// <summary>
diff --git a/Source/Engine/Input/Input.cpp b/Source/Engine/Input/Input.cpp
index 81411ed76..af5600823 100644
--- a/Source/Engine/Input/Input.cpp
+++ b/Source/Engine/Input/Input.cpp
@@ -97,7 +97,7 @@ Action Input::MouseLeave;
 Delegate<const Float2&, int32> Input::TouchDown;
 Delegate<const Float2&, int32> Input::TouchMove;
 Delegate<const Float2&, int32> Input::TouchUp;
-Delegate<StringView> Input::ActionTriggered;
+Delegate<StringView, const InputActionState&> Input::ActionTriggered;
 Array<ActionConfig> Input::ActionMappings;
 Array<AxisConfig> Input::AxisMappings;
 
@@ -1022,9 +1022,9 @@ void InputService::Update()
     {
         for (auto i = Actions.Begin(); i.IsNotEnd(); ++i)
         {
-            if (i->Value.Active)
+            if (i->Value.State != InputActionState::Waiting)
             {
-                Input::ActionTriggered(i->Key);
+                Input::ActionTriggered(i->Key, i->Value.State);
             }
         }
     }
diff --git a/Source/Engine/Input/Input.h b/Source/Engine/Input/Input.h
index 84d312fa3..5ff02eda9 100644
--- a/Source/Engine/Input/Input.h
+++ b/Source/Engine/Input/Input.h
@@ -293,7 +293,7 @@ public:
     /// Event fired when virtual input action is triggered. Called before scripts update. See <see cref="ActionMappings"/> to edit configuration.
     /// </summary>
     /// <seealso cref="InputEvent"/>
-    API_EVENT() static Delegate<StringView> ActionTriggered;
+    API_EVENT() static Delegate<StringView, const InputActionState&> ActionTriggered;
 
     /// <summary>
     /// Gets the value of the virtual action identified by name. Use <see cref="ActionMappings"/> to get the current config.

From eeab9774a91d2425048c11b3f1eb6270e133c38d Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Tue, 26 Sep 2023 09:31:23 -0500
Subject: [PATCH 032/103] Add easily getting action state

---
 Source/Engine/Engine/InputEvent.cs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/Source/Engine/Engine/InputEvent.cs b/Source/Engine/Engine/InputEvent.cs
index c6c46c43d..b8b3dbfa9 100644
--- a/Source/Engine/Engine/InputEvent.cs
+++ b/Source/Engine/Engine/InputEvent.cs
@@ -16,10 +16,15 @@ namespace FlaxEngine
         public string Name;
 
         /// <summary>
-        /// Returns true if the event has been triggered during the current frame (e.g. user pressed a key). Use <see cref="Pressed"/>, <see cref="Pressing"/>, <see cref="Released"/> to catch events without active waiting.
+        /// Returns true if the event has been triggered during the current frame (e.g. user pressed a key). Use <see cref="Pressed"/> to catch events without active waiting.
         /// </summary>
         public bool Active => Input.GetAction(Name);
 
+        /// <summary>
+        /// Returns the event state. Use Use <see cref="Pressed"/>, <see cref="Pressing"/>, <see cref="Released"/> to catch events without active waiting.
+        /// </summary>
+        public InputActionState State => Input.GetActionState(Name);
+
         /// <summary>
         /// Occurs when event is pressed (e.g. user pressed a key). Called before scripts update.
         /// </summary>

From ed2dd7211ae786add63b0b5908ae01215f6a97fa Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Tue, 26 Sep 2023 09:40:30 -0500
Subject: [PATCH 033/103] Add back depriciated Triggered event.

---
 Source/Engine/Engine/InputEvent.cs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/Source/Engine/Engine/InputEvent.cs b/Source/Engine/Engine/InputEvent.cs
index b8b3dbfa9..0cfc47896 100644
--- a/Source/Engine/Engine/InputEvent.cs
+++ b/Source/Engine/Engine/InputEvent.cs
@@ -25,6 +25,12 @@ namespace FlaxEngine
         /// </summary>
         public InputActionState State => Input.GetActionState(Name);
 
+        /// <summary>
+        /// Occurs when event is triggered (e.g. user pressed a key). Called before scripts update.
+        /// </summary>
+        [System.Obsolete("Depreciated in 1.7, use Pressed.")]
+        public event Action Triggered;
+
         /// <summary>
         /// Occurs when event is pressed (e.g. user pressed a key). Called before scripts update.
         /// </summary>
@@ -75,6 +81,7 @@ namespace FlaxEngine
             case InputActionState.None: break;
             case InputActionState.Waiting: break;
             case InputActionState.Pressing:
+                Triggered?.Invoke();
                 Pressing?.Invoke();
                 break;
             case InputActionState.Press:

From 3a9dd3f8f85b0c53d6818c1ce36f61cb11e2fdb4 Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Tue, 26 Sep 2023 09:41:41 -0500
Subject: [PATCH 034/103] Small wording change

---
 Source/Engine/Engine/InputEvent.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Source/Engine/Engine/InputEvent.cs b/Source/Engine/Engine/InputEvent.cs
index 0cfc47896..8c84a8a7f 100644
--- a/Source/Engine/Engine/InputEvent.cs
+++ b/Source/Engine/Engine/InputEvent.cs
@@ -28,7 +28,7 @@ namespace FlaxEngine
         /// <summary>
         /// Occurs when event is triggered (e.g. user pressed a key). Called before scripts update.
         /// </summary>
-        [System.Obsolete("Depreciated in 1.7, use Pressed.")]
+        [System.Obsolete("Depreciated in 1.7, use Pressed Action.")]
         public event Action Triggered;
 
         /// <summary>

From 071a73c6d98a9a187be03fcfa7c9b623fa6977a2 Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Tue, 26 Sep 2023 10:03:34 -0500
Subject: [PATCH 035/103] Add AxisChanged event to InputAxis.

---
 Source/Engine/Engine/InputAxis.cs | 32 +++++++++++++++++++++++++++++++
 Source/Engine/Input/Input.cpp     |  9 +++++++++
 Source/Engine/Input/Input.h       |  6 ++++++
 3 files changed, 47 insertions(+)

diff --git a/Source/Engine/Engine/InputAxis.cs b/Source/Engine/Engine/InputAxis.cs
index f8ba7e72b..7b4da3191 100644
--- a/Source/Engine/Engine/InputAxis.cs
+++ b/Source/Engine/Engine/InputAxis.cs
@@ -1,5 +1,7 @@
 // Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
 
+using System;
+
 namespace FlaxEngine
 {
     /// <summary>
@@ -23,11 +25,17 @@ namespace FlaxEngine
         /// </summary>
         public float ValueRaw => Input.GetAxisRaw(Name);
 
+        /// <summary>
+        /// Occurs when axis is changed. Called before scripts update.
+        /// </summary>
+        public event Action ValueChanged;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="InputAxis"/> class.
         /// </summary>
         public InputAxis()
         {
+            Input.AxisChanged += Handler;
         }
 
         /// <summary>
@@ -36,7 +44,31 @@ namespace FlaxEngine
         /// <param name="name">The axis name.</param>
         public InputAxis(string name)
         {
+            Input.AxisChanged += Handler;
             Name = name;
         }
+        
+        private void Handler(string name)
+        {
+            if (string.Equals(Name, name, StringComparison.OrdinalIgnoreCase))
+                ValueChanged?.Invoke();
+        }
+        
+        /// <summary>
+        /// Finalizes an instance of the <see cref="InputAxis"/> class.
+        /// </summary>
+        ~InputAxis()
+        {
+            Input.AxisChanged -= Handler;
+        }
+        
+        /// <summary>
+        /// Releases this object.
+        /// </summary>
+        public void Dispose()
+        {
+            Input.AxisChanged -= Handler;
+            GC.SuppressFinalize(this);
+        }
     }
 }
diff --git a/Source/Engine/Input/Input.cpp b/Source/Engine/Input/Input.cpp
index af5600823..a54b6d631 100644
--- a/Source/Engine/Input/Input.cpp
+++ b/Source/Engine/Input/Input.cpp
@@ -98,6 +98,7 @@ Delegate<const Float2&, int32> Input::TouchDown;
 Delegate<const Float2&, int32> Input::TouchMove;
 Delegate<const Float2&, int32> Input::TouchUp;
 Delegate<StringView, const InputActionState&> Input::ActionTriggered;
+Delegate<StringView> Input::AxisChanged;
 Array<ActionConfig> Input::ActionMappings;
 Array<AxisConfig> Input::AxisMappings;
 
@@ -1020,6 +1021,14 @@ void InputService::Update()
     // Send events for the active actions (send events only in play mode)
     if (!Time::GetGamePaused())
     {
+        for (auto i = Axes.Begin(); i.IsNotEnd(); ++i)
+        {
+            if (Math::NotNearEqual(i->Value.Value, i->Value.PrevKeyValue))
+            {
+                Input::AxisChanged(i->Key);
+            }
+        }
+        
         for (auto i = Actions.Begin(); i.IsNotEnd(); ++i)
         {
             if (i->Value.State != InputActionState::Waiting)
diff --git a/Source/Engine/Input/Input.h b/Source/Engine/Input/Input.h
index 5ff02eda9..ed66a6cd9 100644
--- a/Source/Engine/Input/Input.h
+++ b/Source/Engine/Input/Input.h
@@ -295,6 +295,12 @@ public:
     /// <seealso cref="InputEvent"/>
     API_EVENT() static Delegate<StringView, const InputActionState&> ActionTriggered;
 
+    /// <summary>
+    /// Event fired when virtual input axis is changed. Called before scripts update. See <see cref="AxisMappings"/> to edit configuration.
+    /// </summary>
+    /// <seealso cref="InputAxis"/>
+    API_EVENT() static Delegate<StringView> AxisChanged;
+
     /// <summary>
     /// Gets the value of the virtual action identified by name. Use <see cref="ActionMappings"/> to get the current config.
     /// </summary>

From 9b48d1feb85a52f867788ac6d4594d2e095fbe8a Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Tue, 26 Sep 2023 10:04:08 -0500
Subject: [PATCH 036/103] Update comments

---
 Source/Engine/Input/Input.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Source/Engine/Input/Input.cpp b/Source/Engine/Input/Input.cpp
index a54b6d631..2a098088e 100644
--- a/Source/Engine/Input/Input.cpp
+++ b/Source/Engine/Input/Input.cpp
@@ -1018,7 +1018,7 @@ void InputService::Update()
         Input::SetMousePosition(Screen::GetSize() * 0.5f);
     }
 
-    // Send events for the active actions (send events only in play mode)
+    // Send events for the active actions and axes (send events only in play mode)
     if (!Time::GetGamePaused())
     {
         for (auto i = Axes.Begin(); i.IsNotEnd(); ++i)

From d14dc56b5c8f9d62bf6ec5ab265d22952d8caf54 Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Tue, 26 Sep 2023 10:26:06 -0500
Subject: [PATCH 037/103] Change name to AxisValueChanged.

---
 Source/Engine/Engine/InputAxis.cs | 8 ++++----
 Source/Engine/Input/Input.cpp     | 4 ++--
 Source/Engine/Input/Input.h       | 2 +-
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Source/Engine/Engine/InputAxis.cs b/Source/Engine/Engine/InputAxis.cs
index 7b4da3191..c70bada74 100644
--- a/Source/Engine/Engine/InputAxis.cs
+++ b/Source/Engine/Engine/InputAxis.cs
@@ -35,7 +35,7 @@ namespace FlaxEngine
         /// </summary>
         public InputAxis()
         {
-            Input.AxisChanged += Handler;
+            Input.AxisValueChanged += Handler;
         }
 
         /// <summary>
@@ -44,7 +44,7 @@ namespace FlaxEngine
         /// <param name="name">The axis name.</param>
         public InputAxis(string name)
         {
-            Input.AxisChanged += Handler;
+            Input.AxisValueChanged += Handler;
             Name = name;
         }
         
@@ -59,7 +59,7 @@ namespace FlaxEngine
         /// </summary>
         ~InputAxis()
         {
-            Input.AxisChanged -= Handler;
+            Input.AxisValueChanged -= Handler;
         }
         
         /// <summary>
@@ -67,7 +67,7 @@ namespace FlaxEngine
         /// </summary>
         public void Dispose()
         {
-            Input.AxisChanged -= Handler;
+            Input.AxisValueChanged -= Handler;
             GC.SuppressFinalize(this);
         }
     }
diff --git a/Source/Engine/Input/Input.cpp b/Source/Engine/Input/Input.cpp
index 2a098088e..d3c09c130 100644
--- a/Source/Engine/Input/Input.cpp
+++ b/Source/Engine/Input/Input.cpp
@@ -98,7 +98,7 @@ Delegate<const Float2&, int32> Input::TouchDown;
 Delegate<const Float2&, int32> Input::TouchMove;
 Delegate<const Float2&, int32> Input::TouchUp;
 Delegate<StringView, const InputActionState&> Input::ActionTriggered;
-Delegate<StringView> Input::AxisChanged;
+Delegate<StringView> Input::AxisValueChanged;
 Array<ActionConfig> Input::ActionMappings;
 Array<AxisConfig> Input::AxisMappings;
 
@@ -1025,7 +1025,7 @@ void InputService::Update()
         {
             if (Math::NotNearEqual(i->Value.Value, i->Value.PrevKeyValue))
             {
-                Input::AxisChanged(i->Key);
+                Input::AxisValueChanged(i->Key);
             }
         }
         
diff --git a/Source/Engine/Input/Input.h b/Source/Engine/Input/Input.h
index ed66a6cd9..eb1299334 100644
--- a/Source/Engine/Input/Input.h
+++ b/Source/Engine/Input/Input.h
@@ -299,7 +299,7 @@ public:
     /// Event fired when virtual input axis is changed. Called before scripts update. See <see cref="AxisMappings"/> to edit configuration.
     /// </summary>
     /// <seealso cref="InputAxis"/>
-    API_EVENT() static Delegate<StringView> AxisChanged;
+    API_EVENT() static Delegate<StringView> AxisValueChanged;
 
     /// <summary>
     /// Gets the value of the virtual action identified by name. Use <see cref="ActionMappings"/> to get the current config.

From c4da34a463c5d0d88018154a83dcf7f5cd710ff7 Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Wed, 27 Sep 2023 16:24:33 +0200
Subject: [PATCH 038/103] - Implemented function node and bind/unbind node
 compatiblility/filtering - Added NodeTypeHint enum

---
 Source/Editor/Surface/Archetypes/Function.cs  | 10 +++
 .../Surface/ContextMenu/VisjectCMItem.cs      | 74 ++++++++++++++++---
 Source/Editor/Surface/NodeArchetype.cs        | 20 +++++
 Source/Editor/Surface/VisualScriptSurface.cs  |  3 +-
 4 files changed, 97 insertions(+), 10 deletions(-)

diff --git a/Source/Editor/Surface/Archetypes/Function.cs b/Source/Editor/Surface/Archetypes/Function.cs
index cffb2ad6f..d027dd8f1 100644
--- a/Source/Editor/Surface/Archetypes/Function.cs
+++ b/Source/Editor/Surface/Archetypes/Function.cs
@@ -2228,6 +2228,7 @@ namespace FlaxEditor.Surface.Archetypes
                 Title = "Function Input",
                 Description = "The graph function input data",
                 Flags = NodeFlags.MaterialGraph | NodeFlags.ParticleEmitterGraph | NodeFlags.AnimGraph | NodeFlags.NoSpawnViaPaste,
+                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(240, 60),
                 DefaultValues = new object[]
                 {
@@ -2247,6 +2248,7 @@ namespace FlaxEditor.Surface.Archetypes
                 Title = "Function Output",
                 Description = "The graph function output data",
                 Flags = NodeFlags.MaterialGraph | NodeFlags.ParticleEmitterGraph | NodeFlags.AnimGraph | NodeFlags.NoSpawnViaPaste,
+                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(240, 60),
                 DefaultValues = new object[]
                 {
@@ -2265,6 +2267,7 @@ namespace FlaxEditor.Surface.Archetypes
                 Title = string.Empty,
                 Description = "Overrides the base class method with custom implementation",
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI | NodeFlags.NoSpawnViaPaste,
+                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(240, 60),
                 DefaultValues = new object[]
                 {
@@ -2279,6 +2282,7 @@ namespace FlaxEditor.Surface.Archetypes
                 Create = (id, context, arch, groupArch) => new InvokeMethodNode(id, context, arch, groupArch),
                 Title = string.Empty,
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI,
+                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(240, 60),
                 DefaultValues = new object[]
                 {
@@ -2302,6 +2306,7 @@ namespace FlaxEditor.Surface.Archetypes
                 Create = (id, context, arch, groupArch) => new ReturnNode(id, context, arch, groupArch),
                 Title = "Return",
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI,
+                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(100, 40),
                 DefaultValues = new object[]
                 {
@@ -2320,6 +2325,7 @@ namespace FlaxEditor.Surface.Archetypes
                 Title = "New Function",
                 Description = "Adds a new function to the script",
                 Flags = NodeFlags.VisualScriptGraph,
+                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(240, 20),
                 DefaultValues = new object[]
                 {
@@ -2332,6 +2338,7 @@ namespace FlaxEditor.Surface.Archetypes
                 Create = (id, context, arch, groupArch) => new GetFieldNode(id, context, arch, groupArch),
                 Title = string.Empty,
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI,
+                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(240, 60),
                 DefaultValues = new object[]
                 {
@@ -2347,6 +2354,7 @@ namespace FlaxEditor.Surface.Archetypes
                 Create = (id, context, arch, groupArch) => new SetFieldNode(id, context, arch, groupArch),
                 Title = string.Empty,
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI,
+                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(240, 60),
                 DefaultValues = new object[]
                 {
@@ -2363,6 +2371,7 @@ namespace FlaxEditor.Surface.Archetypes
                 Create = (id, context, arch, groupArch) => new BindEventNode(id, context, arch, groupArch),
                 Title = string.Empty,
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI,
+                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(260, 60),
                 DefaultValues = new object[]
                 {
@@ -2385,6 +2394,7 @@ namespace FlaxEditor.Surface.Archetypes
                 Create = (id, context, arch, groupArch) => new UnbindEventNode(id, context, arch, groupArch),
                 Title = string.Empty,
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI,
+                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(260, 60),
                 DefaultValues = new object[]
                 {
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index 7b0ce6c85..f8b7d9d51 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -3,11 +3,13 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using FlaxEditor.Scripting;
 using FlaxEditor.Surface.Elements;
 using FlaxEditor.Utilities;
 using FlaxEngine;
 using FlaxEngine.GUI;
+using FlaxEngine.Utilities;
 
 namespace FlaxEditor.Surface.ContextMenu
 {
@@ -121,13 +123,70 @@ namespace FlaxEditor.Surface.ContextMenu
                 Visible = true;
                 return true;   
             }
-            
-            if (_archetype?.Elements == null)
+
+            if (_archetype == null)
             {
                 Visible = false;
                 return false;
             }
-            
+
+            bool isCompatible = false;
+            if (_archetype.Elements != null)
+            {
+                isCompatible = CheckElementsCompatibility(startBox);
+            }
+
+            if (_archetype.NodeTypeHint == NodeTypeHint.FunctionNode)
+            {
+                isCompatible = false;
+                ScriptMemberInfo memberInfo = ScriptMemberInfo.Null;
+
+                if (_archetype.Tag is ScriptMemberInfo info)
+                {
+                    memberInfo = info;
+                }
+                else if(_archetype.DefaultValues is { Length: > 1 })
+                {
+                    var eventName = (string)_archetype.DefaultValues[1];
+                    var eventType = TypeUtils.GetType((string)_archetype.DefaultValues[0]);
+                    memberInfo = eventType.GetMember(eventName, MemberTypes.Event, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
+                }
+
+                if (memberInfo != ScriptMemberInfo.Null)
+                {
+                    if (startBox.IsOutput)
+                    {
+                        var parameters = memberInfo.GetParameters();
+                        ScriptType outType = startBox.CurrentType;
+
+                        if (!memberInfo.IsStatic)
+                        {
+                            var scriptType = TypeUtils.GetType((string)_archetype.DefaultValues[0]);
+                            isCompatible |= CanCastToType(scriptType, outType, _archetype.ConnectionsHints);
+                        }
+
+                        if (!memberInfo.IsEvent)
+                        {
+                            for (int i = 0; i < parameters.Length; i++)
+                            {
+                                ScriptType inType = parameters[i].Type;
+                                isCompatible |= CanCastToType(inType, outType, _archetype.ConnectionsHints);
+                            }
+                        }
+                    }
+                    else
+                    {
+
+                    }
+                }
+            }
+
+            Visible = isCompatible;
+            return isCompatible;
+        }
+
+        private bool CheckElementsCompatibility(Box startBox)
+        {
             bool isCompatible = false;
             foreach (NodeElementArchetype element in _archetype.Elements)
             {
@@ -153,15 +212,12 @@ namespace FlaxEditor.Surface.ContextMenu
                     hint = startBox.ParentNode.Archetype.ConnectionsHints;
                 }
                 
-                bool checkCompatibility = CanCastToType(inType, outType, hint);
-                isCompatible |= checkCompatibility;
+                isCompatible |= CanCastToType(inType, outType, hint);
             }
-            
-            Visible = isCompatible;
-            
+
             return isCompatible;
         }
-
+        
         private bool CanCastToType(ScriptType currentType, ScriptType type, ConnectionsHint hint)
         {
             if (VisjectSurface.CanUseDirectCastStatic(type, currentType, false))
diff --git a/Source/Editor/Surface/NodeArchetype.cs b/Source/Editor/Surface/NodeArchetype.cs
index 6dc923ce2..1cdaee2d2 100644
--- a/Source/Editor/Surface/NodeArchetype.cs
+++ b/Source/Editor/Surface/NodeArchetype.cs
@@ -73,6 +73,20 @@ namespace FlaxEditor.Surface
         All = Scalar | Vector | Enum | Anything | Value | Array | Dictionary,
     }
 
+    [HideInEditor]
+    public enum NodeTypeHint
+    {
+        /// <summary>
+        /// Is Node.
+        /// </summary>
+        Default = 0,
+        
+        /// <summary>
+        /// Is Function Node.
+        /// </summary>
+        FunctionNode = 1,
+    }
+    
     /// <summary>
     /// Surface node archetype description.
     /// </summary>
@@ -152,6 +166,11 @@ namespace FlaxEditor.Surface
         /// </summary>
         public ConnectionsHint ConnectionsHints;
 
+        /// <summary>
+        /// Node Type hints.
+        /// </summary>
+        public NodeTypeHint NodeTypeHint;
+        
         /// <summary>
         /// Array with independent boxes IDs.
         /// </summary>
@@ -193,6 +212,7 @@ namespace FlaxEditor.Surface
                 DefaultValues = (object[])DefaultValues?.Clone(),
                 DefaultType = DefaultType,
                 ConnectionsHints = ConnectionsHints,
+                NodeTypeHint = NodeTypeHint,
                 IndependentBoxes = (int[])IndependentBoxes?.Clone(),
                 DependentBoxes = (int[])DependentBoxes?.Clone(),
                 Elements = (NodeElementArchetype[])Elements?.Clone(),
diff --git a/Source/Editor/Surface/VisualScriptSurface.cs b/Source/Editor/Surface/VisualScriptSurface.cs
index e961f686d..b6c0112a9 100644
--- a/Source/Editor/Surface/VisualScriptSurface.cs
+++ b/Source/Editor/Surface/VisualScriptSurface.cs
@@ -370,7 +370,7 @@ namespace FlaxEditor.Surface
                                 bindNode.Description = SurfaceUtils.GetVisualScriptMemberInfoDescription(member);
                                 bindNode.SubTitle = string.Format(" (in {0})", scriptTypeName);
                                 ((IList<NodeArchetype>)group.Archetypes).Add(bindNode);
-
+                                
                                 // Add Unbind event node
                                 var unbindNode = (NodeArchetype)Archetypes.Function.Nodes[9].Clone();
                                 unbindNode.DefaultValues[0] = scriptTypeTypeName;
@@ -589,6 +589,7 @@ namespace FlaxEditor.Surface
                         node.DefaultValues[0] = name;
                         node.DefaultValues[1] = parameters.Length;
                         node.Title = "Override " + name;
+                        node.Tag = member;
                         nodes.Add(node);
                     }
                 }

From 63c213aec010198d8d750d528b93ec93db46ef20 Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Wed, 27 Sep 2023 17:04:35 +0200
Subject: [PATCH 039/103] - Support for Impulse ports

---
 Source/Editor/Surface/ContextMenu/VisjectCMItem.cs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index f8b7d9d51..370c5014a 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -138,7 +138,6 @@ namespace FlaxEditor.Surface.ContextMenu
 
             if (_archetype.NodeTypeHint == NodeTypeHint.FunctionNode)
             {
-                isCompatible = false;
                 ScriptMemberInfo memberInfo = ScriptMemberInfo.Null;
 
                 if (_archetype.Tag is ScriptMemberInfo info)
@@ -154,11 +153,17 @@ namespace FlaxEditor.Surface.ContextMenu
 
                 if (memberInfo != ScriptMemberInfo.Null)
                 {
+                    if(memberInfo.IsEvent)
+                        isCompatible = false;
+                    
                     if (startBox.IsOutput)
                     {
                         var parameters = memberInfo.GetParameters();
                         ScriptType outType = startBox.CurrentType;
 
+                        if (startBox.CurrentType.IsVoid && memberInfo.ValueType.IsVoid)
+                            isCompatible = true;
+                        
                         if (!memberInfo.IsStatic)
                         {
                             var scriptType = TypeUtils.GetType((string)_archetype.DefaultValues[0]);

From 155d11c07b2427f7ac6e074244a849dd0fb7060c Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Wed, 27 Sep 2023 19:28:06 +0200
Subject: [PATCH 040/103] - Filtering now also applies when dragging a
 connection from an input port

---
 .../Surface/ContextMenu/VisjectCMItem.cs      | 51 ++++++++++---------
 1 file changed, 28 insertions(+), 23 deletions(-)

diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index 370c5014a..be69d675c 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -156,32 +156,37 @@ namespace FlaxEditor.Surface.ContextMenu
                     if(memberInfo.IsEvent)
                         isCompatible = false;
                     
-                    if (startBox.IsOutput)
-                    {
-                        var parameters = memberInfo.GetParameters();
-                        ScriptType outType = startBox.CurrentType;
-
-                        if (startBox.CurrentType.IsVoid && memberInfo.ValueType.IsVoid)
-                            isCompatible = true;
-                        
-                        if (!memberInfo.IsStatic)
-                        {
-                            var scriptType = TypeUtils.GetType((string)_archetype.DefaultValues[0]);
-                            isCompatible |= CanCastToType(scriptType, outType, _archetype.ConnectionsHints);
-                        }
-
-                        if (!memberInfo.IsEvent)
-                        {
-                            for (int i = 0; i < parameters.Length; i++)
-                            {
-                                ScriptType inType = parameters[i].Type;
-                                isCompatible |= CanCastToType(inType, outType, _archetype.ConnectionsHints);
-                            }
-                        }
-                    }
+                    if (startBox.CurrentType.IsVoid && memberInfo.ValueType.IsVoid)
+                        isCompatible = true;
                     else
                     {
+                        if (startBox.IsOutput)
+                        {
+                            var parameters = memberInfo.GetParameters();
+                            ScriptType outType = startBox.CurrentType;
 
+                            if (!memberInfo.IsStatic)
+                            {
+                                var scriptType = memberInfo.DeclaringType;
+                                isCompatible |= CanCastToType(scriptType, outType, _archetype.ConnectionsHints);
+                            }
+
+                            if (!memberInfo.IsEvent)
+                            {
+                                for (int i = 0; i < parameters.Length; i++)
+                                {
+                                    ScriptType inType = parameters[i].Type;
+                                    isCompatible |= CanCastToType(inType, outType, _archetype.ConnectionsHints);
+                                }
+                            }
+                        }
+                        else
+                        {
+                            ScriptType inType = startBox.CurrentType;
+                            ScriptType outType = memberInfo.ValueType;
+
+                            isCompatible |= CanCastToType(inType, outType, _archetype.ConnectionsHints);
+                        }
                     }
                 }
             }

From 9694522b4ea367fc7efc232ae0d74734fe02d372 Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Thu, 28 Sep 2023 13:25:56 -0500
Subject: [PATCH 041/103] Change to use enum value.

---
 Source/Engine/Input/Input.cpp | 2 +-
 Source/Engine/Input/Input.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Source/Engine/Input/Input.cpp b/Source/Engine/Input/Input.cpp
index d3c09c130..dbcdf66bd 100644
--- a/Source/Engine/Input/Input.cpp
+++ b/Source/Engine/Input/Input.cpp
@@ -97,7 +97,7 @@ Action Input::MouseLeave;
 Delegate<const Float2&, int32> Input::TouchDown;
 Delegate<const Float2&, int32> Input::TouchMove;
 Delegate<const Float2&, int32> Input::TouchUp;
-Delegate<StringView, const InputActionState&> Input::ActionTriggered;
+Delegate<StringView, InputActionState> Input::ActionTriggered;
 Delegate<StringView> Input::AxisValueChanged;
 Array<ActionConfig> Input::ActionMappings;
 Array<AxisConfig> Input::AxisMappings;
diff --git a/Source/Engine/Input/Input.h b/Source/Engine/Input/Input.h
index eb1299334..c11026eff 100644
--- a/Source/Engine/Input/Input.h
+++ b/Source/Engine/Input/Input.h
@@ -293,7 +293,7 @@ public:
     /// Event fired when virtual input action is triggered. Called before scripts update. See <see cref="ActionMappings"/> to edit configuration.
     /// </summary>
     /// <seealso cref="InputEvent"/>
-    API_EVENT() static Delegate<StringView, const InputActionState&> ActionTriggered;
+    API_EVENT() static Delegate<StringView, InputActionState> ActionTriggered;
 
     /// <summary>
     /// Event fired when virtual input axis is changed. Called before scripts update. See <see cref="AxisMappings"/> to edit configuration.

From 9acee407469f45c474dcfee0eb7a8d3a38489326 Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Thu, 28 Sep 2023 20:53:47 +0200
Subject: [PATCH 042/103] - Added context sensitive toggle gui

---
 .../Editor/Surface/ContextMenu/VisjectCM.cs   | 45 +++++++++++++++++--
 1 file changed, 41 insertions(+), 4 deletions(-)

diff --git a/Source/Editor/Surface/ContextMenu/VisjectCM.cs b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
index 04130fc1e..0d4a35e51 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCM.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
@@ -40,6 +40,8 @@ namespace FlaxEditor.Surface.ContextMenu
         public delegate List<SurfaceParameter> ParameterGetterDelegate();
 
         private readonly List<VisjectCMGroup> _groups = new List<VisjectCMGroup>(16);
+        private CheckBox _contextSensitiveToggle;
+        private bool _contextSensitiveSearchEnabled = true;
         private readonly TextBox _searchBox;
         private bool _waitingForInput;
         private VisjectCMGroup _surfaceParametersGroup;
@@ -127,7 +129,7 @@ namespace FlaxEditor.Surface.ContextMenu
                 _parameterSetNodeArchetype = info.ParameterSetNodeArchetype ?? Archetypes.Parameters.Nodes[3];
 
             // Context menu dimensions
-            Size = new Float2(320, 248);
+            Size = new Float2(300, 400);
 
             var headerPanel = new Panel(ScrollBars.None)
             {
@@ -139,17 +141,40 @@ namespace FlaxEditor.Surface.ContextMenu
             };
 
             // Title bar
+            var titleFontReference = new FontReference(Style.Current.FontLarge.Asset, 10);
             var titleLabel = new Label
             {
-                Width = Width - 8,
+                Width = Width * 0.5f - 8f,
                 Height = 20,
                 X = 4,
                 Parent = headerPanel,
                 Text = "Select Node",
-                HorizontalAlignment = TextAlignment.Center,
-                Font = new FontReference(Style.Current.FontLarge.Asset, 10),
+                HorizontalAlignment = TextAlignment.Near,
+                Font = titleFontReference,
             };
 
+            // Context sensitive toggle
+            var contextSensitiveLabel = new Label
+            {
+                Width = Width * 0.5f - 28,
+                Height = 20,
+                X = Width * 0.5f,
+                Parent = headerPanel,
+                Text = "Context Sensitive",
+                HorizontalAlignment = TextAlignment.Far,
+                Font = titleFontReference,
+            };
+            
+            _contextSensitiveToggle = new CheckBox
+            {
+                Width = 20,
+                Height = 20,
+                X = Width - 24,
+                Parent = headerPanel,
+                Checked = _contextSensitiveSearchEnabled,
+            };
+            _contextSensitiveToggle.StateChanged += OnContextSensitiveToggleStateChanged;
+            
             // Search box
             _searchBox = new SearchBox(false, 2, 22)
             {
@@ -251,6 +276,11 @@ namespace FlaxEditor.Surface.ContextMenu
             }
         }
 
+        private void OnContextSensitiveToggleStateChanged(CheckBox checkBox)
+        {
+            _contextSensitiveSearchEnabled = checkBox.Checked;
+        }
+
         /// <summary>
         /// Adds the group archetype to add to the menu.
         /// </summary>
@@ -768,5 +798,12 @@ namespace FlaxEditor.Surface.ContextMenu
         {
             return GetPreviousSiblings(item).OfType<T>();
         }
+
+        /// <inheritdoc />
+        public override void OnDestroy()
+        {
+            _contextSensitiveToggle.StateChanged -= OnContextSensitiveToggleStateChanged;
+            base.OnDestroy();
+        }
     }
 }

From 84b240216f38b0184851b0ddda23d1ca274fa9e4 Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Thu, 28 Sep 2023 21:31:58 +0200
Subject: [PATCH 043/103] - Implemented context sensitive toggle functionality
 - Item list now updates on the fly when toggleing context sensitivity - Added
 profiling - Fixed a highlighting bug - Minor cleanup

---
 .../Editor/Surface/ContextMenu/VisjectCM.cs   | 40 ++++++++++++++-----
 .../Surface/ContextMenu/VisjectCMGroup.cs     |  7 ++++
 .../Surface/ContextMenu/VisjectCMItem.cs      |  5 ++-
 3 files changed, 42 insertions(+), 10 deletions(-)

diff --git a/Source/Editor/Surface/ContextMenu/VisjectCM.cs b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
index 0d4a35e51..67148a5a4 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCM.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
@@ -161,6 +161,7 @@ namespace FlaxEditor.Surface.ContextMenu
                 X = Width * 0.5f,
                 Parent = headerPanel,
                 Text = "Context Sensitive",
+                TooltipText = "Should the nodes be filtered to only show those that can be connected in the current context?",
                 HorizontalAlignment = TextAlignment.Far,
                 Font = titleFontReference,
             };
@@ -276,11 +277,6 @@ namespace FlaxEditor.Surface.ContextMenu
             }
         }
 
-        private void OnContextSensitiveToggleStateChanged(CheckBox checkBox)
-        {
-            _contextSensitiveSearchEnabled = checkBox.Checked;
-        }
-
         /// <summary>
         /// Adds the group archetype to add to the menu.
         /// </summary>
@@ -318,7 +314,7 @@ namespace FlaxEditor.Surface.ContextMenu
                         OnSearchFilterChanged();
                     }
                 }
-                else
+                else if(_contextSensitiveSearchEnabled)
                 {
                     group.EvaluateVisibilityWithBox(_selectedBox);
                 }
@@ -355,7 +351,8 @@ namespace FlaxEditor.Surface.ContextMenu
                             Parent = group
                         };
                     }
-                    group.EvaluateVisibilityWithBox(_selectedBox); 
+                    if(_contextSensitiveSearchEnabled)
+                        group.EvaluateVisibilityWithBox(_selectedBox); 
                     group.SortChildren();
                     group.Parent = _groupsPanel;
                     _groups.Add(group);
@@ -465,7 +462,7 @@ namespace FlaxEditor.Surface.ContextMenu
             LockChildrenRecursive();
             for (int i = 0; i < _groups.Count; i++)
             {
-                _groups[i].UpdateFilter(_searchBox.Text, _selectedBox);
+                _groups[i].UpdateFilter(_searchBox.Text, _contextSensitiveSearchEnabled ? _selectedBox : null);
                 _groups[i].UpdateItemSort(_selectedBox);
             }
             SortGroups();
@@ -484,6 +481,30 @@ namespace FlaxEditor.Surface.ContextMenu
             Profiler.EndEvent();
         }
 
+        private void OnContextSensitiveToggleStateChanged(CheckBox checkBox)
+        {
+            Profiler.BeginEvent("VisjectCM.OnContextSensitiveToggleStateChanged");
+            _contextSensitiveSearchEnabled = checkBox.Checked;
+            
+            LockChildrenRecursive();
+            for (int i = 0; i < _groups.Count; i++)
+            {
+                _groups[i].UpdateFilter(_searchBox.Text, _contextSensitiveSearchEnabled ? _selectedBox : null);
+            }
+            SortGroups();
+            UnlockChildrenRecursive();
+            
+            Profiler.BeginEvent("VisjectCM.Layout");
+            if (SelectedItem == null || !SelectedItem.VisibleInHierarchy)
+                SelectedItem = _groups.Find(g => g.Visible)?.Children.Find(c => c.Visible && c is VisjectCMItem) as VisjectCMItem;
+            PerformLayout();
+            if (SelectedItem != null)
+                _panel1.ScrollViewTo(SelectedItem);
+            Profiler.EndEvent();
+            
+            Profiler.EndEvent();
+        }
+        
         /// <summary>
         /// Sort the groups and keeps <see cref="_groups"/> in sync
         /// </summary>
@@ -540,7 +561,8 @@ namespace FlaxEditor.Surface.ContextMenu
             for (int i = 0; i < _groups.Count; i++)
             {
                 _groups[i].ResetView();
-                _groups[i].EvaluateVisibilityWithBox(_selectedBox);
+                if(_contextSensitiveSearchEnabled)
+                    _groups[i].EvaluateVisibilityWithBox(_selectedBox);
             }
             UnlockChildrenRecursive();
 
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
index 9560aecbb..d11d51223 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
@@ -132,6 +132,13 @@ namespace FlaxEditor.Surface.ContextMenu
         {
             if (selectedBox == null)
             {
+                for (int i = 0; i < _children.Count; i++)
+                {
+                    if (_children[i] is VisjectCMItem item)
+                    {
+                        item.CanConnectTo(null);
+                    }
+                }
                 Visible = true;
                 return;
             }
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index be69d675c..4aa5c6ce8 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -309,11 +309,14 @@ namespace FlaxEditor.Surface.ContextMenu
             if (selectedBox != null)
             {
                 if (!CanConnectTo(selectedBox))
+                {
+                    _highlights?.Clear();
                     return;
+                }
             }
             
             _isStartsWithMatch = _isFullMatch = false;
-            if (filterText == null)
+            if (string.IsNullOrEmpty(filterText))
             {
                 // Clear filter
                 _highlights?.Clear();

From a4970b7fced7f1b6b81849b8527f6118a7665941 Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Fri, 29 Sep 2023 16:25:34 +0200
Subject: [PATCH 044/103] - Group names now get filtered again (currently doing
 a second filtering pass through the items) - More cleanup

---
 .../Editor/Surface/ContextMenu/VisjectCM.cs   | 45 ++++++++-----------
 .../Surface/ContextMenu/VisjectCMGroup.cs     |  8 ++--
 2 files changed, 22 insertions(+), 31 deletions(-)

diff --git a/Source/Editor/Surface/ContextMenu/VisjectCM.cs b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
index 67148a5a4..9955f0434 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCM.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
@@ -450,7 +450,25 @@ namespace FlaxEditor.Surface.ContextMenu
                 return;
 
             Profiler.BeginEvent("VisjectCM.OnSearchFilterChanged");
+            UpdateFilters();
+            _searchBox.Focus();
+            Profiler.EndEvent();
+        }
+
+        private void OnContextSensitiveToggleStateChanged(CheckBox checkBox)
+        {
+            // Skip events during setup or init stuff
+            if (IsLayoutLocked)
+                return;
             
+            Profiler.BeginEvent("VisjectCM.OnContextSensitiveToggleStateChanged");
+            _contextSensitiveSearchEnabled = checkBox.Checked;
+            UpdateFilters();
+            Profiler.EndEvent();
+        }
+
+        private void UpdateFilters()
+        {
             if (string.IsNullOrEmpty(_searchBox.Text) && _selectedBox == null)
             {
                 ResetView();
@@ -475,33 +493,6 @@ namespace FlaxEditor.Surface.ContextMenu
             PerformLayout();
             if (SelectedItem != null)
                 _panel1.ScrollViewTo(SelectedItem);
-            _searchBox.Focus();
-            Profiler.EndEvent();
-
-            Profiler.EndEvent();
-        }
-
-        private void OnContextSensitiveToggleStateChanged(CheckBox checkBox)
-        {
-            Profiler.BeginEvent("VisjectCM.OnContextSensitiveToggleStateChanged");
-            _contextSensitiveSearchEnabled = checkBox.Checked;
-            
-            LockChildrenRecursive();
-            for (int i = 0; i < _groups.Count; i++)
-            {
-                _groups[i].UpdateFilter(_searchBox.Text, _contextSensitiveSearchEnabled ? _selectedBox : null);
-            }
-            SortGroups();
-            UnlockChildrenRecursive();
-            
-            Profiler.BeginEvent("VisjectCM.Layout");
-            if (SelectedItem == null || !SelectedItem.VisibleInHierarchy)
-                SelectedItem = _groups.Find(g => g.Visible)?.Children.Find(c => c.Visible && c is VisjectCMItem) as VisjectCMItem;
-            PerformLayout();
-            if (SelectedItem != null)
-                _panel1.ScrollViewTo(SelectedItem);
-            Profiler.EndEvent();
-            
             Profiler.EndEvent();
         }
         
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
index d11d51223..efb8ab458 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
@@ -100,17 +100,17 @@ namespace FlaxEditor.Surface.ContextMenu
             }
 
             // Update header title
-            /*if (QueryFilterHelper.Match(filterText, HeaderText))
+            if (QueryFilterHelper.Match(filterText, HeaderText))
             {
                 for (int i = 0; i < _children.Count; i++)
                 {
                     if (_children[i] is VisjectCMItem item)
                     {
-                        item.Visible = true;
+                        item.UpdateFilter(null, selectedBox);
+                        isAnyVisible |= item.Visible;
                     }
                 }
-                isAnyVisible = true;
-            }*/
+            }
 
             // Update itself
             if (isAnyVisible)

From 4bf46c3af3a353ee45635c30f70054373f680bd8 Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Fri, 29 Sep 2023 17:19:38 +0200
Subject: [PATCH 045/103] - More cleanup and comments

---
 .../Editor/Surface/ContextMenu/VisjectCM.cs   |   1 -
 .../Surface/ContextMenu/VisjectCMItem.cs      | 106 +++++-------------
 Source/Editor/Surface/Elements/Box.cs         |  54 +--------
 .../Surface/VisjectSurface.Connecting.cs      |  64 +++++++++++
 4 files changed, 93 insertions(+), 132 deletions(-)

diff --git a/Source/Editor/Surface/ContextMenu/VisjectCM.cs b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
index 9955f0434..c07173aec 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCM.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
@@ -5,7 +5,6 @@ using System.Collections.Generic;
 using System.Linq;
 using FlaxEditor.GUI.ContextMenu;
 using FlaxEditor.GUI.Input;
-using FlaxEditor.Scripting;
 using FlaxEngine;
 using FlaxEngine.GUI;
 using FlaxEngine.Utilities;
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index 4aa5c6ce8..b0ff74272 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -80,7 +80,7 @@ namespace FlaxEditor.Surface.ContextMenu
             if (!Visible)
                 return;
 
-            if (selectedBox != null && CanConnectTo(selectedBox, NodeArchetype))
+            if (selectedBox != null && CanConnectTo(selectedBox))
                 SortScore += 1;
             if (Data != null)
                 SortScore += 1;
@@ -95,29 +95,14 @@ namespace FlaxEditor.Surface.ContextMenu
             textRect = new Rectangle(22, 0, Width - 24, Height);
         }
 
-        private bool CanConnectTo(Box startBox, NodeArchetype nodeArchetype)
-        {
-            if (startBox == null)
-                return false;
-            if (!startBox.IsOutput)
-                return false; // For now, I'm only handing the output box case
-
-            if (nodeArchetype.Elements != null)
-            {
-                for (int i = 0; i < nodeArchetype.Elements.Length; i++)
-                {
-                    if (nodeArchetype.Elements[i].Type == NodeElementType.Input &&
-                        startBox.CanUseType(nodeArchetype.Elements[i].ConnectionsType))
-                    {
-                        return true;
-                    }
-                }
-            }
-            return false;
-        }
-
+        /// <summary>
+        /// Checks if this context menu item can be connected to a given box, before a node is actually spawned.
+        /// </summary>
+        /// <param name="startBox">The connected box</param>
+        /// <returns>True if the connected box is compatible with this item</returns>
         public bool CanConnectTo(Box startBox)
         {
+            // Is compatible if box is null for reset reasons
             if (startBox == null)
             {
                 Visible = true;
@@ -131,15 +116,20 @@ namespace FlaxEditor.Surface.ContextMenu
             }
 
             bool isCompatible = false;
+            
+            // Check compatibility based on the defined elements in the archetype. This handles all the default groups and items
             if (_archetype.Elements != null)
             {
                 isCompatible = CheckElementsCompatibility(startBox);
             }
 
+            // Check compatibility based on the archetype tag or name. This handles custom groups and items, mainly function nodes for visual scripting
             if (_archetype.NodeTypeHint == NodeTypeHint.FunctionNode)
             {
                 ScriptMemberInfo memberInfo = ScriptMemberInfo.Null;
 
+                // Check if the archetype tag already has a member info otherwise try to fetch it via the archetype type and name
+                // Only really the InvokeMethod Nodes have a member info in their tag
                 if (_archetype.Tag is ScriptMemberInfo info)
                 {
                     memberInfo = info;
@@ -155,22 +145,29 @@ namespace FlaxEditor.Surface.ContextMenu
                 {
                     if(memberInfo.IsEvent)
                         isCompatible = false;
-                    
+
+                    // Box was dragged from an impulse port and the member info can be invoked so it is compatible
                     if (startBox.CurrentType.IsVoid && memberInfo.ValueType.IsVoid)
-                        isCompatible = true;
+                    {
+                        isCompatible = true;   
+                    }
                     else
                     {
+                        // When the startBox is output we only need to check the input parameters
                         if (startBox.IsOutput)
                         {
                             var parameters = memberInfo.GetParameters();
                             ScriptType outType = startBox.CurrentType;
-
+                            
+                            // non static members have an instance input parameter
                             if (!memberInfo.IsStatic)
                             {
                                 var scriptType = memberInfo.DeclaringType;
                                 isCompatible |= CanCastToType(scriptType, outType, _archetype.ConnectionsHints);
                             }
 
+                            // We ignore event members here since they only have output parameters, which are currently not declared as such
+                            // TODO: Fix bug where event member parameters 'IsOut' is set to false and not true
                             if (!memberInfo.IsEvent)
                             {
                                 for (int i = 0; i < parameters.Length; i++)
@@ -182,6 +179,7 @@ namespace FlaxEditor.Surface.ContextMenu
                         }
                         else
                         {
+                            // When the startBox is input we only have to check the output type of the method
                             ScriptType inType = startBox.CurrentType;
                             ScriptType outType = memberInfo.ValueType;
 
@@ -232,60 +230,10 @@ namespace FlaxEditor.Surface.ContextMenu
         {
             if (VisjectSurface.CanUseDirectCastStatic(type, currentType, false))
                 return true;
-
-            var connectionsHints = hint;
-            if (currentType == ScriptType.Null && connectionsHints != ConnectionsHint.None)
-            {
-                if ((connectionsHints & ConnectionsHint.Anything) == ConnectionsHint.Anything)
-                    return true;
-                if ((connectionsHints & ConnectionsHint.Value) == ConnectionsHint.Value && type.Type != typeof(void))
-                    return true;
-                if ((connectionsHints & ConnectionsHint.Enum) == ConnectionsHint.Enum && type.IsEnum)
-                    return true;
-                if ((connectionsHints & ConnectionsHint.Array) == ConnectionsHint.Array && type.IsArray)
-                    return true;
-                if ((connectionsHints & ConnectionsHint.Dictionary) == ConnectionsHint.Dictionary && type.IsDictionary)
-                    return true;
-                if ((connectionsHints & ConnectionsHint.Vector) == ConnectionsHint.Vector)
-                {
-                    var t = type.Type;
-                    if (t == typeof(Vector2) ||
-                        t == typeof(Vector3) ||
-                        t == typeof(Vector4) ||
-                        t == typeof(Float2) ||
-                        t == typeof(Float3) ||
-                        t == typeof(Float4) ||
-                        t == typeof(Double2) ||
-                        t == typeof(Double3) ||
-                        t == typeof(Double4) ||
-                        t == typeof(Int2) ||
-                        t == typeof(Int3) ||
-                        t == typeof(Int4) ||
-                        t == typeof(Color))
-                    {
-                        return true;
-                    }
-                }
-                if ((connectionsHints & ConnectionsHint.Scalar) == ConnectionsHint.Scalar)
-                {
-                    var t = type.Type;
-                    if (t == typeof(bool) ||
-                        t == typeof(char) ||
-                        t == typeof(byte) ||
-                        t == typeof(short) ||
-                        t == typeof(ushort) ||
-                        t == typeof(int) ||
-                        t == typeof(uint) ||
-                        t == typeof(long) ||
-                        t == typeof(ulong) ||
-                        t == typeof(float) ||
-                        t == typeof(double))
-                    {
-                        return true;
-                    }
-                }
-            }
-
+            
+            if(VisjectSurface.IsTypeCompatible(currentType, type, hint))
+                return true;
+            
             return CanCast(type, currentType);
         }
         
diff --git a/Source/Editor/Surface/Elements/Box.cs b/Source/Editor/Surface/Elements/Box.cs
index e771fa71c..5032b6048 100644
--- a/Source/Editor/Surface/Elements/Box.cs
+++ b/Source/Editor/Surface/Elements/Box.cs
@@ -231,58 +231,8 @@ namespace FlaxEditor.Surface.Elements
             }
 
             // Check using connection hints
-            var connectionsHints = ParentNode.Archetype.ConnectionsHints;
-            if (Archetype.ConnectionsType == ScriptType.Null && connectionsHints != ConnectionsHint.None)
-            {
-                if ((connectionsHints & ConnectionsHint.Anything) == ConnectionsHint.Anything)
-                    return true;
-                if ((connectionsHints & ConnectionsHint.Value) == ConnectionsHint.Value && type.Type != typeof(void))
-                    return true;
-                if ((connectionsHints & ConnectionsHint.Enum) == ConnectionsHint.Enum && type.IsEnum)
-                    return true;
-                if ((connectionsHints & ConnectionsHint.Array) == ConnectionsHint.Array && type.IsArray)
-                    return true;
-                if ((connectionsHints & ConnectionsHint.Dictionary) == ConnectionsHint.Dictionary && type.IsDictionary)
-                    return true;
-                if ((connectionsHints & ConnectionsHint.Vector) == ConnectionsHint.Vector)
-                {
-                    var t = type.Type;
-                    if (t == typeof(Vector2) ||
-                        t == typeof(Vector3) ||
-                        t == typeof(Vector4) ||
-                        t == typeof(Float2) ||
-                        t == typeof(Float3) ||
-                        t == typeof(Float4) ||
-                        t == typeof(Double2) ||
-                        t == typeof(Double3) ||
-                        t == typeof(Double4) ||
-                        t == typeof(Int2) ||
-                        t == typeof(Int3) ||
-                        t == typeof(Int4) ||
-                        t == typeof(Color))
-                    {
-                        return true;
-                    }
-                }
-                if ((connectionsHints & ConnectionsHint.Scalar) == ConnectionsHint.Scalar)
-                {
-                    var t = type.Type;
-                    if (t == typeof(bool) ||
-                        t == typeof(char) ||
-                        t == typeof(byte) ||
-                        t == typeof(short) ||
-                        t == typeof(ushort) ||
-                        t == typeof(int) ||
-                        t == typeof(uint) ||
-                        t == typeof(long) ||
-                        t == typeof(ulong) ||
-                        t == typeof(float) ||
-                        t == typeof(double))
-                    {
-                        return true;
-                    }
-                }
-            }
+            if(VisjectSurface.IsTypeCompatible(Archetype.ConnectionsType, type, ParentNode.Archetype.ConnectionsHints))
+                return true;
 
             // Check independent and if there is box with bigger potential because it may block current one from changing type
             var parentArch = ParentNode.Archetype;
diff --git a/Source/Editor/Surface/VisjectSurface.Connecting.cs b/Source/Editor/Surface/VisjectSurface.Connecting.cs
index 2fbff7cb8..449f88f8c 100644
--- a/Source/Editor/Surface/VisjectSurface.Connecting.cs
+++ b/Source/Editor/Surface/VisjectSurface.Connecting.cs
@@ -136,6 +136,70 @@ namespace FlaxEditor.Surface
             return result;
         }
 
+        /// <summary>
+        /// Checks if a type is compatible with another type and can be casted by using a connection hint
+        /// </summary>
+        /// <param name="from">Source type</param>
+        /// <param name="to">Type to check compatibility with</param>
+        /// <param name="hint">Hint to check if casting is possible</param>
+        /// <returns>True if the source type is compatible with the target type</returns>
+        public static bool IsTypeCompatible(ScriptType from, ScriptType to, ConnectionsHint hint)
+        {
+            if (from == ScriptType.Null && hint != ConnectionsHint.None)
+            {
+                if ((hint & ConnectionsHint.Anything) == ConnectionsHint.Anything)
+                    return true;
+                if ((hint & ConnectionsHint.Value) == ConnectionsHint.Value && to.Type != typeof(void))
+                    return true;
+                if ((hint & ConnectionsHint.Enum) == ConnectionsHint.Enum && to.IsEnum)
+                    return true;
+                if ((hint & ConnectionsHint.Array) == ConnectionsHint.Array && to.IsArray)
+                    return true;
+                if ((hint & ConnectionsHint.Dictionary) == ConnectionsHint.Dictionary && to.IsDictionary)
+                    return true;
+                if ((hint & ConnectionsHint.Vector) == ConnectionsHint.Vector)
+                {
+                    var t = to.Type;
+                    if (t == typeof(Vector2) ||
+                        t == typeof(Vector3) ||
+                        t == typeof(Vector4) ||
+                        t == typeof(Float2) ||
+                        t == typeof(Float3) ||
+                        t == typeof(Float4) ||
+                        t == typeof(Double2) ||
+                        t == typeof(Double3) ||
+                        t == typeof(Double4) ||
+                        t == typeof(Int2) ||
+                        t == typeof(Int3) ||
+                        t == typeof(Int4) ||
+                        t == typeof(Color))
+                    {
+                        return true;
+                    }
+                }
+                if ((hint & ConnectionsHint.Scalar) == ConnectionsHint.Scalar)
+                {
+                    var t = to.Type;
+                    if (t == typeof(bool) ||
+                        t == typeof(char) ||
+                        t == typeof(byte) ||
+                        t == typeof(short) ||
+                        t == typeof(ushort) ||
+                        t == typeof(int) ||
+                        t == typeof(uint) ||
+                        t == typeof(long) ||
+                        t == typeof(ulong) ||
+                        t == typeof(float) ||
+                        t == typeof(double))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+        
         /// <summary>
         /// Checks if can use direct conversion from one type to another.
         /// </summary>

From 091d34b20d22a9cf6bbde017c8dc84064203f498 Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Fri, 29 Sep 2023 17:26:56 +0200
Subject: [PATCH 046/103] - Even more cleanup and comments

---
 Source/Editor/Surface/ContextMenu/VisjectCM.cs     | 7 +++----
 Source/Editor/Surface/ContextMenu/VisjectCMItem.cs | 2 +-
 Source/Editor/Surface/NodeArchetype.cs             | 3 +++
 Source/Editor/Surface/VisualScriptSurface.cs       | 2 +-
 4 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/Source/Editor/Surface/ContextMenu/VisjectCM.cs b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
index c07173aec..36f71a1a7 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCM.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
@@ -494,7 +494,7 @@ namespace FlaxEditor.Surface.ContextMenu
                 _panel1.ScrollViewTo(SelectedItem);
             Profiler.EndEvent();
         }
-        
+
         /// <summary>
         /// Sort the groups and keeps <see cref="_groups"/> in sync
         /// </summary>
@@ -558,7 +558,7 @@ namespace FlaxEditor.Surface.ContextMenu
 
             SortGroups();
             PerformLayout();
-            
+
             Profiler.EndEvent();
         }
 
@@ -676,11 +676,10 @@ namespace FlaxEditor.Surface.ContextMenu
             // Prepare
             UpdateSurfaceParametersGroup();
             ResetView();
-            
             _panel1.VScrollBar.TargetValue = 0;
             Focus();
             _waitingForInput = true;
-            
+
             base.OnShow();
         }
 
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index b0ff74272..950303800 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -336,7 +336,7 @@ namespace FlaxEditor.Surface.ContextMenu
                 }
             }
         }
-        
+
         /// <inheritdoc />
         public override void Draw()
         {
diff --git a/Source/Editor/Surface/NodeArchetype.cs b/Source/Editor/Surface/NodeArchetype.cs
index 1cdaee2d2..4255b7199 100644
--- a/Source/Editor/Surface/NodeArchetype.cs
+++ b/Source/Editor/Surface/NodeArchetype.cs
@@ -73,6 +73,9 @@ namespace FlaxEditor.Surface
         All = Scalar | Vector | Enum | Anything | Value | Array | Dictionary,
     }
 
+    /// <summary>
+    /// Node type hint. Helps to distinguish special archetypes
+    /// </summary>
     [HideInEditor]
     public enum NodeTypeHint
     {
diff --git a/Source/Editor/Surface/VisualScriptSurface.cs b/Source/Editor/Surface/VisualScriptSurface.cs
index b6c0112a9..04c4da9d2 100644
--- a/Source/Editor/Surface/VisualScriptSurface.cs
+++ b/Source/Editor/Surface/VisualScriptSurface.cs
@@ -370,7 +370,7 @@ namespace FlaxEditor.Surface
                                 bindNode.Description = SurfaceUtils.GetVisualScriptMemberInfoDescription(member);
                                 bindNode.SubTitle = string.Format(" (in {0})", scriptTypeName);
                                 ((IList<NodeArchetype>)group.Archetypes).Add(bindNode);
-                                
+
                                 // Add Unbind event node
                                 var unbindNode = (NodeArchetype)Archetypes.Function.Nodes[9].Clone();
                                 unbindNode.DefaultValues[0] = scriptTypeTypeName;

From b5dc91656819b072c82d0080c3e44dffd9f2938e Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Fri, 29 Sep 2023 17:44:31 +0200
Subject: [PATCH 047/103] - Moved ScriptType casting check from Box to
 ScriptType class - Even more cleanup and comments, wowzers

---
 Source/Editor/Scripting/ScriptType.cs         | 27 ++++++++
 .../Surface/ContextMenu/VisjectCMItem.cs      | 65 ++++++++-----------
 Source/Editor/Surface/Elements/Box.cs         | 21 ++----
 3 files changed, 60 insertions(+), 53 deletions(-)

diff --git a/Source/Editor/Scripting/ScriptType.cs b/Source/Editor/Scripting/ScriptType.cs
index 454c3a5d2..e3de348d2 100644
--- a/Source/Editor/Scripting/ScriptType.cs
+++ b/Source/Editor/Scripting/ScriptType.cs
@@ -1393,5 +1393,32 @@ namespace FlaxEditor.Scripting
                 return _custom.GetMembers(name, MemberTypes.Method, bindingAttr).FirstOrDefault();
             return ScriptMemberInfo.Null;
         }
+        
+        /// <summary>
+        /// Basic check to see if a type could be casted to another type
+        /// </summary>
+        /// <param name="from">Source type</param>
+        /// <param name="to">Target type</param>
+        /// <returns>True if the type can be casted</returns>
+        public static bool CanCast(ScriptType from, ScriptType to)
+        {
+            if (from == to)
+                return true;
+            if (from == Null || to == Null)
+                return false;
+            return (from.Type != typeof(void) && from.Type != typeof(FlaxEngine.Object)) &&
+                   (to.Type != typeof(void) && to.Type != typeof(FlaxEngine.Object)) &&
+                   from.IsAssignableFrom(to);
+        }
+
+        /// <summary>
+        /// Basic check to see if this type could be casted to another type
+        /// </summary>
+        /// <param name="to">Target type</param>
+        /// <returns>True if the type can be casted</returns>
+        public bool CanCastTo(ScriptType to)
+        {
+            return CanCast(this, to);
+        }
     }
 }
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index 950303800..e3f4b0e66 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -3,7 +3,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
 using FlaxEditor.Scripting;
 using FlaxEditor.Surface.Elements;
 using FlaxEditor.Utilities;
@@ -117,12 +116,6 @@ namespace FlaxEditor.Surface.ContextMenu
 
             bool isCompatible = false;
             
-            // Check compatibility based on the defined elements in the archetype. This handles all the default groups and items
-            if (_archetype.Elements != null)
-            {
-                isCompatible = CheckElementsCompatibility(startBox);
-            }
-
             // Check compatibility based on the archetype tag or name. This handles custom groups and items, mainly function nodes for visual scripting
             if (_archetype.NodeTypeHint == NodeTypeHint.FunctionNode)
             {
@@ -134,18 +127,18 @@ namespace FlaxEditor.Surface.ContextMenu
                 {
                     memberInfo = info;
                 }
-                else if(_archetype.DefaultValues is { Length: > 1 })
+                else if(_archetype.DefaultValues is { Length: > 1 }) // We have to check since VisualScriptFunctionNode and ReturnNode don't have a name and type
                 {
                     var eventName = (string)_archetype.DefaultValues[1];
                     var eventType = TypeUtils.GetType((string)_archetype.DefaultValues[0]);
-                    memberInfo = eventType.GetMember(eventName, MemberTypes.Event, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
+                    memberInfo = eventType.GetMember(eventName, System.Reflection.MemberTypes.Event, 
+                                                     System.Reflection.BindingFlags.Public | 
+                                                     System.Reflection.BindingFlags.Static | 
+                                                     System.Reflection.BindingFlags.Instance);
                 }
 
                 if (memberInfo != ScriptMemberInfo.Null)
                 {
-                    if(memberInfo.IsEvent)
-                        isCompatible = false;
-
                     // Box was dragged from an impulse port and the member info can be invoked so it is compatible
                     if (startBox.CurrentType.IsVoid && memberInfo.ValueType.IsVoid)
                     {
@@ -163,7 +156,7 @@ namespace FlaxEditor.Surface.ContextMenu
                             if (!memberInfo.IsStatic)
                             {
                                 var scriptType = memberInfo.DeclaringType;
-                                isCompatible |= CanCastToType(scriptType, outType, _archetype.ConnectionsHints);
+                                isCompatible |= CanCastType(scriptType, outType, _archetype.ConnectionsHints);
                             }
 
                             // We ignore event members here since they only have output parameters, which are currently not declared as such
@@ -173,7 +166,7 @@ namespace FlaxEditor.Surface.ContextMenu
                                 for (int i = 0; i < parameters.Length; i++)
                                 {
                                     ScriptType inType = parameters[i].Type;
-                                    isCompatible |= CanCastToType(inType, outType, _archetype.ConnectionsHints);
+                                    isCompatible |= CanCastType(inType, outType, _archetype.ConnectionsHints);
                                 }
                             }
                         }
@@ -183,11 +176,16 @@ namespace FlaxEditor.Surface.ContextMenu
                             ScriptType inType = startBox.CurrentType;
                             ScriptType outType = memberInfo.ValueType;
 
-                            isCompatible |= CanCastToType(inType, outType, _archetype.ConnectionsHints);
+                            isCompatible |= CanCastType(inType, outType, _archetype.ConnectionsHints);
                         }
                     }
                 }
             }
+            else if (_archetype.Elements != null)
+            {
+                // Check compatibility based on the defined elements in the archetype. This handles all the default groups and items
+                isCompatible = CheckElementsCompatibility(startBox);
+            }
 
             Visible = isCompatible;
             return isCompatible;
@@ -198,54 +196,47 @@ namespace FlaxEditor.Surface.ContextMenu
             bool isCompatible = false;
             foreach (NodeElementArchetype element in _archetype.Elements)
             {
+                // Ignore all elements that aren't inputs or outputs (e.g. input fields)
                 if(element.Type != NodeElementType.Output && element.Type != NodeElementType.Input)
                     continue;
                 
+                // Ignore elements with the same direction as the box
                 if ((startBox.IsOutput && element.Type == NodeElementType.Output) || (!startBox.IsOutput && element.Type == NodeElementType.Input))
                     continue;
                 
-                ScriptType inType;
-                ScriptType outType;
+                ScriptType fromType;
+                ScriptType toType;
                 ConnectionsHint hint;
                 if (startBox.IsOutput)
                 {
-                    inType = element.ConnectionsType;
-                    outType = startBox.CurrentType;
+                    fromType = element.ConnectionsType;
+                    toType = startBox.CurrentType;
                     hint = _archetype.ConnectionsHints;
                 }
                 else
                 {
-                    inType = startBox.CurrentType;
-                    outType = element.ConnectionsType;
+                    fromType = startBox.CurrentType;
+                    toType = element.ConnectionsType;
                     hint = startBox.ParentNode.Archetype.ConnectionsHints;
                 }
                 
-                isCompatible |= CanCastToType(inType, outType, hint);
+                isCompatible |= CanCastType(fromType, toType, hint);
             }
 
             return isCompatible;
         }
         
-        private bool CanCastToType(ScriptType currentType, ScriptType type, ConnectionsHint hint)
+        private bool CanCastType(ScriptType from, ScriptType to, ConnectionsHint hint)
         {
-            if (VisjectSurface.CanUseDirectCastStatic(type, currentType, false))
+            // Yes, from and to are switched on purpose
+            if (VisjectSurface.CanUseDirectCastStatic(to, from, false))
                 return true;
             
-            if(VisjectSurface.IsTypeCompatible(currentType, type, hint))
+            if(VisjectSurface.IsTypeCompatible(from, to, hint))
                 return true;
             
-            return CanCast(type, currentType);
-        }
-        
-        private static bool CanCast(ScriptType oB, ScriptType iB)
-        {
-            if (oB == iB)
-                return true;
-            if (oB == ScriptType.Null || iB == ScriptType.Null)
-                return false;
-            return (oB.Type != typeof(void) && oB.Type != typeof(FlaxEngine.Object)) &&
-                   (iB.Type != typeof(void) && iB.Type != typeof(FlaxEngine.Object)) &&
-                   oB.IsAssignableFrom(iB);
+            // Same here
+            return to.CanCastTo(from);
         }
         
         /// <summary>
diff --git a/Source/Editor/Surface/Elements/Box.cs b/Source/Editor/Surface/Elements/Box.cs
index 5032b6048..6a265a21e 100644
--- a/Source/Editor/Surface/Elements/Box.cs
+++ b/Source/Editor/Surface/Elements/Box.cs
@@ -91,7 +91,7 @@ namespace FlaxEditor.Surface.Elements
                     _currentType = value;
 
                     // Check if will need to update box connections due to type change
-                    if ((Surface == null || Surface._isUpdatingBoxTypes == 0) && HasAnyConnection && !CanCast(prev, _currentType))
+                    if ((Surface == null || Surface._isUpdatingBoxTypes == 0) && HasAnyConnection && !prev.CanCastTo(_currentType))
                     {
                         // Remove all invalid connections and update those which still can be valid
                         var connections = Connections.ToArray();
@@ -246,7 +246,7 @@ namespace FlaxEditor.Surface.Elements
                     var b = ParentNode.GetBox(boxes[i]);
 
                     // Check if its the same and tested type matches the default value type
-                    if (b == this && CanCast(parentArch.DefaultType, type))
+                    if (b == this && parentArch.DefaultType.CanCastTo(type))
                     {
                         // Can
                         return true;
@@ -668,17 +668,6 @@ namespace FlaxEditor.Surface.Elements
             }
         }
 
-        private static bool CanCast(ScriptType oB, ScriptType iB)
-        {
-            if (oB == iB)
-                return true;
-            if (oB == ScriptType.Null || iB == ScriptType.Null)
-                return false;
-            return (oB.Type != typeof(void) && oB.Type != typeof(FlaxEngine.Object)) &&
-                   (iB.Type != typeof(void) && iB.Type != typeof(FlaxEngine.Object)) &&
-                   oB.IsAssignableFrom(iB);
-        }
-
         /// <inheritdoc />
         public bool AreConnected(IConnectionInstigator other)
         {
@@ -737,7 +726,7 @@ namespace FlaxEditor.Surface.Elements
             {
                 if (!iB.CanUseType(oB.CurrentType))
                 {
-                    if (!CanCast(oB.CurrentType, iB.CurrentType))
+                    if (!oB.CurrentType.CanCastTo(iB.CurrentType))
                     {
                         // Cannot
                         return false;
@@ -748,7 +737,7 @@ namespace FlaxEditor.Surface.Elements
             {
                 if (!oB.CanUseType(iB.CurrentType))
                 {
-                    if (!CanCast(oB.CurrentType, iB.CurrentType))
+                    if (!oB.CurrentType.CanCastTo(iB.CurrentType))
                     {
                         // Cannot
                         return false;
@@ -821,7 +810,7 @@ namespace FlaxEditor.Surface.Elements
             bool useCaster = false;
             if (!iB.CanUseType(oB.CurrentType))
             {
-                if (CanCast(oB.CurrentType, iB.CurrentType))
+                if (oB.CurrentType.CanCastTo(iB.CurrentType))
                     useCaster = true;
                 else
                     return;

From 3befe4bb4a036b7fff278bffb7d90de88baf4194 Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Fri, 29 Sep 2023 21:53:34 +0200
Subject: [PATCH 048/103] - Fixed a bug where items with a string match didn't
 get highlighted anymore when the group name matched - Remouved double
 filtering when group name matched - Started fixing asynchronous Un/Packing
 nodes filtering

---
 Source/Editor/Surface/Archetypes/Packing.cs   |   2 +
 .../Surface/ContextMenu/VisjectCMGroup.cs     |  21 +---
 .../Surface/ContextMenu/VisjectCMItem.cs      | 109 +++++++++---------
 Source/Editor/Surface/NodeArchetype.cs        |   5 +
 4 files changed, 67 insertions(+), 70 deletions(-)

diff --git a/Source/Editor/Surface/Archetypes/Packing.cs b/Source/Editor/Surface/Archetypes/Packing.cs
index 5a5e9cd5b..54524dc13 100644
--- a/Source/Editor/Surface/Archetypes/Packing.cs
+++ b/Source/Editor/Surface/Archetypes/Packing.cs
@@ -353,6 +353,7 @@ namespace FlaxEditor.Surface.Archetypes
                 Create = (id, context, arch, groupArch) => new PackStructureNode(id, context, arch, groupArch),
                 Description = "Makes the structure data to from the components.",
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.AnimGraph | NodeFlags.NoSpawnViaGUI,
+                NodeTypeHint = NodeTypeHint.PackingNode,
                 Size = new Float2(180, 20),
                 DefaultValues = new object[]
                 {
@@ -463,6 +464,7 @@ namespace FlaxEditor.Surface.Archetypes
                 Create = (id, context, arch, groupArch) => new UnpackStructureNode(id, context, arch, groupArch),
                 Description = "Breaks the structure data to allow extracting components from it.",
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.AnimGraph | NodeFlags.NoSpawnViaGUI,
+                NodeTypeHint = NodeTypeHint.PackingNode,
                 Size = new Float2(180, 20),
                 DefaultValues = new object[]
                 {
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
index efb8ab458..9ab67f856 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
@@ -90,28 +90,16 @@ namespace FlaxEditor.Surface.ContextMenu
 
             // Update items
             bool isAnyVisible = false;
+            bool groupHeaderMatches = QueryFilterHelper.Match(filterText, HeaderText);
             for (int i = 0; i < _children.Count; i++)
             {
                 if (_children[i] is VisjectCMItem item)
                 {
-                    item.UpdateFilter(filterText, selectedBox);
+                    item.UpdateFilter(filterText, selectedBox, groupHeaderMatches);
                     isAnyVisible |= item.Visible;
                 }
             }
 
-            // Update header title
-            if (QueryFilterHelper.Match(filterText, HeaderText))
-            {
-                for (int i = 0; i < _children.Count; i++)
-                {
-                    if (_children[i] is VisjectCMItem item)
-                    {
-                        item.UpdateFilter(null, selectedBox);
-                        isAnyVisible |= item.Visible;
-                    }
-                }
-            }
-
             // Update itself
             if (isAnyVisible)
             {
@@ -136,7 +124,7 @@ namespace FlaxEditor.Surface.ContextMenu
                 {
                     if (_children[i] is VisjectCMItem item)
                     {
-                        item.CanConnectTo(null);
+                        item.Visible = true;
                     }
                 }
                 Visible = true;
@@ -150,7 +138,8 @@ namespace FlaxEditor.Surface.ContextMenu
             {
                 if (_children[i] is VisjectCMItem item)
                 {
-                    isAnyVisible |= item.CanConnectTo(selectedBox);
+                    item.Visible = item.CanConnectTo(selectedBox);
+                    isAnyVisible |= item.Visible;
                 }
             }
             
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index e3f4b0e66..65ba19909 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -103,29 +103,23 @@ namespace FlaxEditor.Surface.ContextMenu
         {
             // Is compatible if box is null for reset reasons
             if (startBox == null)
-            {
-                Visible = true;
                 return true;   
-            }
 
             if (_archetype == null)
-            {
-                Visible = false;
                 return false;
-            }
 
             bool isCompatible = false;
             
             // Check compatibility based on the archetype tag or name. This handles custom groups and items, mainly function nodes for visual scripting
-            if (_archetype.NodeTypeHint == NodeTypeHint.FunctionNode)
+            if (_archetype.NodeTypeHint is NodeTypeHint.FunctionNode)
             {
                 ScriptMemberInfo memberInfo = ScriptMemberInfo.Null;
 
                 // Check if the archetype tag already has a member info otherwise try to fetch it via the archetype type and name
                 // Only really the InvokeMethod Nodes have a member info in their tag
-                if (_archetype.Tag is ScriptMemberInfo info)
+                if (_archetype.Tag is ScriptMemberInfo tagInfo)
                 {
-                    memberInfo = info;
+                    memberInfo = tagInfo;
                 }
                 else if(_archetype.DefaultValues is { Length: > 1 }) // We have to check since VisualScriptFunctionNode and ReturnNode don't have a name and type
                 {
@@ -139,46 +133,7 @@ namespace FlaxEditor.Surface.ContextMenu
 
                 if (memberInfo != ScriptMemberInfo.Null)
                 {
-                    // Box was dragged from an impulse port and the member info can be invoked so it is compatible
-                    if (startBox.CurrentType.IsVoid && memberInfo.ValueType.IsVoid)
-                    {
-                        isCompatible = true;   
-                    }
-                    else
-                    {
-                        // When the startBox is output we only need to check the input parameters
-                        if (startBox.IsOutput)
-                        {
-                            var parameters = memberInfo.GetParameters();
-                            ScriptType outType = startBox.CurrentType;
-                            
-                            // non static members have an instance input parameter
-                            if (!memberInfo.IsStatic)
-                            {
-                                var scriptType = memberInfo.DeclaringType;
-                                isCompatible |= CanCastType(scriptType, outType, _archetype.ConnectionsHints);
-                            }
-
-                            // We ignore event members here since they only have output parameters, which are currently not declared as such
-                            // TODO: Fix bug where event member parameters 'IsOut' is set to false and not true
-                            if (!memberInfo.IsEvent)
-                            {
-                                for (int i = 0; i < parameters.Length; i++)
-                                {
-                                    ScriptType inType = parameters[i].Type;
-                                    isCompatible |= CanCastType(inType, outType, _archetype.ConnectionsHints);
-                                }
-                            }
-                        }
-                        else
-                        {
-                            // When the startBox is input we only have to check the output type of the method
-                            ScriptType inType = startBox.CurrentType;
-                            ScriptType outType = memberInfo.ValueType;
-
-                            isCompatible |= CanCastType(inType, outType, _archetype.ConnectionsHints);
-                        }
-                    }
+                    isCompatible |= CheckMemberInfoCompatibility(startBox, memberInfo);
                 }
             }
             else if (_archetype.Elements != null)
@@ -186,11 +141,56 @@ namespace FlaxEditor.Surface.ContextMenu
                 // Check compatibility based on the defined elements in the archetype. This handles all the default groups and items
                 isCompatible = CheckElementsCompatibility(startBox);
             }
-
-            Visible = isCompatible;
+            
             return isCompatible;
         }
 
+        private bool CheckMemberInfoCompatibility(Box startBox, ScriptMemberInfo info)
+        {
+            bool isCompatible = false;
+            // Box was dragged from an impulse port and the member info can be invoked so it is compatible
+            if (startBox.CurrentType.IsVoid && info.ValueType.IsVoid)
+            {
+                isCompatible = true;   
+            }
+            else
+            {
+                // When the startBox is output we only need to check the input parameters
+                if (startBox.IsOutput && !info.IsField)
+                {
+                    var parameters = info.GetParameters();
+                    ScriptType outType = startBox.CurrentType;
+                    
+                    // non static members have an instance input parameter
+                    if (!info.IsStatic)
+                    {
+                        var scriptType = info.DeclaringType;
+                        isCompatible |= CanCastType(scriptType, outType, _archetype.ConnectionsHints);
+                    }
+
+                    // We ignore event members here since they only have output parameters, which are currently not declared as such
+                    // TODO: Fix bug where event member parameters 'IsOut' is set to false and not true
+                    if (!info.IsEvent)
+                    {
+                        for (int i = 0; i < parameters.Length; i++)
+                        {
+                            ScriptType inType = parameters[i].Type;
+                            isCompatible |= CanCastType(inType, outType, _archetype.ConnectionsHints);
+                        }
+                    }
+                }
+                else
+                {
+                    // When the startBox is input we only have to check the output type of the method
+                    ScriptType inType = startBox.CurrentType;
+                    ScriptType outType = info.ValueType;
+
+                    isCompatible |= CanCastType(inType, outType, _archetype.ConnectionsHints);
+                }
+            }
+            return isCompatible;
+        }
+        
         private bool CheckElementsCompatibility(Box startBox)
         {
             bool isCompatible = false;
@@ -243,11 +243,12 @@ namespace FlaxEditor.Surface.ContextMenu
         /// Updates the filter.
         /// </summary>
         /// <param name="filterText">The filter text.</param>
-        public void UpdateFilter(string filterText, Box selectedBox)
+        public void UpdateFilter(string filterText, Box selectedBox, bool groupHeaderMatches = false)
         {
             if (selectedBox != null)
             {
-                if (!CanConnectTo(selectedBox))
+                Visible = CanConnectTo(selectedBox);
+                if (!Visible)
                 {
                     _highlights?.Clear();
                     return;
@@ -319,7 +320,7 @@ namespace FlaxEditor.Surface.ContextMenu
 
                     Data = data;
                 }
-                else
+                else if(!groupHeaderMatches)
                 {
                     // Hide
                     _highlights?.Clear();
diff --git a/Source/Editor/Surface/NodeArchetype.cs b/Source/Editor/Surface/NodeArchetype.cs
index 4255b7199..146618ae7 100644
--- a/Source/Editor/Surface/NodeArchetype.cs
+++ b/Source/Editor/Surface/NodeArchetype.cs
@@ -88,6 +88,11 @@ namespace FlaxEditor.Surface
         /// Is Function Node.
         /// </summary>
         FunctionNode = 1,
+        
+        /// <summary>
+        /// Is custom Packing Node.
+        /// </summary>
+        PackingNode = 2,
     }
     
     /// <summary>

From 35f641955b0587a3adc61b7296f46f7dc209c1e6 Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Sat, 30 Sep 2023 13:20:04 +0200
Subject: [PATCH 049/103] - Removed NodeTypeHint - Added delegates to check
 compatiblity with custom archetypes - Added compatibility check to
 InvokeMethod archetype

---
 Source/Editor/Surface/Archetypes/Function.cs  | 53 +++++++++++++++----
 Source/Editor/Surface/Archetypes/Packing.cs   |  2 -
 .../Surface/ContextMenu/VisjectCMItem.cs      | 46 ++++++++--------
 Source/Editor/Surface/NodeArchetype.cs        | 47 +++++++---------
 .../Surface/VisjectSurface.Connecting.cs      | 11 ++++
 5 files changed, 92 insertions(+), 67 deletions(-)

diff --git a/Source/Editor/Surface/Archetypes/Function.cs b/Source/Editor/Surface/Archetypes/Function.cs
index d027dd8f1..422ebf35b 100644
--- a/Source/Editor/Surface/Archetypes/Function.cs
+++ b/Source/Editor/Surface/Archetypes/Function.cs
@@ -773,7 +773,7 @@ namespace FlaxEditor.Surface.Archetypes
                     Values[4] = GetSignatureData(memberInfo, memberInfo.GetParameters());
                 }
             }
-
+            
             private SignatureInfo LoadSignature()
             {
                 var signature = new SignatureInfo();
@@ -1151,6 +1151,45 @@ namespace FlaxEditor.Surface.Archetypes
 
                 base.OnDestroy();
             }
+            
+            internal static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
+            {
+                if (nodeArch.Tag is not ScriptMemberInfo memberInfo)
+                    return false;
+                if(memberInfo.ValueType.IsVoid && outputType.IsVoid)
+                    return true;
+                if (!memberInfo.IsStatic)
+                {
+                    if (VisjectSurface.FullCastCheck(memberInfo.DeclaringType, outputType, hint))
+                        return true;
+                }
+                foreach (var param in memberInfo.GetParameters())
+                {
+                    if(param.IsOut)
+                        continue;
+                    if (VisjectSurface.FullCastCheck(param.Type, outputType, hint))
+                        return true;
+                }
+                return false;
+            }
+            
+            internal static bool IsOutputCompatible(NodeArchetype nodeArch, ScriptType inputType, ConnectionsHint hint)
+            {
+                if (nodeArch.Tag is not ScriptMemberInfo memberInfo)
+                    return false;
+                if(memberInfo.ValueType.IsVoid && inputType.IsVoid)
+                    return true;
+                if (VisjectSurface.FullCastCheck(memberInfo.ValueType, inputType, hint))
+                    return true;
+                foreach (var param in memberInfo.GetParameters())
+                {
+                    if(!param.IsOut)
+                        continue;
+                    if (VisjectSurface.FullCastCheck(param.Type, inputType, hint))
+                        return true;
+                }
+                return false;
+            }
         }
 
         private sealed class ReturnNode : SurfaceNode
@@ -2228,7 +2267,6 @@ namespace FlaxEditor.Surface.Archetypes
                 Title = "Function Input",
                 Description = "The graph function input data",
                 Flags = NodeFlags.MaterialGraph | NodeFlags.ParticleEmitterGraph | NodeFlags.AnimGraph | NodeFlags.NoSpawnViaPaste,
-                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(240, 60),
                 DefaultValues = new object[]
                 {
@@ -2248,7 +2286,6 @@ namespace FlaxEditor.Surface.Archetypes
                 Title = "Function Output",
                 Description = "The graph function output data",
                 Flags = NodeFlags.MaterialGraph | NodeFlags.ParticleEmitterGraph | NodeFlags.AnimGraph | NodeFlags.NoSpawnViaPaste,
-                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(240, 60),
                 DefaultValues = new object[]
                 {
@@ -2267,7 +2304,6 @@ namespace FlaxEditor.Surface.Archetypes
                 Title = string.Empty,
                 Description = "Overrides the base class method with custom implementation",
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI | NodeFlags.NoSpawnViaPaste,
-                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(240, 60),
                 DefaultValues = new object[]
                 {
@@ -2280,9 +2316,10 @@ namespace FlaxEditor.Surface.Archetypes
             {
                 TypeID = 4,
                 Create = (id, context, arch, groupArch) => new InvokeMethodNode(id, context, arch, groupArch),
+                IsInputCompatible = InvokeMethodNode.IsInputCompatible,
+                IsOutputCompatible = InvokeMethodNode.IsOutputCompatible,
                 Title = string.Empty,
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI,
-                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(240, 60),
                 DefaultValues = new object[]
                 {
@@ -2306,7 +2343,6 @@ namespace FlaxEditor.Surface.Archetypes
                 Create = (id, context, arch, groupArch) => new ReturnNode(id, context, arch, groupArch),
                 Title = "Return",
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI,
-                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(100, 40),
                 DefaultValues = new object[]
                 {
@@ -2325,7 +2361,6 @@ namespace FlaxEditor.Surface.Archetypes
                 Title = "New Function",
                 Description = "Adds a new function to the script",
                 Flags = NodeFlags.VisualScriptGraph,
-                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(240, 20),
                 DefaultValues = new object[]
                 {
@@ -2338,7 +2373,6 @@ namespace FlaxEditor.Surface.Archetypes
                 Create = (id, context, arch, groupArch) => new GetFieldNode(id, context, arch, groupArch),
                 Title = string.Empty,
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI,
-                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(240, 60),
                 DefaultValues = new object[]
                 {
@@ -2354,7 +2388,6 @@ namespace FlaxEditor.Surface.Archetypes
                 Create = (id, context, arch, groupArch) => new SetFieldNode(id, context, arch, groupArch),
                 Title = string.Empty,
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI,
-                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(240, 60),
                 DefaultValues = new object[]
                 {
@@ -2371,7 +2404,6 @@ namespace FlaxEditor.Surface.Archetypes
                 Create = (id, context, arch, groupArch) => new BindEventNode(id, context, arch, groupArch),
                 Title = string.Empty,
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI,
-                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(260, 60),
                 DefaultValues = new object[]
                 {
@@ -2394,7 +2426,6 @@ namespace FlaxEditor.Surface.Archetypes
                 Create = (id, context, arch, groupArch) => new UnbindEventNode(id, context, arch, groupArch),
                 Title = string.Empty,
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI,
-                NodeTypeHint = NodeTypeHint.FunctionNode,
                 Size = new Float2(260, 60),
                 DefaultValues = new object[]
                 {
diff --git a/Source/Editor/Surface/Archetypes/Packing.cs b/Source/Editor/Surface/Archetypes/Packing.cs
index 54524dc13..5a5e9cd5b 100644
--- a/Source/Editor/Surface/Archetypes/Packing.cs
+++ b/Source/Editor/Surface/Archetypes/Packing.cs
@@ -353,7 +353,6 @@ namespace FlaxEditor.Surface.Archetypes
                 Create = (id, context, arch, groupArch) => new PackStructureNode(id, context, arch, groupArch),
                 Description = "Makes the structure data to from the components.",
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.AnimGraph | NodeFlags.NoSpawnViaGUI,
-                NodeTypeHint = NodeTypeHint.PackingNode,
                 Size = new Float2(180, 20),
                 DefaultValues = new object[]
                 {
@@ -464,7 +463,6 @@ namespace FlaxEditor.Surface.Archetypes
                 Create = (id, context, arch, groupArch) => new UnpackStructureNode(id, context, arch, groupArch),
                 Description = "Breaks the structure data to allow extracting components from it.",
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.AnimGraph | NodeFlags.NoSpawnViaGUI,
-                NodeTypeHint = NodeTypeHint.PackingNode,
                 Size = new Float2(180, 20),
                 DefaultValues = new object[]
                 {
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index 65ba19909..1d645a94e 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -109,9 +109,23 @@ namespace FlaxEditor.Surface.ContextMenu
                 return false;
 
             bool isCompatible = false;
+
+            if (startBox.IsOutput && _archetype.IsInputCompatible != null)
+            {
+                isCompatible |= _archetype.IsInputCompatible.Invoke(_archetype, startBox.CurrentType, _archetype.ConnectionsHints);
+            } 
+            else if (!startBox.IsOutput && _archetype.IsOutputCompatible != null)
+            {
+                isCompatible |= _archetype.IsOutputCompatible.Invoke(_archetype, startBox.CurrentType, startBox.ParentNode.Archetype.ConnectionsHints);
+            }
+            else if (_archetype.Elements != null)
+            {
+                // Check compatibility based on the defined elements in the archetype. This handles all the default groups and items
+                isCompatible = CheckElementsCompatibility(startBox);
+            }
             
             // Check compatibility based on the archetype tag or name. This handles custom groups and items, mainly function nodes for visual scripting
-            if (_archetype.NodeTypeHint is NodeTypeHint.FunctionNode)
+            /*if (_archetype.NodeTypeHint is NodeTypeHint.FunctionNode)
             {
                 ScriptMemberInfo memberInfo = ScriptMemberInfo.Null;
 
@@ -135,12 +149,8 @@ namespace FlaxEditor.Surface.ContextMenu
                 {
                     isCompatible |= CheckMemberInfoCompatibility(startBox, memberInfo);
                 }
-            }
-            else if (_archetype.Elements != null)
-            {
-                // Check compatibility based on the defined elements in the archetype. This handles all the default groups and items
-                isCompatible = CheckElementsCompatibility(startBox);
-            }
+            }*/
+            /*else */
             
             return isCompatible;
         }
@@ -165,17 +175,16 @@ namespace FlaxEditor.Surface.ContextMenu
                     if (!info.IsStatic)
                     {
                         var scriptType = info.DeclaringType;
-                        isCompatible |= CanCastType(scriptType, outType, _archetype.ConnectionsHints);
+                        isCompatible |= VisjectSurface.FullCastCheck(scriptType, outType, _archetype.ConnectionsHints);
                     }
 
                     // We ignore event members here since they only have output parameters, which are currently not declared as such
-                    // TODO: Fix bug where event member parameters 'IsOut' is set to false and not true
                     if (!info.IsEvent)
                     {
                         for (int i = 0; i < parameters.Length; i++)
                         {
                             ScriptType inType = parameters[i].Type;
-                            isCompatible |= CanCastType(inType, outType, _archetype.ConnectionsHints);
+                            isCompatible |= VisjectSurface.FullCastCheck(inType, outType, _archetype.ConnectionsHints);
                         }
                     }
                 }
@@ -185,7 +194,7 @@ namespace FlaxEditor.Surface.ContextMenu
                     ScriptType inType = startBox.CurrentType;
                     ScriptType outType = info.ValueType;
 
-                    isCompatible |= CanCastType(inType, outType, _archetype.ConnectionsHints);
+                    isCompatible |= VisjectSurface.FullCastCheck(inType, outType, _archetype.ConnectionsHints);
                 }
             }
             return isCompatible;
@@ -220,25 +229,12 @@ namespace FlaxEditor.Surface.ContextMenu
                     hint = startBox.ParentNode.Archetype.ConnectionsHints;
                 }
                 
-                isCompatible |= CanCastType(fromType, toType, hint);
+                isCompatible |= VisjectSurface.FullCastCheck(fromType, toType, hint);
             }
 
             return isCompatible;
         }
         
-        private bool CanCastType(ScriptType from, ScriptType to, ConnectionsHint hint)
-        {
-            // Yes, from and to are switched on purpose
-            if (VisjectSurface.CanUseDirectCastStatic(to, from, false))
-                return true;
-            
-            if(VisjectSurface.IsTypeCompatible(from, to, hint))
-                return true;
-            
-            // Same here
-            return to.CanCastTo(from);
-        }
-        
         /// <summary>
         /// Updates the filter.
         /// </summary>
diff --git a/Source/Editor/Surface/NodeArchetype.cs b/Source/Editor/Surface/NodeArchetype.cs
index 146618ae7..1a7f88f20 100644
--- a/Source/Editor/Surface/NodeArchetype.cs
+++ b/Source/Editor/Surface/NodeArchetype.cs
@@ -72,28 +72,6 @@ namespace FlaxEditor.Surface
         /// </summary>
         All = Scalar | Vector | Enum | Anything | Value | Array | Dictionary,
     }
-
-    /// <summary>
-    /// Node type hint. Helps to distinguish special archetypes
-    /// </summary>
-    [HideInEditor]
-    public enum NodeTypeHint
-    {
-        /// <summary>
-        /// Is Node.
-        /// </summary>
-        Default = 0,
-        
-        /// <summary>
-        /// Is Function Node.
-        /// </summary>
-        FunctionNode = 1,
-        
-        /// <summary>
-        /// Is custom Packing Node.
-        /// </summary>
-        PackingNode = 2,
-    }
     
     /// <summary>
     /// Surface node archetype description.
@@ -111,6 +89,11 @@ namespace FlaxEditor.Surface
         /// <returns>The created node object.</returns>
         public delegate SurfaceNode CreateCustomNodeFunc(uint id, VisjectSurfaceContext context, NodeArchetype nodeArch, GroupArchetype groupArch);
 
+        /// <summary>
+        /// Checks if the given type is compatible with the given node archetype. Used for custom nodes
+        /// </summary>
+        public delegate bool IsCompatible(NodeArchetype nodeArch, ScriptType portType, ConnectionsHint hint);
+        
         /// <summary>
         /// Unique node type ID within a single group.
         /// </summary>
@@ -121,6 +104,16 @@ namespace FlaxEditor.Surface
         /// </summary>
         public CreateCustomNodeFunc Create;
 
+        /// <summary>
+        /// Function for asynchronously loaded nodes to check if input ports are compatible, for filtering.
+        /// </summary>
+        public IsCompatible IsInputCompatible;
+        
+        /// <summary>
+        /// Function for asynchronously loaded nodes to check if output ports are compatible, for filtering.
+        /// </summary>
+        public IsCompatible IsOutputCompatible;
+        
         /// <summary>
         /// Default initial size of the node.
         /// </summary>
@@ -130,7 +123,7 @@ namespace FlaxEditor.Surface
         /// Custom set of flags.
         /// </summary>
         public NodeFlags Flags;
-
+        
         /// <summary>
         /// Title text.
         /// </summary>
@@ -173,11 +166,6 @@ namespace FlaxEditor.Surface
         /// Connections hints.
         /// </summary>
         public ConnectionsHint ConnectionsHints;
-
-        /// <summary>
-        /// Node Type hints.
-        /// </summary>
-        public NodeTypeHint NodeTypeHint;
         
         /// <summary>
         /// Array with independent boxes IDs.
@@ -211,6 +199,8 @@ namespace FlaxEditor.Surface
             {
                 TypeID = TypeID,
                 Create = Create,
+                IsInputCompatible = IsInputCompatible,
+                IsOutputCompatible = IsOutputCompatible,
                 Size = Size,
                 Flags = Flags,
                 Title = Title,
@@ -220,7 +210,6 @@ namespace FlaxEditor.Surface
                 DefaultValues = (object[])DefaultValues?.Clone(),
                 DefaultType = DefaultType,
                 ConnectionsHints = ConnectionsHints,
-                NodeTypeHint = NodeTypeHint,
                 IndependentBoxes = (int[])IndependentBoxes?.Clone(),
                 DependentBoxes = (int[])DependentBoxes?.Clone(),
                 Elements = (NodeElementArchetype[])Elements?.Clone(),
diff --git a/Source/Editor/Surface/VisjectSurface.Connecting.cs b/Source/Editor/Surface/VisjectSurface.Connecting.cs
index 449f88f8c..9ca4f82e8 100644
--- a/Source/Editor/Surface/VisjectSurface.Connecting.cs
+++ b/Source/Editor/Surface/VisjectSurface.Connecting.cs
@@ -199,6 +199,17 @@ namespace FlaxEditor.Surface
 
             return false;
         }
+
+        public static bool FullCastCheck(ScriptType from, ScriptType to, ConnectionsHint hint)
+        {
+            // Yes, from and to are switched on purpose
+            if (CanUseDirectCastStatic(to, from, false))
+                return true;
+            if(IsTypeCompatible(from, to, hint))
+                return true;
+            // Same here
+            return to.CanCastTo(from);
+        }
         
         /// <summary>
         /// Checks if can use direct conversion from one type to another.

From 719efc4a99d3f5d3d6ec8b98c2411c947fab7c3c Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Sat, 30 Sep 2023 13:45:21 +0200
Subject: [PATCH 050/103] - Added Input/Output compatibility check to event
 based nodes - Removed a huge chunk of compatibility checking code out of
 CMItem

---
 Source/Editor/Surface/Archetypes/Function.cs  | 41 ++++++++++
 .../Surface/ContextMenu/VisjectCMItem.cs      | 74 -------------------
 2 files changed, 41 insertions(+), 74 deletions(-)

diff --git a/Source/Editor/Surface/Archetypes/Function.cs b/Source/Editor/Surface/Archetypes/Function.cs
index 422ebf35b..975267ad2 100644
--- a/Source/Editor/Surface/Archetypes/Function.cs
+++ b/Source/Editor/Surface/Archetypes/Function.cs
@@ -2223,6 +2223,43 @@ namespace FlaxEditor.Surface.Archetypes
 
                 base.OnDestroy();
             }
+            
+            internal static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
+            {
+                // Event based nodes always have a pulse input, so it's always compatible with void
+                if (outputType.IsVoid)
+                    return true;
+                
+                var eventName = (string)nodeArch.DefaultValues[1];
+                var eventType = TypeUtils.GetType((string)nodeArch.DefaultValues[0]);
+                var member = eventType.GetMember(eventName, MemberTypes.Event, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
+                if (member && SurfaceUtils.IsValidVisualScriptEvent(member))
+                {
+                    if (!member.IsStatic)
+                    {
+                        if (VisjectSurface.FullCastCheck(eventType, outputType, hint))
+                            return true;
+                    }
+                }
+                return false;
+            }
+            
+            internal static bool IsOutputCompatible(NodeArchetype nodeArch, ScriptType inputType, ConnectionsHint hint)
+            {
+                // Event based nodes always have a pulse output, so it's always compatible with void
+                if (inputType.IsVoid)
+                    return true;
+                
+                var eventName = (string)nodeArch.DefaultValues[1];
+                var eventType = TypeUtils.GetType((string)nodeArch.DefaultValues[0]);
+                var member = eventType.GetMember(eventName, MemberTypes.Event, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
+                if (member && SurfaceUtils.IsValidVisualScriptEvent(member))
+                {
+                    if (VisjectSurface.FullCastCheck(member.ValueType, inputType, hint))
+                        return true;
+                }
+                return false;
+            }
         }
 
         private sealed class BindEventNode : EventBaseNode
@@ -2402,6 +2439,8 @@ namespace FlaxEditor.Surface.Archetypes
             {
                 TypeID = 9,
                 Create = (id, context, arch, groupArch) => new BindEventNode(id, context, arch, groupArch),
+                IsInputCompatible = EventBaseNode.IsInputCompatible,
+                IsOutputCompatible = EventBaseNode.IsOutputCompatible,
                 Title = string.Empty,
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI,
                 Size = new Float2(260, 60),
@@ -2424,6 +2463,8 @@ namespace FlaxEditor.Surface.Archetypes
             {
                 TypeID = 10,
                 Create = (id, context, arch, groupArch) => new UnbindEventNode(id, context, arch, groupArch),
+                IsInputCompatible = EventBaseNode.IsInputCompatible,
+                IsOutputCompatible = EventBaseNode.IsOutputCompatible,
                 Title = string.Empty,
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI,
                 Size = new Float2(260, 60),
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index 1d645a94e..70c60f9bf 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -109,7 +109,6 @@ namespace FlaxEditor.Surface.ContextMenu
                 return false;
 
             bool isCompatible = false;
-
             if (startBox.IsOutput && _archetype.IsInputCompatible != null)
             {
                 isCompatible |= _archetype.IsInputCompatible.Invoke(_archetype, startBox.CurrentType, _archetype.ConnectionsHints);
@@ -124,79 +123,6 @@ namespace FlaxEditor.Surface.ContextMenu
                 isCompatible = CheckElementsCompatibility(startBox);
             }
             
-            // Check compatibility based on the archetype tag or name. This handles custom groups and items, mainly function nodes for visual scripting
-            /*if (_archetype.NodeTypeHint is NodeTypeHint.FunctionNode)
-            {
-                ScriptMemberInfo memberInfo = ScriptMemberInfo.Null;
-
-                // Check if the archetype tag already has a member info otherwise try to fetch it via the archetype type and name
-                // Only really the InvokeMethod Nodes have a member info in their tag
-                if (_archetype.Tag is ScriptMemberInfo tagInfo)
-                {
-                    memberInfo = tagInfo;
-                }
-                else if(_archetype.DefaultValues is { Length: > 1 }) // We have to check since VisualScriptFunctionNode and ReturnNode don't have a name and type
-                {
-                    var eventName = (string)_archetype.DefaultValues[1];
-                    var eventType = TypeUtils.GetType((string)_archetype.DefaultValues[0]);
-                    memberInfo = eventType.GetMember(eventName, System.Reflection.MemberTypes.Event, 
-                                                     System.Reflection.BindingFlags.Public | 
-                                                     System.Reflection.BindingFlags.Static | 
-                                                     System.Reflection.BindingFlags.Instance);
-                }
-
-                if (memberInfo != ScriptMemberInfo.Null)
-                {
-                    isCompatible |= CheckMemberInfoCompatibility(startBox, memberInfo);
-                }
-            }*/
-            /*else */
-            
-            return isCompatible;
-        }
-
-        private bool CheckMemberInfoCompatibility(Box startBox, ScriptMemberInfo info)
-        {
-            bool isCompatible = false;
-            // Box was dragged from an impulse port and the member info can be invoked so it is compatible
-            if (startBox.CurrentType.IsVoid && info.ValueType.IsVoid)
-            {
-                isCompatible = true;   
-            }
-            else
-            {
-                // When the startBox is output we only need to check the input parameters
-                if (startBox.IsOutput && !info.IsField)
-                {
-                    var parameters = info.GetParameters();
-                    ScriptType outType = startBox.CurrentType;
-                    
-                    // non static members have an instance input parameter
-                    if (!info.IsStatic)
-                    {
-                        var scriptType = info.DeclaringType;
-                        isCompatible |= VisjectSurface.FullCastCheck(scriptType, outType, _archetype.ConnectionsHints);
-                    }
-
-                    // We ignore event members here since they only have output parameters, which are currently not declared as such
-                    if (!info.IsEvent)
-                    {
-                        for (int i = 0; i < parameters.Length; i++)
-                        {
-                            ScriptType inType = parameters[i].Type;
-                            isCompatible |= VisjectSurface.FullCastCheck(inType, outType, _archetype.ConnectionsHints);
-                        }
-                    }
-                }
-                else
-                {
-                    // When the startBox is input we only have to check the output type of the method
-                    ScriptType inType = startBox.CurrentType;
-                    ScriptType outType = info.ValueType;
-
-                    isCompatible |= VisjectSurface.FullCastCheck(inType, outType, _archetype.ConnectionsHints);
-                }
-            }
             return isCompatible;
         }
         

From 1dc01cd0238142c3e4336a824f8b96f0e8c7b0d2 Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Sat, 30 Sep 2023 20:07:33 +0200
Subject: [PATCH 051/103] - Added compatibility checks to packing structures
 nodes - Added compatibility checks to more function nodes

---
 Source/Editor/Surface/Archetypes/Function.cs | 135 ++++++++++++++++++-
 Source/Editor/Surface/Archetypes/Packing.cs  |  82 +++++++++++
 2 files changed, 212 insertions(+), 5 deletions(-)

diff --git a/Source/Editor/Surface/Archetypes/Function.cs b/Source/Editor/Surface/Archetypes/Function.cs
index 975267ad2..cf680c06e 100644
--- a/Source/Editor/Surface/Archetypes/Function.cs
+++ b/Source/Editor/Surface/Archetypes/Function.cs
@@ -1156,14 +1156,19 @@ namespace FlaxEditor.Surface.Archetypes
             {
                 if (nodeArch.Tag is not ScriptMemberInfo memberInfo)
                     return false;
-                if(memberInfo.ValueType.IsVoid && outputType.IsVoid)
-                    return true;
+                
                 if (!memberInfo.IsStatic)
                 {
                     if (VisjectSurface.FullCastCheck(memberInfo.DeclaringType, outputType, hint))
                         return true;
                 }
-                foreach (var param in memberInfo.GetParameters())
+                
+                var parameters = memberInfo.GetParameters();
+                bool isPure = (parameters.Length == 0 && !memberInfo.ValueType.IsVoid);
+                if (outputType.IsVoid)
+                    return !isPure;
+                
+                foreach (var param in parameters)
                 {
                     if(param.IsOut)
                         continue;
@@ -1177,10 +1182,14 @@ namespace FlaxEditor.Surface.Archetypes
             {
                 if (nodeArch.Tag is not ScriptMemberInfo memberInfo)
                     return false;
-                if(memberInfo.ValueType.IsVoid && inputType.IsVoid)
-                    return true;
                 if (VisjectSurface.FullCastCheck(memberInfo.ValueType, inputType, hint))
                     return true;
+                
+                var parameters = memberInfo.GetParameters();
+                bool isPure = (parameters.Length == 0 && !memberInfo.ValueType.IsVoid);
+                if (inputType.IsVoid)
+                    return !isPure;
+                
                 foreach (var param in memberInfo.GetParameters())
                 {
                     if(!param.IsOut)
@@ -1816,6 +1825,16 @@ namespace FlaxEditor.Surface.Archetypes
 
                 base.OnDestroy();
             }
+            
+            internal static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
+            {
+                return false;
+            }
+            
+            internal static bool IsOutputCompatible(NodeArchetype nodeArch, ScriptType inputType, ConnectionsHint hint)
+            {
+                return inputType.IsVoid;
+            }
         }
 
         private abstract class FieldNodeBase : SurfaceNode
@@ -1952,6 +1971,64 @@ namespace FlaxEditor.Surface.Archetypes
                 Title = "Get " + SurfaceUtils.GetMethodDisplayName((string)Values[1]);
                 UpdateSignature();
             }
+            
+            internal static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
+            {
+                var scriptType = TypeUtils.GetType((string)nodeArch.DefaultValues[0]);
+                if (scriptType == ScriptType.Null)
+                    return false;
+                
+                var members = scriptType.GetMembers((string)nodeArch.DefaultValues[1], MemberTypes.Field, BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
+                foreach (var member in members)
+                {
+                    if (!SurfaceUtils.IsValidVisualScriptField(member))
+                        continue;
+                        
+                    if (member)
+                    {
+                        if (!member.IsStatic && VisjectSurface.FullCastCheck(scriptType, outputType, hint))
+                            return true;
+                    }
+                    else
+                    {
+                        var isStatic = (bool)nodeArch.DefaultValues[3];
+                        if (!isStatic && VisjectSurface.FullCastCheck(scriptType, outputType, hint))
+                            return true;
+                    }
+                    break;
+                }
+                
+                return false;
+            }
+            
+            internal static bool IsOutputCompatible(NodeArchetype nodeArch, ScriptType inputType, ConnectionsHint hint)
+            {
+                var scriptType = TypeUtils.GetType((string)nodeArch.DefaultValues[0]);
+                if (scriptType == ScriptType.Null)
+                    return false;
+                
+                var members = scriptType.GetMembers((string)nodeArch.DefaultValues[1], MemberTypes.Field, BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
+                foreach (var member in members)
+                {
+                    if (!SurfaceUtils.IsValidVisualScriptField(member))
+                        continue;
+                        
+                    if (member)
+                    {
+                        if (VisjectSurface.FullCastCheck(member.ValueType, inputType, hint))
+                            return true;
+                    }
+                    else
+                    {
+                        var typeName = (string)nodeArch.DefaultValues[2];
+                        if (VisjectSurface.FullCastCheck(TypeUtils.GetType(typeName), inputType, hint))
+                            return true;
+                    }
+                    break;
+                }
+
+                return false;
+            }
         }
 
         private sealed class SetFieldNode : FieldNodeBase
@@ -2005,6 +2082,48 @@ namespace FlaxEditor.Surface.Archetypes
                 Title = "Set " + SurfaceUtils.GetMethodDisplayName((string)Values[1]);
                 UpdateSignature();
             }
+            
+            internal static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
+            {
+                if(outputType.IsVoid)
+                    return true;
+                
+                var scriptType = TypeUtils.GetType((string)nodeArch.DefaultValues[0]);
+                if (scriptType == ScriptType.Null)
+                    return false;
+                
+                var members = scriptType.GetMembers((string)nodeArch.DefaultValues[1], MemberTypes.Field, BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
+                foreach (var member in members)
+                {
+                    if (!SurfaceUtils.IsValidVisualScriptField(member))
+                        continue;
+                        
+                    if (member)
+                    {
+                        if (VisjectSurface.FullCastCheck(member.ValueType, outputType, hint))
+                            return true;
+                        if (!member.IsStatic && VisjectSurface.FullCastCheck(scriptType, outputType, hint))
+                            return true;
+                    }
+                    else
+                    {
+                        var typeName = (string)nodeArch.DefaultValues[2];
+                        if (VisjectSurface.FullCastCheck(TypeUtils.GetType(typeName), outputType, hint))
+                            return true;
+                        var isStatic = (bool)nodeArch.DefaultValues[3];
+                        if (!isStatic && VisjectSurface.FullCastCheck(scriptType, outputType, hint))
+                            return true;
+                    }
+                    break;
+                }
+                
+                return false;
+            }
+            
+            internal static bool IsOutputCompatible(NodeArchetype nodeArch, ScriptType inputType, ConnectionsHint hint)
+            {
+                return inputType.IsVoid;
+            }
         }
 
         private abstract class EventBaseNode : SurfaceNode, IFunctionsDependantNode
@@ -2395,6 +2514,8 @@ namespace FlaxEditor.Surface.Archetypes
             {
                 TypeID = 6,
                 Create = (id, context, arch, groupArch) => new VisualScriptFunctionNode(id, context, arch, groupArch),
+                IsInputCompatible = VisualScriptFunctionNode.IsInputCompatible,
+                IsOutputCompatible = VisualScriptFunctionNode.IsOutputCompatible,
                 Title = "New Function",
                 Description = "Adds a new function to the script",
                 Flags = NodeFlags.VisualScriptGraph,
@@ -2408,6 +2529,8 @@ namespace FlaxEditor.Surface.Archetypes
             {
                 TypeID = 7,
                 Create = (id, context, arch, groupArch) => new GetFieldNode(id, context, arch, groupArch),
+                IsInputCompatible = GetFieldNode.IsInputCompatible,
+                IsOutputCompatible = GetFieldNode.IsOutputCompatible,
                 Title = string.Empty,
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI,
                 Size = new Float2(240, 60),
@@ -2423,6 +2546,8 @@ namespace FlaxEditor.Surface.Archetypes
             {
                 TypeID = 8,
                 Create = (id, context, arch, groupArch) => new SetFieldNode(id, context, arch, groupArch),
+                IsInputCompatible = SetFieldNode.IsInputCompatible,
+                IsOutputCompatible = SetFieldNode.IsOutputCompatible,
                 Title = string.Empty,
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI,
                 Size = new Float2(240, 60),
diff --git a/Source/Editor/Surface/Archetypes/Packing.cs b/Source/Editor/Surface/Archetypes/Packing.cs
index 5a5e9cd5b..ccabaaa6d 100644
--- a/Source/Editor/Surface/Archetypes/Packing.cs
+++ b/Source/Editor/Surface/Archetypes/Packing.cs
@@ -207,6 +207,26 @@ namespace FlaxEditor.Surface.Archetypes
                     AddElement(box);
                 }
             }
+            
+            protected static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
+            {
+                // Event based nodes always have a pulse input, so it's always compatible with void
+                if (outputType.IsVoid)
+                    return true;
+                
+                var eventName = (string)nodeArch.DefaultValues[1];
+                var eventType = TypeUtils.GetType((string)nodeArch.DefaultValues[0]);
+                var member = eventType.GetMember(eventName, MemberTypes.Event, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
+                if (member && SurfaceUtils.IsValidVisualScriptEvent(member))
+                {
+                    if (!member.IsStatic)
+                    {
+                        if (VisjectSurface.FullCastCheck(eventType, outputType, hint))
+                            return true;
+                    }
+                }
+                return false;
+            }
         }
 
         private sealed class PackStructureNode : StructureNode
@@ -216,6 +236,35 @@ namespace FlaxEditor.Surface.Archetypes
             : base(id, context, nodeArch, groupArch, false)
             {
             }
+            
+            internal static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
+            {
+                var typeName = (string)nodeArch.DefaultValues[0];
+                var type = TypeUtils.GetType(typeName);
+                if (type)
+                {
+                    var fields = type.GetMembers(BindingFlags.Public | BindingFlags.Instance).Where(x => x.IsField).ToArray();
+                    var fieldsLength = fields.Length;
+                    for (var i = 0; i < fieldsLength; i++)
+                    {
+                        if (VisjectSurface.FullCastCheck(fields[i].ValueType, outputType, hint))
+                            return true;
+                    }
+                }
+                return false;
+            }
+            
+            internal static bool IsOutputCompatible(NodeArchetype nodeArch, ScriptType inputType, ConnectionsHint hint)
+            {
+                var typeName = (string)nodeArch.DefaultValues[0];
+                var type = TypeUtils.GetType(typeName);
+                if (type)
+                {
+                    if (VisjectSurface.FullCastCheck(type, inputType, hint))
+                        return true;
+                }
+                return false;
+            }
         }
 
         private sealed class UnpackStructureNode : StructureNode
@@ -225,6 +274,35 @@ namespace FlaxEditor.Surface.Archetypes
             : base(id, context, nodeArch, groupArch, true)
             {
             }
+
+            internal static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
+            {
+                var typeName = (string)nodeArch.DefaultValues[0];
+                var type = TypeUtils.GetType(typeName);
+                if (type)
+                {
+                    if (VisjectSurface.FullCastCheck(type, outputType, hint))
+                        return true;
+                }
+                return false;
+            }
+            
+            internal static bool IsOutputCompatible(NodeArchetype nodeArch, ScriptType inputType, ConnectionsHint hint)
+            {
+                var typeName = (string)nodeArch.DefaultValues[0];
+                var type = TypeUtils.GetType(typeName);
+                if (type)
+                {
+                    var fields = type.GetMembers(BindingFlags.Public | BindingFlags.Instance).Where(x => x.IsField).ToArray();
+                    var fieldsLength = fields.Length;
+                    for (var i = 0; i < fieldsLength; i++)
+                    {
+                        if (VisjectSurface.FullCastCheck(fields[i].ValueType, inputType, hint))
+                            return true;
+                    }
+                }
+                return false;
+            }
         }
 
         /// <summary>
@@ -351,6 +429,8 @@ namespace FlaxEditor.Surface.Archetypes
                 TypeID = 26,
                 Title = "Pack Structure",
                 Create = (id, context, arch, groupArch) => new PackStructureNode(id, context, arch, groupArch),
+                IsInputCompatible = PackStructureNode.IsInputCompatible,
+                IsOutputCompatible = PackStructureNode.IsOutputCompatible,
                 Description = "Makes the structure data to from the components.",
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.AnimGraph | NodeFlags.NoSpawnViaGUI,
                 Size = new Float2(180, 20),
@@ -461,6 +541,8 @@ namespace FlaxEditor.Surface.Archetypes
                 TypeID = 36,
                 Title = "Unpack Structure",
                 Create = (id, context, arch, groupArch) => new UnpackStructureNode(id, context, arch, groupArch),
+                IsInputCompatible = UnpackStructureNode.IsInputCompatible,
+                IsOutputCompatible = UnpackStructureNode.IsOutputCompatible,
                 Description = "Breaks the structure data to allow extracting components from it.",
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.AnimGraph | NodeFlags.NoSpawnViaGUI,
                 Size = new Float2(180, 20),

From 2e09c4fb6381aa91e64f16ce0558a66ab0856a7b Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Sat, 30 Sep 2023 20:22:49 +0200
Subject: [PATCH 052/103] - Made visject items a tiny tiny tiny bit taller

---
 Source/Editor/Surface/ContextMenu/VisjectCMItem.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index 70c60f9bf..28a9392b2 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -58,7 +58,7 @@ namespace FlaxEditor.Surface.ContextMenu
         /// <param name="groupArchetype">The group archetype.</param>
         /// <param name="archetype">The archetype.</param>
         public VisjectCMItem(VisjectCMGroup group, GroupArchetype groupArchetype, NodeArchetype archetype)
-        : base(0, 0, 120, 12)
+        : base(0, 0, 120, 14)
         {
             Group = group;
             _groupArchetype = groupArchetype;

From aca6d7110d7d6504ef938baa195840a5eea77755 Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Sat, 30 Sep 2023 20:27:51 +0200
Subject: [PATCH 053/103] - Cleanup and comments

---
 Source/Editor/Surface/Archetypes/Function.cs        | 2 +-
 Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs | 4 ++--
 Source/Editor/Surface/NodeArchetype.cs              | 6 +++---
 Source/Editor/Surface/VisjectSurface.Connecting.cs  | 7 +++++++
 4 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/Source/Editor/Surface/Archetypes/Function.cs b/Source/Editor/Surface/Archetypes/Function.cs
index cf680c06e..d56d6d790 100644
--- a/Source/Editor/Surface/Archetypes/Function.cs
+++ b/Source/Editor/Surface/Archetypes/Function.cs
@@ -773,7 +773,7 @@ namespace FlaxEditor.Surface.Archetypes
                     Values[4] = GetSignatureData(memberInfo, memberInfo.GetParameters());
                 }
             }
-            
+
             private SignatureInfo LoadSignature()
             {
                 var signature = new SignatureInfo();
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
index 9ab67f856..aab9f3112 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
@@ -153,10 +153,10 @@ namespace FlaxEditor.Surface.ContextMenu
                 // Hide group if none of the items matched the filter
                 Visible = false;
             }
-            
+
             Profiler.EndEvent();
         }
-        
+
         /// <summary>
         /// Updates the sorting of the <see cref="VisjectCMItem"/>s of this <see cref="VisjectCMGroup"/>
         /// Also updates the <see cref="SortScore"/>
diff --git a/Source/Editor/Surface/NodeArchetype.cs b/Source/Editor/Surface/NodeArchetype.cs
index 1a7f88f20..e2a9c84fa 100644
--- a/Source/Editor/Surface/NodeArchetype.cs
+++ b/Source/Editor/Surface/NodeArchetype.cs
@@ -72,7 +72,7 @@ namespace FlaxEditor.Surface
         /// </summary>
         All = Scalar | Vector | Enum | Anything | Value | Array | Dictionary,
     }
-    
+
     /// <summary>
     /// Surface node archetype description.
     /// </summary>
@@ -123,7 +123,7 @@ namespace FlaxEditor.Surface
         /// Custom set of flags.
         /// </summary>
         public NodeFlags Flags;
-        
+
         /// <summary>
         /// Title text.
         /// </summary>
@@ -166,7 +166,7 @@ namespace FlaxEditor.Surface
         /// Connections hints.
         /// </summary>
         public ConnectionsHint ConnectionsHints;
-        
+
         /// <summary>
         /// Array with independent boxes IDs.
         /// </summary>
diff --git a/Source/Editor/Surface/VisjectSurface.Connecting.cs b/Source/Editor/Surface/VisjectSurface.Connecting.cs
index 9ca4f82e8..145bdfedf 100644
--- a/Source/Editor/Surface/VisjectSurface.Connecting.cs
+++ b/Source/Editor/Surface/VisjectSurface.Connecting.cs
@@ -200,6 +200,13 @@ namespace FlaxEditor.Surface
             return false;
         }
 
+        /// <summary>
+        /// Checks if a type is compatible with another type and can be casted by using a connection hint
+        /// </summary>
+        /// <param name="from">Source type</param>
+        /// <param name="to">Target type</param>
+        /// <param name="hint">Connection hint</param>
+        /// <returns>True if any method of casting or compatibility check succeeds</returns>
         public static bool FullCastCheck(ScriptType from, ScriptType to, ConnectionsHint hint)
         {
             // Yes, from and to are switched on purpose

From 07d13f0144e115ce2eed05c1b9a7db4f7473281f Mon Sep 17 00:00:00 2001
From: Nils Hausfeld <nils.hausfeld@axon-flux.com>
Date: Sat, 30 Sep 2023 23:06:26 +0200
Subject: [PATCH 054/103] - Implemented very basic support for method override
 nodes - Cleanup

---
 Source/Editor/Surface/Archetypes/Function.cs | 12 ++++++++++++
 Source/Editor/Surface/VisualScriptSurface.cs |  1 -
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/Source/Editor/Surface/Archetypes/Function.cs b/Source/Editor/Surface/Archetypes/Function.cs
index d56d6d790..de89ab50c 100644
--- a/Source/Editor/Surface/Archetypes/Function.cs
+++ b/Source/Editor/Surface/Archetypes/Function.cs
@@ -744,6 +744,16 @@ namespace FlaxEditor.Surface.Archetypes
 
                 base.OnDestroy();
             }
+            
+            internal static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
+            {
+                return false;
+            }
+            
+            internal static bool IsOutputCompatible(NodeArchetype nodeArch, ScriptType inputType, ConnectionsHint hint)
+            {
+                return inputType.IsVoid;
+            }
         }
 
         private sealed class InvokeMethodNode : SurfaceNode
@@ -2460,6 +2470,8 @@ namespace FlaxEditor.Surface.Archetypes
                 Title = string.Empty,
                 Description = "Overrides the base class method with custom implementation",
                 Flags = NodeFlags.VisualScriptGraph | NodeFlags.NoSpawnViaGUI | NodeFlags.NoSpawnViaPaste,
+                IsInputCompatible = MethodOverrideNode.IsInputCompatible,
+                IsOutputCompatible = MethodOverrideNode.IsOutputCompatible,
                 Size = new Float2(240, 60),
                 DefaultValues = new object[]
                 {
diff --git a/Source/Editor/Surface/VisualScriptSurface.cs b/Source/Editor/Surface/VisualScriptSurface.cs
index 04c4da9d2..e961f686d 100644
--- a/Source/Editor/Surface/VisualScriptSurface.cs
+++ b/Source/Editor/Surface/VisualScriptSurface.cs
@@ -589,7 +589,6 @@ namespace FlaxEditor.Surface
                         node.DefaultValues[0] = name;
                         node.DefaultValues[1] = parameters.Length;
                         node.Title = "Override " + name;
-                        node.Tag = member;
                         nodes.Add(node);
                     }
                 }

From b492c9421bc7b73245f394a48335d2dcee553034 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Sun, 1 Oct 2023 21:02:08 +0200
Subject: [PATCH 055/103] Fix `Tag` deserialization in cooked game

#1534
---
 Source/Engine/Serialization/JsonConverters.cs | 28 +++++++++++++++++++
 Source/Engine/Serialization/JsonSerializer.cs |  1 +
 2 files changed, 29 insertions(+)

diff --git a/Source/Engine/Serialization/JsonConverters.cs b/Source/Engine/Serialization/JsonConverters.cs
index 40f9cb5a2..ebcea8b30 100644
--- a/Source/Engine/Serialization/JsonConverters.cs
+++ b/Source/Engine/Serialization/JsonConverters.cs
@@ -351,6 +351,34 @@ namespace FlaxEngine.Json
         }
     }
 
+    /// <summary>
+    /// Serialize <see cref="Tag"/> as inlined text.
+    /// </summary>
+    /// <seealso cref="Newtonsoft.Json.JsonConverter" />
+    internal class TagConverter : JsonConverter
+    {
+        /// <inheritdoc />
+        public override void WriteJson(JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
+        {
+            var tag = (Tag)value;
+            writer.WriteValue(tag.ToString());
+        }
+
+        /// <inheritdoc />
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.String)
+                return Tags.Get((string)reader.Value);
+            return Tag.Default;
+        }
+
+        /// <inheritdoc />
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType == typeof(Tag);
+        }
+    }
+
     /*
     /// <summary>
     /// Serialize Guid values using `N` format
diff --git a/Source/Engine/Serialization/JsonSerializer.cs b/Source/Engine/Serialization/JsonSerializer.cs
index 619862b1f..36aeaae4c 100644
--- a/Source/Engine/Serialization/JsonSerializer.cs
+++ b/Source/Engine/Serialization/JsonSerializer.cs
@@ -127,6 +127,7 @@ namespace FlaxEngine.Json
             settings.Converters.Add(new MarginConverter());
             settings.Converters.Add(new VersionConverter());
             settings.Converters.Add(new LocalizedStringConverter());
+            settings.Converters.Add(new TagConverter());
             //settings.Converters.Add(new GuidConverter());
             return settings;
         }

From 652510ee50ba123a49d3fb344ddd53d9979daa47 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Sun, 1 Oct 2023 21:55:20 +0200
Subject: [PATCH 056/103] Minor codestyle tweaks for #1420

---
 .../Engine/Level/Components/MissingScript.h   | 44 +++++++++----------
 Source/Engine/Level/SceneObjectsFactory.cpp   | 15 ++++---
 2 files changed, 31 insertions(+), 28 deletions(-)

diff --git a/Source/Engine/Level/Components/MissingScript.h b/Source/Engine/Level/Components/MissingScript.h
index 601346203..bfb73498f 100644
--- a/Source/Engine/Level/Components/MissingScript.h
+++ b/Source/Engine/Level/Components/MissingScript.h
@@ -1,4 +1,8 @@
-#pragma once
+// Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
+
+#pragma once
+
+#if USE_EDITOR
 
 #include "Engine/Core/Cache.h"
 #include "Engine/Scripting/Script.h"
@@ -13,8 +17,10 @@ API_CLASS(Attributes="HideInEditor") class FLAXENGINE_API MissingScript : public
     API_AUTO_SERIALIZATION();
     DECLARE_SCRIPTING_TYPE(MissingScript);
 
-public:
+private:
+    ScriptingObjectReference<Script> _referenceScript;
 
+public:
     /// <summary>
     /// Namespace and type name of missing script.
     /// </summary>
@@ -28,8 +34,7 @@ public:
     /// <summary>
     /// Field for assigning new script to transfer data to.
     /// </summary>
-    API_PROPERTY()
-    FORCE_INLINE ScriptingObjectReference<Script> GetReferenceScript() const
+    API_PROPERTY() ScriptingObjectReference<Script> GetReferenceScript() const
     {
         return _referenceScript;
     }
@@ -37,29 +42,24 @@ public:
     /// <summary>
     /// Field for assigning new script to transfer data to.
     /// </summary>
-    API_PROPERTY()
-    void SetReferenceScript(ScriptingObjectReference<Script> value)
+    API_PROPERTY() void SetReferenceScript(const ScriptingObjectReference<Script>& value)
     {
         _referenceScript = value;
+        if (Data.IsEmpty())
+            return;
+        rapidjson_flax::Document document;
+        document.Parse(Data.ToStringAnsi().GetText());
 
-        if(Data.IsEmpty()) return;
-        
-        MapToReferenceScript();
-    }
-
-private:
-    ScriptingObjectReference<Script> _referenceScript;
-    
-    void MapToReferenceScript()
-    {
-        rapidjson_flax::Document doc;
-        doc.Parse(Data.ToStringAnsi().GetText());
-        
         auto modifier = Cache::ISerializeModifier.Get();
-        _referenceScript->Deserialize(doc, modifier.Value);
+        _referenceScript->Deserialize(document, modifier.Value);
 
-        this->DeleteObject();
+        DeleteObject();
     }
 };
 
-inline MissingScript::MissingScript(const SpawnParams& params) : Script(params){}
+inline MissingScript::MissingScript(const SpawnParams& params)
+    : Script(params)
+{
+}
+
+#endif
diff --git a/Source/Engine/Level/SceneObjectsFactory.cpp b/Source/Engine/Level/SceneObjectsFactory.cpp
index 2eb341a2f..7fc7ac7f6 100644
--- a/Source/Engine/Level/SceneObjectsFactory.cpp
+++ b/Source/Engine/Level/SceneObjectsFactory.cpp
@@ -231,7 +231,8 @@ void SceneObjectsFactory::HandleObjectDeserializationError(const ISerializable::
     rapidjson_flax::StringBuffer buffer;
     PrettyJsonWriter writer(buffer);
     value.Accept(writer.GetWriter());
-    LOG(Warning, "Failed to deserialize scene object from data: {0}", String(buffer.GetString()));
+    String bufferStr(buffer.GetString());
+    LOG(Warning, "Failed to deserialize scene object from data: {0}", bufferStr);
 
     // Try to log some useful info about missing object (eg. it's parent name for faster fixing)
     const auto parentIdMember = value.FindMember("ParentID");
@@ -241,12 +242,14 @@ void SceneObjectsFactory::HandleObjectDeserializationError(const ISerializable::
         Actor* parent = Scripting::FindObject<Actor>(parentId);
         if (parent)
         {
-            MissingScript* dummyScript = parent->AddScript<MissingScript>();
-
+#if USE_EDITOR
+            // Add dummy script
+            auto* dummyScript = parent->AddScript<MissingScript>();
             const auto parentIdMember = value.FindMember("TypeName");
-            dummyScript->MissingTypeName = parentIdMember->value.GetString();
-            dummyScript->Data = String(buffer.GetString());
-            
+            if (parentIdMember != value.MemberEnd() && parentIdMember->value.IsString())
+                dummyScript->MissingTypeName = parentIdMember->value.GetString();
+            dummyScript->Data = MoveTemp(bufferStr);
+#endif
             LOG(Warning, "Parent actor of the missing object: {0}", parent->GetName());
         }
     }

From 10ea0b066519c6a54844c12cce5695c4b1a05990 Mon Sep 17 00:00:00 2001
From: Menotdan <32620310+Menotdan@users.noreply.github.com>
Date: Mon, 2 Oct 2023 03:32:11 -0400
Subject: [PATCH 057/103] Make it clearer what "Restore Materials on Reimport"
 means.

---
 Source/Engine/Tools/ModelTool/ModelTool.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Source/Engine/Tools/ModelTool/ModelTool.h b/Source/Engine/Tools/ModelTool/ModelTool.h
index 9dc5bf067..e67c90873 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.h
+++ b/Source/Engine/Tools/ModelTool/ModelTool.h
@@ -337,8 +337,8 @@ public:
         // If checked, the importer will import texture files used by the model and any embedded texture resources.
         API_FIELD(Attributes="EditorOrder(410), EditorDisplay(\"Materials\"), VisibleIf(nameof(ShowGeometry))")
         bool ImportTextures = true;
-        // If checked, the importer will try to restore the model material slots.
-        API_FIELD(Attributes="EditorOrder(420), EditorDisplay(\"Materials\", \"Restore Materials On Reimport\"), VisibleIf(nameof(ShowGeometry))")
+        // If checked, the importer will try to keep the model's current material slots, instead of importing materials from the source file.
+        API_FIELD(Attributes="EditorOrder(420), EditorDisplay(\"Materials\", \"Keep Material Slots on Reimport\"), VisibleIf(nameof(ShowGeometry))")
         bool RestoreMaterialsOnReimport = true;
 
     public: // SDF

From 0ea3cb0d690244423459fe6a504c0bb227459bd3 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Mon, 2 Oct 2023 11:05:19 +0200
Subject: [PATCH 058/103] Improve workflow with Android project generated after
 #1570

---
 .../Flax.Build/Platforms/Linux/LinuxPlatform.cs | 10 ++++++----
 .../VisualStudioProjectGenerator.cs             | 17 ++++++++++++++++-
 2 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/Source/Tools/Flax.Build/Platforms/Linux/LinuxPlatform.cs b/Source/Tools/Flax.Build/Platforms/Linux/LinuxPlatform.cs
index 44a2c247a..a47a048aa 100644
--- a/Source/Tools/Flax.Build/Platforms/Linux/LinuxPlatform.cs
+++ b/Source/Tools/Flax.Build/Platforms/Linux/LinuxPlatform.cs
@@ -37,7 +37,7 @@ namespace Flax.Build.Platforms
         public LinuxPlatform()
         {
             // Try to use system compiler
-            if (Platform.BuildTargetPlatform == TargetPlatform.Linux)
+            if (BuildTargetPlatform == TargetPlatform.Linux)
             {
                 // Pick the newest compiler (overriden by specified in command line)
                 if (Which(Configuration.Compiler) != null)
@@ -67,7 +67,7 @@ namespace Flax.Build.Platforms
                 Log.Verbose($"Using native Linux toolchain (compiler {Compiler})");
                 HasRequiredSDKsInstalled = true;
             }
-            else if (Platform.BuildTargetPlatform != TargetPlatform.Mac)
+            else if (BuildTargetPlatform != TargetPlatform.Mac)
             {
                 // Check if Linux toolchain is installed
                 string toolchainName = "v13_clang-7.0.1-centos7";
@@ -76,9 +76,11 @@ namespace Flax.Build.Platforms
                 {
                     if (string.IsNullOrEmpty(toolchainsRoot))
                     {
-                        Log.Warning("Missing Linux Toolchain. Cannot build for Linux platform.");
+                        if (BuildTargetPlatform == TargetPlatform.Linux)
+                            Log.Warning("Missing Linux Toolchain. Cannot build for Linux platform.");
+                        else
+                            Log.Verbose("Missing Linux Toolchain. Cannot build for Linux platform.");
                     }
-
                     return;
                 }
 
diff --git a/Source/Tools/Flax.Build/Projects/VisualStudio/VisualStudioProjectGenerator.cs b/Source/Tools/Flax.Build/Projects/VisualStudio/VisualStudioProjectGenerator.cs
index a6684d6eb..5bf8be5c8 100644
--- a/Source/Tools/Flax.Build/Projects/VisualStudio/VisualStudioProjectGenerator.cs
+++ b/Source/Tools/Flax.Build/Projects/VisualStudio/VisualStudioProjectGenerator.cs
@@ -24,6 +24,13 @@ namespace Flax.Build.Projects.VisualStudio
             /// <inheritdoc />
             public override void Generate(string solutionPath)
             {
+                // Try to reuse the existing project guid from existing files
+                ProjectGuid = GetProjectGuid(Path, Name);
+                if (ProjectGuid == Guid.Empty)
+                    ProjectGuid = GetProjectGuid(solutionPath, Name);
+                if (ProjectGuid == Guid.Empty)
+                    ProjectGuid = Guid.NewGuid();
+
                 var gen = (VisualStudioProjectGenerator)Generator;
                 var projectFileToolVersion = gen.ProjectFileToolVersion;
                 var vcProjectFileContent = new StringBuilder();
@@ -500,7 +507,15 @@ namespace Flax.Build.Projects.VisualStudio
                                     firstEditorMatch = i;
                                 }
                             }
-                            if (firstFullMatch != -1)
+                            if (project is AndroidProject)
+                            {
+                                // Utility Android deploy project only for exact match
+                                if (firstFullMatch != -1)
+                                    projectConfiguration = configuration;
+                                else
+                                    projectConfiguration = new SolutionConfiguration(project.Configurations[0]);
+                            }
+                            else if (firstFullMatch != -1)
                             {
                                 projectConfiguration = configuration;
                                 build = solution.MainProject == project || (solution.MainProject == null && project.Name == solution.Name);

From 70f0fbe954fd37338df044e652f205201abdc1f6 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Mon, 2 Oct 2023 11:37:24 +0200
Subject: [PATCH 059/103] Fix crash on Vulkan when drawing shader without
 binding proper constant Buffer

#1289
---
 .../Vulkan/GPUContextVulkan.cpp               | 24 ++++++++++++-------
 .../GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp |  2 +-
 2 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/Source/Engine/GraphicsDevice/Vulkan/GPUContextVulkan.cpp b/Source/Engine/GraphicsDevice/Vulkan/GPUContextVulkan.cpp
index d52b446e3..b0bb1c733 100644
--- a/Source/Engine/GraphicsDevice/Vulkan/GPUContextVulkan.cpp
+++ b/Source/Engine/GraphicsDevice/Vulkan/GPUContextVulkan.cpp
@@ -459,9 +459,9 @@ void GPUContextVulkan::UpdateDescriptorSets(const SpirvShaderDescriptorInfo& des
             {
             case VK_DESCRIPTOR_TYPE_SAMPLER:
             {
-                const VkSampler sampler = _samplerHandles[slot];
-                ASSERT(sampler);
-                needsWrite |= dsWriter.WriteSampler(descriptorIndex, sampler, index);
+                const VkSampler handle = _samplerHandles[slot];
+                ASSERT(handle);
+                needsWrite |= dsWriter.WriteSampler(descriptorIndex, handle, index);
                 break;
             }
             case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
@@ -547,12 +547,18 @@ void GPUContextVulkan::UpdateDescriptorSets(const SpirvShaderDescriptorInfo& des
             }
             case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
             {
-                auto cb = handles[slot];
-                ASSERT(cb);
-                VkBuffer buffer;
-                VkDeviceSize offset, range;
-                uint32 dynamicOffset;
-                cb->DescriptorAsDynamicUniformBuffer(this, buffer, offset, range, dynamicOffset);
+                auto handle = handles[slot];
+                VkBuffer buffer = VK_NULL_HANDLE;
+                VkDeviceSize offset = 0, range = 0;
+                uint32 dynamicOffset = 0;
+                if (handle)
+                    handle->DescriptorAsDynamicUniformBuffer(this, buffer, offset, range, dynamicOffset);
+                else
+                {
+                    const auto dummy = _device->HelperResources.GetDummyBuffer();
+                    buffer = dummy->GetHandle();
+                    range = dummy->GetSize();
+                }
                 needsWrite |= dsWriter.WriteDynamicUniformBuffer(descriptorIndex, buffer, offset, range, dynamicOffset, index);
                 break;
             }
diff --git a/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp b/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp
index eb23c0871..bd6246d6d 100644
--- a/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp
+++ b/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp
@@ -868,7 +868,7 @@ GPUBufferVulkan* HelperResourcesVulkan::GetDummyBuffer()
     if (!_dummyBuffer)
     {
         _dummyBuffer = (GPUBufferVulkan*)_device->CreateBuffer(TEXT("DummyBuffer"));
-        _dummyBuffer->Init(GPUBufferDescription::Buffer(sizeof(int32), GPUBufferFlags::ShaderResource | GPUBufferFlags::UnorderedAccess, PixelFormat::R32_SInt));
+        _dummyBuffer->Init(GPUBufferDescription::Buffer(sizeof(int32) * 256, GPUBufferFlags::ShaderResource | GPUBufferFlags::UnorderedAccess, PixelFormat::R32_SInt));
     }
 
     return _dummyBuffer;

From 1156f72fbe726b64338cfd8a8a8bd554029bd191 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Mon, 2 Oct 2023 12:40:37 +0200
Subject: [PATCH 060/103] Add versions sorting to VulkanSDK selection on macOS

---
 .../Vulkan/GraphicsDeviceVulkan.Build.cs      |  3 ++-
 .../Platforms/Android/AndroidNdk.cs           | 14 +----------
 .../Tools/Flax.Build/Utilities/Utilities.cs   | 23 +++++++++++++++++++
 3 files changed, 26 insertions(+), 14 deletions(-)

diff --git a/Source/Engine/GraphicsDevice/Vulkan/GraphicsDeviceVulkan.Build.cs b/Source/Engine/GraphicsDevice/Vulkan/GraphicsDeviceVulkan.Build.cs
index 252652978..9ffa68272 100644
--- a/Source/Engine/GraphicsDevice/Vulkan/GraphicsDeviceVulkan.Build.cs
+++ b/Source/Engine/GraphicsDevice/Vulkan/GraphicsDeviceVulkan.Build.cs
@@ -51,7 +51,8 @@ public sealed class VulkanSdk : Sdk
                     var subDirs = Directory.GetDirectories(path);
                     if (subDirs.Length != 0)
                     {
-                        path = Path.Combine(subDirs[0], "macOS");
+                        Flax.Build.Utilities.SortVersionDirectories(subDirs);
+                        path = Path.Combine(subDirs.Last(), "macOS");
                         if (Directory.Exists(path))
                             vulkanSdk = path;
                     }
diff --git a/Source/Tools/Flax.Build/Platforms/Android/AndroidNdk.cs b/Source/Tools/Flax.Build/Platforms/Android/AndroidNdk.cs
index 3d7359d93..ba1a5558d 100644
--- a/Source/Tools/Flax.Build/Platforms/Android/AndroidNdk.cs
+++ b/Source/Tools/Flax.Build/Platforms/Android/AndroidNdk.cs
@@ -42,19 +42,7 @@ namespace Flax.Build.Platforms
                     var subdirs = Directory.GetDirectories(Path.Combine(AndroidSdk.Instance.RootPath, "ndk"));
                     if (subdirs.Length != 0)
                     {
-                        Array.Sort(subdirs, (a, b) =>
-                        {
-                            Version va, vb;
-                            if (Version.TryParse(a, out va))
-                            {
-                                if (Version.TryParse(b, out vb))
-                                    return va.CompareTo(vb);
-                                return 1;
-                            }
-                            if (Version.TryParse(b, out vb))
-                                return -1;
-                            return 0;
-                        });
+                        Utilities.SortVersionDirectories(subdirs);
                         sdkPath = subdirs.Last();
                     }
                 }
diff --git a/Source/Tools/Flax.Build/Utilities/Utilities.cs b/Source/Tools/Flax.Build/Utilities/Utilities.cs
index af6777199..268fb06c9 100644
--- a/Source/Tools/Flax.Build/Utilities/Utilities.cs
+++ b/Source/Tools/Flax.Build/Utilities/Utilities.cs
@@ -746,5 +746,28 @@ namespace Flax.Build
             text = text.Replace(findWhat, replaceWith);
             File.WriteAllText(file, text);
         }
+
+        /// <summary>
+        /// Sorts the directories by name assuming they contain version text. Sorted from lowest to the highest version.
+        /// </summary>
+        /// <param name="file">The paths array to sort.</param>
+        public static void SortVersionDirectories(string[] paths)
+        {
+            if (paths == null || paths.Length == 0)
+                return;
+            Array.Sort(paths, (a, b) =>
+            {
+                Version va, vb;
+                if (Version.TryParse(a, out va))
+                {
+                    if (Version.TryParse(b, out vb))
+                        return va.CompareTo(vb);
+                    return 1;
+                }
+                if (Version.TryParse(b, out vb))
+                    return -1;
+                return 0;
+            });
+        }
     }
 }

From 17291a8a139bdd95715ffac21c2ead5139e67109 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Mon, 2 Oct 2023 12:48:14 +0200
Subject: [PATCH 061/103] Fix `Cannot find compatible metal driver` on macOS
 due to the newest Vulkan SDK regression

#1469
---
 .../GraphicsDevice/Vulkan/GPUDeviceVulkan.Layers.cpp  |  7 +++++++
 .../Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp  |  3 +++
 .../GraphicsDevice/Vulkan/IncludeVulkanHeaders.h      | 11 +++++++++++
 3 files changed, 21 insertions(+)

diff --git a/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.Layers.cpp b/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.Layers.cpp
index bdd92c762..1e086788e 100644
--- a/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.Layers.cpp
+++ b/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.Layers.cpp
@@ -35,6 +35,10 @@ static const char* GValidationLayers[] =
 
 static const char* GInstanceExtensions[] =
 {
+#if PLATFORM_APPLE_FAMILY && defined(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)
+    VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME,
+    VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
+#endif
 #if VK_EXT_validation_cache
     VK_EXT_VALIDATION_CACHE_EXTENSION_NAME,
 #endif
@@ -46,6 +50,9 @@ static const char* GInstanceExtensions[] =
 
 static const char* GDeviceExtensions[] =
 {
+#if PLATFORM_APPLE_FAMILY && defined(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME)
+    VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME,
+#endif
     VK_KHR_SWAPCHAIN_EXTENSION_NAME,
 #if VK_KHR_maintenance1
     VK_KHR_MAINTENANCE1_EXTENSION_NAME,
diff --git a/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp b/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp
index bd6246d6d..cb40504d4 100644
--- a/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp
+++ b/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp
@@ -1078,6 +1078,9 @@ GPUDevice* GPUDeviceVulkan::Create()
 
     VkInstanceCreateInfo instInfo;
     RenderToolsVulkan::ZeroStruct(instInfo, VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO);
+#ifdef PLATFORM_APPLE_FAMILY
+    instInfo.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
+#endif
     instInfo.pApplicationInfo = &appInfo;
 
     GetInstanceLayersAndExtensions(InstanceExtensions, InstanceLayers, SupportsDebugUtilsExt);
diff --git a/Source/Engine/GraphicsDevice/Vulkan/IncludeVulkanHeaders.h b/Source/Engine/GraphicsDevice/Vulkan/IncludeVulkanHeaders.h
index 3a1b6a615..4e2694aab 100644
--- a/Source/Engine/GraphicsDevice/Vulkan/IncludeVulkanHeaders.h
+++ b/Source/Engine/GraphicsDevice/Vulkan/IncludeVulkanHeaders.h
@@ -41,4 +41,15 @@
 #define VMA_NOT_NULL
 #include <ThirdParty/VulkanMemoryAllocator/vk_mem_alloc.h>
 
+#if PLATFORM_APPLE_FAMILY
+// Declare potentially missing extensions from newer SDKs
+#ifndef VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME
+#define VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME "VK_KHR_portability_enumeration"
+#define VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR 0x00000001
+#endif
+#ifndef VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME
+#define VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME "VK_KHR_portability_subset"
+#endif
+#endif
+
 #endif

From 41f005f95bd084760816011d53fe929e92a7261f Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Mon, 2 Oct 2023 12:49:02 +0200
Subject: [PATCH 062/103] Fix typo from
 17291a8a139bdd95715ffac21c2ead5139e67109

---
 Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp b/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp
index cb40504d4..6de1755dc 100644
--- a/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp
+++ b/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp
@@ -1078,7 +1078,7 @@ GPUDevice* GPUDeviceVulkan::Create()
 
     VkInstanceCreateInfo instInfo;
     RenderToolsVulkan::ZeroStruct(instInfo, VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO);
-#ifdef PLATFORM_APPLE_FAMILY
+#if PLATFORM_APPLE_FAMILY
     instInfo.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
 #endif
     instInfo.pApplicationInfo = &appInfo;

From 8bafdb0b78970544436600b19ac26ba8f6ed36e5 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Mon, 2 Oct 2023 12:52:44 +0200
Subject: [PATCH 063/103] Remove `std::function` usage from `ArrayExtensions`

---
 Source/Engine/Core/Collections/ArrayExtensions.h     | 12 +++++-------
 Source/Engine/Foliage/FoliageType.cpp                |  2 +-
 Source/Engine/Graphics/Models/SkeletonMapping.h      |  2 +-
 .../GraphicsDevice/Vulkan/GPUDeviceVulkan.Layers.cpp |  2 +-
 .../Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp |  4 ++--
 Source/Engine/Tools/ModelTool/ModelTool.cpp          |  2 +-
 6 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/Source/Engine/Core/Collections/ArrayExtensions.h b/Source/Engine/Core/Collections/ArrayExtensions.h
index 788b31edb..2ae6da9c8 100644
--- a/Source/Engine/Core/Collections/ArrayExtensions.h
+++ b/Source/Engine/Core/Collections/ArrayExtensions.h
@@ -4,7 +4,7 @@
 
 #include "../Collections/Array.h"
 #include "../Collections/Dictionary.h"
-#include <functional>
+#include "../Delegate.h"
 
 class ArrayExtensions;
 
@@ -23,7 +23,6 @@ public:
     /// <summary>
     /// Gets the common key.
     /// </summary>
-    /// <returns>The key.</returns>
     FORCE_INLINE const TKey& GetKey() const
     {
         return _key;
@@ -32,7 +31,6 @@ public:
     /// <summary>
     /// Gets the common key.
     /// </summary>
-    /// <returns>The key.</returns>
     FORCE_INLINE TKey GetKey()
     {
         return _key;
@@ -52,7 +50,7 @@ public:
     /// <param name="predicate">The prediction function. Should return true for the target element to find.</param>
     /// <returns>The index of the element or -1 if nothing found.</returns>
     template<typename T, typename AllocationType>
-    static int32 IndexOf(const Array<T, AllocationType>& obj, const std::function<bool(const T&)>& predicate)
+    static int32 IndexOf(const Array<T, AllocationType>& obj, const Function<bool(const T&)>& predicate)
     {
         for (int32 i = 0; i < obj.Count(); i++)
         {
@@ -71,7 +69,7 @@ public:
     /// <param name="predicate">The prediction function.</param>
     /// <returns>True if any element in the collection matches the prediction, otherwise false.</returns>
     template<typename T, typename AllocationType>
-    static bool Any(const Array<T, AllocationType>& obj, const std::function<bool(const T&)>& predicate)
+    static bool Any(const Array<T, AllocationType>& obj, const Function<bool(const T&)>& predicate)
     {
         for (int32 i = 0; i < obj.Count(); i++)
         {
@@ -90,7 +88,7 @@ public:
     /// <param name="predicate">The prediction function.</param>
     /// <returns>True if all elements in the collection matches the prediction, otherwise false.</returns>
     template<typename T, typename AllocationType>
-    static int32 All(const Array<T, AllocationType>& obj, const std::function<bool(const T&)>& predicate)
+    static int32 All(const Array<T, AllocationType>& obj, const Function<bool(const T&)>& predicate)
     {
         for (int32 i = 0; i < obj.Count(); i++)
         {
@@ -109,7 +107,7 @@ public:
     /// <param name="keySelector">A function to extract the key for each element.</param>
     /// <param name="result">The result collection with groups.</param>
     template<typename TSource, typename TKey, typename AllocationType>
-    static void GroupBy(const Array<TSource, AllocationType>& obj, const std::function<TKey(TSource const&)>& keySelector, Array<IGrouping<TKey, TSource>, AllocationType>& result)
+    static void GroupBy(const Array<TSource, AllocationType>& obj, const Function<TKey(TSource const&)>& keySelector, Array<IGrouping<TKey, TSource>, AllocationType>& result)
     {
         Dictionary<TKey, IGrouping<TKey, TSource>> data(static_cast<int32>(obj.Count() * 3.0f));
         for (int32 i = 0; i < obj.Count(); i++)
diff --git a/Source/Engine/Foliage/FoliageType.cpp b/Source/Engine/Foliage/FoliageType.cpp
index 785010c44..7d530dfed 100644
--- a/Source/Engine/Foliage/FoliageType.cpp
+++ b/Source/Engine/Foliage/FoliageType.cpp
@@ -130,7 +130,7 @@ void FoliageType::Serialize(SerializeStream& stream, const void* otherObj)
 
     SERIALIZE(Model);
 
-    const std::function<bool(const ModelInstanceEntry&)> IsValidMaterial = [](const ModelInstanceEntry& e) -> bool
+    const Function<bool(const ModelInstanceEntry&)> IsValidMaterial = [](const ModelInstanceEntry& e) -> bool
     {
         return e.Material;
     };
diff --git a/Source/Engine/Graphics/Models/SkeletonMapping.h b/Source/Engine/Graphics/Models/SkeletonMapping.h
index ac2af245b..e3ec0c793 100644
--- a/Source/Engine/Graphics/Models/SkeletonMapping.h
+++ b/Source/Engine/Graphics/Models/SkeletonMapping.h
@@ -66,7 +66,7 @@ public:
             const auto parentModelIndex = node.ParentIndex;
 
             // Find matching node in skeleton (or map to best parent)
-            const std::function<bool(const T&)> f = [node](const T& x) -> bool
+            const Function<bool(const T&)> f = [node](const T& x) -> bool
             {
                 return x.Name == node.Name;
             };
diff --git a/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.Layers.cpp b/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.Layers.cpp
index 1e086788e..0b857d394 100644
--- a/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.Layers.cpp
+++ b/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.Layers.cpp
@@ -578,7 +578,7 @@ void GPUDeviceVulkan::ParseOptionalDeviceExtensions(const Array<const char*>& de
 
     const auto HasExtension = [&deviceExtensions](const char* name) -> bool
     {
-        const std::function<bool(const char* const&)> CheckCallback = [&name](const char* const& extension) -> bool
+        const Function<bool(const char* const&)> CheckCallback = [&name](const char* const& extension) -> bool
         {
             return StringUtils::Compare(extension, name) == 0;
         };
diff --git a/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp b/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp
index 6de1755dc..b4a6112a9 100644
--- a/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp
+++ b/Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp
@@ -431,7 +431,7 @@ void DeferredDeletionQueueVulkan::EnqueueGenericResource(Type type, uint64 handl
     ScopeLock lock(_locker);
 
 #if BUILD_DEBUG
-    const std::function<bool(const Entry&)> ContainsHandle = [handle](const Entry& e)
+    const Function<bool(const Entry&)> ContainsHandle = [handle](const Entry& e)
     {
         return e.Handle == handle;
     };
@@ -1087,7 +1087,7 @@ GPUDevice* GPUDeviceVulkan::Create()
 
     const auto hasExtension = [](const Array<const char*>& extensions, const char* name) -> bool
     {
-        const std::function<bool(const char* const&)> callback = [&name](const char* const& extension) -> bool
+        const Function<bool(const char* const&)> callback = [&name](const char* const& extension) -> bool
         {
             return extension && StringUtils::Compare(extension, name) == 0;
         };
diff --git a/Source/Engine/Tools/ModelTool/ModelTool.cpp b/Source/Engine/Tools/ModelTool/ModelTool.cpp
index 15c7cbc32..9c9fb00a4 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.cpp
@@ -1474,7 +1474,7 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
 
             // Group meshes that can be merged together
             typedef Pair<int32, int32> MeshGroupKey;
-            const std::function<MeshGroupKey(MeshData* const&)> f = [](MeshData* const& x) -> MeshGroupKey
+            const Function<MeshGroupKey(MeshData* const&)> f = [](MeshData* const& x) -> MeshGroupKey
             {
                 return MeshGroupKey(x->NodeIndex, x->MaterialSlotIndex);
             };

From 8a9d0271a38534692d1e6e1c7ed4cec58c36fc85 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Mon, 2 Oct 2023 13:04:21 +0200
Subject: [PATCH 064/103] =?UTF-8?q?Add=20ignoring=20=E2=80=99.DS=5FStore?=
 =?UTF-8?q?=E2=80=99=20files=20in=20Content=20on=20macOS?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 Source/Editor/Modules/ContentDatabaseModule.cs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/Source/Editor/Modules/ContentDatabaseModule.cs b/Source/Editor/Modules/ContentDatabaseModule.cs
index 143352421..c35b010c7 100644
--- a/Source/Editor/Modules/ContentDatabaseModule.cs
+++ b/Source/Editor/Modules/ContentDatabaseModule.cs
@@ -931,6 +931,11 @@ namespace FlaxEditor.Modules
                 // Check if node already has that element (skip during init when we want to walk project dir very fast)
                 if (_isDuringFastSetup || !parent.Folder.ContainsChild(path))
                 {
+#if PLATFORM_MAC
+                    if (path.EndsWith(".DS_Store", StringComparison.Ordinal))
+                        continue;
+#endif
+
                     // Create file item
                     ContentItem item;
                     if (path.EndsWith(".cs"))
@@ -972,6 +977,11 @@ namespace FlaxEditor.Modules
                 // Check if node already has that element (skip during init when we want to walk project dir very fast)
                 if (_isDuringFastSetup || !parent.Folder.ContainsChild(path))
                 {
+#if PLATFORM_MAC
+                    if (path.EndsWith(".DS_Store", StringComparison.Ordinal))
+                        continue;
+#endif
+
                     // Create file item
                     ContentItem item = null;
                     if (FlaxEngine.Content.GetAssetInfo(path, out var assetInfo))

From 5fe135e10b788dc5199ba6d5a49313cb095c8f38 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Mon, 2 Oct 2023 13:11:20 +0200
Subject: [PATCH 065/103] Fix updating Content folder name when renamed in
 Finder on macOS

---
 Source/Editor/Content/Tree/MainContentTreeNode.cs | 2 +-
 Source/Editor/Modules/ContentDatabaseModule.cs    | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/Source/Editor/Content/Tree/MainContentTreeNode.cs b/Source/Editor/Content/Tree/MainContentTreeNode.cs
index 43b36986d..def873622 100644
--- a/Source/Editor/Content/Tree/MainContentTreeNode.cs
+++ b/Source/Editor/Content/Tree/MainContentTreeNode.cs
@@ -29,7 +29,7 @@ namespace FlaxEditor.Content
             //_watcher.Changed += OnEvent;
             _watcher.Created += OnEvent;
             _watcher.Deleted += OnEvent;
-            //_watcher.Renamed += OnEvent;
+            _watcher.Renamed += OnEvent;
         }
 
         private void OnEvent(object sender, FileSystemEventArgs e)
diff --git a/Source/Editor/Modules/ContentDatabaseModule.cs b/Source/Editor/Modules/ContentDatabaseModule.cs
index c35b010c7..552658aa1 100644
--- a/Source/Editor/Modules/ContentDatabaseModule.cs
+++ b/Source/Editor/Modules/ContentDatabaseModule.cs
@@ -1207,6 +1207,7 @@ namespace FlaxEditor.Modules
             {
             case WatcherChangeTypes.Created:
             case WatcherChangeTypes.Deleted:
+            case WatcherChangeTypes.Renamed:
             {
                 lock (_dirtyNodes)
                 {

From dd66ee3521b9b7a21b39bb65f5ce04616311dfb7 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Mon, 2 Oct 2023 13:08:15 +0200
Subject: [PATCH 066/103] Add using text `Show in Finder` on macOS in Editor

---
 Source/Editor/Content/Import/ImportFilesDialog.cs  | 2 +-
 Source/Editor/Utilities/Constants.cs               | 6 ++++++
 Source/Editor/Windows/ContentWindow.ContextMenu.cs | 6 +++---
 Source/Editor/Windows/OutputLogWindow.cs           | 2 +-
 Source/Editor/Windows/Profiler/Assets.cs           | 2 +-
 Source/Editor/Windows/Search/SearchItem.cs         | 2 +-
 6 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/Source/Editor/Content/Import/ImportFilesDialog.cs b/Source/Editor/Content/Import/ImportFilesDialog.cs
index ab2c7be15..967583cf6 100644
--- a/Source/Editor/Content/Import/ImportFilesDialog.cs
+++ b/Source/Editor/Content/Import/ImportFilesDialog.cs
@@ -139,7 +139,7 @@ namespace FlaxEditor.Content.Import
             var menu = new ContextMenu();
             menu.AddButton("Rename", OnRenameClicked);
             menu.AddButton("Don't import", OnDontImportClicked);
-            menu.AddButton("Show in Explorer", OnShowInExplorerClicked);
+            menu.AddButton(Utilities.Constants.ShowInExplorer, OnShowInExplorerClicked);
             menu.Tag = node;
             menu.Show(node, location);
         }
diff --git a/Source/Editor/Utilities/Constants.cs b/Source/Editor/Utilities/Constants.cs
index 176fed5f7..fb9f82cf5 100644
--- a/Source/Editor/Utilities/Constants.cs
+++ b/Source/Editor/Utilities/Constants.cs
@@ -14,5 +14,11 @@ namespace FlaxEditor.Utilities
         public const string FacebookUrl = "https://facebook.com/FlaxEngine";
         public const string YoutubeUrl = "https://youtube.com/c/FlaxEngine";
         public const string TwitterUrl = "https://twitter.com/FlaxEngine";
+
+#if PLATFORM_MAC
+        public const string ShowInExplorer = "Show in Finder";
+#else
+        public const string ShowInExplorer = "Show in explorer";
+#endif
     }
 }
diff --git a/Source/Editor/Windows/ContentWindow.ContextMenu.cs b/Source/Editor/Windows/ContentWindow.ContextMenu.cs
index 6923d634d..1dd26ecf5 100644
--- a/Source/Editor/Windows/ContentWindow.ContextMenu.cs
+++ b/Source/Editor/Windows/ContentWindow.ContextMenu.cs
@@ -58,7 +58,7 @@ namespace FlaxEditor.Windows
 
             if (item is ContentFolder contentFolder && contentFolder.Node is ProjectTreeNode)
             {
-                cm.AddButton("Show in explorer", () => FileSystem.ShowFileExplorer(CurrentViewFolder.Path));
+                cm.AddButton(Utilities.Constants.ShowInExplorer, () => FileSystem.ShowFileExplorer(CurrentViewFolder.Path));
             }
             else if (isValidElement)
             {
@@ -72,7 +72,7 @@ namespace FlaxEditor.Windows
                             Open(e);
                     });
 
-                cm.AddButton("Show in explorer", () => FileSystem.ShowFileExplorer(System.IO.Path.GetDirectoryName(item.Path)));
+                cm.AddButton(Utilities.Constants.ShowInExplorer, () => FileSystem.ShowFileExplorer(System.IO.Path.GetDirectoryName(item.Path)));
 
                 if (item.HasDefaultThumbnail == false)
                 {
@@ -135,7 +135,7 @@ namespace FlaxEditor.Windows
             }
             else
             {
-                cm.AddButton("Show in explorer", () => FileSystem.ShowFileExplorer(CurrentViewFolder.Path));
+                cm.AddButton(Utilities.Constants.ShowInExplorer, () => FileSystem.ShowFileExplorer(CurrentViewFolder.Path));
 
                 b = cm.AddButton("Paste", _view.Paste);
                 b.Enabled = _view.CanPaste();
diff --git a/Source/Editor/Windows/OutputLogWindow.cs b/Source/Editor/Windows/OutputLogWindow.cs
index 1d188a32c..3665b7073 100644
--- a/Source/Editor/Windows/OutputLogWindow.cs
+++ b/Source/Editor/Windows/OutputLogWindow.cs
@@ -195,7 +195,7 @@ namespace FlaxEditor.Windows
             _contextMenu.AddButton("Clear log", Clear);
             _contextMenu.AddButton("Copy selection", _output.Copy);
             _contextMenu.AddButton("Select All", _output.SelectAll);
-            _contextMenu.AddButton("Show in explorer", () => FileSystem.ShowFileExplorer(Path.Combine(Globals.ProjectFolder, "Logs")));
+            _contextMenu.AddButton(Utilities.Constants.ShowInExplorer, () => FileSystem.ShowFileExplorer(Path.Combine(Globals.ProjectFolder, "Logs")));
             _contextMenu.AddButton("Scroll to bottom", () => { _vScroll.TargetValue = _vScroll.Maximum; }).Icon = Editor.Icons.ArrowDown12;
 
             // Setup editor options
diff --git a/Source/Editor/Windows/Profiler/Assets.cs b/Source/Editor/Windows/Profiler/Assets.cs
index e2a65d496..3ccf6e2eb 100644
--- a/Source/Editor/Windows/Profiler/Assets.cs
+++ b/Source/Editor/Windows/Profiler/Assets.cs
@@ -274,7 +274,7 @@ namespace FlaxEditor.Windows.Profiler
                 ContextMenuButton b;
                 b = cm.AddButton("Open", () => Editor.Instance.ContentEditing.Open(assetItem));
                 cm.AddButton("Show in content window", () => Editor.Instance.Windows.ContentWin.Select(assetItem));
-                cm.AddButton("Show in explorer", () => FileSystem.ShowFileExplorer(System.IO.Path.GetDirectoryName(assetItem.Path)));
+                cm.AddButton(Utilities.Constants.ShowInExplorer, () => FileSystem.ShowFileExplorer(System.IO.Path.GetDirectoryName(assetItem.Path)));
                 cm.AddButton("Select actors using this asset", () => Editor.Instance.SceneEditing.SelectActorsUsingAsset(assetItem.ID));
                 cm.AddButton("Show asset references graph", () => Editor.Instance.Windows.Open(new AssetReferencesGraphWindow(Editor.Instance, assetItem)));
                 cm.AddButton("Copy name", () => Clipboard.Text = assetItem.NamePath);
diff --git a/Source/Editor/Windows/Search/SearchItem.cs b/Source/Editor/Windows/Search/SearchItem.cs
index e8bdc4e56..506d30d0d 100644
--- a/Source/Editor/Windows/Search/SearchItem.cs
+++ b/Source/Editor/Windows/Search/SearchItem.cs
@@ -157,7 +157,7 @@ namespace FlaxEditor.Windows.Search
                 var cm = new FlaxEditor.GUI.ContextMenu.ContextMenu { Tag = assetItem };
                 b = cm.AddButton("Open", () => Editor.Instance.ContentFinding.Open(Item));
                 cm.AddSeparator();
-                cm.AddButton("Show in explorer", () => FileSystem.ShowFileExplorer(System.IO.Path.GetDirectoryName(assetItem.Path)));
+                cm.AddButton(Utilities.Constants.ShowInExplorer, () => FileSystem.ShowFileExplorer(System.IO.Path.GetDirectoryName(assetItem.Path)));
                 cm.AddButton("Show in Content window", () => Editor.Instance.Windows.ContentWin.Select(assetItem, true));
                 b.Enabled = proxy != null && proxy.CanReimport(assetItem);
                 if (assetItem is BinaryAssetItem binaryAsset)

From 4e42f84873d86711b0c5d40883be5ad15911efe0 Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Mon, 2 Oct 2023 08:39:13 -0500
Subject: [PATCH 067/103] Fix bug in depreciated triggered action placement.

---
 Source/Engine/Engine/InputEvent.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Source/Engine/Engine/InputEvent.cs b/Source/Engine/Engine/InputEvent.cs
index 8c84a8a7f..0267aed96 100644
--- a/Source/Engine/Engine/InputEvent.cs
+++ b/Source/Engine/Engine/InputEvent.cs
@@ -81,10 +81,10 @@ namespace FlaxEngine
             case InputActionState.None: break;
             case InputActionState.Waiting: break;
             case InputActionState.Pressing:
-                Triggered?.Invoke();
                 Pressing?.Invoke();
                 break;
             case InputActionState.Press:
+                Triggered?.Invoke();
                 Pressed?.Invoke();
                 break;
             case InputActionState.Release:

From 4149da5f9edbfdae923c6ad7f84d3136d265c9b0 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Mon, 2 Oct 2023 18:57:40 +0200
Subject: [PATCH 068/103] Fix crash when generating project files with
 toolchain setup that fails

#1537
---
 Source/Tools/Flax.Build/Build/Platform.cs     | 22 +++++++++++++------
 .../Tools/Flax.Build/Utilities/Utilities.cs   |  2 +-
 2 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/Source/Tools/Flax.Build/Build/Platform.cs b/Source/Tools/Flax.Build/Build/Platform.cs
index 16f114363..f458225fa 100644
--- a/Source/Tools/Flax.Build/Build/Platform.cs
+++ b/Source/Tools/Flax.Build/Build/Platform.cs
@@ -244,7 +244,19 @@ namespace Flax.Build
         /// <returns>The toolchain.</returns>
         public Toolchain TryGetToolchain(TargetArchitecture targetArchitecture)
         {
-            return HasRequiredSDKsInstalled ? GetToolchain(targetArchitecture) : null;
+            Toolchain result = null;
+            if (HasRequiredSDKsInstalled)
+            {
+                try
+                {
+                    result = GetToolchain(targetArchitecture);
+                }
+                catch (Exception ex)
+                {
+                    Log.Exception(ex);
+                }
+            }
+            return result;
         }
 
         /// <summary>
@@ -260,16 +272,12 @@ namespace Flax.Build
             if (_toolchains == null)
                 _toolchains = new Dictionary<TargetArchitecture, Toolchain>();
 
-            var key = targetArchitecture;
-
             Toolchain toolchain;
-            if (_toolchains.TryGetValue(key, out toolchain))
-            {
+            if (_toolchains.TryGetValue(targetArchitecture, out toolchain))
                 return toolchain;
-            }
 
             toolchain = CreateToolchain(targetArchitecture);
-            _toolchains.Add(key, toolchain);
+            _toolchains.Add(targetArchitecture, toolchain);
 
             return toolchain;
         }
diff --git a/Source/Tools/Flax.Build/Utilities/Utilities.cs b/Source/Tools/Flax.Build/Utilities/Utilities.cs
index ed7116a5d..b001eea3f 100644
--- a/Source/Tools/Flax.Build/Utilities/Utilities.cs
+++ b/Source/Tools/Flax.Build/Utilities/Utilities.cs
@@ -764,7 +764,7 @@ namespace Flax.Build
         /// <summary>
         /// Sorts the directories by name assuming they contain version text. Sorted from lowest to the highest version.
         /// </summary>
-        /// <param name="file">The paths array to sort.</param>
+        /// <param name="paths">The paths array to sort.</param>
         public static void SortVersionDirectories(string[] paths)
         {
             if (paths == null || paths.Length == 0)

From 78b074e7da62acbd30ace3213c4dabea255f34a1 Mon Sep 17 00:00:00 2001
From: nothingTVatYT <rjakob13@googlemail.com>
Date: Tue, 3 Oct 2023 01:14:35 +0200
Subject: [PATCH 069/103] Fix segfault: target can be null when font size is
 changed

---
 Source/Editor/Windows/ContentWindow.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Source/Editor/Windows/ContentWindow.cs b/Source/Editor/Windows/ContentWindow.cs
index c25316e9a..b8e8a15ed 100644
--- a/Source/Editor/Windows/ContentWindow.cs
+++ b/Source/Editor/Windows/ContentWindow.cs
@@ -989,7 +989,7 @@ namespace FlaxEditor.Windows
                 }
                 _view.ShowItems(items, _sortType, false, true);
             }
-            else
+            else if (target != null)
             {
                 // Show folder contents
                 var items = target.Folder.Children;

From 8007417fe53ad1dd2767abfe7a9312bbd5ec3cf7 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Tue, 3 Oct 2023 09:50:50 +0200
Subject: [PATCH 070/103] Fix applying scale to imported models with Assimp

#1445 #1443
---
 Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp b/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp
index 7eff75514..fe684591e 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp
@@ -705,8 +705,15 @@ bool ModelTool::ImportDataAssimp(const char* path, ImportedModelData& data, Opti
             return true;
         }
 
+        // Create root node
+        AssimpNode& rootNode = context->Nodes.AddOne();
+        rootNode.ParentIndex = -1;
+        rootNode.LodIndex = 0;
+        rootNode.Name = TEXT("Root");
+        rootNode.LocalTransform = Transform::Identity;
+
         // Process imported scene nodes
-        ProcessNodes(*context, context->Scene->mRootNode, -1);
+        ProcessNodes(*context, context->Scene->mRootNode, 0);
     }
     DeleteMe<AssimpImporterData> contextCleanup(options.SplitContext ? nullptr : context);
 

From 2caa168dd9256d58fcceb6abd1d194af2b1146f1 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Tue, 3 Oct 2023 10:00:57 +0200
Subject: [PATCH 071/103] Fix using `DefaultFrameRate` for animation imported
 with Assimp

#1444
---
 Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp b/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp
index fe684591e..8aa9199fe 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp
@@ -829,7 +829,13 @@ bool ModelTool::ImportDataAssimp(const char* path, ImportedModelData& data, Opti
             const auto animations = context->Scene->mAnimations[animIndex];
             data.Animation.Channels.Resize(animations->mNumChannels, false);
             data.Animation.Duration = animations->mDuration;
-            data.Animation.FramesPerSecond = animations->mTicksPerSecond != 0.0 ? animations->mTicksPerSecond : 25.0;
+            data.Animation.FramesPerSecond = animations->mTicksPerSecond;
+            if (data.Animation.FramesPerSecond <= 0)
+            {
+                data.Animation.FramesPerSecond = context->Options.DefaultFrameRate;
+                if (data.Animation.FramesPerSecond <= 0)
+                    data.Animation.FramesPerSecond = 30.0f;
+            }
 
             for (unsigned i = 0; i < animations->mNumChannels; i++)
             {

From 78b08b455213b7e58f6f720052637e08d45bcef1 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Tue, 3 Oct 2023 12:22:35 +0200
Subject: [PATCH 072/103] Backport
 https://github.com/nem0/OpenFBX/commit/ccceff4f7889611dd1fd9d5fd2d5ccecbc210b9f

---
 Source/ThirdParty/OpenFBX/ofbx.cpp | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/Source/ThirdParty/OpenFBX/ofbx.cpp b/Source/ThirdParty/OpenFBX/ofbx.cpp
index 001a39271..be917dd9c 100644
--- a/Source/ThirdParty/OpenFBX/ofbx.cpp
+++ b/Source/ThirdParty/OpenFBX/ofbx.cpp
@@ -1184,7 +1184,6 @@ struct GeometryImpl : Geometry
 	const BlendShape* blendShape = nullptr;
 
 	std::vector<int> indices;
-	std::vector<int> to_old_vertices;
 	std::vector<NewVertex> to_new_vertices;
 
 	GeometryImpl(const Scene& _scene, const IElement& _element)
@@ -1765,7 +1764,7 @@ struct AnimationLayerImpl : AnimationLayer
 	{
 		for (const AnimationCurveNodeImpl* node : curve_nodes)
 		{
-			if (node->bone_link_property == prop && node->bone == &bone) return node;
+			if (node->bone_link_property.begin && node->bone_link_property == prop && node->bone == &bone) return node;
 		}
 		return nullptr;
 	}
@@ -2487,20 +2486,22 @@ static void buildGeometryVertexData(
 	std::vector<int>& to_old_indices,
 	bool triangulationEnabled)
 {
+	std::vector<int> to_old_vertices;
+
 	if (triangulationEnabled) {
-		triangulate(original_indices, &geom->to_old_vertices, &to_old_indices);
-		geom->vertices.resize(geom->to_old_vertices.size());
+		triangulate(original_indices, &to_old_vertices, &to_old_indices);
+		geom->vertices.resize(to_old_vertices.size());
 		geom->indices.resize(geom->vertices.size());
-		for (int i = 0, c = (int)geom->to_old_vertices.size(); i < c; ++i)
+		for (int i = 0, c = (int)to_old_vertices.size(); i < c; ++i)
 		{
-			geom->vertices[i] = vertices[geom->to_old_vertices[i]];
+			geom->vertices[i] = vertices[to_old_vertices[i]];
 			geom->indices[i] = codeIndex(i, i % 3 == 2);
 		}
 	} else {
 		geom->vertices = vertices;
-		geom->to_old_vertices.resize(original_indices.size());
+		to_old_vertices.resize(original_indices.size());
 		for (size_t i = 0; i < original_indices.size(); ++i) {
-			geom->to_old_vertices[i] = decodeIndex(original_indices[i]);
+			to_old_vertices[i] = decodeIndex(original_indices[i]);
 		}
 		geom->indices = original_indices;
 		to_old_indices.resize(original_indices.size());
@@ -2508,8 +2509,7 @@ static void buildGeometryVertexData(
 	}
 
 	geom->to_new_vertices.resize(vertices.size()); // some vertices can be unused, so this isn't necessarily the same size as to_old_vertices.
-	const int* to_old_vertices = geom->to_old_vertices.empty() ? nullptr : &geom->to_old_vertices[0];
-	for (int i = 0, c = (int)geom->to_old_vertices.size(); i < c; ++i)
+	for (int i = 0, c = (int)to_old_vertices.size(); i < c; ++i)
 	{
 		int old = to_old_vertices[i];
 		add(geom->to_new_vertices[old], i);
@@ -2736,7 +2736,7 @@ bool ShapeImpl::postprocess(GeometryImpl* geom, Allocator& allocator)
 	allocator.vec3_tmp2.clear(); // old normals
 	allocator.int_tmp.clear(); // old indices
 	if (!parseDoubleVecData(*vertices_element->first_property, &allocator.vec3_tmp, &allocator.tmp)) return true;
-	if (!parseDoubleVecData(*normals_element->first_property, &allocator.vec3_tmp2, &allocator.tmp)) return true;
+	if (normals_element && !parseDoubleVecData(*normals_element->first_property, &allocator.vec3_tmp2, &allocator.tmp)) return true;
 	if (!parseBinaryArray(*indexes_element->first_property, &allocator.int_tmp)) return true;
 
 	if (allocator.vec3_tmp.size() != allocator.int_tmp.size() || allocator.vec3_tmp2.size() != allocator.int_tmp.size()) return false;
@@ -2745,7 +2745,7 @@ bool ShapeImpl::postprocess(GeometryImpl* geom, Allocator& allocator)
 	normals = geom->normals;
 
 	Vec3* vr = &allocator.vec3_tmp[0];
-	Vec3* nr = &allocator.vec3_tmp2[0];
+	Vec3* nr = normals_element ? &allocator.vec3_tmp2[0] : nullptr;
 	int* ir = &allocator.int_tmp[0];
 	for (int i = 0, c = (int)allocator.int_tmp.size(); i < c; ++i)
 	{
@@ -2755,7 +2755,7 @@ bool ShapeImpl::postprocess(GeometryImpl* geom, Allocator& allocator)
 		while (n)
 		{
 			vertices[n->index] = vertices[n->index] + vr[i];
-			normals[n->index] = normals[n->index] + nr[i];
+			if (normals_element) normals[n->index] = normals[n->index] + nr[i];
 			n = n->next;
 		}
 	}
@@ -3561,7 +3561,7 @@ Object* Object::getParent() const
 		if (connection.from == id)
 		{
 			Object* obj = scene.m_object_map.find(connection.to)->second.object;
-			if (obj && obj->is_node)
+			if (obj && obj->is_node && obj != this && connection.type == Scene::Connection::OBJECT_OBJECT)
 			{
 				assert(parent == nullptr);
 				parent = obj;

From ee83c60e1f1a6b7c0247a9865d53462d9ab9f4aa Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Tue, 3 Oct 2023 12:23:13 +0200
Subject: [PATCH 073/103] Backport
 https://github.com/nem0/OpenFBX/commit/756d9b28aa01915421a107552655efa68b804fcd

---
 Source/ThirdParty/OpenFBX/ofbx.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/Source/ThirdParty/OpenFBX/ofbx.cpp b/Source/ThirdParty/OpenFBX/ofbx.cpp
index be917dd9c..f3896b5a6 100644
--- a/Source/ThirdParty/OpenFBX/ofbx.cpp
+++ b/Source/ThirdParty/OpenFBX/ofbx.cpp
@@ -365,6 +365,7 @@ float DataView::toFloat() const
 
 bool DataView::operator==(const char* rhs) const
 {
+	if (!begin) return false;
 	const char* c = rhs;
 	const char* c2 = (const char*)begin;
 	while (*c && c2 != (const char*)end)
@@ -2473,6 +2474,15 @@ static void triangulate(
 		++in_polygon_idx;
 		if (old_indices[i] < 0)
 		{
+			if (in_polygon_idx <= 2) {
+				// invalid polygon, let's pop it
+				to_old_vertices->pop_back();
+				to_old_indices->pop_back();
+				if (in_polygon_idx == 2) {
+					to_old_vertices->pop_back();
+					to_old_indices->pop_back();
+				}
+			}
 			in_polygon_idx = 0;
 		}
 	}

From 58c6e0cd151ae774cd3d01b7ea0649f7b8f395aa Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Tue, 3 Oct 2023 12:23:36 +0200
Subject: [PATCH 074/103] Backport
 https://github.com/nem0/OpenFBX/commit/dde6cbeb14cab424b9bbbeb6d75c4b84cc22f633

---
 Source/ThirdParty/OpenFBX/ofbx.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Source/ThirdParty/OpenFBX/ofbx.cpp b/Source/ThirdParty/OpenFBX/ofbx.cpp
index f3896b5a6..6b6e3d71b 100644
--- a/Source/ThirdParty/OpenFBX/ofbx.cpp
+++ b/Source/ThirdParty/OpenFBX/ofbx.cpp
@@ -365,7 +365,7 @@ float DataView::toFloat() const
 
 bool DataView::operator==(const char* rhs) const
 {
-	if (!begin) return false;
+	if (!begin) return !rhs[0];
 	const char* c = rhs;
 	const char* c2 = (const char*)begin;
 	while (*c && c2 != (const char*)end)

From 167fead18d36c38ff1bc061201b1da4bf3440ff9 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Tue, 3 Oct 2023 12:24:06 +0200
Subject: [PATCH 075/103] Backport
 https://github.com/nem0/OpenFBX/commit/0f53d0461f72a0b0879cd682097b597b85ae116f

---
 Source/ThirdParty/OpenFBX/ofbx.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/Source/ThirdParty/OpenFBX/ofbx.cpp b/Source/ThirdParty/OpenFBX/ofbx.cpp
index 6b6e3d71b..3723043e9 100644
--- a/Source/ThirdParty/OpenFBX/ofbx.cpp
+++ b/Source/ThirdParty/OpenFBX/ofbx.cpp
@@ -803,6 +803,14 @@ static OptionalError<Property*> readTextProperty(Cursor* cursor, Allocator& allo
 
 			prop->value.end = cursor->current;
 		}
+		else if (cursor->current < cursor->end && (*cursor->current == 'e' || *cursor->current == 'E')) {
+			prop->type = 'D';
+			// 10e-013
+			++cursor->current;
+			if (cursor->current < cursor->end && *cursor->current == '-') ++cursor->current;
+			while (cursor->current < cursor->end && isdigit(*cursor->current)) ++cursor->current;
+			prop->value.end = cursor->current;
+		}
 		return prop;
 	}
 

From 7bb3ddefeb15c89d02e6afc5034374fa96ae73de Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Tue, 3 Oct 2023 07:51:15 -0500
Subject: [PATCH 076/103] Fix AnimatedModel box.

---
 Source/Engine/Level/Actors/AnimatedModel.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/Source/Engine/Level/Actors/AnimatedModel.cpp b/Source/Engine/Level/Actors/AnimatedModel.cpp
index dff527924..a211bb42b 100644
--- a/Source/Engine/Level/Actors/AnimatedModel.cpp
+++ b/Source/Engine/Level/Actors/AnimatedModel.cpp
@@ -537,9 +537,10 @@ void AnimatedModel::UpdateBounds()
         }
 
         // Apply margin based on model dimensions
-        const Vector3 modelBoxSize = SkinnedModel->GetBox().GetSize();
-        const Vector3 center = _box.GetCenter();
-        const Vector3 sizeHalf = Vector3::Max(_box.GetSize() + modelBoxSize * 0.2f, modelBoxSize) * 0.5f;
+        const auto modelBox = SkinnedModel->GetBox(_transform.GetWorld());
+        const Vector3 modelBoxSize = modelBox.GetSize();
+        const Vector3 center = modelBox.GetCenter();
+        const Vector3 sizeHalf = modelBoxSize * 0.5f;
         _box = BoundingBox(center - sizeHalf, center + sizeHalf);
     }
     else

From 60ac0a8196e18434f404cdef0ea809b0110518d6 Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Tue, 3 Oct 2023 08:25:05 -0500
Subject: [PATCH 077/103] Fix box changes from animations.

---
 Source/Engine/Level/Actors/AnimatedModel.cpp | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/Source/Engine/Level/Actors/AnimatedModel.cpp b/Source/Engine/Level/Actors/AnimatedModel.cpp
index a211bb42b..d20e5d7dd 100644
--- a/Source/Engine/Level/Actors/AnimatedModel.cpp
+++ b/Source/Engine/Level/Actors/AnimatedModel.cpp
@@ -526,6 +526,7 @@ void AnimatedModel::UpdateBounds()
             const int32 bonesCount = skeleton.Bones.Count();
 #define GET_NODE_POS(i) _transform.LocalToWorld(GraphInstance.NodesPose[skeleton.Bones[i].NodeIndex].GetTranslation())
             BoundingBox box(GET_NODE_POS(0));
+            box.Merge(SkinnedModel->GetBox(_transform.GetWorld()));
             for (int32 boneIndex = 1; boneIndex < bonesCount; boneIndex++)
                 box.Merge(GET_NODE_POS(boneIndex));
             _box = box;
@@ -533,15 +534,13 @@ void AnimatedModel::UpdateBounds()
         }
         else
         {
-            _box = SkinnedModel->GetBox(_transform.GetWorld());
+            // No animation applied
+            const auto modelBox = SkinnedModel->GetBox(_transform.GetWorld());
+            const Vector3 modelBoxSize = modelBox.GetSize();
+            const Vector3 center = modelBox.GetCenter();
+            const Vector3 sizeHalf = modelBoxSize * 0.5f;
+            _box = BoundingBox(center - sizeHalf, center + sizeHalf);
         }
-
-        // Apply margin based on model dimensions
-        const auto modelBox = SkinnedModel->GetBox(_transform.GetWorld());
-        const Vector3 modelBoxSize = modelBox.GetSize();
-        const Vector3 center = modelBox.GetCenter();
-        const Vector3 sizeHalf = modelBoxSize * 0.5f;
-        _box = BoundingBox(center - sizeHalf, center + sizeHalf);
     }
     else
     {

From d6861696a5e939607afc59af003cfedde1b1e264 Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Tue, 3 Oct 2023 09:17:52 -0500
Subject: [PATCH 078/103] Simplify.

---
 Source/Engine/Level/Actors/AnimatedModel.cpp | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/Source/Engine/Level/Actors/AnimatedModel.cpp b/Source/Engine/Level/Actors/AnimatedModel.cpp
index d20e5d7dd..f9440dac9 100644
--- a/Source/Engine/Level/Actors/AnimatedModel.cpp
+++ b/Source/Engine/Level/Actors/AnimatedModel.cpp
@@ -534,12 +534,8 @@ void AnimatedModel::UpdateBounds()
         }
         else
         {
-            // No animation applied
-            const auto modelBox = SkinnedModel->GetBox(_transform.GetWorld());
-            const Vector3 modelBoxSize = modelBox.GetSize();
-            const Vector3 center = modelBox.GetCenter();
-            const Vector3 sizeHalf = modelBoxSize * 0.5f;
-            _box = BoundingBox(center - sizeHalf, center + sizeHalf);
+            // No animation asset applied
+            _box = SkinnedModel->GetBox(_transform.GetWorld());
         }
     }
     else

From 9fbc51a22a2d112f40695ad0a036770f8600b076 Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Tue, 3 Oct 2023 09:21:27 -0500
Subject: [PATCH 079/103] Add back in fixed margin code.

---
 Source/Engine/Level/Actors/AnimatedModel.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/Source/Engine/Level/Actors/AnimatedModel.cpp b/Source/Engine/Level/Actors/AnimatedModel.cpp
index f9440dac9..66931cc7d 100644
--- a/Source/Engine/Level/Actors/AnimatedModel.cpp
+++ b/Source/Engine/Level/Actors/AnimatedModel.cpp
@@ -537,6 +537,12 @@ void AnimatedModel::UpdateBounds()
             // No animation asset applied
             _box = SkinnedModel->GetBox(_transform.GetWorld());
         }
+
+        // Apply margin based on model dimensions
+        const Vector3 modelBoxSize = SkinnedModel->GetBox(_transform.GetWorld()).GetSize();
+        const Vector3 center = _box.GetCenter();
+        const Vector3 sizeHalf = Vector3::Max(_box.GetSize() + modelBoxSize * 0.2f, modelBoxSize) * 0.5f;
+        _box = BoundingBox(center - sizeHalf, center + sizeHalf);
     }
     else
     {

From 36b1dc145293492f8b3d92061484003f1e7bc14f Mon Sep 17 00:00:00 2001
From: Ari Vuollet <ari.vuollet@kapsi.fi>
Date: Tue, 3 Oct 2023 17:37:15 +0300
Subject: [PATCH 080/103] Fix particle effects not working properly at high
 framerate

---
 Source/Engine/Particles/Particles.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Source/Engine/Particles/Particles.cpp b/Source/Engine/Particles/Particles.cpp
index 52234fd7a..5850b6736 100644
--- a/Source/Engine/Particles/Particles.cpp
+++ b/Source/Engine/Particles/Particles.cpp
@@ -1283,8 +1283,8 @@ void ParticlesSystem::Job(int32 index)
         updateBounds = true;
     }
     // TODO: if using fixed timestep quantize the dt and accumulate remaining part for the next update?
-    if (dt <= 1.0f / 240.0f)
-        return;
+    //if (dt <= 1.0f / 240.0f)
+    //    return;
     dt *= effect->SimulationSpeed;
     instance.Time += dt;
     const float fps = particleSystem->FramesPerSecond;

From b948152a41c64dd0e0c238b0c91993f9eef5621f Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Tue, 3 Oct 2023 09:40:46 -0500
Subject: [PATCH 081/103] Simplify

---
 Source/Engine/Level/Actors/AnimatedModel.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/Source/Engine/Level/Actors/AnimatedModel.cpp b/Source/Engine/Level/Actors/AnimatedModel.cpp
index 66931cc7d..b5ccc291b 100644
--- a/Source/Engine/Level/Actors/AnimatedModel.cpp
+++ b/Source/Engine/Level/Actors/AnimatedModel.cpp
@@ -519,6 +519,7 @@ void AnimatedModel::UpdateBounds()
     }
     else if (SkinnedModel && SkinnedModel->IsLoaded())
     {
+        const auto modelBox = SkinnedModel->GetBox(_transform.GetWorld());
         if (GraphInstance.NodesPose.Count() != 0)
         {
             // Per-bone bounds estimated from positions
@@ -526,7 +527,7 @@ void AnimatedModel::UpdateBounds()
             const int32 bonesCount = skeleton.Bones.Count();
 #define GET_NODE_POS(i) _transform.LocalToWorld(GraphInstance.NodesPose[skeleton.Bones[i].NodeIndex].GetTranslation())
             BoundingBox box(GET_NODE_POS(0));
-            box.Merge(SkinnedModel->GetBox(_transform.GetWorld()));
+            box.Merge(modelBox);
             for (int32 boneIndex = 1; boneIndex < bonesCount; boneIndex++)
                 box.Merge(GET_NODE_POS(boneIndex));
             _box = box;
@@ -535,11 +536,11 @@ void AnimatedModel::UpdateBounds()
         else
         {
             // No animation asset applied
-            _box = SkinnedModel->GetBox(_transform.GetWorld());
+            _box = modelBox;
         }
 
         // Apply margin based on model dimensions
-        const Vector3 modelBoxSize = SkinnedModel->GetBox(_transform.GetWorld()).GetSize();
+        const Vector3 modelBoxSize = modelBox.GetSize();
         const Vector3 center = _box.GetCenter();
         const Vector3 sizeHalf = Vector3::Max(_box.GetSize() + modelBoxSize * 0.2f, modelBoxSize) * 0.5f;
         _box = BoundingBox(center - sizeHalf, center + sizeHalf);

From 4e83a0a757b66563bba7959caf829ebe0bc88d75 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Tue, 3 Oct 2023 22:20:44 +0200
Subject: [PATCH 082/103] Fix potential exception in drag and drop handling

---
 Source/Editor/Content/GUI/ContentView.DragDrop.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Source/Editor/Content/GUI/ContentView.DragDrop.cs b/Source/Editor/Content/GUI/ContentView.DragDrop.cs
index 348e2b443..ffce81e2d 100644
--- a/Source/Editor/Content/GUI/ContentView.DragDrop.cs
+++ b/Source/Editor/Content/GUI/ContentView.DragDrop.cs
@@ -68,7 +68,7 @@ namespace FlaxEditor.Content.GUI
                 _validDragOver = true;
                 result = DragDropEffect.Copy;
             }
-            else if (_dragActors.HasValidDrag)
+            else if (_dragActors != null && _dragActors.HasValidDrag)
             {
                 _validDragOver = true;
                 result = DragDropEffect.Move;
@@ -94,7 +94,7 @@ namespace FlaxEditor.Content.GUI
                 result = DragDropEffect.Copy;
             }
             // Check if drop actor(s)
-            else if (_dragActors.HasValidDrag)
+            else if (_dragActors != null && _dragActors.HasValidDrag)
             {
                 // Import actors
                 var currentFolder = Editor.Instance.Windows.ContentWin.CurrentViewFolder;

From 68a713fb951aa121a01bd6966407e762cecbdf78 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Tue, 3 Oct 2023 22:30:58 +0200
Subject: [PATCH 083/103] Fix model importer to use precomputed Offset Matrix
 for skeletal model bones

#1525
---
 .../Tools/ModelTool/ModelTool.OpenFBX.cpp     | 60 ++-----------------
 Source/Engine/Tools/ModelTool/ModelTool.cpp   | 24 ++++----
 Source/ThirdParty/OpenFBX/ofbx.cpp            |  2 +-
 3 files changed, 21 insertions(+), 65 deletions(-)

diff --git a/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp b/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
index 215eadaba..39f5bb974 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
@@ -366,9 +366,7 @@ void ProcessNodes(OpenFbxImporterData& data, const ofbx::Object* aNode, int32 pa
     {
         node.LodIndex = data.Nodes[parentIndex].LodIndex;
         if (node.LodIndex == 0)
-        {
             node.LodIndex = ModelTool::DetectLodIndex(node.Name);
-        }
         ASSERT(Math::IsInRange(node.LodIndex, 0, MODEL_MAX_LODS - 1));
     }
 
@@ -416,8 +414,9 @@ Matrix GetOffsetMatrix(OpenFbxImporterData& data, const ofbx::Mesh* mesh, const
             }
         }
     }
+	//return Matrix::Identity;
     return ToMatrix(node->getGlobalTransform());
-#elif 1
+#else
     Matrix t = Matrix::Identity;
     const int32 boneIdx = data.FindBone(node);
     int32 idx = data.Bones[boneIdx].NodeIndex;
@@ -427,17 +426,6 @@ Matrix GetOffsetMatrix(OpenFbxImporterData& data, const ofbx::Mesh* mesh, const
         idx = data.Nodes[idx].ParentIndex;
     } while (idx != -1);
     return t;
-#else
-	auto* skin = mesh->getGeometry()->getSkin();
-	for (int i = 0, c = skin->getClusterCount(); i < c; i++)
-	{
-		const ofbx::Cluster* cluster = skin->getCluster(i);
-		if (cluster->getLink() == node)
-		{
-			return ToMatrix(cluster->getTransformLinkMatrix());
-		}
-	}
-	return Matrix::Identity;
 #endif
 }
 
@@ -455,17 +443,14 @@ bool ImportBones(OpenFbxImporterData& data, String& errorMsg)
         const auto aMesh = data.Scene->getMesh(i);
         const auto aGeometry = aMesh->getGeometry();
         const ofbx::Skin* skin = aGeometry->getSkin();
-
         if (skin == nullptr || IsMeshInvalid(aMesh))
             continue;
 
-        for (int clusterIndex = 0, c = skin->getClusterCount(); clusterIndex < c; clusterIndex++)
+        for (int clusterIndex = 0, clusterCount = skin->getClusterCount(); clusterIndex < clusterCount; clusterIndex++)
         {
             const ofbx::Cluster* cluster = skin->getCluster(clusterIndex);
-
             if (cluster->getIndicesCount() == 0)
                 continue;
-
             const auto link = cluster->getLink();
             ASSERT(link != nullptr);
 
@@ -487,7 +472,7 @@ bool ImportBones(OpenFbxImporterData& data, String& errorMsg)
 
                 // Add bone
                 boneIndex = data.Bones.Count();
-                data.Bones.EnsureCapacity(Math::Max(128, boneIndex + 16));
+                data.Bones.EnsureCapacity(256);
                 data.Bones.Resize(boneIndex + 1);
                 auto& bone = data.Bones[boneIndex];
 
@@ -495,7 +480,7 @@ bool ImportBones(OpenFbxImporterData& data, String& errorMsg)
                 bone.NodeIndex = nodeIndex;
                 bone.ParentBoneIndex = -1;
                 bone.FbxObj = link;
-                bone.OffsetMatrix = GetOffsetMatrix(data, aMesh, link);
+                bone.OffsetMatrix = GetOffsetMatrix(data, aMesh, link) * Matrix::Scaling(data.GlobalSettings.UnitScaleFactor);
                 bone.OffsetMatrix.Invert();
 
                 // Mirror offset matrices (RH to LH)
@@ -547,9 +532,7 @@ bool ProcessMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofb
     // Vertex positions
     mesh.Positions.Resize(vertexCount, false);
     for (int i = 0; i < vertexCount; i++)
-    {
         mesh.Positions.Get()[i] = ToFloat3(vertices[i + firstVertexOffset]);
-    }
 
     // Indices (dummy index buffer)
     if (vertexCount % 3 != 0)
@@ -559,24 +542,18 @@ bool ProcessMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofb
     }
     mesh.Indices.Resize(vertexCount, false);
     for (int i = 0; i < vertexCount; i++)
-    {
         mesh.Indices.Get()[i] = i;
-    }
 
     // Texture coordinates
     if (uvs)
     {
         mesh.UVs.Resize(vertexCount, false);
         for (int i = 0; i < vertexCount; i++)
-        {
             mesh.UVs.Get()[i] = ToFloat2(uvs[i + firstVertexOffset]);
-        }
         if (data.ConvertRH)
         {
             for (int32 v = 0; v < vertexCount; v++)
-            {
                 mesh.UVs[v].Y = 1.0f - mesh.UVs[v].Y;
-            }
         }
     }
 
@@ -593,16 +570,12 @@ bool ProcessMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofb
     {
         mesh.Normals.Resize(vertexCount, false);
         for (int i = 0; i < vertexCount; i++)
-        {
             mesh.Normals.Get()[i] = ToFloat3(normals[i + firstVertexOffset]);
-        }
         if (data.ConvertRH)
         {
             // Mirror normals along the Z axis
             for (int32 i = 0; i < vertexCount; i++)
-            {
                 mesh.Normals.Get()[i].Z *= -1.0f;
-            }
         }
     }
 
@@ -615,16 +588,12 @@ bool ProcessMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofb
     {
         mesh.Tangents.Resize(vertexCount, false);
         for (int i = 0; i < vertexCount; i++)
-        {
             mesh.Tangents.Get()[i] = ToFloat3(tangents[i + firstVertexOffset]);
-        }
         if (data.ConvertRH)
         {
             // Mirror tangents along the Z axis
             for (int32 i = 0; i < vertexCount; i++)
-            {
                 mesh.Tangents.Get()[i].Z *= -1.0f;
-            }
         }
     }
 
@@ -670,15 +639,11 @@ bool ProcessMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofb
         {
             mesh.LightmapUVs.Resize(vertexCount, false);
             for (int i = 0; i < vertexCount; i++)
-            {
                 mesh.LightmapUVs.Get()[i] = ToFloat2(lightmapUVs[i + firstVertexOffset]);
-            }
             if (data.ConvertRH)
             {
                 for (int32 v = 0; v < vertexCount; v++)
-                {
                     mesh.LightmapUVs[v].Y = 1.0f - mesh.LightmapUVs[v].Y;
-                }
             }
         }
         else
@@ -692,9 +657,7 @@ bool ProcessMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofb
     {
         mesh.Colors.Resize(vertexCount, false);
         for (int i = 0; i < vertexCount; i++)
-        {
             mesh.Colors.Get()[i] = ToColor(colors[i + firstVertexOffset]);
-        }
     }
 
     // Blend Indices and Blend Weights
@@ -705,13 +668,11 @@ bool ProcessMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofb
         mesh.BlendIndices.SetAll(Int4::Zero);
         mesh.BlendWeights.SetAll(Float4::Zero);
 
-        for (int clusterIndex = 0, c = skin->getClusterCount(); clusterIndex < c; clusterIndex++)
+        for (int clusterIndex = 0, clusterCount = skin->getClusterCount(); clusterIndex < clusterCount; clusterIndex++)
         {
             const ofbx::Cluster* cluster = skin->getCluster(clusterIndex);
-
             if (cluster->getIndicesCount() == 0)
                 continue;
-
             const auto link = cluster->getLink();
             ASSERT(link != nullptr);
 
@@ -815,15 +776,11 @@ bool ProcessMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofb
     {
         // Mirror positions along the Z axis
         for (int32 i = 0; i < vertexCount; i++)
-        {
             mesh.Positions[i].Z *= -1.0f;
-        }
         for (auto& blendShapeData : mesh.BlendShapes)
         {
             for (auto& v : blendShapeData.Vertices)
-            {
                 v.PositionDelta.Z *= -1.0f;
-            }
         }
     }
 
@@ -834,9 +791,7 @@ bool ProcessMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofb
     {
         // Invert the order
         for (int32 i = 0; i < mesh.Indices.Count(); i += 3)
-        {
             Swap(mesh.Indices[i], mesh.Indices[i + 2]);
-        }
     }
 
     if ((data.Options.CalculateTangents || !tangents) && mesh.UVs.HasItems())
@@ -888,9 +843,7 @@ bool ImportMesh(ImportedModelData& result, OpenFbxImporterData& data, const ofbx
         {
             node.LodIndex = data.Nodes[0].LodIndex;
             if (node.LodIndex == 0)
-            {
                 node.LodIndex = ModelTool::DetectLodIndex(node.Name);
-            }
             ASSERT(Math::IsInRange(node.LodIndex, 0, MODEL_MAX_LODS - 1));
         }
         node.LocalTransform = Transform::Identity;
@@ -999,7 +952,6 @@ void ImportCurve(const ofbx::AnimationCurveNode* curveNode, LinearCurve<T>& curv
 {
     if (curveNode == nullptr)
         return;
-
     const auto keyframes = curve.Resize(info.FramesCount);
     const auto bone = curveNode->getBone();
     Frame localFrame;
diff --git a/Source/Engine/Tools/ModelTool/ModelTool.cpp b/Source/Engine/Tools/ModelTool/ModelTool.cpp
index 9c9fb00a4..2f3b68f95 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.cpp
@@ -1320,14 +1320,17 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
                 }
             }
 
-            // Apply import transform on root bones
-            for (int32 i = 0; i < data.Skeleton.Bones.Count(); i++)
+            // Apply import transform on bones
+            Matrix importMatrixInv;
+            importTransform.GetWorld(importMatrixInv);
+            importMatrixInv.Invert();
+            for (SkeletonBone& bone : data.Skeleton.Bones)
             {
-                auto& bone = data.Skeleton.Bones.Get()[i];
                 if (bone.ParentIndex == -1)
                 {
                     bone.LocalTransform = importTransform.LocalToWorld(bone.LocalTransform);
                 }
+                bone.OffsetMatrix = importMatrixInv * bone.OffsetMatrix;
             }
         }
 
@@ -1363,20 +1366,21 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
         // use SkeletonMapping<SkeletonBone> to map bones?
 
         // Calculate offset matrix (inverse bind pose transform) for every bone manually
-        {
-            for (int32 i = 0; i < data.Skeleton.Bones.Count(); i++)
+        /*{
+            for (SkeletonBone& bone : data.Skeleton.Bones)
             {
                 Matrix t = Matrix::Identity;
-                int32 idx = data.Skeleton.Bones[i].NodeIndex;
+                int32 idx = bone.NodeIndex;
                 do
                 {
-                    t *= data.Skeleton.Nodes[idx].LocalTransform.GetWorld();
-                    idx = data.Skeleton.Nodes[idx].ParentIndex;
+                    const SkeletonNode& node = data.Skeleton.Nodes[idx];
+                    t *= node.LocalTransform.GetWorld();
+                    idx = node.ParentIndex;
                 } while (idx != -1);
                 t.Invert();
-                data.Skeleton.Bones[i].OffsetMatrix = t;
+                bone.OffsetMatrix = t;
             }
-        }
+        }*/
 
 #if USE_SKELETON_NODES_SORTING
         // Sort skeleton nodes and bones hierarchy (parents first)
diff --git a/Source/ThirdParty/OpenFBX/ofbx.cpp b/Source/ThirdParty/OpenFBX/ofbx.cpp
index 3723043e9..a15c174d7 100644
--- a/Source/ThirdParty/OpenFBX/ofbx.cpp
+++ b/Source/ThirdParty/OpenFBX/ofbx.cpp
@@ -3538,7 +3538,7 @@ Object* Object::resolveObjectLink(int idx) const
 		if (connection.to == id && connection.from != 0)
 		{
 			Object* obj = scene.m_object_map.find(connection.from)->second.object;
-			if (obj)
+			if (obj && obj->is_node && obj != this && connection.type == Scene::Connection::OBJECT_OBJECT)
 			{
 				if (idx == 0) return obj;
 				--idx;

From b5d927baa542f2320b0d23b81708301159a21285 Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Tue, 3 Oct 2023 16:22:43 -0500
Subject: [PATCH 084/103] Force windows window to be correct size when
 restoring window on maximize from minimize.

---
 .../Engine/Platform/Windows/WindowsWindow.cpp | 23 +++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/Source/Engine/Platform/Windows/WindowsWindow.cpp b/Source/Engine/Platform/Windows/WindowsWindow.cpp
index d712102fa..906816bf0 100644
--- a/Source/Engine/Platform/Windows/WindowsWindow.cpp
+++ b/Source/Engine/Platform/Windows/WindowsWindow.cpp
@@ -711,8 +711,27 @@ void WindowsWindow::CheckForWindowResize()
     // Cache client size
     RECT rect;
     GetClientRect(_handle, &rect);
-    const int32 width = Math::Max(rect.right - rect.left, 0L);
-    const int32 height = Math::Max(rect.bottom - rect.top, 0L);
+    int32 width = Math::Max(rect.right - rect.left, 0L);
+    int32 height = Math::Max(rect.bottom - rect.top, 0L);
+
+    // Check for windows maximized size and see if it needs to adjust position if needed
+    if (_maximized)
+    {
+        // Pick the current monitor data for sizing
+        const HMONITOR monitor = MonitorFromWindow(_handle, MONITOR_DEFAULTTONEAREST);
+        MONITORINFO monitorInfo;
+        monitorInfo.cbSize = sizeof(MONITORINFO);
+        GetMonitorInfoW(monitor, &monitorInfo);
+        
+        auto cwidth = monitorInfo.rcWork.right - monitorInfo.rcWork.left;
+        auto cheight = monitorInfo.rcWork.bottom - monitorInfo.rcWork.top;
+        if (width > cwidth && height > cheight)
+        {
+            width = cwidth;
+            height = cheight;
+            SetWindowPos(_handle, HWND_TOP, monitorInfo.rcWork.left, monitorInfo.rcWork.top, width, height, SWP_FRAMECHANGED | SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
+        }
+    }
     _clientSize = Float2(static_cast<float>(width), static_cast<float>(height));
 
     // Check if window size has been changed

From c6bd989744ea7c0082126bb43fe69176fa8e869b Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Tue, 3 Oct 2023 22:47:13 -0500
Subject: [PATCH 085/103] Add Game Settings open button to menu.

---
 Source/Editor/Modules/UIModule.cs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/Source/Editor/Modules/UIModule.cs b/Source/Editor/Modules/UIModule.cs
index 299865dea..c882efb87 100644
--- a/Source/Editor/Modules/UIModule.cs
+++ b/Source/Editor/Modules/UIModule.cs
@@ -553,6 +553,13 @@ namespace FlaxEditor.Modules
             cm.AddSeparator();
             _menuEditSelectAll = cm.AddButton("Select all", inputOptions.SelectAll, Editor.SceneEditing.SelectAllScenes);
             _menuEditFind = cm.AddButton("Find", inputOptions.Search, Editor.Windows.SceneWin.Search);
+            cm.AddSeparator();
+            cm.AddButton("Game Settings", () =>
+            {
+                var item = Editor.ContentDatabase.Find(GameSettings.GameSettingsAssetPath);
+                if(item != null)
+                    Editor.ContentEditing.Open(item);
+            });
 
             // Scene
             MenuScene = MainMenu.AddButton("Scene");

From b3b6251c107ee210ef7cfa7d8a44d3298f02acca Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Wed, 4 Oct 2023 09:47:48 +0200
Subject: [PATCH 086/103] Add `GlobalInfo` parsing to OpenFBX

#1525
---
 Source/ThirdParty/OpenFBX/ofbx.cpp | 119 ++++++++++++++++++++---------
 Source/ThirdParty/OpenFBX/ofbx.h   |   9 +++
 2 files changed, 90 insertions(+), 38 deletions(-)

diff --git a/Source/ThirdParty/OpenFBX/ofbx.cpp b/Source/ThirdParty/OpenFBX/ofbx.cpp
index a15c174d7..e3cbd6230 100644
--- a/Source/ThirdParty/OpenFBX/ofbx.cpp
+++ b/Source/ThirdParty/OpenFBX/ofbx.cpp
@@ -1567,6 +1567,7 @@ struct Scene : IScene
 	int getAnimationStackCount() const override { return (int)m_animation_stacks.size(); }
 	int getMeshCount() const override { return (int)m_meshes.size(); }
 	float getSceneFrameRate() const override { return m_scene_frame_rate; }
+    const GlobalInfo* getGlobalInfo() const override { return &m_info; }
 	const GlobalSettings* getGlobalSettings() const override { return &m_settings; }
 
 	const Object* const* getAllObjects() const override { return m_all_objects.empty() ? nullptr : &m_all_objects[0]; }
@@ -1629,6 +1630,7 @@ struct Scene : IScene
 	Element* m_root_element = nullptr;
 	Root* m_root = nullptr;
 	float m_scene_frame_rate = -1;
+	GlobalInfo m_info;
 	GlobalSettings m_settings;
 	std::unordered_map<u64, ObjectPair> m_object_map;
 	std::vector<Object*> m_all_objects;
@@ -2933,6 +2935,66 @@ static float getFramerateFromTimeMode(FrameRate time_mode, float custom_frame_ra
 }
 
 
+#define get_property(name, field, type, getter) if (node->first_property->value == name) \
+    { \
+        IElementProperty* prop = node->getProperty(4); \
+        if (prop) \
+        { \
+	        DataView value = prop->getValue(); \
+	        field = (type)value.getter(); \
+        } \
+    }
+#define get_time_property(name, field, type, getter) if (node->first_property->value == name) \
+    { \
+        IElementProperty* prop = node->getProperty(4); \
+        if (prop) \
+        { \
+	        DataView value = prop->getValue(); \
+	        field = fbxTimeToSeconds((type)value.getter()); \
+        } \
+    }
+#define get_text_property(name, field) if (node->first_property->value == name) \
+    { \
+        IElementProperty* prop = node->getProperty(4); \
+        if (prop) \
+        { \
+	        DataView value = prop->getValue(); \
+            value.toString(field); \
+        } \
+    }
+
+
+static void parseGlobalInfo(const Element& root, Scene* scene)
+{
+    for (Element* header = root.child; header; header = header->sibling)
+	{
+		if (header->id != "FBXHeaderExtension")
+		    continue;
+	    for (Element* info = header->child; info; info = info->sibling)
+	    {
+		    if (info->id != "SceneInfo")
+		        continue;
+			for (Element* props70 = info->child; props70; props70 = props70->sibling)
+			{
+				if (props70->id != "Properties70")
+				    continue;
+				for (Element* node = props70->child; node; node = node->sibling)
+				{
+					if (!node->first_property)
+						continue;
+					get_text_property("Original|ApplicationVendor", scene->m_info.AppVendor, UpVector, toInt);
+					get_text_property("Original|ApplicationName", scene->m_info.AppName, UpVector, toInt);
+					get_text_property("Original|ApplicationVersion", scene->m_info.AppVersion, UpVector, toInt);
+				}
+				break;
+			}
+			break;
+	    }
+		break;
+    }
+}
+
+
 static void parseGlobalSettings(const Element& root, Scene* scene)
 {
 	for (Element* settings = root.child; settings; settings = settings->sibling)
@@ -2947,44 +3009,20 @@ static void parseGlobalSettings(const Element& root, Scene* scene)
 					{
 						if (!node->first_property)
 							continue;
-
-						#define get_property(name, field, type, getter) if(node->first_property->value == name) \
-						{ \
-							IElementProperty* prop = node->getProperty(4); \
-							if (prop) \
-							{ \
-								DataView value = prop->getValue(); \
-								scene->m_settings.field = (type)value.getter(); \
-							} \
-						}
-
-						#define get_time_property(name, field, type, getter) if(node->first_property->value == name) \
-						{ \
-							IElementProperty* prop = node->getProperty(4); \
-							if (prop) \
-							{ \
-								DataView value = prop->getValue(); \
-								scene->m_settings.field = fbxTimeToSeconds((type)value.getter()); \
-							} \
-						}
-
-						get_property("UpAxis", UpAxis, UpVector, toInt);
-						get_property("UpAxisSign", UpAxisSign, int, toInt);
-						get_property("FrontAxis", FrontAxis, FrontVector, toInt);
-						get_property("FrontAxisSign", FrontAxisSign, int, toInt);
-						get_property("CoordAxis", CoordAxis, CoordSystem, toInt);
-						get_property("CoordAxisSign", CoordAxisSign, int, toInt);
-						get_property("OriginalUpAxis", OriginalUpAxis, int, toInt);
-						get_property("OriginalUpAxisSign", OriginalUpAxisSign, int, toInt);
-						get_property("UnitScaleFactor", UnitScaleFactor, float, toDouble);
-						get_property("OriginalUnitScaleFactor", OriginalUnitScaleFactor, float, toDouble);
-						get_time_property("TimeSpanStart", TimeSpanStart, u64, toU64);
-						get_time_property("TimeSpanStop", TimeSpanStop, u64, toU64);
-						get_property("TimeMode", TimeMode, FrameRate, toInt);
-						get_property("CustomFrameRate", CustomFrameRate, float, toDouble);
-
-						#undef get_property
-
+						get_property("UpAxis", scene->m_settings.UpAxis, UpVector, toInt);
+						get_property("UpAxisSign", scene->m_settings.UpAxisSign, int, toInt);
+						get_property("FrontAxis", scene->m_settings.FrontAxis, FrontVector, toInt);
+						get_property("FrontAxisSign", scene->m_settings.FrontAxisSign, int, toInt);
+						get_property("CoordAxis", scene->m_settings.CoordAxis, CoordSystem, toInt);
+						get_property("CoordAxisSign", scene->m_settings.CoordAxisSign, int, toInt);
+						get_property("OriginalUpAxis", scene->m_settings.OriginalUpAxis, int, toInt);
+						get_property("OriginalUpAxisSign", scene->m_settings.OriginalUpAxisSign, int, toInt);
+						get_property("UnitScaleFactor", scene->m_settings.UnitScaleFactor, float, toDouble);
+						get_property("OriginalUnitScaleFactor", scene->m_settings.OriginalUnitScaleFactor, float, toDouble);
+						get_time_property("TimeSpanStart", scene->m_settings.TimeSpanStart, u64, toU64);
+						get_time_property("TimeSpanStop", scene->m_settings.TimeSpanStop, u64, toU64);
+						get_property("TimeMode", scene->m_settings.TimeMode, FrameRate, toInt);
+						get_property("CustomFrameRate", scene->m_settings.CustomFrameRate, float, toDouble);
 						scene->m_scene_frame_rate = getFramerateFromTimeMode(scene->m_settings.TimeMode, scene->m_settings.CustomFrameRate);
 					}
 					break;
@@ -2996,6 +3034,10 @@ static void parseGlobalSettings(const Element& root, Scene* scene)
 }
 
 
+#undef get_property
+#undef get_time_property
+
+
 struct ParseGeometryJob {
 	const Element* element;
 	bool triangulate;
@@ -3624,6 +3666,7 @@ IScene* load(const u8* data, int size, u64 flags, JobProcessor job_processor, vo
 	if (!parseConnections(*root.getValue(), scene.get())) return nullptr;
 	if (!parseTakes(scene.get())) return nullptr;
 	if (!parseObjects(*root.getValue(), scene.get(), flags, scene->m_allocator, job_processor, job_user_ptr)) return nullptr;
+	parseGlobalInfo(*root.getValue(), scene.get());
 	parseGlobalSettings(*root.getValue(), scene.get());
 
 	return scene.release();
diff --git a/Source/ThirdParty/OpenFBX/ofbx.h b/Source/ThirdParty/OpenFBX/ofbx.h
index 7066659e3..09ca328bb 100644
--- a/Source/ThirdParty/OpenFBX/ofbx.h
+++ b/Source/ThirdParty/OpenFBX/ofbx.h
@@ -511,6 +511,14 @@ struct GlobalSettings
 };
 
 
+struct GlobalInfo
+{
+	char AppVendor[128];
+	char AppName[128];
+	char AppVersion[128];
+};
+
+
 struct IScene
 {
 	virtual void destroy() = 0;
@@ -519,6 +527,7 @@ struct IScene
 	virtual const TakeInfo* getTakeInfo(const char* name) const = 0;
 	virtual int getMeshCount() const = 0;
 	virtual float getSceneFrameRate() const = 0;
+	virtual const GlobalInfo* getGlobalInfo() const = 0;
 	virtual const GlobalSettings* getGlobalSettings() const = 0;
 	virtual const Mesh* getMesh(int index) const = 0;
 	virtual int getAnimationStackCount() const = 0;

From 52b9a995add6ea7b475c1247b4469b4a97978ec5 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Wed, 4 Oct 2023 10:01:17 +0200
Subject: [PATCH 087/103] Fix bone Offset Matrix from fbx when using root
 RotationMatrix

#1525
---
 .../Tools/ModelTool/ModelTool.OpenFBX.cpp     | 42 +++++++++++++++++--
 1 file changed, 38 insertions(+), 4 deletions(-)

diff --git a/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp b/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
index 39f5bb974..f1e89d6bc 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.OpenFBX.cpp
@@ -12,6 +12,8 @@
 #include "Engine/Tools/TextureTool/TextureTool.h"
 #include "Engine/Platform/File.h"
 
+#define OPEN_FBX_CONVERT_SPACE 1
+
 // Import OpenFBX library
 // Source: https://github.com/nem0/OpenFBX
 #include <ThirdParty/OpenFBX/ofbx.h>
@@ -85,12 +87,16 @@ struct OpenFbxImporterData
     const ModelTool::Options& Options;
 
     ofbx::GlobalSettings GlobalSettings;
+#if OPEN_FBX_CONVERT_SPACE
+    Quaternion RootConvertRotation = Quaternion::Identity;
     Float3 Up;
     Float3 Front;
     Float3 Right;
     bool ConvertRH;
+#else
+    static constexpr bool ConvertRH = false;
+#endif
     float FrameRate;
-    Quaternion RootConvertRotation = Quaternion::Identity;
 
     Array<FbxNode> Nodes;
     Array<FbxBone> Bones;
@@ -103,7 +109,9 @@ struct OpenFbxImporterData
         , Path(path)
         , Options(options)
         , GlobalSettings(*scene->getGlobalSettings())
+#if OPEN_FBX_CONVERT_SPACE
         , ConvertRH(GlobalSettings.CoordAxis == ofbx::CoordSystem_RightHanded)
+#endif
         , Nodes(static_cast<int32>(scene->getMeshCount() * 4.0f))
     {
         float frameRate = scene->getSceneFrameRate();
@@ -114,6 +122,7 @@ struct OpenFbxImporterData
                 frameRate = 30.0f;
         }
         FrameRate = frameRate;
+#if OPEN_FBX_CONVERT_SPACE
         const float coordAxisSign = GlobalSettings.CoordAxis == ofbx::CoordSystem_LeftHanded ? -1.0f : +1.0f;
         switch (GlobalSettings.UpAxis)
         {
@@ -170,6 +179,7 @@ struct OpenFbxImporterData
             break;
         default: ;
         }
+#endif
     }
 
     bool ImportMaterialTexture(ImportedModelData& result, const ofbx::Material* mat, ofbx::Texture::TextureType textureType, int32& textureIndex, TextureEntry::TypeHint type) const
@@ -371,6 +381,7 @@ void ProcessNodes(OpenFbxImporterData& data, const ofbx::Object* aNode, int32 pa
     }
 
     auto transform = ToMatrix(aNode->evalLocal(aNode->getLocalTranslation(), aNode->getLocalRotation()));
+#if OPEN_FBX_CONVERT_SPACE
     if (data.ConvertRH)
     {
         // Mirror all base vectors at the local Z axis
@@ -386,6 +397,7 @@ void ProcessNodes(OpenFbxImporterData& data, const ofbx::Object* aNode, int32 pa
         transform.M33 = -transform.M33;
         transform.M43 = -transform.M43;
     }
+#endif
     transform.Decompose(node.LocalTransform);
     data.Nodes.Add(node);
 
@@ -494,6 +506,15 @@ bool ImportBones(OpenFbxImporterData& data, String& errorMsg)
                     m.M32 = -m.M32;
                     m.M34 = -m.M34;
                 }
+
+                // Convert bone matrix if scene uses root transform
+                if (!data.RootConvertRotation.IsIdentity())
+                {
+                    Matrix m;
+                    Matrix::RotationQuaternion(data.RootConvertRotation, m);
+                    m.Invert();
+                    bone.OffsetMatrix = m * bone.OffsetMatrix;
+                }
             }
         }
     }
@@ -1095,6 +1116,14 @@ bool ModelTool::ImportDataOpenFBX(const char* path, ImportedModelData& data, Opt
         }
         fileData.Resize(0);
 
+        // Tweak scene if exported by Blender
+        auto& globalInfo = *scene->getGlobalInfo();
+        if (StringAnsiView(globalInfo.AppName).StartsWith(StringAnsiView("Blender"), StringSearchCase::IgnoreCase))
+        {
+            auto ptr = const_cast<ofbx::GlobalSettings*>(scene->getGlobalSettings());
+            ptr->UpAxis = (ofbx::UpVector)((int32)ptr->UpAxis + 1);
+        }
+
         // Process imported scene
         context = New<OpenFbxImporterData>(path, options, scene);
         auto& globalSettings = context->GlobalSettings;
@@ -1105,10 +1134,13 @@ bool ModelTool::ImportDataOpenFBX(const char* path, ImportedModelData& data, Opt
 
         // Log scene info
         LOG(Info, "Loaded FBX model, Frame Rate: {0}, Unit Scale Factor: {1}", context->FrameRate, globalSettings.UnitScaleFactor);
+        LOG(Info, "{0}, {1}, {2}", String(globalInfo.AppName), String(globalInfo.AppVersion), String(globalInfo.AppVendor));
         LOG(Info, "Up: {1}{0}", globalSettings.UpAxis == ofbx::UpVector_AxisX ? TEXT("X") : globalSettings.UpAxis == ofbx::UpVector_AxisY ? TEXT("Y") : TEXT("Z"), globalSettings.UpAxisSign == 1 ? TEXT("+") : TEXT("-"));
         LOG(Info, "Front: {1}{0}", globalSettings.FrontAxis == ofbx::FrontVector_ParityEven ? TEXT("ParityEven") : TEXT("ParityOdd"), globalSettings.FrontAxisSign == 1 ? TEXT("+") : TEXT("-"));
         LOG(Info, "{0} Handed{1}", globalSettings.CoordAxis == ofbx::CoordSystem_RightHanded ? TEXT("Right") : TEXT("Left"), globalSettings.CoordAxisSign == 1 ? TEXT("") : TEXT(" (negative)"));
+#if OPEN_FBX_CONVERT_SPACE
         LOG(Info, "Imported scene: Up={0}, Front={1}, Right={2}", context->Up, context->Front, context->Right);
+#endif
 
         // Extract embedded textures
         if (EnumHasAnyFlags(data.Types, ImportDataTypes::Textures))
@@ -1138,6 +1170,7 @@ bool ModelTool::ImportDataOpenFBX(const char* path, ImportedModelData& data, Opt
             }
         }
 
+#if OPEN_FBX_CONVERT_SPACE
         // Transform nodes to match the engine coordinates system - DirectX (UpVector = +Y, FrontVector = +Z, CoordSystem = -X (LeftHanded))
         if (context->Up == Float3(1, 0, 0) && context->Front == Float3(0, 0, 1) && context->Right == Float3(0, 1, 0))
         {
@@ -1167,15 +1200,16 @@ bool ModelTool::ImportDataOpenFBX(const char* path, ImportedModelData& data, Opt
             context->RootConvertRotation = Quaternion::Euler(90, 0, 0);*/
         if (!context->RootConvertRotation.IsIdentity())
         {
-            for (int32 i = 0; i < context->Nodes.Count(); i++)
+            for (auto& node : context->Nodes)
             {
-                if (context->Nodes[i].ParentIndex == -1)
+                if (node.ParentIndex == -1)
                 {
-                    context->Nodes[i].LocalTransform.Orientation = context->RootConvertRotation * context->Nodes[i].LocalTransform.Orientation;
+                    node.LocalTransform.Orientation = context->RootConvertRotation * node.LocalTransform.Orientation;
                     break;
                 }
             }
         }
+#endif
     }
     DeleteMe<OpenFbxImporterData> contextCleanup(options.SplitContext ? nullptr : context);
 

From 46353365da53f31857531c356f7278a56421e1d8 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Wed, 4 Oct 2023 10:24:36 +0200
Subject: [PATCH 088/103] Fix missing debug shapes drawing when skeleton node
 gets selected

#1220
---
 Source/Editor/Windows/Assets/SkinnedModelWindow.cs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/Source/Editor/Windows/Assets/SkinnedModelWindow.cs b/Source/Editor/Windows/Assets/SkinnedModelWindow.cs
index d360e5570..d8790172b 100644
--- a/Source/Editor/Windows/Assets/SkinnedModelWindow.cs
+++ b/Source/Editor/Windows/Assets/SkinnedModelWindow.cs
@@ -321,6 +321,7 @@ namespace FlaxEditor.Windows.Assets
 
                         var tree = group.Tree();
                         tree.TreeControl.RightClick += OnTreeNodeRightClick;
+                        tree.TreeControl.SelectedChanged += OnTreeSelectedChanged;
                         for (int i = 0; i < nodes.Length; i++)
                         {
                             if (nodes[i].ParentIndex == -1)
@@ -367,6 +368,12 @@ namespace FlaxEditor.Windows.Assets
                     menu.Show(node, location);
                 }
 
+                private void OnTreeSelectedChanged(List<TreeNode> before, List<TreeNode> after)
+                {
+                    if (after.Count != 0)
+                        ((SkeletonPropertiesProxy)Values[0]).Window._preview.ShowDebugDraw = true;
+                }
+
                 private void OnTreeNodeCopyName(ContextMenuButton b)
                 {
                     Clipboard.Text = (string)b.Tag;

From 9fa709aa79785fff61704e77751d81a87617f389 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Wed, 4 Oct 2023 12:42:11 +0200
Subject: [PATCH 089/103] Fix importing skinned models with meshes that don't
 have valid skinning to properly link into the node's bone

#1525
---
 Source/Engine/Tools/ModelTool/ModelTool.cpp | 54 ++++++++++++++-------
 Source/Engine/Tools/ModelTool/ModelTool.h   |  1 +
 2 files changed, 37 insertions(+), 18 deletions(-)

diff --git a/Source/Engine/Tools/ModelTool/ModelTool.cpp b/Source/Engine/Tools/ModelTool/ModelTool.cpp
index 2f3b68f95..8bd384602 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.cpp
@@ -841,19 +841,35 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
             const auto mesh = data.LODs[0].Meshes[i];
             if (mesh->BlendIndices.IsEmpty() || mesh->BlendWeights.IsEmpty())
             {
-                LOG(Warning, "Imported mesh \'{0}\' has missing skinning data. It may result in invalid rendering.", mesh->Name);
-
                 auto indices = Int4::Zero;
                 auto weights = Float4::UnitX;
 
                 // Check if use a single bone for skinning
                 auto nodeIndex = data.Skeleton.FindNode(mesh->Name);
                 auto boneIndex = data.Skeleton.FindBone(nodeIndex);
-                if (boneIndex != -1)
+                if (boneIndex == -1 && nodeIndex != -1 && data.Skeleton.Bones.Count() < MAX_BONES_PER_MODEL)
                 {
-                    LOG(Warning, "Using auto-detected bone {0} (index {1})", data.Skeleton.Nodes[nodeIndex].Name, boneIndex);
+                    // Add missing bone to be used by skinned model from animated nodes pose
+                    boneIndex = data.Skeleton.Bones.Count();
+                    auto& bone = data.Skeleton.Bones.AddOne();
+                    bone.ParentIndex = -1;
+                    bone.NodeIndex = nodeIndex;
+                    bone.LocalTransform = CombineTransformsFromNodeIndices(data.Nodes, -1, nodeIndex);
+                    CalculateBoneOffsetMatrix(data.Skeleton.Nodes, bone.OffsetMatrix, bone.NodeIndex);
+                    LOG(Warning, "Using auto-created bone {0} (index {1}) for mesh \'{2}\'", data.Skeleton.Nodes[nodeIndex].Name, boneIndex, mesh->Name);
                     indices.X = boneIndex;
                 }
+                else if (boneIndex != -1)
+                {
+                    // Fallback to already added bone
+                    LOG(Warning, "Using auto-detected bone {0} (index {1}) for mesh \'{2}\'", data.Skeleton.Nodes[nodeIndex].Name, boneIndex, mesh->Name);
+                    indices.X = boneIndex;
+                }
+                else
+                {
+                    // No bone
+                    LOG(Warning, "Imported mesh \'{0}\' has missing skinning data. It may result in invalid rendering.", mesh->Name);
+                }
 
                 mesh->BlendIndices.Resize(mesh->Positions.Count());
                 mesh->BlendWeights.Resize(mesh->Positions.Count());
@@ -1366,20 +1382,9 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
         // use SkeletonMapping<SkeletonBone> to map bones?
 
         // Calculate offset matrix (inverse bind pose transform) for every bone manually
-        /*{
-            for (SkeletonBone& bone : data.Skeleton.Bones)
-            {
-                Matrix t = Matrix::Identity;
-                int32 idx = bone.NodeIndex;
-                do
-                {
-                    const SkeletonNode& node = data.Skeleton.Nodes[idx];
-                    t *= node.LocalTransform.GetWorld();
-                    idx = node.ParentIndex;
-                } while (idx != -1);
-                t.Invert();
-                bone.OffsetMatrix = t;
-            }
+        /*for (SkeletonBone& bone : data.Skeleton.Bones)
+        {
+            CalculateBoneOffsetMatrix(data.Skeleton.Nodes, bone.OffsetMatrix, bone.NodeIndex);
         }*/
 
 #if USE_SKELETON_NODES_SORTING
@@ -1759,4 +1764,17 @@ bool ModelTool::FindTexture(const String& sourcePath, const String& file, String
 
 #endif
 
+void ModelTool::CalculateBoneOffsetMatrix(const Array<SkeletonNode>& nodes, Matrix& offsetMatrix, int32 nodeIndex)
+{
+    offsetMatrix = Matrix::Identity;
+    int32 idx = nodeIndex;
+    do
+    {
+        const SkeletonNode& node = nodes[idx];
+        offsetMatrix *= node.LocalTransform.GetWorld();
+        idx = node.ParentIndex;
+    } while (idx != -1);
+    offsetMatrix.Invert();
+}
+
 #endif
diff --git a/Source/Engine/Tools/ModelTool/ModelTool.h b/Source/Engine/Tools/ModelTool/ModelTool.h
index 9dc5bf067..4893eb32f 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.h
+++ b/Source/Engine/Tools/ModelTool/ModelTool.h
@@ -419,6 +419,7 @@ public:
     }
 
 private:
+    static void CalculateBoneOffsetMatrix(const Array<SkeletonNode>& nodes, Matrix& offsetMatrix, int32 nodeIndex);
 #if USE_ASSIMP
     static bool ImportDataAssimp(const char* path, ImportedModelData& data, Options& options, String& errorMsg);
 #endif

From d68c65d9d613064b2f26c9d09ca21cb0712c765c Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Wed, 4 Oct 2023 13:50:15 +0200
Subject: [PATCH 090/103] Fix build regression from
 9fa709aa79785fff61704e77751d81a87617f389

---
 Source/Engine/Tools/ModelTool/ModelTool.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Source/Engine/Tools/ModelTool/ModelTool.cpp b/Source/Engine/Tools/ModelTool/ModelTool.cpp
index 8bd384602..91cfe74e4 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.cpp
@@ -1762,8 +1762,6 @@ bool ModelTool::FindTexture(const String& sourcePath, const String& file, String
     return false;
 }
 
-#endif
-
 void ModelTool::CalculateBoneOffsetMatrix(const Array<SkeletonNode>& nodes, Matrix& offsetMatrix, int32 nodeIndex)
 {
     offsetMatrix = Matrix::Identity;
@@ -1778,3 +1776,5 @@ void ModelTool::CalculateBoneOffsetMatrix(const Array<SkeletonNode>& nodes, Matr
 }
 
 #endif
+
+#endif

From f1600b30146874183d0cc849ba5206a131027cb4 Mon Sep 17 00:00:00 2001
From: Edu Garcia <28616+Arcnor@users.noreply.github.com>
Date: Wed, 4 Oct 2023 12:39:27 +0100
Subject: [PATCH 091/103] Move custom pugixml changes to pugixml_extra

---
 .../Cooker/Platform/Mac/MacPlatformTools.cpp  | 32 +++++-----
 Source/ThirdParty/pugixml/pugixml.cpp         | 21 -------
 Source/ThirdParty/pugixml/pugixml.hpp         |  2 -
 Source/ThirdParty/pugixml/pugixml_extra.cpp   | 63 +++++++++++++++++++
 Source/ThirdParty/pugixml/pugixml_extra.hpp   | 18 ++++++
 5 files changed, 98 insertions(+), 38 deletions(-)
 create mode 100644 Source/ThirdParty/pugixml/pugixml_extra.cpp
 create mode 100644 Source/ThirdParty/pugixml/pugixml_extra.hpp

diff --git a/Source/Editor/Cooker/Platform/Mac/MacPlatformTools.cpp b/Source/Editor/Cooker/Platform/Mac/MacPlatformTools.cpp
index b66a96a9b..0008228f7 100644
--- a/Source/Editor/Cooker/Platform/Mac/MacPlatformTools.cpp
+++ b/Source/Editor/Cooker/Platform/Mac/MacPlatformTools.cpp
@@ -17,7 +17,9 @@
 #include "Editor/ProjectInfo.h"
 #include "Editor/Cooker/GameCooker.h"
 #include "Editor/Utilities/EditorUtilities.h"
-#include <ThirdParty/pugixml/pugixml.hpp>
+
+#include "pugixml/pugixml_extra.hpp"
+
 using namespace pugi;
 
 IMPLEMENT_SETTINGS_GETTER(MacPlatformSettings, MacPlatform);
@@ -170,17 +172,17 @@ bool MacPlatformTools::OnPostProcess(CookingData& data)
     const String plistPath = data.DataOutputPath / TEXT("Info.plist");
     {
         xml_document doc;
-        xml_node plist = doc.child_or_append(PUGIXML_TEXT("plist"));
+        xml_node_extra plist = xml_node_extra(doc).child_or_append(PUGIXML_TEXT("plist"));
         plist.append_attribute(PUGIXML_TEXT("version")).set_value(PUGIXML_TEXT("1.0"));
-        xml_node dict = plist.child_or_append(PUGIXML_TEXT("dict"));
+        xml_node_extra dict = plist.child_or_append(PUGIXML_TEXT("dict"));
 
 #define ADD_ENTRY(key, value) \
-    dict.append_child(PUGIXML_TEXT("key")).set_child_value(PUGIXML_TEXT(key)); \
-    dict.append_child(PUGIXML_TEXT("string")).set_child_value(PUGIXML_TEXT(value))
+    dict.append_child_with_value(PUGIXML_TEXT("key"), PUGIXML_TEXT(key)); \
+    dict.append_child_with_value(PUGIXML_TEXT("string"), PUGIXML_TEXT(value))
 #define ADD_ENTRY_STR(key, value) \
-    dict.append_child(PUGIXML_TEXT("key")).set_child_value(PUGIXML_TEXT(key)); \
+    dict.append_child_with_value(PUGIXML_TEXT("key"), PUGIXML_TEXT(key)); \
     { std::u16string valueStr(value.GetText()); \
-    dict.append_child(PUGIXML_TEXT("string")).set_child_value(pugi::string_t(valueStr.begin(), valueStr.end()).c_str()); }
+    dict.append_child_with_value(PUGIXML_TEXT("string"), pugi::string_t(valueStr.begin(), valueStr.end()).c_str()); }
 
         ADD_ENTRY("CFBundleDevelopmentRegion", "English");
         ADD_ENTRY("CFBundlePackageType", "APPL");
@@ -194,22 +196,22 @@ bool MacPlatformTools::OnPostProcess(CookingData& data)
         ADD_ENTRY_STR("CFBundleVersion", projectVersion);
         ADD_ENTRY_STR("NSHumanReadableCopyright", gameSettings->CopyrightNotice);
 
-        dict.append_child(PUGIXML_TEXT("key")).set_child_value(PUGIXML_TEXT("CFBundleSupportedPlatforms"));
-        xml_node CFBundleSupportedPlatforms = dict.append_child(PUGIXML_TEXT("array"));
-        CFBundleSupportedPlatforms.append_child(PUGIXML_TEXT("string")).set_child_value(PUGIXML_TEXT("MacOSX"));
+        dict.append_child_with_value(PUGIXML_TEXT("key"), PUGIXML_TEXT("CFBundleSupportedPlatforms"));
+        xml_node_extra CFBundleSupportedPlatforms = dict.append_child(PUGIXML_TEXT("array"));
+        CFBundleSupportedPlatforms.append_child_with_value(PUGIXML_TEXT("string"), PUGIXML_TEXT("MacOSX"));
 
-        dict.append_child(PUGIXML_TEXT("key")).set_child_value(PUGIXML_TEXT("LSMinimumSystemVersionByArchitecture"));
-        xml_node LSMinimumSystemVersionByArchitecture = dict.append_child(PUGIXML_TEXT("dict"));
+        dict.append_child_with_value(PUGIXML_TEXT("key"), PUGIXML_TEXT("LSMinimumSystemVersionByArchitecture"));
+        xml_node_extra LSMinimumSystemVersionByArchitecture = dict.append_child(PUGIXML_TEXT("dict"));
         switch (_arch)
         {
         case ArchitectureType::x64:
-            LSMinimumSystemVersionByArchitecture.append_child(PUGIXML_TEXT("key")).set_child_value(PUGIXML_TEXT("x86_64"));
+            LSMinimumSystemVersionByArchitecture.append_child_with_value(PUGIXML_TEXT("key"), PUGIXML_TEXT("x86_64"));
             break;
         case ArchitectureType::ARM64:
-            LSMinimumSystemVersionByArchitecture.append_child(PUGIXML_TEXT("key")).set_child_value(PUGIXML_TEXT("arm64"));
+            LSMinimumSystemVersionByArchitecture.append_child_with_value(PUGIXML_TEXT("key"), PUGIXML_TEXT("arm64"));
             break;
         }
-        LSMinimumSystemVersionByArchitecture.append_child(PUGIXML_TEXT("string")).set_child_value(PUGIXML_TEXT("10.15"));
+        LSMinimumSystemVersionByArchitecture.append_child_with_value(PUGIXML_TEXT("string"), PUGIXML_TEXT("10.15"));
         
 #undef ADD_ENTRY
 #undef ADD_ENTRY_STR
diff --git a/Source/ThirdParty/pugixml/pugixml.cpp b/Source/ThirdParty/pugixml/pugixml.cpp
index af52e1ea8..56860bb90 100644
--- a/Source/ThirdParty/pugixml/pugixml.cpp
+++ b/Source/ThirdParty/pugixml/pugixml.cpp
@@ -4799,16 +4799,6 @@ namespace pugi
 		return xml_node();
 	}
 
-	PUGI__FN xml_node xml_node::child_or_append(const char_t* name_)
-	{
-		if (!_root) return xml_node();
-
-		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
-			if (i->name && impl::strequal(name_, i->name)) return xml_node(i);
-
-		return append_child(name_);
-	}
-
 	PUGI__FN xml_attribute xml_node::attribute(const char_t* name_) const
 	{
 		if (!_root) return xml_attribute();
@@ -4879,17 +4869,6 @@ namespace pugi
 		return PUGIXML_TEXT("");
 	}
 
-    PUGI__FN bool xml_node::set_child_value(const char_t* rhs)
-    {
-		if (!_root) return false;
-		
-		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
-			if (i->value && impl::is_text_node(i))
-				return xml_node(i).set_value(rhs);
-
-		return append_child(node_pcdata).set_value(rhs);
-    }
-
     PUGI__FN const char_t* xml_node::child_value(const char_t* name_) const
 	{
 		return child(name_).child_value();
diff --git a/Source/ThirdParty/pugixml/pugixml.hpp b/Source/ThirdParty/pugixml/pugixml.hpp
index fd71dfb1a..d937bff47 100644
--- a/Source/ThirdParty/pugixml/pugixml.hpp
+++ b/Source/ThirdParty/pugixml/pugixml.hpp
@@ -452,14 +452,12 @@ namespace pugi
 
 		// Get child, attribute or next/previous sibling with the specified name
 		xml_node child(const char_t* name) const;
-		xml_node child_or_append(const char_t* name);
 		xml_attribute attribute(const char_t* name) const;
 		xml_node next_sibling(const char_t* name) const;
 		xml_node previous_sibling(const char_t* name) const;
 
 		// Get child value of current node; that is, value of the first child node of type PCDATA/CDATA
 		const char_t* child_value() const;
-		bool set_child_value(const char_t* rhs);
 
 		// Get child value of child with specified name. Equivalent to child(name).child_value().
 		const char_t* child_value(const char_t* name) const;
diff --git a/Source/ThirdParty/pugixml/pugixml_extra.cpp b/Source/ThirdParty/pugixml/pugixml_extra.cpp
new file mode 100644
index 000000000..1c823112b
--- /dev/null
+++ b/Source/ThirdParty/pugixml/pugixml_extra.cpp
@@ -0,0 +1,63 @@
+#include "pugixml.hpp"
+#include "pugixml_extra.hpp"
+
+namespace pugi
+{
+
+    // Compare two strings
+    // This comes from pugi::impl::strequal
+    bool strequal(const char_t* src, const char_t* dst)
+    {
+#ifdef PUGIXML_WCHAR_MODE
+        return wcscmp(src, dst) == 0;
+#else
+        return strcmp(src, dst) == 0;
+#endif
+    }
+
+    // This comes from pugi::impl::is_text_node
+    inline bool is_text_node(const xml_node& node)
+    {
+        xml_node_type type = node.type();
+
+        return type == node_pcdata || type == node_cdata;
+    }
+
+    xml_node_extra::xml_node_extra(xml_node child) : xml_node(child)
+    {
+    }
+
+    xml_node_extra xml_node_extra::child_or_append(const char_t* name_)
+    {
+        if (!name_ || !_root) return xml_node_extra();
+
+        for (xml_node& child : *this)
+        {
+            const auto *name = child.name();
+            if (name && strequal(name_, name)) return xml_node_extra(child);
+        }
+
+        return xml_node_extra(append_child(name_));
+    }
+
+    bool xml_node_extra::set_child_value(const char_t* rhs)
+    {
+        if (!_root) return xml_node();
+
+        for (xml_node& child : *this)
+        {
+            if (child.value() && is_text_node(child))
+            {
+                return child.set_value(rhs);
+            }
+        }
+
+        return append_child(node_pcdata).set_value(rhs);
+    }
+
+    void xml_node_extra::append_child_with_value(const char_t* name_, const char_t* rhs)
+    {
+        xml_node_extra child = xml_node_extra(append_child(name_));
+        child.append_child(node_pcdata).set_value(rhs);
+    }
+}
diff --git a/Source/ThirdParty/pugixml/pugixml_extra.hpp b/Source/ThirdParty/pugixml/pugixml_extra.hpp
new file mode 100644
index 000000000..0103120eb
--- /dev/null
+++ b/Source/ThirdParty/pugixml/pugixml_extra.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "pugixml.hpp"
+
+namespace pugi
+{
+    class xml_node_extra : public xml_node
+    {
+    public:
+        xml_node_extra() = default;
+        xml_node_extra(xml_node child);
+
+        xml_node_extra child_or_append(const char_t* name_);
+        bool set_child_value(const char_t* rhs);
+        void append_child_with_value(const char_t* name_, const char_t* rhs);
+
+    };
+}

From bed736a8eeb8ab5bad5c82458d9324edde88685e Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Wed, 4 Oct 2023 15:16:10 +0200
Subject: [PATCH 092/103] Add support for importing embedded textures via
 `Assimp` importer

#669
---
 .../Tools/ModelTool/ModelTool.Assimp.cpp      | 44 ++++++++++++++++++-
 1 file changed, 42 insertions(+), 2 deletions(-)

diff --git a/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp b/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp
index 8aa9199fe..d2e26ee68 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp
@@ -7,6 +7,7 @@
 #include "Engine/Core/DeleteMe.h"
 #include "Engine/Core/Math/Matrix.h"
 #include "Engine/Platform/FileSystem.h"
+#include "Engine/Platform/File.h"
 #include "Engine/Tools/TextureTool/TextureTool.h"
 
 // Import Assimp library
@@ -515,8 +516,47 @@ bool ImportTexture(ImportedModelData& result, AssimpImporterData& data, aiString
 bool ImportMaterialTexture(ImportedModelData& result, AssimpImporterData& data, const aiMaterial* aMaterial, aiTextureType aTextureType, int32& textureIndex, TextureEntry::TypeHint type)
 {
     aiString aFilename;
-    return aMaterial->GetTexture(aTextureType, 0, &aFilename, nullptr, nullptr, nullptr, nullptr) == AI_SUCCESS &&
-            ImportTexture(result, data, aFilename, textureIndex, type);
+    if (aMaterial->GetTexture(aTextureType, 0, &aFilename, nullptr, nullptr, nullptr, nullptr) == AI_SUCCESS)
+    {
+        // Check for embedded textures
+        String filename = String(aFilename.C_Str()).TrimTrailing();
+        if (filename.StartsWith(TEXT(AI_EMBEDDED_TEXNAME_PREFIX)))
+        {
+            const aiTexture* aTex = data.Scene->GetEmbeddedTexture(aFilename.C_Str());
+            const StringView texIndexName(filename.Get() + (ARRAY_COUNT(AI_EMBEDDED_TEXNAME_PREFIX) - 1));
+            int32 texIndex;
+            if (!aTex && !StringUtils::Parse(texIndexName.Get(), texIndexName.Length(), &texIndex) && texIndex >= 0 && texIndex < data.Scene->mNumTextures)
+                aTex = data.Scene->mTextures[texIndex];
+            if (aTex && aTex->mHeight == 0 && aTex->mWidth > 0)
+            {
+                // Export embedded texture to temporary file
+                filename = String::Format(TEXT("{0}_tex_{1}.{2}"), StringUtils::GetFileNameWithoutExtension(data.Path), texIndexName, String(aTex->achFormatHint));
+                File::WriteAllBytes(String(StringUtils::GetDirectoryName(data.Path)) / filename, (const byte*)aTex->pcData, (int32)aTex->mWidth);
+            }
+        }
+
+        // Find texture file path
+        String path;
+        if (ModelTool::FindTexture(data.Path, filename, path))
+            return true;
+
+        // Check if already used
+        textureIndex = 0;
+        while (textureIndex < result.Textures.Count())
+        {
+            if (result.Textures[textureIndex].FilePath == path)
+                return true;
+            textureIndex++;
+        }
+
+        // Import texture
+        auto& texture = result.Textures.AddOne();
+        texture.FilePath = path;
+        texture.Type = type;
+        texture.AssetID = Guid::Empty;
+        return true;
+    }
+    return false;
 }
 
 bool ImportMaterials(ImportedModelData& result, AssimpImporterData& data, String& errorMsg)

From fe9b6d73a86a8af864542bdf500b945952f6cccc Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Wed, 4 Oct 2023 16:54:50 +0200
Subject: [PATCH 093/103] Fix build regression from
 b3b6251c107ee210ef7cfa7d8a44d3298f02acca

---
 Source/ThirdParty/OpenFBX/ofbx.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Source/ThirdParty/OpenFBX/ofbx.cpp b/Source/ThirdParty/OpenFBX/ofbx.cpp
index e3cbd6230..e60211e3d 100644
--- a/Source/ThirdParty/OpenFBX/ofbx.cpp
+++ b/Source/ThirdParty/OpenFBX/ofbx.cpp
@@ -2982,9 +2982,9 @@ static void parseGlobalInfo(const Element& root, Scene* scene)
 				{
 					if (!node->first_property)
 						continue;
-					get_text_property("Original|ApplicationVendor", scene->m_info.AppVendor, UpVector, toInt);
-					get_text_property("Original|ApplicationName", scene->m_info.AppName, UpVector, toInt);
-					get_text_property("Original|ApplicationVersion", scene->m_info.AppVersion, UpVector, toInt);
+					get_text_property("Original|ApplicationVendor", scene->m_info.AppVendor);
+					get_text_property("Original|ApplicationName", scene->m_info.AppName);
+					get_text_property("Original|ApplicationVersion", scene->m_info.AppVersion);
 				}
 				break;
 			}

From f1d57e47cb7e86596cf9cdb376d7002d8d0cfe6c Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Wed, 4 Oct 2023 17:34:14 +0200
Subject: [PATCH 094/103] Fix regression in some context menus on Windows due
 to recent changes to windows showing after first paint

---
 Source/Editor/GUI/ContextMenu/ContextMenuBase.cs | 2 +-
 Source/Engine/Platform/Windows/WindowsWindow.cpp | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/Source/Editor/GUI/ContextMenu/ContextMenuBase.cs b/Source/Editor/GUI/ContextMenu/ContextMenuBase.cs
index 7ecd197eb..628af18e1 100644
--- a/Source/Editor/GUI/ContextMenu/ContextMenuBase.cs
+++ b/Source/Editor/GUI/ContextMenu/ContextMenuBase.cs
@@ -154,6 +154,7 @@ namespace FlaxEditor.GUI.ContextMenu
             }
 
             // Unlock and perform controls update
+            Location = Float2.Zero;
             UnlockChildrenRecursive();
             PerformLayout();
 
@@ -162,7 +163,6 @@ namespace FlaxEditor.GUI.ContextMenu
             var dpiSize = Size * dpiScale;
             var locationWS = parent.PointToWindow(location);
             var locationSS = parentWin.PointToScreen(locationWS);
-            Location = Float2.Zero;
             var monitorBounds = Platform.GetMonitorBounds(locationSS);
             var rightBottomLocationSS = locationSS + dpiSize;
             bool isUp = false, isLeft = false;
diff --git a/Source/Engine/Platform/Windows/WindowsWindow.cpp b/Source/Engine/Platform/Windows/WindowsWindow.cpp
index 906816bf0..1bc50f207 100644
--- a/Source/Engine/Platform/Windows/WindowsWindow.cpp
+++ b/Source/Engine/Platform/Windows/WindowsWindow.cpp
@@ -220,6 +220,12 @@ void WindowsWindow::Show()
         if (!_settings.HasBorder)
         {
             SetWindowPos(_handle, nullptr, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER);
+            if (!_settings.IsRegularWindow && _settings.ShowAfterFirstPaint && _settings.StartPosition == WindowStartPosition::Manual)
+            {
+                int32 x = Math::TruncToInt(_settings.Position.X);
+                int32 y = Math::TruncToInt(_settings.Position.Y);
+                SetWindowPos(_handle, nullptr, x, y, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
+            }
         }
 #endif
 

From f2a3338dce85b2b9a6fb9c7957349b27fdf92e72 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Wed, 4 Oct 2023 19:58:10 +0200
Subject: [PATCH 095/103] Improve #859

---
 Source/Editor/Windows/GameWindow.cs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/Source/Editor/Windows/GameWindow.cs b/Source/Editor/Windows/GameWindow.cs
index 2e9fa4014..fdedbb3c2 100644
--- a/Source/Editor/Windows/GameWindow.cs
+++ b/Source/Editor/Windows/GameWindow.cs
@@ -466,8 +466,13 @@ namespace FlaxEditor.Windows
         /// <inheritdoc />
         public override void OnMouseLeave()
         {
-            Parent?.Focus();
             base.OnMouseLeave();
+
+            // Remove focus from game window when mouse moves out and the cursor is hidden during game
+            if ((IsFocused || ContainsFocus) && Parent != null && Editor.IsPlayMode && !Screen.CursorVisible)
+            {
+                Parent.Focus();
+            }
         }
 
         /// <inheritdoc />

From f46cc32715f9faffb4afff5d98fb337c98aa7b73 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Wed, 4 Oct 2023 20:15:23 +0200
Subject: [PATCH 096/103] Cleanup code #1115

---
 .../Editor/Managed/ManagedEditor.Internal.cpp |  2 +-
 Source/Engine/Content/Asset.h                 |  1 -
 Source/Engine/Content/Content.cpp             |  5 --
 Source/Engine/Tools/ModelTool/ModelTool.cpp   | 63 ++++++++-----------
 Source/Engine/Tools/ModelTool/ModelTool.h     |  7 +--
 5 files changed, 30 insertions(+), 48 deletions(-)

diff --git a/Source/Editor/Managed/ManagedEditor.Internal.cpp b/Source/Editor/Managed/ManagedEditor.Internal.cpp
index 49c3af87e..afcbb740a 100644
--- a/Source/Editor/Managed/ManagedEditor.Internal.cpp
+++ b/Source/Editor/Managed/ManagedEditor.Internal.cpp
@@ -829,4 +829,4 @@ bool ManagedEditor::TryRestoreImportOptions(ModelTool::Options& options, String
     // Get options from model
     FileSystem::NormalizePath(assetPath);
     return ImportModelFile::TryGetImportOptions(assetPath, options);
-}
\ No newline at end of file
+}
diff --git a/Source/Engine/Content/Asset.h b/Source/Engine/Content/Asset.h
index 0ecc6db3f..2d2ba4b3f 100644
--- a/Source/Engine/Content/Asset.h
+++ b/Source/Engine/Content/Asset.h
@@ -246,4 +246,3 @@ public:
 
 // Don't include Content.h but just Load method
 extern FLAXENGINE_API Asset* LoadAsset(const Guid& id, const ScriptingTypeHandle& type);
-extern FLAXENGINE_API Asset* LoadAsset(const StringView& path, const ScriptingTypeHandle& type);
diff --git a/Source/Engine/Content/Content.cpp b/Source/Engine/Content/Content.cpp
index eabf58cf2..6aecd1778 100644
--- a/Source/Engine/Content/Content.cpp
+++ b/Source/Engine/Content/Content.cpp
@@ -447,11 +447,6 @@ FLAXENGINE_API Asset* LoadAsset(const Guid& id, const ScriptingTypeHandle& type)
     return Content::LoadAsync(id, type);
 }
 
-FLAXENGINE_API Asset* LoadAsset(const StringView& path, const ScriptingTypeHandle& type)
-{
-    return Content::LoadAsync(path, type);
-}
-
 Asset* Content::LoadAsync(const StringView& path, MClass* type)
 {
     CHECK_RETURN(type, nullptr);
diff --git a/Source/Engine/Tools/ModelTool/ModelTool.cpp b/Source/Engine/Tools/ModelTool/ModelTool.cpp
index ad41028c9..b703b47d1 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.cpp
@@ -633,8 +633,8 @@ void CreateLinearListFromTree(Array<SkeletonNode>& nodes, Array<int32>& mapping)
     // Customized breadth first tree algorithm (each node has no direct reference to the children so we build the cache for the nodes depth level)
     const int32 count = nodes.Count();
     Array<Pair<int32, int32>> depths(count); // Pair.First = Depth, Pair.Second = Node Index
-    depths.SetSize(count);
-    depths.Set(-1);
+    depths.Resize(count);
+    depths.SetAll(-1);
     for (int32 i = 0; i < count; i++)
     {
         // Skip evaluated nodes
@@ -653,7 +653,7 @@ void CreateLinearListFromTree(Array<SkeletonNode>& nodes, Array<int32>& mapping)
         } while (end != -1 && lastDepth == -1);
 
         // Set the depth (second item is the node index)
-        depths[i] = MakePair(lastDepth + relativeDepth, i);
+        depths[i] = ToPair(lastDepth + relativeDepth, i);
     }
     for (int32 i = 0; i < count; i++)
     {
@@ -666,7 +666,7 @@ void CreateLinearListFromTree(Array<SkeletonNode>& nodes, Array<int32>& mapping)
 
     // Extract nodes mapping O(n^2)
     mapping.EnsureCapacity(count, false);
-    mapping.SetSize(count);
+    mapping.Resize(count);
     for (int32 i = 0; i < count; i++)
     {
         int32 newIndex = -1;
@@ -964,7 +964,7 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
         case TextureEntry::TypeHint::Normals:
             textureOptions.Type = TextureFormatType::NormalMap;
             break;
-        default:;
+        default: ;
         }
         AssetsImportingManager::ImportIfEdited(texture.FilePath, assetPath, texture.AssetID, &textureOptions);
 #endif
@@ -999,37 +999,34 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
         importedFileNames.Add(filename);
 #if COMPILE_WITH_ASSETS_IMPORTER
         auto assetPath = autoImportOutput / filename + ASSET_FILES_EXTENSION_WITH_DOT;
+
+        // When splitting imported meshes allow only the first mesh to import assets (mesh[0] is imported after all following ones so import assets during mesh[1])
+        if (!options.SplitObjects && options.ObjectIndex != 1 && options.ObjectIndex != -1)
+        {
+            // Find that asset create previously
+            AssetInfo info;
+            if (Content::GetAssetInfo(assetPath, info))
+                material.AssetID = info.ID;
+            continue;
+        }
+
         if (options.ImportMaterialsAsInstances)
         {
-            if (!options.SplitObjects && options.ObjectIndex != 1 && options.ObjectIndex != -1)
-            {
-                // Find that asset create previously
-                AssetInfo info;
-                if (Content::GetAssetInfo(assetPath, info))
-                    material.AssetID = info.ID;
-                continue;
-            }
-
+            // Create material instance
             AssetsImportingManager::Create(AssetsImportingManager::CreateMaterialInstanceTag, assetPath, material.AssetID);
-            MaterialInstance* materialInstance = (MaterialInstance*)LoadAsset(assetPath, MaterialInstance::TypeInitializer);
-            if (materialInstance->WaitForLoaded())
+            if (MaterialInstance* materialInstance = Content::Load<MaterialInstance>(assetPath))
+            {
+                materialInstance->SetBaseMaterial(options.InstanceToImportAs);
+                materialInstance->Save();
+            }
+            else
             {
                 LOG(Error, "Failed to load material instance after creation. ({0})", assetPath);
-                return true;
             }
-
-            MaterialBase* materialInstanceOf = options.InstanceToImportAs;
-            if (materialInstanceOf->WaitForLoaded())
-            {
-                LOG(Error, "Failed to load material to create an instance of. ({0})", options.InstanceToImportAs->GetID());
-                return true;
-            }
-
-            materialInstance->SetBaseMaterial(materialInstanceOf);
-            materialInstance->Save();
         }
         else
         {
+            // Create material
             CreateMaterial::Options materialOptions;
             materialOptions.Diffuse.Color = material.Diffuse.Color;
             if (material.Diffuse.TextureIndex != -1)
@@ -1047,15 +1044,6 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
                 materialOptions.Info.CullMode = CullMode::TwoSided;
             if (!Math::IsOne(material.Opacity.Value) || material.Opacity.TextureIndex != -1)
                 materialOptions.Info.BlendMode = MaterialBlendMode::Transparent;
-
-            if (!options.SplitObjects && options.ObjectIndex != 1 && options.ObjectIndex != -1)
-            {
-                // Find that asset create previously
-                AssetInfo info;
-                if (Content::GetAssetInfo(assetPath, info))
-                    material.AssetID = info.ID;
-                continue;
-            }
             AssetsImportingManager::Create(AssetsImportingManager::CreateMaterialTag, assetPath, material.AssetID, &materialOptions);
         }
 #endif
@@ -1441,7 +1429,8 @@ bool ModelTool::ImportModel(const String& path, ModelData& meshData, Options& op
                 bone.NodeIndex = mapping[bone.NodeIndex];
             }
         }
-        reorder_nodes_and_test_it_out!
+        reorder_nodes_and_test_it_out
+        !
 #endif
     }
     else if (options.Type == ModelType::Animation)
diff --git a/Source/Engine/Tools/ModelTool/ModelTool.h b/Source/Engine/Tools/ModelTool/ModelTool.h
index 99ca72df5..36bb9b12c 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.h
+++ b/Source/Engine/Tools/ModelTool/ModelTool.h
@@ -12,8 +12,7 @@
 #include "Engine/Graphics/Models/ModelData.h"
 #include "Engine/Graphics/Models/SkeletonData.h"
 #include "Engine/Animations/AnimationData.h"
-#include <Engine/Content/Assets/Material.h>
-#include <Engine/Graphics/GPUDevice.h>
+#include "Engine/Content/Assets/MaterialBase.h"
 
 class JsonWriter;
 
@@ -265,7 +264,7 @@ public:
         // If specified, all meshes which name starts with this prefix will be imported as a separate collision data (excluded used for rendering).
         API_FIELD(Attributes="EditorOrder(100), EditorDisplay(\"Geometry\"), VisibleIf(nameof(ShowGeometry))")
         String CollisionMeshesPrefix = TEXT("");
-        // The type of collision that should be generated if has collision prefix especified
+        // The type of collision that should be generated if has collision prefix specified.
         API_FIELD(Attributes = "EditorOrder(105), EditorDisplay(\"Geometry\"), VisibleIf(nameof(ShowGeometry))")
         CollisionDataType CollisionType = CollisionDataType::TriangleMesh;
 
@@ -345,7 +344,7 @@ public:
         bool ImportMaterialsAsInstances = false;
         // The material to import the model's materials as an instance of.
         API_FIELD(Attributes = "EditorOrder(402), EditorDisplay(\"Materials\"), VisibleIf(nameof(ImportMaterialsAsInstances))")
-        AssetReference<Material> InstanceToImportAs = (Material*) GPUDevice::Instance->GetDefaultMaterial();
+        AssetReference<MaterialBase> InstanceToImportAs;
         // If checked, the importer will import texture files used by the model and any embedded texture resources.
         API_FIELD(Attributes="EditorOrder(410), EditorDisplay(\"Materials\"), VisibleIf(nameof(ShowGeometry))")
         bool ImportTextures = true;

From 7777f73c26f6d4e5a2004aa7cf060db472d7eb87 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Wed, 4 Oct 2023 20:20:35 +0200
Subject: [PATCH 097/103] Fix warning

---
 Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp b/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp
index d2e26ee68..000a2e77b 100644
--- a/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp
+++ b/Source/Engine/Tools/ModelTool/ModelTool.Assimp.cpp
@@ -524,7 +524,7 @@ bool ImportMaterialTexture(ImportedModelData& result, AssimpImporterData& data,
         {
             const aiTexture* aTex = data.Scene->GetEmbeddedTexture(aFilename.C_Str());
             const StringView texIndexName(filename.Get() + (ARRAY_COUNT(AI_EMBEDDED_TEXNAME_PREFIX) - 1));
-            int32 texIndex;
+            uint32 texIndex;
             if (!aTex && !StringUtils::Parse(texIndexName.Get(), texIndexName.Length(), &texIndex) && texIndex >= 0 && texIndex < data.Scene->mNumTextures)
                 aTex = data.Scene->mTextures[texIndex];
             if (aTex && aTex->mHeight == 0 && aTex->mWidth > 0)

From 92f677f2380687a69738c6c0ff1c4321601168ac Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Wed, 4 Oct 2023 22:25:27 +0200
Subject: [PATCH 098/103] Codestyle formatting #1522

---
 Source/Editor/Scripting/ScriptType.cs         |  2 +-
 Source/Editor/Surface/Archetypes/Function.cs  | 62 +++++++++----------
 Source/Editor/Surface/Archetypes/Packing.cs   | 10 +--
 .../Editor/Surface/ContextMenu/VisjectCM.cs   | 14 ++---
 .../Surface/ContextMenu/VisjectCMGroup.cs     |  4 +-
 .../Surface/ContextMenu/VisjectCMItem.cs      | 22 +++----
 Source/Editor/Surface/Elements/Box.cs         |  2 +-
 Source/Editor/Surface/Elements/OutputBox.cs   | 16 ++---
 Source/Editor/Surface/NodeArchetype.cs        |  6 +-
 Source/Editor/Surface/SurfaceUtils.cs         |  4 +-
 .../Surface/VisjectSurface.Connecting.cs      |  4 +-
 11 files changed, 74 insertions(+), 72 deletions(-)

diff --git a/Source/Editor/Scripting/ScriptType.cs b/Source/Editor/Scripting/ScriptType.cs
index e3de348d2..b0c3a36dd 100644
--- a/Source/Editor/Scripting/ScriptType.cs
+++ b/Source/Editor/Scripting/ScriptType.cs
@@ -1393,7 +1393,7 @@ namespace FlaxEditor.Scripting
                 return _custom.GetMembers(name, MemberTypes.Method, bindingAttr).FirstOrDefault();
             return ScriptMemberInfo.Null;
         }
-        
+
         /// <summary>
         /// Basic check to see if a type could be casted to another type
         /// </summary>
diff --git a/Source/Editor/Surface/Archetypes/Function.cs b/Source/Editor/Surface/Archetypes/Function.cs
index de89ab50c..e9d73ae68 100644
--- a/Source/Editor/Surface/Archetypes/Function.cs
+++ b/Source/Editor/Surface/Archetypes/Function.cs
@@ -744,12 +744,12 @@ namespace FlaxEditor.Surface.Archetypes
 
                 base.OnDestroy();
             }
-            
+
             internal static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
             {
                 return false;
             }
-            
+
             internal static bool IsOutputCompatible(NodeArchetype nodeArch, ScriptType inputType, ConnectionsHint hint)
             {
                 return inputType.IsVoid;
@@ -1161,48 +1161,48 @@ namespace FlaxEditor.Surface.Archetypes
 
                 base.OnDestroy();
             }
-            
+
             internal static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
             {
                 if (nodeArch.Tag is not ScriptMemberInfo memberInfo)
                     return false;
-                
+
                 if (!memberInfo.IsStatic)
                 {
                     if (VisjectSurface.FullCastCheck(memberInfo.DeclaringType, outputType, hint))
                         return true;
                 }
-                
+
                 var parameters = memberInfo.GetParameters();
                 bool isPure = (parameters.Length == 0 && !memberInfo.ValueType.IsVoid);
                 if (outputType.IsVoid)
                     return !isPure;
-                
+
                 foreach (var param in parameters)
                 {
-                    if(param.IsOut)
+                    if (param.IsOut)
                         continue;
                     if (VisjectSurface.FullCastCheck(param.Type, outputType, hint))
                         return true;
                 }
                 return false;
             }
-            
+
             internal static bool IsOutputCompatible(NodeArchetype nodeArch, ScriptType inputType, ConnectionsHint hint)
             {
                 if (nodeArch.Tag is not ScriptMemberInfo memberInfo)
                     return false;
                 if (VisjectSurface.FullCastCheck(memberInfo.ValueType, inputType, hint))
                     return true;
-                
+
                 var parameters = memberInfo.GetParameters();
                 bool isPure = (parameters.Length == 0 && !memberInfo.ValueType.IsVoid);
                 if (inputType.IsVoid)
                     return !isPure;
-                
+
                 foreach (var param in memberInfo.GetParameters())
                 {
-                    if(!param.IsOut)
+                    if (!param.IsOut)
                         continue;
                     if (VisjectSurface.FullCastCheck(param.Type, inputType, hint))
                         return true;
@@ -1835,12 +1835,12 @@ namespace FlaxEditor.Surface.Archetypes
 
                 base.OnDestroy();
             }
-            
+
             internal static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
             {
                 return false;
             }
-            
+
             internal static bool IsOutputCompatible(NodeArchetype nodeArch, ScriptType inputType, ConnectionsHint hint)
             {
                 return inputType.IsVoid;
@@ -1981,19 +1981,19 @@ namespace FlaxEditor.Surface.Archetypes
                 Title = "Get " + SurfaceUtils.GetMethodDisplayName((string)Values[1]);
                 UpdateSignature();
             }
-            
+
             internal static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
             {
                 var scriptType = TypeUtils.GetType((string)nodeArch.DefaultValues[0]);
                 if (scriptType == ScriptType.Null)
                     return false;
-                
+
                 var members = scriptType.GetMembers((string)nodeArch.DefaultValues[1], MemberTypes.Field, BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
                 foreach (var member in members)
                 {
                     if (!SurfaceUtils.IsValidVisualScriptField(member))
                         continue;
-                        
+
                     if (member)
                     {
                         if (!member.IsStatic && VisjectSurface.FullCastCheck(scriptType, outputType, hint))
@@ -2007,22 +2007,22 @@ namespace FlaxEditor.Surface.Archetypes
                     }
                     break;
                 }
-                
+
                 return false;
             }
-            
+
             internal static bool IsOutputCompatible(NodeArchetype nodeArch, ScriptType inputType, ConnectionsHint hint)
             {
                 var scriptType = TypeUtils.GetType((string)nodeArch.DefaultValues[0]);
                 if (scriptType == ScriptType.Null)
                     return false;
-                
+
                 var members = scriptType.GetMembers((string)nodeArch.DefaultValues[1], MemberTypes.Field, BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
                 foreach (var member in members)
                 {
                     if (!SurfaceUtils.IsValidVisualScriptField(member))
                         continue;
-                        
+
                     if (member)
                     {
                         if (VisjectSurface.FullCastCheck(member.ValueType, inputType, hint))
@@ -2092,22 +2092,22 @@ namespace FlaxEditor.Surface.Archetypes
                 Title = "Set " + SurfaceUtils.GetMethodDisplayName((string)Values[1]);
                 UpdateSignature();
             }
-            
+
             internal static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
             {
-                if(outputType.IsVoid)
+                if (outputType.IsVoid)
                     return true;
-                
+
                 var scriptType = TypeUtils.GetType((string)nodeArch.DefaultValues[0]);
                 if (scriptType == ScriptType.Null)
                     return false;
-                
+
                 var members = scriptType.GetMembers((string)nodeArch.DefaultValues[1], MemberTypes.Field, BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
                 foreach (var member in members)
                 {
                     if (!SurfaceUtils.IsValidVisualScriptField(member))
                         continue;
-                        
+
                     if (member)
                     {
                         if (VisjectSurface.FullCastCheck(member.ValueType, outputType, hint))
@@ -2126,10 +2126,10 @@ namespace FlaxEditor.Surface.Archetypes
                     }
                     break;
                 }
-                
+
                 return false;
             }
-            
+
             internal static bool IsOutputCompatible(NodeArchetype nodeArch, ScriptType inputType, ConnectionsHint hint)
             {
                 return inputType.IsVoid;
@@ -2352,13 +2352,13 @@ namespace FlaxEditor.Surface.Archetypes
 
                 base.OnDestroy();
             }
-            
+
             internal static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
             {
                 // Event based nodes always have a pulse input, so it's always compatible with void
                 if (outputType.IsVoid)
                     return true;
-                
+
                 var eventName = (string)nodeArch.DefaultValues[1];
                 var eventType = TypeUtils.GetType((string)nodeArch.DefaultValues[0]);
                 var member = eventType.GetMember(eventName, MemberTypes.Event, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
@@ -2372,13 +2372,13 @@ namespace FlaxEditor.Surface.Archetypes
                 }
                 return false;
             }
-            
+
             internal static bool IsOutputCompatible(NodeArchetype nodeArch, ScriptType inputType, ConnectionsHint hint)
             {
                 // Event based nodes always have a pulse output, so it's always compatible with void
                 if (inputType.IsVoid)
                     return true;
-                
+
                 var eventName = (string)nodeArch.DefaultValues[1];
                 var eventType = TypeUtils.GetType((string)nodeArch.DefaultValues[0]);
                 var member = eventType.GetMember(eventName, MemberTypes.Event, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
diff --git a/Source/Editor/Surface/Archetypes/Packing.cs b/Source/Editor/Surface/Archetypes/Packing.cs
index ccabaaa6d..e61b8e0df 100644
--- a/Source/Editor/Surface/Archetypes/Packing.cs
+++ b/Source/Editor/Surface/Archetypes/Packing.cs
@@ -207,13 +207,13 @@ namespace FlaxEditor.Surface.Archetypes
                     AddElement(box);
                 }
             }
-            
+
             protected static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
             {
                 // Event based nodes always have a pulse input, so it's always compatible with void
                 if (outputType.IsVoid)
                     return true;
-                
+
                 var eventName = (string)nodeArch.DefaultValues[1];
                 var eventType = TypeUtils.GetType((string)nodeArch.DefaultValues[0]);
                 var member = eventType.GetMember(eventName, MemberTypes.Event, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
@@ -236,7 +236,7 @@ namespace FlaxEditor.Surface.Archetypes
             : base(id, context, nodeArch, groupArch, false)
             {
             }
-            
+
             internal static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
             {
                 var typeName = (string)nodeArch.DefaultValues[0];
@@ -253,7 +253,7 @@ namespace FlaxEditor.Surface.Archetypes
                 }
                 return false;
             }
-            
+
             internal static bool IsOutputCompatible(NodeArchetype nodeArch, ScriptType inputType, ConnectionsHint hint)
             {
                 var typeName = (string)nodeArch.DefaultValues[0];
@@ -286,7 +286,7 @@ namespace FlaxEditor.Surface.Archetypes
                 }
                 return false;
             }
-            
+
             internal static bool IsOutputCompatible(NodeArchetype nodeArch, ScriptType inputType, ConnectionsHint hint)
             {
                 var typeName = (string)nodeArch.DefaultValues[0];
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCM.cs b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
index 36f71a1a7..342429fc8 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCM.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCM.cs
@@ -164,7 +164,7 @@ namespace FlaxEditor.Surface.ContextMenu
                 HorizontalAlignment = TextAlignment.Far,
                 Font = titleFontReference,
             };
-            
+
             _contextSensitiveToggle = new CheckBox
             {
                 Width = 20,
@@ -174,7 +174,7 @@ namespace FlaxEditor.Surface.ContextMenu
                 Checked = _contextSensitiveSearchEnabled,
             };
             _contextSensitiveToggle.StateChanged += OnContextSensitiveToggleStateChanged;
-            
+
             // Search box
             _searchBox = new SearchBox(false, 2, 22)
             {
@@ -313,7 +313,7 @@ namespace FlaxEditor.Surface.ContextMenu
                         OnSearchFilterChanged();
                     }
                 }
-                else if(_contextSensitiveSearchEnabled)
+                else if (_contextSensitiveSearchEnabled)
                 {
                     group.EvaluateVisibilityWithBox(_selectedBox);
                 }
@@ -350,8 +350,8 @@ namespace FlaxEditor.Surface.ContextMenu
                             Parent = group
                         };
                     }
-                    if(_contextSensitiveSearchEnabled)
-                        group.EvaluateVisibilityWithBox(_selectedBox); 
+                    if (_contextSensitiveSearchEnabled)
+                        group.EvaluateVisibilityWithBox(_selectedBox);
                     group.SortChildren();
                     group.Parent = _groupsPanel;
                     _groups.Add(group);
@@ -459,7 +459,7 @@ namespace FlaxEditor.Surface.ContextMenu
             // Skip events during setup or init stuff
             if (IsLayoutLocked)
                 return;
-            
+
             Profiler.BeginEvent("VisjectCM.OnContextSensitiveToggleStateChanged");
             _contextSensitiveSearchEnabled = checkBox.Checked;
             UpdateFilters();
@@ -551,7 +551,7 @@ namespace FlaxEditor.Surface.ContextMenu
             for (int i = 0; i < _groups.Count; i++)
             {
                 _groups[i].ResetView();
-                if(_contextSensitiveSearchEnabled)
+                if (_contextSensitiveSearchEnabled)
                     _groups[i].EvaluateVisibilityWithBox(_selectedBox);
             }
             UnlockChildrenRecursive();
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
index aab9f3112..fd825cdff 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
@@ -132,7 +132,7 @@ namespace FlaxEditor.Surface.ContextMenu
             }
 
             Profiler.BeginEvent("VisjectCMGroup.EvaluateVisibilityWithBox");
-            
+
             bool isAnyVisible = false;
             for (int i = 0; i < _children.Count; i++)
             {
@@ -142,7 +142,7 @@ namespace FlaxEditor.Surface.ContextMenu
                     isAnyVisible |= item.Visible;
                 }
             }
-            
+
             // Update itself
             if (isAnyVisible)
             {
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index 28a9392b2..b512f6946 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -103,7 +103,7 @@ namespace FlaxEditor.Surface.ContextMenu
         {
             // Is compatible if box is null for reset reasons
             if (startBox == null)
-                return true;   
+                return true;
 
             if (_archetype == null)
                 return false;
@@ -112,7 +112,7 @@ namespace FlaxEditor.Surface.ContextMenu
             if (startBox.IsOutput && _archetype.IsInputCompatible != null)
             {
                 isCompatible |= _archetype.IsInputCompatible.Invoke(_archetype, startBox.CurrentType, _archetype.ConnectionsHints);
-            } 
+            }
             else if (!startBox.IsOutput && _archetype.IsOutputCompatible != null)
             {
                 isCompatible |= _archetype.IsOutputCompatible.Invoke(_archetype, startBox.CurrentType, startBox.ParentNode.Archetype.ConnectionsHints);
@@ -122,23 +122,23 @@ namespace FlaxEditor.Surface.ContextMenu
                 // Check compatibility based on the defined elements in the archetype. This handles all the default groups and items
                 isCompatible = CheckElementsCompatibility(startBox);
             }
-            
+
             return isCompatible;
         }
-        
+
         private bool CheckElementsCompatibility(Box startBox)
         {
             bool isCompatible = false;
             foreach (NodeElementArchetype element in _archetype.Elements)
             {
                 // Ignore all elements that aren't inputs or outputs (e.g. input fields)
-                if(element.Type != NodeElementType.Output && element.Type != NodeElementType.Input)
+                if (element.Type != NodeElementType.Output && element.Type != NodeElementType.Input)
                     continue;
-                
+
                 // Ignore elements with the same direction as the box
                 if ((startBox.IsOutput && element.Type == NodeElementType.Output) || (!startBox.IsOutput && element.Type == NodeElementType.Input))
                     continue;
-                
+
                 ScriptType fromType;
                 ScriptType toType;
                 ConnectionsHint hint;
@@ -154,13 +154,13 @@ namespace FlaxEditor.Surface.ContextMenu
                     toType = element.ConnectionsType;
                     hint = startBox.ParentNode.Archetype.ConnectionsHints;
                 }
-                
+
                 isCompatible |= VisjectSurface.FullCastCheck(fromType, toType, hint);
             }
 
             return isCompatible;
         }
-        
+
         /// <summary>
         /// Updates the filter.
         /// </summary>
@@ -176,7 +176,7 @@ namespace FlaxEditor.Surface.ContextMenu
                     return;
                 }
             }
-            
+
             _isStartsWithMatch = _isFullMatch = false;
             if (string.IsNullOrEmpty(filterText))
             {
@@ -242,7 +242,7 @@ namespace FlaxEditor.Surface.ContextMenu
 
                     Data = data;
                 }
-                else if(!groupHeaderMatches)
+                else if (!groupHeaderMatches)
                 {
                     // Hide
                     _highlights?.Clear();
diff --git a/Source/Editor/Surface/Elements/Box.cs b/Source/Editor/Surface/Elements/Box.cs
index 6a265a21e..a03c8f701 100644
--- a/Source/Editor/Surface/Elements/Box.cs
+++ b/Source/Editor/Surface/Elements/Box.cs
@@ -231,7 +231,7 @@ namespace FlaxEditor.Surface.Elements
             }
 
             // Check using connection hints
-            if(VisjectSurface.IsTypeCompatible(Archetype.ConnectionsType, type, ParentNode.Archetype.ConnectionsHints))
+            if (VisjectSurface.IsTypeCompatible(Archetype.ConnectionsType, type, ParentNode.Archetype.ConnectionsHints))
                 return true;
 
             // Check independent and if there is box with bigger potential because it may block current one from changing type
diff --git a/Source/Editor/Surface/Elements/OutputBox.cs b/Source/Editor/Surface/Elements/OutputBox.cs
index cf78b559c..8ef64ec77 100644
--- a/Source/Editor/Surface/Elements/OutputBox.cs
+++ b/Source/Editor/Surface/Elements/OutputBox.cs
@@ -35,7 +35,7 @@ namespace FlaxEditor.Surface.Elements
         {
             // Calculate control points
             CalculateBezierControlPoints(start, end, out var control1, out var control2);
-            
+
             // Draw line
             Render2D.DrawBezier(start, control1, control2, end, color, thickness);
 
@@ -54,16 +54,16 @@ namespace FlaxEditor.Surface.Elements
             const float maxControlLength = 150f;
             var dst = (end - start).Length;
             var yDst = Mathf.Abs(start.Y - end.Y);
-            
+
             // Calculate control points
             var minControlDst = dst * 0.5f;
             var maxControlDst = Mathf.Max(Mathf.Min(maxControlLength, dst), minControlLength);
             var controlDst = Mathf.Lerp(minControlDst, maxControlDst, Mathf.Clamp(yDst / minControlLength, 0f, 1f));
-            
+
             control1 = new Float2(start.X + controlDst, start.Y);
             control2 = new Float2(end.X - controlDst, end.Y);
         }
-        
+
         /// <summary>
         /// Checks if a point intersects a connection
         /// </summary>
@@ -86,11 +86,13 @@ namespace FlaxEditor.Surface.Elements
         public static bool IntersectsConnection(ref Float2 start, ref Float2 end, ref Float2 point, float distance)
         {
             // Pretty much a point in rectangle check
-            if ((point.X - start.X) * (end.X - point.X) < 0) return false;
+            if ((point.X - start.X) * (end.X - point.X) < 0)
+                return false;
 
             float offset = Mathf.Sign(end.Y - start.Y) * distance;
-            if ((point.Y - (start.Y - offset)) * ((end.Y + offset) - point.Y) < 0) return false;
-            
+            if ((point.Y - (start.Y - offset)) * ((end.Y + offset) - point.Y) < 0)
+                return false;
+
             float squaredDistance = distance;
             CalculateBezierControlPoints(start, end, out var control1, out var control2);
 
diff --git a/Source/Editor/Surface/NodeArchetype.cs b/Source/Editor/Surface/NodeArchetype.cs
index e2a9c84fa..fe54268e2 100644
--- a/Source/Editor/Surface/NodeArchetype.cs
+++ b/Source/Editor/Surface/NodeArchetype.cs
@@ -93,7 +93,7 @@ namespace FlaxEditor.Surface
         /// Checks if the given type is compatible with the given node archetype. Used for custom nodes
         /// </summary>
         public delegate bool IsCompatible(NodeArchetype nodeArch, ScriptType portType, ConnectionsHint hint);
-        
+
         /// <summary>
         /// Unique node type ID within a single group.
         /// </summary>
@@ -108,12 +108,12 @@ namespace FlaxEditor.Surface
         /// Function for asynchronously loaded nodes to check if input ports are compatible, for filtering.
         /// </summary>
         public IsCompatible IsInputCompatible;
-        
+
         /// <summary>
         /// Function for asynchronously loaded nodes to check if output ports are compatible, for filtering.
         /// </summary>
         public IsCompatible IsOutputCompatible;
-        
+
         /// <summary>
         /// Default initial size of the node.
         /// </summary>
diff --git a/Source/Editor/Surface/SurfaceUtils.cs b/Source/Editor/Surface/SurfaceUtils.cs
index 08b9c6d63..5f4c3ef07 100644
--- a/Source/Editor/Surface/SurfaceUtils.cs
+++ b/Source/Editor/Surface/SurfaceUtils.cs
@@ -406,8 +406,8 @@ namespace FlaxEditor.Surface
 
         internal static bool IsValidVisualScriptType(ScriptType scriptType)
         {
-            if (!scriptType.IsPublic || 
-                scriptType.HasAttribute(typeof(HideInEditorAttribute), true) || 
+            if (!scriptType.IsPublic ||
+                scriptType.HasAttribute(typeof(HideInEditorAttribute), true) ||
                 scriptType.HasAttribute(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute), false))
                 return false;
             if (scriptType.IsGenericType)
diff --git a/Source/Editor/Surface/VisjectSurface.Connecting.cs b/Source/Editor/Surface/VisjectSurface.Connecting.cs
index 145bdfedf..dd34f9c7c 100644
--- a/Source/Editor/Surface/VisjectSurface.Connecting.cs
+++ b/Source/Editor/Surface/VisjectSurface.Connecting.cs
@@ -212,12 +212,12 @@ namespace FlaxEditor.Surface
             // Yes, from and to are switched on purpose
             if (CanUseDirectCastStatic(to, from, false))
                 return true;
-            if(IsTypeCompatible(from, to, hint))
+            if (IsTypeCompatible(from, to, hint))
                 return true;
             // Same here
             return to.CanCastTo(from);
         }
-        
+
         /// <summary>
         /// Checks if can use direct conversion from one type to another.
         /// </summary>

From d1c0900ad7c5d3b85c9b9872fa470987543ebb7a Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Wed, 4 Oct 2023 22:38:06 +0200
Subject: [PATCH 099/103] Fix potential error when loading Guid from Json

---
 Source/Engine/Serialization/JsonTools.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Source/Engine/Serialization/JsonTools.cpp b/Source/Engine/Serialization/JsonTools.cpp
index 07a577033..c395df4f1 100644
--- a/Source/Engine/Serialization/JsonTools.cpp
+++ b/Source/Engine/Serialization/JsonTools.cpp
@@ -256,7 +256,7 @@ BoundingBox JsonTools::GetBoundingBox(const Value& value)
 
 Guid JsonTools::GetGuid(const Value& value)
 {
-    if (value.IsNull())
+    if (!value.IsString())
         return Guid::Empty;
     CHECK_RETURN(value.GetStringLength() == 32, Guid::Empty);
 

From b586b5fe4154a24eabab5f53b8e9987d0c47549a Mon Sep 17 00:00:00 2001
From: Chandler Cox <mr.chandlercox@gmail.com>
Date: Wed, 4 Oct 2023 15:57:28 -0500
Subject: [PATCH 100/103] Ensure editor font is sent as something.

---
 Source/Editor/Options/InterfaceOptions.cs | 75 +++++++++++++++++++++--
 1 file changed, 70 insertions(+), 5 deletions(-)

diff --git a/Source/Editor/Options/InterfaceOptions.cs b/Source/Editor/Options/InterfaceOptions.cs
index 5fd8c31c7..a028d47f9 100644
--- a/Source/Editor/Options/InterfaceOptions.cs
+++ b/Source/Editor/Options/InterfaceOptions.cs
@@ -166,7 +166,19 @@ namespace FlaxEditor.Options
         /// Gets or sets the output log text font.
         /// </summary>
         [EditorDisplay("Output Log", "Text Font"), EditorOrder(320), Tooltip("The output log text font.")]
-        public FontReference OutputLogTextFont { get; set; } = new FontReference(FlaxEngine.Content.LoadAsyncInternal<FontAsset>(EditorAssets.InconsolataRegularFont), 10);
+        public FontReference OutputLogTextFont
+        {
+            get => _outputLogFont;
+            set
+            {
+                if (value == null)
+                    _outputLogFont = new FontReference(FlaxEngine.Content.LoadAsyncInternal<FontAsset>(EditorAssets.InconsolataRegularFont), 10);
+                else if (!value.Font)
+                    _outputLogFont.Font = FlaxEngine.Content.LoadAsyncInternal<FontAsset>(EditorAssets.InconsolataRegularFont);
+                else
+                    _outputLogFont = value;
+            }
+        }
 
         /// <summary>
         /// Gets or sets the output log text color.
@@ -225,29 +237,82 @@ namespace FlaxEditor.Options
         public int NumberOfGameClientsToLaunch = 1;
 
         private static FontAsset DefaultFont => FlaxEngine.Content.LoadAsyncInternal<FontAsset>(EditorAssets.PrimaryFont);
+        private FontReference _titleFont = new FontReference(DefaultFont, 18);
+        private FontReference _largeFont = new FontReference(DefaultFont, 14);
+        private FontReference _mediumFont = new FontReference(DefaultFont, 9);
+        private FontReference _smallFont= new FontReference(DefaultFont, 9);
+        private FontReference _outputLogFont = new FontReference(FlaxEngine.Content.LoadAsyncInternal<FontAsset>(EditorAssets.InconsolataRegularFont), 10);
 
         /// <summary>
         /// Gets or sets the title font for editor UI.
         /// </summary>
         [EditorDisplay("Fonts"), EditorOrder(600), Tooltip("The title font for editor UI.")]
-        public FontReference TitleFont { get; set; } = new FontReference(DefaultFont, 18);
+        public FontReference TitleFont
+        {
+            get => _titleFont;
+            set
+            {
+                if (value == null)
+                    _titleFont = new FontReference(DefaultFont, 18);
+                else if (!value.Font)
+                    _titleFont.Font = DefaultFont;
+                else
+                    _titleFont = value;
+            }
+        }
 
         /// <summary>
         /// Gets or sets the large font for editor UI.
         /// </summary>
         [EditorDisplay("Fonts"), EditorOrder(610), Tooltip("The large font for editor UI.")]
-        public FontReference LargeFont { get; set; } = new FontReference(DefaultFont, 14);
+        public FontReference LargeFont
+        {
+            get => _largeFont;
+            set
+            {
+                if (value == null)
+                    _largeFont = new FontReference(DefaultFont, 14);
+                else if (!value.Font)
+                    _largeFont.Font = DefaultFont;
+                else
+                    _largeFont = value;
+            }
+        }
 
         /// <summary>
         /// Gets or sets the medium font for editor UI.
         /// </summary>
         [EditorDisplay("Fonts"), EditorOrder(620), Tooltip("The medium font for editor UI.")]
-        public FontReference MediumFont { get; set; } = new FontReference(DefaultFont, 9);
+        public FontReference MediumFont
+        {
+            get => _mediumFont;
+            set
+            {
+                if (value == null)
+                    _mediumFont = new FontReference(DefaultFont, 9);
+                else if (!value.Font)
+                    _mediumFont.Font = DefaultFont;
+                else
+                    _mediumFont = value;
+            }
+        }
 
         /// <summary>
         /// Gets or sets the small font for editor UI.
         /// </summary>
         [EditorDisplay("Fonts"), EditorOrder(630), Tooltip("The small font for editor UI.")]
-        public FontReference SmallFont { get; set; } = new FontReference(DefaultFont, 9);
+        public FontReference SmallFont
+        {
+            get => _smallFont;
+            set
+            {
+                if (value == null)
+                    _smallFont = new FontReference(DefaultFont, 9);
+                else if (!value.Font)
+                    _smallFont.Font = DefaultFont;
+                else
+                    _smallFont = value;
+            }
+        }
     }
 }

From fd679f0af59eb73244c39cb69107faf93b9358b9 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Wed, 4 Oct 2023 23:11:38 +0200
Subject: [PATCH 101/103] Add automatic game settings apply when saving json
 file in Editor

#1440
---
 Source/Engine/Content/JsonAsset.cpp | 12 ++++++++++--
 Source/Engine/Content/JsonAsset.h   |  1 +
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/Source/Engine/Content/JsonAsset.cpp b/Source/Engine/Content/JsonAsset.cpp
index 1fbc2abed..b48ef02e5 100644
--- a/Source/Engine/Content/JsonAsset.cpp
+++ b/Source/Engine/Content/JsonAsset.cpp
@@ -12,6 +12,7 @@
 #include "FlaxEngine.Gen.h"
 #include "Cache/AssetsCache.h"
 #include "Engine/Core/Log.h"
+#include "Engine/Core/Config/Settings.h"
 #include "Engine/Serialization/JsonTools.h"
 #include "Engine/Serialization/JsonWriters.h"
 #include "Engine/Content/Factories/JsonAssetFactory.h"
@@ -126,8 +127,7 @@ void FindIds(ISerializable::DeserializeStream& node, Array<Guid>& output)
     }
     else if (node.IsString())
     {
-        const auto length = node.GetStringLength();
-        if (length == 32)
+        if (node.GetStringLength() == 32)
         {
             // Try parse as Guid in format `N` (32 hex chars)
             Guid id;
@@ -362,6 +362,7 @@ void JsonAsset::unload(bool isReloading)
 #endif
     Scripting::ScriptsUnload.Unbind<JsonAsset, &JsonAsset::DeleteInstance>(this);
     DeleteInstance();
+    _isAfterReload |= isReloading;
 
     JsonAssetBase::unload(isReloading);
 }
@@ -408,6 +409,13 @@ bool JsonAsset::CreateInstance()
         }
     }
 
+    // Special case for Settings assets to flush them after edited and saved in Editor
+    if (typeHandle && typeHandle.IsSubclassOf(SettingsBase::TypeInitializer) && _isAfterReload)
+    {
+        _isAfterReload = false;
+        ((SettingsBase*)Instance)->Apply();
+    }
+
     return false;
 }
 
diff --git a/Source/Engine/Content/JsonAsset.h b/Source/Engine/Content/JsonAsset.h
index c53649d33..0b6e3ca86 100644
--- a/Source/Engine/Content/JsonAsset.h
+++ b/Source/Engine/Content/JsonAsset.h
@@ -118,6 +118,7 @@ API_CLASS(NoSpawn) class FLAXENGINE_API JsonAsset : public JsonAssetBase
     DECLARE_ASSET_HEADER(JsonAsset);
 private:
     ScriptingType::Dtor _dtor;
+    bool _isAfterReload = false;
 
 public:
     /// <summary>

From 1838c7bba7ce7f45697ca49c47b925ac317dd930 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Wed, 4 Oct 2023 23:21:40 +0200
Subject: [PATCH 102/103] Minor cleanup

---
 Source/Editor/Content/Items/ContentItem.cs    | 18 ++++++++---------
 .../Dedicated/MissingScriptEditor.cs          |  2 +-
 .../CustomEditors/Dedicated/SplineEditor.cs   |  2 +-
 .../Editors/ActorTransformEditor.cs           |  2 +-
 .../Editors/ObjectSwitcherEditor.cs           |  1 -
 .../Editor/CustomEditors/Editors/TagEditor.cs |  2 +-
 .../CustomEditors/GUI/PropertiesList.cs       |  2 +-
 Source/Editor/Options/GeneralOptions.cs       |  4 ++--
 Source/Editor/Options/InterfaceOptions.cs     |  2 +-
 Source/Editor/Surface/Archetypes/Packing.cs   | 20 -------------------
 .../Surface/ContextMenu/VisjectCMGroup.cs     |  3 ++-
 .../Surface/ContextMenu/VisjectCMItem.cs      |  3 ++-
 12 files changed, 21 insertions(+), 40 deletions(-)

diff --git a/Source/Editor/Content/Items/ContentItem.cs b/Source/Editor/Content/Items/ContentItem.cs
index 94db3a5b9..6bbdc0a51 100644
--- a/Source/Editor/Content/Items/ContentItem.cs
+++ b/Source/Editor/Content/Items/ContentItem.cs
@@ -486,7 +486,7 @@ namespace FlaxEditor.Content
             else
                 Render2D.FillRectangle(rectangle, Color.Black);
         }
-        
+
         /// <summary>
         /// Draws the item thumbnail.
         /// </summary>
@@ -684,7 +684,7 @@ namespace FlaxEditor.Content
                 var thumbnailSize = size.X;
                 thumbnailRect = new Rectangle(0, 0, thumbnailSize, thumbnailSize);
                 nameAlignment = TextAlignment.Center;
-                
+
                 if (this is ContentFolder)
                 {
                     // Small shadow
@@ -692,7 +692,7 @@ namespace FlaxEditor.Content
                     var color = Color.Black.AlphaMultiplied(0.2f);
                     Render2D.FillRectangle(shadowRect, color);
                     Render2D.FillRectangle(clientRect, style.Background.RGBMultiplied(1.25f));
-                    
+
                     if (isSelected)
                         Render2D.FillRectangle(clientRect, Parent.ContainsFocus ? style.BackgroundSelected : style.LightBackground);
                     else if (IsMouseOver)
@@ -706,14 +706,14 @@ namespace FlaxEditor.Content
                     var shadowRect = new Rectangle(2, 2, clientRect.Width + 1, clientRect.Height + 1);
                     var color = Color.Black.AlphaMultiplied(0.2f);
                     Render2D.FillRectangle(shadowRect, color);
-                    
+
                     Render2D.FillRectangle(clientRect, style.Background.RGBMultiplied(1.25f));
                     Render2D.FillRectangle(TextRectangle, style.LightBackground);
-                    
+
                     var accentHeight = 2 * view.ViewScale;
                     var barRect = new Rectangle(0, thumbnailRect.Height - accentHeight, clientRect.Width, accentHeight);
                     Render2D.FillRectangle(barRect, Color.DimGray);
-                    
+
                     DrawThumbnail(ref thumbnailRect, false);
                     if (isSelected)
                     {
@@ -733,18 +733,18 @@ namespace FlaxEditor.Content
                 var thumbnailSize = size.Y - 2 * DefaultMarginSize;
                 thumbnailRect = new Rectangle(DefaultMarginSize, DefaultMarginSize, thumbnailSize, thumbnailSize);
                 nameAlignment = TextAlignment.Near;
-                
+
                 if (isSelected)
                     Render2D.FillRectangle(clientRect, Parent.ContainsFocus ? style.BackgroundSelected : style.LightBackground);
                 else if (IsMouseOver)
                     Render2D.FillRectangle(clientRect, style.BackgroundHighlighted);
-                
+
                 DrawThumbnail(ref thumbnailRect);
                 break;
             }
             default: throw new ArgumentOutOfRangeException();
             }
-            
+
             // Draw short name
             Render2D.PushClip(ref textRect);
             Render2D.DrawText(style.FontMedium, ShowFileExtension || view.ShowFileExtensions ? FileName : ShortName, textRect, style.Foreground, nameAlignment, TextAlignment.Center, TextWrapping.WrapWords, 1f, 0.95f);
diff --git a/Source/Editor/CustomEditors/Dedicated/MissingScriptEditor.cs b/Source/Editor/CustomEditors/Dedicated/MissingScriptEditor.cs
index 03d5ddd55..a6c4e6623 100644
--- a/Source/Editor/CustomEditors/Dedicated/MissingScriptEditor.cs
+++ b/Source/Editor/CustomEditors/Dedicated/MissingScriptEditor.cs
@@ -20,7 +20,7 @@ public class MissingScriptEditor : GenericEditor
         }
 
         dropPanel.HeaderTextColor = Color.OrangeRed;
-        
+
         base.Initialize(layout);
     }
 }
diff --git a/Source/Editor/CustomEditors/Dedicated/SplineEditor.cs b/Source/Editor/CustomEditors/Dedicated/SplineEditor.cs
index 03d58ef33..7b9b65c5c 100644
--- a/Source/Editor/CustomEditors/Dedicated/SplineEditor.cs
+++ b/Source/Editor/CustomEditors/Dedicated/SplineEditor.cs
@@ -348,7 +348,7 @@ namespace FlaxEditor.CustomEditors.Dedicated
 
             if (!CanEditTangent())
                 return;
-            
+
             var index = _lastPointSelected.Index;
             var currentTangentInPosition = _selectedSpline.GetSplineLocalTangent(index, true).Translation;
             var currentTangentOutPosition = _selectedSpline.GetSplineLocalTangent(index, false).Translation;
diff --git a/Source/Editor/CustomEditors/Editors/ActorTransformEditor.cs b/Source/Editor/CustomEditors/Editors/ActorTransformEditor.cs
index 4aa02ac78..4c153e759 100644
--- a/Source/Editor/CustomEditors/Editors/ActorTransformEditor.cs
+++ b/Source/Editor/CustomEditors/Editors/ActorTransformEditor.cs
@@ -88,7 +88,7 @@ namespace FlaxEditor.CustomEditors.Editors
                 LinkValues = Editor.Instance.Windows.PropertiesWin.ScaleLinked;
 
                 // Add button with the link icon
-                
+
                 _linkButton = new Button
                 {
                     BackgroundBrush = new SpriteBrush(Editor.Instance.Icons.Link32),
diff --git a/Source/Editor/CustomEditors/Editors/ObjectSwitcherEditor.cs b/Source/Editor/CustomEditors/Editors/ObjectSwitcherEditor.cs
index 4d0c0f662..2ef993e75 100644
--- a/Source/Editor/CustomEditors/Editors/ObjectSwitcherEditor.cs
+++ b/Source/Editor/CustomEditors/Editors/ObjectSwitcherEditor.cs
@@ -160,7 +160,6 @@ namespace FlaxEditor.CustomEditors.Editors
                 var option = _options[comboBox.SelectedIndex];
                 if (option.Type != null)
                     value = option.Creator(option.Type);
-
             }
             SetValue(value);
             RebuildLayoutOnRefresh();
diff --git a/Source/Editor/CustomEditors/Editors/TagEditor.cs b/Source/Editor/CustomEditors/Editors/TagEditor.cs
index 911397785..dbd5d124c 100644
--- a/Source/Editor/CustomEditors/Editors/TagEditor.cs
+++ b/Source/Editor/CustomEditors/Editors/TagEditor.cs
@@ -634,7 +634,7 @@ namespace FlaxEditor.CustomEditors.Editors
             var textSize = FlaxEngine.GUI.Style.Current.FontMedium.MeasureText(buttonText);
             if (textSize.Y > button.Width)
                 button.Width = textSize.Y + 2;
-            
+
             button.SetAnchorPreset(AnchorPresets.MiddleRight, false, true);
             button.Clicked += ShowPicker;
         }
diff --git a/Source/Editor/CustomEditors/GUI/PropertiesList.cs b/Source/Editor/CustomEditors/GUI/PropertiesList.cs
index 2b2f0a3d3..93aacbd34 100644
--- a/Source/Editor/CustomEditors/GUI/PropertiesList.cs
+++ b/Source/Editor/CustomEditors/GUI/PropertiesList.cs
@@ -175,7 +175,7 @@ namespace FlaxEditor.CustomEditors.GUI
         {
             // Clear flag
             _mouseOverSplitter = false;
-            
+
             if (_cursorChanged)
             {
                 Cursor = CursorType.Default;
diff --git a/Source/Editor/Options/GeneralOptions.cs b/Source/Editor/Options/GeneralOptions.cs
index 63822a7ca..33124bab0 100644
--- a/Source/Editor/Options/GeneralOptions.cs
+++ b/Source/Editor/Options/GeneralOptions.cs
@@ -106,7 +106,7 @@ namespace FlaxEditor.Options
         [DefaultValue(60.0f), Limit(0, 666)]
         [EditorDisplay("General", "Editor FPS"), EditorOrder(110), Tooltip("Limit for the editor draw/update frames per second rate (FPS). Use higher values if you need more responsive interface or lower values to use less device power. Value 0 disables any limits.")]
         public float EditorFPS { get; set; } = 60.0f;
-        
+
         /// <summary>
         /// Gets or sets The FPS of the editor when the editor window is not focused. Usually set to lower then the editor FPS.
         /// </summary>
@@ -203,7 +203,7 @@ namespace FlaxEditor.Options
         [DefaultValue(5), Limit(1)]
         [EditorDisplay("Auto Save", "Auto Save Frequency"), EditorOrder(801), Tooltip("The interval between auto saves (in minutes)")]
         public int AutoSaveFrequency { get; set; } = 5;
-        
+
         /// <summary>
         /// Gets or sets a value indicating the time before the auto save that the popup shows (in seconds).
         /// </summary>
diff --git a/Source/Editor/Options/InterfaceOptions.cs b/Source/Editor/Options/InterfaceOptions.cs
index a028d47f9..95a273f19 100644
--- a/Source/Editor/Options/InterfaceOptions.cs
+++ b/Source/Editor/Options/InterfaceOptions.cs
@@ -240,7 +240,7 @@ namespace FlaxEditor.Options
         private FontReference _titleFont = new FontReference(DefaultFont, 18);
         private FontReference _largeFont = new FontReference(DefaultFont, 14);
         private FontReference _mediumFont = new FontReference(DefaultFont, 9);
-        private FontReference _smallFont= new FontReference(DefaultFont, 9);
+        private FontReference _smallFont = new FontReference(DefaultFont, 9);
         private FontReference _outputLogFont = new FontReference(FlaxEngine.Content.LoadAsyncInternal<FontAsset>(EditorAssets.InconsolataRegularFont), 10);
 
         /// <summary>
diff --git a/Source/Editor/Surface/Archetypes/Packing.cs b/Source/Editor/Surface/Archetypes/Packing.cs
index e61b8e0df..6b9e72e7e 100644
--- a/Source/Editor/Surface/Archetypes/Packing.cs
+++ b/Source/Editor/Surface/Archetypes/Packing.cs
@@ -207,26 +207,6 @@ namespace FlaxEditor.Surface.Archetypes
                     AddElement(box);
                 }
             }
-
-            protected static bool IsInputCompatible(NodeArchetype nodeArch, ScriptType outputType, ConnectionsHint hint)
-            {
-                // Event based nodes always have a pulse input, so it's always compatible with void
-                if (outputType.IsVoid)
-                    return true;
-
-                var eventName = (string)nodeArch.DefaultValues[1];
-                var eventType = TypeUtils.GetType((string)nodeArch.DefaultValues[0]);
-                var member = eventType.GetMember(eventName, MemberTypes.Event, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
-                if (member && SurfaceUtils.IsValidVisualScriptEvent(member))
-                {
-                    if (!member.IsStatic)
-                    {
-                        if (VisjectSurface.FullCastCheck(eventType, outputType, hint))
-                            return true;
-                    }
-                }
-                return false;
-            }
         }
 
         private sealed class PackStructureNode : StructureNode
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
index fd825cdff..e52e10482 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMGroup.cs
@@ -84,6 +84,7 @@ namespace FlaxEditor.Surface.ContextMenu
         /// Updates the filter.
         /// </summary>
         /// <param name="filterText">The filter text.</param>
+        /// <param name="selectedBox">The optionally selected box to show hints for it.</param>
         public void UpdateFilter(string filterText, Box selectedBox)
         {
             Profiler.BeginEvent("VisjectCMGroup.UpdateFilter");
@@ -116,7 +117,7 @@ namespace FlaxEditor.Surface.ContextMenu
             Profiler.EndEvent();
         }
 
-        public void EvaluateVisibilityWithBox(Box selectedBox)
+        internal void EvaluateVisibilityWithBox(Box selectedBox)
         {
             if (selectedBox == null)
             {
diff --git a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
index b512f6946..7fd583202 100644
--- a/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
+++ b/Source/Editor/Surface/ContextMenu/VisjectCMItem.cs
@@ -8,7 +8,6 @@ using FlaxEditor.Surface.Elements;
 using FlaxEditor.Utilities;
 using FlaxEngine;
 using FlaxEngine.GUI;
-using FlaxEngine.Utilities;
 
 namespace FlaxEditor.Surface.ContextMenu
 {
@@ -165,6 +164,8 @@ namespace FlaxEditor.Surface.ContextMenu
         /// Updates the filter.
         /// </summary>
         /// <param name="filterText">The filter text.</param>
+        /// <param name="selectedBox">The optionally selected box to show hints for it.</param>
+        /// <param name="groupHeaderMatches">True if item's group header got a filter match and item should stay visible.</param>
         public void UpdateFilter(string filterText, Box selectedBox, bool groupHeaderMatches = false)
         {
             if (selectedBox != null)

From 86d1d298206697b80ef83bd75eb93faf2762e2de Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Thu, 5 Oct 2023 10:13:49 +0200
Subject: [PATCH 103/103] Fix deadlock regression from
 fd679f0af59eb73244c39cb69107faf93b9358b9 when applying Game Settings itself

---
 Source/Engine/Content/Asset.h       |  2 +-
 Source/Engine/Content/JsonAsset.cpp | 21 ++++++++++++++-------
 Source/Engine/Content/JsonAsset.h   |  1 +
 3 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/Source/Engine/Content/Asset.h b/Source/Engine/Content/Asset.h
index 2d2ba4b3f..be188b2b9 100644
--- a/Source/Engine/Content/Asset.h
+++ b/Source/Engine/Content/Asset.h
@@ -227,7 +227,7 @@ protected:
 
     bool onLoad(LoadAssetTask* task);
     void onLoaded();
-    void onLoaded_MainThread();
+    virtual void onLoaded_MainThread();
     virtual void onUnload_MainThread();
 #if USE_EDITOR
     virtual void onRename(const StringView& newPath) = 0;
diff --git a/Source/Engine/Content/JsonAsset.cpp b/Source/Engine/Content/JsonAsset.cpp
index b48ef02e5..9977a28e1 100644
--- a/Source/Engine/Content/JsonAsset.cpp
+++ b/Source/Engine/Content/JsonAsset.cpp
@@ -367,6 +367,20 @@ void JsonAsset::unload(bool isReloading)
     JsonAssetBase::unload(isReloading);
 }
 
+void JsonAsset::onLoaded_MainThread()
+{
+    JsonAssetBase::onLoaded_MainThread();
+
+    // Special case for Settings assets to flush them after edited and saved in Editor
+    const StringAsANSI<> dataTypeNameAnsi(DataTypeName.Get(), DataTypeName.Length());
+    const auto typeHandle = Scripting::FindScriptingType(StringAnsiView(dataTypeNameAnsi.Get(), DataTypeName.Length()));
+    if (Instance && typeHandle && typeHandle.IsSubclassOf(SettingsBase::TypeInitializer) && _isAfterReload)
+    {
+        _isAfterReload = false;
+        ((SettingsBase*)Instance)->Apply();
+    }
+}
+
 bool JsonAsset::CreateInstance()
 {
     ScopeLock lock(Locker);
@@ -409,13 +423,6 @@ bool JsonAsset::CreateInstance()
         }
     }
 
-    // Special case for Settings assets to flush them after edited and saved in Editor
-    if (typeHandle && typeHandle.IsSubclassOf(SettingsBase::TypeInitializer) && _isAfterReload)
-    {
-        _isAfterReload = false;
-        ((SettingsBase*)Instance)->Apply();
-    }
-
     return false;
 }
 
diff --git a/Source/Engine/Content/JsonAsset.h b/Source/Engine/Content/JsonAsset.h
index 0b6e3ca86..a8e89cec0 100644
--- a/Source/Engine/Content/JsonAsset.h
+++ b/Source/Engine/Content/JsonAsset.h
@@ -150,6 +150,7 @@ protected:
     // [JsonAssetBase]
     LoadResult loadAsset() override;
     void unload(bool isReloading) override;
+    void onLoaded_MainThread() override;
 
 private:
     bool CreateInstance();