DebugPanel.cs

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using System.Collections.Generic;
using UnityEngine;

namespace HoloToolkit.Unity
{
    public class DebugPanel : SingleInstance<DebugPanel>
    {
        private TextMesh textMesh;

        private Queue<string> logMessages = new Queue<string>();
        private Queue<string> nextLogMessages = new Queue<string>();

        private int maxLogMessages = 30;

        public delegate string GetLogLine();

        private List<GetLogLine> externalLogs = new List<GetLogLine>();

        private void Awake()
        {
            textMesh = GetComponent<TextMesh>();
            Application.logMessageReceivedThreaded += Application_logMessageReceivedThreaded;
        }

        private void Update()
        {
            string logMessageString = CalculateLogMessageString();
            textMesh.text = logMessageString;
        }

        private string CalculateLogMessageString()
        {
            string logMessageString = "Per Frame Data:\n------\n";
            for (int index = 0; index < externalLogs.Count; index++)
            {
                string nextExternalLine = externalLogs[index]();
                if (!string.IsNullOrEmpty(nextExternalLine))
                {
                    logMessageString += string.Format("{0}\n", nextExternalLine);
                }
            }

            logMessageString += "------\n";

            lock (logMessages)
            {
                while (logMessages.Count > 0)
                {
                    string nextMessage = logMessages.Dequeue();
                    logMessageString += string.Format("{0}\n", nextMessage);
                    // for the next frame...
                    nextLogMessages.Enqueue(nextMessage);
                }

                Queue<string> tmp = logMessages;
                logMessages = nextLogMessages;
                nextLogMessages = tmp;
                nextLogMessages.Clear();
            }

            return logMessageString;
        }

        private void Application_logMessageReceivedThreaded(string condition, string stackTrace, LogType type)
        {
            LogCallback(condition, stackTrace, type);
        }

        private void LogCallback(string message, string stack, LogType logType)
        {
            lock (logMessages)
            {
                while (logMessages.Count > maxLogMessages)
                {
                    logMessages.Dequeue();
                }

                logMessages.Enqueue(message);
                if (logType != LogType.Log)
                {
                    // Also add the stack. This will push us beyond our max messages, but it is a soft limit, 
                    // and the stack information is valuable in error/warning cases.
                    logMessages.Enqueue(stack);
                }
            }
        }

        public void RegisterExternalLogCallback(GetLogLine callback)
        {
            externalLogs.Add(callback);
        }

        public void UnregisterExternalLogCallback(GetLogLine callback)
        {
            if (externalLogs.Contains(callback))
            {
                externalLogs.Remove(callback);
            }
        }
    }
}