_rider improvement

Flax.flaxproj

@@ -4,7 +4,7 @@
     "Major": 1,
     "Minor": 11,
     "Revision": 0,
-    "Build": 6801
+    "Build": 6802
   },
   "Company": "Flax",
   "Copyright": "Copyright (c) 2012-2025 Wojciech Figat. All rights reserved.",

Source/Editor/Content/Proxy/AssetProxy.cs

@@ -130,6 +130,11 @@ namespace FlaxEditor.Content
             eyeAdaptation.Mode = EyeAdaptationMode.None;
             eyeAdaptation.OverrideFlags |= EyeAdaptationSettingsOverride.Mode;
             preview.PostFxVolume.EyeAdaptation = eyeAdaptation;
+
+            var antiAliasing = preview.PostFxVolume.AntiAliasing;
+            antiAliasing.Mode = AntialiasingMode.FastApproximateAntialiasing;
+            antiAliasing.OverrideFlags |= AntiAliasingSettingsOverride.Mode;
+            preview.PostFxVolume.AntiAliasing = antiAliasing;
         }
     }
 }

Source/Editor/Modules/SourceCodeEditing/DefaultSourceCodeEditor.cs

@@ -40,10 +40,11 @@ namespace FlaxEditor.Modules.SourceCodeEditing
             var codeEditing = Editor.Instance.CodeEditing;
             var vsCode = codeEditing.GetInBuildEditor(CodeEditorTypes.VSCode);
             var rider = codeEditing.GetInBuildEditor(CodeEditorTypes.Rider);
+            var zed = codeEditing.GetInBuildEditor(CodeEditorTypes.Zed);
 
 #if PLATFORM_WINDOW
             // Favor the newest Visual Studio
-            for (int i = (int)CodeEditorTypes.VS2019; i >= (int)CodeEditorTypes.VS2008; i--)
+            for (int i = (int)CodeEditorTypes.VS2026; i >= (int)CodeEditorTypes.VS2008; i--)
             {
                 var visualStudio = codeEditing.GetInBuildEditor((CodeEditorTypes)i);
                 if (visualStudio != null)
@@ -66,6 +67,8 @@ namespace FlaxEditor.Modules.SourceCodeEditing
                 _currentEditor = vsCode;
             else if (rider != null)
                 _currentEditor = rider;
+            else if (zed != null)
+                _currentEditor = zed;
             else
                 _currentEditor = codeEditing.GetInBuildEditor(CodeEditorTypes.SystemDefault);
         }

Source/Editor/Modules/SourceCodeEditing/InBuildSourceCodeEditor.cs

@@ -66,6 +66,9 @@ namespace FlaxEditor.Modules.SourceCodeEditing
             case CodeEditorTypes.Rider:
                 Name = "Rider";
                 break;
+            case CodeEditorTypes.Zed:
+                Name = "Zed";
+                break;
             default: throw new ArgumentOutOfRangeException(nameof(type), type, null);
             }
         }
@@ -83,6 +86,7 @@ namespace FlaxEditor.Modules.SourceCodeEditing
                 case CodeEditorTypes.VSCodeInsiders:
                 case CodeEditorTypes.VSCode: return "-vscode -vs2022";
                 case CodeEditorTypes.Rider: return "-vs2022";
+                case CodeEditorTypes.Zed: return "-vs2022";
                 default: return null;
                 }
             }

Source/Editor/Scripting/CodeEditor.cpp

@@ -6,6 +6,7 @@
 #include "ScriptsBuilder.h"
 #include "CodeEditors/VisualStudioCodeEditor.h"
 #include "CodeEditors/RiderCodeEditor.h"
+#include "CodeEditors/ZedEditor.h"
 #if USE_VISUAL_STUDIO_DTE
 #include "CodeEditors/VisualStudio/VisualStudioEditor.h"
 #endif
@@ -241,6 +242,7 @@ bool CodeEditingManagerService::Init()
 #endif
     VisualStudioCodeEditor::FindEditors(&CodeEditors);
     RiderCodeEditor::FindEditors(&CodeEditors);
+    ZedEditor::FindEditors(&CodeEditors);
     CodeEditors.Add(New<SystemDefaultCodeEditor>());
 
     return false;

Source/Editor/Scripting/CodeEditor.h

@@ -77,6 +77,11 @@ API_ENUM(Namespace="FlaxEditor", Attributes="HideInEditor") enum class CodeEdito
     /// </summary>
     VSCodeInsiders,
 
+    /// <summary>
+    /// Zed
+    /// </summary>
+    Zed,
+
     /// <summary>
     /// Rider
     /// </summary>

Source/Editor/Scripting/CodeEditors/RiderCodeEditor.cpp

@@ -14,6 +14,9 @@
 
 #if PLATFORM_WINDOWS
 #include "Engine/Platform/Win32/IncludeWindowsHeaders.h"
+#elif PLATFORM_MAC
+#include "Engine/Platform/Apple/AppleUtils.h"
+#include <AppKit/AppKit.h>
 #endif
 
 namespace
@@ -218,6 +221,15 @@ void RiderCodeEditor::FindEditors(Array<CodeEditor*>* output)
 #endif
 
 #if PLATFORM_MAC
+    // System installed app
+    NSURL* AppURL = [[NSWorkspace sharedWorkspace]URLForApplicationWithBundleIdentifier:@"com.jetbrains.rider"];
+    if (AppURL != nullptr)
+    {
+        const String path = AppleUtils::ToString((CFStringRef)[AppURL path]);
+        SearchDirectory(&installations, path / TEXT("/Contents/Resources"));
+    }
+
+    // JetBrains Toolbox installations
     String applicationSupportFolder;
     FileSystem::GetSpecialFolderPath(SpecialFolder::ProgramData, applicationSupportFolder);
 
@@ -232,6 +244,7 @@ void RiderCodeEditor::FindEditors(Array<CodeEditor*>* output)
 
     // Check the local installer version
     SearchDirectory(&installations, TEXT("/Applications/Rider.app/Contents/Resources"));
+    SearchDirectory(&installations, TEXT("/Applications/Rider EAP.app/Contents/Resources"));
 #endif
 
     for (const String& directory : subDirectories)

Source/Editor/Scripting/CodeEditors/ZedEditor.cpp

@@ -0,0 +1,180 @@
+// Copyright (c) Wojciech Figat. All rights reserved.
+
+#include "ZedEditor.h"
+#include "Engine/Platform/FileSystem.h"
+#include "Engine/Platform/CreateProcessSettings.h"
+#include "Engine/Core/Log.h"
+#include "Editor/Editor.h"
+#include "Editor/ProjectInfo.h"
+#include "Editor/Scripting/ScriptsBuilder.h"
+#include "Engine/Engine/Globals.h"
+#if PLATFORM_LINUX
+#include <stdio.h>
+#elif PLATFORM_WINDOWS
+#include "Engine/Platform/Win32/IncludeWindowsHeaders.h"
+#elif PLATFORM_MAC
+#include "Engine/Platform/Apple/AppleUtils.h"
+#include <AppKit/AppKit.h>
+#endif
+
+ZedEditor::ZedEditor(const String& execPath)
+    : _execPath(execPath)
+    , _workspacePath(Globals::ProjectFolder)
+{
+}
+
+void ZedEditor::FindEditors(Array<CodeEditor*>* output)
+{
+#if PLATFORM_WINDOWS
+    String cmd;
+    if (Platform::ReadRegValue(HKEY_CURRENT_USER, TEXT("SOFTWARE\\Classes\\Applications\\Zed.exe\\shell\\open\\command"), TEXT(""), &cmd) || cmd.IsEmpty())
+    {
+        if (Platform::ReadRegValue(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\Classes\\Applications\\Zed.exe\\shell\\open\\command"), TEXT(""), &cmd) || cmd.IsEmpty())
+        {
+            // No hits in registry, try default path instead
+        }
+    }
+    String path;
+    if (cmd.IsEmpty())
+    {
+        path = cmd.Substring(1, cmd.Length() - String(TEXT("\" \"%1\"")).Length() - 1);
+    }
+    else
+    {
+        String localAppDataPath;
+        FileSystem::GetSpecialFolderPath(SpecialFolder::LocalAppData, localAppDataPath);
+        path = localAppDataPath / TEXT("Programs/Zed/Zed.exe");
+    }
+    if (FileSystem::FileExists(path))
+    {
+        output->Add(New<ZedEditor>(path));
+    }
+#elif PLATFORM_LINUX
+    char buffer[128];
+    FILE* pipe = popen("/bin/bash -c \"type -p zed\"", "r");
+    if (pipe)
+    {
+        StringAnsi pathAnsi;
+        while (fgets(buffer, sizeof(buffer), pipe) != NULL)
+            pathAnsi += buffer;
+        pclose(pipe);
+        const String path(pathAnsi.Get(), pathAnsi.Length() != 0 ? pathAnsi.Length() - 1 : 0);
+        if (FileSystem::FileExists(path))
+        {
+            output->Add(New<VisualStudioCodeEditor>(path, false));
+            return;
+        }
+    }
+    {
+        const String path(TEXT("/usr/bin/zed"));
+        if (FileSystem::FileExists(path))
+        {
+            output->Add(New<VisualStudioCodeEditor>(path, false));
+            return;
+        }
+    }
+
+    // Detect Flatpak installations
+    {
+        CreateProcessSettings procSettings;
+        procSettings.FileName = TEXT("/bin/bash -c \"flatpak list --app --columns=application | grep dev.zed.Zed -c\"");
+        procSettings.HiddenWindow = true;
+        if (Platform::CreateProcess(procSettings) == 0)
+        {
+            const String runPath(TEXT("flatpak run dev.zed.Zed"));
+            output->Add(New<VisualStudioCodeEditor>(runPath));
+            return;
+        }
+    }
+#elif PLATFORM_MAC
+    // Prefer the Zed CLI application over bundled app, as this handles opening files in existing instance better.
+    // The bundle also contains the CLI application under Zed.app/Contents/MacOS/zed, but using this doesn't make any difference.
+    const String cliPath(TEXT("/usr/local/bin/zed"));
+    if (FileSystem::FileExists(cliPath))
+    {
+        output->Add(New<ZedEditor>(cliPath));
+        return;;
+    }
+
+    // System installed app
+    NSURL* AppURL = [[NSWorkspace sharedWorkspace]URLForApplicationWithBundleIdentifier:@"dev.zed.Zed"];
+    if (AppURL != nullptr)
+    {
+        const String path = AppleUtils::ToString((CFStringRef)[AppURL path]);
+        output->Add(New<ZedEditor>(path));
+        return;
+    }
+
+    // Predefined locations
+    String userFolder;
+    FileSystem::GetSpecialFolderPath(SpecialFolder::Documents, userFolder);
+    String paths[3] =
+    {
+        TEXT("/Applications/Zed.app"),
+        userFolder + TEXT("/../Zed.app"),
+        userFolder + TEXT("/../Downloads/Zed.app"),
+    };
+    for (const String& path : paths)
+    {
+        if (FileSystem::DirectoryExists(path))
+        {
+            output->Add(New<ZedEditor>(path));
+            break;
+        }
+    }
+#endif
+}
+
+CodeEditorTypes ZedEditor::GetType() const
+{
+    return CodeEditorTypes::Zed;
+}
+
+String ZedEditor::GetName() const
+{
+    return TEXT("Zed");
+}
+
+void ZedEditor::OpenFile(const String& path, int32 line)
+{
+    // Generate VS solution files for intellisense
+    if (!FileSystem::FileExists(Globals::ProjectFolder / Editor::Project->Name + TEXT(".sln")))
+    {
+        ScriptsBuilder::GenerateProject(TEXT("-vs2022"));
+    }
+
+    // Open file
+    line = line > 0 ? line : 1;
+    CreateProcessSettings procSettings;
+    procSettings.FileName = _execPath;
+    procSettings.Arguments = String::Format(TEXT("\"{0}\" \"{1}:{2}\""), _workspacePath, path, line);
+    procSettings.HiddenWindow = false;
+    procSettings.WaitForEnd = false;
+    procSettings.LogOutput = false;
+    procSettings.ShellExecute = true;
+    Platform::CreateProcess(procSettings);
+}
+
+void ZedEditor::OpenSolution()
+{
+    // Generate VS solution files for intellisense
+    if (!FileSystem::FileExists(Globals::ProjectFolder / Editor::Project->Name + TEXT(".sln")))
+    {
+        ScriptsBuilder::GenerateProject(TEXT("-vs2022"));
+    }
+
+    // Open solution
+    CreateProcessSettings procSettings;
+    procSettings.FileName = _execPath;
+    procSettings.Arguments = String::Format(TEXT("\"{0}\""), _workspacePath);
+    procSettings.HiddenWindow = false;
+    procSettings.WaitForEnd = false;
+    procSettings.LogOutput = false;
+    procSettings.ShellExecute = true;
+    Platform::CreateProcess(procSettings);
+}
+
+bool ZedEditor::UseAsyncForOpen() const
+{
+    return false;
+}

Source/Editor/Scripting/CodeEditors/ZedEditor.h

@@ -0,0 +1,41 @@
+// Copyright (c) Wojciech Figat. All rights reserved.
+
+#pragma once
+
+#include "Editor/Scripting/CodeEditor.h"
+
+/// <summary>
+/// Implementation of code editor utility that is using Microsoft Visual Studio Code.
+/// </summary>
+class ZedEditor : public CodeEditor
+{
+private:
+
+    String _execPath;
+    String _workspacePath;
+
+public:
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="VisualStudioEditor"/> class.
+    /// </summary>
+    /// <param name="execPath">Executable file path</param>
+    ZedEditor(const String& execPath);
+
+public:
+
+    /// <summary>
+    /// Tries to find installed Visual Studio Code instance. Adds them to the result list.
+    /// </summary>
+    /// <param name="output">The output editors.</param>
+    static void FindEditors(Array<CodeEditor*>* output);
+
+public:
+
+    // [CodeEditor]
+    CodeEditorTypes GetType() const override;
+    String GetName() const override;
+    void OpenFile(const String& path, int32 line) override;
+    void OpenSolution() override;
+    bool UseAsyncForOpen() const override;
+};

Source/Engine/GraphicsDevice/DirectX/DX12/GPUContextDX12.cpp

@@ -491,7 +491,7 @@ void GPUContextDX12::flushUAVs()
     ASSERT(uaCount <= GPU_MAX_UA_BINDED);
 
     // Fill table with source descriptors
-    DxShaderHeader& header = _currentCompute ? ((GPUShaderProgramCSDX12*)_currentCompute)->Header : _currentState->Header;
+    DxShaderHeader& header = _isCompute ? ((GPUShaderProgramCSDX12*)_currentCompute)->Header : _currentState->Header;
     D3D12_CPU_DESCRIPTOR_HANDLE srcDescriptorRangeStarts[GPU_MAX_UA_BINDED];
     for (uint32 i = 0; i < uaCount; i++)
     {

Source/Engine/Physics/PhysX/PhysicsBackendPhysX.cpp

@@ -1969,6 +1969,7 @@ void PhysicsBackend::EndSimulateScene(void* scene)
         scenePhysX->EventsCallback.SendTriggerEvents();
         scenePhysX->EventsCallback.SendCollisionEvents();
         scenePhysX->EventsCallback.SendJointEvents();
+        scenePhysX->EventsCallback.Clear();
     }
 
     // Clear delta after simulation ended
@@ -4466,14 +4467,14 @@ void PhysicsBackend::FlushRequests(void* scene)
     }
     if (scenePhysX->RemoveColliders.HasItems())
     {
-        for (int32 i = 0; i < scenePhysX->RemoveColliders.Count(); i++)
-            scenePhysX->EventsCallback.OnColliderRemoved(scenePhysX->RemoveColliders[i]);
+        for (PhysicsColliderActor* e : scenePhysX->RemoveColliders)
+            scenePhysX->EventsCallback.OnColliderRemoved(e);
         scenePhysX->RemoveColliders.Clear();
     }
     if (scenePhysX->RemoveJoints.HasItems())
     {
-        for (int32 i = 0; i < scenePhysX->RemoveJoints.Count(); i++)
-            scenePhysX->EventsCallback.OnJointRemoved(scenePhysX->RemoveJoints[i]);
+        for (Joint* e : scenePhysX->RemoveJoints)
+            scenePhysX->EventsCallback.OnJointRemoved(e);
         scenePhysX->RemoveJoints.Clear();
     }
 

Source/Engine/Renderer/ColorGradingPass.cpp

@@ -47,6 +47,9 @@ public:
     Data CachedData;
     ToneMappingMode Mode = ToneMappingMode::None;
     Texture* LutTexture = nullptr;
+#if COMPILE_WITH_DEV_ENV
+    uint64 FrameRendered = 0;
+#endif
 
     ~ColorGradingCustomBuffer()
     {
@@ -54,6 +57,17 @@ public:
     }
 };
 
+#if COMPILE_WITH_DEV_ENV
+
+void ColorGradingPass::OnShaderReloading(Asset* obj)
+{
+    _psLut.Release();
+    invalidateResources();
+    _reloadedFrame = Engine::FrameCount;
+}
+
+#endif
+
 String ColorGradingPass::ToString() const
 {
     return TEXT("ColorGradingPass");
@@ -194,6 +208,9 @@ GPUTexture* ColorGradingPass::RenderLUT(RenderContext& renderContext)
     // Check if LUT parameter hasn't been changed since the last time
     if (Platform::MemoryCompare(&colorGradingBuffer.CachedData , &data, sizeof(Data)) == 0 &&
         colorGradingBuffer.Mode == toneMapping.Mode &&
+#if COMPILE_WITH_DEV_ENV
+        colorGradingBuffer.FrameRendered > _reloadedFrame &&
+#endif
         Engine::FrameCount > 30 && // Skip caching when engine is starting TODO: find why this hack is needed
         colorGradingBuffer.LutTexture == lutTexture)
     {
@@ -203,6 +220,9 @@ GPUTexture* ColorGradingPass::RenderLUT(RenderContext& renderContext)
     colorGradingBuffer.CachedData = data;
     colorGradingBuffer.Mode = toneMapping.Mode;
     colorGradingBuffer.LutTexture = lutTexture;
+#if COMPILE_WITH_DEV_ENV
+    colorGradingBuffer.FrameRendered = Engine::FrameCount;
+#endif
 
     // Render LUT
     PROFILE_GPU("Color Grading LUT");

Source/Engine/Renderer/ColorGradingPass.h

@@ -25,11 +25,8 @@ public:
 
 private:
 #if COMPILE_WITH_DEV_ENV
-    void OnShaderReloading(Asset* obj)
-    {
-        _psLut.Release();
-        invalidateResources();
-    }
+    uint64 _reloadedFrame = 0;
+    void OnShaderReloading(Asset* obj);
 #endif
 
 public:

Source/Engine/Renderer/EyeAdaptationPass.cpp

@@ -98,6 +98,7 @@ void EyeAdaptationPass::Render(RenderContext& renderContext, GPUTexture* colorBu
     if (mode == EyeAdaptationMode::Manual)
     {
         // Apply fixed manual exposure
+        context->ResetSR();
         context->SetRenderTarget(*colorBuffer);
         context->SetViewportAndScissors((float)colorBuffer->Width(), (float)colorBuffer->Height());
         context->SetState(_psManual);

Source/Engine/Scripting/Scripting.Build.cs

@@ -32,7 +32,7 @@ public class Scripting : EngineModule
                 options.ScriptingAPI.Defines.Add("NET");
                 AddFrameworkDefines("NET{0}_{1}", dotnetSdk.Version.Major, 0); // "NET7_0"
                 for (int i = 5; i <= dotnetSdk.Version.Major; i++)
-                    AddFrameworkDefines("NET{0}_{1}_OR_GREATER", dotnetSdk.Version.Major, 0); // "NET7_0_OR_GREATER"
+                    AddFrameworkDefines("NET{0}_{1}_OR_GREATER", i, 0); // "NET7_0_OR_GREATER"
                 options.ScriptingAPI.Defines.Add("NETCOREAPP");
                 AddFrameworkDefines("NETCOREAPP{0}_{1}_OR_GREATER", 3, 1); // "NETCOREAPP3_1_OR_GREATER"
                 AddFrameworkDefines("NETCOREAPP{0}_{1}_OR_GREATER", 2, 2);

Source/Engine/Tools/TextureTool/TextureTool.stb.cpp

@@ -65,6 +65,8 @@
 
 #endif
 
+#undef MessageBox
+
 static void stbWrite(void* context, void* data, int size)
 {
     auto file = (FileWriteStream*)context;

Source/Shaders/ColorGrading.shader

@@ -164,16 +164,14 @@ float3 TonemapACES(float3 linearColor)
 	// The code was originally written by Stephen Hill (@self_shadow).
 
 	// sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
-	static const float3x3 ACESInputMat =
-	{
+	static const float3x3 ACESInputMat = {
 		{0.59719, 0.35458, 0.04823},
 		{0.07600, 0.90834, 0.01566},
 		{0.02840, 0.13383, 0.83777}
 	};
 
 	// ODT_SAT => XYZ => D60_2_D65 => sRGB
-	static const float3x3 ACESOutputMat =
-	{
+	static const float3x3 ACESOutputMat = {
 		{ 1.60475, -0.53108, -0.07367},
 		{-0.10208,  1.10813, -0.00605},
 		{-0.00327, -0.07276,  1.07602}
@@ -188,6 +186,7 @@ float3 TonemapACES(float3 linearColor)
 	color = a / b;
 
 	color = mul(ACESOutputMat, color);
+
 	return saturate(color);
 }
 

Source/Shaders/GammaCorrectionCommon.hlsl

@@ -37,7 +37,7 @@ float4 FastTonemapInvert(float4 c)
     return float4(FastTonemapInvert(c.rgb), c.a);
 }
 
-float LinearToSrgbChannel(float linearColor)
+float LinearToSrgb(float linearColor)
 {
     if (linearColor < 0.00313067)
         return linearColor * 12.92;
@@ -46,10 +46,7 @@ float LinearToSrgbChannel(float linearColor)
 
 float3 LinearToSrgb(float3 linearColor)
 {
-    return float3(
-        LinearToSrgbChannel(linearColor.r),
-        LinearToSrgbChannel(linearColor.g),
-        LinearToSrgbChannel(linearColor.b));
+    return float3(LinearToSrgb(linearColor.r), LinearToSrgb(linearColor.g), LinearToSrgb(linearColor.b));
 }
 
 float3 sRGBToLinear(float3 color)

Source/ThirdParty/detex/detex.h

@@ -72,7 +72,11 @@ __BEGIN_DECLS
 #include <stdint.h>
 #include <stdbool.h>
 
+#if defined(_MSC_VER)
+#define DETEX_INLINE_ONLY __forceinline
+#else
 #define DETEX_INLINE_ONLY __attribute__((always_inline)) inline
+#endif
 #define DETEX_RESTRICT __restrict
 
 /* Maximum uncompressed block size in bytes. */

Source/Tools/Flax.Build/Projects/VisualStudio/VCProjectGenerator.cs

@@ -114,7 +114,7 @@ namespace Flax.Build.Projects.VisualStudio
             vcProjectFileContent.AppendLine("    <Keyword>MakeFileProj</Keyword>");
             if (Version >= VisualStudioVersion.VisualStudio2022)
                 vcProjectFileContent.AppendLine("    <ResolveNuGetPackages>false</ResolveNuGetPackages>");
-            vcProjectFileContent.AppendLine("    <VCTargetsPath Condition=\"$(Configuration.Contains('Linux'))\">./</VCTargetsPath>");
+            vcProjectFileContent.AppendLine("    <VCTargetsPath Condition=\"$(Configuration.Contains('Linux')) or $(Configuration.Contains('Mac'))\">./</VCTargetsPath>");
             vcProjectFileContent.AppendLine("  </PropertyGroup>");
 
             // Default properties