Unity log 自定义输出

最新推荐文章于 2024-04-28 12:19:52 发布

警醒与鞭策

最新推荐文章于 2024-04-28 12:19:52 发布

阅读量3.7k

点赞数 1

分类专栏： Unity3d

Unity3d 专栏收录该内容

158 篇文章 16 订阅

订阅专栏

//#define USE_TESTCONSOLE
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:

static readonly Dictionary<LogType, Color> logTypeColors = new Dictionary<LogType, Color>
{
{ LogType.Assert, Color.white },
{ LogType.Error, Color.red },
{ LogType.Exception, Color.red },
{ LogType.Log, Color.white },
{ LogType.Warning, Color.yellow },
};

const string windowTitle = "Console";
const int margin = 20;
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, 10000, 20);
Rect windowRect = new Rect(margin, margin, Screen.width - (margin * 2), Screen.height - (margin * 2));

void OnEnable()
{
#if UNITY_5
Application.logMessageReceived += HandleLog;
#else
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];

// 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
}

}

随便写个C#代码，在Update中测试的。

[csharp]view plaincopy 
    
print?
 // Update is called once per frame  
     void Update ()  
     {  
         //DebugConsole.Log(" test s");  
         Debug.Log("Debug log  test");  
         Console.WriteLine("this is Console Write line test ");  
         ///  
         //DebugConsole.instance.AddMessage("this is instance AddMessage test by cartzhang", "warning");  
         //DebugConsole.Log("this is debug console log test cartzhang");  
     }  

直接写在屏幕上的代码

 
    using UnityEngine;  
  using System.Collections;  
   
   
 public class DebugConsole : MonoBehaviour  
  {  
 #if USE_DEBUGCONSOLE  
     public GameObject DebugGui = null;             // The GUI that will be duplicated  
     public Vector3 defaultGuiPosition = new Vector3(0.01F, 0.98F, 0F);  
     public Vector3 defaultGuiScale = new Vector3(0.5F, 0.5F, 1F);  
     public Color normal = Color.green;  
     public Color warning = Color.yellow;  
     public Color error = Color.red;  
     public int maxMessages = 30;                   // The max number of messages displayed  
     public float lineSpacing = 0.02F;              // The amount of space between lines  
     public ArrayList messages = new ArrayList();  
     public ArrayList guis = new ArrayList();  
     public ArrayList colors = new ArrayList();  
     public bool draggable = true;                  // Can the output be dragged around at runtime by default?   
     public bool visible = true;                    // Does output show on screen by default or do we have to enable it with code?   
     public bool pixelCorrect = false; // set to be pixel Correct linespacing  
     public static bool isVisible  
     {                                        
         get  
         {  
             return DebugConsole.instance.visible;  
         }  
    
         set  
         {  
             DebugConsole.instance.visible = value;  
             if (value == true)  
             {  
                 DebugConsole.instance.Display();  
             }  
             else if (value == false)  
             {  
                 DebugConsole.instance.ClearScreen();  
             }  
         }  
     }  
    
     public static bool isDraggable  
     {                                        
         get  
         {  
             return DebugConsole.instance.draggable;  
         }  
    
         set  
         {  
             DebugConsole.instance.draggable = value;  
    
         }  
     }  
    
    
     private static DebugConsole s_Instance = null;   // Our instance to allow this script to be called without a direct connection.  
     public static DebugConsole instance  
     {  
         get  
         {  
             if (s_Instance == null)  
             {  
                 s_Instance = FindObjectOfType(typeof(DebugConsole)) as DebugConsole;  
                 if (s_Instance == null)  
                 {  
                     GameObject console = new GameObject();  
                     console.AddComponent<DebugConsole>();  
                     console.name = "DebugConsoleController";  
                     s_Instance = FindObjectOfType(typeof(DebugConsole)) as DebugConsole;  
                     DebugConsole.instance.InitGuis();  
                 }  
    
             }  
    
             return s_Instance;  
         }  
     }  
    
     void Awake()  
     {  
         s_Instance = this;  
         InitGuis();  
    
     }  
    
     protected bool guisCreated = false;  
     protected float screenHeight =-1;  
     public void InitGuis()  
     {  
         float usedLineSpacing = lineSpacing;  
         screenHeight = Screen.height;  
         if(pixelCorrect)  
             usedLineSpacing = 1.0F / screenHeight * usedLineSpacing;    
    
         if (guisCreated == false)  
         {  
             if (DebugGui == null)  // If an external GUIText is not set, provide the default GUIText  
             {  
                 DebugGui = new GameObject();  
                 DebugGui.AddComponent<GUIText>();  
                 DebugGui.name = "DebugGUI(0)";  
                 DebugGui.transform.position = defaultGuiPosition;  
                 DebugGui.transform.localScale = defaultGuiScale;  
             }  
    
             // Create our GUI objects to our maxMessages count  
             Vector3 position = DebugGui.transform.position;  
             guis.Add(DebugGui);  
             int x = 1;  
    
             while (x < maxMessages)  
             {  
                 position.y -= usedLineSpacing;  
                 GameObject clone = null;  
                 clone = (GameObject)Instantiate(DebugGui, position, transform.rotation);  
                 clone.name = string.Format("DebugGUI({0})", x);  
                 guis.Add(clone);  
                 position = clone.transform.position;  
                 x += 1;  
             }  
    
             x = 0;  
             while (x < guis.Count)  
             {  
                 GameObject temp = (GameObject)guis[x];  
                 temp.transform.parent = DebugGui.transform;  
                 x++;  
             }  
             guisCreated = true;  
         } else {  
             // we're called on a screensize change, so fiddle with sizes  
             Vector3 position = DebugGui.transform.position;  
             for(int x=0;x < guis.Count; x++)  
             {  
                 position.y -= usedLineSpacing;  
                 GameObject temp = (GameObject)guis[x];  
                 temp.transform.position= position;  
             }         
         }  
     }  
    
    
    
     bool connectedToMouse = false;    
     void Update()  
     {  
         // If we are visible and the screenHeight has changed, reset linespacing  
         if (visible == true && screenHeight != Screen.height)  
         {  
             InitGuis();  
         }  
         if (draggable == true)  
         {  
             if (Input.GetMouseButtonDown(0))  
             {  
                 if (connectedToMouse == false && DebugGui.GetComponent<GUIText>().HitTest((Vector3)Input.mousePosition) == true)  
                 {  
                     connectedToMouse = true;  
                 }  
                 else if (connectedToMouse == true)  
                 {  
                     connectedToMouse = false;  
                 }  
    
             }  
    
             if (connectedToMouse == true)  
             {  
                 float posX = DebugGui.transform.position.x;  
                 float posY = DebugGui.transform.position.y;  
                 posX = Input.mousePosition.x / Screen.width;  
                 posY = Input.mousePosition.y / Screen.height;  
                 DebugGui.transform.position = new Vector3(posX, posY, 0F);  
             }  
         }  
    
     }  
     //+++++++++ INTERFACE FUNCTIONS ++++++++++++++++++++++++++++++++  
     public static void Log(string message, string color)  
     {  
         DebugConsole.instance.AddMessage(message, color);  
    
     }  
     //++++ OVERLOAD ++++  
     public static void Log(string message)  
     {  
         DebugConsole.instance.AddMessage(message);  
     }  
    
     public static void Clear()  
     {  
         DebugConsole.instance.ClearMessages();  
     }  
     //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    
    
     //---------- void AddMesage(string message, string color) ------  
     //Adds a mesage to the list  
     //--------------------------------------------------------------  
    
     public void AddMessage(string message, string color)  
     {  
         messages.Add(message);  
         colors.Add(color);  
         Display();  
     }  
     //++++++++++ OVERLOAD for AddMessage ++++++++++++++++++++++++++++  
     // Overloads AddMessage to only require one argument(message)  
     //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
     public void AddMessage(string message)  
     {  
         messages.Add(message);  
         colors.Add("normal");  
         Display();  
     }  
    
    
     //----------- void ClearMessages() ------------------------------  
     // Clears the messages from the screen and the lists  
     //---------------------------------------------------------------  
     public void ClearMessages()  
     {  
         messages.Clear();  
         colors.Clear();  
         ClearScreen();  
     }  
    
    
     //-------- void ClearScreen() ----------------------------------  
     // Clears all output from all GUI objects  
     //--------------------------------------------------------------  
     void ClearScreen()  
     {  
         if (guis.Count < maxMessages)  
         {  
             //do nothing as we haven't created our guis yet  
         }  
         else  
         {  
             int x = 0;  
             while (x < guis.Count)  
             {  
                 GameObject gui = (GameObject)guis[x];     
                 gui.GetComponent<GUIText>().text = "";  
                 //increment and loop  
                 x += 1;  
             }  
         }  
     }     
    
    
     //---------- void Prune() ---------------------------------------  
     // Prunes the array to fit within the maxMessages limit  
     //---------------------------------------------------------------  
     void Prune()  
     {  
         int diff;  
         if (messages.Count > maxMessages)  
         {  
             if (messages.Count <= 0)  
             {  
                 diff = 0;  
             }  
             else  
             {  
                 diff = messages.Count - maxMessages;  
             }  
             messages.RemoveRange(0, (int)diff);  
             colors.RemoveRange(0, (int)diff);  
         }  
    
     }  
    
     //---------- void Display() -------------------------------------  
     // Displays the list and handles coloring  
     //---------------------------------------------------------------  
     void Display()  
     {  
         //check if we are set to display  
         if (visible == false)  
         {  
             ClearScreen();  
         }  
         else if (visible == true)  
         {  
    
    
             if (messages.Count > maxMessages)  
             {  
                 Prune();  
             }  
    
             // Carry on with display  
             int x = 0;  
             if (guis.Count < maxMessages)  
             {  
                 //do nothing as we havent created our guis yet  
             }  
             else  
             {  
                 while (x < messages.Count)  
                 {  
                     GameObject gui = (GameObject)guis[x];     
    
                     //set our color  
                     switch ((string)colors[x])  
                     {  
                         case "normal": gui.GetComponent<GUIText>().material.color = normal;  
                             break;  
                         case "warning": gui.GetComponent<GUIText>().material.color = warning;  
                             break;  
                         case "error": gui.GetComponent<GUIText>().material.color = error;  
                             break;  
                     }  
    
                     //now set the text for this element  
                     gui.GetComponent<GUIText>().text = (string)messages[x];  
    
                     //increment and loop  
                     x += 1;  
                 }  
             }  
    
         }  
     }  
 #endif  
    
  }// End DebugConsole Class  
 
 

2.使用方法

[csharp]view plaincopy 
    
print?
 //DebugConsole.instance.AddMessage("this is instance AddMessage test by cartzhang", "warning");  
        //DebugConsole.Log("this is debug console log test cartzhang");  

代码是歪果仁写的，但是很好用。

首先，输入的代码：

名字为ConsoleInput.cs

[csharp]view plaincopy 
    
print?
 using UnityEngine;  
 using System;  
 using System.Collections;  
 using System.Runtime.InteropServices;  
 using System.IO;  
   
 namespace ConsoleTestWindows  
 {  
     public class ConsoleInput  
     {  
         //public delegate void InputText( string strInput );  
         public event System.Action<string> OnInputText;  
         public string inputString;  
   
         public void ClearLine()  
         {  
             //System.Text.Encoding test = Console.InputEncoding;  
             Console.CursorLeft = 0;  
             Console.Write( new String( ' ', Console.BufferWidth ) );  
             Console.CursorTop--;  
             Console.CursorLeft = 0;  
         }  
   
         public void RedrawInputLine()  
         {  
             if ( inputString.Length == 0 ) return;  
   
             if ( Console.CursorLeft > 0 )  
                 ClearLine();  
   
             System.Console.ForegroundColor = ConsoleColor.Green;  
             System.Console.Write( inputString );  
         }  
   
         internal void OnBackspace()  
         {  
             if ( inputString.Length < 1 ) return;  
   
             inputString = inputString.Substring( 0, inputString.Length - 1 );  
             RedrawInputLine();  
         }  
   
         internal void OnEscape()  
         {  
             ClearLine();  
             inputString = "";  
         }  
   
         internal void OnEnter()  
         {  
             ClearLine();  
             System.Console.ForegroundColor = ConsoleColor.Green;  
             System.Console.WriteLine( "> " + inputString );  
   
             var strtext = inputString;  
             inputString = "";  
   
             if ( OnInputText != null )  
             {  
                 OnInputText( strtext );  
             }  
         }  
   
         public void Update()  
         {  
             if ( !Console.KeyAvailable ) return;  
             var key = Console.ReadKey();  
   
             if ( key.Key == ConsoleKey.Enter )  
             {  
                 OnEnter();  
                 return;  
             }  
   
             if ( key.Key == ConsoleKey.Backspace )  
             {  
                 OnBackspace();  
                 return;  
             }  
   
             if ( key.Key == ConsoleKey.Escape )  
             {  
                 OnEscape();  
                 return;  
             }  
   
             if ( key.KeyChar != '\u0000' )  
             {  
                 inputString += key.KeyChar;  
                 RedrawInputLine();  
                 return;  
             }  
         }  
     }  
 }  

然后，你还需要一个控制台窗口

如下：

[csharp]view plaincopy 
    
print?
 using UnityEngine;  
 using System;  
 using System.Collections;  
 using System.Runtime.InteropServices;  
 using System.IO;  
   
 namespace ConsoleTestWindows  
 {  
     /// <summary>  
     /// Creates a console window that actually works in Unity  
     /// You should add a script that redirects output using Console.Write to write to it.  
     /// </summary>  
     public class ConsoleWindow  
     {  
         TextWriter oldOutput;  
   
         public void Initialize()  
         {  
             //  
             // Attach to any existing consoles we have  
             // failing that, create a new one.  
             //  
             if ( !AttachConsole( 0x0ffffffff ) )  
             {  
                 AllocConsole();  
             }  
   
             oldOutput = Console.Out;  
   
             try  
             {  
                 IntPtr stdHandle = GetStdHandle( STD_OUTPUT_HANDLE );  
                 Microsoft.Win32.SafeHandles.SafeFileHandle safeFileHandle = new Microsoft.Win32.SafeHandles.SafeFileHandle( stdHandle, true );  
                 FileStream fileStream = new FileStream(safeFileHandle, FileAccess.Write);  
                 System.Text.Encoding encoding = System.Text.Encoding.ASCII;  
                 StreamWriter standardOutput = new StreamWriter( fileStream, encoding );  
                 standardOutput.AutoFlush = true;  
                 Console.SetOut( standardOutput );  
             }  
             catch ( System.Exception e )  
             {  
                 Debug.Log( "Couldn't redirect output: " + e.Message );  
             }  
         }  
   
         public void Shutdown()  
         {  
             Console.SetOut( oldOutput );  
             FreeConsole();  
         }  
   
         public void SetTitle( string strName )  
         {  
             SetConsoleTitle( strName );  
         }  
   
         private const int STD_OUTPUT_HANDLE = -11;  
   
         [DllImport( "kernel32.dll", SetLastError = true )]  
         static extern bool AttachConsole( uint dwProcessId );  
   
         [DllImport( "kernel32.dll", SetLastError = true )]  
         static extern bool AllocConsole();  
   
         [DllImport( "kernel32.dll", SetLastError = true )]  
         static extern bool FreeConsole();  
   
         [DllImport( "kernel32.dll", EntryPoint = "GetStdHandle", SetLastError = true, CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall )]  
         private static extern IntPtr GetStdHandle( int nStdHandle );  
   
         [DllImport( "kernel32.dll" )]  
         static extern bool SetConsoleTitle( string lpConsoleTitle );  
     }  
 }  

三、输入和窗口准备齐全了，问题来了。

当你试图编译代码时候，你会发现居然编译报错，各种找不到。

Console.CursorLeft等大量的方法和变量都找不到。

这是因为Untiy5 默认的目标框架Unity3.5 .net sbu base class Libraries.。在Player Setting中，可设置为.Net 2.0。

这就可以改变了VS下的编译环境了。

但是要是你想要修改编译环境为你想要的其他呢？

四、那么问题来了？怎么修改编译环境的目标框架呢？

你肯定不会是想出这个问题的第一人？所以那就有人来解决问题；

动态的修改你的FrameWork,就可以解答这个问题。

代码：UpgradeVSProject.cs

[csharp]view plaincopy 
    
print?
 //#define USE_UPGRADEVS  
 using UnityEngine;  
 using System.Collections;  
 using UnityEditor;  
 using System.IO;  
 using System.Text.RegularExpressions;  
   
 class UpgradeVSProject : AssetPostprocessor  
 {  
 #if USE_UPGRADEVS  
     private static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)  
     {  
         string currentDir = Directory.GetCurrentDirectory();  
         string[] slnFile = Directory.GetFiles(currentDir, "*.sln");  
         string[] csprojFile = Directory.GetFiles(currentDir, "*.csproj");  
   
         bool hasChanged = false;  
         if (slnFile != null)  
         {  
             for (int i = 0; i < slnFile.Length; i++)  
             {  
                 if (ReplaceInFile(slnFile[i], "Format Version 10.00", "Format Version 11.00"))  
                     hasChanged = true;  
             }  
         }  
   
         if (csprojFile != null)  
         {  
             for (int i = 0; i < csprojFile.Length; i++)  
             {  
                 if (ReplaceInFile(csprojFile[i], "ToolsVersion=\"3.5\"", "ToolsVersion=\"4.0\""))  
                     hasChanged = true;  
   
                 if (ReplaceInFile(csprojFile[i], "<TargetFrameworkVersion>v3.5</TargetFrameworkVersion>", "<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>"))  
                     hasChanged = true;  
             }  
         }  
   
         if (hasChanged)  
         {  
             Debug.LogWarning("Project is now upgraded to Visual Studio 2010 Solution!");  
         }  
         else  
         {  
             Debug.Log("Project-version has not changed...");  
         }  
     }  
   
     static private bool ReplaceInFile(string filePath, string searchText, string replaceText)  
     {  
         StreamReader reader = new StreamReader(filePath);  
         string content = reader.ReadToEnd();  
         reader.Close();  
   
         if (content.IndexOf(searchText) != -1)  
         {  
             content = Regex.Replace(content, searchText, replaceText);  
             StreamWriter writer = new StreamWriter(filePath);  
             writer.Write(content);  
             writer.Close();  
   
             return true;  
         }  
   
         return false;  
     }  
 #endif  
 }  

同样，我写了代码屏蔽的宏定义。使用的时候启用就可以了。

就可以自动升高版本到4.0上，当然你也可以修改代码来升高到其他版本的。

注意：这个代码很明显，需要放置在Editor文件夹下。

五、测试结果

我写了个几行的测试代码：

[csharp]view plaincopy 
    
print?
 using UnityEngine;  
 using System.Collections;  
   
 public class Tes : MonoBehaviour {  
   
     // Use this for initialization  
     void Start () {  
       
     }  
       
     // Update is called once per frame  
     void Update ()   
     {  
         if (Input.GetKey(KeyCode.A))  
         {  
             Debug.Log("this is debug log");  
             System.Console.WriteLine("this is system console write line");  
         }  
       
     }  
 }

警醒与鞭策

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Unity log 自定义输出

//#define USE_TESTCONSOLEusing System.Collections.Generic;using UnityEngine;namespace Consolation{ /// /// A console to display Unity's debug logs in-game. /// class
复制链接

扫一扫

专栏目录