Add PS5 platform defines and types

Source/Editor/Content/Create/SettingsCreateEntry.cs

@@ -40,6 +40,8 @@ namespace FlaxEditor.Content.Create
             XboxScarlettPlatformSettings,
             AndroidPlatformSettings,
             SwitchPlatformSettings,
+            [EditorDisplay(null, "PS5 Platform Settings")]
+            PS5PlatformSettings,
         }
 
         private static readonly Type[] _types =
@@ -63,6 +65,7 @@ namespace FlaxEditor.Content.Create
             TypeUtils.GetManagedType(GameSettings.XboxScarlettPlatformSettingsTypename),
             typeof(AndroidPlatformSettings),
             TypeUtils.GetManagedType(GameSettings.SwitchPlatformSettingsTypename),
+            TypeUtils.GetManagedType(GameSettings.PS5PlatformSettingsTypename),
         };
 
         internal class Options
@@ -228,6 +231,11 @@ namespace FlaxEditor.Content.Create
                         return false;
                     instance.SwitchPlatform = asset;
                     break;
+                case SettingsTypes.PS5PlatformSettings:
+                    if (instance.PS5Platform != null)
+                        return false;
+                    instance.PS5Platform = asset;
+                    break;
                 }
                 return true;
             }

Source/Editor/Cooker/CookingData.h

@@ -93,6 +93,12 @@ API_ENUM() enum class BuildPlatform
     /// Switch.
     /// </summary>
     Switch = 10,
+
+    /// <summary>
+    /// PlayStation 5
+    /// </summary>
+    API_ENUM(Attributes="EditorDisplay(null, \"PlayStation 5\")")
+    PS5 = 11,
 };
 
 extern FLAXENGINE_API const Char* ToString(const BuildPlatform platform);

Source/Editor/Cooker/GameCooker.cpp

@@ -42,6 +42,9 @@
 #if PLATFORM_TOOLS_PS4
 #include "Platforms/PS4/Editor/PlatformTools/PS4PlatformTools.h"
 #endif
+#if PLATFORM_TOOLS_PS5
+#include "Platforms/PS5/Editor/PlatformTools/PS5PlatformTools.h"
+#endif
 #if PLATFORM_TOOLS_XBOX_ONE
 #include "Platforms/XboxOne/Editor/PlatformTools/XboxOnePlatformTools.h"
 #endif
@@ -123,6 +126,8 @@ const Char* ToString(const BuildPlatform platform)
         return TEXT("Android ARM64");
     case BuildPlatform::Switch:
         return TEXT("Switch");
+    case BuildPlatform::PS5:
+        return TEXT("PlayStation 5");
     default:
         return TEXT("?");
     }
@@ -314,6 +319,11 @@ PlatformTools* GameCooker::GetTools(BuildPlatform platform)
         case BuildPlatform::Switch:
             result = New<SwitchPlatformTools>();
             break;
+#endif
+#if PLATFORM_TOOLS_PS5
+        case BuildPlatform::PS5:
+            result = New<PS5PlatformTools>();
+            break;
 #endif
         }
         Tools.Add(platform, result);

Source/Editor/Cooker/GameCooker.cs

@@ -99,6 +99,7 @@ namespace FlaxEditor
             case BuildPlatform.XboxOne: return PlatformType.XboxOne;
             case BuildPlatform.LinuxX64: return PlatformType.Linux;
             case BuildPlatform.PS4: return PlatformType.PS4;
+            case BuildPlatform.PS5: return PlatformType.PS5;
             case BuildPlatform.AndroidARM64: return PlatformType.Android;
             case BuildPlatform.XboxScarlett: return PlatformType.XboxScarlett;
             case BuildPlatform.Switch: return PlatformType.Switch;

Source/Editor/Cooker/Steps/CompileScriptsStep.cpp

@@ -182,6 +182,10 @@ bool CompileScriptsStep::Perform(CookingData& data)
         platform = TEXT("Switch");
         architecture = TEXT("ARM64");
         break;
+    case BuildPlatform::PS5:
+        platform = TEXT("PS5");
+        architecture = TEXT("x64");
+        break;
     default:
         LOG(Error, "Unknown or unsupported build platform.");
         return true;

Source/Editor/Cooker/Steps/CookAssetsStep.cpp

@@ -514,6 +514,14 @@ bool ProcessShaderBase(CookAssetsStep::AssetCookData& data, ShaderAssetBase* ass
         COMPILE_PROFILE(Vulkan_SM5, SHADER_FILE_CHUNK_INTERNAL_VULKAN_SM5_CACHE);
         break;
     }
+#endif
+#if PLATFORM_TOOLS_PS5
+    case BuildPlatform::PS5:
+    {
+        const char* platformDefineName = "PLATFORM_PS5";
+        COMPILE_PROFILE(PS5, SHADER_FILE_CHUNK_INTERNAL_GENERIC_CACHE);
+        break;
+    }
 #endif
     default:
     {

Source/Editor/Editor.Build.cs

@@ -57,6 +57,7 @@ public class Editor : EditorModule
             AddPlatformTools(options, platformToolsRoot, platformToolsRootExternal, "UWP", "PLATFORM_TOOLS_UWP");
             AddPlatformTools(options, platformToolsRoot, platformToolsRootExternal, "XboxOne", "PLATFORM_TOOLS_XBOX_ONE", "PLATFORM_TOOLS_GDK");
             AddPlatformTools(options, platformToolsRoot, platformToolsRootExternal, "PS4", "PLATFORM_TOOLS_PS4");
+            AddPlatformTools(options, platformToolsRoot, platformToolsRootExternal, "PS5", "PLATFORM_TOOLS_PS5");
             AddPlatformTools(options, platformToolsRoot, platformToolsRootExternal, "XboxScarlett", "PLATFORM_TOOLS_XBOX_SCARLETT", "PLATFORM_TOOLS_GDK");
             AddPlatformTools(options, platformToolsRoot, platformToolsRootExternal, "Android", "PLATFORM_TOOLS_ANDROID");
             AddPlatformTools(options, platformToolsRoot, platformToolsRootExternal, "Switch", "PLATFORM_TOOLS_SWITCH");

Source/Editor/GUI/PlatformSelector.cs

@@ -90,6 +90,7 @@ namespace FlaxEditor.GUI
                 new PlatformData(PlatformType.XboxScarlett, icons.XBoxScarletIcon128, "Xbox Scarlett"),
                 new PlatformData(PlatformType.Android, icons.AndroidIcon128, "Android"),
                 new PlatformData(PlatformType.Switch, icons.SwitchIcon128, "Switch"),
+                new PlatformData(PlatformType.PS5, icons.PS4Icon128, "PlayStation 5"),
             };
 
             const float IconSize = 64.0f;

Source/Editor/Modules/ContentDatabaseModule.cs

@@ -962,6 +962,10 @@ namespace FlaxEditor.Modules
             if (typeSwitchPlatformSettings != null)
                 Proxy.Add(new SettingsProxy(typeSwitchPlatformSettings, Editor.Instance.Icons.SwitchSettings128));
 
+            var typePS5PlatformSettings = TypeUtils.GetManagedType(GameSettings.PS5PlatformSettingsTypename);
+            if (typePS5PlatformSettings != null)
+                Proxy.Add(new SettingsProxy(typePS5PlatformSettings, Editor.Instance.Icons.PlaystationSettings128));
+
             // Last add generic json (won't override other json proxies)
             Proxy.Add(new GenericJsonAssetProxy());
 

Source/Editor/Surface/Archetypes/Tools.cs

@@ -1346,9 +1346,9 @@ namespace FlaxEditor.Surface.Archetypes
                 Title = "Platform Switch",
                 Description = "Gets the input value based on the runtime-platform type",
                 Flags = NodeFlags.AllGraphs,
-                Size = new Vector2(220, 180),
+                Size = new Vector2(220, 200),
                 ConnectionsHints = ConnectionsHint.Value,
-                IndependentBoxes = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 },
+                IndependentBoxes = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 },
                 DependentBoxes = new[] { 0 },
                 Elements = new[]
                 {
@@ -1362,6 +1362,7 @@ namespace FlaxEditor.Surface.Archetypes
                     NodeElementArchetype.Factory.Input(6, "Xbox Scarlett", true, null, 7),
                     NodeElementArchetype.Factory.Input(7, "Android", true, null, 8),
                     NodeElementArchetype.Factory.Input(8, "Switch", true, null, 9),
+                    NodeElementArchetype.Factory.Input(9, "PlayStation 5", true, null, 10),
                 }
             },
             new NodeArchetype

Source/Editor/Windows/GameCookerWindow.cs

@@ -44,6 +44,7 @@ namespace FlaxEditor.Windows
                 { PlatformType.XboxScarlett, new XboxScarlett() },
                 { PlatformType.Android, new Android() },
                 { PlatformType.Switch, new Switch() },
+                { PlatformType.PS5, new PS5() },
             };
 
             public BuildTabProxy(GameCookerWindow win, PlatformSelector platformSelector)
@@ -59,6 +60,7 @@ namespace FlaxEditor.Windows
                 PerPlatformOptions[PlatformType.XboxScarlett].Init("Output/XboxScarlett", "XboxScarlett");
                 PerPlatformOptions[PlatformType.Android].Init("Output/Android", "Android");
                 PerPlatformOptions[PlatformType.Switch].Init("Output/Switch", "Switch");
+                PerPlatformOptions[PlatformType.PS5].Init("Output/PS5", "PS5");
             }
 
             abstract class Platform
@@ -195,6 +197,11 @@ namespace FlaxEditor.Windows
                 protected override BuildPlatform BuildPlatform => BuildPlatform.Switch;
             }
 
+            class PS5 : Platform
+            {
+                protected override BuildPlatform BuildPlatform => BuildPlatform.PS5;
+            }
+
             class Editor : CustomEditor
             {
                 private PlatformType _platform;
@@ -239,6 +246,9 @@ namespace FlaxEditor.Windows
                         case PlatformType.Switch:
                             name = "Switch";
                             break;
+                        case PlatformType.PS5:
+                            name = "PlayStation 5";
+                            break;
                         default:
                             name = CustomEditorsUtil.GetPropertyNameUI(_platform.ToString());
                             break;

Source/Engine/Audio/Audio.Build.cs

@@ -50,6 +50,10 @@ public class Audio : EngineModule
             options.SourcePaths.Add(Path.Combine(Globals.EngineRoot, "Source", "Platforms", "Switch", "Engine", "Audio"));
             options.CompileEnv.PreprocessorDefinitions.Add("AUDIO_API_SWITCH");
             break;
+        case TargetPlatform.PS5:
+            options.SourcePaths.Add(Path.Combine(Globals.EngineRoot, "Source", "Platforms", "PS5", "Engine", "Audio"));
+            options.CompileEnv.PreprocessorDefinitions.Add("AUDIO_API_PS5");
+            break;
         default: throw new InvalidPlatformException(options.Platform.Target);
         }
 

Source/Engine/Audio/Audio.cpp

@@ -18,6 +18,9 @@
 #if AUDIO_API_PS4
 #include "Platforms/PS4/Engine/Audio/AudioBackendPS4.h"
 #endif
+#if AUDIO_API_PS5
+#include "Platforms/PS5/Engine/Audio/AudioBackendPS5.h"
+#endif
 #if AUDIO_API_SWITCH
 #include "Platforms/Switch/Engine/Audio/AudioBackendSwitch.h"
 #endif
@@ -182,44 +185,34 @@ bool AudioService::Init()
     AudioBackend* backend = nullptr;
 #if AUDIO_API_NONE
     if (mute)
-    {
         backend = New<AudioBackendNone>();
-    }
 #endif
 #if AUDIO_API_PS4
     if (!backend)
-    {
         backend = New<AudioBackendPS4>();
-    }
+#endif
+#if AUDIO_API_PS5
+    if (!backend)
+        backend = New<AudioBackendPS5>();
 #endif
 #if AUDIO_API_SWITCH
     if (!backend)
-    {
         backend = New<AudioBackendSwitch>();
-    }
 #endif
 #if AUDIO_API_OPENAL
     if (!backend)
-    {
         backend = New<AudioBackendOAL>();
-    }
 #endif
 #if AUDIO_API_XAUDIO2
 	if (!backend)
-	{
 		backend = New<AudioBackendXAudio2>();
-	}
 #endif
 #if AUDIO_API_NONE
     if (!backend)
-    {
         backend = New<AudioBackendNone>();
-    }
 #else
     if (mute)
-    {
         LOG(Warning, "Cannot use mute audio. Null Audio Backend not available on this platform.");
-    }
 #endif
     if (backend == nullptr)
     {

Source/Engine/Core/Config/GameSettings.cpp

@@ -55,6 +55,8 @@ IMPLEMENT_SETTINGS_GETTER(UWPPlatformSettings, UWPPlatform);
 IMPLEMENT_SETTINGS_GETTER(LinuxPlatformSettings, LinuxPlatform);
 #elif PLATFORM_PS4
 IMPLEMENT_SETTINGS_GETTER(PS4PlatformSettings, PS4Platform);
+#elif PLATFORM_PS5
+IMPLEMENT_SETTINGS_GETTER(PS5PlatformSettings, PS5Platform);
 #elif PLATFORM_XBOX_ONE
 IMPLEMENT_SETTINGS_GETTER(XboxOnePlatformSettings, XboxOnePlatform);
 #elif PLATFORM_XBOX_SCARLETT
@@ -223,6 +225,7 @@ void GameSettings::Deserialize(DeserializeStream& stream, ISerializeModifier* mo
     DESERIALIZE(XboxScarlettPlatform);
     DESERIALIZE(AndroidPlatform);
     DESERIALIZE(SwitchPlatform);
+    DESERIALIZE(PS5Platform);
 }
 
 void LayersAndTagsSettings::Deserialize(DeserializeStream& stream, ISerializeModifier* modifier)

Source/Engine/Core/Config/GameSettings.cs

@@ -10,6 +10,7 @@ namespace FlaxEditor.Content.Settings
     partial class GameSettings
     {
         internal const string PS4PlatformSettingsTypename = "FlaxEditor.Content.Settings.PS4PlatformSettings";
+        internal const string PS5PlatformSettingsTypename = "FlaxEditor.Content.Settings.PS5PlatformSettings";
         internal const string XboxOnePlatformSettingsTypename = "FlaxEditor.Content.Settings.XboxOnePlatformSettings";
         internal const string XboxScarlettPlatformSettingsTypename = "FlaxEditor.Content.Settings.XboxScarlettPlatformSettings";
         internal const string SwitchPlatformSettingsTypename = "FlaxEditor.Content.Settings.SwitchPlatformSettings";
@@ -168,6 +169,14 @@ namespace FlaxEditor.Content.Settings
         public JsonAsset SwitchPlatform;
 #endif
 
+#if FLAX_EDITOR || PLATFORM_PS5
+        /// <summary>
+        /// Reference to PS5 Platform Settings asset. Used to apply configuration on PS5 platform.
+        /// </summary>
+        [EditorOrder(2080), EditorDisplay("Platform Settings", "PlayStation 5"), AssetReference(PS5PlatformSettingsTypename, true), Tooltip("Reference to PS5 Platform Settings asset")]
+        public JsonAsset PS5Platform;
+#endif
+
         /// <summary>
         /// Gets the absolute path to the game settings asset file.
         /// </summary>
@@ -282,6 +291,10 @@ namespace FlaxEditor.Content.Settings
             if (type.FullName == SwitchPlatformSettingsTypename)
                 return LoadAsset(gameSettings.SwitchPlatform, SwitchPlatformSettingsTypename) as T;
 #endif
+#if FLAX_EDITOR || PLATFORM_PS5
+            if (type.FullName == PS5PlatformSettingsTypename)
+                return LoadAsset(gameSettings.PS5Platform, PS5PlatformSettingsTypename) as T;
+#endif
 
             if (gameSettings.CustomSettings != null)
             {
@@ -374,6 +387,8 @@ namespace FlaxEditor.Content.Settings
                 return SaveAsset(gameSettings, ref gameSettings.AndroidPlatform, obj);
             if (type.FullName == SwitchPlatformSettingsTypename)
                 return SaveAsset(gameSettings, ref gameSettings.SwitchPlatform, obj);
+            if (type.FullName == PS5PlatformSettingsTypename)
+                return SaveAsset(gameSettings, ref gameSettings.PS5Platform, obj);
             if (type == typeof(AudioSettings))
                 return SaveAsset(gameSettings, ref gameSettings.Audio, obj);
 

Source/Engine/Core/Config/GameSettings.h

@@ -81,6 +81,7 @@ public:
     Guid XboxScarlettPlatform;
     Guid AndroidPlatform;
     Guid SwitchPlatform;
+    Guid PS5Platform;
 
 public:
 

Source/Engine/Core/Config/PlatformSettings.h

@@ -29,3 +29,6 @@
 #if PLATFORM_SWITCH
 #include "Platforms/Switch/Engine/Platform/SwitchPlatformSettings.h"
 #endif
+#if PLATFORM_PS5
+#include "Platforms/PS5/Engine/Platform/PS5PlatformSettings.h"
+#endif

Source/Engine/Engine/Engine.Build.cs

@@ -44,6 +44,9 @@ public class Engine : EngineModule
         case TargetPlatform.PS4:
             options.SourcePaths.Add(Path.Combine(Globals.EngineRoot, "Source", "Platforms", "PS4", "Engine", "Engine"));
             break;
+        case TargetPlatform.PS5:
+            options.SourcePaths.Add(Path.Combine(Globals.EngineRoot, "Source", "Platforms", "PS5", "Engine", "Engine"));
+            break;
         case TargetPlatform.Switch:
             options.SourcePaths.Add(Path.Combine(Globals.EngineRoot, "Source", "Platforms", "Switch", "Engine", "Engine"));
             break;

Source/Engine/Engine/Game.h

@@ -12,6 +12,8 @@
 #include "Linux/LinuxGame.h"
 #elif PLATFORM_PS4
 #include "Platforms/PS4/Engine/Engine/PS4Game.h"
+#elif PLATFORM_PS5
+#include "Platforms/PS5/Engine/Engine/PS5Game.h"
 #elif PLATFORM_XBOX_ONE
 #include "Platforms/XboxOne/Engine/Engine/XboxOneGame.h"
 #elif PLATFORM_XBOX_SCARLETT

Source/Engine/Graphics/Enums.h

@@ -70,6 +70,11 @@ API_ENUM() enum class RendererType
     /// </summary>
     PS4 = 11,
 
+    /// <summary>
+    /// PlayStation 5
+    /// </summary>
+    PS5 = 12,
+
     API_ENUM(Attributes="HideInEditor")
     MAX
 };
@@ -121,6 +126,11 @@ API_ENUM() enum class ShaderProfile
     /// </summary>
     DirectX_SM6 = 7,
 
+    /// <summary>
+    /// PlayStation 5
+    /// </summary>
+    PS5 = 8,
+
     API_ENUM(Attributes="HideInEditor")
     MAX
 };

Source/Engine/Graphics/Graphics.Build.cs

@@ -72,6 +72,9 @@ public class Graphics : EngineModule
         case TargetPlatform.PS4:
             options.PrivateDependencies.Add("GraphicsDevicePS4");
             break;
+        case TargetPlatform.PS5:
+            options.PrivateDependencies.Add("GraphicsDevicePS5");
+            break;
         case TargetPlatform.Android:
             options.PrivateDependencies.Add("GraphicsDeviceVulkan");
             break;

Source/Engine/Graphics/Graphics.cpp

@@ -30,6 +30,9 @@ extern GPUDevice* CreateGPUDeviceDX12();
 #if GRAPHICS_API_PS4
 extern GPUDevice* CreateGPUDevicePS4();
 #endif
+#if GRAPHICS_API_PS5
+extern GPUDevice* CreateGPUDevicePS5();
+#endif
 
 class GraphicsService : public EngineService
 {
@@ -132,6 +135,10 @@ bool GraphicsService::Init()
 #if GRAPHICS_API_PS4
         if (!device)
             device = CreateGPUDevicePS4();
+#endif
+#if GRAPHICS_API_PS5
+        if (!device)
+            device = CreateGPUDevicePS5();
 #endif
     }
 

Source/Engine/Graphics/RenderTools.cpp

@@ -52,6 +52,9 @@ const Char* ToString(RendererType value)
     case RendererType::PS4:
         result = TEXT("PS4");
         break;
+    case RendererType::PS5:
+        result = TEXT("PS5");
+        break;
     default:
         result = TEXT("?");
     }
@@ -87,6 +90,9 @@ const Char* ToString(ShaderProfile value)
     case ShaderProfile::PS4:
         result = TEXT("PS4");
         break;
+    case ShaderProfile::PS5:
+        result = TEXT("PS5");
+        break;
     default:
         result = TEXT("?");
     }
@@ -289,6 +295,7 @@ FeatureLevel RenderTools::GetFeatureLevel(ShaderProfile profile)
     switch (profile)
     {
     case ShaderProfile::DirectX_SM6:
+    case ShaderProfile::PS5:
         return FeatureLevel::SM6;
     case ShaderProfile::DirectX_SM5:
     case ShaderProfile::Vulkan_SM5:
@@ -313,6 +320,7 @@ bool RenderTools::CanSupportTessellation(ShaderProfile profile)
     case ShaderProfile::DirectX_SM6:
     case ShaderProfile::DirectX_SM5:
     case ShaderProfile::PS4:
+    case ShaderProfile::PS5:
         return true;
     default:
         return false;

Source/Engine/Graphics/Shaders/Cache/ShaderCacheManager.cpp

@@ -11,7 +11,7 @@
 #include "Engine/Graphics/Materials/MaterialShader.h"
 #include "Engine/Particles/Graph/GPU/ParticleEmitterGraph.GPU.h"
 
-const Char* ShaderProfileCacheDirNames[8] =
+const Char* ShaderProfileCacheDirNames[] =
 {
     // @formatter:off
     TEXT("EARTH_IS_NOT_FLAT_XD"), // Unknown
@@ -22,6 +22,7 @@ const Char* ShaderProfileCacheDirNames[8] =
     TEXT("VK_SM5"), // Vulkan_SM5
     TEXT("PS4"), // PS4
     TEXT("DX_SM6"), // DirectX_SM6
+    TEXT("PS5"), // PS5
     // @formatter:on
 };
 

Source/Engine/Main/Main.Build.cs

@@ -57,6 +57,9 @@ public class Main : EngineModule
         case TargetPlatform.PS4:
             options.SourcePaths.Add(Path.Combine(Globals.EngineRoot, "Source", "Platforms", "PS4", "Engine", "Main"));
             break;
+        case TargetPlatform.PS5:
+            options.SourcePaths.Add(Path.Combine(Globals.EngineRoot, "Source", "Platforms", "PS5", "Engine", "Main"));
+            break;
         case TargetPlatform.XboxOne:
             options.SourcePaths.Add(Path.Combine(Globals.EngineRoot, "Source", "Platforms", "XboxOne", "Engine", "Main"));
             break;

Source/Engine/Platform/Base/PlatformBase.cpp

@@ -587,6 +587,8 @@ const Char* ToString(PlatformType type)
         return TEXT("Android");
     case PlatformType::Switch:
         return TEXT("Switch");
+    case PlatformType::PS5:
+        return TEXT("PlayStation 5");
     default:
         return TEXT("");
     }

Source/Engine/Platform/Clipboard.h

@@ -4,22 +4,10 @@
 
 #if PLATFORM_WINDOWS
 #include "Windows/WindowsClipboard.h"
-#elif PLATFORM_UWP
-#include "Base/ClipboardBase.h"
 #elif PLATFORM_LINUX
 #include "Linux/LinuxClipboard.h"
-#elif PLATFORM_PS4
-#include "Base/ClipboardBase.h"
-#elif PLATFORM_XBOX_ONE
-#include "Base/ClipboardBase.h"
-#elif PLATFORM_XBOX_SCARLETT
-#include "Base/ClipboardBase.h"
-#elif PLATFORM_ANDROID
-#include "Base/ClipboardBase.h"
-#elif PLATFORM_SWITCH
-#include "Base/ClipboardBase.h"
 #else
-#error Missing Clipboard implementation!
+#include "Base/ClipboardBase.h"
 #endif
 
 #include "Types.h"

Source/Engine/Platform/CriticalSection.h

@@ -10,6 +10,8 @@
 #include "Unix/UnixCriticalSection.h"
 #elif PLATFORM_PS4
 #include "Unix/UnixCriticalSection.h"
+#elif PLATFORM_PS5
+#include "Unix/UnixCriticalSection.h"
 #elif PLATFORM_XBOX_ONE
 #include "Win32/Win32CriticalSection.h"
 #elif PLATFORM_XBOX_SCARLETT

Source/Engine/Platform/Defines.h

@@ -48,6 +48,11 @@ API_ENUM() enum class PlatformType
     /// Running on Switch.
     /// </summary>
     Switch = 8,
+
+    /// <summary>
+    /// Running on PlayStation 5.
+    /// </summary>
+    PS5 = 9,
 };
 
 /// <summary>
@@ -103,6 +108,9 @@ API_ENUM() enum class ArchitectureType
 #if !defined(PLATFORM_PS4)
 #define PLATFORM_PS4 0
 #endif
+#if !defined(PLATFORM_PS5)
+#define PLATFORM_PS5 0
+#endif
 #if !defined(PLATFORM_XBOX_SCARLETT)
 #define PLATFORM_XBOX_SCARLETT 0
 #endif
@@ -130,6 +138,8 @@ API_ENUM() enum class ArchitectureType
 #include "Linux/LinuxDefines.h"
 #elif PLATFORM_PS4
 #include "Platforms/PS4/Engine/Platform/PS4Defines.h"
+#elif PLATFORM_PS5
+#include "Platforms/PS5/Engine/Platform/PS5Defines.h"
 #elif PLATFORM_XBOX_ONE
 #include "Platforms/XboxOne/Engine/Platform/XboxOneDefines.h"
 #elif PLATFORM_XBOX_SCARLETT
@@ -178,7 +188,7 @@ API_ENUM() enum class ArchitectureType
 // Platform family defines
 #define PLATFORM_WINDOWS_FAMILY (PLATFORM_WINDOWS || PLATFORM_UWP || PLATFORM_XBOX_ONE || PLATFORM_XBOX_SCARLETT)
 #define PLATFORM_MICROSOFT_FAMILY (PLATFORM_WINDOWS_FAMILY)
-#define PLATFORM_UNIX_FAMILY (PLATFORM_LINUX || PLATFORM_ANDROID || PLATFORM_PS4)
+#define PLATFORM_UNIX_FAMILY (PLATFORM_LINUX || PLATFORM_ANDROID || PLATFORM_PS4 || PLATFORM_PS5)
 #define PLATFORM_APPLE_FAMILY (PLATFORM_IOS || PLATFORM_OSX)
 
 // SIMD defines

Source/Engine/Platform/File.h

@@ -10,6 +10,8 @@
 #include "Unix/UnixFile.h"
 #elif PLATFORM_PS4
 #include "Unix/UnixFile.h"
+#elif PLATFORM_PS5
+#include "Unix/UnixFile.h"
 #elif PLATFORM_XBOX_ONE
 #include "Win32/Win32File.h"
 #elif PLATFORM_XBOX_SCARLETT

Source/Engine/Platform/FileSystem.h

@@ -10,6 +10,8 @@
 #include "Linux/LinuxFileSystem.h"
 #elif PLATFORM_PS4
 #include "Platforms/PS4/Engine/Platform/PS4FileSystem.h"
+#elif PLATFORM_PS5
+#include "Platforms/PS5/Engine/Platform/PS5FileSystem.h"
 #elif PLATFORM_XBOX_ONE
 #include "Platforms/XboxOne/Engine/Platform/XboxOneFileSystem.h"
 #elif PLATFORM_XBOX_SCARLETT

Source/Engine/Platform/FileSystemWatcher.h

@@ -4,20 +4,10 @@
 
 #if PLATFORM_WINDOWS
 #include "Windows/WindowsFileSystemWatcher.h"
-#elif PLATFORM_UWP
-#include "Base/FileSystemWatcherBase.h"
 #elif PLATFORM_LINUX
 #include "Linux/LinuxFileSystemWatcher.h"
-#elif PLATFORM_PS4
-#include "Base/FileSystemWatcherBase.h"
-#elif PLATFORM_XBOX_SCARLETT
-#include "Base/FileSystemWatcherBase.h"
-#elif PLATFORM_ANDROID
-#include "Base/FileSystemWatcherBase.h"
-#elif PLATFORM_SWITCH
-#include "Base/FileSystemWatcherBase.h"
 #else
-#error Missing File System Watcher implementation!
+#include "Base/FileSystemWatcherBase.h"
 #endif
 
 #include "Types.h"

Source/Engine/Platform/Network.h

@@ -10,6 +10,8 @@
 #include "Unix/UnixNetwork.h"
 #elif PLATFORM_PS4
 #include "Platforms/PS4/Engine/Platform/PS4Network.h"
+#elif PLATFORM_PS5
+#include "Platforms/PS5/Engine/Platform/PS5Network.h"
 #elif PLATFORM_XBOX_ONE
 #include "Win32/Win32Network.h"
 #elif PLATFORM_XBOX_SCARLETT

Source/Engine/Platform/Platform.Build.cs

@@ -56,6 +56,10 @@ public class Platform : EngineModule
             options.SourcePaths.Add(Path.Combine(FolderPath, "Unix"));
             options.SourcePaths.Add(Path.Combine(Globals.EngineRoot, "Source", "Platforms", "PS4", "Engine", "Platform"));
             break;
+        case TargetPlatform.PS5:
+            options.SourcePaths.Add(Path.Combine(FolderPath, "Unix"));
+            options.SourcePaths.Add(Path.Combine(Globals.EngineRoot, "Source", "Platforms", "PS5", "Engine", "Platform"));
+            break;
         case TargetPlatform.XboxOne:
             options.SourcePaths.Add(Path.Combine(FolderPath, "Win32"));
             options.SourcePaths.Add(Path.Combine(FolderPath, "GDK"));
@@ -86,6 +90,7 @@ public class Platform : EngineModule
             AddSourceFileIfExists(options, Path.Combine(Globals.EngineRoot, "Source", "Platforms", "XboxOne", "Engine", "Platform", "XboxOnePlatformSettings.h"));
             AddSourceFileIfExists(options, Path.Combine(Globals.EngineRoot, "Source", "Platforms", "XboxScarlett", "Engine", "Platform", "XboxScarlettPlatformSettings.h"));
             AddSourceFileIfExists(options, Path.Combine(Globals.EngineRoot, "Source", "Platforms", "PS4", "Engine", "Platform", "PS4PlatformSettings.h"));
+            AddSourceFileIfExists(options, Path.Combine(Globals.EngineRoot, "Source", "Platforms", "PS5", "Engine", "Platform", "PS5PlatformSettings.h"));
             AddSourceFileIfExists(options, Path.Combine(Globals.EngineRoot, "Source", "Platforms", "Switch", "Engine", "Platform", "SwitchPlatformSettings.h"));
         }
     }

Source/Engine/Platform/Platform.h

@@ -16,6 +16,8 @@
 #include "Linux/LinuxPlatform.h"
 #elif PLATFORM_PS4
 #include "Platforms/PS4/Engine/Platform/PS4Platform.h"
+#elif PLATFORM_PS5
+#include "Platforms/PS5/Engine/Platform/PS5Platform.h"
 #elif PLATFORM_XBOX_ONE
 #include "Platforms/XboxOne/Engine/Platform/XboxOnePlatform.h"
 #elif PLATFORM_XBOX_SCARLETT

Source/Engine/Platform/Thread.h

@@ -10,6 +10,8 @@
 #include "Linux/LinuxThread.h"
 #elif PLATFORM_PS4
 #include "Platforms/PS4/Engine/Platform/PS4Thread.h"
+#elif PLATFORM_PS5
+#include "Platforms/PS5/Engine/Platform/PS5Thread.h"
 #elif PLATFORM_XBOX_ONE
 #include "Win32/Win32Thread.h"
 #elif PLATFORM_XBOX_SCARLETT

Source/Engine/Platform/Types.h

@@ -93,6 +93,30 @@ class PS4Window;
 typedef PS4Window Window;
 class PS4Network;
 typedef PS4Network Network;
+
+#elif PLATFORM_PS5
+
+class ClipboardBase;
+typedef ClipboardBase Clipboard;
+class UnixCriticalSection;
+typedef UnixCriticalSection CriticalSection;
+class UnixConditionVariable;
+typedef UnixConditionVariable ConditionVariable;
+class PS5FileSystem;
+typedef PS5FileSystem FileSystem;
+class FileSystemWatcherBase;
+typedef FileSystemWatcherBase FileSystemWatcher;
+class UnixFile;
+typedef UnixFile File;
+class PS5Platform;
+typedef PS5Platform Platform;
+class PS5Thread;
+typedef PS5Thread Thread;
+class PS5Window;
+typedef PS5Window Window;
+class PS5Network;
+typedef PS5Network Network;
+
 #elif PLATFORM_XBOX_ONE
 
 class ClipboardBase;

Source/Engine/Platform/Unix/UnixNetwork.cpp

@@ -1,6 +1,6 @@
 // Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
 
-#if PLATFORM_UNIX && !PLATFORM_PS4
+#if PLATFORM_UNIX && !PLATFORM_PS4 && !PLATFORM_PS5
 
 #include "UnixNetwork.h"
 #include "Engine/Core/Log.h"

Source/Engine/ShadersCompilation/ShadersCompilation.Build.cs

@@ -58,6 +58,8 @@ public class ShadersCompilation : EngineModule
 
         if (Sdk.HasValid("PS4Sdk"))
             options.PrivateDependencies.Add("ShaderCompilerPS4");
+        if (Sdk.HasValid("PS5Sdk"))
+            options.PrivateDependencies.Add("ShaderCompilerPS5");
     }
 
     /// <inheritdoc />

Source/Engine/ShadersCompilation/ShadersCompilation.cpp

@@ -37,6 +37,9 @@
 #if COMPILE_WITH_PS4_SHADER_COMPILER
 #include "Platforms/PS4/Engine/ShaderCompilerPS4/ShaderCompilerPS4.h"
 #endif
+#if COMPILE_WITH_PS5_SHADER_COMPILER
+#include "Platforms/PS5/Engine/ShaderCompilerPS5/ShaderCompilerPS5.h"
+#endif
 
 namespace ShadersCompilationImpl
 {
@@ -151,7 +154,6 @@ ShaderCompiler* ShadersCompilation::CreateCompiler(ShaderProfile profile)
     switch (profile)
     {
 #if COMPILE_WITH_D3D_SHADER_COMPILER
-        // Direct 3D
     case ShaderProfile::DirectX_SM4:
     case ShaderProfile::DirectX_SM5:
         result = New<ShaderCompilerD3D>(profile);
@@ -163,16 +165,19 @@ ShaderCompiler* ShadersCompilation::CreateCompiler(ShaderProfile profile)
         break;
 #endif
 #if COMPILE_WITH_VK_SHADER_COMPILER
-        // Vulkan
     case ShaderProfile::Vulkan_SM5:
         result = New<ShaderCompilerVulkan>(profile);
         break;
 #endif
 #if COMPILE_WITH_PS4_SHADER_COMPILER
-        // PS4
     case ShaderProfile::PS4:
         result = New<ShaderCompilerPS4>();
         break;
+#endif
+#if COMPILE_WITH_PS5_SHADER_COMPILER
+    case ShaderProfile::PS5:
+        result = New<ShaderCompilerPS5>();
+        break;
 #endif
     default:
         break;

Source/Engine/Tools/TextureTool/TextureTool.Build.cs

@@ -32,6 +32,7 @@ public class TextureTool : EngineModule
             break;
         case TargetPlatform.Linux:
         case TargetPlatform.PS4:
+        case TargetPlatform.PS5:
         case TargetPlatform.Android:
         case TargetPlatform.Switch:
             useStb = true;

Source/Engine/Visject/ShaderGraph.cpp

@@ -768,6 +768,7 @@ void ShaderGenerator::ProcessGroupTools(Box* box, Node* node, Value& value)
         PLATFORM_CASE(7, "PLATFORM_XBOX_SCARLETT");
         PLATFORM_CASE(8, "PLATFORM_ANDROID");
         PLATFORM_CASE(9, "PLATFORM_SWITCH");
+        PLATFORM_CASE(10, "PLATFORM_PS5");
 #undef PLATFORM_CASE
         break;
     }

Source/Engine/Visject/VisjectGraph.cpp

@@ -891,6 +891,9 @@ void VisjectExecutor::ProcessGroupTools(Box* box, Node* node, Value& value)
         case PlatformType::Switch:
             boxId = 9;
             break;
+        case PlatformType::PS5:
+            boxId = 10;
+            break;
         default: ;
         }
         value = tryGetValue(node->GetBox(node->GetBox(boxId)->HasConnection() ? boxId : 1), Value::Zero);

Source/ThirdParty/freetype/freetype.Build.cs

@@ -39,6 +39,7 @@ public class freetype : DepsModule
             break;
         case TargetPlatform.Linux:
         case TargetPlatform.PS4:
+        case TargetPlatform.PS5:
         case TargetPlatform.Android:
         case TargetPlatform.Switch:
             options.OutputFiles.Add(Path.Combine(depsRoot, "libfreetype.a"));

Source/ThirdParty/mono-2.0/mono.Build.cs

@@ -76,6 +76,7 @@ public class mono : DepsModule
             options.Libraries.Add(Path.Combine(depsRoot, "libmonosgen-2.0.so"));
             break;
         case TargetPlatform.PS4:
+        case TargetPlatform.PS5:
             options.OutputFiles.Add(Path.Combine(depsRoot, "libmono.a"));
             options.OutputFiles.Add(Path.Combine(depsRoot, "libmonoruntime.a"));
             options.OutputFiles.Add(Path.Combine(depsRoot, "libmonoutils.a"));

Source/ThirdParty/ogg/ogg.Build.cs

@@ -38,6 +38,7 @@ public class ogg : DepsModule
             break;
         case TargetPlatform.Linux:
         case TargetPlatform.PS4:
+        case TargetPlatform.PS5:
         case TargetPlatform.Android:
         case TargetPlatform.Switch:
             options.OutputFiles.Add(Path.Combine(depsRoot, "libogg.a"));

Source/ThirdParty/vorbis/vorbis.Build.cs

@@ -46,6 +46,7 @@ public class vorbis : DepsModule
             options.OutputFiles.Add(Path.Combine(depsRoot, "libvorbisfile.a"));
             break;
         case TargetPlatform.PS4:
+        case TargetPlatform.PS5:
             options.OutputFiles.Add(Path.Combine(depsRoot, "libvorbis.a"));
             break;
         default: throw new InvalidPlatformException(options.Platform.Target);

Source/Tools/Flax.Build/Build/DepsModule.cs

@@ -30,6 +30,7 @@ namespace Flax.Build
                 break;
             case TargetPlatform.Linux:
             case TargetPlatform.PS4:
+            case TargetPlatform.PS5:
             case TargetPlatform.Android:
             case TargetPlatform.Switch:
                 options.OutputFiles.Add(Path.Combine(path, string.Format("lib{0}.a", name)));

Source/Tools/Flax.Build/Build/Module.cs

@@ -93,6 +93,7 @@ namespace Flax.Build
             case TargetPlatform.UWP: return "PLATFORM_UWP";
             case TargetPlatform.Linux: return "PLATFORM_LINUX";
             case TargetPlatform.PS4: return "PLATFORM_PS4";
+            case TargetPlatform.PS5: return "PLATFORM_PS5";
             case TargetPlatform.XboxScarlett: return "PLATFORM_XBOX_SCARLETT";
             case TargetPlatform.Android: return "PLATFORM_ANDROID";
             case TargetPlatform.Switch: return "PLATFORM_SWITCH";

Source/Tools/Flax.Build/Build/Platform.cs

@@ -239,6 +239,7 @@ namespace Flax.Build
             case TargetPlatform.UWP: return targetArchitecture == TargetArchitecture.x64;
             case TargetPlatform.Linux: return targetArchitecture == TargetArchitecture.x64;
             case TargetPlatform.PS4: return targetArchitecture == TargetArchitecture.x64;
+            case TargetPlatform.PS5: return targetArchitecture == TargetArchitecture.x64;
             case TargetPlatform.Android: return targetArchitecture == TargetArchitecture.ARM64;
             case TargetPlatform.Switch: return targetArchitecture == TargetArchitecture.ARM64;
             default: return false;

Source/Tools/Flax.Build/Build/TargetPlatform.cs

@@ -46,6 +46,11 @@ namespace Flax.Build
         /// Running on Switch.
         /// </summary>
         Switch = 8,
+
+        /// <summary>
+        /// Running on PlayStation 5.
+        /// </summary>
+        PS5 = 9,
     }
 
     /// <summary>

Source/Tools/Flax.Build/Deps/Dependency.cs

@@ -238,6 +238,7 @@ namespace Flax.Deps
             }
             case TargetPlatform.Linux:
             case TargetPlatform.PS4:
+            case TargetPlatform.PS5:
             {
                 cmdLine = "CMakeLists.txt";
                 break;

Source/Tools/Flax.Build/Flax.Build.csproj

@@ -138,6 +138,7 @@
     <Compile Include="Platforms\Android\*.cs" />
     <Compile Include="Platforms\Linux\*.cs" />
     <Compile Include="..\..\Platforms\PS4\Flax.Build\*.cs" />
+    <Compile Include="..\..\Platforms\PS5\Flax.Build\*.cs" />
     <Compile Include="Platforms\Unix\*.cs" />
     <Compile Include="Platforms\UWP\*.cs" />
     <Compile Include="Platforms\Windows\*.cs" />

Source/Tools/Flax.Build/Globals.cs

@@ -32,6 +32,7 @@ namespace Flax.Build
             TargetPlatform.XboxOne,
             TargetPlatform.Linux,
             TargetPlatform.PS4,
+            TargetPlatform.PS5,
             TargetPlatform.XboxScarlett,
             TargetPlatform.Android,
             TargetPlatform.Switch,

Source/Tools/Flax.Build/Platforms/Unix/UnixToolchain.cs

@@ -182,6 +182,7 @@ namespace Flax.Build.Platforms
                 default: throw new InvalidArchitectureException(architecture);
                 }
             case TargetPlatform.PS4: return (string)Utilities.GetStaticValue("Flax.Build.Platforms.PS4Toolchain", "ToolchainName");
+            case TargetPlatform.PS5: return (string)Utilities.GetStaticValue("Flax.Build.Platforms.PS5Toolchain", "ToolchainName");
             case TargetPlatform.Android:
                 switch (architecture)
                 {

Source/Tools/Flax.Build/Platforms/Windows/WindowsPlatform.cs

@@ -58,6 +58,7 @@ namespace Flax.Build.Platforms
             case TargetPlatform.Windows: return GetSDKs().Count != 0;
             case TargetPlatform.UWP: return GetSDKs().FirstOrDefault(x => x.Key != WindowsPlatformSDK.v8_1).Value != null;
             case TargetPlatform.PS4: return Sdk.HasValid("PS4Sdk");
+            case TargetPlatform.PS5: return Sdk.HasValid("PS5Sdk");
             case TargetPlatform.XboxOne:
             case TargetPlatform.XboxScarlett: return GetSDKs().ContainsKey(WindowsPlatformSDK.v10_0_19041_0) && Sdk.HasValid("GDK");
             case TargetPlatform.Android: return AndroidSdk.Instance.IsValid && AndroidNdk.Instance.IsValid;