补齐备份工程打开依赖

Assets/Plugins/IngameDebugConsole/Android.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 3d7d7a61a5341904eb3c65af025b1d86
+folderAsset: yes
+timeCreated: 1510075633
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Android/DebugLogLogcatListener.cs

@@ -0,0 +1,54 @@
+#if !UNITY_EDITOR && UNITY_ANDROID
+using System.Collections.Generic;
+using UnityEngine;
+
+// Credit: https://stackoverflow.com/a/41018028/2373034
+namespace IngameDebugConsole
+{
+	public class DebugLogLogcatListener : AndroidJavaProxy
+	{
+		private Queue<string> queuedLogs;
+		private AndroidJavaObject nativeObject;
+
+		public DebugLogLogcatListener() : base( "com.yasirkula.unity.DebugConsoleLogcatLogReceiver" )
+		{
+			queuedLogs = new Queue<string>( 16 );
+		}
+
+		~DebugLogLogcatListener()
+		{
+			Stop();
+
+			if( nativeObject != null )
+				nativeObject.Dispose();
+		}
+
+		public void Start( string arguments )
+		{
+			if( nativeObject == null )
+				nativeObject = new AndroidJavaObject( "com.yasirkula.unity.DebugConsoleLogcatLogger" );
+
+			nativeObject.Call( "Start", this, arguments );
+		}
+
+		public void Stop()
+		{
+			if( nativeObject != null )
+				nativeObject.Call( "Stop" );
+		}
+
+		public void OnLogReceived( string log )
+		{
+			queuedLogs.Enqueue( log );
+		}
+
+		public string GetLog()
+		{
+			if( queuedLogs.Count > 0 )
+				return queuedLogs.Dequeue();
+
+			return null;
+		}
+	}
+}
+#endif

Assets/Plugins/IngameDebugConsole/Android/DebugLogLogcatListener.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: dd3b7385882055d4a8c2b91deb6b2470
+timeCreated: 1510076185
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Android/IngameDebugConsole.aar.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: bf909fab1c14af446b0a854de42289b2
+timeCreated: 1510086220
+licenseType: Free
+PluginImporter:
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  isPreloaded: 0
+  isOverridable: 0
+  platformData:
+    data:
+      first:
+        Android: Android
+      second:
+        enabled: 1
+        settings: {}
+    data:
+      first:
+        Any: 
+      second:
+        enabled: 0
+        settings: {}
+    data:
+      first:
+        Editor: Editor
+      second:
+        enabled: 0
+        settings:
+          DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Editor.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 86f54622630720f4abe279acdbb8886f
+folderAsset: yes
+timeCreated: 1561217660
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Editor/DebugLogManagerEditor.cs

@@ -0,0 +1,160 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace IngameDebugConsole
+{
+	[CustomEditor( typeof( DebugLogManager ) )]
+	public class DebugLogManagerEditor : Editor
+	{
+		private SerializedProperty singleton;
+		private SerializedProperty minimumHeight;
+		private SerializedProperty enableHorizontalResizing;
+		private SerializedProperty resizeFromRight;
+		private SerializedProperty minimumWidth;
+		private SerializedProperty enablePopup;
+		private SerializedProperty startInPopupMode;
+		private SerializedProperty startMinimized;
+		private SerializedProperty toggleWithKey;
+		private SerializedProperty toggleKey;
+		private SerializedProperty enableSearchbar;
+		private SerializedProperty topSearchbarMinWidth;
+		private SerializedProperty receiveLogsWhileInactive;
+		private SerializedProperty receiveInfoLogs;
+		private SerializedProperty receiveWarningLogs;
+		private SerializedProperty receiveErrorLogs;
+		private SerializedProperty receiveExceptionLogs;
+		private SerializedProperty captureLogTimestamps;
+		private SerializedProperty alwaysDisplayTimestamps;
+		private SerializedProperty queuedLogLimit;
+		private SerializedProperty clearCommandAfterExecution;
+		private SerializedProperty commandHistorySize;
+		private SerializedProperty showCommandSuggestions;
+		private SerializedProperty receiveLogcatLogsInAndroid;
+		private SerializedProperty logcatArguments;
+		private SerializedProperty avoidScreenCutout;
+		private SerializedProperty popupAvoidsScreenCutout;
+		private SerializedProperty autoFocusOnCommandInputField;
+
+		private readonly GUIContent receivedLogTypesLabel = new GUIContent( "Received Log Types", "Only these logs will be received by the console window, other logs will simply be skipped" );
+		private readonly GUIContent receiveInfoLogsLabel = new GUIContent( "Info" );
+		private readonly GUIContent receiveWarningLogsLabel = new GUIContent( "Warning" );
+		private readonly GUIContent receiveErrorLogsLabel = new GUIContent( "Error" );
+		private readonly GUIContent receiveExceptionLogsLabel = new GUIContent( "Exception" );
+
+		private void OnEnable()
+		{
+			singleton = serializedObject.FindProperty( "singleton" );
+			minimumHeight = serializedObject.FindProperty( "minimumHeight" );
+			enableHorizontalResizing = serializedObject.FindProperty( "enableHorizontalResizing" );
+			resizeFromRight = serializedObject.FindProperty( "resizeFromRight" );
+			minimumWidth = serializedObject.FindProperty( "minimumWidth" );
+			enablePopup = serializedObject.FindProperty( "enablePopup" );
+			startInPopupMode = serializedObject.FindProperty( "startInPopupMode" );
+			startMinimized = serializedObject.FindProperty( "startMinimized" );
+			toggleWithKey = serializedObject.FindProperty( "toggleWithKey" );
+#if ENABLE_INPUT_SYSTEM && !ENABLE_LEGACY_INPUT_MANAGER
+			toggleKey = serializedObject.FindProperty( "toggleBinding" );
+#else
+			toggleKey = serializedObject.FindProperty( "toggleKey" );
+#endif
+			enableSearchbar = serializedObject.FindProperty( "enableSearchbar" );
+			topSearchbarMinWidth = serializedObject.FindProperty( "topSearchbarMinWidth" );
+			receiveLogsWhileInactive = serializedObject.FindProperty( "receiveLogsWhileInactive" );
+			receiveInfoLogs = serializedObject.FindProperty( "receiveInfoLogs" );
+			receiveWarningLogs = serializedObject.FindProperty( "receiveWarningLogs" );
+			receiveErrorLogs = serializedObject.FindProperty( "receiveErrorLogs" );
+			receiveExceptionLogs = serializedObject.FindProperty( "receiveExceptionLogs" );
+			captureLogTimestamps = serializedObject.FindProperty( "captureLogTimestamps" );
+			alwaysDisplayTimestamps = serializedObject.FindProperty( "alwaysDisplayTimestamps" );
+			queuedLogLimit = serializedObject.FindProperty( "queuedLogLimit" );
+			clearCommandAfterExecution = serializedObject.FindProperty( "clearCommandAfterExecution" );
+			commandHistorySize = serializedObject.FindProperty( "commandHistorySize" );
+			showCommandSuggestions = serializedObject.FindProperty( "showCommandSuggestions" );
+			receiveLogcatLogsInAndroid = serializedObject.FindProperty( "receiveLogcatLogsInAndroid" );
+			logcatArguments = serializedObject.FindProperty( "logcatArguments" );
+			avoidScreenCutout = serializedObject.FindProperty( "avoidScreenCutout" );
+			popupAvoidsScreenCutout = serializedObject.FindProperty( "popupAvoidsScreenCutout" );
+			autoFocusOnCommandInputField = serializedObject.FindProperty( "autoFocusOnCommandInputField" );
+		}
+
+		public override void OnInspectorGUI()
+		{
+			serializedObject.Update();
+
+			EditorGUILayout.PropertyField( singleton );
+
+			EditorGUILayout.Space();
+
+			EditorGUILayout.PropertyField( minimumHeight );
+
+			EditorGUILayout.PropertyField( enableHorizontalResizing );
+			if( enableHorizontalResizing.boolValue )
+			{
+				DrawSubProperty( resizeFromRight );
+				DrawSubProperty( minimumWidth );
+			}
+
+			EditorGUILayout.PropertyField( avoidScreenCutout );
+			DrawSubProperty( popupAvoidsScreenCutout );
+
+			EditorGUILayout.Space();
+
+			EditorGUILayout.PropertyField( enablePopup );
+			if( enablePopup.boolValue )
+				DrawSubProperty( startInPopupMode );
+			else
+				DrawSubProperty( startMinimized );
+
+			EditorGUILayout.PropertyField( toggleWithKey );
+			if( toggleWithKey.boolValue )
+				DrawSubProperty( toggleKey );
+
+			EditorGUILayout.Space();
+
+			EditorGUILayout.PropertyField( enableSearchbar );
+			if( enableSearchbar.boolValue )
+				DrawSubProperty( topSearchbarMinWidth );
+
+			EditorGUILayout.Space();
+
+			EditorGUILayout.PropertyField( receiveLogsWhileInactive );
+
+			EditorGUILayout.PrefixLabel( receivedLogTypesLabel );
+			EditorGUI.indentLevel++;
+			EditorGUILayout.PropertyField( receiveInfoLogs, receiveInfoLogsLabel );
+			EditorGUILayout.PropertyField( receiveWarningLogs, receiveWarningLogsLabel );
+			EditorGUILayout.PropertyField( receiveErrorLogs, receiveErrorLogsLabel );
+			EditorGUILayout.PropertyField( receiveExceptionLogs, receiveExceptionLogsLabel );
+			EditorGUI.indentLevel--;
+
+			EditorGUILayout.PropertyField( receiveLogcatLogsInAndroid );
+			if( receiveLogcatLogsInAndroid.boolValue )
+				DrawSubProperty( logcatArguments );
+
+			EditorGUILayout.PropertyField( captureLogTimestamps );
+			if( captureLogTimestamps.boolValue )
+				DrawSubProperty( alwaysDisplayTimestamps );
+
+			EditorGUILayout.PropertyField( queuedLogLimit );
+
+			EditorGUILayout.Space();
+
+			EditorGUILayout.PropertyField( clearCommandAfterExecution );
+			EditorGUILayout.PropertyField( commandHistorySize );
+			EditorGUILayout.PropertyField( showCommandSuggestions );
+			EditorGUILayout.PropertyField( autoFocusOnCommandInputField );
+
+			EditorGUILayout.Space();
+
+			DrawPropertiesExcluding( serializedObject, "m_Script" );
+			serializedObject.ApplyModifiedProperties();
+		}
+
+		private void DrawSubProperty( SerializedProperty property )
+		{
+			EditorGUI.indentLevel++;
+			EditorGUILayout.PropertyField( property );
+			EditorGUI.indentLevel--;
+		}
+	}
+}

Assets/Plugins/IngameDebugConsole/Editor/DebugLogManagerEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 4c23e5c521cb0c54b9a638b2a653d1d3
+timeCreated: 1561217671
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Editor/IngameDebugConsole.Editor.asmdef

@@ -0,0 +1,17 @@
+{
+    "name": "IngameDebugConsole.Editor",
+    "references": [
+        "IngameDebugConsole.Runtime"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Assets/Plugins/IngameDebugConsole/Editor/IngameDebugConsole.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 466e67dabd1db22468246c39eddb6c3f
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/IngameDebugConsole.Runtime.asmdef

@@ -0,0 +1,6 @@
+{
+    "name": "IngameDebugConsole.Runtime",
+    "references": [
+        "Unity.InputSystem"
+    ]
+}

Assets/Plugins/IngameDebugConsole/IngameDebugConsole.Runtime.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 3de88c88fbbb8f944b9210d496af9762
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/README.txt

@@ -0,0 +1,7 @@
+= In-game Debug Console (v1.6.2) =
+
+Documentation: https://github.com/yasirkula/UnityIngameDebugConsole
+FAQ: https://github.com/yasirkula/UnityIngameDebugConsole#faq
+E-mail: yasirkula@gmail.com
+
+You can simply place the IngameDebugConsole prefab to your scene. Hovering the cursor over its properties in the Inspector will reveal explanatory tooltips.

Assets/Plugins/IngameDebugConsole/README.txt.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: edf2ac73f7bc3064c96d53009106dc53
+timeCreated: 1563307881
+licenseType: Free
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 860c08388401a6d4e858fe4910ea9337
+folderAsset: yes
+timeCreated: 1465930645
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts/CircularBuffer.cs

@@ -0,0 +1,119 @@
+// #define RESET_REMOVED_ELEMENTS
+
+namespace IngameDebugConsole
+{
+	public class CircularBuffer<T>
+	{
+		private T[] arr;
+		private int startIndex;
+
+		public int Count { get; private set; }
+		public T this[int index] { get { return arr[( startIndex + index ) % arr.Length]; } }
+
+		public CircularBuffer( int capacity )
+		{
+			arr = new T[capacity];
+		}
+
+		// Old elements are overwritten when capacity is reached
+		public void Add( T value )
+		{
+			if( Count < arr.Length )
+				arr[Count++] = value;
+			else
+			{
+				arr[startIndex] = value;
+				if( ++startIndex >= arr.Length )
+					startIndex = 0;
+			}
+		}
+	}
+
+	public class DynamicCircularBuffer<T>
+	{
+		private T[] arr;
+		private int startIndex;
+
+		public int Count { get; private set; }
+		public int Capacity { get { return arr.Length; } }
+
+		public T this[int index]
+		{
+			get { return arr[( startIndex + index ) % arr.Length]; }
+			set { arr[( startIndex + index ) % arr.Length] = value; }
+		}
+
+		public DynamicCircularBuffer( int initialCapacity = 2 )
+		{
+			arr = new T[initialCapacity];
+		}
+
+		public void Add( T value )
+		{
+			if( Count >= arr.Length )
+			{
+				int prevSize = arr.Length;
+				int newSize = prevSize > 0 ? prevSize * 2 : 2; // Size must be doubled (at least), or the shift operation below must consider IndexOutOfRange situations
+
+				System.Array.Resize( ref arr, newSize );
+
+				if( startIndex > 0 )
+				{
+					if( startIndex <= ( prevSize - 1 ) / 2 )
+					{
+						// Move elements [0,startIndex) to the end
+						for( int i = 0; i < startIndex; i++ )
+						{
+							arr[i + prevSize] = arr[i];
+#if RESET_REMOVED_ELEMENTS
+							arr[i] = default( T );
+#endif
+						}
+					}
+					else
+					{
+						// Move elements [startIndex,prevSize) to the end
+						int delta = newSize - prevSize;
+						for( int i = prevSize - 1; i >= startIndex; i-- )
+						{
+							arr[i + delta] = arr[i];
+#if RESET_REMOVED_ELEMENTS
+							arr[i] = default( T );
+#endif
+						}
+
+						startIndex += delta;
+					}
+				}
+			}
+
+			this[Count++] = value;
+		}
+
+		public T RemoveFirst()
+		{
+			T element = arr[startIndex];
+#if RESET_REMOVED_ELEMENTS
+			arr[startIndex] = default( T );
+#endif
+
+			if( ++startIndex >= arr.Length )
+				startIndex = 0;
+
+			Count--;
+			return element;
+		}
+
+		public T RemoveLast()
+		{
+			int index = ( startIndex + Count - 1 ) % arr.Length;
+			T element = arr[index];
+#if RESET_REMOVED_ELEMENTS
+			arr[index] = default( T );
+#endif
+
+			Count--;
+			return element;
+		}
+	}
+}

Assets/Plugins/IngameDebugConsole/Scripts/CircularBuffer.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 6136cb3c00eac0149901b8e7f2fecef8
+timeCreated: 1550943949
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts/Commands.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: bb9b6e1ab379cec46bfae8f8abcc1f45
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts/Commands/PlayerPrefsCommands.cs

@@ -0,0 +1,58 @@
+using UnityEngine;
+
+namespace IngameDebugConsole.Commands
+{
+	public class PlayerPrefsCommands
+	{
+		[ConsoleMethod( "prefs.int", "Returns the value of an Integer PlayerPrefs field" ), UnityEngine.Scripting.Preserve]
+		public static string PlayerPrefsGetInt( string key )
+		{
+			if( !PlayerPrefs.HasKey( key ) ) return "Key Not Found";
+			return PlayerPrefs.GetInt( key ).ToString();
+		}
+
+		[ConsoleMethod( "prefs.int", "Sets the value of an Integer PlayerPrefs field" ), UnityEngine.Scripting.Preserve]
+		public static void PlayerPrefsSetInt( string key, int value )
+		{
+			PlayerPrefs.SetInt( key, value );
+		}
+
+		[ConsoleMethod( "prefs.float", "Returns the value of a Float PlayerPrefs field" ), UnityEngine.Scripting.Preserve]
+		public static string PlayerPrefsGetFloat( string key )
+		{
+			if( !PlayerPrefs.HasKey( key ) ) return "Key Not Found";
+			return PlayerPrefs.GetFloat( key ).ToString();
+		}
+
+		[ConsoleMethod( "prefs.float", "Sets the value of a Float PlayerPrefs field" ), UnityEngine.Scripting.Preserve]
+		public static void PlayerPrefsSetFloat( string key, float value )
+		{
+			PlayerPrefs.SetFloat( key, value );
+		}
+
+		[ConsoleMethod( "prefs.string", "Returns the value of a String PlayerPrefs field" ), UnityEngine.Scripting.Preserve]
+		public static string PlayerPrefsGetString( string key )
+		{
+			if( !PlayerPrefs.HasKey( key ) ) return "Key Not Found";
+			return PlayerPrefs.GetString( key );
+		}
+
+		[ConsoleMethod( "prefs.string", "Sets the value of a String PlayerPrefs field" ), UnityEngine.Scripting.Preserve]
+		public static void PlayerPrefsSetString( string key, string value )
+		{
+			PlayerPrefs.SetString( key, value );
+		}
+
+		[ConsoleMethod( "prefs.delete", "Deletes a PlayerPrefs field" ), UnityEngine.Scripting.Preserve]
+		public static void PlayerPrefsDelete( string key )
+		{
+			PlayerPrefs.DeleteKey( key );
+		}
+
+		[ConsoleMethod( "prefs.clear", "Deletes all PlayerPrefs fields" ), UnityEngine.Scripting.Preserve]
+		public static void PlayerPrefsClear()
+		{
+			PlayerPrefs.DeleteAll();
+		}
+	}
+}

Assets/Plugins/IngameDebugConsole/Scripts/Commands/PlayerPrefsCommands.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 33fb3ee25c8764f4c905fa3ac7c4eb89
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts/Commands/SceneCommands.cs

@@ -0,0 +1,58 @@
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace IngameDebugConsole.Commands
+{
+	public class SceneCommands
+	{
+		[ConsoleMethod( "scene.load", "Loads a scene" ), UnityEngine.Scripting.Preserve]
+		public static void LoadScene( string sceneName )
+		{
+			LoadSceneInternal( sceneName, false, LoadSceneMode.Single );
+		}
+
+		[ConsoleMethod( "scene.load", "Loads a scene" ), UnityEngine.Scripting.Preserve]
+		public static void LoadScene( string sceneName, LoadSceneMode mode )
+		{
+			LoadSceneInternal( sceneName, false, mode );
+		}
+
+		[ConsoleMethod( "scene.loadasync", "Loads a scene asynchronously" ), UnityEngine.Scripting.Preserve]
+		public static void LoadSceneAsync( string sceneName )
+		{
+			LoadSceneInternal( sceneName, true, LoadSceneMode.Single );
+		}
+
+		[ConsoleMethod( "scene.loadasync", "Loads a scene asynchronously" ), UnityEngine.Scripting.Preserve]
+		public static void LoadSceneAsync( string sceneName, LoadSceneMode mode )
+		{
+			LoadSceneInternal( sceneName, true, mode );
+		}
+
+		private static void LoadSceneInternal( string sceneName, bool isAsync, LoadSceneMode mode )
+		{
+			if( SceneManager.GetSceneByName( sceneName ).IsValid() )
+			{
+				Debug.Log( "Scene " + sceneName + " is already loaded" );
+				return;
+			}
+
+			if( isAsync )
+				SceneManager.LoadSceneAsync( sceneName, mode );
+			else
+				SceneManager.LoadScene( sceneName, mode );
+		}
+
+		[ConsoleMethod( "scene.unload", "Unloads a scene" ), UnityEngine.Scripting.Preserve]
+		public static void UnloadScene( string sceneName )
+		{
+			SceneManager.UnloadSceneAsync( sceneName );
+		}
+
+		[ConsoleMethod( "scene.restart", "Restarts the active scene" ), UnityEngine.Scripting.Preserve]
+		public static void RestartScene()
+		{
+			SceneManager.LoadScene( SceneManager.GetActiveScene().name, LoadSceneMode.Single );
+		}
+	}
+}

Assets/Plugins/IngameDebugConsole/Scripts/Commands/SceneCommands.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 45984eacd62d9a3489fd62689265a23c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts/Commands/TimeCommands.cs

@@ -0,0 +1,19 @@
+using UnityEngine;
+
+namespace IngameDebugConsole.Commands
+{
+	public class TimeCommands
+	{
+		[ConsoleMethod( "time.scale", "Sets the Time.timeScale value" ), UnityEngine.Scripting.Preserve]
+		public static void SetTimeScale( float value )
+		{
+			Time.timeScale = Mathf.Max( value, 0f );
+		}
+
+		[ConsoleMethod( "time.scale", "Returns the current Time.timeScale value" ), UnityEngine.Scripting.Preserve]
+		public static float GetTimeScale()
+		{
+			return Time.timeScale;
+		}
+	}
+}

Assets/Plugins/IngameDebugConsole/Scripts/Commands/TimeCommands.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bb12a1f557fffa541909fcfe92d9c1bf
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts/ConsoleMethodAttribute.cs

@@ -0,0 +1,23 @@
+using System;
+
+namespace IngameDebugConsole
+{
+	[AttributeUsage( AttributeTargets.Method, Inherited = false, AllowMultiple = true )]
+	public class ConsoleMethodAttribute : Attribute
+	{
+		private string m_command;
+		private string m_description;
+		private string[] m_parameterNames;
+
+		public string Command { get { return m_command; } }
+		public string Description { get { return m_description; } }
+		public string[] ParameterNames { get { return m_parameterNames; } }
+
+		public ConsoleMethodAttribute( string command, string description, params string[] parameterNames )
+		{
+			m_command = command;
+			m_description = description;
+			m_parameterNames = parameterNames;
+		}
+	}
+}

Assets/Plugins/IngameDebugConsole/Scripts/ConsoleMethodAttribute.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 324bb39c0bff0f74fa42f83e91f07e3a
+timeCreated: 1520710946
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts/DebugLogConsole.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d15693a03d0d33b4892c6365a2a97e19
+timeCreated: 1472036503
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts/DebugLogEntry.cs

@@ -0,0 +1,170 @@
+using System.Globalization;
+using System.Text;
+using UnityEngine;
+
+// Container for a simple debug entry
+namespace IngameDebugConsole
+{
+	public class DebugLogEntry : System.IEquatable<DebugLogEntry>
+	{
+		private const int HASH_NOT_CALCULATED = -623218;
+
+		public string logString;
+		public string stackTrace;
+
+		private string completeLog;
+
+		// Sprite to show with this entry
+		public Sprite logTypeSpriteRepresentation;
+
+		// Collapsed count
+		public int count;
+
+		private int hashValue;
+
+		public void Initialize( string logString, string stackTrace )
+		{
+			this.logString = logString;
+			this.stackTrace = stackTrace;
+
+			completeLog = null;
+			count = 1;
+			hashValue = HASH_NOT_CALCULATED;
+		}
+
+		// Check if two entries have the same origin
+		public bool Equals( DebugLogEntry other )
+		{
+			return this.logString == other.logString && this.stackTrace == other.stackTrace;
+		}
+
+		// Checks if logString or stackTrace contains the search term
+		public bool MatchesSearchTerm( string searchTerm )
+		{
+			return ( logString != null && DebugLogConsole.caseInsensitiveComparer.IndexOf( logString, searchTerm, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) >= 0 ) ||
+				( stackTrace != null && DebugLogConsole.caseInsensitiveComparer.IndexOf( stackTrace, searchTerm, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) >= 0 );
+		}
+
+		// Return a string containing complete information about this debug entry
+		public override string ToString()
+		{
+			if( completeLog == null )
+				completeLog = string.Concat( logString, "\n", stackTrace );
+
+			return completeLog;
+		}
+
+		// Credit: https://stackoverflow.com/a/19250516/2373034
+		public override int GetHashCode()
+		{
+			if( hashValue == HASH_NOT_CALCULATED )
+			{
+				unchecked
+				{
+					hashValue = 17;
+					hashValue = hashValue * 23 + ( logString == null ? 0 : logString.GetHashCode() );
+					hashValue = hashValue * 23 + ( stackTrace == null ? 0 : stackTrace.GetHashCode() );
+				}
+			}
+
+			return hashValue;
+		}
+	}
+
+	public struct QueuedDebugLogEntry
+	{
+		public readonly string logString;
+		public readonly string stackTrace;
+		public readonly LogType logType;
+
+		public QueuedDebugLogEntry( string logString, string stackTrace, LogType logType )
+		{
+			this.logString = logString;
+			this.stackTrace = stackTrace;
+			this.logType = logType;
+		}
+
+		// Checks if logString or stackTrace contains the search term
+		public bool MatchesSearchTerm( string searchTerm )
+		{
+			return ( logString != null && DebugLogConsole.caseInsensitiveComparer.IndexOf( logString, searchTerm, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) >= 0 ) ||
+				( stackTrace != null && DebugLogConsole.caseInsensitiveComparer.IndexOf( stackTrace, searchTerm, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) >= 0 );
+		}
+	}
+
+	public struct DebugLogEntryTimestamp
+	{
+		public readonly System.DateTime dateTime;
+#if !IDG_OMIT_ELAPSED_TIME
+		public readonly float elapsedSeconds;
+#endif
+#if !IDG_OMIT_FRAMECOUNT
+		public readonly int frameCount;
+#endif
+
+#if !IDG_OMIT_ELAPSED_TIME && !IDG_OMIT_FRAMECOUNT
+		public DebugLogEntryTimestamp( System.DateTime dateTime, float elapsedSeconds, int frameCount )
+#elif !IDG_OMIT_ELAPSED_TIME
+		public DebugLogEntryTimestamp( System.DateTime dateTime, float elapsedSeconds )
+#elif !IDG_OMIT_FRAMECOUNT
+		public DebugLogEntryTimestamp( System.DateTime dateTime, int frameCount )
+#else
+		public DebugLogEntryTimestamp( System.DateTime dateTime )
+#endif
+		{
+			this.dateTime = dateTime;
+#if !IDG_OMIT_ELAPSED_TIME
+			this.elapsedSeconds = elapsedSeconds;
+#endif
+#if !IDG_OMIT_FRAMECOUNT
+			this.frameCount = frameCount;
+#endif
+		}
+
+		public void AppendTime( StringBuilder sb )
+		{
+			// Add DateTime in format: [HH:mm:ss]
+			sb.Append( "[" );
+
+			int hour = dateTime.Hour;
+			if( hour >= 10 )
+				sb.Append( hour );
+			else
+				sb.Append( "0" ).Append( hour );
+
+			sb.Append( ":" );
+
+			int minute = dateTime.Minute;
+			if( minute >= 10 )
+				sb.Append( minute );
+			else
+				sb.Append( "0" ).Append( minute );
+
+			sb.Append( ":" );
+
+			int second = dateTime.Second;
+			if( second >= 10 )
+				sb.Append( second );
+			else
+				sb.Append( "0" ).Append( second );
+
+			sb.Append( "]" );
+		}
+
+		public void AppendFullTimestamp( StringBuilder sb )
+		{
+			AppendTime( sb );
+
+#if !IDG_OMIT_ELAPSED_TIME && !IDG_OMIT_FRAMECOUNT
+			// Append elapsed seconds and frame count in format: [1.0s at #Frame]
+			sb.Append( "[" ).Append( elapsedSeconds.ToString( "F1" ) ).Append( "s at " ).Append( "#" ).Append( frameCount ).Append( "]" );
+#elif !IDG_OMIT_ELAPSED_TIME
+			// Append elapsed seconds in format: [1.0s]
+			sb.Append( "[" ).Append( elapsedSeconds.ToString( "F1" ) ).Append( "s]" );
+#elif !IDG_OMIT_FRAMECOUNT
+			// Append frame count in format: [#Frame]
+			sb.Append( "[#" ).Append( frameCount ).Append( "]" );
+#endif
+		}
+	}
+}

Assets/Plugins/IngameDebugConsole/Scripts/DebugLogEntry.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e7b1a420c564be040bf73b8a377fc2c2
+timeCreated: 1466375168
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts/DebugLogIndexList.cs

@@ -0,0 +1,39 @@
+namespace IngameDebugConsole
+{
+	public class DebugLogIndexList<T>
+	{
+		private T[] indices;
+		private int size;
+
+		public int Count { get { return size; } }
+		public T this[int index]
+		{
+			get { return indices[index]; }
+			set { indices[index] = value; }
+		}
+
+		public DebugLogIndexList()
+		{
+			indices = new T[64];
+			size = 0;
+		}
+
+		public void Add( T value )
+		{
+			if( size == indices.Length )
+				System.Array.Resize( ref indices, size * 2 );
+
+			indices[size++] = value;
+		}
+
+		public void Clear()
+		{
+			size = 0;
+		}
+
+		public int IndexOf( T value )
+		{
+			return System.Array.IndexOf( indices, value );
+		}
+	}
+}

Assets/Plugins/IngameDebugConsole/Scripts/DebugLogIndexList.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 37c6c91e5bfac6f499698c03f593bcbb
+timeCreated: 1520627934
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts/DebugLogItem.cs

@@ -0,0 +1,283 @@
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.EventSystems;
+using System.Text;
+#if UNITY_EDITOR
+using UnityEditor;
+using System.Text.RegularExpressions;
+#endif
+
+// A UI element to show information about a debug entry
+namespace IngameDebugConsole
+{
+	public class DebugLogItem : MonoBehaviour, IPointerClickHandler
+	{
+		#region Platform Specific Elements
+#if !UNITY_2018_1_OR_NEWER
+#if !UNITY_EDITOR && UNITY_ANDROID
+		private static AndroidJavaClass m_ajc = null;
+		private static AndroidJavaClass AJC
+		{
+			get
+			{
+				if( m_ajc == null )
+					m_ajc = new AndroidJavaClass( "com.yasirkula.unity.DebugConsole" );
+
+				return m_ajc;
+			}
+		}
+
+		private static AndroidJavaObject m_context = null;
+		private static AndroidJavaObject Context
+		{
+			get
+			{
+				if( m_context == null )
+				{
+					using( AndroidJavaObject unityClass = new AndroidJavaClass( "com.unity3d.player.UnityPlayer" ) )
+					{
+						m_context = unityClass.GetStatic<AndroidJavaObject>( "currentActivity" );
+					}
+				}
+
+				return m_context;
+			}
+		}
+#elif !UNITY_EDITOR && UNITY_IOS
+		[System.Runtime.InteropServices.DllImport( "__Internal" )]
+		private static extern void _DebugConsole_CopyText( string text );
+#endif
+#endif
+		#endregion
+
+#pragma warning disable 0649
+		// Cached components
+		[SerializeField]
+		private RectTransform transformComponent;
+		public RectTransform Transform { get { return transformComponent; } }
+
+		[SerializeField]
+		private Image imageComponent;
+		public Image Image { get { return imageComponent; } }
+
+		[SerializeField]
+		private CanvasGroup canvasGroupComponent;
+		public CanvasGroup CanvasGroup { get { return canvasGroupComponent; } }
+
+		[SerializeField]
+		private Text logText;
+		[SerializeField]
+		private Image logTypeImage;
+
+		// Objects related to the collapsed count of the debug entry
+		[SerializeField]
+		private GameObject logCountParent;
+		[SerializeField]
+		private Text logCountText;
+
+		[SerializeField]
+		private RectTransform copyLogButton;
+#pragma warning restore 0649
+
+		// Debug entry to show with this log item
+		private DebugLogEntry logEntry;
+		public DebugLogEntry Entry { get { return logEntry; } }
+
+		private DebugLogEntryTimestamp? logEntryTimestamp;
+		public DebugLogEntryTimestamp? Timestamp { get { return logEntryTimestamp; } }
+
+		// Index of the entry in the list of entries
+		private int entryIndex;
+		public int Index { get { return entryIndex; } }
+
+		private bool isExpanded;
+		public bool Expanded { get { return isExpanded; } }
+
+		private Vector2 logTextOriginalPosition;
+		private Vector2 logTextOriginalSize;
+		private float copyLogButtonHeight;
+
+		private DebugLogRecycledListView listView;
+
+		public void Initialize( DebugLogRecycledListView listView )
+		{
+			this.listView = listView;
+
+			logTextOriginalPosition = logText.rectTransform.anchoredPosition;
+			logTextOriginalSize = logText.rectTransform.sizeDelta;
+			copyLogButtonHeight = copyLogButton.anchoredPosition.y + copyLogButton.sizeDelta.y + 2f; // 2f: space between text and button
+
+#if !UNITY_EDITOR && UNITY_WEBGL
+			copyLogButton.gameObject.AddComponent<DebugLogItemCopyWebGL>().Initialize( this );
+#endif
+		}
+
+		public void SetContent( DebugLogEntry logEntry, DebugLogEntryTimestamp? logEntryTimestamp, int entryIndex, bool isExpanded )
+		{
+			this.logEntry = logEntry;
+			this.logEntryTimestamp = logEntryTimestamp;
+			this.entryIndex = entryIndex;
+			this.isExpanded = isExpanded;
+
+			Vector2 size = transformComponent.sizeDelta;
+			if( isExpanded )
+			{
+				logText.horizontalOverflow = HorizontalWrapMode.Wrap;
+				size.y = listView.SelectedItemHeight;
+
+				if( !copyLogButton.gameObject.activeSelf )
+				{
+					copyLogButton.gameObject.SetActive( true );
+
+					logText.rectTransform.anchoredPosition = new Vector2( logTextOriginalPosition.x, logTextOriginalPosition.y + copyLogButtonHeight * 0.5f );
+					logText.rectTransform.sizeDelta = logTextOriginalSize - new Vector2( 0f, copyLogButtonHeight );
+				}
+			}
+			else
+			{
+				logText.horizontalOverflow = HorizontalWrapMode.Overflow;
+				size.y = listView.ItemHeight;
+
+				if( copyLogButton.gameObject.activeSelf )
+				{
+					copyLogButton.gameObject.SetActive( false );
+
+					logText.rectTransform.anchoredPosition = logTextOriginalPosition;
+					logText.rectTransform.sizeDelta = logTextOriginalSize;
+				}
+			}
+
+			transformComponent.sizeDelta = size;
+
+			SetText( logEntry, logEntryTimestamp, isExpanded );
+			logTypeImage.sprite = logEntry.logTypeSpriteRepresentation;
+		}
+
+		// Show the collapsed count of the debug entry
+		public void ShowCount()
+		{
+			logCountText.text = logEntry.count.ToString();
+
+			if( !logCountParent.activeSelf )
+				logCountParent.SetActive( true );
+		}
+
+		// Hide the collapsed count of the debug entry
+		public void HideCount()
+		{
+			if( logCountParent.activeSelf )
+				logCountParent.SetActive( false );
+		}
+
+		// Update the debug entry's displayed timestamp
+		public void UpdateTimestamp( DebugLogEntryTimestamp timestamp )
+		{
+			logEntryTimestamp = timestamp;
+
+			if( isExpanded || listView.manager.alwaysDisplayTimestamps )
+				SetText( logEntry, timestamp, isExpanded );
+		}
+
+		private void SetText( DebugLogEntry logEntry, DebugLogEntryTimestamp? logEntryTimestamp, bool isExpanded )
+		{
+			if( !logEntryTimestamp.HasValue || ( !isExpanded && !listView.manager.alwaysDisplayTimestamps ) )
+				logText.text = isExpanded ? logEntry.ToString() : logEntry.logString;
+			else
+			{
+				StringBuilder sb = listView.manager.sharedStringBuilder;
+				sb.Length = 0;
+
+				if( isExpanded )
+				{
+					logEntryTimestamp.Value.AppendFullTimestamp( sb );
+					sb.Append( ": " ).Append( logEntry.ToString() );
+				}
+				else
+				{
+					logEntryTimestamp.Value.AppendTime( sb );
+					sb.Append( " " ).Append( logEntry.logString );
+				}
+
+				logText.text = sb.ToString();
+			}
+		}
+
+		// This log item is clicked, show the debug entry's stack trace
+		public void OnPointerClick( PointerEventData eventData )
+		{
+#if UNITY_EDITOR
+			if( eventData.button == PointerEventData.InputButton.Right )
+			{
+				Match regex = Regex.Match( logEntry.stackTrace, @"\(at .*\.cs:[0-9]+\)$", RegexOptions.Multiline );
+				if( regex.Success )
+				{
+					string line = logEntry.stackTrace.Substring( regex.Index + 4, regex.Length - 5 );
+					int lineSeparator = line.IndexOf( ':' );
+					MonoScript script = AssetDatabase.LoadAssetAtPath<MonoScript>( line.Substring( 0, lineSeparator ) );
+					if( script != null )
+						AssetDatabase.OpenAsset( script, int.Parse( line.Substring( lineSeparator + 1 ) ) );
+				}
+			}
+			else
+				listView.OnLogItemClicked( this );
+#else
+			listView.OnLogItemClicked( this );
+#endif
+		}
+
+		public void CopyLog()
+		{
+#if UNITY_EDITOR || !UNITY_WEBGL
+			string log = GetCopyContent();
+			if( string.IsNullOrEmpty( log ) )
+				return;
+
+#if UNITY_EDITOR || UNITY_2018_1_OR_NEWER || ( !UNITY_ANDROID && !UNITY_IOS )
+			GUIUtility.systemCopyBuffer = log;
+#elif UNITY_ANDROID
+			AJC.CallStatic( "CopyText", Context, log );
+#elif UNITY_IOS
+			_DebugConsole_CopyText( log );
+#endif
+#endif
+		}
+
+		internal string GetCopyContent()
+		{
+			if( !logEntryTimestamp.HasValue )
+				return logEntry.ToString();
+			else
+			{
+				StringBuilder sb = listView.manager.sharedStringBuilder;
+				sb.Length = 0;
+
+				logEntryTimestamp.Value.AppendFullTimestamp( sb );
+				sb.Append( ": " ).Append( logEntry.ToString() );
+
+				return sb.ToString();
+			}
+		}
+
+		public float CalculateExpandedHeight( DebugLogEntry logEntry, DebugLogEntryTimestamp? logEntryTimestamp )
+		{
+			string text = logText.text;
+			HorizontalWrapMode wrapMode = logText.horizontalOverflow;
+
+			SetText( logEntry, logEntryTimestamp, true );
+			logText.horizontalOverflow = HorizontalWrapMode.Wrap;
+
+			float result = logText.preferredHeight + copyLogButtonHeight;
+
+			logText.text = text;
+			logText.horizontalOverflow = wrapMode;
+
+			return Mathf.Max( listView.ItemHeight, result );
+		}
+
+		// Return a string containing complete information about the debug entry
+		public override string ToString()
+		{
+			return logEntry.ToString();
+		}
+	}
+}

Assets/Plugins/IngameDebugConsole/Scripts/DebugLogItem.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d2ea291be9de70a4abfec595203c96c1
+timeCreated: 1465919949
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts/DebugLogItemCopyWebGL.cs

@@ -0,0 +1,36 @@
+#if !UNITY_EDITOR && UNITY_WEBGL
+using System.Runtime.InteropServices;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace IngameDebugConsole
+{
+	public class DebugLogItemCopyWebGL : MonoBehaviour, IPointerDownHandler, IPointerUpHandler
+	{
+		[DllImport( "__Internal" )]
+		private static extern void IngameDebugConsoleStartCopy( string textToCopy );
+		[DllImport( "__Internal" )]
+		private static extern void IngameDebugConsoleCancelCopy();
+
+		private DebugLogItem logItem;
+
+		public void Initialize( DebugLogItem logItem )
+		{
+			this.logItem = logItem;
+		}
+
+		public void OnPointerDown( PointerEventData eventData )
+		{
+			string log = logItem.GetCopyContent();
+			if( !string.IsNullOrEmpty( log ) )
+				IngameDebugConsoleStartCopy( log );
+		}
+
+		public void OnPointerUp( PointerEventData eventData )
+		{
+			if( eventData.dragging )
+				IngameDebugConsoleCancelCopy();
+		}
+	}
+}
+#endif

Assets/Plugins/IngameDebugConsole/Scripts/DebugLogItemCopyWebGL.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5a7d9d894141e704d8160fb4632121ac
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts/DebugLogManager.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 6a4f16ed905adcd4ab0d7c8c11f0d72c
+timeCreated: 1522092746
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: -9869
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts/DebugLogPopup.cs

@@ -0,0 +1,277 @@
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.EventSystems;
+using System.Collections;
+#if UNITY_EDITOR && UNITY_2021_1_OR_NEWER
+using Screen = UnityEngine.Device.Screen; // To support Device Simulator on Unity 2021.1+
+#endif
+
+// Manager class for the debug popup
+namespace IngameDebugConsole
+{
+    public class DebugLogPopup : MonoBehaviour, IPointerClickHandler, IBeginDragHandler, IDragHandler, IEndDragHandler
+    {
+        private RectTransform popupTransform;
+
+        // Dimensions of the popup divided by 2
+        private Vector2 halfSize;
+
+        // Background image that will change color to indicate an alert
+        private Image backgroundImage;
+
+        // Canvas group to modify visibility of the popup
+        private CanvasGroup canvasGroup;
+
+#pragma warning disable 0649
+        [SerializeField]
+        private DebugLogManager debugManager;
+
+        [SerializeField]
+        private Text newInfoCountText;
+        [SerializeField]
+        private Text newWarningCountText;
+        [SerializeField]
+        private Text newErrorCountText;
+
+        [SerializeField]
+        private Color alertColorInfo;
+        [SerializeField]
+        private Color alertColorWarning;
+        [SerializeField]
+        private Color alertColorError;
+#pragma warning restore 0649
+
+        // Number of new debug entries since the log window has been closed
+        private int newInfoCount = 0, newWarningCount = 0, newErrorCount = 0;
+
+        private Color normalColor;
+
+        private bool isPopupBeingDragged = false;
+        private Vector2 normalizedPosition;
+
+        // Coroutines for simple code-based animations
+        private IEnumerator moveToPosCoroutine = null;
+
+        private void Awake()
+        {
+            popupTransform = (RectTransform)transform;
+            backgroundImage = GetComponent<Image>();
+            canvasGroup = GetComponent<CanvasGroup>();
+
+            normalColor = backgroundImage.color;
+
+            halfSize = popupTransform.sizeDelta * 0.5f;
+
+            Vector2 pos = popupTransform.anchoredPosition;
+            if (pos.x != 0f || pos.y != 0f)
+                normalizedPosition = pos.normalized; // Respect the initial popup position set in the prefab
+            else
+                normalizedPosition = new Vector2(0.5f, 0f); // Right edge by default
+        }
+
+        public void NewLogsArrived(int newInfo, int newWarning, int newError)
+        {
+            if (newInfo > 0)
+            {
+                newInfoCount += newInfo;
+                newInfoCountText.text = newInfoCount.ToString();
+            }
+
+            if (newWarning > 0)
+            {
+                newWarningCount += newWarning;
+                newWarningCountText.text = newWarningCount.ToString();
+            }
+
+            if (newError > 0)
+            {
+                newErrorCount += newError;
+                newErrorCountText.text = newErrorCount.ToString();
+            }
+
+            if (newErrorCount > 0)
+                backgroundImage.color = alertColorError;
+            else if (newWarningCount > 0)
+                backgroundImage.color = alertColorWarning;
+            else
+                backgroundImage.color = alertColorInfo;
+        }
+
+        private void Reset()
+        {
+            newInfoCount = 0;
+            newWarningCount = 0;
+            newErrorCount = 0;
+
+            newInfoCountText.text = "0";
+            newWarningCountText.text = "0";
+            newErrorCountText.text = "0";
+
+            backgroundImage.color = normalColor;
+        }
+
+        // A simple smooth movement animation
+        private IEnumerator MoveToPosAnimation(Vector2 targetPos)
+        {
+            float modifier = 0f;
+            Vector2 initialPos = popupTransform.anchoredPosition;
+
+            while (modifier < 1f)
+            {
+                modifier += 4f * Time.unscaledDeltaTime;
+                popupTransform.anchoredPosition = Vector2.Lerp(initialPos, targetPos, modifier);
+
+                yield return null;
+            }
+        }
+
+        // Popup is clicked
+        public void OnPointerClick(PointerEventData data)
+        {
+            // Hide the popup and show the log window
+            if (!isPopupBeingDragged)
+                debugManager.ShowLogWindow();
+        }
+
+        // Hides the log window and shows the popup
+        public void Show()
+        {
+            canvasGroup.blocksRaycasts = true;
+            canvasGroup.alpha = 1f;
+
+            // Reset the counters
+            Reset();
+
+            // Update position in case resolution was changed while the popup was hidden
+            UpdatePosition(true);
+        }
+
+        // Hide the popup
+        public void Hide()
+        {
+            canvasGroup.blocksRaycasts = false;
+            canvasGroup.alpha = 0f;
+
+            isPopupBeingDragged = false;
+        }
+
+        public void OnBeginDrag(PointerEventData data)
+        {
+            isPopupBeingDragged = true;
+
+            // If a smooth movement animation is in progress, cancel it
+            if (moveToPosCoroutine != null)
+            {
+                StopCoroutine(moveToPosCoroutine);
+                moveToPosCoroutine = null;
+            }
+        }
+
+        // Reposition the popup
+        public void OnDrag(PointerEventData data)
+        {
+            Vector2 localPoint;
+            if (RectTransformUtility.ScreenPointToLocalPointInRectangle(debugManager.canvasTR, data.position, data.pressEventCamera, out localPoint))
+                popupTransform.anchoredPosition = localPoint;
+        }
+
+        // Smoothly translate the popup to the nearest edge
+        public void OnEndDrag(PointerEventData data)
+        {
+            isPopupBeingDragged = false;
+            UpdatePosition(false);
+        }
+
+        // There are 2 different spaces used in these calculations:
+        // RectTransform space: raw anchoredPosition of the popup that's in range [-canvasSize/2, canvasSize/2]
+        // Safe area space: Screen.safeArea space that's in range [safeAreaBottomLeft, safeAreaTopRight] where these corner positions
+        //                  are all positive (calculated from bottom left corner of the screen instead of the center of the screen)
+        public void UpdatePosition(bool immediately)
+        {
+            Vector2 canvasRawSize = debugManager.canvasTR.rect.size;
+
+            // Calculate safe area bounds
+            float canvasWidth = canvasRawSize.x;
+            float canvasHeight = canvasRawSize.y;
+
+            float canvasBottomLeftX = 0f;
+            float canvasBottomLeftY = 0f;
+
+            if (debugManager.popupAvoidsScreenCutout)
+            {
+#if UNITY_2017_2_OR_NEWER && (UNITY_EDITOR || UNITY_ANDROID || UNITY_IOS)
+                Rect safeArea = Screen.safeArea;
+
+                int screenWidth = Screen.width;
+                int screenHeight = Screen.height;
+
+                canvasWidth *= safeArea.width / screenWidth;
+                canvasHeight *= safeArea.height / screenHeight;
+
+                canvasBottomLeftX = canvasRawSize.x * (safeArea.x / screenWidth);
+                canvasBottomLeftY = canvasRawSize.y * (safeArea.y / screenHeight);
+#endif
+            }
+
+            // Calculate safe area position of the popup
+            // normalizedPosition allows us to glue the popup to a specific edge of the screen. It becomes useful when
+            // the popup is at the right edge and we switch from portrait screen orientation to landscape screen orientation.
+            // Without normalizedPosition, popup could jump to bottom or top edges instead of staying at the right edge
+            Vector2 pos = canvasRawSize * 0.5f + (immediately ? new Vector2(normalizedPosition.x * canvasWidth, normalizedPosition.y * canvasHeight) : (popupTransform.anchoredPosition - new Vector2(canvasBottomLeftX, canvasBottomLeftY)));
+
+            // Find distances to all four edges of the safe area
+            float distToLeft = pos.x;
+            float distToRight = canvasWidth - distToLeft;
+
+            float distToBottom = pos.y;
+            float distToTop = canvasHeight - distToBottom;
+
+            float horDistance = Mathf.Min(distToLeft, distToRight);
+            float vertDistance = Mathf.Min(distToBottom, distToTop);
+
+            // Find the nearest edge's safe area coordinates
+            if (horDistance < vertDistance)
+            {
+                if (distToLeft < distToRight)
+                    pos = new Vector2(halfSize.x, pos.y);
+                else
+                    pos = new Vector2(canvasWidth - halfSize.x, pos.y);
+
+                pos.y = Mathf.Clamp(pos.y, halfSize.y, canvasHeight - halfSize.y);
+            }
+            else
+            {
+                if (distToBottom < distToTop)
+                    pos = new Vector2(pos.x, halfSize.y);
+                else
+                    pos = new Vector2(pos.x, canvasHeight - halfSize.y);
+
+                pos.x = Mathf.Clamp(pos.x, halfSize.x, canvasWidth - halfSize.x);
+            }
+
+            pos -= canvasRawSize * 0.5f;
+
+            normalizedPosition.Set(pos.x / canvasWidth, pos.y / canvasHeight);
+
+            // Safe area's bottom left coordinates are added to pos only after normalizedPosition's value
+            // is set because normalizedPosition is in range [-canvasWidth / 2, canvasWidth / 2]
+            pos += new Vector2(canvasBottomLeftX, canvasBottomLeftY);
+
+            // If another smooth movement animation is in progress, cancel it
+            if (moveToPosCoroutine != null)
+            {
+                StopCoroutine(moveToPosCoroutine);
+                moveToPosCoroutine = null;
+            }
+
+            if (immediately)
+                popupTransform.anchoredPosition = pos;
+            else
+            {
+                // Smoothly translate the popup to the specified position
+                moveToPosCoroutine = MoveToPosAnimation(pos);
+                StartCoroutine(moveToPosCoroutine);
+            }
+        }
+    }
+}

Assets/Plugins/IngameDebugConsole/Scripts/DebugLogPopup.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 05cc4b1999716644c9308528e38e7081
+timeCreated: 1466533184
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts/DebugLogRecycledListView.cs

@@ -0,0 +1,392 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+// Handles the log items in an optimized way such that existing log items are
+// recycled within the list instead of creating a new log item at each chance
+namespace IngameDebugConsole
+{
+	public class DebugLogRecycledListView : MonoBehaviour
+	{
+#pragma warning disable 0649
+		// Cached components
+		[SerializeField]
+		private RectTransform transformComponent;
+		[SerializeField]
+		private RectTransform viewportTransform;
+
+		[SerializeField]
+		private Color logItemNormalColor1;
+		[SerializeField]
+		private Color logItemNormalColor2;
+		[SerializeField]
+		private Color logItemSelectedColor;
+#pragma warning restore 0649
+
+		internal DebugLogManager manager;
+		private ScrollRect scrollView;
+
+		private float logItemHeight, _1OverLogItemHeight;
+		private float viewportHeight;
+
+		// Unique debug entries
+		private List<DebugLogEntry> collapsedLogEntries = null;
+
+		// Indices of debug entries to show in collapsedLogEntries
+		private DebugLogIndexList<int> indicesOfEntriesToShow = null;
+		private DebugLogIndexList<DebugLogEntryTimestamp> timestampsOfEntriesToShow = null;
+
+		private int indexOfSelectedLogEntry = int.MaxValue;
+		private float positionOfSelectedLogEntry = float.MaxValue;
+		private float heightOfSelectedLogEntry;
+		private float deltaHeightOfSelectedLogEntry;
+
+		// Log items used to visualize the debug entries at specified indices
+		private readonly Dictionary<int, DebugLogItem> logItemsAtIndices = new Dictionary<int, DebugLogItem>( 256 );
+
+		private bool isCollapseOn = false;
+
+		// Current indices of debug entries shown on screen
+		private int currentTopIndex = -1, currentBottomIndex = -1;
+
+		public float ItemHeight { get { return logItemHeight; } }
+		public float SelectedItemHeight { get { return heightOfSelectedLogEntry; } }
+
+		private void Awake()
+		{
+			scrollView = viewportTransform.GetComponentInParent<ScrollRect>();
+			scrollView.onValueChanged.AddListener( ( pos ) => UpdateItemsInTheList( false ) );
+
+			viewportHeight = viewportTransform.rect.height;
+		}
+
+		public void Initialize( DebugLogManager manager, List<DebugLogEntry> collapsedLogEntries, DebugLogIndexList<int> indicesOfEntriesToShow, DebugLogIndexList<DebugLogEntryTimestamp> timestampsOfEntriesToShow, float logItemHeight )
+		{
+			this.manager = manager;
+			this.collapsedLogEntries = collapsedLogEntries;
+			this.indicesOfEntriesToShow = indicesOfEntriesToShow;
+			this.timestampsOfEntriesToShow = timestampsOfEntriesToShow;
+			this.logItemHeight = logItemHeight;
+			_1OverLogItemHeight = 1f / logItemHeight;
+		}
+
+		public void SetCollapseMode( bool collapse )
+		{
+			isCollapseOn = collapse;
+		}
+
+		// A log item is clicked, highlight it
+		public void OnLogItemClicked( DebugLogItem item )
+		{
+			OnLogItemClickedInternal( item.Index, item );
+		}
+
+		// Force expand the log item at specified index
+		public void SelectAndFocusOnLogItemAtIndex( int itemIndex )
+		{
+			if( indexOfSelectedLogEntry != itemIndex ) // Make sure that we aren't deselecting the target log item
+				OnLogItemClickedInternal( itemIndex );
+
+			float transformComponentCenterYAtTop = viewportHeight * 0.5f;
+			float transformComponentCenterYAtBottom = transformComponent.sizeDelta.y - viewportHeight * 0.5f;
+			float transformComponentTargetCenterY = itemIndex * logItemHeight + viewportHeight * 0.5f;
+			if( transformComponentCenterYAtTop == transformComponentCenterYAtBottom )
+				scrollView.verticalNormalizedPosition = 0.5f;
+			else
+				scrollView.verticalNormalizedPosition = Mathf.Clamp01( Mathf.InverseLerp( transformComponentCenterYAtBottom, transformComponentCenterYAtTop, transformComponentTargetCenterY ) );
+
+			manager.SetSnapToBottom( false );
+		}
+
+		private void OnLogItemClickedInternal( int itemIndex, DebugLogItem referenceItem = null )
+		{
+			if( indexOfSelectedLogEntry != itemIndex )
+			{
+				DeselectSelectedLogItem();
+
+				if( !referenceItem )
+				{
+					if( currentTopIndex == -1 )
+						UpdateItemsInTheList( false ); // Try to generate some DebugLogItems, we need one DebugLogItem to calculate the text height
+
+					referenceItem = logItemsAtIndices[currentTopIndex];
+				}
+
+				indexOfSelectedLogEntry = itemIndex;
+				positionOfSelectedLogEntry = itemIndex * logItemHeight;
+				heightOfSelectedLogEntry = referenceItem.CalculateExpandedHeight( collapsedLogEntries[indicesOfEntriesToShow[itemIndex]], ( timestampsOfEntriesToShow != null ) ? timestampsOfEntriesToShow[itemIndex] : (DebugLogEntryTimestamp?) null );
+				deltaHeightOfSelectedLogEntry = heightOfSelectedLogEntry - logItemHeight;
+
+				manager.SetSnapToBottom( false );
+			}
+			else
+				DeselectSelectedLogItem();
+
+			if( indexOfSelectedLogEntry >= currentTopIndex && indexOfSelectedLogEntry <= currentBottomIndex )
+				ColorLogItem( logItemsAtIndices[indexOfSelectedLogEntry], indexOfSelectedLogEntry );
+
+			CalculateContentHeight();
+
+			HardResetItems();
+			UpdateItemsInTheList( true );
+
+			manager.ValidateScrollPosition();
+		}
+
+		// Deselect the currently selected log item
+		public void DeselectSelectedLogItem()
+		{
+			int indexOfPreviouslySelectedLogEntry = indexOfSelectedLogEntry;
+			indexOfSelectedLogEntry = int.MaxValue;
+
+			positionOfSelectedLogEntry = float.MaxValue;
+			heightOfSelectedLogEntry = deltaHeightOfSelectedLogEntry = 0f;
+
+			if( indexOfPreviouslySelectedLogEntry >= currentTopIndex && indexOfPreviouslySelectedLogEntry <= currentBottomIndex )
+				ColorLogItem( logItemsAtIndices[indexOfPreviouslySelectedLogEntry], indexOfPreviouslySelectedLogEntry );
+		}
+
+		// Number of debug entries may be changed, update the list
+		public void OnLogEntriesUpdated( bool updateAllVisibleItemContents )
+		{
+			CalculateContentHeight();
+			viewportHeight = viewportTransform.rect.height;
+
+			if( updateAllVisibleItemContents )
+				HardResetItems();
+
+			UpdateItemsInTheList( updateAllVisibleItemContents );
+		}
+
+		// A single collapsed log entry at specified index is updated, refresh its item if visible
+		public void OnCollapsedLogEntryAtIndexUpdated( int index )
+		{
+			DebugLogItem logItem;
+			if( logItemsAtIndices.TryGetValue( index, out logItem ) )
+			{
+				logItem.ShowCount();
+
+				if( timestampsOfEntriesToShow != null )
+					logItem.UpdateTimestamp( timestampsOfEntriesToShow[index] );
+			}
+		}
+
+		// Log window's width has changed, update the expanded (currently selected) log's height
+		public void OnViewportWidthChanged()
+		{
+			if( indexOfSelectedLogEntry >= indicesOfEntriesToShow.Count )
+				return;
+
+			if( currentTopIndex == -1 )
+			{
+				UpdateItemsInTheList( false ); // Try to generate some DebugLogItems, we need one DebugLogItem to calculate the text height
+				if( currentTopIndex == -1 ) // No DebugLogItems are generated, weird
+					return;
+			}
+
+			DebugLogItem referenceItem = logItemsAtIndices[currentTopIndex];
+
+			heightOfSelectedLogEntry = referenceItem.CalculateExpandedHeight( collapsedLogEntries[indicesOfEntriesToShow[indexOfSelectedLogEntry]], ( timestampsOfEntriesToShow != null ) ? timestampsOfEntriesToShow[indexOfSelectedLogEntry] : (DebugLogEntryTimestamp?) null );
+			deltaHeightOfSelectedLogEntry = heightOfSelectedLogEntry - logItemHeight;
+
+			CalculateContentHeight();
+
+			HardResetItems();
+			UpdateItemsInTheList( true );
+
+			manager.ValidateScrollPosition();
+		}
+
+		// Log window's height has changed, update the list
+		public void OnViewportHeightChanged()
+		{
+			viewportHeight = viewportTransform.rect.height;
+			UpdateItemsInTheList( false );
+		}
+
+		private void HardResetItems()
+		{
+			if( currentTopIndex != -1 )
+			{
+				DestroyLogItemsBetweenIndices( currentTopIndex, currentBottomIndex );
+				currentTopIndex = -1;
+			}
+		}
+
+		private void CalculateContentHeight()
+		{
+			float newHeight = Mathf.Max( 1f, indicesOfEntriesToShow.Count * logItemHeight + deltaHeightOfSelectedLogEntry );
+			transformComponent.sizeDelta = new Vector2( 0f, newHeight );
+		}
+
+		// Calculate the indices of log entries to show
+		// and handle log items accordingly
+		public void UpdateItemsInTheList( bool updateAllVisibleItemContents )
+		{
+			// If there is at least one log entry to show
+			if( indicesOfEntriesToShow.Count > 0 )
+			{
+				float contentPosTop = transformComponent.anchoredPosition.y - 1f;
+				float contentPosBottom = contentPosTop + viewportHeight + 2f;
+
+				if( positionOfSelectedLogEntry <= contentPosBottom )
+				{
+					if( positionOfSelectedLogEntry <= contentPosTop )
+					{
+						contentPosTop -= deltaHeightOfSelectedLogEntry;
+						contentPosBottom -= deltaHeightOfSelectedLogEntry;
+
+						if( contentPosTop < positionOfSelectedLogEntry - 1f )
+							contentPosTop = positionOfSelectedLogEntry - 1f;
+
+						if( contentPosBottom < contentPosTop + 2f )
+							contentPosBottom = contentPosTop + 2f;
+					}
+					else
+					{
+						contentPosBottom -= deltaHeightOfSelectedLogEntry;
+						if( contentPosBottom < positionOfSelectedLogEntry + 1f )
+							contentPosBottom = positionOfSelectedLogEntry + 1f;
+					}
+				}
+
+				int newTopIndex = (int) ( contentPosTop * _1OverLogItemHeight );
+				int newBottomIndex = (int) ( contentPosBottom * _1OverLogItemHeight );
+
+				if( newTopIndex < 0 )
+					newTopIndex = 0;
+
+				if( newBottomIndex > indicesOfEntriesToShow.Count - 1 )
+					newBottomIndex = indicesOfEntriesToShow.Count - 1;
+
+				if( currentTopIndex == -1 )
+				{
+					// There are no log items visible on screen,
+					// just create the new log items
+					updateAllVisibleItemContents = true;
+
+					currentTopIndex = newTopIndex;
+					currentBottomIndex = newBottomIndex;
+
+					CreateLogItemsBetweenIndices( newTopIndex, newBottomIndex );
+				}
+				else
+				{
+					// There are some log items visible on screen
+
+					if( newBottomIndex < currentTopIndex || newTopIndex > currentBottomIndex )
+					{
+						// If user scrolled a lot such that, none of the log items are now within
+						// the bounds of the scroll view, pool all the previous log items and create
+						// new log items for the new list of visible debug entries
+						updateAllVisibleItemContents = true;
+
+						DestroyLogItemsBetweenIndices( currentTopIndex, currentBottomIndex );
+						CreateLogItemsBetweenIndices( newTopIndex, newBottomIndex );
+					}
+					else
+					{
+						// User did not scroll a lot such that, there are still some log items within
+						// the bounds of the scroll view. Don't destroy them but update their content,
+						// if necessary
+						if( newTopIndex > currentTopIndex )
+							DestroyLogItemsBetweenIndices( currentTopIndex, newTopIndex - 1 );
+
+						if( newBottomIndex < currentBottomIndex )
+							DestroyLogItemsBetweenIndices( newBottomIndex + 1, currentBottomIndex );
+
+						if( newTopIndex < currentTopIndex )
+						{
+							CreateLogItemsBetweenIndices( newTopIndex, currentTopIndex - 1 );
+
+							// If it is not necessary to update all the log items,
+							// then just update the newly created log items. Otherwise,
+							// wait for the major update
+							if( !updateAllVisibleItemContents )
+								UpdateLogItemContentsBetweenIndices( newTopIndex, currentTopIndex - 1 );
+						}
+
+						if( newBottomIndex > currentBottomIndex )
+						{
+							CreateLogItemsBetweenIndices( currentBottomIndex + 1, newBottomIndex );
+
+							// If it is not necessary to update all the log items,
+							// then just update the newly created log items. Otherwise,
+							// wait for the major update
+							if( !updateAllVisibleItemContents )
+								UpdateLogItemContentsBetweenIndices( currentBottomIndex + 1, newBottomIndex );
+						}
+					}
+
+					currentTopIndex = newTopIndex;
+					currentBottomIndex = newBottomIndex;
+				}
+
+				if( updateAllVisibleItemContents )
+				{
+					// Update all the log items
+					UpdateLogItemContentsBetweenIndices( currentTopIndex, currentBottomIndex );
+				}
+			}
+			else
+				HardResetItems();
+		}
+
+		private void CreateLogItemsBetweenIndices( int topIndex, int bottomIndex )
+		{
+			for( int i = topIndex; i <= bottomIndex; i++ )
+				CreateLogItemAtIndex( i );
+		}
+
+		// Create (or unpool) a log item
+		private void CreateLogItemAtIndex( int index )
+		{
+			DebugLogItem logItem = manager.PopLogItem();
+
+			// Reposition the log item
+			Vector2 anchoredPosition = new Vector2( 1f, -index * logItemHeight );
+			if( index > indexOfSelectedLogEntry )
+				anchoredPosition.y -= deltaHeightOfSelectedLogEntry;
+
+			logItem.Transform.anchoredPosition = anchoredPosition;
+
+			// Color the log item
+			ColorLogItem( logItem, index );
+
+			// To access this log item easily in the future, add it to the dictionary
+			logItemsAtIndices[index] = logItem;
+		}
+
+		private void DestroyLogItemsBetweenIndices( int topIndex, int bottomIndex )
+		{
+			for( int i = topIndex; i <= bottomIndex; i++ )
+				manager.PoolLogItem( logItemsAtIndices[i] );
+		}
+
+		private void UpdateLogItemContentsBetweenIndices( int topIndex, int bottomIndex )
+		{
+			DebugLogItem logItem;
+			for( int i = topIndex; i <= bottomIndex; i++ )
+			{
+				logItem = logItemsAtIndices[i];
+				logItem.SetContent( collapsedLogEntries[indicesOfEntriesToShow[i]], ( timestampsOfEntriesToShow != null ) ? timestampsOfEntriesToShow[i] : (DebugLogEntryTimestamp?) null, i, i == indexOfSelectedLogEntry );
+
+				if( isCollapseOn )
+					logItem.ShowCount();
+				else
+					logItem.HideCount();
+			}
+		}
+
+		// Color a log item using its index
+		private void ColorLogItem( DebugLogItem logItem, int index )
+		{
+			if( index == indexOfSelectedLogEntry )
+				logItem.Image.color = logItemSelectedColor;
+			else if( index % 2 == 0 )
+				logItem.Image.color = logItemNormalColor1;
+			else
+				logItem.Image.color = logItemNormalColor2;
+		}
+	}
+}

Assets/Plugins/IngameDebugConsole/Scripts/DebugLogRecycledListView.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ce231987d32488f43b6fb798f7df43f6
+timeCreated: 1466373025
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts/DebugLogResizeListener.cs

@@ -0,0 +1,24 @@
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+// Listens to drag event on the DebugLogManager's resize button
+namespace IngameDebugConsole
+{
+	public class DebugLogResizeListener : MonoBehaviour, IBeginDragHandler, IDragHandler
+	{
+#pragma warning disable 0649
+		[SerializeField]
+		private DebugLogManager debugManager;
+#pragma warning restore 0649
+
+		// This interface must be implemented in order to receive drag events
+		void IBeginDragHandler.OnBeginDrag( PointerEventData eventData )
+		{
+		}
+
+		void IDragHandler.OnDrag( PointerEventData eventData )
+		{
+			debugManager.Resize( eventData );
+		}
+	}
+}

Assets/Plugins/IngameDebugConsole/Scripts/DebugLogResizeListener.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 6565f2084f5aef44abe57c988745b9c3
+timeCreated: 1601221093
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts/DebugsOnScrollListener.cs

@@ -0,0 +1,60 @@
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.EventSystems;
+
+// Listens to scroll events on the scroll rect that debug items are stored
+// and decides whether snap to bottom should be true or not
+// 
+// Procedure: if, after a user input (drag or scroll), scrollbar is at the bottom, then 
+// snap to bottom shall be true, otherwise it shall be false
+namespace IngameDebugConsole
+{
+	public class DebugsOnScrollListener : MonoBehaviour, IScrollHandler, IBeginDragHandler, IEndDragHandler
+	{
+		public ScrollRect debugsScrollRect;
+		public DebugLogManager debugLogManager;
+
+		public void OnScroll( PointerEventData data )
+		{
+			if( IsScrollbarAtBottom() )
+				debugLogManager.SetSnapToBottom( true );
+			else
+				debugLogManager.SetSnapToBottom( false );
+		}
+
+		public void OnBeginDrag( PointerEventData data )
+		{
+			debugLogManager.SetSnapToBottom( false );
+		}
+
+		public void OnEndDrag( PointerEventData data )
+		{
+			if( IsScrollbarAtBottom() )
+				debugLogManager.SetSnapToBottom( true );
+			else
+				debugLogManager.SetSnapToBottom( false );
+		}
+
+		public void OnScrollbarDragStart( BaseEventData data )
+		{
+			debugLogManager.SetSnapToBottom( false );
+		}
+
+		public void OnScrollbarDragEnd( BaseEventData data )
+		{
+			if( IsScrollbarAtBottom() )
+				debugLogManager.SetSnapToBottom( true );
+			else
+				debugLogManager.SetSnapToBottom( false );
+		}
+
+		private bool IsScrollbarAtBottom()
+		{
+			float scrollbarYPos = debugsScrollRect.verticalNormalizedPosition;
+			if( scrollbarYPos <= 1E-6f )
+				return true;
+
+			return false;
+		}
+	}
+}

Assets/Plugins/IngameDebugConsole/Scripts/DebugsOnScrollListener.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: cb564dcb180e586429c57456166a76b5
+timeCreated: 1466004663
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/Scripts/EventSystemHandler.cs

@@ -0,0 +1,75 @@
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.SceneManagement;
+#if ENABLE_INPUT_SYSTEM && !ENABLE_LEGACY_INPUT_MANAGER
+using UnityEngine.InputSystem.UI;
+#endif
+
+namespace IngameDebugConsole
+{
+	// Avoid multiple EventSystems in the scene by activating the embedded EventSystem only if one doesn't already exist in the scene
+	[DefaultExecutionOrder( 1000 )]
+	public class EventSystemHandler : MonoBehaviour
+	{
+#pragma warning disable 0649
+		[SerializeField]
+		private GameObject embeddedEventSystem;
+#pragma warning restore 0649
+
+#if ENABLE_INPUT_SYSTEM && !ENABLE_LEGACY_INPUT_MANAGER
+		private void Awake()
+		{
+			StandaloneInputModule legacyInputModule = embeddedEventSystem.GetComponent<StandaloneInputModule>();
+			if( legacyInputModule )
+			{
+				DestroyImmediate( legacyInputModule );
+				embeddedEventSystem.AddComponent<InputSystemUIInputModule>();
+			}
+		}
+#endif
+
+		private void OnEnable()
+		{
+			SceneManager.sceneLoaded -= OnSceneLoaded;
+			SceneManager.sceneLoaded += OnSceneLoaded;
+			SceneManager.sceneUnloaded -= OnSceneUnloaded;
+			SceneManager.sceneUnloaded += OnSceneUnloaded;
+
+			ActivateEventSystemIfNeeded();
+		}
+
+		private void OnDisable()
+		{
+			SceneManager.sceneLoaded -= OnSceneLoaded;
+			SceneManager.sceneUnloaded -= OnSceneUnloaded;
+
+			DeactivateEventSystem();
+		}
+
+		private void OnSceneLoaded( Scene scene, LoadSceneMode mode )
+		{
+#if UNITY_2017_2_OR_NEWER
+			DeactivateEventSystem();
+#endif
+			ActivateEventSystemIfNeeded();
+		}
+
+		private void OnSceneUnloaded( Scene current )
+		{
+			// Deactivate the embedded EventSystem before changing scenes because the new scene might have its own EventSystem
+			DeactivateEventSystem();
+		}
+
+		private void ActivateEventSystemIfNeeded()
+		{
+			if( embeddedEventSystem && !EventSystem.current )
+				embeddedEventSystem.SetActive( true );
+		}
+
+		private void DeactivateEventSystem()
+		{
+			if( embeddedEventSystem )
+				embeddedEventSystem.SetActive( false );
+		}
+	}
+}

Assets/Plugins/IngameDebugConsole/Scripts/EventSystemHandler.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c3cc1b407f337e641ad32a2e91d5b478
+timeCreated: 1658741613
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/WebGL.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a091b43ce3618074d8cf2beb7e538a7d
+folderAsset: yes
+timeCreated: 1626377678
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/WebGL/IngameDebugConsole.jslib

@@ -0,0 +1,70 @@
+mergeInto( LibraryManager.library,
+{
+	IngameDebugConsoleStartCopy: function( textToCopy )
+	{
+		var textToCopyJS = UTF8ToString( textToCopy );
+		
+		// Delete if element exist
+		var copyTextButton = document.getElementById( 'DebugConsoleCopyButtonGL' );
+		if( !copyTextButton )
+		{
+			copyTextButton = document.createElement( 'button' );
+			copyTextButton.setAttribute( 'id', 'DebugConsoleCopyButtonGL' );
+			copyTextButton.setAttribute( 'style','display:none; visibility:hidden;' );
+		}
+		
+		copyTextButton.onclick = function( event )
+		{
+			// Credit: https://stackoverflow.com/a/30810322/2373034
+			if( navigator.clipboard )
+			{
+				navigator.clipboard.writeText( textToCopyJS ).then( function() { }, function( err )
+				{
+					console.error( "Couldn't copy text to clipboard using clipboard.writeText: ", err );
+				} );
+			}
+			else
+			{
+				var textArea = document.createElement( 'textarea' );
+				textArea.value = textToCopyJS;
+
+				// Avoid scrolling to bottom
+				textArea.style.top = "0";
+				textArea.style.left = "0";
+				textArea.style.position = "fixed";
+
+				document.body.appendChild( textArea );
+				textArea.focus();
+				textArea.select();
+
+				try
+				{
+					document.execCommand( 'copy' );
+				}
+				catch( err )
+				{
+					console.error( "Couldn't copy text to clipboard using document.execCommand", err );
+				}
+
+				document.body.removeChild( textArea );
+			}
+		};
+
+		document.body.appendChild( copyTextButton );
+		document.onmouseup = function()
+		{
+			document.onmouseup = null;
+			copyTextButton.click();
+			document.body.removeChild( copyTextButton );
+		};
+	},
+	
+	IngameDebugConsoleCancelCopy: function()
+	{
+		var copyTextButton = document.getElementById( 'DebugConsoleCopyButtonGL' );
+		if( copyTextButton )
+			document.body.removeChild( copyTextButton );
+		
+		document.onmouseup = null;
+	}
+} );

Assets/Plugins/IngameDebugConsole/WebGL/IngameDebugConsole.jslib.meta

@@ -0,0 +1,39 @@
+fileFormatVersion: 2
+guid: aa23dd530e9f98c4cb0766404fc0e755
+timeCreated: 1626377683
+licenseType: Free
+PluginImporter:
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  isPreloaded: 0
+  isOverridable: 0
+  platformData:
+    data:
+      first:
+        Any: 
+      second:
+        enabled: 0
+        settings: {}
+    data:
+      first:
+        Editor: Editor
+      second:
+        enabled: 0
+        settings:
+          DefaultValueInitialized: true
+    data:
+      first:
+        Facebook: WebGL
+      second:
+        enabled: 1
+        settings: {}
+    data:
+      first:
+        WebGL: WebGL
+      second:
+        enabled: 1
+        settings: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/iOS.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 4552a2fd287aca645a670fa2b65e52a9
+folderAsset: yes
+timeCreated: 1586184974
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/IngameDebugConsole/iOS/IngameDebugConsole.mm

@@ -0,0 +1,4 @@
+extern "C" void _DebugConsole_CopyText( const char* text ) 
+{
+	[UIPasteboard generalPasteboard].string = [NSString stringWithUTF8String:text];
+}

Assets/Plugins/IngameDebugConsole/iOS/IngameDebugConsole.mm.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: 4b53767ec4f910e4a9876cbe77d57968
+timeCreated: 1498727312
+licenseType: Pro
+PluginImporter:
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  isPreloaded: 0
+  isOverridable: 0
+  platformData:
+    data:
+      first:
+        Any: 
+      second:
+        enabled: 0
+        settings: {}
+    data:
+      first:
+        Editor: Editor
+      second:
+        enabled: 0
+        settings:
+          DefaultValueInitialized: true
+    data:
+      first:
+        iPhone: iOS
+      second:
+        enabled: 1
+        settings: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: