Merge branch 'master' into 2021.3-urp

Author: JohannesDeml

Assets/Plugins/WebGL/WebBridge.meta

@@ -15,7 +15,7 @@ namespace Supyrb.Attributes
 {
 	[AttributeUsage(AttributeTargets.Method)]
 	[MeansImplicitUse]
-	public class WebGlCommandAttribute : Attribute
+	public class WebCommandAttribute : Attribute
 	{
 		public string Description { get; set; }
 	}

…Plugins/WebGL/WebGLTools/Attributes.meta …/Plugins/WebGL/WebBridge/Attributes.metaAssets/Plugins/WebGL/WebGLTools/Attributes.meta renamed to Assets/Plugins/WebGL/WebBridge/Attributes.meta Assets/Plugins/WebGL/WebGLTools/Attributes.meta renamed to Assets/Plugins/WebGL/WebBridge/Attributes.meta

@@ -19,13 +19,13 @@ namespace Supyrb
 	/// <summary>
 	/// Add commands to the WebGL bridge to expose them to the browser console
 	/// </summary>
-	public partial class WebGlBridge
+	public class CommonCommands : WebCommands
 	{
 		/// <summary>
 		/// Disable capturing all keyboard input, e.g. for using native html input fields
 		/// Browser Usage: <code>unityGame.SendMessage("WebGL","DisableCaptureAllKeyboardInput");</code>
 		/// </summary>
-		[WebGlCommand(Description = "Disable unity from consuming all keyboard input")]
+		[WebCommand(Description = "Disable unity from consuming all keyboard input")]
 		public void DisableCaptureAllKeyboardInput()
 		{
 #if !UNITY_EDITOR && UNITY_WEBGL
@@ -38,7 +38,7 @@ public void DisableCaptureAllKeyboardInput()
 		/// Enable capturing all keyboard input, to make sure the game does not miss any key strokes
 		/// Browser Usage: <code>unityGame.SendMessage("WebGL","EnableCaptureAllKeyboardInput");</code>
 		/// </summary>
-		[WebGlCommand(Description = "Enable unity from consuming all keyboard input")]
+		[WebCommand(Description = "Enable unity from consuming all keyboard input")]
 		public void EnableCaptureAllKeyboardInput()
 		{
 #if !UNITY_EDITOR && UNITY_WEBGL
@@ -51,18 +51,18 @@ public void EnableCaptureAllKeyboardInput()
 		/// Logs the current memory usage
 		/// Browser Usage: <code>unityGame.SendMessage("WebGL","LogMemory");</code>
 		/// </summary>
-		[WebGlCommand(Description = "Logs the current memory")]
+		[WebCommand(Description = "Logs the current memory")]
 		[ContextMenu(nameof(LogMemory))]
 		public void LogMemory()
 		{
-			WebGlPlugins.LogMemory();
+			WebToolPlugins.LogMemory();
 		}
 
 		/// <summary>
 		/// Unloads all unused assets <see cref="Resources.UnloadUnusedAssets"/>
 		/// Browser Usage: <code>unityGame.SendMessage("WebGL","UnloadUnusedAssets");</code>
 		/// </summary>
-		[WebGlCommand(Description = "Resources.UnloadUnusedAssets")]
+		[WebCommand(Description = "Resources.UnloadUnusedAssets")]
 		[ContextMenu(nameof(UnloadUnusedAssets))]
 		public void UnloadUnusedAssets()
 		{
@@ -75,7 +75,7 @@ public void UnloadUnusedAssets()
 		/// Browser Usage: <code>unityGame.SendMessage("WebGL", "SetApplicationRunInBackground", 1);</code>
 		/// </summary>
 		/// <param name="runInBackground">1 if it should run in background</param>
-		[WebGlCommand(Description = "Application.runInBackground")]
+		[WebCommand(Description = "Application.runInBackground")]
 		public void SetApplicationRunInBackground(int runInBackground)
 		{
 			Application.runInBackground = runInBackground == 1;
@@ -86,7 +86,7 @@ public void SetApplicationRunInBackground(int runInBackground)
 		/// Browser Usage: <code>unityGame.SendMessage("WebGL", "SetApplicationTargetFrameRate", 15);</code>
 		/// </summary>
 		/// <param name="targetFrameRate">frame rate to render in</param>
-		[WebGlCommand(Description = "Application.targetFrameRate")]
+		[WebCommand(Description = "Application.targetFrameRate")]
 		public void SetApplicationTargetFrameRate(int targetFrameRate)
 		{
 			Application.targetFrameRate = targetFrameRate;
@@ -97,7 +97,7 @@ public void SetApplicationTargetFrameRate(int targetFrameRate)
 		/// Browser Usage: <code>unityGame.SendMessage("WebGL", "SetTimeFixedDeltaTime", 0.02);</code>
 		/// </summary>
 		/// <param name="fixedDeltaTime"></param>
-		[WebGlCommand(Description = "Time.fixedDeltaTime")]
+		[WebCommand(Description = "Time.fixedDeltaTime")]
 		public void SetTimeFixedDeltaTime(float fixedDeltaTime)
 		{
 			Time.fixedDeltaTime = fixedDeltaTime;
@@ -109,7 +109,7 @@ public void SetTimeFixedDeltaTime(float fixedDeltaTime)
 		/// Browser Usage: <code>unityGame.SendMessage("WebGL", "SetTimeTimeScale", 0.2);</code>
 		/// </summary>
 		/// <param name="timeScale">new timescale value</param>
-		[WebGlCommand(Description = "Time.timeScale")]
+		[WebCommand(Description = "Time.timeScale")]
 		public void SetTimeTimeScale(float timeScale)
 		{
 			Time.timeScale = timeScale;
@@ -119,28 +119,28 @@ public void SetTimeTimeScale(float timeScale)
 		/// Toggle the visibility of the info panel in the top right corner
 		/// Browser Usage: <code>unityGame.SendMessage("WebGL", "ToggleInfoPanel");</code>
 		/// </summary>
-		[WebGlCommand(Description = "Toggle develop ui visibility of InfoPanel")]
+		[WebCommand(Description = "Toggle develop ui visibility of InfoPanel")]
 		public void ToggleInfoPanel()
 		{
-			WebGlPlugins.ToggleInfoPanel();
+			WebToolPlugins.ToggleInfoPanel();
 		}
 
 		/// <summary>
 		/// Log the user agent of the browser and if this agent is classified as mobile
 		/// Browser Usage: <code>unityGame.SendMessage("WebGL", "LogUserAgent");</code>
 		/// </summary>
-		[WebGlCommand(Description = "Log User Agent and isMobileDevice")]
+		[WebCommand(Description = "Log User Agent and isMobileDevice")]
 		public void LogUserAgent()
 		{
-			string userAgent = WebGlPlugins.GetUserAgent();
-			bool isMobileDevice = WebGlPlugins.IsMobileDevice();
+			string userAgent = WebToolPlugins.GetUserAgent();
+			bool isMobileDevice = WebToolPlugins.IsMobileDevice();
 			Debug.Log($"<color=#4D65A4>User Agent:</color> '{userAgent}', <color=#4D65A4>IsMobileDevice:</color> '{isMobileDevice}'");
 		}
 
 		/// <summary>
 		/// Log example messages to show off unity rich text parsing to html & console styling
 		/// </summary>
-		[WebGlCommand(Description = "Log example messages for Log, warning and error")]
+		[WebCommand(Description = "Log example messages for Log, warning and error")]
 		[ContextMenu(nameof(LogExampleMessages))]
 		public void LogExampleMessages()
 		{
@@ -153,7 +153,7 @@ public void LogExampleMessages()
 		/// Log a custom message to test Debug.Log in general
 		/// </summary>
 		/// <param name="message">Message that will be logged</param>
-		[WebGlCommand(Description = "Log a custom message")]
+		[WebCommand(Description = "Log a custom message")]
 		public void LogMessage(string message)
 		{
 			Debug.Log(message);
@@ -162,7 +162,7 @@ public void LogMessage(string message)
 		/// <summary>
 		/// Throw an exception from System namespace to see how stack traces look for that
 		/// </summary>
-		[WebGlCommand(Description = "Throw a dictionary key not found exception")]
+		[WebCommand(Description = "Throw a dictionary key not found exception")]
 		[ContextMenu(nameof(ThrowDictionaryException))]
 		public void ThrowDictionaryException()
 		{
@@ -175,7 +175,7 @@ public void ThrowDictionaryException()
 		/// Log information of all texture formats that Unity supports, which ones are supported by
 		/// the current platform and browser, and which ones are not supported
 		/// </summary>
-		[WebGlCommand(Description = "Log supported and unsupported texture formats")]
+		[WebCommand(Description = "Log supported and unsupported texture formats")]
 		[ContextMenu(nameof(LogTextureSupport))]
 		public void LogTextureSupport()
 		{
@@ -209,7 +209,7 @@ public void LogTextureSupport()
 		/// <summary>
 		/// Deletes all player prefs <see cref="PlayerPrefs.DeleteAll"/>
 		/// </summary>
-		[WebGlCommand(Description = "PlayerPrefs.DeleteAll")]
+		[WebCommand(Description = "PlayerPrefs.DeleteAll")]
 		[ContextMenu(nameof(DeleteAllPlayerPrefs))]
 		public void DeleteAllPlayerPrefs()
 		{
@@ -221,7 +221,7 @@ public void DeleteAllPlayerPrefs()
 		/// <see cref="GraphicsSettings.logWhenShaderIsCompiled "/>
 		/// </summary>
 		/// <param name="runInBackground">1 if it should run in background</param>
-		[WebGlCommand(Description = "GraphicsSettings.logWhenShaderIsCompiled")]
+		[WebCommand(Description = "GraphicsSettings.logWhenShaderIsCompiled")]
 		[ContextMenu(nameof(LogShaderCompilation))]
 		public void LogShaderCompilation(int enabled)
 		{

…ools/Attributes/WebGlCommandAttribute.cs …Bridge/Attributes/WebCommandAttribute.csAssets/Plugins/WebGL/WebGLTools/Attributes/WebGlCommandAttribute.cs renamed to Assets/Plugins/WebGL/WebBridge/Attributes/WebCommandAttribute.cs Assets/Plugins/WebGL/WebGLTools/Attributes/WebGlCommandAttribute.cs renamed to Assets/Plugins/WebGL/WebBridge/Attributes/WebCommandAttribute.cs

@@ -0,0 +1,19 @@
+{
+    "name": "Supyrb.WebBridge",
+    "rootNamespace": "",
+    "references": [
+        "GUID:e6be6bd2cac63ce49a95472c9d6e313a"
+    ],
+    "includePlatforms": [
+        "Editor",
+        "WebGL"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

…Attributes/WebGlCommandAttribute.cs.meta …e/Attributes/WebCommandAttribute.cs.metaAssets/Plugins/WebGL/WebGLTools/Attributes/WebGlCommandAttribute.cs.meta renamed to Assets/Plugins/WebGL/WebBridge/Attributes/WebCommandAttribute.cs.meta Assets/Plugins/WebGL/WebGLTools/Attributes/WebGlCommandAttribute.cs.meta renamed to Assets/Plugins/WebGL/WebBridge/Attributes/WebCommandAttribute.cs.meta

@@ -0,0 +1,141 @@
+// --------------------------------------------------------------------------------------------------------------------
+// <copyright file="WebGlBridge.cs">
+//   Copyright (c) 2021 Johannes Deml. All rights reserved.
+// </copyright>
+// <author>
+//   Johannes Deml
+//   public@deml.io
+// </author>
+// --------------------------------------------------------------------------------------------------------------------
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+using Supyrb.Attributes;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace Supyrb
+{
+	/// <summary>
+	/// Bridge to Unity to access unity logic through the browser console
+	/// You can extend your commands by creating a partial class for WebBridge, see WebBridge.Commands as an example
+	/// </summary>
+	public class WebBridge : WebCommands
+	{
+		private const string WebBridgeGameObjectName = "WebBridge";
+
+		private static GameObject bridgeInstance;
+#if UNITY_WEBGL
+		[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+		private static void OnBeforeSceneLoadRuntimeMethod()
+		{
+			SetGlobalVariables();
+			bridgeInstance = new GameObject(WebBridgeGameObjectName);
+			DontDestroyOnLoad(bridgeInstance);
+			AddAllWebCommands();
+		}
+#endif
+
+		private static void AddAllWebCommands()
+		{
+			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
+			List<Type> webCommandTypes = new List<Type>();
+			foreach (var assembly in assemblies)
+			{
+				Type[] types = assembly.GetTypes();
+				foreach (var type in types)
+				{
+					if (type.IsSubclassOf(typeof(WebCommands)))
+					{
+						webCommandTypes.Add(type);
+					}
+				}
+			}
+
+			// Sort the commands to make the output deterministic
+			webCommandTypes.Sort((a, b) => a.Name.CompareTo(b.Name));
+			foreach (var webCommandType in webCommandTypes)
+			{
+				bridgeInstance.AddComponent(webCommandType);
+			}
+		}
+
+		private static void SetGlobalVariables()
+		{
+			var graphicsDevice = SystemInfo.graphicsDeviceType;
+			string webGraphics = string.Empty;
+			switch (graphicsDevice)
+			{
+				case GraphicsDeviceType.OpenGLES2:
+					webGraphics = "WebGL 1";
+					break;
+				case GraphicsDeviceType.OpenGLES3:
+					webGraphics = "WebGL 2";
+					break;
+#if UNITY_2023_2_OR_NEWER
+				case GraphicsDeviceType.WebGPU:
+					webGraphics = "WebGPU";
+					break;
+#endif
+				default:
+					webGraphics = graphicsDevice.ToString();
+					break;
+			}
+			WebToolPlugins.SetVariable("webGlVersion", webGraphics);
+			WebToolPlugins.SetVariable("unityVersion", Application.unityVersion);
+#if !UNITY_EDITOR && UNITY_WEBGL
+			WebToolPlugins.SetVariable("unityCaptureAllKeyboardInputDefault", WebGLInput.captureAllKeyboardInput?"true":"false");
+#endif
+		}
+
+		private void Start()
+		{
+			Debug.Log($"Unity WebGL Bridge ready -> Run 'runUnityCommand(\"Help\")' in the browser console to see usage");
+		}
+
+		[WebCommand(Description = "Log all available commands")]
+		[ContextMenu(nameof(Help))]
+		public void Help()
+		{
+			StringBuilder sb = new StringBuilder();
+			sb.AppendLine("Available commands:");
+
+			foreach (var webCommand in gameObject.GetComponents<WebCommands>())
+			{
+				sb.AppendLine($"<b>---{webCommand.GetType().Name}---</b>");
+				MethodInfo[] methods = webCommand.GetType().GetMethods(BindingFlags.Public | BindingFlags.Instance);
+
+				for (int i = 0; i < methods.Length; i++)
+				{
+					var method = methods[i];
+					WebCommandAttribute commandAttribute = method.GetCustomAttribute<WebCommandAttribute>();
+					if (commandAttribute != null)
+					{
+						sb.Append($"runUnityCommand(\"{method.Name}\"");
+						ParameterInfo[] parameters = method.GetParameters();
+						for (int j = 0; j < parameters.Length; j++)
+						{
+							var parameter = parameters[j];
+							if (parameter.ParameterType == typeof(string))
+							{
+								sb.Append($", \"{parameter.ParameterType} {parameter.Name}\"");
+							}
+							else
+							{
+								sb.Append($", {parameter.ParameterType} {parameter.Name}");
+							}
+						}
+
+						sb.AppendLine($"); <color=#555555FF>-> {commandAttribute.Description}</color>");
+					}
+				}
+
+			}
+
+			sb.AppendLine($"\nRun a command with 'runUnityCommand(\"COMMAND_NAME\",PARAMETER);'");
+			Debug.Log(sb.ToString());
+		}
+	}
+}