IuvoUnity.Debug.IuvoDebug Class Reference

If you ever cant see the debug logs, make sure to call IuvoDebug.Initialize() in your main scene and that the correct Validation Levels are set. More...

Classes
class	IuvoDebugRunner

Public Types
enum	ValidationLevel { Debug , Warning , Error }
enum	LogDestination { PersistentFile , EditorFile , CustomFile }

Static Public Member Functions
static void	EnableValidationLevel (ValidationLevel level, bool enable)
static void	Initialize ()
static void	SetLogFilePath (string path)
static void	DebugTransform (Transform toDebug, [CallerMemberName] string memberName="", [CallerFilePath] string filePath="", [CallerLineNumber] int lineNumber=0)
static void	DebugPosition (Vector3 position, [CallerMemberName] string memberName="", [CallerFilePath] string filePath="", [CallerLineNumber] int lineNumber=0)
static void	DebugRotation (Quaternion rotation, [CallerMemberName] string memberName="", [CallerFilePath] string filePath="", [CallerLineNumber] int lineNumber=0)
static void	DebugEulerAngles (Vector3 eulerAngles, [CallerMemberName] string memberName="", [CallerFilePath] string filePath="", [CallerLineNumber] int lineNumber=0)
static void	DebugScale (Vector3 scale, [CallerMemberName] string memberName="", [CallerFilePath] string filePath="", [CallerLineNumber] int lineNumber=0)
static void	DebugLossyScale (Vector3 lossyScale, [CallerMemberName] string memberName="", [CallerFilePath] string filePath="", [CallerLineNumber] int lineNumber=0)
static bool	RaycastDebug (Vector3 origin, Vector3 direction, out RaycastHit hit, float distance=Mathf.Infinity, int layerMask=Physics.DefaultRaycastLayers, Color? debugColor=null, [CallerMemberName] string memberName="", [CallerFilePath] string filePath="", [CallerLineNumber] int lineNumber=0)
static void	DebugLogIuvoVersion ([CallerMemberName] string memberName="", [CallerFilePath] string filePath="", [CallerLineNumber] int lineNumber=0)
static void	DebugIuvoGame (IuvoGame game, [CallerMemberName] string memberName="", [CallerFilePath] string filePath="", [CallerLineNumber] int lineNumber=0)
static void	DebugLog (string message, bool richTxtMsg=true, [CallerMemberName] string memberName="", [CallerFilePath] string filePath="", [CallerLineNumber] int lineNumber=0)
static void	DebugLogWarning (string message, bool richTxtMsg=true, [CallerMemberName] string memberName="", [CallerFilePath] string filePath="", [CallerLineNumber] int lineNumber=0)
static void	DebugLogError (string message, bool richTxtMsg=false, [CallerMemberName] string memberName="", [CallerFilePath] string filePath="", [CallerLineNumber] int lineNumber=0)

Static Public Attributes
static HashSet< ValidationLevel >	EnabledLevels
static HashSet< LogDestination >	EnabledDestinations

Static Private Member Functions
static void	EnqueueLog (string message)
static System.Collections.IEnumerator	FlushPersistentLogQueueRoutine ()
static System.Collections.IEnumerator	FlushEditorLogQueueRoutine ()
static System.Collections.IEnumerator	FlushCustomLogQueueRoutine ()
static void	FinalFlushOnQuitPersistentLog ()
static void	FinalFlushOnQuitEditorLog ()
static void	FinalFlushOnQuitCustomLog ()
static string	FormatMessage (string level, string message, string memberName, string filePath, int lineNumber, out string richTextMessage, bool richTxtMsg)

Static Private Attributes
static string	persistentLogFilePath = Path.Combine(Application.persistentDataPath, "IuvoDebugLog_Persistent.txt")
static string	editorLogFilePath = Path.Combine(Application.dataPath, "IuvoDebugLog_Editor.txt")
static string	customLogFilePath = ""
static readonly Queue< string >	persistentLogQueue = new Queue<string>()
static readonly Queue< string >	editorLogQueue = new Queue<string>()
static readonly Queue< string >	customLogQueue = new Queue<string>()
static readonly object	fileLock = new object()
static bool	coroutineStarted = false

Detailed Description

If you ever cant see the debug logs, make sure to call IuvoDebug.Initialize() in your main scene and that the correct Validation Levels are set.

Member Enumeration Documentation

LogDestination

enum IuvoUnity.Debug.IuvoDebug.LogDestination

Enumerator
PersistentFile
EditorFile
CustomFile

            {
                PersistentFile,
                EditorFile,
                CustomFile
            }

ValidationLevel

enum IuvoUnity.Debug.IuvoDebug.ValidationLevel

Enumerator
Debug
Warning
Error

            {
                Debug,
                Warning,
                Error
            }

Member Function Documentation

DebugEulerAngles()

void IuvoUnity.Debug.IuvoDebug.DebugEulerAngles ( Vector3 eulerAngles, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNumber = 0 )

static

            {
                if (!EnabledLevels.Contains(ValidationLevel.Debug)) return;
                DebugLog($"Angles: {eulerAngles:F3}", false, memberName, filePath, lineNumber);
            }

References DebugLog(), and EnabledLevels.

Referenced by DebugTransform().

DebugIuvoGame()

void IuvoUnity.Debug.IuvoDebug.DebugIuvoGame ( IuvoGame game, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNumber = 0 )

static

will be removed once class fully implements

            {
                if (!EnabledLevels.Contains(ValidationLevel.Debug)) return;
                if (game == null)
                {
                    DebugLogWarning("IuvoGame instance is null", false, memberName, filePath, lineNumber);
                    return;
                }
                DebugLog($"Game: {game.gameName}", false, memberName, filePath, lineNumber);
                DebugLog($"Game Version: {game.gameVersion}", false, memberName, filePath, lineNumber);
                DebugLog($"Developer: {game.developerName}", false, memberName, filePath, lineNumber);
                DebugLog($"Publisher: {game.publisherName}", false, memberName, filePath, lineNumber);
                DebugLog($"Screen Resolution: {game.screenWidth}x{game.screenHeight}", false, memberName, filePath, lineNumber);
 
                {
                    if (game.systemsStateMachine != null)
                    {
                        if (game.systemsStateMachine.currentState != null)
                        {
                            DebugLog($"Systems State: {game.systemsStateMachine.currentState.stateName}", false, memberName, filePath, lineNumber);
                        }
                        else
                        {
                            DebugLogWarning("Systems StateMachine current state is null", false, memberName, filePath, lineNumber);
                        }
                    }
                    else
                    {
                        DebugLogWarning("Systems StateMachine is null", false, memberName, filePath, lineNumber);
                    }
                }
 
                // check for the game debug interface
                IGameDebug gameDebug = game as IGameDebug;
                if (gameDebug != null)
                {
                    gameDebug.LogGameInfo();
                    gameDebug.LogGameState();
                }
                else
                {
                    DebugLogWarning("IuvoGame does not implement IGameDebug interface", false, memberName, filePath, lineNumber);
                }
            }

References DebugLog(), DebugLogWarning(), EnabledLevels, IuvoUnity.Constants.IGameDebug.LogGameInfo(), IuvoUnity.Constants.IGameDebug.LogGameState(), and IuvoUnity.Constants.IuvoGame.systemsStateMachine.

Referenced by IuvoUnity.Debug.TestDebugButton.TestFunction().

DebugLog()

void IuvoUnity.Debug.IuvoDebug.DebugLog ( string message, bool richTxtMsg = true, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNumber = 0 )

static

            {
                if (!EnabledLevels.Contains(ValidationLevel.Debug)) return;
                string richFormatted;
                string formatted = FormatMessage("[DEBUG]", message, memberName, filePath, lineNumber, out richFormatted, richTxtMsg);
                UnityEngine.Debug.Log(richFormatted);
                EnqueueLog(formatted);
            }

References EnabledLevels, EnqueueLog(), and FormatMessage().

Referenced by IuvoUnity.StateMachines.CSM.ConditionalStateMachine.ChangeState(), DebugEulerAngles(), DebugIuvoGame(), DebugLogIuvoVersion(), DebugLossyScale(), DebugPosition(), DebugRotation(), DebugScale(), IuvoUnity.Configurations.HealthConfiguration.ImplementDefaultScalingAlgorithm(), IuvoUnity.Configurations.LevelConfiguration.ImplementDefaultScalingAlgorithm(), IuvoUnity.Extensions.GameObjectExtensions.LogComponents< T >(), IuvoUnity.Extensions.GameObjectExtensions.LogComponentsInChildren< T >(), IuvoUnity.Constants.IuvoGame.LogGameInfo(), IuvoUnity.Constants.IuvoGame.LogGameState(), IuvoUnity.BaseClasses.HealthComponent.OnDestroy(), IuvoUnity.Configurations.HealthConfiguration.OnDisable(), IuvoUnity.Configurations.LevelConfiguration.OnDisable(), IuvoUnity.RPG.Stat.OnDisable(), IuvoUnity.RPG.Stat.OnEnable(), IuvoUnity.Inputs.BaseInputActionLegacy.Perform(), IuvoUnity.Inputs.InputActionBase.Perform(), IuvoUnity.Configurations.BaseConfig< T >.PrintInfo(), IuvoUnity.Configurations.HealthConfiguration.PrintInfo(), IuvoUnity.Configurations.LevelConfiguration.PrintInfo(), IuvoUnity.Configurations.TimerConfiguration.PrintInfo(), IuvoUnity.Configurations.LevelConfiguration.Serialize(), IuvoUnity.Configurations.HealthConfiguration.SetLevelScalingCurve(), IuvoUnity.Configurations.LevelConfiguration.SetLevelScalingCurve(), TimerTestUI.Start(), and IuvoUnity.Debug.TestDebugButton.TestFunction().

DebugLogError()

void IuvoUnity.Debug.IuvoDebug.DebugLogError ( string message, bool richTxtMsg = false, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNumber = 0 )

static

            {
                if (!EnabledLevels.Contains(ValidationLevel.Error)) return;
                string richFormatted;
                string formatted = FormatMessage("[ERROR]", message, memberName, filePath, lineNumber, out richFormatted, richTxtMsg);
                UnityEngine.Debug.LogError(richFormatted);
                EnqueueLog(formatted);
            }

References EnabledLevels, EnqueueLog(), and FormatMessage().

Referenced by IuvoUnity.BaseClasses.LevelComponent.AddExperience(), IuvoUnity.BaseClasses.LevelComponent.AddLevels(), IuvoUnity.StateMachines.CSM.ConditionalStateMachine.Awake(), TimerTestUI.Awake(), IuvoUnity.Configurations.TimerConfiguration.Configure(), IuvoUnity.ProceduralGeneration.Room.CreateRoom(), IuvoUnity.ProceduralGeneration.ProceduralStripMesh.GenerateBetweenStrips(), IuvoUnity.Configurations.BaseConfig< T >.GetConfigSerializePath(), IuvoUnity.BaseClasses.LevelComponent.GetExperienceToNextLevel(), IuvoUnity.Configurations.HealthConfiguration.GetMaxHealthAtLevel(), IuvoUnity.ProceduralGeneration.Room.InitializeRoom(), IuvoUnity.BaseClasses.LevelComponent.LoseLevels(), IuvoUnity.BaseClasses.LevelComponent.OnDestroy(), IuvoUnity.Configurations.TimerConfiguration.Reconfigure(), IuvoUnity.ProceduralGeneration.Room.RemoveSharedWalls(), IuvoUnity.Extensions.GameObjectExtensions.ScaleNonStaticChildrenWithMesh(), IuvoUnity.Extensions.GameObjectExtensions.ScaleStaticChildrenWithMesh(), IuvoUnity.Configurations.LevelConfiguration.Serialize(), IuvoUnity.BaseClasses.LevelComponent.SerializeSelf(), IuvoUnity.Extensions.MeshRendererExtensions.SetCulling(), IuvoUnity.StateMachines.CSM.ConditionalStateMachine.SetForceDefaultState(), IuvoUnity.StateMachines.CSM.ConditionalStateMachine.SetForcePrevState(), IuvoUnity.Configurations.HealthConfiguration.SetLevelScalingCurve(), IuvoUnity.Configurations.LevelConfiguration.SetLevelScalingCurve(), IuvoUnity.BaseClasses.LevelComponent.Start(), IuvoUnity.ProceduralGeneration.Room.Start(), IuvoUnity.Debug.TestDebugButton.TestFunction(), IuvoUnity.BaseClasses.LevelComponent.TryGetLevelConfig(), IuvoUnity.BaseClasses.HealthComponent.UpdateMaxHealth(), and IuvoUnity.Extensions.MaterialExtensions.WithShader().

DebugLogIuvoVersion()

void IuvoUnity.Debug.IuvoDebug.DebugLogIuvoVersion ( [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNumber = 0 )

static

            {
                string version = IuvoCore.GetVersion();
                DebugLog($"IuvoUnity Version: {version}", false, memberName, filePath, lineNumber);
            }

References DebugLog(), and IuvoUnity.Core.IuvoCore.GetVersion().

Referenced by IuvoUnity.Debug.TestDebugButton.TestFunction().

DebugLogWarning()

void IuvoUnity.Debug.IuvoDebug.DebugLogWarning ( string message, bool richTxtMsg = true, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNumber = 0 )

static

            {
                if (!EnabledLevels.Contains(ValidationLevel.Warning)) return;
                string richFormatted;
                string formatted = FormatMessage("[WARNING]", message, memberName, filePath, lineNumber, out richFormatted, richTxtMsg);
                UnityEngine.Debug.LogWarning(richFormatted);
                EnqueueLog(formatted);
            }

References EnabledLevels, EnqueueLog(), and FormatMessage().

Referenced by IuvoUnity.BaseClasses.LevelComponent.AddExperience(), IuvoUnity.BaseClasses.LevelComponent.AddLevels(), IuvoUnity.BaseClasses.LevelComponent.AddLevelUpPoint(), IuvoUnity.DataStructs.Timer.AwaitFinish(), IuvoUnity.Inputs.InputActionBase.Awake(), IuvoUnity.StateMachines.CSM.ConditionalStateMachine.Awake(), IuvoUnity.StateMachines.CSM.ConditionalStateMachine.ChangeState(), IuvoUnity.DataStructs.ContextKeyGroups.CheckForDuplicateEnumNames(), IuvoUnity.Extensions.BoxColliderExtensions.CombineBoxCollidersToMesh(), IuvoUnity.BaseClasses.DamageComponent.DamageComponent(), IuvoUnity.BaseClasses.DamageComponent.DealDamage(), DebugIuvoGame(), IuvoUnity.DataStructs.DecrementTimer.DecrementTimer(), IuvoUnity.Configurations.LevelConfiguration.DeserializeLevelComponent(), IuvoUnity.ProceduralGeneration.ProceduralStripMesh.GenerateMesh(), IuvoUnity.Configurations.BaseConfig< T >.GetConfigSerializePath(), IuvoUnity.DataStructs.MultiTimer.GetDuration(), IuvoUnity.Configurations.LevelConfiguration.GetExpAtLevel(), IuvoUnity.StateMachines.CSM.ConditionalStateMachine.HandleContinue(), IuvoUnity.StateMachines.CSM.ConditionalStateMachine.HandleFallbackLogic(), IuvoUnity.BaseClasses.HealthComponent.Heal(), IuvoUnity.DataStructs.IncrementTimer.IncrementTimer(), IuvoUnity.DataStructs.Chain< T >.InsertAt(), IuvoUnity.BaseClasses.LevelComponent.LoseExperience(), IuvoUnity.BaseClasses.LevelComponent.LoseLevels(), IuvoUnity.DataStructs.MultiTimer.Remaining(), IuvoUnity.DataStructs.Context.Set< T >(), IuvoUnity.DataStructs.MultiTimer.SetDuration(), IuvoUnity.RPG.Stat.SetStatName(), IuvoUnity.Extensions.BoxColliderExtensions.SnapTo(), IuvoUnity.BaseClasses.LevelComponent.SpendLevelUpPoint(), IuvoUnity.BaseClasses.HealthComponent.Start(), IuvoUnity.StateMachines.CSM.ConditionalStateMachineAnalyzer.Start(), IuvoUnity.BaseClasses.HealthComponent.TakeDamage(), IuvoUnity.Debug.TestDebugButton.TestFunction(), IuvoUnity.StateMachines.CSM.ConditionalStateMachine.TryChangeState(), IuvoUnity.DataStructs.Chain< T >.ValidateLinks(), IuvoUnity.Extensions.MaterialExtensions.WithBuffer(), IuvoUnity.Extensions.MaterialExtensions.WithMainColor(), IuvoUnity.Extensions.MaterialExtensions.WithMainTexture(), IuvoUnity.Extensions.MaterialExtensions.WithRenderingMode(), IuvoUnity.Extensions.MaterialExtensions.WithShader(), IuvoUnity.Extensions.MaterialExtensions.WithShader(), IuvoUnity.Extensions.MaterialExtensions.WithShader(), and IuvoUnity.Extensions.MaterialExtensions.WithTextureArray().

DebugLossyScale()

void IuvoUnity.Debug.IuvoDebug.DebugLossyScale ( Vector3 lossyScale, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNumber = 0 )

static

            {
                if (!EnabledLevels.Contains(ValidationLevel.Debug)) return;
                DebugLog($"Lossy Scale: {lossyScale:F3}", false, memberName, filePath, lineNumber);
            }

References DebugLog(), and EnabledLevels.

Referenced by DebugTransform().

DebugPosition()

void IuvoUnity.Debug.IuvoDebug.DebugPosition ( Vector3 position, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNumber = 0 )

static

            {
                if (!EnabledLevels.Contains(ValidationLevel.Debug)) return;
                DebugLog($"Position: {position:F3}", false, memberName, filePath, lineNumber);
            }

References DebugLog(), and EnabledLevels.

Referenced by DebugTransform().

DebugRotation()

void IuvoUnity.Debug.IuvoDebug.DebugRotation ( Quaternion rotation, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNumber = 0 )

static

            {
                if (!EnabledLevels.Contains(ValidationLevel.Debug)) return;
                DebugLog($"Quaternion: {rotation.x:F3}, {rotation.y:F3}, {rotation.z:F3}, {rotation.w:F3}", false, memberName, filePath, lineNumber);
            }

References DebugLog(), and EnabledLevels.

Referenced by DebugTransform().

DebugScale()

void IuvoUnity.Debug.IuvoDebug.DebugScale ( Vector3 scale, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNumber = 0 )

static

            {
                if (!EnabledLevels.Contains(ValidationLevel.Debug)) return;
                DebugLog($"Scale: {scale:F3}", false, memberName, filePath, lineNumber);
            }

References DebugLog(), and EnabledLevels.

Referenced by DebugTransform().

DebugTransform()

void IuvoUnity.Debug.IuvoDebug.DebugTransform ( Transform toDebug, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNumber = 0 )

static

            {
                if (!EnabledLevels.Contains(ValidationLevel.Debug)) return;
 
                DebugPosition(toDebug.position, memberName, filePath, lineNumber);
                DebugRotation(toDebug.rotation, memberName, filePath, lineNumber);
                DebugEulerAngles(toDebug.eulerAngles, memberName, filePath, lineNumber);
                DebugScale(toDebug.localScale, memberName, filePath, lineNumber);
                DebugLossyScale(toDebug.lossyScale, memberName, filePath, lineNumber);
            }

References DebugEulerAngles(), DebugLossyScale(), DebugPosition(), DebugRotation(), DebugScale(), and EnabledLevels.

EnableValidationLevel()

void IuvoUnity.Debug.IuvoDebug.EnableValidationLevel ( ValidationLevel level, bool enable )

static

            {
                if (enable) EnabledLevels.Add(level);
                else EnabledLevels.Remove(level);
            }

References EnabledLevels.

EnqueueLog()

void IuvoUnity.Debug.IuvoDebug.EnqueueLog ( string message )

staticprivate

            {
                lock (fileLock)
                {
                    if (EnabledDestinations.Contains(LogDestination.CustomFile) && !string.IsNullOrEmpty(customLogFilePath))
                    {
                        customLogQueue.Enqueue(message);
                    }
 
                    if (EnabledDestinations.Contains(LogDestination.PersistentFile))
                    {
                        persistentLogQueue.Enqueue(message);
                    }
 
                    if (EnabledDestinations.Contains(LogDestination.EditorFile))
                    {
                        editorLogQueue.Enqueue(message);
                    }
                }
            }

References customLogFilePath, customLogQueue, editorLogQueue, EnabledDestinations, fileLock, and persistentLogQueue.

Referenced by DebugLog(), DebugLogError(), and DebugLogWarning().

FinalFlushOnQuitCustomLog()

void IuvoUnity.Debug.IuvoDebug.FinalFlushOnQuitCustomLog ( )

staticprivate

            {
                lock (fileLock)
                {
                    if (editorLogQueue.Count > 0)
                    {
                        try
                        {
                            Directory.CreateDirectory(Path.GetDirectoryName(customLogFilePath));
                            File.AppendAllLines(customLogFilePath, customLogQueue);
                            customLogQueue.Clear();
                        }
                        catch (Exception ex)
                        {
                            UnityEngine.Debug.LogError($"[IuvoDebug] Final flush failed: {ex}");
                        }
                    }
                }
            }

References customLogFilePath, customLogQueue, editorLogQueue, and fileLock.

Referenced by Initialize().

FinalFlushOnQuitEditorLog()

void IuvoUnity.Debug.IuvoDebug.FinalFlushOnQuitEditorLog ( )

staticprivate

            {
                lock (fileLock)
                {
                    if (editorLogQueue.Count > 0)
                    {
                        try
                        {
                            Directory.CreateDirectory(Path.GetDirectoryName(editorLogFilePath));
                            File.AppendAllLines(editorLogFilePath, editorLogQueue);
                            editorLogQueue.Clear();
                        }
                        catch (Exception ex)
                        {
                            UnityEngine.Debug.LogError($"[IuvoDebug] Final flush failed: {ex}");
                        }
                    }
                }
            }

References editorLogFilePath, editorLogQueue, and fileLock.

Referenced by Initialize().

FinalFlushOnQuitPersistentLog()

void IuvoUnity.Debug.IuvoDebug.FinalFlushOnQuitPersistentLog ( )

staticprivate

            {
                lock (fileLock)
                {
                    if (persistentLogQueue.Count > 0)
                    {
                        try
                        {
                            Directory.CreateDirectory(Path.GetDirectoryName(persistentLogFilePath));
                            File.AppendAllLines(persistentLogFilePath, persistentLogQueue);
                            persistentLogQueue.Clear();
                        }
                        catch (Exception ex)
                        {
                            UnityEngine.Debug.LogError($"[IuvoDebug] Final flush failed: {ex}");
                        }
                    }
                }
            }

References fileLock, persistentLogFilePath, and persistentLogQueue.

Referenced by Initialize().

FlushCustomLogQueueRoutine()

System.Collections.IEnumerator IuvoUnity.Debug.IuvoDebug.FlushCustomLogQueueRoutine ( )

staticprivate

            {
                while (true)
                {
                    lock (fileLock)
                    {
                        if (editorLogQueue.Count > 0)
                        {
                            try
                            {
                                Directory.CreateDirectory(Path.GetDirectoryName(customLogFilePath));
                                File.AppendAllLines(customLogFilePath, customLogQueue);
                                customLogQueue.Clear(); // only clear on success
                            }
                            catch (Exception ex)
                            {
                                UnityEngine.Debug.LogError($"[IuvoDebug] Failed to write log to file: {ex}");
                            }
                        }
                    }
                    yield return new WaitForSecondsRealtime(1f); // batch write every 1 sec
                }
            }

References customLogFilePath, customLogQueue, editorLogQueue, and fileLock.

Referenced by Initialize().

FlushEditorLogQueueRoutine()

System.Collections.IEnumerator IuvoUnity.Debug.IuvoDebug.FlushEditorLogQueueRoutine ( )

staticprivate

            {
                while (true)
                {
                    lock (fileLock)
                    {
                        if (editorLogQueue.Count > 0)
                        {
                            try
                            {
                                Directory.CreateDirectory(Path.GetDirectoryName(editorLogFilePath));
                                File.AppendAllLines(editorLogFilePath, editorLogQueue);
                                editorLogQueue.Clear(); // only clear on success
                            }
                            catch (Exception ex)
                            {
                                UnityEngine.Debug.LogError($"[IuvoDebug] Failed to write log to file: {ex}");
                            }
                        }
                    }
                    yield return new WaitForSecondsRealtime(1f); // batch write every 1 sec
                }
            }

References editorLogFilePath, editorLogQueue, and fileLock.

Referenced by Initialize().

FlushPersistentLogQueueRoutine()

System.Collections.IEnumerator IuvoUnity.Debug.IuvoDebug.FlushPersistentLogQueueRoutine ( )

staticprivate

            {
                while (true)
                {
                    lock (fileLock)
                    {
                        if (persistentLogQueue.Count > 0)
                        {
                            try
                            {
                                Directory.CreateDirectory(Path.GetDirectoryName(persistentLogFilePath));
                                File.AppendAllLines(persistentLogFilePath, persistentLogQueue);
                                persistentLogQueue.Clear(); // only clear on success
                            }
                            catch (Exception ex)
                            {
                                UnityEngine.Debug.LogError($"[IuvoDebug] Failed to write log to file: {ex}");
                            }
                        }
                    }
                    yield return new WaitForSecondsRealtime(1f); // batch write every 1 sec
                }
            }

References fileLock, persistentLogFilePath, and persistentLogQueue.

Referenced by Initialize().

FormatMessage()

string IuvoUnity.Debug.IuvoDebug.FormatMessage ( string level, string message, string memberName, string filePath, int lineNumber, out string richTextMessage, bool richTxtMsg )

staticprivate

            {
                string fileName = Path.GetFileName(filePath);
 
                string color = level == "[ERROR]" ? "orange" :
                               level == "[WARNING]" ? "yellow" :
                               "green";
 
                string richLevel = $"<color={color}>{level}</color>";
 
 
 
                string richMessage = $"<color={color}>{message}</color>";
                if (level == "[WARNING]") richMessage = $"<color={color}><i>{message}</i></color>";
                else if (level == "[ERROR]") richMessage = $"<color={color}><b>{message}</b></color>";
 
                string location = $"[{memberName} in {fileName}:{lineNumber}]";
                string richLocation = $"[{memberName} in {fileName}:{lineNumber}]";
                if (level == "[ERROR]") richLocation = $"<b>[{memberName} in {fileName}:{lineNumber}]</b>";
 
                string val = $"{level} {message} {location}";
                richTextMessage = val;
                if (!richTxtMsg)
                {
                    richMessage = message;
                    richLocation = $"[{memberName} in {fileName}:{lineNumber}]";
                    richTextMessage = $"{level} {richMessage} {richLocation}";
                }
 
                string dateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                val = $"{dateTime} {val}";
                return val;
            }

Referenced by DebugLog(), DebugLogError(), and DebugLogWarning().

Initialize()

void IuvoUnity.Debug.IuvoDebug.Initialize ( )

static

            {
                if (!coroutineStarted)
                {
                    // Create a persistent runner for coroutines
                    var runnerObj = new GameObject("IuvoDebugRunner");
                    UnityEngine.Object.DontDestroyOnLoad(runnerObj);
                    var runner = runnerObj.AddComponent<IuvoDebugRunner>();
                    runner.StartCoroutine(FlushPersistentLogQueueRoutine());
                    runner.StartCoroutine(FlushEditorLogQueueRoutine());
                    runner.StartCoroutine(FlushCustomLogQueueRoutine());
 
                    // Ensure final flush on quit
                    Application.quitting += FinalFlushOnQuitPersistentLog;
                    Application.quitting += FinalFlushOnQuitEditorLog;
                    Application.quitting += FinalFlushOnQuitCustomLog;
 
                    coroutineStarted = true;
                }
            }

References coroutineStarted, FinalFlushOnQuitCustomLog(), FinalFlushOnQuitEditorLog(), FinalFlushOnQuitPersistentLog(), FlushCustomLogQueueRoutine(), FlushEditorLogQueueRoutine(), and FlushPersistentLogQueueRoutine().

Referenced by IuvoUnity.Debug.TestDebugButton.Awake().

RaycastDebug()

bool IuvoUnity.Debug.IuvoDebug.RaycastDebug ( Vector3 origin, Vector3 direction, out RaycastHit hit, float distance = Mathf::Infinity, int layerMask = Physics::DefaultRaycastLayers, Color? debugColor = null, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNumber = 0 )

static

            {
                if (!EnabledLevels.Contains(ValidationLevel.Debug))
                {
                    hit = new RaycastHit();
                    return false;
                }
 
                return PhysicsHelpers.RaycastDebug(origin, direction, out hit, distance, layerMask, debugColor);
            }

References EnabledLevels, and IuvoUnity.IuvoPhysics.PhysicsHelpers.RaycastDebug().

SetLogFilePath()

void IuvoUnity.Debug.IuvoDebug.SetLogFilePath ( string path )

static

            {
                lock (fileLock)
                {
                    customLogFilePath = string.IsNullOrEmpty(path) ? persistentLogFilePath : path;
                }
            }

References customLogFilePath, fileLock, and persistentLogFilePath.

Member Data Documentation

coroutineStarted

bool IuvoUnity.Debug.IuvoDebug.coroutineStarted = false

staticprivate

Referenced by Initialize().

customLogFilePath

string IuvoUnity.Debug.IuvoDebug.customLogFilePath = ""

staticprivate

Referenced by EnqueueLog(), FinalFlushOnQuitCustomLog(), FlushCustomLogQueueRoutine(), and SetLogFilePath().

customLogQueue

readonly Queue<string> IuvoUnity.Debug.IuvoDebug.customLogQueue = new Queue<string>()

staticprivate

Referenced by EnqueueLog(), FinalFlushOnQuitCustomLog(), and FlushCustomLogQueueRoutine().

editorLogFilePath

string IuvoUnity.Debug.IuvoDebug.editorLogFilePath = Path.Combine(Application.dataPath, "IuvoDebugLog_Editor.txt")

staticprivate

Referenced by FinalFlushOnQuitEditorLog(), and FlushEditorLogQueueRoutine().

editorLogQueue

readonly Queue<string> IuvoUnity.Debug.IuvoDebug.editorLogQueue = new Queue<string>()

staticprivate

Referenced by EnqueueLog(), FinalFlushOnQuitCustomLog(), FinalFlushOnQuitEditorLog(), FlushCustomLogQueueRoutine(), and FlushEditorLogQueueRoutine().

EnabledDestinations

HashSet<LogDestination> IuvoUnity.Debug.IuvoDebug.EnabledDestinations

static

Initial value:

                                          = new HashSet<LogDestination>
{
    LogDestination.PersistentFile,
    LogDestination.EditorFile,
    LogDestination.CustomFile
}

            {
                LogDestination.PersistentFile,
                LogDestination.EditorFile,
                LogDestination.CustomFile
            };

Referenced by EnqueueLog().

EnabledLevels

HashSet<ValidationLevel> IuvoUnity.Debug.IuvoDebug.EnabledLevels

static

Initial value:

                                    = new HashSet<ValidationLevel>
{
    ValidationLevel.Debug,
    ValidationLevel.Warning,
    ValidationLevel.Error
}

            {
                ValidationLevel.Debug,
                ValidationLevel.Warning,
                ValidationLevel.Error
            };

Referenced by DebugEulerAngles(), DebugIuvoGame(), DebugLog(), DebugLogError(), DebugLogWarning(), DebugLossyScale(), DebugPosition(), DebugRotation(), DebugScale(), DebugTransform(), EnableValidationLevel(), and RaycastDebug().

fileLock

readonly object IuvoUnity.Debug.IuvoDebug.fileLock = new object()

staticprivate

Referenced by EnqueueLog(), FinalFlushOnQuitCustomLog(), FinalFlushOnQuitEditorLog(), FinalFlushOnQuitPersistentLog(), FlushCustomLogQueueRoutine(), FlushEditorLogQueueRoutine(), FlushPersistentLogQueueRoutine(), and SetLogFilePath().

persistentLogFilePath

string IuvoUnity.Debug.IuvoDebug.persistentLogFilePath = Path.Combine(Application.persistentDataPath, "IuvoDebugLog_Persistent.txt")

staticprivate

Referenced by FinalFlushOnQuitPersistentLog(), FlushPersistentLogQueueRoutine(), and SetLogFilePath().

persistentLogQueue

readonly Queue<string> IuvoUnity.Debug.IuvoDebug.persistentLogQueue = new Queue<string>()

staticprivate

Referenced by EnqueueLog(), FinalFlushOnQuitPersistentLog(), and FlushPersistentLogQueueRoutine().

---

The documentation for this class was generated from the following file:

• D:/Unity/IuvoUnityCore/Assets/IuvoUnity/Runtime/Debug/IuvoDebug.cs