unity控制檯上的信息打印到屏幕上

      接上一個汽車控制，現在我需要實現的是在汽車跑的時候實時打印它的速度在屏幕上，我們都知道如果直接Debug.Log()的話，它打印在控制檯上，我們只需要製作一個GUI窗口，打印log就可以了，這個功能是一個外國蜀黍的，我拿來改了一下，灰常對不起，我找了半天找不到原博地址了，我說一下修改的內容吧，由於原程序雖然可以打印log，但是不能和控制檯一樣往下實時刷新，它的滾動條不能自己往下刷新，你要看還要用鼠標往下拉，這樣很不方便。

  我怎麼做的呢，其實很簡單，加一個協程（start和clearlog函數）就好了，我定了每0.1s定時清空一次log，看上去和實時刷新差不多，效果圖，爲什麼不能每幀刷新呢？因爲FixedUpdate的每一幀和Update的幀的長度不一樣，神奇~

我這個人美感不行，你可以自己調調位置界面顏色之類的。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace Consolation
{
    /// <summary>  
    /// A console to display Unity's debug logs in-game.  
    /// </summary>  
    class TestConsole : MonoBehaviour
    {
//#if USE_TESTCONSOLE
        struct Log  
        {  
            public string message;  
            public string stackTrace;  
            public LogType type;  
        }  
 
        #region Inspector Settings  
  
        /// <summary>  
        /// The hotkey to show and hide the console window.  
        /// </summary>  
        public KeyCode toggleKey = KeyCode.BackQuote;  
  
        /// <summary>  
        /// Whether to open the window by shaking the device (mobile-only).  
        /// </summary>  
        public bool shakeToOpen = true;  
  
        /// <summary>  
        /// The (squared) acceleration above which the window should open.  
        /// </summary>  
        public float shakeAcceleration = 3f;  
  
        /// <summary>  
        /// Whether to only keep a certain number of logs.  
        ///  
        /// Setting this can be helpful if memory usage is a concern.  
        /// </summary>  
        public bool restrictLogCount = false;  
  
        /// <summary>  
        /// Number of logs to keep before removing old ones.  
        /// </summary>  
        public int maxLogs = 1000;  
 
        #endregion
  
        readonly List<Log> logs = new List<Log>();  
        Vector2 scrollPosition;  
        bool visible;  
        bool collapse;

        // Visual elements:  
        private void Start()
        {
            StartCoroutine(ClearLog());
        }
        IEnumerator ClearLog()
        {
            yield return new WaitForSeconds(0.1f);
            logs.Clear();
            yield return StartCoroutine(ClearLog());
        }
        static readonly Dictionary<LogType, Color> logTypeColors = new Dictionary<LogType, Color>  
        {  
            //Log類型
            { LogType.Assert, Color.white },  
            { LogType.Error, Color.red },  
            { LogType.Exception, Color.red },  
            { LogType.Log, Color.white },  
            { LogType.Warning, Color.yellow },  
        };  
  //窗口設置
        const string windowTitle = "Speed";  
        const int margin = 100;  
      //  static readonly GUIContent clearLabel = new GUIContent("Clear", "Clear the contents of the console.");  
       // static readonly GUIContent collapseLabel = new GUIContent("Collapse", "Hide repeated messages.");  
  
       readonly Rect titleBarRect = new Rect(0, 0, 1000, 20);  
        Rect windowRect = new Rect(500, 0, Screen.width - (margin * 5), Screen.height - (margin * 6));  
  
        void OnEnable()  
        {
//#if UNITY_5
            Application.logMessageReceived += HandleLog;  
//#else
           // Application.logMessageReceived(HandleLog);
         //  Application.RegisterLogCallback(HandleLog);  
//#endif
        }  
  
        void OnDisable()  
        {  
//#if UNITY_5
            Application.logMessageReceived -= HandleLog;  
//#else
           // Application.RegisterLogCallback(null);  
//#endif
        }  
  
        void Update()  
        {  
            if (Input.GetKeyDown(toggleKey))  
            {  
                visible = !visible;  
            }  
  
            if (shakeToOpen && Input.acceleration.sqrMagnitude > shakeAcceleration)  
            {  
                visible = true;  
            }  
        }  
  
        void OnGUI()  
        {  
            if (!visible)  
            {  
                return;  
            }  
  
         //

            windowRect = GUILayout.Window(123456, windowRect, DrawConsoleWindow, windowTitle);  
        }  
  
        /// <summary>  
        /// Displays a window that lists the recorded logs.  
        /// </summary>  
        /// <param name="windowID">Window ID.</param>  
        void DrawConsoleWindow(int windowID)  
        {  
            DrawLogsList();  
            DrawToolbar();  
  
            // Allow the window to be dragged by its title bar.  
            GUI.DragWindow(titleBarRect);  
        }  
  
        /// <summary>  
        /// Displays a scrollable list of logs.  
        /// </summary>  
        void DrawLogsList()  
        {  
            scrollPosition = GUILayout.BeginScrollView(scrollPosition);  
  
            // Iterate through the recorded logs.  
            for (var i = 0; i < logs.Count; i++)  
            {  
                var log = logs[i];
              //  Destroy(logs[i - 1]);
                // Combine identical messages if collapse option is chosen.  
                if (collapse && i > 0)  
                {  
                    var previousMessage = logs[i - 1].message;  
  
                    if (log.message == previousMessage)  
                    {  
                        continue;  
                    }  
                }  
  
                GUI.contentColor = logTypeColors[log.type];  
                GUILayout.Label(log.message);  
            }  
  
            GUILayout.EndScrollView();  
  
            // Ensure GUI colour is reset before drawing other components.  
            GUI.contentColor = Color.white;  
        }  
  
        /// <summary>  
        /// Displays options for filtering and changing the logs list.  
        /// </summary>  
        void DrawToolbar()  
        {  
            GUILayout.BeginHorizontal();  
  
            //if (GUILayout.Button(clearLabel))  
            //{  
            //    logs.Clear();  
            //}  
  
           // collapse = GUILayout.Toggle(collapse, collapseLabel, GUILayout.ExpandWidth(false));  
  
            GUILayout.EndHorizontal();  
        }  
  
        /// <summary>  
        /// Records a log from the log callback.  
        /// </summary>  
        /// <param name="message">Message.</param>  
        /// <param name="stackTrace">Trace of where the message came from.</param>  
        /// <param name="type">Type of message (error, exception, warning, assert).</param>  
        void HandleLog(string message, string stackTrace, LogType type)  
        {  
            logs.Add(new Log  
            {  
                message = message,  
                stackTrace = stackTrace,  
                type = type,  
            });  
  
            TrimExcessLogs();  
        }  
  
        /// <summary>  
        /// Removes old logs that exceed the maximum number allowed.  
        /// </summary>  
        void TrimExcessLogs()  
        {  
            if (!restrictLogCount)  
            {  
                return;  
            }  
  
            var amountToRemove = Mathf.Max(logs.Count - maxLogs, 0);  
  
            if (amountToRemove == 0)  
            {  
                return;  
            }  
  
            logs.RemoveRange(0, amountToRemove);  
        }
       
        //#endif
    }
}

不得不說，協程真的太好用了啊，按~這個鍵可以調出這個GUI,再次抱歉。

後續：

    在這裏打印出debug信息，這種做法是可以的，但是顯示速度變量之類的最好的方法是在OnGUI函數裏調用，由於這個是每幀都會執行一次，所以看上去是實時刷新。上面的做法可以但不夠簡潔。

例如

 void OnGUI()
    {

        if (!visible)
        {

            GUI.backgroundColor = Color.black;
            float guiWidth = Screen.width / 2 - 200;
            GUI.backgroundColor = Color.blue;
            GUI.Button(new Rect(Screen.width - 30 - guiWidth, 165, 10, Mathf.Clamp(((-motorInput) * 100), -100, 0)), "");

            GUI.backgroundColor = Color.red;
            GUI.Button(new Rect(Screen.width - 45 - guiWidth, 165, 10, Mathf.Clamp((-brakeInput * 100), -100, 0)), "");

        }

    }